class.dc.xmlrpc.php @ 696:1a2b2b2d943b

Visit:

Revision 696:1a2b2b2d943b, 44.3 KB checked in by Franck <carnet.franck.paul@…>, 14 years ago (diff)
Typos (virgule surnuméraire en fin d'énumération de tableau)

Rev	Line
[0]	1	<?php
	2	# -- BEGIN LICENSE BLOCK ---------------------------------------
	3	#
	4	# This file is part of Dotclear 2.
	5	#
[270]	6	# Copyright (c) 2003-2011 Olivier Meunier & Association Dotclear
[0]	7	# Licensed under the GPL version 2.0 license.
	8	# See LICENSE file or
	9	# http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
	10	#
	11	# -- END LICENSE BLOCK -----------------------------------------
	12	if (!defined('DC_RC_PATH')) { return; }
	13
	14	class dcXmlRpc extends xmlrpcIntrospectionServer
	15	{
	16	public $core;
	17	private $blog_id;
	18	private $blog_loaded = false;
	19	private $debug = false;
	20	private $debug_file = '/tmp/dotclear-xmlrpc.log';
	21	private $trace_args = true;
	22	private $trace_response = true;
	23
	24	public function __construct($core,$blog_id)
	25	{
	26	parent::__construct();
	27
	28	$this->core =& $core;
	29	$this->blog_id = $blog_id;
	30
	31	# Blogger methods
	32	$this->addCallback('blogger.newPost',array($this,'blogger_newPost'),
	33	array('string','string','string','string','string','string','integer'),
	34	'New post');
	35
	36	$this->addCallback('blogger.editPost',array($this,'blogger_editPost'),
	37	array('boolean','string','string','string','string','string','integer'),
	38	'Edit a post');
	39
	40	$this->addCallback('blogger.getPost',array($this,'blogger_getPost'),
	41	array('struct','string','integer','string','string'),
	42	'Return a posts by ID');
	43
	44	$this->addCallback('blogger.deletePost',array($this,'blogger_deletePost'),
	45	array('string','string','string','string','string','integer'),
	46	'Delete a post');
	47
	48	$this->addCallback('blogger.getRecentPosts',array($this,'blogger_getRecentPosts'),
	49	array('array','string','string','string','string','integer'),
	50	'Return a list of recent posts');
	51
	52	$this->addCallback('blogger.getUsersBlogs',array($this,'blogger_getUserBlogs'),
	53	array('struct','string','string','string'),
	54	"Return user's blog");
	55
	56	$this->addCallback('blogger.getUserInfo',array($this,'blogger_getUserInfo'),
	57	array('struct','string','string','string'),
	58	'Return User Info');
	59
	60	# Metaweblog methods
	61	$this->addCallback('metaWeblog.newPost',array($this,'mw_newPost'),
	62	array('string','string','string','string','struct','boolean'),
	63	'Creates a new post, and optionnaly publishes it.');
	64
	65	$this->addCallback('metaWeblog.editPost',array($this,'mw_editPost'),
	66	array('boolean','string','string','string','struct','boolean'),
	67	'Updates information about an existing entry');
	68
	69	$this->addCallback('metaWeblog.getPost',array($this,'mw_getPost'),
	70	array('struct','string','string','string'),
	71	'Returns information about a specific post');
	72
	73	$this->addCallback('metaWeblog.getRecentPosts',array($this,'mw_getRecentPosts'),
	74	array('array','string','string','string','integer'),
	75	'List of most recent posts in the system');
	76
	77	$this->addCallback('metaWeblog.getCategories',array($this,'mw_getCategories'),
	78	array('array','string','string','string'),
	79	'List of all categories defined in the weblog');
	80
	81	$this->addCallback('metaWeblog.newMediaObject',array($this,'mw_newMediaObject'),
	82	array('struct','string','string','string','struct'),
	83	'Upload a file on the web server');
	84
	85	# MovableType methods
	86	$this->addCallback('mt.getRecentPostTitles',array($this,'mt_getRecentPostTitles'),
	87	array('array','string','string','string','integer'),
	88	'List of most recent posts in the system');
	89
	90	$this->addCallback('mt.getCategoryList',array($this,'mt_getCategoryList'),
	91	array('array','string','string','string'),
	92	'List of all categories defined in the weblog');
	93
	94	$this->addCallback('mt.getPostCategories',array($this,'mt_getPostCategories'),
	95	array('array','string','string','string'),
	96	'List of all categories to which the post is assigned');
	97
	98	$this->addCallback('mt.setPostCategories',array($this,'mt_setPostCategories'),
	99	array('boolean','string','string','string','array'),
	100	'Sets the categories for a post');
	101
	102	$this->addCallback('mt.publishPost',array($this,'mt_publishPost'),
	103	array('boolean','string','string','string'),
	104	'Retrieve pings list for a post');
	105
	106	$this->addCallback('mt.supportedMethods',array($this,'listMethods'),
	107	array(),'Retrieve information about the XML-RPC methods supported by the server.');
	108
	109	$this->addCallback('mt.supportedTextFilters',array($this,'mt_supportedTextFilters'),
	110	array(),'Retrieve information about supported text filters.');
	111
	112	# WordPress methods
	113	$this->addCallback('wp.getUsersBlogs',array($this,'wp_getUsersBlogs'),
	114	array('array','string','string'),
	115	'Retrieve the blogs of the user.');
	116
	117	$this->addCallback('wp.getPage',array($this,'wp_getPage'),
	118	array('struct','integer','integer','string','string'),
	119	'Get the page identified by the page ID.');
	120
	121	$this->addCallback('wp.getPages',array($this,'wp_getPages'),
	122	array('array','integer','string','string','integer'),
	123	'Get an array of all the pages on a blog.');
	124
	125	$this->addCallback('wp.newPage',array($this,'wp_newPage'),
	126	array('integer','integer','string','string','struct','boolean'),
	127	'Create a new page.');
	128
	129	$this->addCallback('wp.deletePage',array($this,'wp_deletePage'),
	130	array('boolean','integer','string','string','integer'),
	131	'Removes a page from the blog.');
	132
	133	$this->addCallback('wp.editPage',array($this,'wp_editPage'),
	134	array('boolean','integer','integer','string','string','struct','boolean'),
	135	'Make changes to a blog page.');
	136
	137	$this->addCallback('wp.getPageList',array($this,'wp_getPageList'),
	138	array('array','integer','string','string'),
	139	'Get an array of all the pages on a blog. Just the minimum details, lighter than wp.getPages.');
	140
	141	$this->addCallback('wp.getAuthors',array($this,'wp_getAuthors'),
	142	array('array','integer','string','string'),
	143	'Get an array of users for the blog.');
	144
	145	$this->addCallback('wp.getCategories',array($this,'wp_getCategories'),
	146	array('array','integer','string','string'),
	147	'Get an array of available categories on a blog.');
	148
	149	$this->addCallback('wp.getTags',array($this,'wp_getTags'),
	150	array('array','integer','string','string'),
	151	'Get list of all tags for the blog.');
	152
	153	$this->addCallback('wp.newCategory',array($this,'wp_newCategory'),
	154	array('integer','integer','string','string','struct'),
	155	'Create a new category.');
	156
	157	$this->addCallback('wp.deleteCategory',array($this,'wp_deleteCategory'),
	158	array('boolean','integer','string','string','integer'),
	159	'Delete a category with a given ID.');
	160
	161	$this->addCallback('wp.suggestCategories',array($this,'wp_suggestCategories'),
	162	array('array','integer','string','string','string','integer'),
	163	'Get an array of categories that start with a given string.');
	164
	165	$this->addCallback('wp.uploadFile',array($this,'wp_uploadFile'),
	166	array('struct','integer','string','string','struct'),
	167	'Upload a file');
	168
	169	$this->addCallback('wp.getPostStatusList',array($this,'wp_getPostStatusList'),
	170	array('array','integer','string','string'),
	171	'Retrieve all of the post statuses.');
	172
	173	$this->addCallback('wp.getPageStatusList',array($this,'wp_getPageStatusList'),
	174	array('array','integer','string','string'),
	175	'Retrieve all of the pages statuses.');
	176
	177	$this->addCallback('wp.getPageTemplates',array($this,'wp_getPageTemplates'),
	178	array('struct','integer','string','string'),
	179	'Retrieve page templates.');
	180
	181	$this->addCallback('wp.getOptions',array($this,'wp_getOptions'),
	182	array('struct','integer','string','string','array'),
	183	'Retrieve blog options');
	184
	185	$this->addCallback('wp.setOptions',array($this,'wp_setOptions'),
	186	array('struct','integer','string','string','struct'),
	187	'Update blog options');
	188
	189	$this->addCallback('wp.getComment',array($this,'wp_getComment'),
	190	array('struct','integer','string','string','integer'),
	191	"Gets a comment, given it's comment ID.");
	192
	193	$this->addCallback('wp.getCommentCount',array($this,'wp_getCommentCount'),
	194	array('array','integer','string','string','integer'),
	195	'Retrieve comment count.');
	196
	197	$this->addCallback('wp.getComments',array($this,'wp_getComments'),
	198	array('array','integer','string','string','struct'),
	199	'Gets a set of comments for a given post.');
	200
	201	$this->addCallback('wp.deleteComment',array($this,'wp_deleteComment'),
	202	array('boolean','integer','string','string','integer'),
	203	'Delete a comment with given ID.');
	204
	205	$this->addCallback('wp.editComment',array($this,'wp_editComment'),
	206	array('boolean','integer','string','string','integer','struct'),
	207	'Edit a comment with given ID.');
	208
	209	$this->addCallback('wp.newComment',array($this,'wp_newComment'),
	210	array('integer','integer','string','string','integer','struct'),
	211	'Create a new comment for a given post ID.');
	212
	213	$this->addCallback('wp.getCommentStatusList',array($this,'wp_getCommentStatusList'),
	214	array('array','integer','string','string'),
	215	'Retrieve all of the comment statuses.');
	216	}
	217
	218	public function serve($data=false,$encoding='UTF-8')
	219	{
	220	parent::serve(false,$encoding);
	221	}
	222
	223	public function call($methodname,$args)
	224	{
	225	try {
	226	$rsp = @parent::call($methodname,$args);
	227	$this->debugTrace($methodname,$args,$rsp);
	228	return $rsp;
	229	} catch (Exception $e) {
	230	$this->debugTrace($methodname,$args,array($e->getMessage(),$e->getCode()));
	231	throw $e;
	232	}
	233	}
	234
	235	private function debugTrace($methodname,$args,$rsp)
	236	{
	237	if (!$this->debug) {
	238	return;
	239	}
	240
	241	if (($fp = @fopen($this->debug_file,'a')) !== false)
	242	{
	243	fwrite($fp,'['.date('r').']'.' '.$methodname);
	244
	245	if ($this->trace_args) {
	246	fwrite($fp,"\n- args ---\n".var_export($args,1));
	247	}
	248
	249	if ($this->trace_response) {
	250	fwrite($fp,"\n- response ---\n".var_export($rsp,1));
	251	}
	252	fwrite($fp,"\n");
	253	fclose($fp);
	254	}
	255	}
	256
	257	/* Internal methods
	258	--------------------------------------------------- */
	259	private function setUser($user_id,$pwd)
	260	{
	261	if ($this->core->auth->userID() == $user_id) {
	262	return true;
	263	}
	264
	265	if ($this->core->auth->checkUser($user_id,$pwd) !== true) {
	266	throw new Exception('Login error');
	267	}
	268
	269	return true;
	270	}
	271
	272	private function setBlog()
	273	{
	274	if (!$this->blog_id) {
	275	throw new Exception('No blog ID given.');
	276	}
	277
	278	if ($this->blog_loaded) {
	279	return true;
	280	}
	281
	282	$this->core->setBlog($this->blog_id);
	283	$this->blog_loaded = true;
	284
	285	if (!$this->core->blog->id) {
	286	$this->core->blog = null;
	287	throw new Exception('Blog does not exist.');
	288	}
	289
	290	if (!$this->core->blog->settings->system->enable_xmlrpc \|\|
	291	!$this->core->auth->check('usage,contentadmin',$this->core->blog->id)) {
	292	$this->core->blog = null;
	293	throw new Exception('Not enough permissions on this blog.');
	294	}
	295
	296	foreach ($this->core->plugins->getModules() as $id => $m) {
	297	$this->core->plugins->loadNsFile($id,'xmlrpc');
	298	}
	299
	300	return true;
	301	}
	302
	303	private function getPostRS($post_id,$user,$pwd,$post_type='post')
	304	{
	305	$this->setUser($user,$pwd);
	306	$this->setBlog();
	307	$rs = $this->core->blog->getPosts(array(
	308	'post_id' => (integer) $post_id,
	309	'post_type' => $post_type
	310	));
	311
	312	if ($rs->isEmpty()) {
	313	throw new Exception('This entry does not exist');
	314	}
	315
	316	return $rs;
	317	}
	318
	319	private function getCatID($cat_url)
	320	{
	321	$rs = $this->core->blog->getCategories(array('cat_url' => $cat_url));
	322
	323	return $rs->isEmpty() ? null : $rs->cat_id;
	324	}
	325
	326	/* Generic methods
	327	--------------------------------------------------- */
	328	private function newPost($blog_id,$user,$pwd,$content,$struct=array(),$publish=true)
	329	{
	330	$this->setUser($user,$pwd);
	331	$this->setBlog();
	332
	333	$title = !empty($struct['title']) ? $struct['title'] : '';
	334	$excerpt = !empty($struct['mt_excerpt']) ? $struct['mt_excerpt'] : '';
	335	$description = !empty($struct['description']) ? $struct['description'] : null;
	336	$dateCreated = !empty($struct['dateCreated']) ? $struct['dateCreated'] : null;
	337	$open_comment = isset($struct['mt_allow_comments']) ? $struct['mt_allow_comments'] : 1;
	338	$open_tb = isset($struct['mt_allow_pings']) ? $struct['mt_allow_pings'] : 1;
	339
	340	if ($description !== null) {
	341	$content = $description;
	342	}
	343
	344	if (!$title) {
	345	$title = text::cutString(html::clean($content),25).'...';
	346	}
	347
	348	$excerpt_xhtml = $this->core->callFormater('xhtml',$excerpt);
	349	$content_xhtml = $this->core->callFormater('xhtml',$content);
	350
	351	if (empty($content)) {
	352	throw new Exception('Cannot create an empty entry');
	353	}
	354
	355	$cur = $this->core->con->openCursor($this->core->prefix.'post');
	356
	357	$cur->user_id = $this->core->auth->userID();
	358	$cur->post_lang = $this->core->auth->getInfo('user_lang');
	359	$cur->post_title = trim($title);
	360	$cur->post_content = $content;
	361	$cur->post_excerpt = $excerpt;
	362	$cur->post_content_xhtml = $content_xhtml;
	363	$cur->post_excerpt_xhtml = $excerpt_xhtml;
	364	$cur->post_open_comment = (integer) ($open_comment == 1);
	365	$cur->post_open_tb = (integer) ($open_tb == 1);
	366	$cur->post_status = (integer) $publish;
	367	$cur->post_format = 'xhtml';
	368
	369	if ($dateCreated) {
	370	if ($dateCreated instanceof xmlrpcDate) {
	371	$cur->post_dt = date('Y-m-d H:i:00',$dateCreated->getTimestamp());
	372	} elseif (is_string($dateCreated) && @strtotime($dateCreated)) {
	373	$cur->post_dt = date('Y-m-d H:i:00',strtotime($dateCreated));
	374	}
	375	}
	376
	377	# Categories in an array
	378	if (isset($struct['categories']) && is_array($struct['categories']))
	379	{
	380	$categories = $struct['categories'];
	381	$cat_id = !empty($categories[0]) ? $categories[0] : null;
	382
	383	$cur->cat_id = $this->getCatID($cat_id);
	384	}
	385
	386	if (isset($struct['wp_slug'])) {
	387	$cur->post_url = $struct['wp_slug'];
	388	}
	389
	390	if (isset($struct['wp_password'])) {
	391	$cur->post_password = $struct['wp_password'];
	392	}
	393
	394	$cur->post_type = 'post';
	395	if (!empty($struct['post_type'])) {
	396	$cur->post_type = $struct['post_type'];
	397	}
	398
	399	if ($cur->post_type == 'post')
	400	{
	401	# --BEHAVIOR-- xmlrpcBeforeNewPost
	402	$this->core->callBehavior('xmlrpcBeforeNewPost',$this,$cur,$content,$struct,$publish);
	403
	404	$post_id = $this->core->blog->addPost($cur);
	405
	406	# --BEHAVIOR-- xmlrpcAfterNewPost
	407	$this->core->callBehavior('xmlrpcAfterNewPost',$this,$post_id,$cur,$content,$struct,$publish);
	408	}
	409	elseif ($cur->post_type == 'page')
	410	{
	411	if (isset($struct['wp_page_order'])) {
	412	$cur->post_position = (integer) $struct['wp_page_order'];
	413	}
	414
	415	$this->core->blog->settings->system->post_url_format = '{t}';
	416
	417	$post_id = $this->core->blog->addPost($cur);
	418	}
	419	else
	420	{
	421	throw new Exception('Invalid post type',401);
	422	}
	423
	424	return (string) $post_id;
	425	}
	426
	427	private function editPost($post_id,$user,$pwd,$content,$struct=array(),$publish=true)
	428	{
	429	$post_id = (integer) $post_id;
	430
	431	$post_type = 'post';
	432	if (!empty($struct['post_type'])) {
	433	$post_type = $struct['post_type'];
	434	}
	435
	436	$post = $this->getPostRS($post_id,$user,$pwd,$post_type);
	437
	438	$title = (!empty($struct['title'])) ? $struct['title'] : '';
	439	$excerpt = (!empty($struct['mt_excerpt'])) ? $struct['mt_excerpt'] : '';
	440	$description = (!empty($struct['description'])) ? $struct['description'] : null;
	441	$dateCreated = !empty($struct['dateCreated']) ? $struct['dateCreated'] : null;
	442	$open_comment = (isset($struct['mt_allow_comments'])) ? $struct['mt_allow_comments'] : 1;
	443	$open_tb = (isset($struct['mt_allow_pings'])) ? $struct['mt_allow_pings'] : 1;
	444
	445	if ($description !== null) {
	446	$content = $description;
	447	}
	448
	449	if (!$title) {
	450	$title = text::cutString(html::clean($content),25).'...';
	451	}
	452
	453	$excerpt_xhtml = $this->core->callFormater('xhtml',$excerpt);
	454	$content_xhtml = $this->core->callFormater('xhtml',$content);
	455
	456	if (empty($content)) {
	457	throw new Exception('Cannot create an empty entry');
	458	}
	459
	460	$cur = $this->core->con->openCursor($this->core->prefix.'post');
	461
	462	$cur->post_type = $post_type;
	463	$cur->post_title = trim($title);
	464	$cur->post_content = $content;
	465	$cur->post_excerpt = $excerpt;
	466	$cur->post_content_xhtml = $content_xhtml;
	467	$cur->post_excerpt_xhtml = $excerpt_xhtml;
	468	$cur->post_open_comment = (integer) ($open_comment == 1);
	469	$cur->post_open_tb = (integer) ($open_tb == 1);
	470	$cur->post_status = (integer) $publish;
	471	$cur->post_format = 'xhtml';
	472	$cur->post_url = $post->post_url;
	473
	474
	475	if ($dateCreated) {
	476	if ($dateCreated instanceof xmlrpcDate) {
	477	$cur->post_dt = date('Y-m-d H:i:00',$dateCreated->getTimestamp());
	478	} elseif (is_string($dateCreated) && @strtotime($dateCreated)) {
	479	$cur->post_dt = date('Y-m-d H:i:00',strtotime($dateCreated));
	480	}
	481	} else {
	482	$cur->post_dt = $post->post_dt;
	483	}
	484
	485	# Categories in an array
	486	if (isset($struct['categories']) && is_array($struct['categories']))
	487	{
	488	$categories = $struct['categories'];
	489	$cat_id = !empty($categories[0]) ? $categories[0] : null;
	490
	491	$cur->cat_id = $this->getCatID($cat_id);
	492	}
	493
	494	if (isset($struct['wp_slug'])) {
	495	$cur->post_url = $struct['wp_slug'];
	496	}
	497
	498	if (isset($struct['wp_password'])) {
	499	$cur->post_password = $struct['wp_password'];
	500	}
	501
	502	if ($cur->post_type == 'post')
	503	{
	504	# --BEHAVIOR-- xmlrpcBeforeEditPost
	505	$this->core->callBehavior('xmlrpcBeforeEditPost',$this,$post_id,$cur,$content,$struct,$publish);
	506
	507	$this->core->blog->updPost($post_id,$cur);
	508
	509	# --BEHAVIOR-- xmlrpcAfterEditPost
	510	$this->core->callBehavior('xmlrpcAfterEditPost',$this,$post_id,$cur,$content,$struct,$publish);
	511	}
	512	elseif ($cur->post_type == 'page')
	513	{
	514	if (isset($struct['wp_page_order'])) {
	515	$cur->post_position = (integer) $struct['wp_page_order'];
	516	}
	517
	518	$this->core->blog->settings->system->post_url_format = '{t}';
	519
	520	$this->core->blog->updPost($post_id,$cur);
	521	}
	522	else
	523	{
	524	throw new Exception('Invalid post type',401);
	525	}
	526
	527	return true;
	528	}
	529
	530	private function getPost($post_id,$user,$pwd,$type='mw')
	531	{
	532	$post_id = (integer) $post_id;
	533
	534	$post = $this->getPostRS($post_id,$user,$pwd);
	535
	536	$res = new ArrayObject();
	537
	538	$res['dateCreated'] = new xmlrpcDate($post->getTS());
	539	$res['userid'] = $post->user_id;
	540	$res['postid'] = $post->post_id;
	541
	542	if ($post->cat_id) {
	543	$res['categories'] = array($post->cat_url);
	544	}
	545
	546	if ($type == 'blogger') {
	547	$res['content'] = $post->post_content_xhtml;
	548	}
	549
	550	if ($type == 'mt' \|\| $type == 'mw') {
	551	$res['title'] = $post->post_title;
	552	}
	553
	554	if ($type == 'mw') {
	555	$res['description'] = $post->post_content_xhtml;
	556	$res['link'] = $res['permaLink'] = $post->getURL();
	557	$res['mt_excerpt'] = $post->post_excerpt_xhtml;
	558	$res['mt_text_more'] = '';
	559	$res['mt_allow_comments'] = (integer) $post->post_open_comment;
	560	$res['mt_allow_pings'] = (integer) $post->post_open_tb;
	561	$res['mt_convert_breaks'] = '';
	562	$res['mt_keywords'] = '';
	563	}
	564
	565	# --BEHAVIOR-- xmlrpcGetPostInfo
	566	$this->core->callBehavior('xmlrpcGetPostInfo',$this,$type,array(&$res));
	567
	568	return $res;
	569	}
	570
	571	private function deletePost($post_id,$user,$pwd)
	572	{
	573	$post_id = (integer) $post_id;
	574
	575	$this->getPostRS($post_id,$user,$pwd);
	576	$this->core->blog->delPost($post_id);
	577
	578	return true;
	579	}
	580
	581	private function getRecentPosts($blog_id,$user,$pwd,$nb_post,$type='mw')
	582	{
	583	$this->setUser($user,$pwd);
	584	$this->setBlog();
	585
	586	$nb_post = (integer) $nb_post;
	587
	588	if ($nb_post > 50) {
	589	throw new Exception('Cannot retrieve more than 50 entries');
	590	}
	591
	592	$params = array();
	593	$params['limit'] = $nb_post;
	594
	595	$posts = $this->core->blog->getPosts($params);
	596
	597	$res = array();
	598	while ($posts->fetch())
	599	{
	600	$tres = array();
	601
	602	$tres['dateCreated'] = new xmlrpcDate($posts->getTS());
	603	$tres['userid'] = $posts->user_id;
	604	$tres['postid'] = $posts->post_id;
	605
	606	if ($posts->cat_id) {
	607	$tres['categories'] = array($posts->cat_url);
	608	}
	609
	610	if ($type == 'blogger') {
	611	$tres['content'] = $posts->post_content_xhtml;
	612	}
	613
	614	if ($type == 'mt' \|\| $type == 'mw') {
	615	$tres['title'] = $posts->post_title;
	616	}
	617
	618	if ($type == 'mw') {
	619	$tres['description'] = $posts->post_content_xhtml;
	620	$tres['link'] = $tres['permaLink'] = $posts->getURL();
	621	$tres['mt_excerpt'] = $posts->post_excerpt_xhtml;
	622	$tres['mt_text_more'] = '';
	623	$tres['mt_allow_comments'] = (integer) $posts->post_open_comment;
	624	$tres['mt_allow_pings'] = (integer) $posts->post_open_tb;
	625	$tres['mt_convert_breaks'] = '';
	626	$tres['mt_keywords'] = '';
	627	}
	628
	629	# --BEHAVIOR-- xmlrpcGetPostInfo
	630	$this->core->callBehavior('xmlrpcGetPostInfo',$this,$type,array(&$tres));
	631
	632	$res[] = $tres;
	633	}
	634
	635	return $res;
	636	}
	637
	638	private function getUserBlogs($user,$pwd)
	639	{
	640	$this->setUser($user,$pwd);
	641	$this->setBlog();
	642
	643	return array(array(
	644	'url' => $this->core->blog->url,
	645	'blogid' => '1',
	646	'blogName' => $this->core->blog->name
	647	));
	648	}
	649
	650	private function getUserInfo($user,$pwd)
	651	{
	652	$this->setUser($user,$pwd);
	653
	654	return array(
	655	'userid' => $this->core->auth->userID(),
	656	'firstname' => $this->core->auth->getInfo('user_firstname'),
	657	'lastname' => $this->core->auth->getInfo('user_name'),
	658	'nickname' => $this->core->auth->getInfo('user_displayname'),
	659	'email' => $this->core->auth->getInfo('user_email'),
	660	'url' => $this->core->auth->getInfo('user_url')
	661	);
	662	}
	663
	664	private function getCategories($blog_id,$user,$pwd)
	665	{
	666	$this->setUser($user,$pwd);
	667	$this->setBlog();
	668	$rs = $this->core->blog->getCategories();
	669
	670	$res = array();
	671
	672	$l = $rs->level;
	673	$stack = array('',$rs->cat_url);
	674
	675	while ($rs->fetch())
	676	{
	677	$d = $rs->level - $l;
	678	if ($d == 0) {
	679	array_pop($stack);
	680	$parent = end($stack);
	681	} elseif ($d > 0) {
	682	$parent = end($stack);
	683	} elseif ($d < 0) {
	684	$D = abs($d);
	685	for ($i=0; $i<=$D; $i++) {
	686	array_pop($stack);
	687	}
	688	$parent = end($stack);
	689	}
	690
	691	$res[] = array(
	692	'categoryId' => $rs->cat_url,
	693	'parentId' => $parent,
	694	'description' => $rs->cat_title,
	695	'categoryName' => $rs->cat_url,
	696	'htmlUrl' => $this->core->blog->url.$this->core->url->getBase('category').'/'.$rs->cat_url,
	697	'rssUrl' => $this->core->blog->url.$this->core->url->getBase('feed').'/category/'.$rs->cat_url.'/rss2'
	698	);
	699
	700	$stack[] = $rs->cat_url;
	701	$l = $rs->level;
	702	}
	703
	704	return $res;
	705	}
	706
	707	private function getPostCategories($post_id,$user,$pwd)
	708	{
	709	$post_id = (integer) $post_id;
	710
	711	$post = $this->getPostRS($post_id,$user,$pwd);
	712
	713	return array(
	714	array(
	715	'categoryName' => $post->cat_url,
	716	'categoryId' => (string) $post->cat_url,
	717	'isPrimary' => true
	718	)
	719	);
	720	}
	721
	722	private function setPostCategories($post_id,$user,$pwd,$categories)
	723	{
	724	$post_id = (integer) $post_id;
	725
	726	$post = $this->getPostRS($post_id,$user,$pwd);
	727
	728	$cat_id = (!empty($categories[0]['categoryId'])) ? $categories[0]['categoryId'] : null;
	729
	730	foreach($categories as $v)
	731	{
	732	if (isset($v['isPrimary']) && $v['isPrimary']) {
	733	$cat_id = $v['categoryId'];
	734	break;
	735	}
	736	}
	737
	738	# w.bloggar sends -1 for no category.
	739	if ($cat_id == -1) {
	740	$cat_id = null;
	741	}
	742
	743	if ($cat_id) {
	744	$cat_id = $this->getCatID($cat_id);
	745	}
	746
	747	$this->core->blog->updPostCategory($post_id,(integer) $cat_id);
	748
	749	return true;
	750	}
	751
	752	private function publishPost($post_id,$user,$pwd)
	753	{
	754	$post_id = (integer) $post_id;
	755
	756	$this->getPostRS($post_id,$user,$pwd);
	757
	758	# --BEHAVIOR-- xmlrpcBeforePublishPost
	759	$this->core->callBehavior('xmlrpcBeforePublishPost',$this,$post_id);
	760
	761	$this->core->blog->updPostStatus($post_id,1);
	762
	763	# --BEHAVIOR-- xmlrpcAfterPublishPost
	764	$this->core->callBehavior('xmlrpcAfterPublishPost',$this,$post_id);
	765
	766	return true;
	767	}
	768
	769	private function newMediaObject($blog_id,$user,$pwd,$file)
	770	{
	771	if (empty($file['name'])) {
	772	throw new Exception('No file name');
	773	}
	774
	775	if (empty($file['bits'])) {
	776	throw new Exception('No file content');
	777	}
	778
	779	$file_name = $file['name'];
	780	$file_bits = $file['bits'];
	781
	782	$this->setUser($user,$pwd);
	783	$this->setBlog();
	784
	785	$media = new dcMedia($this->core);
	786
	787	$dir_name = path::clean(dirname($file_name));
	788	$file_name = basename($file_name);
	789
	790	$dir_name = preg_replace('!^/!','',$dir_name);
	791	if ($dir_name != '')
	792	{
	793	$dir = explode('/',$dir_name);
	794	$cwd = './';
	795	foreach ($dir as $v)
	796	{
	797	$v = files::tidyFileName($v);
	798	$cwd .= $v.'/';
	799	$media->makeDir($v);
	800	$media->chdir($cwd);
	801	}
	802	}
	803
	804	$media_id = $media->uploadBits($file_name,$file_bits);
	805
	806	$f = $media->getFile($media_id);
	807	return array(
	808	'file' => $file_name,
	809	'url' => $f->file_url,
	810	'type' => files::getMimeType($file_name)
	811	);
	812	}
	813
	814	private function translateWpStatus($s)
	815	{
	816	$status = array(
	817	'draft' => -2,
	818	'pending' => -2,
	819	'private' => 0,
	820	'publish' => 1,
	821	'scheduled' => -1
	822	);
	823
	824	if (is_int($s)) {
	825	$status = array_flip($status);
	826	return isset($status[$s]) ? $status[$s] : $status[-2];
	827	} else {
	828	return isset($status[$s]) ? $status[$s] : $status['pending'];
	829	}
	830	}
	831
	832	private function translateWpCommentstatus($s)
	833	{
	834	$status = array(
	835	'hold' => -1,
	836	'approve' => 0,
	837	'spam' => -2
	838	);
	839
	840	if (is_int($s)) {
	841	$status = array_flip($status);
	842	return isset($status[$s]) ? $status[$s] : $status[0];
	843	} else {
	844	return isset($status[$s]) ? $status[$s] : $status['approve'];
	845	}
	846	}
	847
	848	private function translateWpOptions($options=array())
	849	{
	850	$timezone = 0;
	851	if ($this->core->blog->settings->system->blog_timezone) {
	852	$timezone = dt::getTimeOffset($this->core->blog->settings->system->blog_timezone)/3600;
	853	}
	854
	855	$res = array (
	856	'software_name' => array (
	857	'desc' => 'Software Name',
	858	'readonly' => true,
	859	'value' => 'Dotclear'
	860	),
	861	'software_version' => array (
	862	'desc' => 'Software Version',
	863	'readonly' => true,
	864	'value' => DC_VERSION
	865	),
	866	'blog_url' => array (
	867	'desc' => 'Blog URL',
	868	'readonly' => true,
	869	'value' => $this->core->blog->url
	870	),
	871	'time_zone' => array (
	872	'desc' => 'Time Zone',
	873	'readonly' => true,
	874	'value' => (string) $timezone
	875	),
	876	'blog_title' => array (
	877	'desc' => 'Blog Title',
	878	'readonly' => false,
	879	'value' => $this->core->blog->name
	880	),
	881	'blog_tagline' => array (
	882	'desc' => 'Blog Tagline',
	883	'readonly' => false,
	884	'value' => $this->core->blog->desc
	885	),
	886	'date_format' => array (
	887	'desc' => 'Date Format',
	888	'readonly' => false,
	889	'value' => $this->core->blog->settings->system->date_format
	890	),
	891	'time_format' => array (
	892	'desc' => 'Time Format',
	893	'readonly' => false,
	894	'value' => $this->core->blog->settings->system->time_format
	895	)
	896	);
	897
	898	if (!empty($options))
	899	{
	900	$r = array();
	901	foreach ($options as $v) {
	902	if (isset($res[$v])) {
	903	$r[$v] = $res[$v];
	904	}
	905	}
	906	return $r;
	907	}
	908
	909	return $res;
	910	}
	911
	912	private function getPostStatusList($blog_id,$user,$pwd)
	913	{
	914	$this->setUser($user,$pwd);
	915	$this->setBlog();
	916
	917	return array(
	918	'draft' => 'Draft',
	919	'pending' => 'Pending Review',
	920	'private' => 'Private',
	921	'publish' => 'Published',
	922	'scheduled' => 'Scheduled'
	923	);
	924	}
	925
	926	private function getPageStatusList($blog_id,$user,$pwd)
	927	{
	928	$this->setUser($user,$pwd);
	929	$this->setBlog();
	930	$this->checkPagesPermission();
	931
	932	return array(
	933	'draft' => 'Draft',
	934	'private' => 'Private',
	935	'published' => 'Published',
	936	'scheduled' => 'Scheduled'
	937	);
	938	}
	939
	940	private function checkPagesPermission()
	941	{
	942	if (!$this->core->plugins->moduleExists('pages')) {
	943	throw new Exception('Pages management is not available on this blog.');
	944	}
	945
	946	if (!$this->core->auth->check('pages,contentadmin',$this->core->blog->id)) {
	947	throw new Exception('Not enough permissions to edit pages.',401);
	948	}
	949	}
	950
	951	private function getPages($blog_id,$user,$pwd,$limit=null,$id=null)
	952	{
	953	$this->setUser($user,$pwd);
	954	$this->setBlog();
	955	$this->checkPagesPermission();
	956
	957	$params = array(
	958	'post_type' => 'page',
	959	'order' => 'post_position ASC, post_title ASC'
	960	);
	961
	962	if ($id) {
	963	$params['post_id'] = (integer) $id;
	964	}
	965	if ($limit) {
	966	$params['limit'] = $limit;
	967	}
	968
	969	$posts = $this->core->blog->getPosts($params);
	970
	971	$res = array();
	972	while ($posts->fetch())
	973	{
	974	$tres = array(
	975	"dateCreated" => new xmlrpcDate($posts->getTS()),
	976	"userid" => $posts->user_id,
	977	"page_id" => $posts->post_id,
	978	"page_status" => $this->translateWpStatus((integer) $posts->post_status),
	979	"description" => $posts->post_content_xhtml,
	980	"title" => $posts->post_title,
	981	"link" => $posts->getURL(),
	982	"permaLink" => $posts->getURL(),
	983	"categories" => array(),
	984	"excerpt" => $posts->post_excerpt_xhtml,
	985	"text_more" => '',
	986	"mt_allow_comments" => (integer) $posts->post_open_comment,
	987	"mt_allow_pings" => (integer) $posts->post_open_tb,
	988	"wp_slug" => $posts->post_url,
	989	"wp_password" => $posts->post_password,
	990	"wp_author" => $posts->getAuthorCN(),
	991	"wp_page_parent_id" => 0,
	992	"wp_page_parent_title" => '',
	993	"wp_page_order" => $posts->post_position,
	994	"wp_author_id" => $posts->user_id,
	995	"wp_author_display_name" => $posts->getAuthorCN(),
	996	"date_created_gmt" => new xmlrpcDate(dt::iso8601($posts->getTS(),$posts->post_tz)),
	997	"custom_fields" => array(),
	998	"wp_page_template" => 'default'
	999	);
	1000
	1001	# --BEHAVIOR-- xmlrpcGetPageInfo
	1002	$this->core->callBehavior('xmlrpcGetPageInfo',$this,array(&$tres));
	1003
	1004	$res[] = $tres;
	1005	}
	1006
	1007	return $res;
	1008	}
	1009
	1010	private function newPage($blog_id,$user,$pwd,$struct,$publish)
	1011	{
	1012	$this->setUser($user,$pwd);
	1013	$this->setBlog();
	1014	$this->checkPagesPermission();
	1015
	1016	$struct['post_type'] = 'page';
	1017
	1018	return $this->newPost($blog_id,$user,$pwd,null,$struct,$publish);
	1019	}
	1020
	1021	private function editPage($page_id,$user,$pwd,$struct,$publish)
	1022	{
	1023	$this->setUser($user,$pwd);
	1024	$this->setBlog();
	1025	$this->checkPagesPermission();
	1026
	1027	$struct['post_type'] = 'page';
	1028
	1029	return $this->editPost($page_id,$user,$pwd,null,$struct,$publish);
	1030	}
	1031
	1032	private function deletePage($page_id,$user,$pwd)
	1033	{
	1034	$this->setUser($user,$pwd);
	1035	$this->setBlog();
	1036	$this->checkPagesPermission();
	1037
	1038	$page_id = (integer) $page_id;
	1039
	1040	$this->getPostRS($page_id,$user,$pwd,'page');
	1041	$this->core->blog->delPost($page_id);
	1042
	1043	return true;
	1044	}
	1045
	1046	private function getAuthors($user,$pwd)
	1047	{
	1048	$this->setUser($user,$pwd);
	1049	$this->setBlog();
	1050
	1051	$rs = $this->core->getBlogPermissions($this->core->blog->id);
	1052	$res = array();
	1053
	1054	foreach($rs as $k => $v)
	1055	{
	1056	$res[] = array(
	1057	'user_id' => $k,
	1058	'user_login' => $k,
	1059	'display_name' => dcUtils::getUserCN($k,$v['name'],$v['firstname'],$v['displayname'])
	1060	);
	1061	}
	1062	return $res;
	1063	}
	1064
	1065	private function getTags($user,$pwd)
	1066	{
	1067	$this->setUser($user,$pwd);
	1068	$this->setBlog();
	1069
	1070	$tags = $this->core->meta->getMeta('tag');
	1071	$tags->sort('meta_id_lower','asc');
	1072
	1073	$res = array();
	1074	$url = $this->core->blog->url.$this->core->url->getBase('tag').'/%s';
	1075	$f_url = $this->core->blog->url.$this->core->url->getBase('tag_feed').'/%s';
	1076	while ($tags->fetch())
	1077	{
	1078	$res[] = array(
	1079	'tag_id' => $tags->meta_id,
	1080	'name' => $tags->meta_id,
	1081	'count' => $tags->count,
	1082	'slug' => $tags->meta_id,
	1083	'html_url' => sprintf($url,$tags->meta_id),
	1084	'rss_url' => sprintf($f_url,$tags->meta_id)
	1085	);
	1086	}
	1087	return $res;
	1088	}
	1089
	1090	private function newCategory($user,$pwd,$struct)
	1091	{
	1092	$this->setUser($user,$pwd);
	1093	$this->setBlog();
	1094
	1095	if (empty($struct['name'])) {
	1096	throw new Exception('You mus give a category name.');
	1097	}
	1098
	1099	$cur = $this->core->con->openCursor($this->core->prefix.'category');
	1100	$cur->cat_title = $struct['name'];
	1101
	1102	if (!empty($struct['slug'])) {
	1103	$cur->cat_url = $struct['slug'];
	1104	}
	1105	if (!empty($struct['category_description'])) {
	1106	$cur->cat_desc = $struct['category_description'];
	1107	if (html::clean($cur->cat_desc) == $cur->cat_desc) {
	1108	$cur->cat_desc = '<p>'.$cur->cat_desc.'</p>';
	1109	}
	1110	}
	1111
	1112	$parent = !empty($struct['category_parent']) ? (integer) $struct['category_parent'] : 0;
	1113
	1114	$id = $this->core->blog->addCategory($cur,$parent);
	1115	$rs = $this->core->blog->getCategory($id);
	1116	return $rs->cat_url;
	1117	}
	1118
	1119	private function deleteCategory($user,$pwd,$cat_id)
	1120	{
	1121	$this->setUser($user,$pwd);
	1122	$this->setBlog();
	1123
	1124	$c = $this->core->blog->getCategories(array('cat_url' => $cat_id));
	1125	if ($c->isEmpty()) {
	1126	throw new Exception(__('This category does not exist.'));
	1127	}
	1128	$cat_id = $c->cat_id;
	1129	unset($c);
	1130
	1131	$this->core->blog->delCategory((integer) $cat_id);
	1132	return true;
	1133	}
	1134
	1135	private function searchCategories($user,$pwd,$category,$limit)
	1136	{
	1137	$this->setUser($user,$pwd);
	1138	$this->setBlog();
	1139
	1140	$strReq = 'SELECT cat_id, cat_title, cat_url '.
	1141	'FROM '.$this->core->prefix.'category '.
	1142	"WHERE blog_id = '".$this->core->con->escape($this->core->blog->id)."' ".
	1143	"AND LOWER(cat_title) LIKE LOWER('%".$this->core->con->escape($category)."%') ".
	1144	($limit > 0 ? $this->core->con->limit($limit) : '');
	1145
	1146	$rs = $this->core->con->select($strReq);
	1147
	1148	$res = array();
	1149	while ($rs->fetch())
	1150	{
	1151	$res[] = array(
	1152	'category_id' => $rs->cat_url,
	1153	'category_name' => $rs->cat_url
	1154	);
	1155	}
	1156	return $res;
	1157	}
	1158
	1159	private function countComments($user,$pwd,$post_id)
	1160	{
	1161	$this->setUser($user,$pwd);
	1162	$this->setBlog();
	1163
	1164	$res = array(
	1165	'approved' => 0,
	1166	'awaiting_moderation' => 0,
	1167	'spam' => 0,
	1168	'total' => 0
	1169	);
	1170	$rs = $this->core->blog->getComments(array('post_id' => $post_id));
	1171
	1172	while ($rs->fetch()) {
	1173	$res['total']++;
	1174	if ($rs->comment_status == 1) {
	1175	$res['approved']++;
	1176	} elseif ($rs->comment_status == -2) {
	1177	$res['spam']++;
	1178	} else {
	1179	$res['awaiting_moderation']++;
	1180	}
	1181	}
	1182	return $res;
	1183	}
	1184
	1185	private function getComments($user,$pwd,$struct,$id=null)
	1186	{
	1187	$this->setUser($user,$pwd);
	1188	$this->setBlog();
	1189
	1190	$params = array();
	1191
	1192	if (!empty($struct['status'])) {
	1193	$params['comment_status'] = $this->translateWpCommentstatus($struct['status']);
	1194	}
	1195
	1196	if (!empty($struct['post_id'])) {
	1197	$params['post_id'] = (integer) $struct['post_id'];
	1198	}
	1199
	1200	if (isset($id)) {
	1201	$params['comment_id'] = $id;
	1202	}
	1203
	1204	$offset = !empty($struct['offset']) ? (integer) $struct['offset'] : 0;
	1205	$limit = !empty($struct['number']) ? (integer) $struct['number'] : 10;
	1206	$params['limit'] = array($offset,$limit);
	1207
	1208	$rs = $this->core->blog->getComments($params);
	1209	$res = array();
	1210	while ($rs->fetch())
	1211	{
	1212	$res[] = array(
	1213	'date_created_gmt' => new xmlrpcDate($rs->getTS()),
	1214	'user_id' => $rs->user_id,
	1215	'comment_id' => $rs->comment_id,
	1216	'parent' => 0,
	1217	'status' => $this->translateWpCommentstatus((integer) $rs->comment_status),
	1218	'content' => $rs->comment_content,
	1219	'link' => $rs->getPostURL().'#c'.$rs->comment_id,
	1220	'post_id' => $rs->post_id,
	1221	'post_title' => $rs->post_title,
	1222	'author' => $rs->comment_author,
	1223	'author_url' => $rs->comment_site,
	1224	'author_email' => $rs->comment_email,
[696]	1225	'author_ip' => $rs->comment_ip
[0]	1226	);
	1227	}
	1228	return $res;
	1229	}
	1230
	1231	private function addComment($user,$pwd,$post_id,$struct)
	1232	{
	1233	$this->setUser($user,$pwd);
	1234	$this->setBlog();
	1235
	1236	if (empty($struct['content'])) {
	1237	throw new Exception('Sorry, you cannot post an empty comment',401);
	1238	}
	1239
	1240	if (is_numeric($post_id)) {
	1241	$p['post_id'] = $post_id;
	1242	} else {
	1243	$p['post_url'] = $post_id;
	1244	}
	1245	$rs = $this->core->blog->getPosts($p);
	1246	if ($rs->isEmpty()) {
	1247	throw new Exception('Sorry, no such post.',404);
	1248	}
	1249
	1250	$cur = $this->core->con->openCursor($this->core->prefix.'comment');
	1251
	1252	$cur->comment_author = $this->core->auth->getInfo('user_cn');
	1253	$cur->comment_email = $this->core->auth->getInfo('user_email');
	1254	$cur->comment_site = $this->core->auth->getInfo('user_url');
	1255
	1256	$cur->comment_content = $struct['content'];
	1257	$cur->post_id = (integer) $post_id;
	1258
	1259	$id = $this->core->blog->addComment($cur);
	1260	return $id;
	1261	}
	1262
	1263	private function updComment($user,$pwd,$comment_id,$struct)
	1264	{
	1265	$this->setUser($user,$pwd);
	1266	$this->setBlog();
	1267
	1268	$cur = $this->core->con->openCursor($this->core->prefix.'comment');
	1269
	1270	if (isset($struct['status'])) {
	1271	$cur->comment_status = $this->translateWpCommentstatus($struct['status']);
	1272	}
	1273
	1274	if (isset($struct['date_created_gmt'])) {
	1275	if ($struct['date_created_gmt'] instanceof xmlrpcDate) {
	1276	$cur->comment_dt = date('Y-m-d H:i:00',$struct['date_created_gmt']->getTimestamp());
	1277	} elseif (is_string($struct['date_created_gmt']) && @strtotime($struct['date_created_gmt'])) {
	1278	$cur->comment_dt = date('Y-m-d H:i:00',strtotime($struct['date_created_gmt']));
	1279	}
	1280	$cur->comment_dt = $struct['date_created_gmt'];
	1281	}
	1282
	1283	if (isset($struct['content'])) {
	1284	$cur->comment_content = $struct['content'];
	1285	}
	1286
	1287	if (isset($struct['author'])) {
	1288	$cur->comment_author = $struct['author'];
	1289	}
	1290
	1291	if (isset($struct['author_url'])) {
	1292	$cur->comment_site = $struct['author_url'];
	1293	}
	1294
	1295	if (isset($struct['author_email'])) {
	1296	$cur->comment_email = $struct['author_email'];
	1297	}
	1298
	1299	$this->core->blog->updComment($comment_id,$cur);
	1300	return true;
	1301	}
	1302
	1303	private function delComment($user,$pwd,$comment_id)
	1304	{
	1305	$this->setUser($user,$pwd);
	1306	$this->setBlog();
	1307
	1308	$this->core->blog->delComment($comment_id);
	1309	return true;
	1310	}
	1311
	1312	/* Blogger methods
	1313	--------------------------------------------------- */
	1314	public function blogger_newPost($appkey,$blogid,$username,$password,$content,$publish)
	1315	{
	1316	return $this->newPost($blogid,$username,$password,$content,array(),$publish);
	1317	}
	1318
	1319	public function blogger_editPost($appkey,$postid,$username,$password,$content,$publish)
	1320	{
	1321	return $this->editPost($postid,$username,$password,$content,array(),$publish);
	1322	}
	1323
	1324	public function blogger_getPost($appkey,$postid,$username,$password)
	1325	{
	1326	return $this->getPost($postid,$username,$password,'blogger');
	1327	}
	1328
	1329	public function blogger_deletePost($appkey,$postid,$username,$password,$publish)
	1330	{
	1331	return $this->deletePost($postid,$username,$password);
	1332	}
	1333
	1334	public function blogger_getRecentPosts($appkey,$blogid,$username,$password,$numberOfPosts)
	1335	{
	1336	return $this->getRecentPosts($blogid,$username,$password,$numberOfPosts,'blogger');
	1337	}
	1338
	1339	public function blogger_getUserBlogs($appkey,$username,$password)
	1340	{
	1341	return $this->getUserBlogs($username,$password);
	1342	}
	1343
	1344	public function blogger_getUserInfo($appkey,$username,$password)
	1345	{
	1346	return $this->getUserInfo($username,$password);
	1347	}
	1348
	1349
	1350	/* Metaweblog methods
	1351	------------------------------------------------------- */
	1352	public function mw_newPost($blogid,$username,$password,$content,$publish)
	1353	{
	1354	return $this->newPost($blogid,$username,$password,'',$content,$publish);
	1355	}
	1356
	1357	public function mw_editPost($postid,$username,$password,$content,$publish)
	1358	{
	1359	return $this->editPost($postid,$username,$password,'',$content,$publish);
	1360	}
	1361
	1362	public function mw_getPost($postid,$username,$password)
	1363	{
	1364	return $this->getPost($postid,$username,$password,'mw');
	1365	}
	1366
	1367	public function mw_getRecentPosts($blogid,$username,$password,$numberOfPosts)
	1368	{
	1369	return $this->getRecentPosts($blogid,$username,$password,$numberOfPosts,'mw');
	1370	}
	1371
	1372	public function mw_getCategories($blogid,$username,$password)
	1373	{
	1374	return $this->getCategories($blogid,$username,$password);
	1375	}
	1376
	1377	public function mw_newMediaObject($blogid,$username,$password,$file)
	1378	{
	1379	return $this->newMediaObject($blogid,$username,$password,$file);
	1380	}
	1381
	1382	/* MovableType methods
	1383	--------------------------------------------------- */
	1384	public function mt_getRecentPostTitles($blogid,$username,$password,$numberOfPosts)
	1385	{
	1386	return $this->getRecentPosts($blogid,$username,$password,$numberOfPosts,'mt');
	1387	}
	1388
	1389	public function mt_getCategoryList($blogid,$username,$password)
	1390	{
	1391	return $this->getCategories($blogid,$username,$password);
	1392	}
	1393
	1394	public function mt_getPostCategories($postid,$username,$password)
	1395	{
	1396	return $this->getPostCategories($postid,$username,$password);
	1397	}
	1398
	1399	public function mt_setPostCategories($postid,$username,$password,$categories)
	1400	{
	1401	return $this->setPostCategories($postid,$username,$password,$categories);
	1402	}
	1403
	1404	public function mt_publishPost($postid,$username,$password)
	1405	{
	1406	return $this->publishPost($postid,$username,$password);
	1407	}
	1408
	1409	public function mt_supportedTextFilters()
	1410	{
	1411	return array();
	1412	}
	1413
	1414	/* WordPress methods
	1415	--------------------------------------------------- */
	1416	public function wp_getUsersBlogs($username,$password)
	1417	{
	1418	return $this->getUserBlogs($username,$password);
	1419	}
	1420
	1421	public function wp_getPage($blogid,$pageid,$username,$password)
	1422	{
	1423	$res = $this->getPages($blogid,$username,$password,null,$pageid);
	1424
	1425	if (empty($res)) {
	1426	throw new Exception('Sorry, no such page',404);
	1427	}
	1428
	1429	return $res[0];
	1430	}
	1431
	1432	public function wp_getPages($blogid,$username,$password,$num=10)
	1433	{
	1434	return $this->getPages($blogid,$username,$password,$num);
	1435	}
	1436
	1437	public function wp_newPage($blogid,$username,$password,$content,$publish)
	1438	{
	1439	return $this->newPage($blogid,$username,$password,$content,$publish);
	1440	}
	1441
	1442	public function wp_deletePage($blogid,$username,$password,$pageid)
	1443	{
	1444	return $this->deletePage($pageid,$username,$password);
	1445	}
	1446
	1447	public function wp_editPage($blogid,$pageid,$username,$password,$content,$publish)
	1448	{
	1449	return $this->editPage($pageid,$username,$password,$content,$publish);
	1450	}
	1451
	1452	public function wp_getPageList($blogid,$username,$password)
	1453	{
	1454	$A = $this->getPages($blogid,$username,$password);
	1455	$res = array();
	1456	foreach ($A as $v) {
	1457	$res[] = array(
	1458	'page_id' => $v['page_id'],
	1459	'page_title' => $v['title'],
	1460	'page_parent_id' => $v['wp_page_parent_id'],
	1461	'dateCreated' => $v['dateCreated'],
	1462	'date_created_gmt' => $v['date_created_gmt']
	1463	);
	1464	}
	1465	return $res;
	1466	}
	1467
	1468	public function wp_getAuthors($blogid,$username,$password)
	1469	{
	1470	return $this->getAuthors($username,$password);
	1471	}
	1472
	1473	public function wp_getCategories($blogid,$username,$password)
	1474	{
	1475	return $this->getCategories($blogid,$username,$password);
	1476	}
	1477
	1478	public function wp_getTags($blogid,$username,$password)
	1479	{
	1480	return $this->getTags($username,$password);
	1481	}
	1482
	1483	public function wp_newCategory($blogid,$username,$password,$content)
	1484	{
	1485	return $this->newCategory($username,$password,$content);
	1486	}
	1487
	1488	public function wp_deleteCategory($blogid,$username,$password,$categoryid)
	1489	{
	1490	return $this->deleteCategory($username,$password,$categoryid);
	1491	}
	1492
	1493	public function wp_suggestCategories($blogid,$username,$password,$category,$max_results=0)
	1494	{
	1495	return $this->searchCategories($username,$password,$category,$max_results);
	1496	}
	1497
	1498	public function wp_uploadFile($blogid,$username,$password,$file)
	1499	{
	1500	return $this->newMediaObject($blogid,$username,$password,$file);
	1501	}
	1502
	1503	public function wp_getPostStatusList($blogid,$username,$password)
	1504	{
	1505	return $this->getPostStatusList($blogid,$username,$password);
	1506	}
	1507
	1508	public function wp_getPageStatusList($blogid,$username,$password)
	1509	{
	1510	return $this->getPostStatusList($blogid,$username,$password);
	1511	}
	1512
	1513	public function wp_getPageTemplates($blogid,$username,$password)
	1514	{
	1515	return array('Default' => 'default');
	1516	}
	1517
	1518	public function wp_getOptions($blogid,$username,$password,$options=array())
	1519	{
	1520	$this->setUser($username,$password);
	1521	$this->setBlog();
	1522
	1523	return $this->translateWpOptions($options);
	1524	}
	1525
	1526	public function wp_setOptions($blogid,$username,$password,$options)
	1527	{
	1528	$this->setUser($username,$password);
	1529	$this->setBlog();
	1530
	1531	if (!$this->core->auth->check('admin',$this->core->blog->id)) {
	1532	throw new Exception('Not enough permissions to edit options.',401);
	1533	}
	1534
	1535	$opt = $this->translateWpOptions();
	1536
	1537	$done = array();
	1538	$blog_changes = false;
	1539	$cur = $this->core->con->openCursor($this->core->prefix.'blog');
	1540
	1541	$this->core->blog->settings->addNamespace('system');
	1542
	1543	foreach ($options as $name => $value)
	1544	{
	1545	if (!isset($opt[$name]) \|\| $opt[$name]['readonly']) {
	1546	continue;
	1547	}
	1548
	1549	switch ($name)
	1550	{
	1551	case 'blog_title':
	1552	$blog_changes = true;
	1553	$cur->blog_name = $value;
	1554	$done[] = $name;
	1555	break;
	1556	case 'blog_tagline':
	1557	$blog_changes = true;
	1558	$cur->blog_desc = $value;
	1559	$done[] = $name;
	1560	break;
	1561	case 'date_format':
	1562	$this->core->blog->settings->system->put('date_format',$value);
	1563	$done[] = $name;
	1564	break;
	1565	case 'time_format':
	1566	$this->core->blog->settings->system->put('time_format',$value);
	1567	$done[] = $name;
	1568	break;
	1569	}
	1570	}
	1571
	1572	if ($blog_changes) {
	1573	$this->core->updBlog($this->core->blog->id,$cur);
	1574	$this->core->setBlog($this->core->blog->id);
	1575	}
	1576
	1577	return $this->translateWpOptions($done);
	1578	}
	1579
	1580	public function wp_getComment($blogid,$username,$password,$commentid)
	1581	{
	1582	$res = $this->getComments($username,$password,array(),$commentid);
	1583
	1584	if (empty($res)) {
	1585	throw new Exception('Sorry, no such comment',404);
	1586	}
	1587
	1588	return $res[0];
	1589	}
	1590
	1591	public function wp_getCommentCount($blogid,$username,$password,$postid)
	1592	{
	1593	return $this->countComments($username,$password,$postid);
	1594	}
	1595
	1596	public function wp_getComments($blogid,$username,$password,$struct)
	1597	{
	1598	return $this->getComments($username,$password,$struct);
	1599	}
	1600
	1601	public function wp_deleteComment($blogid,$username,$password,$commentid)
	1602	{
	1603	return $this->delComment($username,$password,$commentid);
	1604	}
	1605
	1606	public function wp_editComment($blogid,$username,$password,$commentid,$content)
	1607	{
	1608	return $this->updComment($username,$password,$commentid,$content);
	1609	}
	1610
	1611	public function wp_newComment($blogid,$username,$password,$postid,$content)
	1612	{
	1613	return $this->addComment($username,$password,$postid,$content);
	1614	}
	1615
	1616	public function wp_getCommentStatusList($blogid,$username,$password)
	1617	{
	1618	$this->setUser($username,$password);
	1619	$this->setBlog();
	1620
	1621	return array(
	1622	'hold' => 'Unapproved',
	1623	'approve' => 'Approved',
	1624	'spam' => 'Spam'
	1625	);
	1626	}
	1627	}
	1628	?>

Note: See TracBrowser for help on using the repository browser.

Dotclear

Context Navigation

source: inc/core/class.dc.xmlrpc.php @ 696:1a2b2b2d943b

Download in other formats:

Sites map