1 |
dpavlin |
2 |
<?php |
2 |
|
|
// vim: ts=4 foldcolumn=4 foldmethod=marker |
3 |
|
|
/** |
4 |
|
|
* RF_Client_Controller class found here. |
5 |
|
|
* |
6 |
|
|
* This file is part of Reblog, |
7 |
|
|
* a derivative work of Feed On Feeds. |
8 |
|
|
* |
9 |
|
|
* Distributed under the Gnu Public License. |
10 |
|
|
* |
11 |
|
|
* @package Refeed |
12 |
|
|
* @license http://opensource.org/licenses/gpl-license.php GNU Public License |
13 |
|
|
* @author Michal Migurski <mike@stamen.com> |
14 |
|
|
* @author Michael Frumin <mfrumin@eyebeam.org> |
15 |
|
|
* @copyright ©2004 Michael Frumin, Michal Migurski |
16 |
|
|
* @link http://reblog.org Reblog |
17 |
|
|
* @link http://feedonfeeds.com Feed On Feeds |
18 |
|
|
* @version $Revision: 1.34 $ |
19 |
|
|
*/ |
20 |
|
|
|
21 |
|
|
/** |
22 |
|
|
* |
23 |
|
|
*/ |
24 |
|
|
define('REBLOG_RESPONSE_FEED_LIST', 1); |
25 |
|
|
|
26 |
|
|
/** |
27 |
|
|
* |
28 |
|
|
*/ |
29 |
|
|
define('REBLOG_RESPONSE_ITEM_LIST', 2); |
30 |
|
|
|
31 |
|
|
/** |
32 |
|
|
* |
33 |
|
|
*/ |
34 |
|
|
define('REBLOG_RESPONSE_ADD_FEED', 3); |
35 |
|
|
|
36 |
|
|
/** |
37 |
|
|
* |
38 |
|
|
*/ |
39 |
|
|
define('REBLOG_RESPONSE_POST_ITEM', 4); |
40 |
|
|
|
41 |
|
|
/** |
42 |
|
|
* |
43 |
|
|
*/ |
44 |
|
|
define('REBLOG_RESPONSE_UPDATE_FEED', 5); |
45 |
|
|
|
46 |
|
|
/** |
47 |
|
|
* |
48 |
|
|
*/ |
49 |
|
|
define('REBLOG_RESPONSE_UPDATE_ALL', 6); |
50 |
|
|
|
51 |
|
|
/** |
52 |
|
|
* |
53 |
|
|
*/ |
54 |
|
|
define('REBLOG_RESPONSE_CALL', 7); |
55 |
|
|
|
56 |
|
|
/** |
57 |
|
|
* |
58 |
|
|
*/ |
59 |
|
|
define('REBLOG_RESPONSE_DO', 8); |
60 |
|
|
|
61 |
|
|
/** |
62 |
|
|
* |
63 |
|
|
*/ |
64 |
|
|
define('REBLOG_RESPONSE_PUBLISHED_ITEMS', 9); |
65 |
|
|
|
66 |
|
|
/** |
67 |
|
|
* |
68 |
|
|
*/ |
69 |
|
|
define('REBLOG_RESPONSE_PUBLISHED_FEED', 10); |
70 |
|
|
|
71 |
|
|
/** |
72 |
|
|
* |
73 |
|
|
*/ |
74 |
|
|
define('REBLOG_RESPONSE_PUBLISHED_OPML', 11); |
75 |
|
|
|
76 |
|
|
|
77 |
|
|
|
78 |
|
|
/** |
79 |
|
|
*/ |
80 |
|
|
class RF_Client_Controller |
81 |
|
|
{ |
82 |
|
|
/** |
83 |
|
|
* Reference to operative controller object. |
84 |
|
|
* @var RF_Controller |
85 |
|
|
*/ |
86 |
|
|
var $controller; |
87 |
|
|
|
88 |
|
|
/** |
89 |
|
|
* Reference to operative view object. |
90 |
|
|
* @var Smarty |
91 |
|
|
*/ |
92 |
|
|
var $view; |
93 |
|
|
|
94 |
|
|
/** |
95 |
|
|
* Associative array of page types and URL's. |
96 |
|
|
* @var array |
97 |
|
|
*/ |
98 |
|
|
var $locations; |
99 |
|
|
|
100 |
|
|
|
101 |
|
|
var $response_code; |
102 |
|
|
|
103 |
|
|
/** |
104 |
|
|
* @param RF_Controller $controller - |
105 |
|
|
* @param Smarty $view - |
106 |
|
|
* |
107 |
|
|
* @uses RF_Client_Controller::$controller Assigned on instantiation, from {@link RF_Controller $controller}. |
108 |
|
|
* @uses RF_Client_Controller::$view Assigned on instantiation, from {@link Smarty $view}. |
109 |
|
|
* @uses RF_Client_Controller::$locations Assigned on instantiation, to an array of location fragments |
110 |
|
|
* @uses RF_Controller::invokePlugin() "clientCreated" event, |
111 |
|
|
* parameters: {@link RF_Client_Controller $client_controller}. |
112 |
|
|
*/ |
113 |
|
|
function RF_Client_Controller(&$controller, &$view, $locations = null) |
114 |
|
|
{ |
115 |
|
|
if(strtolower(get_class($controller)) != strtolower('RF_Controller')) |
116 |
|
|
die("RF_Client_Controller must be instantiated with an RF_Controller."); |
117 |
|
|
|
118 |
|
|
$this->controller =& $controller; |
119 |
|
|
$this->view =& $view; |
120 |
|
|
|
121 |
|
|
$this->locations = is_array($locations) |
122 |
|
|
? $locations |
123 |
|
|
: array(REBLOG_RESPONSE_FEED_LIST => $view->refeed_root.'/index.php', |
124 |
|
|
REBLOG_RESPONSE_ITEM_LIST => $view->refeed_root.'/view.php', |
125 |
|
|
REBLOG_RESPONSE_ADD_FEED => $view->refeed_root.'/add.php', |
126 |
|
|
REBLOG_RESPONSE_POST_ITEM => $view->refeed_root.'/post.php', |
127 |
|
|
REBLOG_RESPONSE_UPDATE_FEED => $view->refeed_root.'/update.php', |
128 |
|
|
REBLOG_RESPONSE_UPDATE_ALL => $view->refeed_root.'/update-quiet.php', |
129 |
|
|
REBLOG_RESPONSE_CALL => $view->refeed_root.'/call.php', |
130 |
|
|
REBLOG_RESPONSE_DO => $view->refeed_root.'/do.php', |
131 |
|
|
REBLOG_RESPONSE_PUBLISHED_ITEMS => $view->refeed_root.'/out/index.php', |
132 |
|
|
REBLOG_RESPONSE_PUBLISHED_FEED => $view->refeed_root.'/out/rss.php', |
133 |
|
|
REBLOG_RESPONSE_PUBLISHED_OPML => $view->refeed_root.'/out/opml.php'); |
134 |
|
|
|
135 |
|
|
$this->view->client = &$this; |
136 |
|
|
$this->cleanMagicQuotes(); |
137 |
|
|
|
138 |
|
|
$this->controller->invokePlugin('clientCreated', array(&$this)); |
139 |
|
|
} |
140 |
|
|
|
141 |
|
|
|
142 |
|
|
function cleanMagicQuotes() { |
143 |
|
|
// "Magic Quotes" is a terrible, terrible feature to have enabled by default. |
144 |
|
|
if(get_magic_quotes_gpc()) { |
145 |
|
|
|
146 |
|
|
foreach($_GET as $var => $value) |
147 |
|
|
if(is_string($value)) |
148 |
|
|
$_GET[$var] = stripslashes($value); |
149 |
|
|
|
150 |
|
|
foreach($_POST as $var => $value) |
151 |
|
|
if(is_string($value)) |
152 |
|
|
$_POST[$var] = stripslashes($value); |
153 |
|
|
|
154 |
|
|
foreach($_REQUEST as $var => $value) |
155 |
|
|
if(is_string($value)) |
156 |
|
|
$_REQUEST[$var] = stripslashes($value); |
157 |
|
|
} |
158 |
|
|
} |
159 |
|
|
|
160 |
|
|
|
161 |
|
|
/** |
162 |
|
|
* @param mixed $output Constant from this file to decide which response to return. |
163 |
|
|
* @param array $ARGS Associative array of arguments, if any. |
164 |
|
|
* @return string HTML response string |
165 |
|
|
*/ |
166 |
|
|
function respond($output, $ARGS = null) |
167 |
|
|
{ |
168 |
|
|
$this->response_code = $output; |
169 |
|
|
|
170 |
|
|
switch($output) { |
171 |
|
|
case REBLOG_RESPONSE_FEED_LIST: return $this->listFeeds($ARGS); |
172 |
|
|
case REBLOG_RESPONSE_ITEM_LIST: return $this->listItems($ARGS); |
173 |
|
|
case REBLOG_RESPONSE_ADD_FEED: return $this->addFeed($ARGS); |
174 |
|
|
case REBLOG_RESPONSE_POST_ITEM: return $this->postItem($ARGS); |
175 |
|
|
case REBLOG_RESPONSE_UPDATE_FEED: return $this->updateFeed($ARGS); |
176 |
|
|
case REBLOG_RESPONSE_UPDATE_ALL: return $this->updateAll($ARGS); |
177 |
|
|
case REBLOG_RESPONSE_CALL: return $this->remoteCall($ARGS); |
178 |
|
|
case REBLOG_RESPONSE_DO: return $this->formDo($ARGS); |
179 |
|
|
case REBLOG_RESPONSE_PUBLISHED_ITEMS: return $this->publishedItems($ARGS); |
180 |
|
|
case REBLOG_RESPONSE_PUBLISHED_FEED: return $this->publishedFeed($ARGS); |
181 |
|
|
case REBLOG_RESPONSE_PUBLISHED_OPML: return $this->publishedOPML($ARGS); |
182 |
|
|
} |
183 |
|
|
} |
184 |
|
|
|
185 |
|
|
function generateResponse($args, $template, $response = null) { |
186 |
|
|
$args['client_response'] = (empty($response) |
187 |
|
|
? $this->response_code |
188 |
|
|
: $response |
189 |
|
|
); |
190 |
|
|
|
191 |
|
|
if(empty($args['user'])) { |
192 |
|
|
$args['user'] =& $GLOBALS['REBLOG_USER']; |
193 |
|
|
} |
194 |
|
|
|
195 |
|
|
$this->view->assign('RB', $args); |
196 |
|
|
return $this->view->fetch($template); |
197 |
|
|
} |
198 |
|
|
|
199 |
|
|
/** |
200 |
|
|
* @param array $ARGS Associative array of arguments, if any - set to $_GET if omitted. |
201 |
|
|
* @return string HTML response string |
202 |
|
|
* |
203 |
|
|
* @uses RF_Client_Controller::_getUserFromArguments() |
204 |
|
|
*/ |
205 |
|
|
function listFeeds($ARGS = null) |
206 |
|
|
{ |
207 |
|
|
if(!is_array($ARGS)) $ARGS =& $_GET; |
208 |
|
|
|
209 |
|
|
$user = RF_Client_Controller::_getUserFromArguments($ARGS); |
210 |
|
|
|
211 |
|
|
$RB = array( |
212 |
|
|
'feeds' => |
213 |
|
|
$this->controller->getUserFeeds($user, RF_Page::viewArguments($ARGS)) |
214 |
|
|
|
215 |
|
|
, 'feed_tags' => |
216 |
|
|
$this->controller->getUserTags($user, 'feed') |
217 |
|
|
|
218 |
|
|
, 'self_feed' => |
219 |
|
|
$this->controller->getUserSelfFeed($user, RF_Page::viewArguments($ARGS)) |
220 |
|
|
|
221 |
|
|
, 'args' => RF_Page::viewArguments($ARGS) |
222 |
|
|
|
223 |
|
|
); |
224 |
|
|
|
225 |
|
|
return $this->generateResponse($RB, 'page-feeds.tpl'); |
226 |
|
|
} |
227 |
|
|
|
228 |
|
|
/** |
229 |
|
|
* @param array $ARGS Associative array of arguments, if any - set to $_GET if omitted. |
230 |
|
|
* @return string HTML response string |
231 |
|
|
* |
232 |
|
|
* @uses RF_Client_Controller::_getUserFromArguments() |
233 |
|
|
* @uses RF_Controller::prepareUserdataArguments() |
234 |
|
|
* @uses RF_Controller::tagUsage() |
235 |
|
|
* @uses RF_Controller::getUserTags() |
236 |
|
|
* @uses RF_Controller::getUserFeeds() |
237 |
|
|
*/ |
238 |
|
|
function listItems($ARGS = null) |
239 |
|
|
{ |
240 |
|
|
if(!is_array($ARGS)) $ARGS =& $_GET; |
241 |
|
|
|
242 |
|
|
$user =& RF_Client_Controller::_getUserFromArguments($ARGS); |
243 |
|
|
|
244 |
|
|
$viewArgs = RF_Page::viewArguments($ARGS); |
245 |
|
|
|
246 |
|
|
$viewArgs['metadata'] = $this->controller->prepareUserdataArguments(isset($ARGS['metadata']) ? $ARGS['metadata'] : null); |
247 |
|
|
|
248 |
|
|
$items =& $this->controller->getUserItems($user, $viewArgs); |
249 |
|
|
|
250 |
|
|
$feeds = array(); |
251 |
|
|
|
252 |
|
|
foreach($items as $item) |
253 |
|
|
if($item->feed) |
254 |
|
|
$feeds[$item->feed->getID()] = $item->feed; |
255 |
|
|
|
256 |
|
|
if($viewArgs['feed']) { |
257 |
|
|
$feed = reset($this->controller->getUserFeeds($user, array('feed' => $viewArgs['feed']))); |
258 |
|
|
} |
259 |
|
|
|
260 |
|
|
$RB = array( |
261 |
|
|
'items' => $items |
262 |
|
|
|
263 |
|
|
, 'item_tags' => $this->controller->getUserTags($user) |
264 |
|
|
|
265 |
|
|
, 'item_tag_usage' => $this->controller->tagUsage($items) |
266 |
|
|
|
267 |
|
|
, 'feed' => $feed |
268 |
|
|
|
269 |
|
|
, 'feeds' => $feeds |
270 |
|
|
|
271 |
|
|
, 'feed_tags' => $this->controller->getUserTags($user, 'feed') |
272 |
|
|
|
273 |
|
|
, 'feed_tag_usage' => $this->controller->tagUsage($feeds) |
274 |
|
|
|
275 |
|
|
, 'args' => $viewArgs |
276 |
|
|
|
277 |
|
|
, 'edit' => (empty($ARGS['noedit']) ? true : false) |
278 |
|
|
|
279 |
|
|
, 'title' => RF_Page::viewTitle($feed, $viewArgs) |
280 |
|
|
|
281 |
|
|
, 'links' => $this->view->itemNavLinks($feed, $viewArgs) |
282 |
|
|
|
283 |
|
|
, 'what' => $viewArgs['what'] |
284 |
|
|
|
285 |
|
|
); |
286 |
|
|
|
287 |
|
|
return $this->generateResponse($RB, 'page-items.tpl'); |
288 |
|
|
|
289 |
|
|
} |
290 |
|
|
|
291 |
|
|
/** |
292 |
|
|
* @param array $ARGS Associative array of arguments, if any - set to $_POST if omitted. |
293 |
|
|
* @return string HTML response string |
294 |
|
|
* |
295 |
|
|
* @uses RF_Client_Controller::_getUserFromArguments() |
296 |
|
|
* @uses RF_Input_Controller::subscribeUserToFeedURL() |
297 |
|
|
* @uses RF_Input_Controller::subscribeUserToFeedsFromOPML() |
298 |
|
|
*/ |
299 |
|
|
function addFeed($ARGS = null) |
300 |
|
|
{ |
301 |
|
|
if(!is_array($ARGS)) $ARGS =& $_POST; |
302 |
|
|
|
303 |
|
|
$user = RF_Client_Controller::_getUserFromArguments($ARGS); |
304 |
|
|
|
305 |
|
|
$input_controller = new RF_Input_Controller($this->controller); |
306 |
|
|
|
307 |
|
|
$_REQUEST['published'] = $_REQUEST['published'] ? 1 : null; |
308 |
|
|
$_REQUEST['rss_url'] = preg_replace('#^feed://#', 'http://', $_REQUEST['rss_url']); |
309 |
|
|
|
310 |
|
|
ob_start(); if($ARGS['action'] == 'submit') { |
311 |
|
|
|
312 |
|
|
if(!empty($_REQUEST['rss_url'])) |
313 |
|
|
if($result = $input_controller->subscribeUserToFeedURL($user, $_REQUEST['rss_url'], $_REQUEST['published'], preg_split('/\s+/', $_REQUEST['tags']))) |
314 |
|
|
$this->view->assign('rss_feeds', array($result)); |
315 |
|
|
|
316 |
|
|
$this->view->assign('rss_results', ob_get_contents()); |
317 |
|
|
ob_clean(); |
318 |
|
|
|
319 |
|
|
if(!empty($_REQUEST['opml_url'])) |
320 |
|
|
if($opml_data = implode('', file($_REQUEST['opml_url']))) |
321 |
|
|
$input_controller->subscribeUserToFeedsFromOPML($user, $opml_data, $_REQUEST['published'], preg_split('/\s+/', $_REQUEST['tags'])); |
322 |
|
|
|
323 |
|
|
$this->view->assign('opml_results', ob_get_contents()); |
324 |
|
|
ob_clean(); |
325 |
|
|
|
326 |
|
|
if(is_uploaded_file($_FILES['opml_file']['tmp_name'])) |
327 |
|
|
if($opml_data = implode('', file($_FILES['opml_file']['tmp_name']))) |
328 |
|
|
$input_controller->subscribeUserToFeedsFromOPML($user, $opml_data, $_REQUEST['published'], preg_split('/\s+/', $_REQUEST['tags'])); |
329 |
|
|
|
330 |
|
|
$this->view->assign('file_results', ob_get_contents()); |
331 |
|
|
ob_clean(); |
332 |
|
|
|
333 |
|
|
} ob_end_clean(); |
334 |
|
|
|
335 |
|
|
return $this->generateResponse(array(), 'page-addfeed.tpl'); |
336 |
|
|
} |
337 |
|
|
|
338 |
|
|
/** |
339 |
|
|
* @param array $ARGS Associative array of arguments, if any - set to $_GET if omitted. |
340 |
|
|
* @return string HTML response string |
341 |
|
|
* |
342 |
|
|
* @uses RF_Client_Controller::_getUserFromArguments() |
343 |
|
|
* @uses RF_Userdata_Controller::postItem() |
344 |
|
|
*/ |
345 |
|
|
function postItem($ARGS = null) |
346 |
|
|
{ |
347 |
|
|
if(!is_array($ARGS)) $ARGS =& $_GET; |
348 |
|
|
|
349 |
|
|
$user = RF_Client_Controller::_getUserFromArguments($ARGS); |
350 |
|
|
|
351 |
|
|
$userdata_controller = new RF_Userdata_Controller($this->controller, $user); |
352 |
|
|
|
353 |
|
|
switch($_REQUEST['action']) { |
354 |
|
|
|
355 |
|
|
case 'Post': |
356 |
|
|
case 'Post New Item': |
357 |
|
|
$item = $userdata_controller->postItem($_REQUEST); |
358 |
|
|
header("Location: {$this->locations[REBLOG_RESPONSE_ITEM_LIST]}?item=".$item->getID()); |
359 |
|
|
break; |
360 |
|
|
} |
361 |
|
|
|
362 |
|
|
return $this->generateResponse(array(), 'page-post.tpl'); |
363 |
|
|
|
364 |
|
|
} |
365 |
|
|
|
366 |
|
|
/** |
367 |
|
|
* @param array $ARGS Associative array of arguments, if any - set to $_REQUEST if omitted. |
368 |
|
|
* @return string HTML response string |
369 |
|
|
* |
370 |
|
|
* @uses RF_Client_Controller::_getUserFromArguments() |
371 |
|
|
* @uses RF_Controller::getUserFeeds() |
372 |
|
|
* @uses RF_Input_Controller::updateFeed() |
373 |
|
|
*/ |
374 |
|
|
function updateFeed($ARGS = null) |
375 |
|
|
{ |
376 |
|
|
if(!is_array($ARGS)) $ARGS =& $_REQUEST; |
377 |
|
|
|
378 |
|
|
$user = RF_Client_Controller::_getUserFromArguments($ARGS); |
379 |
|
|
|
380 |
|
|
$input_controller = new RF_Input_Controller($this->controller); |
381 |
|
|
|
382 |
|
|
$feeds = $this->controller->getUserFeeds($user, $ARGS); |
383 |
|
|
|
384 |
|
|
ob_start(); { |
385 |
|
|
|
386 |
|
|
foreach($feeds as $f => $feed) |
387 |
|
|
$input_controller->updateFeed($feeds[$f]); |
388 |
|
|
|
389 |
|
|
} ob_end_clean(); |
390 |
|
|
|
391 |
|
|
return $this->generateResponse(array('feeds' => $feeds), 'page-update.tpl'); |
392 |
|
|
} |
393 |
|
|
|
394 |
|
|
/** |
395 |
|
|
* @param array $ARGS Associative array of arguments, if any - set to $_GET if omitted. |
396 |
|
|
* @return string HTML response string |
397 |
|
|
* |
398 |
|
|
* @uses RF_Client_Controller::_getUserFromArguments() |
399 |
|
|
* @uses RF_Controller::getFeeds() |
400 |
|
|
* @uses RF_Input_Controller::updateFeed() |
401 |
|
|
*/ |
402 |
|
|
function updateAll($ARGS = null) |
403 |
|
|
{ |
404 |
|
|
if(!is_array($ARGS)) $ARGS =& $_GET; |
405 |
|
|
|
406 |
|
|
$user = RF_Client_Controller::_getUserFromArguments($ARGS); |
407 |
|
|
|
408 |
|
|
$input_controller = new RF_Input_Controller($this->controller); |
409 |
|
|
|
410 |
|
|
$feeds = $this->controller->getFeeds('random'); |
411 |
|
|
|
412 |
|
|
foreach($feeds as $f => $feed) |
413 |
|
|
$input_controller->updateFeed($feeds[$f]); |
414 |
|
|
|
415 |
|
|
return ''; |
416 |
|
|
} |
417 |
|
|
|
418 |
|
|
/** |
419 |
|
|
* @param array $ARGS Associative array of arguments, if any - set to $_GET if omitted. |
420 |
|
|
* @return string HTML response string |
421 |
|
|
* |
422 |
|
|
* @uses RF_Client_Controller::_getUserFromArguments() |
423 |
|
|
* @uses class_hints() |
424 |
|
|
* @uses RF_Userdata_Controller::RF_Userdata_Controller() |
425 |
|
|
* @uses RF_Controller::invokePlugin() Method and arguments are determined from incoming JSON-RPC request |
426 |
|
|
*/ |
427 |
|
|
function remoteCall($ARGS = null) |
428 |
|
|
{ |
429 |
|
|
if(!is_array($ARGS)) $ARGS =& $_GET; |
430 |
|
|
|
431 |
|
|
$user = RF_Client_Controller::_getUserFromArguments($ARGS); |
432 |
|
|
|
433 |
|
|
require_once(join(DIRECTORY_SEPARATOR, array('library', 'JSON-PHP', 'JSON.php'))); |
434 |
|
|
|
435 |
|
|
$json = new Services_JSON(SERVICES_JSON_LOOSE_TYPE); |
436 |
|
|
|
437 |
|
|
$request_raw = file_get_contents('php://input', 1000000); |
438 |
|
|
$request = $json->decode($request_raw); |
439 |
|
|
error_log("Refeed JSON-RPC request: {$request_raw}"); |
440 |
|
|
|
441 |
|
|
// see http://json-rpc.org/specs.xhtml for more info on what's going on here. |
442 |
|
|
class_hints($request['params']); |
443 |
|
|
|
444 |
|
|
$userdata_controller = new RF_Userdata_Controller($this->controller, $user); |
445 |
|
|
|
446 |
|
|
if(method_exists($userdata_controller, $request['method'])) { |
447 |
|
|
// if the userdata controller has the requested method, call it. |
448 |
|
|
$result = call_user_func_array(array(&$userdata_controller, $request['method']), $request['params']); |
449 |
|
|
|
450 |
|
|
} elseif($request['method'] && $request['params']) { |
451 |
|
|
// otherwise, there may be a plugin willing to handle the method |
452 |
|
|
$result = $this->controller->invokePlugin($request['method'], $request['params'], true); |
453 |
|
|
|
454 |
|
|
} |
455 |
|
|
|
456 |
|
|
// now respond. |
457 |
|
|
header('Content-Type: application/x-json-rpc'); |
458 |
|
|
|
459 |
|
|
if($result) |
460 |
|
|
return($json->encode(array('result' => $result, 'error' => null, 'id' => $request['id']))); |
461 |
|
|
|
462 |
|
|
return($json->encode(array('result' => null, 'error' => true, 'id' => $request['id']))); |
463 |
|
|
} |
464 |
|
|
|
465 |
|
|
/** |
466 |
|
|
* @param array $ARGS Associative array of arguments, if any - set to $_POST if omitted. |
467 |
|
|
* @return string HTML response string |
468 |
|
|
* |
469 |
|
|
* @uses RF_Client_Controller::_getUserFromArguments() |
470 |
|
|
* @uses RF_Feed::RF_Feed() |
471 |
|
|
* @uses RF_Item::RF_Item() |
472 |
|
|
* @uses RF_Userdata_Controller::RF_Userdata_Controller() |
473 |
|
|
* @uses RF_Userdata_Controller::markFeedUnpublished() |
474 |
|
|
* @uses RF_Userdata_Controller::markFeedPublished() |
475 |
|
|
* @uses RF_Userdata_Controller::markItemUnpublished() |
476 |
|
|
* @uses RF_Userdata_Controller::markItemPublished() |
477 |
|
|
* @uses RF_Userdata_Controller::markItemRead() |
478 |
|
|
* @uses RF_Userdata_Controller::markItemsRead() |
479 |
|
|
* @uses RF_Controller::getUserItems() |
480 |
|
|
* @uses RF_Userdata_Controller::markItemUnread() |
481 |
|
|
* @uses RF_Userdata_Controller::setItemLink() |
482 |
|
|
* @uses RF_Userdata_Controller::setItemCommentTags() |
483 |
|
|
*/ |
484 |
|
|
function formDo($ARGS = null) |
485 |
|
|
{ |
486 |
|
|
if(!is_array($ARGS)) $ARGS =& $_POST; |
487 |
|
|
|
488 |
|
|
$user = RF_Client_Controller::_getUserFromArguments($ARGS); |
489 |
|
|
|
490 |
|
|
$redirect = $ARGS['return'] |
491 |
|
|
? $ARGS['return'] |
492 |
|
|
: $_SERVER['HTTP_REFERER'] |
493 |
|
|
? $_SERVER['HTTP_REFERER'] |
494 |
|
|
: false; |
495 |
|
|
|
496 |
|
|
if($redirect) |
497 |
|
|
header("Location: {$redirect}"); |
498 |
|
|
|
499 |
|
|
$userdata_controller = new RF_Userdata_Controller($this->controller, $user); |
500 |
|
|
|
501 |
|
|
switch($ARGS['action']) { |
502 |
|
|
|
503 |
|
|
case 'mark-feed-unpublished': |
504 |
|
|
|
505 |
|
|
$userdata_controller->markFeedUnpublished(new RF_Feed(array('id' => $ARGS['id']))); |
506 |
|
|
return 'ok'; |
507 |
|
|
|
508 |
|
|
case 'mark-feed-published': |
509 |
|
|
|
510 |
|
|
$userdata_controller->markFeedPublished(new RF_Feed(array('id' => $ARGS['id']))); |
511 |
|
|
return 'ok'; |
512 |
|
|
|
513 |
|
|
case 'mark-item-unpublished': |
514 |
|
|
|
515 |
|
|
$userdata_controller->markItemUnpublished(new RF_Item(array('id' => $ARGS['id']))); |
516 |
|
|
return 'ok'; |
517 |
|
|
|
518 |
|
|
case 'mark-item-published': |
519 |
|
|
|
520 |
|
|
$userdata_controller->markItemPublished(new RF_Item(array('id' => $ARGS['id']))); |
521 |
|
|
return 'ok'; |
522 |
|
|
|
523 |
|
|
case 'mark-item-read': |
524 |
|
|
|
525 |
|
|
$userdata_controller->markItemRead(new RF_Item(array('id' => $ARGS['id']))); |
526 |
|
|
return 'ok'; |
527 |
|
|
|
528 |
|
|
case 'mark-items-read': |
529 |
|
|
|
530 |
|
|
$ARGS['ids'] = is_array($ARGS['ids']) ? $ARGS['ids'] : array(); |
531 |
|
|
$items = array(); |
532 |
|
|
|
533 |
|
|
foreach($ARGS['ids'] as $id) |
534 |
|
|
if($id && is_numeric($id)) |
535 |
|
|
$items[] = new RF_Item(array('id' => $id)); |
536 |
|
|
|
537 |
|
|
$userdata_controller->markItemsRead($items); |
538 |
|
|
return 'ok'; |
539 |
|
|
|
540 |
|
|
case 'mark-everything-read': |
541 |
|
|
|
542 |
|
|
$items = $this->controller->getUserItems($user, array()); |
543 |
|
|
$userdata_controller->markItemsRead($items); |
544 |
|
|
return 'ok'; |
545 |
|
|
|
546 |
|
|
case 'mark-item-unread': |
547 |
|
|
|
548 |
|
|
$userdata_controller->markItemUnread(new RF_Item(array('id' => $ARGS['id']))); |
549 |
|
|
return 'ok'; |
550 |
|
|
|
551 |
|
|
case 'mark-feed-read': |
552 |
|
|
|
553 |
|
|
$userdata_controller->markFeedRead(new RF_feed(array('id' => $ARGS['id']))); |
554 |
|
|
return 'ok'; |
555 |
|
|
|
556 |
|
|
case 'unsubscribe-from-feed': |
557 |
|
|
|
558 |
|
|
$this->controller->unsubscribeUserFromFeed($user, new RF_Feed(array('id' => $ARGS['id']))); |
559 |
|
|
return 'ok'; |
560 |
|
|
|
561 |
|
|
case 'link-select': |
562 |
|
|
|
563 |
|
|
$userdata_controller->setItemLink(new RF_Item(array('id' => $ARGS['id'])), $ARGS['link']); |
564 |
|
|
return 'ok'; |
565 |
|
|
|
566 |
|
|
case 'submit-item-values': |
567 |
|
|
|
568 |
|
|
$userdata_controller->setItemCommentTags(new RF_Item(array('id' => $ARGS['id'])), $ARGS['comment'], $ARGS['tags']); |
569 |
|
|
|
570 |
|
|
return 'ok'; |
571 |
|
|
|
572 |
|
|
case 'set-use-kb': |
573 |
|
|
$_SESSION['use_kb'] = $ARGS['flag']; |
574 |
|
|
return 'ok'; |
575 |
|
|
|
576 |
|
|
default: |
577 |
|
|
return 'unknown action'; |
578 |
|
|
|
579 |
|
|
} |
580 |
|
|
|
581 |
|
|
return 'no ID'; |
582 |
|
|
} |
583 |
|
|
|
584 |
|
|
/** |
585 |
|
|
* @param array $ARGS Associative array of arguments, if any - set to $_GET if omitted. |
586 |
|
|
* @return string HTML response string |
587 |
|
|
* |
588 |
|
|
* @uses RF_Client_Controller::_getUserFromArguments() |
589 |
|
|
* @uses RF_Controller::prepareUserdataArguments() |
590 |
|
|
* @uses RF_User::itemPageCount() |
591 |
|
|
* @uses RF_Controller::getUserItems() |
592 |
|
|
*/ |
593 |
|
|
function publishedItems($ARGS = null) |
594 |
|
|
{ |
595 |
|
|
if(!is_array($ARGS)) $ARGS =& $_GET; |
596 |
|
|
|
597 |
|
|
$user = RF_Client_Controller::_getUserFromArguments($ARGS); |
598 |
|
|
|
599 |
|
|
$viewArgs = RF_Page::viewArguments($ARGS); |
600 |
|
|
|
601 |
|
|
// some arguments can't be set by query string |
602 |
|
|
$viewArgs['how'] = 'paged'; |
603 |
|
|
$viewArgs['what'] = 'published'; |
604 |
|
|
$viewArgs['howmany'] = $user->itemPageCount(); |
605 |
|
|
$viewArgs['script'] = REBLOG_RESPONSE_PUBLISHED_ITEMS; |
606 |
|
|
$viewArgs['metadata'] = $this->controller->prepareUserdataArguments($ARGS['metadata']); |
607 |
|
|
$viewArgs['metadata'][] = array('format' => 'numeric', 'label' => 'self'); |
608 |
|
|
|
609 |
|
|
$items =& $this->controller->getUserItems($user, $viewArgs); |
610 |
|
|
|
611 |
|
|
$feeds =& $this->controller->getUserFeeds($user, array()); |
612 |
|
|
|
613 |
|
|
$item_tags =& $this->controller->getUserTags($user); |
614 |
|
|
|
615 |
|
|
$RB = array( |
616 |
|
|
'args' => $viewArgs |
617 |
|
|
, 'user' => $user |
618 |
|
|
, 'items' => $items |
619 |
|
|
, 'feeds' => $feeds |
620 |
|
|
, 'item_tags' => $item_tags |
621 |
|
|
, 'title' => RF_Page::viewTitle($feed, $viewArgs) |
622 |
|
|
, 'now' => gmmktime() |
623 |
|
|
, 'links' => $this->view->itemNavLinks($feed, $viewArgs, false) |
624 |
|
|
); |
625 |
|
|
|
626 |
|
|
return $this->generateResponse($RB, 'out/page-html.tpl'); |
627 |
|
|
} |
628 |
|
|
|
629 |
|
|
/** |
630 |
|
|
* @param array $ARGS Associative array of arguments, if any - set to $_GET if omitted. |
631 |
|
|
* @return string XML response string |
632 |
|
|
* |
633 |
|
|
* @uses RF_Client_Controller::_getUserFromArguments() |
634 |
|
|
* @uses RF_Controller::prepareUserdataArguments() |
635 |
|
|
* @uses RF_Controller::getUserItems() |
636 |
|
|
* @uses RF_User::itemPageCount() |
637 |
|
|
*/ |
638 |
|
|
function publishedFeed($ARGS = null) |
639 |
|
|
{ |
640 |
|
|
if(!is_array($ARGS)) $ARGS =& $_GET; |
641 |
|
|
|
642 |
|
|
$user = RF_Client_Controller::_getUserFromArguments($ARGS); |
643 |
|
|
|
644 |
|
|
$viewArgs = RF_Page::viewArguments($ARGS); |
645 |
|
|
|
646 |
|
|
$viewArgs['what'] = 'published'; |
647 |
|
|
$viewArgs['when'] = 'today'; |
648 |
|
|
$viewArgs['metadata'] = $this->controller->prepareUserdataArguments($ARGS['metadata']); |
649 |
|
|
$viewArgs['metadata'][] = array('format' => 'numeric', 'label' => 'self'); |
650 |
|
|
|
651 |
|
|
$items = $this->controller->getUserItems($user, $viewArgs); |
652 |
|
|
|
653 |
|
|
// get all of today's items, plus however many it takes to reach user's item page count in total |
654 |
|
|
if(count($items) < $user->itemPageCount()) { |
655 |
|
|
$viewArgs['how'] = 'paged'; |
656 |
|
|
$viewArgs['when'] = null; |
657 |
|
|
$viewArgs['offset'] = count($items); |
658 |
dpavlin |
25 |
$viewArgs['howmany'] = $user->itemPageCount() - count($items); |
659 |
|
|
if ($_GET['howmany']) $viewArgs['howmany'] = $_GET['howmany']; |
660 |
dpavlin |
2 |
|
661 |
|
|
$items = array_merge($items, $this->controller->getUserItems($user, $viewArgs)); |
662 |
|
|
} |
663 |
|
|
|
664 |
|
|
|
665 |
|
|
|
666 |
|
|
$RB = array( |
667 |
|
|
'args' => $viewArgs |
668 |
|
|
, 'user' => $user |
669 |
|
|
, 'items' => $items |
670 |
|
|
, 'title' => RF_Page::viewTitle($feed, $viewArgs) |
671 |
|
|
, 'now' => gmmktime() |
672 |
|
|
, 'links' => $this->view->itemNavLinks($feed, $viewArgs, false) |
673 |
|
|
); |
674 |
|
|
|
675 |
|
|
$version = empty($ARGS['v']) ? get_configured_feedversion() : $ARGS['v']; |
676 |
|
|
|
677 |
|
|
$tpl = 'out/page-rss2.tpl'; |
678 |
|
|
switch($version) { |
679 |
|
|
case 1: |
680 |
|
|
case 'rss1.0': |
681 |
|
|
$tpl = 'out/page-rss1.tpl'; break; |
682 |
|
|
|
683 |
|
|
case 2: |
684 |
|
|
case 'rss2.0': |
685 |
|
|
$tpl = 'out/page-rss2.tpl'; break; |
686 |
|
|
|
687 |
|
|
case 'atom': |
688 |
|
|
$tpl = 'out/page-atom.tpl'; break; |
689 |
|
|
|
690 |
|
|
} |
691 |
|
|
|
692 |
|
|
header('Content-type: text/xml'); |
693 |
|
|
|
694 |
|
|
return $this->generateResponse($RB, $tpl); |
695 |
|
|
|
696 |
|
|
} |
697 |
|
|
|
698 |
|
|
/** |
699 |
|
|
* @param array $ARGS Associative array of arguments, if any - set to $_GET if omitted. |
700 |
|
|
* @return string XML response string |
701 |
|
|
* |
702 |
|
|
* @uses RF_Client_Controller::_getUserFromArguments() |
703 |
|
|
* @uses RF_Controller::getUserFeeds() |
704 |
|
|
*/ |
705 |
|
|
function publishedOPML($ARGS = null) |
706 |
|
|
{ |
707 |
|
|
if(!is_array($ARGS)) $ARGS =& $_GET; |
708 |
|
|
|
709 |
|
|
$user = RF_Client_Controller::_getUserFromArguments($ARGS); |
710 |
|
|
|
711 |
|
|
header('Content-type: text/xml'); |
712 |
|
|
return $this->generateResponse(array( |
713 |
|
|
'user' => $user |
714 |
|
|
, 'feeds' => $this->controller->getUserFeeds($user, array()) |
715 |
|
|
) |
716 |
|
|
, 'out/opml.tpl' |
717 |
|
|
); |
718 |
|
|
} |
719 |
|
|
|
720 |
|
|
/** |
721 |
|
|
* Return a user based on aguments. |
722 |
|
|
* |
723 |
|
|
* If a "user" element is found in the argument array: |
724 |
|
|
* - The user object at that index if it is a valid RF_User |
725 |
|
|
* - A new user object with that ID if it looks like an integer |
726 |
|
|
* - Null it's something else |
727 |
|
|
* |
728 |
|
|
* Return the global Reblog user if no "user" index is defined. |
729 |
|
|
* |
730 |
|
|
* @static |
731 |
|
|
* @param array $ARGS Associative array of arguments, if any |
732 |
|
|
* @return string XML response string |
733 |
|
|
*/ |
734 |
|
|
function _getUserFromArguments($ARGS) |
735 |
|
|
{ |
736 |
|
|
if(is_array($ARGS) && isset($ARGS['user'])) { |
737 |
|
|
|
738 |
|
|
if(is_subclass_of($ARGS['user'], 'RF_User')) |
739 |
|
|
return $ARGS['user']; |
740 |
|
|
|
741 |
|
|
if(is_numeric($ARGS['user'])) |
742 |
|
|
return new RF_User(array('id' => intval($ARGS['user']))); |
743 |
|
|
|
744 |
|
|
return null; |
745 |
|
|
} |
746 |
|
|
|
747 |
|
|
return $GLOBALS['REBLOG_USER']; |
748 |
|
|
} |
749 |
|
|
|
750 |
|
|
} |
751 |
|
|
|
752 |
|
|
?> |