]> git.mxchange.org Git - friendica-addons.git/blob - pumpio/pumpio.php
Merge pull request #534 from tobiasd/20180218-en
[friendica-addons.git] / pumpio / pumpio.php
1 <?php
2 /**
3  * Name: pump.io Post Connector
4  * Description: Bidirectional (posting, relaying and reading) connector for pump.io.
5  * Version: 0.2
6  * Author: Michael Vogel <http://pirati.ca/profile/heluecht>
7  */
8
9 use Friendica\Content\Text\BBCode;
10 use Friendica\Core\Addon;
11 use Friendica\Core\Config;
12 use Friendica\Core\L10n;
13 use Friendica\Core\PConfig;
14 use Friendica\Core\Worker;
15 use Friendica\Model\Contact;
16 use Friendica\Model\GContact;
17 use Friendica\Model\Group;
18 use Friendica\Model\Item;
19 use Friendica\Model\Queue;
20 use Friendica\Model\User;
21 use Friendica\Util\DateTimeFormat;
22 use Friendica\Util\Network;
23
24 require 'addon/pumpio/oauth/http.php';
25 require 'addon/pumpio/oauth/oauth_client.php';
26 require_once 'include/enotify.php';
27 require_once "mod/share.php";
28
29 define('PUMPIO_DEFAULT_POLL_INTERVAL', 5); // given in minutes
30
31 function pumpio_install() {
32         Addon::registerHook('post_local',           'addon/pumpio/pumpio.php', 'pumpio_post_local');
33         Addon::registerHook('notifier_normal',      'addon/pumpio/pumpio.php', 'pumpio_send');
34         Addon::registerHook('jot_networks',         'addon/pumpio/pumpio.php', 'pumpio_jot_nets');
35         Addon::registerHook('connector_settings',      'addon/pumpio/pumpio.php', 'pumpio_settings');
36         Addon::registerHook('connector_settings_post', 'addon/pumpio/pumpio.php', 'pumpio_settings_post');
37         Addon::registerHook('cron', 'addon/pumpio/pumpio.php', 'pumpio_cron');
38         Addon::registerHook('queue_predeliver', 'addon/pumpio/pumpio.php', 'pumpio_queue_hook');
39         Addon::registerHook('check_item_notification','addon/pumpio/pumpio.php', 'pumpio_check_item_notification');
40 }
41
42 function pumpio_uninstall() {
43         Addon::unregisterHook('post_local',       'addon/pumpio/pumpio.php', 'pumpio_post_local');
44         Addon::unregisterHook('notifier_normal',  'addon/pumpio/pumpio.php', 'pumpio_send');
45         Addon::unregisterHook('jot_networks',     'addon/pumpio/pumpio.php', 'pumpio_jot_nets');
46         Addon::unregisterHook('connector_settings',      'addon/pumpio/pumpio.php', 'pumpio_settings');
47         Addon::unregisterHook('connector_settings_post', 'addon/pumpio/pumpio.php', 'pumpio_settings_post');
48         Addon::unregisterHook('cron', 'addon/pumpio/pumpio.php', 'pumpio_cron');
49         Addon::unregisterHook('queue_predeliver', 'addon/pumpio/pumpio.php', 'pumpio_queue_hook');
50         Addon::unregisterHook('check_item_notification','addon/pumpio/pumpio.php', 'pumpio_check_item_notification');
51 }
52
53 function pumpio_module() {}
54
55 function pumpio_content(&$a) {
56
57         if(! local_user()) {
58                 notice(L10n::t('Permission denied.') . EOL);
59                 return '';
60         }
61
62         require_once("mod/settings.php");
63         settings_init($a);
64
65         if (isset($a->argv[1]))
66                 switch ($a->argv[1]) {
67                         case "connect":
68                                 $o = pumpio_connect($a);
69                                 break;
70                         default:
71                                 $o = print_r($a->argv, true);
72                                 break;
73                 }
74         else
75                 $o = pumpio_connect($a);
76
77         return $o;
78 }
79
80 function pumpio_check_item_notification($a, &$notification_data) {
81         $hostname = PConfig::get($notification_data["uid"], 'pumpio','host');
82         $username = PConfig::get($notification_data["uid"], "pumpio", "user");
83
84         $notification_data["profiles"][] = "https://".$hostname."/".$username;
85 }
86
87
88 function pumpio_registerclient(&$a, $host) {
89
90         $url = "https://".$host."/api/client/register";
91
92         $params = [];
93
94         $application_name  = Config::get('pumpio', 'application_name');
95
96         if ($application_name == "")
97                 $application_name = $a->get_hostname();
98
99         $adminlist = explode(",", str_replace(" ", "", $a->config['admin_email']));
100
101         $params["type"] = "client_associate";
102         $params["contacts"] = $adminlist[0];
103         $params["application_type"] = "native";
104         $params["application_name"] = $application_name;
105         $params["logo_url"] = $a->get_baseurl()."/images/friendica-256.png";
106         $params["redirect_uris"] = $a->get_baseurl()."/pumpio/connect";
107
108         logger("pumpio_registerclient: ".$url." parameters ".print_r($params, true), LOGGER_DEBUG);
109
110         $ch = curl_init($url);
111         curl_setopt($ch, CURLOPT_HEADER, false);
112         curl_setopt($ch, CURLOPT_RETURNTRANSFER,true);
113         curl_setopt($ch, CURLOPT_POST,1);
114         curl_setopt($ch, CURLOPT_POSTFIELDS,$params);
115         curl_setopt($ch, CURLOPT_USERAGENT, "Friendica");
116
117         $s = curl_exec($ch);
118         $curl_info = curl_getinfo($ch);
119
120         if ($curl_info["http_code"] == "200") {
121                 $values = json_decode($s);
122                 logger("pumpio_registerclient: success ".print_r($values, true), LOGGER_DEBUG);
123                 return($values);
124         }
125         logger("pumpio_registerclient: failed: ".print_r($curl_info, true), LOGGER_DEBUG);
126         return(false);
127
128 }
129
130 function pumpio_connect(&$a) {
131         // Start a session.  This is necessary to hold on to  a few keys the callback script will also need
132         session_start();
133
134         // Define the needed keys
135         $consumer_key = PConfig::get(local_user(), 'pumpio','consumer_key');
136         $consumer_secret = PConfig::get(local_user(), 'pumpio','consumer_secret');
137         $hostname = PConfig::get(local_user(), 'pumpio','host');
138
139         if ((($consumer_key == "") || ($consumer_secret == "")) && ($hostname != "")) {
140                 logger("pumpio_connect: register client");
141                 $clientdata = pumpio_registerclient($a, $hostname);
142                 PConfig::set(local_user(), 'pumpio','consumer_key', $clientdata->client_id);
143                 PConfig::set(local_user(), 'pumpio','consumer_secret', $clientdata->client_secret);
144
145                 $consumer_key = PConfig::get(local_user(), 'pumpio','consumer_key');
146                 $consumer_secret = PConfig::get(local_user(), 'pumpio','consumer_secret');
147
148                 logger("pumpio_connect: ckey: ".$consumer_key." csecrect: ".$consumer_secret, LOGGER_DEBUG);
149         }
150
151         if (($consumer_key == "") || ($consumer_secret == "")) {
152                 logger("pumpio_connect: ".sprintf("Unable to register the client at the pump.io server '%s'.", $hostname));
153
154                 $o .= L10n::t("Unable to register the client at the pump.io server '%s'.", $hostname);
155                 return($o);
156         }
157
158         // The callback URL is the script that gets called after the user authenticates with pumpio
159         $callback_url = $a->get_baseurl()."/pumpio/connect";
160
161         // Let's begin.  First we need a Request Token.  The request token is required to send the user
162         // to pumpio's login page.
163
164         // Create a new instance of the oauth_client_class library.  For this step, all we need to give the library is our
165         // Consumer Key and Consumer Secret
166         $client = new oauth_client_class;
167         $client->debug = 1;
168         $client->server = '';
169         $client->oauth_version = '1.0a';
170         $client->request_token_url = 'https://'.$hostname.'/oauth/request_token';
171         $client->dialog_url = 'https://'.$hostname.'/oauth/authorize';
172         $client->access_token_url = 'https://'.$hostname.'/oauth/access_token';
173         $client->url_parameters = false;
174         $client->authorization_header = true;
175         $client->redirect_uri = $callback_url;
176         $client->client_id = $consumer_key;
177         $client->client_secret = $consumer_secret;
178
179         if (($success = $client->Initialize())) {
180                 if (($success = $client->Process())) {
181                         if (strlen($client->access_token)) {
182                                 logger("pumpio_connect: otoken: ".$client->access_token." osecrect: ".$client->access_token_secret, LOGGER_DEBUG);
183                                 PConfig::set(local_user(), "pumpio", "oauth_token", $client->access_token);
184                                 PConfig::set(local_user(), "pumpio", "oauth_token_secret", $client->access_token_secret);
185                         }
186                 }
187                 $success = $client->Finalize($success);
188         }
189         if($client->exit)
190                 $o = 'Could not connect to pumpio. Refresh the page or try again later.';
191
192         if($success) {
193                 logger("pumpio_connect: authenticated");
194                 $o .= L10n::t("You are now authenticated to pumpio.");
195                 $o .= '<br /><a href="'.$a->get_baseurl().'/settings/connectors">'.L10n::t("return to the connector page").'</a>';
196         } else {
197                 logger("pumpio_connect: could not connect");
198                 $o = 'Could not connect to pumpio. Refresh the page or try again later.';
199         }
200
201         return($o);
202 }
203
204 function pumpio_jot_nets(&$a,&$b) {
205         if(! local_user())
206                 return;
207
208         $pumpio_post = PConfig::get(local_user(),'pumpio','post');
209         if(intval($pumpio_post) == 1) {
210                 $pumpio_defpost = PConfig::get(local_user(),'pumpio','post_by_default');
211                 $selected = ((intval($pumpio_defpost) == 1) ? ' checked="checked" ' : '');
212                 $b .= '<div class="profile-jot-net"><input type="checkbox" name="pumpio_enable"' . $selected . ' value="1" /> '
213                         . L10n::t('Post to pumpio') . '</div>';
214         }
215 }
216
217
218 function pumpio_settings(&$a,&$s) {
219
220         if(! local_user())
221                 return;
222
223         /* Add our stylesheet to the page so we can make our settings look nice */
224
225         $a->page['htmlhead'] .= '<link rel="stylesheet"  type="text/css" href="' . $a->get_baseurl() . '/addon/pumpio/pumpio.css' . '" media="all" />' . "\r\n";
226
227         /* Get the current state of our config variables */
228
229         $import_enabled = PConfig::get(local_user(),'pumpio','import');
230         $import_checked = (($import_enabled) ? ' checked="checked" ' : '');
231
232         $enabled = PConfig::get(local_user(),'pumpio','post');
233         $checked = (($enabled) ? ' checked="checked" ' : '');
234         $css = (($enabled) ? '' : '-disabled');
235
236         $def_enabled = PConfig::get(local_user(),'pumpio','post_by_default');
237         $def_checked = (($def_enabled) ? ' checked="checked" ' : '');
238
239         $public_enabled = PConfig::get(local_user(),'pumpio','public');
240         $public_checked = (($public_enabled) ? ' checked="checked" ' : '');
241
242         $mirror_enabled = PConfig::get(local_user(),'pumpio','mirror');
243         $mirror_checked = (($mirror_enabled) ? ' checked="checked" ' : '');
244
245         $servername = PConfig::get(local_user(), "pumpio", "host");
246         $username = PConfig::get(local_user(), "pumpio", "user");
247
248         /* Add some HTML to the existing form */
249
250         $s .= '<span id="settings_pumpio_inflated" class="settings-block fakelink" style="display: block;" onclick="openClose(\'settings_pumpio_expanded\'); openClose(\'settings_pumpio_inflated\');">';
251         $s .= '<img class="connector'.$css.'" src="images/pumpio.png" /><h3 class="connector">'. L10n::t('Pump.io Import/Export/Mirror').'</h3>';
252         $s .= '</span>';
253         $s .= '<div id="settings_pumpio_expanded" class="settings-block" style="display: none;">';
254         $s .= '<span class="fakelink" onclick="openClose(\'settings_pumpio_expanded\'); openClose(\'settings_pumpio_inflated\');">';
255         $s .= '<img class="connector'.$css.'" src="images/pumpio.png" /><h3 class="connector">'. L10n::t('Pump.io Import/Export/Mirror').'</h3>';
256         $s .= '</span>';
257
258         $s .= '<div id="pumpio-username-wrapper">';
259         $s .= '<label id="pumpio-username-label" for="pumpio-username">'.L10n::t('pump.io username (without the servername)').'</label>';
260         $s .= '<input id="pumpio-username" type="text" name="pumpio_user" value="'.$username.'" />';
261         $s .= '</div><div class="clear"></div>';
262
263         $s .= '<div id="pumpio-servername-wrapper">';
264         $s .= '<label id="pumpio-servername-label" for="pumpio-servername">'.L10n::t('pump.io servername (without "http://" or "https://" )').'</label>';
265         $s .= '<input id="pumpio-servername" type="text" name="pumpio_host" value="'.$servername.'" />';
266         $s .= '</div><div class="clear"></div>';
267
268         if (($username != '') && ($servername != '')) {
269
270                 $oauth_token = PConfig::get(local_user(), "pumpio", "oauth_token");
271                 $oauth_token_secret = PConfig::get(local_user(), "pumpio", "oauth_token_secret");
272
273                 $s .= '<div id="pumpio-password-wrapper">';
274                 if (($oauth_token == "") || ($oauth_token_secret == "")) {
275                         $s .= '<div id="pumpio-authenticate-wrapper">';
276                         $s .= '<a href="'.$a->get_baseurl().'/pumpio/connect">'.L10n::t("Authenticate your pump.io connection").'</a>';
277                         $s .= '</div><div class="clear"></div>';
278                 } else {
279                         $s .= '<div id="pumpio-import-wrapper">';
280                         $s .= '<label id="pumpio-import-label" for="pumpio-import">' . L10n::t('Import the remote timeline') . '</label>';
281                         $s .= '<input id="pumpio-import" type="checkbox" name="pumpio_import" value="1" ' . $import_checked . '/>';
282                         $s .= '</div><div class="clear"></div>';
283
284                         $s .= '<div id="pumpio-enable-wrapper">';
285                         $s .= '<label id="pumpio-enable-label" for="pumpio-checkbox">' . L10n::t('Enable pump.io Post Addon') . '</label>';
286                         $s .= '<input id="pumpio-checkbox" type="checkbox" name="pumpio" value="1" ' . $checked . '/>';
287                         $s .= '</div><div class="clear"></div>';
288
289                         $s .= '<div id="pumpio-bydefault-wrapper">';
290                         $s .= '<label id="pumpio-bydefault-label" for="pumpio-bydefault">' . L10n::t('Post to pump.io by default') . '</label>';
291                         $s .= '<input id="pumpio-bydefault" type="checkbox" name="pumpio_bydefault" value="1" ' . $def_checked . '/>';
292                         $s .= '</div><div class="clear"></div>';
293
294                         $s .= '<div id="pumpio-public-wrapper">';
295                         $s .= '<label id="pumpio-public-label" for="pumpio-public">' . L10n::t('Should posts be public?') . '</label>';
296                         $s .= '<input id="pumpio-public" type="checkbox" name="pumpio_public" value="1" ' . $public_checked . '/>';
297                         $s .= '</div><div class="clear"></div>';
298
299                         $s .= '<div id="pumpio-mirror-wrapper">';
300                         $s .= '<label id="pumpio-mirror-label" for="pumpio-mirror">' . L10n::t('Mirror all public posts') . '</label>';
301                         $s .= '<input id="pumpio-mirror" type="checkbox" name="pumpio_mirror" value="1" ' . $mirror_checked . '/>';
302                         $s .= '</div><div class="clear"></div>';
303
304                         $s .= '<div id="pumpio-delete-wrapper">';
305                         $s .= '<label id="pumpio-delete-label" for="pumpio-delete">' . L10n::t('Check to delete this preset') . '</label>';
306                         $s .= '<input id="pumpio-delete" type="checkbox" name="pumpio_delete" value="1" />';
307                         $s .= '</div><div class="clear"></div>';
308                 }
309
310                 $s .= '</div><div class="clear"></div>';
311         }
312
313         /* provide a submit button */
314
315         $s .= '<div class="settings-submit-wrapper" ><input type="submit" id="pumpio-submit" name="pumpio-submit" class="settings-submit" value="' . L10n::t('Save Settings') . '" /></div></div>';
316 }
317
318
319 function pumpio_settings_post(&$a,&$b) {
320
321         if(x($_POST,'pumpio-submit')) {
322                 if(x($_POST,'pumpio_delete')) {
323                         PConfig::set(local_user(),'pumpio','consumer_key','');
324                         PConfig::set(local_user(),'pumpio','consumer_secret','');
325                         PConfig::set(local_user(),'pumpio','oauth_token','');
326                         PConfig::set(local_user(),'pumpio','oauth_token_secret','');
327                         PConfig::set(local_user(),'pumpio','post',false);
328                         PConfig::set(local_user(),'pumpio','import',false);
329                         PConfig::set(local_user(),'pumpio','host','');
330                         PConfig::set(local_user(),'pumpio','user','');
331                         PConfig::set(local_user(),'pumpio','public',false);
332                         PConfig::set(local_user(),'pumpio','mirror',false);
333                         PConfig::set(local_user(),'pumpio','post_by_default',false);
334                         PConfig::set(local_user(),'pumpio','lastdate', 0);
335                         PConfig::set(local_user(),'pumpio','last_id', '');
336                 } else {
337                         // filtering the username if it is filled wrong
338                         $user = $_POST['pumpio_user'];
339                         if (strstr($user, "@")) {
340                                 $pos = strpos($user, "@");
341                                 if ($pos > 0)
342                                         $user = substr($user, 0, $pos);
343                         }
344
345                         // Filtering the hostname if someone is entering it with "http"
346                         $host = $_POST['pumpio_host'];
347                         $host = trim($host);
348                         $host = str_replace(["https://", "http://"], ["", ""], $host);
349
350                         PConfig::set(local_user(),'pumpio','post',intval($_POST['pumpio']));
351                         PConfig::set(local_user(),'pumpio','import',$_POST['pumpio_import']);
352                         PConfig::set(local_user(),'pumpio','host',$host);
353                         PConfig::set(local_user(),'pumpio','user',$user);
354                         PConfig::set(local_user(),'pumpio','public',$_POST['pumpio_public']);
355                         PConfig::set(local_user(),'pumpio','mirror',$_POST['pumpio_mirror']);
356                         PConfig::set(local_user(),'pumpio','post_by_default',intval($_POST['pumpio_bydefault']));
357
358                         if (!$_POST['pumpio_mirror'])
359                                 PConfig::delete(local_user(),'pumpio','lastdate');
360
361                         //header("Location: ".$a->get_baseurl()."/pumpio/connect");
362                 }
363         }
364 }
365
366 function pumpio_post_local(&$a, &$b) {
367
368         if (!local_user() || (local_user() != $b['uid'])) {
369                 return;
370         }
371
372         $pumpio_post   = intval(PConfig::get(local_user(), 'pumpio', 'post'));
373
374         $pumpio_enable = (($pumpio_post && x($_REQUEST,'pumpio_enable')) ? intval($_REQUEST['pumpio_enable']) : 0);
375
376         if ($b['api_source'] && intval(PConfig::get(local_user(), 'pumpio', 'post_by_default'))) {
377                 $pumpio_enable = 1;
378         }
379
380         if (!$pumpio_enable) {
381                 return;
382         }
383
384         if (strlen($b['postopts'])) {
385                 $b['postopts'] .= ',';
386         }
387
388         $b['postopts'] .= 'pumpio';
389 }
390
391
392
393
394 function pumpio_send(&$a,&$b) {
395
396         if (!PConfig::get($b["uid"],'pumpio','import')) {
397                 if($b['deleted'] || $b['private'] || ($b['created'] !== $b['edited']))
398                         return;
399         }
400
401         logger("pumpio_send: parameter ".print_r($b, true), LOGGER_DATA);
402
403         if($b['parent'] != $b['id']) {
404                 // Looking if its a reply to a pumpio post
405                 $r = q("SELECT item.* FROM item, contact WHERE item.id = %d AND item.uid = %d AND contact.id = `contact-id` AND contact.network='%s'LIMIT 1",
406                         intval($b["parent"]),
407                         intval($b["uid"]),
408                         dbesc(NETWORK_PUMPIO));
409
410                 if(!count($r)) {
411                         logger("pumpio_send: no pumpio post ".$b["parent"]);
412                         return;
413                 } else {
414                         $iscomment = true;
415                         $orig_post = $r[0];
416                 }
417         } else {
418                 $iscomment = false;
419
420                 $receiver = pumpio_getreceiver($a, $b);
421
422                 logger("pumpio_send: receiver ".print_r($receiver, true));
423
424                 if (!count($receiver) && ($b['private'] || !strstr($b['postopts'],'pumpio'))) {
425                         return;
426                 }
427
428                 // Dont't post if the post doesn't belong to us.
429                 // This is a check for forum postings
430                 $self = dba::selectFirst('contact', ['id'], ['uid' => $b['uid'], 'self' => true]);
431                 if ($b['contact-id'] != $self['id']) {
432                         return;
433                 }
434         }
435
436         if($b['verb'] == ACTIVITY_LIKE) {
437                 if ($b['deleted'])
438                         pumpio_action($a, $b["uid"], $b["thr-parent"], "unlike");
439                 else
440                         pumpio_action($a, $b["uid"], $b["thr-parent"], "like");
441                 return;
442         }
443
444         if($b['verb'] == ACTIVITY_DISLIKE)
445                 return;
446
447         if (($b['verb'] == ACTIVITY_POST) && ($b['created'] !== $b['edited']) && !$b['deleted'])
448                         pumpio_action($a, $b["uid"], $b["uri"], "update", $b["body"]);
449
450         if (($b['verb'] == ACTIVITY_POST) && $b['deleted'])
451                         pumpio_action($a, $b["uid"], $b["uri"], "delete");
452
453         if($b['deleted'] || ($b['created'] !== $b['edited']))
454                 return;
455
456         // if post comes from pump.io don't send it back
457         if($b['app'] == "pump.io")
458                 return;
459
460         // To-Do;
461         // Support for native shares
462         // http://<hostname>/api/<type>/shares?id=<the-object-id>
463
464         $oauth_token = PConfig::get($b['uid'], "pumpio", "oauth_token");
465         $oauth_token_secret = PConfig::get($b['uid'], "pumpio", "oauth_token_secret");
466         $consumer_key = PConfig::get($b['uid'], "pumpio","consumer_key");
467         $consumer_secret = PConfig::get($b['uid'], "pumpio","consumer_secret");
468
469         $host = PConfig::get($b['uid'], "pumpio", "host");
470         $user = PConfig::get($b['uid'], "pumpio", "user");
471         $public = PConfig::get($b['uid'], "pumpio", "public");
472
473         if($oauth_token && $oauth_token_secret) {
474                 $title = trim($b['title']);
475
476                 $content = BBCode::convert($b['body'], false, 4);
477
478                 $params = [];
479
480                 $params["verb"] = "post";
481
482                 if (!$iscomment) {
483                         $params["object"] = [
484                                                 'objectType' => "note",
485                                                 'content' => $content];
486
487                         if ($title != "")
488                                 $params["object"]["displayName"] = $title;
489
490                         if (count($receiver["to"]))
491                                 $params["to"] = $receiver["to"];
492
493                         if (count($receiver["bto"]))
494                                 $params["bto"] = $receiver["bto"];
495
496                         if (count($receiver["cc"]))
497                                 $params["cc"] = $receiver["cc"];
498
499                         if (count($receiver["bcc"]))
500                                 $params["bcc"] = $receiver["bcc"];
501
502                  } else {
503                         $inReplyTo = ["id" => $orig_post["uri"],
504                                         "objectType" => "note"];
505
506                         if (($orig_post["object-type"] != "") && (strstr($orig_post["object-type"], NAMESPACE_ACTIVITY_SCHEMA)))
507                                 $inReplyTo["objectType"] = str_replace(NAMESPACE_ACTIVITY_SCHEMA, '', $orig_post["object-type"]);
508
509                         $params["object"] = [
510                                                 'objectType' => "comment",
511                                                 'content' => $content,
512                                                 'inReplyTo' => $inReplyTo];
513
514                         if ($title != "")
515                                 $params["object"]["displayName"] = $title;
516                 }
517
518                 $client = new oauth_client_class;
519                 $client->oauth_version = '1.0a';
520                 $client->url_parameters = false;
521                 $client->authorization_header = true;
522                 $client->access_token = $oauth_token;
523                 $client->access_token_secret = $oauth_token_secret;
524                 $client->client_id = $consumer_key;
525                 $client->client_secret = $consumer_secret;
526
527                 $username = $user.'@'.$host;
528                 $url = 'https://'.$host.'/api/user/'.$user.'/feed';
529
530                 if (pumpio_reachable($url))
531                         $success = $client->CallAPI($url, 'POST', $params, ['FailOnAccessError'=>true, 'RequestContentType'=>'application/json'], $user);
532                 else
533                         $success = false;
534
535                 if($success) {
536
537                         if ($user->generator->displayName)
538                                 PConfig::set($b["uid"], "pumpio", "application_name", $user->generator->displayName);
539
540                         $post_id = $user->object->id;
541                         logger('pumpio_send '.$username.': success '.$post_id);
542                         if($post_id && $iscomment) {
543                                 logger('pumpio_send '.$username.': Update extid '.$post_id." for post id ".$b['id']);
544                                 Item::update(['extid' => $post_id], ['id' => $b['id']]);
545                         }
546                 } else {
547                         logger('pumpio_send '.$username.': '.$url.' general error: ' . print_r($user,true));
548
549                         $r = q("SELECT `id` FROM `contact` WHERE `uid` = %d AND `self`", $b['uid']);
550                         if (count($r))
551                                 $a->contact = $r[0]["id"];
552
553                         $s = serialize(['url' => $url, 'item' => $b['id'], 'post' => $params]);
554
555                         Queue::add($a->contact, NETWORK_PUMPIO, $s);
556                         notice(L10n::t('Pump.io post failed. Queued for retry.').EOL);
557                 }
558         }
559 }
560
561 function pumpio_action(&$a, $uid, $uri, $action, $content = "") {
562
563         // Don't do likes and other stuff if you don't import the timeline
564         if (!PConfig::get($uid,'pumpio','import'))
565                 return;
566
567         $ckey    = PConfig::get($uid, 'pumpio', 'consumer_key');
568         $csecret = PConfig::get($uid, 'pumpio', 'consumer_secret');
569         $otoken  = PConfig::get($uid, 'pumpio', 'oauth_token');
570         $osecret = PConfig::get($uid, 'pumpio', 'oauth_token_secret');
571         $hostname = PConfig::get($uid, 'pumpio','host');
572         $username = PConfig::get($uid, "pumpio", "user");
573
574         $r = q("SELECT * FROM `item` WHERE `uri` = '%s' AND `uid` = %d LIMIT 1",
575                                 dbesc($uri),
576                                 intval($uid)
577         );
578
579         if (!count($r))
580                 return;
581
582         $orig_post = $r[0];
583
584         if ($orig_post["extid"] && !strstr($orig_post["extid"], "/proxy/"))
585                 $uri = $orig_post["extid"];
586         else
587                 $uri = $orig_post["uri"];
588
589         if (($orig_post["object-type"] != "") && (strstr($orig_post["object-type"], NAMESPACE_ACTIVITY_SCHEMA)))
590                 $objectType = str_replace(NAMESPACE_ACTIVITY_SCHEMA, '', $orig_post["object-type"]);
591         elseif (strstr($uri, "/api/comment/"))
592                 $objectType = "comment";
593         elseif (strstr($uri, "/api/note/"))
594                 $objectType = "note";
595         elseif (strstr($uri, "/api/image/"))
596                 $objectType = "image";
597
598         $params["verb"] = $action;
599         $params["object"] = ['id' => $uri,
600                                 "objectType" => $objectType,
601                                 "content" => $content];
602
603         $client = new oauth_client_class;
604         $client->oauth_version = '1.0a';
605         $client->authorization_header = true;
606         $client->url_parameters = false;
607
608         $client->client_id = $ckey;
609         $client->client_secret = $csecret;
610         $client->access_token = $otoken;
611         $client->access_token_secret = $osecret;
612
613         $url = 'https://'.$hostname.'/api/user/'.$username.'/feed';
614
615         if (pumpio_reachable($url))
616                 $success = $client->CallAPI($url, 'POST', $params, ['FailOnAccessError'=>true, 'RequestContentType'=>'application/json'], $user);
617         else
618                 $success = false;
619
620         if($success)
621                 logger('pumpio_action '.$username.' '.$action.': success '.$uri);
622         else {
623                 logger('pumpio_action '.$username.' '.$action.': general error: '.$uri.' '.print_r($user,true));
624
625                 $r = q("SELECT `id` FROM `contact` WHERE `uid` = %d AND `self`", $b['uid']);
626                 if (count($r))
627                         $a->contact = $r[0]["id"];
628
629                 $s = serialize(['url' => $url, 'item' => $orig_post["id"], 'post' => $params]);
630
631                 Queue::add($a->contact, NETWORK_PUMPIO, $s);
632                 notice(L10n::t('Pump.io like failed. Queued for retry.').EOL);
633         }
634 }
635
636 function pumpio_sync(&$a) {
637         $r = q("SELECT * FROM `addon` WHERE `installed` = 1 AND `name` = 'pumpio'",
638                 $plugin);
639
640         if (!count($r))
641                 return;
642
643         $last = Config::get('pumpio','last_poll');
644
645         $poll_interval = intval(Config::get('pumpio','poll_interval'));
646         if(! $poll_interval)
647                 $poll_interval = PUMPIO_DEFAULT_POLL_INTERVAL;
648
649         if($last) {
650                 $next = $last + ($poll_interval * 60);
651                 if($next > time()) {
652                         logger('pumpio: poll intervall not reached');
653                         return;
654                 }
655         }
656         logger('pumpio: cron_start');
657
658         $r = q("SELECT * FROM `pconfig` WHERE `cat` = 'pumpio' AND `k` = 'mirror' AND `v` = '1' ORDER BY RAND() ");
659         if(count($r)) {
660                 foreach($r as $rr) {
661                         logger('pumpio: mirroring user '.$rr['uid']);
662                         pumpio_fetchtimeline($a, $rr['uid']);
663                 }
664         }
665
666         $abandon_days = intval(Config::get('system','account_abandon_days'));
667         if ($abandon_days < 1)
668                 $abandon_days = 0;
669
670         $abandon_limit = date(DateTimeFormat::MYSQL, time() - $abandon_days * 86400);
671
672         $r = q("SELECT * FROM `pconfig` WHERE `cat` = 'pumpio' AND `k` = 'import' AND `v` = '1' ORDER BY RAND() ");
673         if(count($r)) {
674                 foreach($r as $rr) {
675                         if ($abandon_days != 0) {
676                                 $user = q("SELECT `login_date` FROM `user` WHERE uid=%d AND `login_date` >= '%s'", $rr['uid'], $abandon_limit);
677                                 if (!count($user)) {
678                                         logger('abandoned account: timeline from user '.$rr['uid'].' will not be imported');
679                                         continue;
680                                 }
681                         }
682
683                         logger('pumpio: importing timeline from user '.$rr['uid']);
684                         pumpio_fetchinbox($a, $rr['uid']);
685
686                         // check for new contacts once a day
687                         $last_contact_check = PConfig::get($rr['uid'],'pumpio','contact_check');
688                         if($last_contact_check)
689                                 $next_contact_check = $last_contact_check + 86400;
690                         else
691                                 $next_contact_check = 0;
692
693                         if($next_contact_check <= time()) {
694                                 pumpio_getallusers($a, $rr["uid"]);
695                                 PConfig::set($rr['uid'],'pumpio','contact_check',time());
696                         }
697                 }
698         }
699
700         logger('pumpio: cron_end');
701
702         Config::set('pumpio','last_poll', time());
703 }
704
705 function pumpio_cron(&$a,$b) {
706         Worker::add(PRIORITY_MEDIUM,"addon/pumpio/pumpio_sync.php");
707 }
708
709 function pumpio_fetchtimeline(&$a, $uid) {
710         $ckey    = PConfig::get($uid, 'pumpio', 'consumer_key');
711         $csecret = PConfig::get($uid, 'pumpio', 'consumer_secret');
712         $otoken  = PConfig::get($uid, 'pumpio', 'oauth_token');
713         $osecret = PConfig::get($uid, 'pumpio', 'oauth_token_secret');
714         $lastdate = PConfig::get($uid, 'pumpio', 'lastdate');
715         $hostname = PConfig::get($uid, 'pumpio','host');
716         $username = PConfig::get($uid, "pumpio", "user");
717
718         //  get the application name for the pump.io app
719         //  1st try personal config, then system config and fallback to the
720         //  hostname of the node if neither one is set.
721         $application_name  = PConfig::get($uid, 'pumpio', 'application_name');
722         if ($application_name == "")
723                 $application_name  = Config::get('pumpio', 'application_name');
724         if ($application_name == "")
725                 $application_name = $a->get_hostname();
726
727         $first_time = ($lastdate == "");
728
729         $client = new oauth_client_class;
730         $client->oauth_version = '1.0a';
731         $client->authorization_header = true;
732         $client->url_parameters = false;
733
734         $client->client_id = $ckey;
735         $client->client_secret = $csecret;
736         $client->access_token = $otoken;
737         $client->access_token_secret = $osecret;
738
739         $url = 'https://'.$hostname.'/api/user/'.$username.'/feed/major';
740
741         logger('pumpio: fetching for user '.$uid.' '.$url.' C:'.$client->client_id.' CS:'.$client->client_secret.' T:'.$client->access_token.' TS:'.$client->access_token_secret);
742
743         $username = $user.'@'.$host;
744
745         if (pumpio_reachable($url))
746                 $success = $client->CallAPI($url, 'GET', [], ['FailOnAccessError'=>true], $user);
747         else
748                 $success = false;
749
750         if (!$success) {
751                 logger('pumpio: error fetching posts for user '.$uid." ".$username." ".print_r($user, true));
752                 return;
753         }
754
755         $posts = array_reverse($user->items);
756
757         $initiallastdate = $lastdate;
758         $lastdate = '';
759
760         if (count($posts)) {
761                 foreach ($posts as $post) {
762                         if ($post->published <= $initiallastdate)
763                                 continue;
764
765                         if ($lastdate < $post->published)
766                                 $lastdate = $post->published;
767
768                         if ($first_time)
769                                 continue;
770
771                         $receiptians = [];
772                         if (@is_array($post->cc))
773                                 $receiptians = array_merge($receiptians, $post->cc);
774
775                         if (@is_array($post->to))
776                                 $receiptians = array_merge($receiptians, $post->to);
777
778                         $public = false;
779                         foreach ($receiptians AS $receiver)
780                                 if (is_string($receiver->objectType))
781                                         if ($receiver->id == "http://activityschema.org/collection/public")
782                                                 $public = true;
783
784                         if ($public && !stristr($post->generator->displayName, $application_name)) {
785                                 require_once('include/html2bbcode.php');
786
787                                 $_SESSION["authenticated"] = true;
788                                 $_SESSION["uid"] = $uid;
789
790                                 unset($_REQUEST);
791                                 $_REQUEST["type"] = "wall";
792                                 $_REQUEST["api_source"] = true;
793                                 $_REQUEST["profile_uid"] = $uid;
794                                 $_REQUEST["source"] = "pump.io";
795
796                                 if (isset($post->object->id)) {
797                                         $_REQUEST['message_id'] = NETWORK_PUMPIO.":".$post->object->id;
798                                 }
799
800                                 if ($post->object->displayName != "")
801                                         $_REQUEST["title"] = html2bbcode($post->object->displayName);
802                                 else
803                                         $_REQUEST["title"] = "";
804
805                                 $_REQUEST["body"] = html2bbcode($post->object->content);
806
807                                 // To-Do: Picture has to be cached and stored locally
808                                 if ($post->object->fullImage->url != "") {
809                                         if ($post->object->fullImage->pump_io->proxyURL != "")
810                                                 $_REQUEST["body"] = "[url=".$post->object->fullImage->pump_io->proxyURL."][img]".$post->object->image->pump_io->proxyURL."[/img][/url]\n".$_REQUEST["body"];
811                                         else
812                                                 $_REQUEST["body"] = "[url=".$post->object->fullImage->url."][img]".$post->object->image->url."[/img][/url]\n".$_REQUEST["body"];
813                                 }
814
815                                 logger('pumpio: posting for user '.$uid);
816
817                                 require_once('mod/item.php');
818
819                                 item_post($a);
820                                 logger('pumpio: posting done - user '.$uid);
821                         }
822                 }
823         }
824
825         if ($lastdate != 0)
826                 PConfig::set($uid,'pumpio','lastdate', $lastdate);
827 }
828
829 function pumpio_dounlike(&$a, $uid, $self, $post, $own_id) {
830         // Searching for the unliked post
831         // Two queries for speed issues
832         $r = q("SELECT * FROM `item` WHERE `uri` = '%s' AND `uid` = %d LIMIT 1",
833                                 dbesc($post->object->id),
834                                 intval($uid)
835                 );
836
837         if (count($r))
838                 $orig_post = $r[0];
839         else {
840                 $r = q("SELECT * FROM `item` WHERE `extid` = '%s' AND `uid` = %d LIMIT 1",
841                                         dbesc($post->object->id),
842                                         intval($uid)
843                         );
844
845                 if (!count($r))
846                         return;
847                 else
848                         $orig_post = $r[0];
849         }
850
851         $contactid = 0;
852
853         if(link_compare($post->actor->url, $own_id)) {
854                 $contactid = $self[0]['id'];
855         } else {
856                 $r = q("SELECT * FROM `contact` WHERE `nurl` = '%s' AND `uid` = %d AND `blocked` = 0 AND `readonly` = 0 LIMIT 1",
857                         dbesc(normalise_link($post->actor->url)),
858                         intval($uid)
859                 );
860
861                 if(count($r))
862                         $contactid = $r[0]['id'];
863
864                 if($contactid == 0)
865                         $contactid = $orig_post['contact-id'];
866         }
867
868         Item::delete(['verb' => ACTIVITY_LIKE, 'uid' => $uid, 'contact-id' => $contactid, 'thr-parent' => $orig_post['uri']]);
869
870         if(count($r))
871                 logger("pumpio_dounlike: unliked existing like. User ".$own_id." ".$uid." Contact: ".$contactid." Url ".$orig_post['uri']);
872         else
873                 logger("pumpio_dounlike: not found. User ".$own_id." ".$uid." Contact: ".$contactid." Url ".$orig_post['uri']);
874 }
875
876 function pumpio_dolike(&$a, $uid, $self, $post, $own_id, $threadcompletion = true) {
877         require_once('include/items.php');
878
879         if ($post->object->id == "") {
880                 logger('Got empty like: '.print_r($post, true), LOGGER_DEBUG);
881                 return;
882         }
883
884         // Searching for the liked post
885         // Two queries for speed issues
886         $r = q("SELECT * FROM `item` WHERE `uri` = '%s' AND `uid` = %d AND `network` = '%s' LIMIT 1",
887                                 dbesc($post->object->id),
888                                 intval($uid),
889                                 dbesc(NETWORK_PUMPIO)
890                 );
891
892         if (count($r))
893                 $orig_post = $r[0];
894         else {
895                 $r = q("SELECT * FROM `item` WHERE `extid` = '%s' AND `uid` = %d AND `network` = '%s' LIMIT 1",
896                                         dbesc($post->object->id),
897                                         intval($uid),
898                                         dbesc(NETWORK_PUMPIO)
899                         );
900
901                 if (!count($r))
902                         return;
903                 else
904                         $orig_post = $r[0];
905         }
906
907         // thread completion
908         if ($threadcompletion)
909                 pumpio_fetchallcomments($a, $uid, $post->object->id);
910
911         $contactid = 0;
912
913         if(link_compare($post->actor->url, $own_id)) {
914                 $contactid = $self[0]['id'];
915                 $post->actor->displayName = $self[0]['name'];
916                 $post->actor->url = $self[0]['url'];
917                 $post->actor->image->url = $self[0]['photo'];
918         } else {
919                 $r = q("SELECT * FROM `contact` WHERE `nurl` = '%s' AND `uid` = %d AND `blocked` = 0 AND `readonly` = 0 LIMIT 1",
920                         dbesc(normalise_link($post->actor->url)),
921                         intval($uid)
922                 );
923
924                 if(count($r))
925                         $contactid = $r[0]['id'];
926
927                 if($contactid == 0)
928                         $contactid = $orig_post['contact-id'];
929         }
930
931         $r = q("SELECT parent FROM `item` WHERE `verb` = '%s' AND `uid` = %d AND `contact-id` = %d AND `thr-parent` = '%s' LIMIT 1",
932                 dbesc(ACTIVITY_LIKE),
933                 intval($uid),
934                 intval($contactid),
935                 dbesc($orig_post['uri'])
936         );
937
938         if(count($r)) {
939                 logger("pumpio_dolike: found existing like. User ".$own_id." ".$uid." Contact: ".$contactid." Url ".$orig_post['uri']);
940                 return;
941         }
942
943         $likedata = [];
944         $likedata['parent'] = $orig_post['id'];
945         $likedata['verb'] = ACTIVITY_LIKE;
946         $likedata['gravity'] = 3;
947         $likedata['uid'] = $uid;
948         $likedata['wall'] = 0;
949         $likedata['uri'] = item_new_uri($a->get_baseurl(), $uid);
950         $likedata['parent-uri'] = $orig_post["uri"];
951         $likedata['contact-id'] = $contactid;
952         $likedata['app'] = $post->generator->displayName;
953         $likedata['author-name'] = $post->actor->displayName;
954         $likedata['author-link'] = $post->actor->url;
955         $likedata['author-avatar'] = $post->actor->image->url;
956
957         $author  = '[url=' . $likedata['author-link'] . ']' . $likedata['author-name'] . '[/url]';
958         $objauthor =  '[url=' . $orig_post['author-link'] . ']' . $orig_post['author-name'] . '[/url]';
959         $post_type = L10n::t('status');
960         $plink = '[url=' . $orig_post['plink'] . ']' . $post_type . '[/url]';
961         $likedata['object-type'] = ACTIVITY_OBJ_NOTE;
962
963         $likedata['body'] = L10n::t('%1$s likes %2$s\'s %3$s', $author, $objauthor, $plink);
964
965         $likedata['object'] = '<object><type>' . ACTIVITY_OBJ_NOTE . '</type><local>1</local>' .
966                 '<id>' . $orig_post['uri'] . '</id><link>' . xmlify('<link rel="alternate" type="text/html" href="' . xmlify($orig_post['plink']) . '" />') . '</link><title>' . $orig_post['title'] . '</title><content>' . $orig_post['body'] . '</content></object>';
967
968         $ret = Item::insert($likedata);
969
970         logger("pumpio_dolike: ".$ret." User ".$own_id." ".$uid." Contact: ".$contactid." Url ".$orig_post['uri']);
971 }
972
973 function pumpio_get_contact($uid, $contact, $no_insert = false) {
974
975         GContact::update(["url" => $contact->url, "network" => NETWORK_PUMPIO, "generation" => 2,
976                         "photo" => $contact->image->url, "name" => $contact->displayName,  "hide" => true,
977                         "nick" => $contact->preferredUsername, "location" => $contact->location->displayName,
978                         "about" => $contact->summary, "addr" => str_replace("acct:", "", $contact->id)]);
979         $cid = Contact::getIdForURL($contact->url, $uid);
980
981         if ($no_insert)
982                 return($cid);
983
984         $r = q("SELECT * FROM `contact` WHERE `uid` = %d AND `nurl` = '%s' LIMIT 1",
985                 intval($uid), dbesc(normalise_link($contact->url)));
986
987         if (!count($r)) {
988                 // create contact record
989                 q("INSERT INTO `contact` (`uid`, `created`, `url`, `nurl`, `addr`, `alias`, `notify`, `poll`,
990                                         `name`, `nick`, `photo`, `network`, `rel`, `priority`,
991                                         `location`, `about`, `writable`, `blocked`, `readonly`, `pending` )
992                                 VALUES (%d, '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', %d, %d, '%s', '%s', %d, 0, 0, 0)",
993                         intval($uid),
994                         dbesc(DateTimeFormat::utcNow()),
995                         dbesc($contact->url),
996                         dbesc(normalise_link($contact->url)),
997                         dbesc(str_replace("acct:", "", $contact->id)),
998                         dbesc(''),
999                         dbesc($contact->id), // What is it for?
1000                         dbesc('pump.io ' . $contact->id), // What is it for?
1001                         dbesc($contact->displayName),
1002                         dbesc($contact->preferredUsername),
1003                         dbesc($contact->image->url),
1004                         dbesc(NETWORK_PUMPIO),
1005                         intval(CONTACT_IS_FRIEND),
1006                         intval(1),
1007                         dbesc($contact->location->displayName),
1008                         dbesc($contact->summary),
1009                         intval(1)
1010                 );
1011
1012                 $r = q("SELECT * FROM `contact` WHERE `nurl` = '%s' AND `uid` = %d LIMIT 1",
1013                         dbesc(normalise_link($contact->url)),
1014                         intval($uid)
1015                         );
1016
1017                 if (!count($r)) {
1018                         return(false);
1019                 }
1020
1021                 $contact_id = $r[0]['id'];
1022
1023                 Group::addMember(User::getDefaultGroup($uid), $contact_id);
1024         } else {
1025                 $contact_id = $r[0]["id"];
1026
1027                 /*      if (DB_UPDATE_VERSION >= "1177")
1028                                 q("UPDATE `contact` SET `location` = '%s',
1029                                                         `about` = '%s'
1030                                                 WHERE `id` = %d",
1031                                         dbesc($contact->location->displayName),
1032                                         dbesc($contact->summary),
1033                                         intval($r[0]['id'])
1034                                 );
1035                 */
1036         }
1037
1038         Contact::updateAvatar($contact->image->url, $uid, $contact_id);
1039
1040         return($contact_id);
1041 }
1042
1043 function pumpio_dodelete(&$a, $uid, $self, $post, $own_id) {
1044
1045         // Two queries for speed issues
1046         $r = q("SELECT * FROM `item` WHERE `uri` = '%s' AND `uid` = %d LIMIT 1",
1047                                 dbesc($post->object->id),
1048                                 intval($uid)
1049                 );
1050
1051         if (count($r))
1052                 return Item::deleteById($r[0]["id"]);
1053
1054         $r = q("SELECT * FROM `item` WHERE `extid` = '%s' AND `uid` = %d LIMIT 1",
1055                                 dbesc($post->object->id),
1056                                 intval($uid)
1057                 );
1058
1059         if (count($r))
1060                 return Item::deleteById($r[0]["id"]);
1061 }
1062
1063 function pumpio_dopost(&$a, $client, $uid, $self, $post, $own_id, $threadcompletion = true) {
1064         require_once('include/items.php');
1065         require_once('include/html2bbcode.php');
1066
1067         if (($post->verb == "like") || ($post->verb == "favorite"))
1068                 return pumpio_dolike($a, $uid, $self, $post, $own_id);
1069
1070         if (($post->verb == "unlike") || ($post->verb == "unfavorite"))
1071                 return pumpio_dounlike($a, $uid, $self, $post, $own_id);
1072
1073         if ($post->verb == "delete")
1074                 return pumpio_dodelete($a, $uid, $self, $post, $own_id);
1075
1076         if ($post->verb != "update") {
1077                 // Two queries for speed issues
1078                 $r = q("SELECT * FROM `item` WHERE `uri` = '%s' AND `uid` = %d LIMIT 1",
1079                                         dbesc($post->object->id),
1080                                         intval($uid)
1081                         );
1082
1083                 if (count($r))
1084                         return false;
1085
1086                 $r = q("SELECT * FROM `item` WHERE `extid` = '%s' AND `uid` = %d LIMIT 1",
1087                                         dbesc($post->object->id),
1088                                         intval($uid)
1089                         );
1090
1091                 if (count($r))
1092                         return false;
1093         }
1094
1095         // Only handle these three types
1096         if (!strstr("post|share|update", $post->verb))
1097                 return false;
1098
1099         $receiptians = [];
1100         if (@is_array($post->cc))
1101                 $receiptians = array_merge($receiptians, $post->cc);
1102
1103         if (@is_array($post->to))
1104                 $receiptians = array_merge($receiptians, $post->to);
1105
1106         foreach ($receiptians AS $receiver)
1107                 if (is_string($receiver->objectType))
1108                         if ($receiver->id == "http://activityschema.org/collection/public")
1109                                 $public = true;
1110
1111         $postarray = [];
1112         $postarray['network'] = NETWORK_PUMPIO;
1113         $postarray['gravity'] = 0;
1114         $postarray['uid'] = $uid;
1115         $postarray['wall'] = 0;
1116         $postarray['uri'] = $post->object->id;
1117         $postarray['object-type'] = NAMESPACE_ACTIVITY_SCHEMA.strtolower($post->object->objectType);
1118
1119         if ($post->object->objectType != "comment") {
1120                 $contact_id = pumpio_get_contact($uid, $post->actor);
1121
1122                 if (!$contact_id)
1123                         $contact_id = $self[0]['id'];
1124
1125                 $postarray['parent-uri'] = $post->object->id;
1126
1127                 if (!$public) {
1128                         $postarray['private'] = 1;
1129                         $postarray['allow_cid'] = '<' . $self[0]['id'] . '>';
1130                 }
1131         } else {
1132                 $contact_id = pumpio_get_contact($uid, $post->actor, true);
1133
1134                 if (link_compare($post->actor->url, $own_id)) {
1135                         $contact_id = $self[0]['id'];
1136                         $post->actor->displayName = $self[0]['name'];
1137                         $post->actor->url = $self[0]['url'];
1138                         $post->actor->image->url = $self[0]['photo'];
1139                 } elseif ($contact_id == 0) {
1140                         // Take an existing contact, the contact of the note or - as a fallback - the id of the user
1141                         $r = q("SELECT * FROM `contact` WHERE `nurl` = '%s' AND `uid` = %d AND `blocked` = 0 AND `readonly` = 0 LIMIT 1",
1142                                 dbesc(normalise_link($post->actor->url)),
1143                                 intval($uid)
1144                         );
1145
1146                         if(count($r))
1147                                 $contact_id = $r[0]['id'];
1148                         else {
1149                                 $r = q("SELECT * FROM `contact` WHERE `nurl` = '%s' AND `uid` = %d AND `blocked` = 0 AND `readonly` = 0 LIMIT 1",
1150                                         dbesc(normalise_link($post->actor->url)),
1151                                         intval($uid)
1152                                 );
1153
1154                                 if(count($r))
1155                                         $contact_id = $r[0]['id'];
1156                                 else
1157                                         $contact_id = $self[0]['id'];
1158                         }
1159                 }
1160
1161                 $reply = new stdClass;
1162                 $reply->verb = "note";
1163                 $reply->cc = $post->cc;
1164                 $reply->to = $post->to;
1165                 $reply->object = new stdClass;
1166                 $reply->object->objectType = $post->object->inReplyTo->objectType;
1167                 $reply->object->content = $post->object->inReplyTo->content;
1168                 $reply->object->id = $post->object->inReplyTo->id;
1169                 $reply->actor = $post->object->inReplyTo->author;
1170                 $reply->url = $post->object->inReplyTo->url;
1171                 $reply->generator = new stdClass;
1172                 $reply->generator->displayName = "pumpio";
1173                 $reply->published = $post->object->inReplyTo->published;
1174                 $reply->received = $post->object->inReplyTo->updated;
1175                 $reply->url = $post->object->inReplyTo->url;
1176                 pumpio_dopost($a, $client, $uid, $self, $reply, $own_id, false);
1177
1178                 $postarray['parent-uri'] = $post->object->inReplyTo->id;
1179         }
1180
1181         if ($post->object->pump_io->proxyURL)
1182                 $postarray['extid'] = $post->object->pump_io->proxyURL;
1183
1184         $postarray['contact-id'] = $contact_id;
1185         $postarray['verb'] = ACTIVITY_POST;
1186         $postarray['owner-name'] = $post->actor->displayName;
1187         $postarray['owner-link'] = $post->actor->url;
1188         $postarray['owner-avatar'] = $post->actor->image->url;
1189         $postarray['author-name'] = $post->actor->displayName;
1190         $postarray['author-link'] = $post->actor->url;
1191         $postarray['author-avatar'] = $post->actor->image->url;
1192         $postarray['plink'] = $post->object->url;
1193         $postarray['app'] = $post->generator->displayName;
1194         $postarray['body'] = html2bbcode($post->object->content);
1195         $postarray['object'] = json_encode($post);
1196
1197         if ($post->object->fullImage->url != "")
1198                 $postarray["body"] = "[url=".$post->object->fullImage->url."][img]".$post->object->image->url."[/img][/url]\n".$postarray["body"];
1199
1200         if ($post->object->displayName != "")
1201                 $postarray['title'] = $post->object->displayName;
1202
1203         $postarray['created'] = DateTimeFormat::utc($post->published);
1204         if (isset($post->updated))
1205                 $postarray['edited'] = DateTimeFormat::utc($post->updated);
1206         elseif (isset($post->received))
1207                 $postarray['edited'] = DateTimeFormat::utc($post->received);
1208         else
1209                 $postarray['edited'] = $postarray['created'];
1210
1211         if ($post->verb == "share") {
1212                 if (!intval(Config::get('system','wall-to-wall_share'))) {
1213                         if (isset($post->object->author->displayName) && ($post->object->author->displayName != ""))
1214                                 $share_author = $post->object->author->displayName;
1215                         elseif (isset($post->object->author->preferredUsername) && ($post->object->author->preferredUsername != ""))
1216                                 $share_author = $post->object->author->preferredUsername;
1217                         else
1218                                 $share_author = $post->object->author->url;
1219
1220                         $postarray['body'] = share_header($share_author, $post->object->author->url,
1221                                                         $post->object->author->image->url, "",
1222                                                         DateTimeFormat::utc($post->object->created),
1223                                                         $post->links->self->href).
1224                                                 $postarray['body']."[/share]";
1225
1226                         /*
1227                         $postarray['body'] = "[share author='".$share_author.
1228                                         "' profile='".$post->object->author->url.
1229                                         "' avatar='".$post->object->author->image->url.
1230                                         "' posted='".DateTimeFormat::convert($post->object->created, 'UTC', 'UTC', ).
1231                                         "' link='".$post->links->self->href."']".$postarray['body']."[/share]";
1232                         */
1233                 } else {
1234                         // Let shares look like wall-to-wall posts
1235                         $postarray['author-name'] = $post->object->author->displayName;
1236                         $postarray['author-link'] = $post->object->author->url;
1237                         $postarray['author-avatar'] = $post->object->author->image->url;
1238                 }
1239         }
1240
1241         if (trim($postarray['body']) == "")
1242                 return false;
1243
1244         $top_item = Item::insert($postarray);
1245         $postarray["id"] = $top_item;
1246
1247         if (($top_item == 0) && ($post->verb == "update")) {
1248                 $fields = ['title' => $postarray["title"], 'body' => $postarray["body"], 'changed' => $postarray["edited"]];
1249                 $condition = ['uri' => $postarray["uri"], 'uid' => $uid];
1250                 Item::update($fields, $condition);
1251         }
1252
1253         if ($post->object->objectType == "comment") {
1254
1255                 if ($threadcompletion)
1256                         pumpio_fetchallcomments($a, $uid, $postarray['parent-uri']);
1257
1258                 $user = q("SELECT * FROM `user` WHERE `uid` = %d AND `account_expired` = 0 LIMIT 1",
1259                                 intval($uid)
1260                         );
1261
1262                 if(!count($user))
1263                         return $top_item;
1264
1265                 $importer_url = $a->get_baseurl() . '/profile/' . $user[0]['nickname'];
1266
1267                 if (link_compare($own_id, $postarray['author-link']))
1268                         return $top_item;
1269
1270                 if (!function_exists("check_item_notification")) {
1271                         $myconv = q("SELECT `author-link`, `author-avatar`, `parent` FROM `item` WHERE `parent-uri` = '%s' AND `uid` = %d AND `parent` != 0 AND `deleted` = 0",
1272                                         dbesc($postarray['parent-uri']),
1273                                         intval($uid)
1274                                         );
1275
1276                         if(count($myconv)) {
1277
1278                                 foreach($myconv as $conv) {
1279                                         // now if we find a match, it means we're in this conversation
1280
1281                                         if(!link_compare($conv['author-link'],$importer_url) && !link_compare($conv['author-link'],$own_id))
1282                                                 continue;
1283
1284                                         require_once('include/enotify.php');
1285
1286                                         $conv_parent = $conv['parent'];
1287
1288                                         notification([
1289                                                 'type'         => NOTIFY_COMMENT,
1290                                                 'notify_flags' => $user[0]['notify-flags'],
1291                                                 'language'     => $user[0]['language'],
1292                                                 'to_name'      => $user[0]['username'],
1293                                                 'to_email'     => $user[0]['email'],
1294                                                 'uid'          => $user[0]['uid'],
1295                                                 'item'         => $postarray,
1296                                                 'link'         => $a->get_baseurl().'/display/'.urlencode(Item::getGuidById($top_item)),
1297                                                 'source_name'  => $postarray['author-name'],
1298                                                 'source_link'  => $postarray['author-link'],
1299                                                 'source_photo' => $postarray['author-avatar'],
1300                                                 'verb'         => ACTIVITY_POST,
1301                                                 'otype'        => 'item',
1302                                                 'parent'       => $conv_parent,
1303                                                 ]);
1304
1305                                         // only send one notification
1306                                         break;
1307                                 }
1308                         }
1309                 }
1310         }
1311
1312         return $top_item;
1313 }
1314
1315 function pumpio_fetchinbox(&$a, $uid) {
1316
1317         $ckey    = PConfig::get($uid, 'pumpio', 'consumer_key');
1318         $csecret = PConfig::get($uid, 'pumpio', 'consumer_secret');
1319         $otoken  = PConfig::get($uid, 'pumpio', 'oauth_token');
1320         $osecret = PConfig::get($uid, 'pumpio', 'oauth_token_secret');
1321         $lastdate = PConfig::get($uid, 'pumpio', 'lastdate');
1322         $hostname = PConfig::get($uid, 'pumpio','host');
1323         $username = PConfig::get($uid, "pumpio", "user");
1324
1325         $own_id = "https://".$hostname."/".$username;
1326
1327         $self = q("SELECT * FROM `contact` WHERE `self` = 1 AND `uid` = %d LIMIT 1",
1328                 intval($uid));
1329
1330         $lastitems = q("SELECT `uri` FROM `thread`
1331                         INNER JOIN `item` ON `item`.`id` = `thread`.`iid`
1332                         WHERE `thread`.`network` = '%s' AND `thread`.`uid` = %d AND `item`.`extid` != ''
1333                         ORDER BY `thread`.`commented` DESC LIMIT 10",
1334                                 dbesc(NETWORK_PUMPIO),
1335                                 intval($uid)
1336                         );
1337
1338         $client = new oauth_client_class;
1339         $client->oauth_version = '1.0a';
1340         $client->authorization_header = true;
1341         $client->url_parameters = false;
1342
1343         $client->client_id = $ckey;
1344         $client->client_secret = $csecret;
1345         $client->access_token = $otoken;
1346         $client->access_token_secret = $osecret;
1347
1348         $last_id = PConfig::get($uid,'pumpio','last_id');
1349
1350         $url = 'https://'.$hostname.'/api/user/'.$username.'/inbox';
1351
1352         if ($last_id != "")
1353                 $url .= '?since='.urlencode($last_id);
1354
1355         if (pumpio_reachable($url))
1356                 $success = $client->CallAPI($url, 'GET', [], ['FailOnAccessError'=>true], $user);
1357         else
1358                 $success = false;
1359
1360         if ($user->items) {
1361             $posts = array_reverse($user->items);
1362
1363             if (count($posts))
1364                     foreach ($posts as $post) {
1365                             $last_id = $post->id;
1366                             pumpio_dopost($a, $client, $uid, $self, $post, $own_id, true);
1367                     }
1368         }
1369
1370         foreach ($lastitems AS $item)
1371                 pumpio_fetchallcomments($a, $uid, $item["uri"]);
1372
1373         PConfig::set($uid,'pumpio','last_id', $last_id);
1374 }
1375
1376 function pumpio_getallusers(&$a, $uid) {
1377         $ckey    = PConfig::get($uid, 'pumpio', 'consumer_key');
1378         $csecret = PConfig::get($uid, 'pumpio', 'consumer_secret');
1379         $otoken  = PConfig::get($uid, 'pumpio', 'oauth_token');
1380         $osecret = PConfig::get($uid, 'pumpio', 'oauth_token_secret');
1381         $hostname = PConfig::get($uid, 'pumpio','host');
1382         $username = PConfig::get($uid, "pumpio", "user");
1383
1384         $client = new oauth_client_class;
1385         $client->oauth_version = '1.0a';
1386         $client->authorization_header = true;
1387         $client->url_parameters = false;
1388
1389         $client->client_id = $ckey;
1390         $client->client_secret = $csecret;
1391         $client->access_token = $otoken;
1392         $client->access_token_secret = $osecret;
1393
1394         $url = 'https://'.$hostname.'/api/user/'.$username.'/following';
1395
1396         if (pumpio_reachable($url))
1397                 $success = $client->CallAPI($url, 'GET', [], ['FailOnAccessError'=>true], $users);
1398         else
1399                 $success = false;
1400
1401         if ($users->totalItems > count($users->items)) {
1402                 $url = 'https://'.$hostname.'/api/user/'.$username.'/following?count='.$users->totalItems;
1403
1404                 if (pumpio_reachable($url))
1405                         $success = $client->CallAPI($url, 'GET', [], ['FailOnAccessError'=>true], $users);
1406                 else
1407                         $success = false;
1408         }
1409
1410         if (is_array($users->items)) {
1411                 foreach ($users->items AS $user) {
1412                         pumpio_get_contact($uid, $user);
1413                 }
1414         }
1415 }
1416
1417 function pumpio_queue_hook(&$a,&$b) {
1418
1419         $qi = q("SELECT * FROM `queue` WHERE `network` = '%s'",
1420                 dbesc(NETWORK_PUMPIO)
1421         );
1422         if(! count($qi))
1423                 return;
1424
1425         foreach($qi as $x) {
1426                 if($x['network'] !== NETWORK_PUMPIO)
1427                         continue;
1428
1429                 logger('pumpio_queue: run');
1430
1431                 $r = q("SELECT `user`.* FROM `user` LEFT JOIN `contact` ON `contact`.`uid` = `user`.`uid`
1432                         WHERE `contact`.`self` = 1 AND `contact`.`id` = %d LIMIT 1",
1433                         intval($x['cid'])
1434                 );
1435                 if(! count($r))
1436                         continue;
1437
1438                 $userdata = $r[0];
1439
1440                 //logger('pumpio_queue: fetching userdata '.print_r($userdata, true));
1441
1442                 $oauth_token = PConfig::get($userdata['uid'], "pumpio", "oauth_token");
1443                 $oauth_token_secret = PConfig::get($userdata['uid'], "pumpio", "oauth_token_secret");
1444                 $consumer_key = PConfig::get($userdata['uid'], "pumpio","consumer_key");
1445                 $consumer_secret = PConfig::get($userdata['uid'], "pumpio","consumer_secret");
1446
1447                 $host = PConfig::get($userdata['uid'], "pumpio", "host");
1448                 $user = PConfig::get($userdata['uid'], "pumpio", "user");
1449
1450                 $success = false;
1451
1452                 if ($oauth_token && $oauth_token_secret &&
1453                         $consumer_key && $consumer_secret) {
1454                         $username = $user.'@'.$host;
1455
1456                         logger('pumpio_queue: able to post for user '.$username);
1457
1458                         $z = unserialize($x['content']);
1459
1460                         $client = new oauth_client_class;
1461                         $client->oauth_version = '1.0a';
1462                         $client->url_parameters = false;
1463                         $client->authorization_header = true;
1464                         $client->access_token = $oauth_token;
1465                         $client->access_token_secret = $oauth_token_secret;
1466                         $client->client_id = $consumer_key;
1467                         $client->client_secret = $consumer_secret;
1468
1469                         if (pumpio_reachable($z['url']))
1470                                 $success = $client->CallAPI($z['url'], 'POST', $z['post'], ['FailOnAccessError'=>true, 'RequestContentType'=>'application/json'], $user);
1471                         else
1472                                 $success = false;
1473
1474                         if($success) {
1475                                 $post_id = $user->object->id;
1476                                 logger('pumpio_queue: send '.$username.': success '.$post_id);
1477                                 if($post_id && $iscomment) {
1478                                         logger('pumpio_send '.$username.': Update extid '.$post_id." for post id ".$z['item']);
1479                                         Item::update(['extid' => $post_id], ['id' => $z['item']]);
1480                                 }
1481                                 Queue::removeItem($x['id']);
1482                         } else
1483                                 logger('pumpio_queue: send '.$username.': '.$url.' general error: ' . print_r($user,true));
1484                 } else
1485                         logger("pumpio_queue: Error getting tokens for user ".$userdata['uid']);
1486
1487                 if (!$success) {
1488                         logger('pumpio_queue: delayed');
1489                         Queue::updateTime($x['id']);
1490                 }
1491         }
1492 }
1493
1494 function pumpio_getreceiver(&$a, $b) {
1495
1496         $receiver = [];
1497
1498         if (!$b["private"]) {
1499
1500                 if(! strstr($b['postopts'],'pumpio'))
1501                         return $receiver;
1502
1503                 $public = PConfig::get($b['uid'], "pumpio", "public");
1504
1505                 if ($public)
1506                         $receiver["to"][] = [
1507                                                 "objectType" => "collection",
1508                                                 "id" => "http://activityschema.org/collection/public"];
1509         } else {
1510                 $cids = explode("><", $b["allow_cid"]);
1511                 $gids = explode("><", $b["allow_gid"]);
1512
1513                 foreach ($cids AS $cid) {
1514                         $cid = trim($cid, " <>");
1515
1516                         $r = q("SELECT `name`, `nick`, `url` FROM `contact` WHERE `id` = %d AND `uid` = %d AND `network` = '%s' AND `blocked` = 0 AND `readonly` = 0 LIMIT 1",
1517                                 intval($cid),
1518                                 intval($b["uid"]),
1519                                 dbesc(NETWORK_PUMPIO)
1520                                 );
1521
1522                         if (count($r)) {
1523                                 $receiver["bcc"][] = [
1524                                                         "displayName" => $r[0]["name"],
1525                                                         "objectType" => "person",
1526                                                         "preferredUsername" => $r[0]["nick"],
1527                                                         "url" => $r[0]["url"]];
1528                         }
1529                 }
1530                 foreach ($gids AS $gid) {
1531                         $gid = trim($gid, " <>");
1532
1533                         $r = q("SELECT `contact`.`name`, `contact`.`nick`, `contact`.`url`, `contact`.`network` ".
1534                                 "FROM `group_member`, `contact` WHERE `group_member`.`gid` = %d ".
1535                                 "AND `contact`.`id` = `group_member`.`contact-id` AND `contact`.`network` = '%s'",
1536                                         intval($gid),
1537                                         dbesc(NETWORK_PUMPIO)
1538                                 );
1539
1540                         foreach ($r AS $row)
1541                                 $receiver["bcc"][] = [
1542                                                         "displayName" => $row["name"],
1543                                                         "objectType" => "person",
1544                                                         "preferredUsername" => $row["nick"],
1545                                                         "url" => $row["url"]];
1546                 }
1547         }
1548
1549         if ($b["inform"] != "") {
1550
1551                 $inform = explode(",", $b["inform"]);
1552
1553                 foreach ($inform AS $cid) {
1554                         if (substr($cid, 0, 4) != "cid:")
1555                                 continue;
1556
1557                         $cid = str_replace("cid:", "", $cid);
1558
1559                         $r = q("SELECT `name`, `nick`, `url` FROM `contact` WHERE `id` = %d AND `uid` = %d AND `network` = '%s' AND `blocked` = 0 AND `readonly` = 0 LIMIT 1",
1560                                 intval($cid),
1561                                 intval($b["uid"]),
1562                                 dbesc(NETWORK_PUMPIO)
1563                                 );
1564
1565                         if (count($r)) {
1566                                         $receiver["to"][] = [
1567                                                                 "displayName" => $r[0]["name"],
1568                                                                 "objectType" => "person",
1569                                                                 "preferredUsername" => $r[0]["nick"],
1570                                                                 "url" => $r[0]["url"]];
1571                         }
1572                 }
1573         }
1574
1575         return $receiver;
1576 }
1577
1578 function pumpio_fetchallcomments(&$a, $uid, $id) {
1579         $ckey    = PConfig::get($uid, 'pumpio', 'consumer_key');
1580         $csecret = PConfig::get($uid, 'pumpio', 'consumer_secret');
1581         $otoken  = PConfig::get($uid, 'pumpio', 'oauth_token');
1582         $osecret = PConfig::get($uid, 'pumpio', 'oauth_token_secret');
1583         $hostname = PConfig::get($uid, 'pumpio','host');
1584         $username = PConfig::get($uid, "pumpio", "user");
1585
1586         logger("pumpio_fetchallcomments: completing comment for user ".$uid." post id ".$id);
1587
1588         $own_id = "https://".$hostname."/".$username;
1589
1590         $self = q("SELECT * FROM `contact` WHERE `self` = 1 AND `uid` = %d LIMIT 1",
1591                 intval($uid));
1592
1593         // Fetching the original post
1594         $r = q("SELECT `extid` FROM `item` WHERE `uri` = '%s' AND `uid` = %d AND `extid` != '' LIMIT 1",
1595                         dbesc($id),
1596                         intval($uid)
1597                 );
1598
1599         if (!count($r))
1600                 return false;
1601
1602         $url = $r[0]["extid"];
1603
1604         $client = new oauth_client_class;
1605         $client->oauth_version = '1.0a';
1606         $client->authorization_header = true;
1607         $client->url_parameters = false;
1608
1609         $client->client_id = $ckey;
1610         $client->client_secret = $csecret;
1611         $client->access_token = $otoken;
1612         $client->access_token_secret = $osecret;
1613
1614         logger("pumpio_fetchallcomments: fetching comment for user ".$uid." url ".$url);
1615
1616         if (pumpio_reachable($url))
1617                 $success = $client->CallAPI($url, 'GET', [], ['FailOnAccessError'=>true], $item);
1618         else
1619                 $success = false;
1620
1621         if (!$success)
1622                 return;
1623
1624         if ($item->likes->totalItems != 0) {
1625                 foreach ($item->likes->items AS $post) {
1626                         $like = new stdClass;
1627                         $like->object = new stdClass;
1628                         $like->object->id = $item->id;
1629                         $like->actor = new stdClass;
1630                         $like->actor->displayName = $item->displayName;
1631                         $like->actor->preferredUsername = $item->preferredUsername;
1632                         $like->actor->url = $item->url;
1633                         $like->actor->image = $item->image;
1634                         $like->generator = new stdClass;
1635                         $like->generator->displayName = "pumpio";
1636                         pumpio_dolike($a, $uid, $self, $post, $own_id, false);
1637                 }
1638         }
1639
1640         if ($item->replies->totalItems == 0)
1641                 return;
1642
1643         foreach ($item->replies->items AS $item) {
1644                 if ($item->id == $id)
1645                         continue;
1646
1647                 // Checking if the comment already exists - Two queries for speed issues
1648                 $r = q("SELECT extid FROM `item` WHERE `uri` = '%s' AND `uid` = %d LIMIT 1",
1649                                 dbesc($item->id),
1650                                 intval($uid)
1651                         );
1652
1653                 if (count($r))
1654                         continue;
1655
1656                 $r = q("SELECT extid FROM `item` WHERE `extid` = '%s' AND `uid` = %d LIMIT 1",
1657                                 dbesc($item->id),
1658                                 intval($uid)
1659                         );
1660
1661                 if (count($r))
1662                         continue;
1663
1664                 $post = new stdClass;
1665                 $post->verb = "post";
1666                 $post->actor = $item->author;
1667                 $post->published = $item->published;
1668                 $post->received = $item->updated;
1669                 $post->generator = new stdClass;
1670                 $post->generator->displayName = "pumpio";
1671                 // To-Do: Check for public post
1672
1673                 unset($item->author);
1674                 unset($item->published);
1675                 unset($item->updated);
1676
1677                 $post->object = $item;
1678
1679                 logger("pumpio_fetchallcomments: posting comment ".$post->object->id." ".print_r($post, true));
1680                 pumpio_dopost($a, $client, $uid, $self, $post, $own_id, false);
1681         }
1682 }
1683
1684
1685 function pumpio_reachable($url) {
1686         $data = Network::curl($url, false, $redirects, ['timeout'=>10]);
1687         return(intval($data['return_code']) != 0);
1688 }
1689
1690 /*
1691 To-Do:
1692  - edit own notes
1693  - delete own notes
1694 */