2010-07-01 19:48:07 -04:00
< ? php
2017-12-01 18:13:39 -05:00
/**
* @ file mod / item . php
*/
2010-07-01 19:48:07 -04:00
2017-03-30 15:32:12 -04:00
/*
2011-02-04 16:37:04 -05:00
* This is the POST destination for most all locally posted
2013-12-26 19:58:21 -05:00
* text stuff . This function handles status , wall - to - wall status ,
* local comments , and remote coments that are posted on this site
2011-02-04 16:37:04 -05:00
* ( as opposed to being delivered in a feed ) .
2013-12-26 19:58:21 -05:00
* Also processed here are posts and comments coming through the
* statusnet / twitter API .
2017-03-30 15:32:12 -04:00
*
2013-12-26 19:58:21 -05:00
* All of these become an " item " which is our basic unit of
2011-02-04 16:37:04 -05:00
* information .
2013-12-26 19:58:21 -05:00
*/
2017-04-30 00:07:00 -04:00
use Friendica\App ;
2017-11-06 21:22:52 -05:00
use Friendica\Core\Config ;
2017-08-26 02:04:21 -04:00
use Friendica\Core\System ;
2017-11-05 07:15:53 -05:00
use Friendica\Core\Worker ;
2017-11-07 22:57:46 -05:00
use Friendica\Database\DBM ;
2017-12-07 09:04:24 -05:00
use Friendica\Model\Contact ;
2017-12-07 09:09:28 -05:00
use Friendica\Model\GContact ;
2018-01-09 16:13:45 -05:00
use Friendica\Model\Item ;
2017-11-06 21:22:52 -05:00
use Friendica\Network\Probe ;
2017-11-07 19:37:53 -05:00
use Friendica\Protocol\Diaspora ;
2017-12-01 14:41:27 -05:00
use Friendica\Protocol\Email ;
2017-11-20 15:37:30 -05:00
use Friendica\Util\Emailer ;
2017-04-30 00:07:00 -04:00
2017-03-30 15:32:12 -04:00
require_once 'include/enotify.php' ;
require_once 'include/tags.php' ;
require_once 'include/threads.php' ;
require_once 'include/text.php' ;
require_once 'include/items.php' ;
2011-08-28 22:22:27 -04:00
2017-01-09 07:14:25 -05:00
function item_post ( App $a ) {
2018-01-19 02:02:43 -05:00
if ( ! local_user () && ! remote_user ()) {
2010-07-01 19:48:07 -04:00
return ;
2017-03-30 15:32:12 -04:00
}
2010-07-01 19:48:07 -04:00
2017-03-31 14:30:21 -04:00
require_once 'include/security.php' ;
2010-07-01 19:48:07 -04:00
2010-10-31 23:36:59 -04:00
$uid = local_user ();
2010-07-26 07:22:19 -04:00
2017-03-30 15:32:12 -04:00
if ( x ( $_REQUEST , 'dropitems' )) {
$arr_drop = explode ( ',' , $_REQUEST [ 'dropitems' ]);
2011-06-15 23:43:39 -04:00
drop_items ( $arr_drop );
2018-01-15 08:05:12 -05:00
$json = [ 'success' => 1 ];
2011-06-16 03:38:41 -04:00
echo json_encode ( $json );
2011-06-15 23:43:39 -04:00
killme ();
}
2012-01-12 17:20:21 -05:00
call_hooks ( 'post_local_start' , $_REQUEST );
2012-01-15 16:57:00 -05:00
logger ( 'postvars ' . print_r ( $_REQUEST , true ), LOGGER_DATA );
2012-01-09 21:52:49 -05:00
2018-01-20 08:54:14 -05:00
$api_source = defaults ( $_REQUEST , 'api_source' , false );
2013-05-09 04:15:22 -04:00
2017-03-30 15:32:12 -04:00
$message_id = (( x ( $_REQUEST , 'message_id' ) && $api_source ) ? strip_tags ( $_REQUEST [ 'message_id' ]) : '' );
2013-05-09 04:15:22 -04:00
2018-01-20 08:54:14 -05:00
$return_path = defaults ( $_REQUEST , 'return' , '' );
$preview = intval ( defaults ( $_REQUEST , 'preview' , 0 ));
2011-07-31 23:01:00 -04:00
2017-03-30 15:32:12 -04:00
/*
* Check for doubly - submitted posts , and reject duplicates
* Note that we have to ignore previews , otherwise nothing will post
* after it ' s been previewed
*/
if ( ! $preview && x ( $_REQUEST , 'post_id_random' )) {
if ( x ( $_SESSION , 'post-random' ) && $_SESSION [ 'post-random' ] == $_REQUEST [ 'post_id_random' ]) {
2012-11-01 19:14:42 -04:00
logger ( " item post: duplicate post " , LOGGER_DEBUG );
2017-08-26 03:32:10 -04:00
item_post_return ( System :: baseUrl (), $api_source , $return_path );
2017-03-30 15:32:12 -04:00
} else {
2012-11-01 19:14:42 -04:00
$_SESSION [ 'post-random' ] = $_REQUEST [ 'post_id_random' ];
2016-12-20 15:15:53 -05:00
}
2012-11-01 19:14:42 -04:00
}
2017-03-30 15:32:12 -04:00
// Is this a reply to something?
2018-01-20 08:54:14 -05:00
$thr_parent = intval ( defaults ( $_REQUEST , 'parent' , 0 ));
$thr_parent_uri = trim ( defaults ( $_REQUEST , 'parent_uri' , '' ));
2010-07-13 19:09:53 -04:00
2018-01-20 08:54:14 -05:00
$thr_parent_contact = null ;
$parent = 0 ;
2010-07-13 19:09:53 -04:00
$parent_item = null ;
2018-01-20 08:54:14 -05:00
$parent_user = null ;
2011-02-08 18:08:07 -05:00
$parent_contact = null ;
2018-01-20 08:54:14 -05:00
2014-08-07 02:02:24 -04:00
$objecttype = null ;
2018-01-19 17:46:24 -05:00
$profile_uid = defaults ( $_REQUEST , 'profile_uid' , local_user ());
2010-07-13 19:09:53 -04:00
2018-01-20 08:54:14 -05:00
if ( $thr_parent || $thr_parent_uri ) {
if ( $thr_parent ) {
$parent_item = dba :: selectFirst ( 'item' , [], [ 'id' => $thr_parent ]);
} elseif ( $thr_parent_uri ) {
$parent_item = dba :: selectFirst ( 'item' , [], [ 'uri' => $thr_parent_uri , 'uid' => $profile_uid ]);
}
2011-08-03 19:29:25 -04:00
2018-01-20 08:54:14 -05:00
// if this isn't the real parent of the conversation, find it
if ( DBM :: is_result ( $parent_item )) {
2014-08-07 02:02:24 -04:00
2018-01-20 08:54:14 -05:00
// The URI and the contact is taken from the direct parent which needn't to be the top parent
$thr_parent_uri = $parent_item [ 'uri' ];
$thr_parent_contact = Contact :: getDetailsByURL ( $parent_item [ " author-link " ]);
2011-08-03 19:29:25 -04:00
2018-01-20 08:54:14 -05:00
if ( $parent_item [ 'id' ] != $parent_item [ 'parent' ]) {
$parent_item = dba :: selectFirst ( 'item' , [], [ 'id' => $parent_item [ 'parent' ]]);
2011-07-31 23:01:00 -04:00
}
2012-07-23 07:58:47 -04:00
}
2011-07-31 20:52:36 -04:00
2018-01-20 08:54:14 -05:00
if ( ! DBM :: is_result ( $parent_item )) {
2018-01-09 15:03:00 -05:00
notice ( t ( 'Unable to locate original post.' ) . EOL );
2017-03-31 14:47:23 -04:00
if ( x ( $_REQUEST , 'return' )) {
2016-10-29 16:17:33 -04:00
goaway ( $return_path );
2016-12-20 15:15:53 -05:00
}
2011-02-16 23:25:10 -05:00
killme ();
2010-07-13 19:09:53 -04:00
}
2018-01-20 08:54:14 -05:00
2018-01-11 14:17:40 -05:00
$parent = $parent_item [ 'id' ];
2018-01-19 02:02:43 -05:00
$parent_user = $parent_item [ 'uid' ];
2011-07-31 23:01:00 -04:00
2018-01-20 08:54:14 -05:00
$parent_contact = Contact :: getDetailsByURL ( $parent_item [ " author-link " ]);
2015-01-11 18:14:51 -05:00
2018-01-20 08:54:14 -05:00
$objecttype = ACTIVITY_OBJ_COMMENT ;
2016-02-14 09:08:49 -05:00
2018-01-20 08:54:14 -05:00
if ( ! x ( $_REQUEST , 'type' )) {
$_REQUEST [ 'type' ] = 'net-comment' ;
2011-02-08 18:08:07 -05:00
}
2010-07-13 19:09:53 -04:00
}
2017-03-30 15:32:12 -04:00
if ( $parent ) {
logger ( 'mod_item: item_post parent=' . $parent );
}
2011-07-31 20:52:36 -04:00
2018-01-20 08:54:14 -05:00
$post_id = intval ( defaults ( $_REQUEST , 'post_id' , 0 ));
$app = strip_tags ( defaults ( $_REQUEST , 'source' , '' ));
$extid = strip_tags ( defaults ( $_REQUEST , 'extid' , '' ));
$object = defaults ( $_REQUEST , 'object' , '' );
2010-08-14 10:55:18 -04:00
2018-01-19 02:02:43 -05:00
// Ensure that the user id in a thread always stay the same
2018-01-19 02:50:11 -05:00
if ( ! is_null ( $parent_user ) && in_array ( $parent_user , [ local_user (), 0 ])) {
2018-01-19 02:02:43 -05:00
$profile_uid = $parent_user ;
}
2016-10-17 15:17:11 -04:00
// Check for multiple posts with the same message id (when the post was created via API)
2017-06-07 22:00:59 -04:00
if (( $message_id != '' ) && ( $profile_uid != 0 )) {
2018-01-20 08:54:14 -05:00
if ( dba :: exists ( 'item' , [ 'uri' => $message_id , 'uid' => $profile_uid ])) {
2016-10-17 15:17:11 -04:00
logger ( " Message with URI " . $message_id . " already exists for user " . $profile_uid , LOGGER_DEBUG );
return ;
}
}
2017-12-19 18:12:37 -05:00
// Allow commenting if it is an answer to a public post
2018-01-19 02:02:43 -05:00
$allow_comment = local_user () && ( $profile_uid == 0 ) && $parent && in_array ( $parent_item [ 'network' ], [ NETWORK_OSTATUS , NETWORK_DIASPORA , NETWORK_DFRN ]);
2017-12-19 18:12:37 -05:00
2018-01-19 02:02:43 -05:00
// Now check that valid personal details have been provided
if ( ! can_write_wall ( $profile_uid ) && ! $allow_comment ) {
2017-03-30 15:32:12 -04:00
notice ( t ( 'Permission denied.' ) . EOL ) ;
if ( x ( $_REQUEST , 'return' )) {
2016-10-29 16:17:33 -04:00
goaway ( $return_path );
2017-03-30 15:32:12 -04:00
}
2011-02-16 23:25:10 -05:00
killme ();
2010-07-01 19:48:07 -04:00
}
2010-08-14 10:55:18 -04:00
2011-03-18 08:06:16 -04:00
// is this an edited post?
$orig_post = null ;
2017-03-30 15:32:12 -04:00
if ( $post_id ) {
2018-01-20 08:54:14 -05:00
$orig_post = dba :: selectFirst ( 'item' , [], [ 'id' => $post_id ]);
2011-03-18 08:06:16 -04:00
}
2018-01-20 08:54:14 -05:00
$user = dba :: selectFirst ( 'user' , [], [ 'uid' => $profile_uid ]);
if ( ! DBM :: is_result ( $user ) && ! $orig_post ) {
return ;
2017-03-30 15:32:12 -04:00
}
2011-11-28 23:09:10 -05:00
2017-03-30 15:32:12 -04:00
if ( $orig_post ) {
2011-03-18 08:06:16 -04:00
$str_group_allow = $orig_post [ 'allow_gid' ];
$str_contact_allow = $orig_post [ 'allow_cid' ];
$str_group_deny = $orig_post [ 'deny_gid' ];
$str_contact_deny = $orig_post [ 'deny_cid' ];
$location = $orig_post [ 'location' ];
$coord = $orig_post [ 'coord' ];
$verb = $orig_post [ 'verb' ];
2014-08-07 02:02:24 -04:00
$objecttype = $orig_post [ 'object-type' ];
2011-03-18 08:06:16 -04:00
$emailcc = $orig_post [ 'emailcc' ];
2014-10-20 02:21:23 -04:00
$app = $orig_post [ 'app' ];
2012-03-22 19:17:10 -04:00
$categories = $orig_post [ 'file' ];
2012-03-28 06:18:26 -04:00
$title = notags ( trim ( $_REQUEST [ 'title' ]));
2012-01-12 17:20:21 -05:00
$body = escape_tags ( trim ( $_REQUEST [ 'body' ]));
2011-03-18 08:06:16 -04:00
$private = $orig_post [ 'private' ];
2018-01-20 08:54:14 -05:00
$pubmail_enabled = $orig_post [ 'pubmail' ];
2013-12-26 19:58:21 -05:00
$network = $orig_post [ 'network' ];
2014-07-21 18:36:20 -04:00
$guid = $orig_post [ 'guid' ];
2014-10-20 02:21:23 -04:00
$extid = $orig_post [ 'extid' ];
2012-03-22 19:17:10 -04:00
2014-07-21 18:36:20 -04:00
} else {
2012-01-12 17:20:21 -05:00
2017-03-30 15:32:12 -04:00
/*
* if coming from the API and no privacy settings are set ,
* use the user default permissions - as they won ' t have
* been supplied via a form .
*/
2017-03-31 14:32:52 -04:00
/// @TODO use x($_REQUEST, 'foo') here
2018-01-09 15:50:06 -05:00
if ( $api_source
2018-01-09 15:03:00 -05:00
&& ! array_key_exists ( 'contact_allow' , $_REQUEST )
&& ! array_key_exists ( 'group_allow' , $_REQUEST )
&& ! array_key_exists ( 'contact_deny' , $_REQUEST )
&& ! array_key_exists ( 'group_deny' , $_REQUEST )) {
2012-01-12 17:20:21 -05:00
$str_group_allow = $user [ 'allow_gid' ];
$str_contact_allow = $user [ 'allow_cid' ];
$str_group_deny = $user [ 'deny_gid' ];
$str_contact_deny = $user [ 'deny_cid' ];
2017-03-30 15:32:12 -04:00
} else {
2012-01-12 17:20:21 -05:00
// use the posted permissions
$str_group_allow = perms2str ( $_REQUEST [ 'group_allow' ]);
$str_contact_allow = perms2str ( $_REQUEST [ 'contact_allow' ]);
$str_group_deny = perms2str ( $_REQUEST [ 'group_deny' ]);
$str_contact_deny = perms2str ( $_REQUEST [ 'contact_deny' ]);
}
$title = notags ( trim ( $_REQUEST [ 'title' ]));
$location = notags ( trim ( $_REQUEST [ 'location' ]));
$coord = notags ( trim ( $_REQUEST [ 'coord' ]));
$verb = notags ( trim ( $_REQUEST [ 'verb' ]));
$emailcc = notags ( trim ( $_REQUEST [ 'emailcc' ]));
$body = escape_tags ( trim ( $_REQUEST [ 'body' ]));
2013-12-26 19:58:21 -05:00
$network = notags ( trim ( $_REQUEST [ 'network' ]));
2014-07-21 18:36:20 -04:00
$guid = get_guid ( 32 );
2012-03-22 19:17:10 -04:00
2015-09-23 04:47:34 -04:00
item_add_language_opt ( $_REQUEST );
$postopts = $_REQUEST [ 'postopts' ] ? $_REQUEST [ 'postopts' ] : " " ;
2012-07-12 01:45:14 -04:00
2011-03-18 08:06:16 -04:00
$private = (( strlen ( $str_group_allow ) || strlen ( $str_contact_allow ) || strlen ( $str_group_deny ) || strlen ( $str_contact_deny )) ? 1 : 0 );
2017-03-30 15:32:12 -04:00
if ( $user [ 'hidewall' ]) {
2013-01-27 16:14:13 -05:00
$private = 2 ;
2017-03-30 15:32:12 -04:00
}
2013-01-27 16:14:13 -05:00
2012-05-19 19:42:24 -04:00
// If this is a comment, set the permissions from the parent.
2017-03-30 15:32:12 -04:00
if ( $parent_item ) {
2012-05-19 19:42:24 -04:00
2013-12-26 19:58:21 -05:00
// for non native networks use the network of the original post as network of the item
if (( $parent_item [ 'network' ] != NETWORK_DIASPORA )
2017-06-07 22:00:59 -04:00
&& ( $parent_item [ 'network' ] != NETWORK_OSTATUS )
&& ( $network == " " )) {
2013-12-26 19:58:21 -05:00
$network = $parent_item [ 'network' ];
2017-03-30 15:32:12 -04:00
}
2013-12-26 19:58:21 -05:00
2012-05-19 19:42:24 -04:00
$str_contact_allow = $parent_item [ 'allow_cid' ];
$str_group_allow = $parent_item [ 'allow_gid' ];
$str_contact_deny = $parent_item [ 'deny_cid' ];
$str_group_deny = $parent_item [ 'deny_gid' ];
2016-10-06 17:24:29 -04:00
$private = $parent_item [ 'private' ];
2011-03-18 08:06:16 -04:00
}
2016-10-06 17:24:29 -04:00
2018-01-20 08:54:14 -05:00
$pubmail_enabled = defaults ( $_REQUEST , 'pubmail_enable' , false ) && ! $private ;
2010-12-19 16:41:55 -05:00
2011-08-14 07:26:41 -04:00
// if using the API, we won't see pubmail_enable - figure out if it should be set
2018-01-09 15:03:00 -05:00
if ( $api_source && $profile_uid && $profile_uid == local_user () && ! $private ) {
2018-01-20 08:54:14 -05:00
if ( function_exists ( 'imap_open' ) && ! Config :: get ( 'system' , 'imap_disabled' )) {
$pubmail_enabled = dba :: exists ( 'mailacct' , [ " `uid` = ? AND `server` != ? " , local_user (), '' ]);
2011-08-14 07:26:41 -04:00
}
}
2018-01-09 15:03:00 -05:00
if ( ! strlen ( $body )) {
2017-03-30 15:32:12 -04:00
if ( $preview ) {
2012-01-09 23:03:00 -05:00
killme ();
2017-03-30 15:32:12 -04:00
}
2018-01-09 15:03:00 -05:00
info ( t ( 'Empty post discarded.' ) . EOL );
2017-03-30 15:32:12 -04:00
if ( x ( $_REQUEST , 'return' )) {
2016-10-29 16:17:33 -04:00
goaway ( $return_path );
2017-03-30 15:32:12 -04:00
}
2011-03-18 08:06:16 -04:00
killme ();
}
2010-07-12 19:43:59 -04:00
}
2017-03-30 15:32:12 -04:00
if ( strlen ( $categories )) {
2012-05-30 01:57:15 -04:00
// get the "fileas" tags for this post
$filedas = file_tag_file_to_list ( $categories , 'file' );
2012-04-01 21:28:31 -04:00
}
2012-05-30 01:57:15 -04:00
// save old and new categories, so we can determine what needs to be deleted from pconfig
$categories_old = $categories ;
$categories = file_tag_list_to_file ( trim ( $_REQUEST [ 'category' ]), 'category' );
$categories_new = $categories ;
2017-03-30 15:32:12 -04:00
if ( strlen ( $filedas )) {
2012-05-30 01:57:15 -04:00
// append the fileas stuff to the new categories list
$categories .= file_tag_list_to_file ( $filedas , 'file' );
2012-04-01 21:28:31 -04:00
}
2010-07-17 02:14:37 -04:00
// get contact info for poster
2010-07-17 22:26:00 -04:00
2010-08-14 10:55:18 -04:00
$author = null ;
2010-12-22 17:16:22 -05:00
$self = false ;
2012-09-05 01:50:28 -04:00
$contact_id = 0 ;
2010-08-14 10:55:18 -04:00
2017-12-19 18:12:37 -05:00
if ( local_user () && (( local_user () == $profile_uid ) || $allow_comment )) {
2010-12-22 17:16:22 -05:00
$self = true ;
2018-01-20 08:54:14 -05:00
$author = dba :: selectFirst ( 'contact' , [], [ 'uid' => local_user (), 'self' => true ]);
2017-12-19 18:12:37 -05:00
} elseif ( remote_user ()) {
2017-04-01 15:46:57 -04:00
if ( x ( $_SESSION , 'remote' ) && is_array ( $_SESSION [ 'remote' ])) {
2017-03-30 15:32:12 -04:00
foreach ( $_SESSION [ 'remote' ] as $v ) {
if ( $v [ 'uid' ] == $profile_uid ) {
2012-09-05 01:50:28 -04:00
$contact_id = $v [ 'cid' ];
break ;
}
}
2013-11-02 21:07:44 -04:00
}
2017-03-30 15:32:12 -04:00
if ( $contact_id ) {
2018-01-20 08:54:14 -05:00
$author = dba :: selectFirst ( 'contact' , [], [ 'id' => $contact_id ]);
2012-09-05 01:50:28 -04:00
}
2010-08-14 10:55:18 -04:00
}
2018-01-20 08:54:14 -05:00
if ( DBM :: is_result ( $author )) {
2010-08-14 10:55:18 -04:00
$contact_id = $author [ 'id' ];
2010-07-17 02:14:37 -04:00
}
// get contact info for owner
2017-12-19 18:12:37 -05:00
if ( $profile_uid == local_user () || $allow_comment ) {
2010-08-14 10:55:18 -04:00
$contact_record = $author ;
2017-03-30 15:32:12 -04:00
} else {
2018-01-20 08:54:14 -05:00
$contact_record = dba :: selectFirst ( 'contact' , [], [ 'uid' => $profile_uid , 'self' => true ]);
2010-08-14 10:55:18 -04:00
}
2010-07-17 02:14:37 -04:00
2012-01-12 17:20:21 -05:00
$post_type = notags ( trim ( $_REQUEST [ 'type' ]));
2010-07-26 01:51:45 -04:00
2017-03-30 15:32:12 -04:00
if ( $post_type === 'net-comment' && $parent_item !== null ) {
if ( $parent_item [ 'wall' ] == 1 ) {
$post_type = 'wall-comment' ;
} else {
$post_type = 'remote-comment' ;
2010-07-28 01:32:21 -04:00
}
2010-07-26 01:51:45 -04:00
}
2010-07-08 20:49:41 -04:00
2017-11-25 21:03:59 -05:00
// Look for any tags and linkify them
$str_tags = '' ;
$inform = '' ;
$tags = get_tags ( $body );
2018-01-20 08:54:14 -05:00
// Add a tag if the parent contact is from OStatus (This will notify them during delivery)
if ( $parent ) {
if ( $thr_parent_contact [ 'network' ] == NETWORK_OSTATUS ) {
$contact = '@[url=' . $thr_parent_contact [ 'url' ] . ']' . $thr_parent_contact [ 'nick' ] . '[/url]' ;
if ( ! in_array ( $contact , $tags )) {
$tags [] = $contact ;
2017-11-25 21:03:59 -05:00
}
}
2018-01-20 08:54:14 -05:00
if ( $parent_contact [ 'network' ] == NETWORK_OSTATUS ) {
$contact = '@[url=' . $parent_contact [ 'url' ] . ']' . $parent_contact [ 'nick' ] . '[/url]' ;
if ( ! in_array ( $contact , $tags )) {
$tags [] = $contact ;
}
2017-11-25 21:03:59 -05:00
}
}
2018-01-15 08:05:12 -05:00
$tagged = [];
2017-11-25 21:03:59 -05:00
$private_forum = false ;
$only_to_forum = false ;
2018-01-15 08:05:12 -05:00
$forum_contact = [];
2017-11-25 21:03:59 -05:00
if ( count ( $tags )) {
foreach ( $tags as $tag ) {
$tag_type = substr ( $tag , 0 , 1 );
if ( $tag_type == '#' ) {
continue ;
}
/*
* If we already tagged 'Robert Johnson' , don 't try and tag ' Robert ' .
* Robert Johnson should be first in the $tags array
*/
$fullnametagged = false ;
2018-01-09 15:50:06 -05:00
/// @TODO $tagged is initialized above if () block and is not filled, maybe old-lost code?
2017-11-25 21:03:59 -05:00
foreach ( $tagged as $nextTag ) {
if ( stristr ( $nextTag , $tag . ' ' )) {
$fullnametagged = true ;
break ;
}
}
if ( $fullnametagged ) {
continue ;
}
2018-01-09 15:03:00 -05:00
$success = handle_tag ( $a , $body , $inform , $str_tags , local_user () ? local_user () : $profile_uid , $tag , $network );
2017-11-25 21:03:59 -05:00
if ( $success [ 'replaced' ]) {
$tagged [] = $tag ;
}
// When the forum is private or the forum is addressed with a "!" make the post private
if ( is_array ( $success [ 'contact' ]) && ( $success [ 'contact' ][ 'prv' ] || ( $tag_type == '!' ))) {
$private_forum = $success [ 'contact' ][ 'prv' ];
$only_to_forum = ( $tag_type == '!' );
$private_id = $success [ 'contact' ][ 'id' ];
$forum_contact = $success [ 'contact' ];
} elseif ( is_array ( $success [ 'contact' ]) && $success [ 'contact' ][ 'forum' ] &&
( $str_contact_allow == '<' . $success [ 'contact' ][ 'id' ] . '>' )) {
$private_forum = false ;
$only_to_forum = true ;
$private_id = $success [ 'contact' ][ 'id' ];
$forum_contact = $success [ 'contact' ];
}
}
}
2017-11-26 17:28:46 -05:00
$original_contact_id = $contact_id ;
2017-11-25 21:03:59 -05:00
if ( ! $parent && count ( $forum_contact ) && ( $private_forum || $only_to_forum )) {
// we tagged a forum in a top level post. Now we change the post
$private = $private_forum ;
$str_group_allow = '' ;
$str_contact_deny = '' ;
$str_group_deny = '' ;
if ( $private_forum ) {
$str_contact_allow = '<' . $private_id . '>' ;
} else {
$str_contact_allow = '' ;
}
$contact_id = $private_id ;
$contact_record = $forum_contact ;
$_REQUEST [ 'origin' ] = false ;
}
2017-03-30 15:32:12 -04:00
/*
2013-11-02 21:07:44 -04:00
* When a photo was uploaded into the message using the ( profile wall ) ajax
2011-01-04 05:01:07 -05:00
* uploader , The permissions are initially set to disallow anybody but the
* owner from seeing it . This is because the permissions may not yet have been
* set for the post . If it ' s private , the photo permissions should be set
* appropriately . But we didn ' t know the final permissions on the post until
* now . So now we ' ll look for links of uploaded messages that are in the
* post and set them to the same permissions as the post itself .
2011-01-04 02:05:20 -05:00
*/
$match = null ;
2017-11-25 21:03:59 -05:00
if ( ! $preview && preg_match_all ( " / \ [img([ \ =0-9x]*?) \ ](.*?) \ [ \ /img \ ]/ " , $body , $match )) {
2012-09-14 20:22:56 -04:00
$images = $match [ 2 ];
2017-03-30 15:32:12 -04:00
if ( count ( $images )) {
2014-08-07 02:02:24 -04:00
$objecttype = ACTIVITY_OBJ_IMAGE ;
2016-12-20 15:15:53 -05:00
foreach ( $images as $image ) {
2017-11-26 17:28:46 -05:00
if ( ! stristr ( $image , System :: baseUrl () . '/photo/' )) {
2011-01-04 05:01:07 -05:00
continue ;
2016-12-20 15:15:53 -05:00
}
2011-01-04 05:01:07 -05:00
$image_uri = substr ( $image , strrpos ( $image , '/' ) + 1 );
$image_uri = substr ( $image_uri , 0 , strpos ( $image_uri , '-' ));
2017-11-26 17:28:46 -05:00
if ( ! strlen ( $image_uri )) {
2011-05-29 18:47:26 -04:00
continue ;
2016-12-20 15:15:53 -05:00
}
2012-05-25 20:42:35 -04:00
2018-01-20 08:54:14 -05:00
/// @todo these lines should be moved to Model/Photo
$srch = '<' . intval ( $original_contact_id ) . '>' ;
2012-05-25 20:42:35 -04:00
2018-01-20 08:54:14 -05:00
$condition = [ 'allow_cid' => $srch , 'allow_gid' => '' , 'deny_cid' => '' , 'deny_gid' => '' ,
'resource-id' => $image_uri , 'uid' => $profile_uid ];
if ( ! dba :: exists ( 'photo' , $condition )) {
2011-05-27 05:37:12 -04:00
continue ;
2016-12-20 04:10:33 -05:00
}
2013-11-02 21:07:44 -04:00
2018-01-20 08:54:14 -05:00
$fields = [ 'allow_cid' => $str_contact_allow , 'allow_gid' => $str_group_allow ,
'deny_cid' => $str_contact_deny , 'deny_gid' => $str_group_deny ];
$condition = [ 'resource-id' => $image_uri , 'uid' => $profile_uid , 'album' => t ( 'Wall Photos' )];
dba :: update ( 'photo' , $fields , $condition );
2011-01-04 02:05:20 -05:00
}
}
}
2011-05-25 05:08:15 -04:00
2017-03-30 15:32:12 -04:00
/*
2011-06-29 21:59:05 -04:00
* Next link in any attachment references we find in the post .
*/
2011-05-29 18:47:26 -04:00
$match = false ;
2011-05-25 05:08:15 -04:00
2018-01-09 15:03:00 -05:00
if ( ! $preview && preg_match_all ( " / \ [attachment \ ](.*?) \ [ \ /attachment \ ]/ " , $body , $match )) {
2011-05-25 05:08:15 -04:00
$attaches = $match [ 1 ];
2017-03-30 15:32:12 -04:00
if ( count ( $attaches )) {
foreach ( $attaches as $attach ) {
2018-01-20 08:54:14 -05:00
$fields = [ 'allow_cid' => $str_contact_allow , 'allow_gid' => $str_group_allow ,
'deny_cid' => $str_contact_deny , 'deny_gid' => $str_group_deny ];
$condition = [ 'id' => $attach ];
dba :: update ( 'attach' , $fields , $condition );
2011-05-25 05:08:15 -04:00
}
}
}
2016-04-24 11:00:19 -04:00
// embedded bookmark or attachment in post? set bookmark flag
2011-09-04 22:58:03 -04:00
$bookmark = 0 ;
2016-04-24 11:00:19 -04:00
$data = get_attachment_data ( $body );
2017-06-07 22:00:59 -04:00
if ( preg_match_all ( " / \ [bookmark \ =([^ \ ]]*) \ ](.*?) \ [ \ /bookmark \ ]/ism " , $body , $match , PREG_SET_ORDER ) || isset ( $data [ " type " ])) {
2014-08-07 02:02:24 -04:00
$objecttype = ACTIVITY_OBJ_BOOKMARK ;
2011-09-04 22:58:03 -04:00
$bookmark = 1 ;
}
2011-10-11 21:24:37 -04:00
$body = bb_translate_video ( $body );
2012-08-03 21:33:11 -04:00
2017-03-30 15:32:12 -04:00
// Fold multi-line [code] sequences
$body = preg_replace ( '/\[\/code\]\s*\[code\]/ism' , " \n " , $body );
2011-01-04 05:01:07 -05:00
2017-03-31 14:36:01 -04:00
$body = scale_external_images ( $body , false );
2012-02-25 17:22:51 -05:00
2014-08-07 02:02:24 -04:00
// Setting the object type if not defined before
if ( ! $objecttype ) {
$objecttype = ACTIVITY_OBJ_NOTE ; // Default value
2017-03-31 14:30:21 -04:00
require_once 'include/plaintext.php' ;
2014-08-07 02:02:24 -04:00
$objectdata = get_attached_data ( $body );
2017-11-25 21:03:59 -05:00
if ( $objectdata [ " type " ] == " link " ) {
2014-08-07 02:02:24 -04:00
$objecttype = ACTIVITY_OBJ_BOOKMARK ;
2017-11-25 21:03:59 -05:00
} elseif ( $objectdata [ " type " ] == " video " ) {
2014-08-07 02:02:24 -04:00
$objecttype = ACTIVITY_OBJ_VIDEO ;
2017-11-25 21:03:59 -05:00
} elseif ( $objectdata [ " type " ] == " photo " ) {
2014-08-07 02:02:24 -04:00
$objecttype = ACTIVITY_OBJ_IMAGE ;
2017-03-30 15:32:12 -04:00
}
2014-08-07 02:02:24 -04:00
}
2012-08-03 21:33:11 -04:00
2011-05-25 05:08:15 -04:00
$attachments = '' ;
2011-05-29 18:47:26 -04:00
$match = false ;
2011-05-25 05:08:15 -04:00
2016-12-19 08:26:13 -05:00
if ( preg_match_all ( '/(\[attachment\]([0-9]+)\[\/attachment\])/' , $body , $match )) {
foreach ( $match [ 2 ] as $mtch ) {
2018-01-20 08:54:14 -05:00
$fields = [ 'id' , 'filename' , 'filesize' , 'filetype' ];
$attachment = dba :: selectFirst ( 'attach' , $fields , [ 'id' => $mtch ]);
if ( DBM :: is_result ( $attachment )) {
2016-12-20 15:31:05 -05:00
if ( strlen ( $attachments )) {
2011-05-25 05:08:15 -04:00
$attachments .= ',' ;
2016-12-20 15:31:05 -05:00
}
2018-01-20 08:54:14 -05:00
$attachments .= '[attach]href="' . System :: baseUrl () . '/attach/' . $attachment [ 'id' ] .
'" length="' . $attachment [ 'filesize' ] . '" type="' . $attachment [ 'filetype' ] .
'" title="' . ( $attachment [ 'filename' ] ? $attachment [ 'filename' ] : '' ) . '"[/attach]' ;
2011-05-25 05:08:15 -04:00
}
$body = str_replace ( $match [ 1 ], '' , $body );
}
}
2010-09-09 22:14:42 -04:00
$wall = 0 ;
2011-03-18 03:30:34 -04:00
2017-11-02 16:15:14 -04:00
if (( $post_type === 'wall' || $post_type === 'wall-comment' ) && ! count ( $forum_contact )) {
2010-09-09 22:14:42 -04:00
$wall = 1 ;
2016-12-20 15:31:05 -05:00
}
2010-09-10 00:16:40 -04:00
2018-01-09 15:03:00 -05:00
if ( ! strlen ( $verb )) {
$verb = ACTIVITY_POST ;
2016-12-20 15:31:05 -05:00
}
2010-09-10 01:02:28 -04:00
2016-12-20 15:31:05 -05:00
if ( $network == " " ) {
2013-12-26 19:58:21 -05:00
$network = NETWORK_DFRN ;
2016-12-20 15:31:05 -05:00
}
2013-12-26 19:58:21 -05:00
2018-01-09 15:03:00 -05:00
$gravity = ( $parent ? 6 : 0 );
2011-10-17 17:52:03 -04:00
2015-03-22 05:12:16 -04:00
// even if the post arrived via API we are considering that it
2011-10-17 17:52:03 -04:00
// originated on this site by default for determining relayability.
2018-01-20 08:54:14 -05:00
$origin = intval ( defaults ( $_REQUEST , 'origin' , 1 ));
2013-12-26 19:58:21 -05:00
2018-01-09 15:03:00 -05:00
$notify_type = ( $parent ? 'comment-new' : 'wall-new' );
2010-07-08 20:49:41 -04:00
2018-01-11 14:17:40 -05:00
$uri = ( $message_id ? $message_id : item_new_uri ( $a -> get_hostname (), $profile_uid , $guid ));
2010-08-10 04:21:38 -04:00
2018-01-11 14:17:40 -05:00
// Fallback so that we alway have a parent uri
2018-01-20 08:54:14 -05:00
if ( ! $thr_parent_uri || ! $parent ) {
$thr_parent_uri = $uri ;
2016-12-20 15:31:05 -05:00
}
2012-08-07 04:04:47 -04:00
2018-01-15 08:05:12 -05:00
$datarray = [];
2010-12-22 17:16:22 -05:00
$datarray [ 'uid' ] = $profile_uid ;
$datarray [ 'type' ] = $post_type ;
$datarray [ 'wall' ] = $wall ;
$datarray [ 'gravity' ] = $gravity ;
2013-12-26 19:58:21 -05:00
$datarray [ 'network' ] = $network ;
2010-12-22 17:16:22 -05:00
$datarray [ 'contact-id' ] = $contact_id ;
$datarray [ 'owner-name' ] = $contact_record [ 'name' ];
$datarray [ 'owner-link' ] = $contact_record [ 'url' ];
$datarray [ 'owner-avatar' ] = $contact_record [ 'thumb' ];
2017-11-19 17:03:39 -05:00
$datarray [ 'owner-id' ] = Contact :: getIdForURL ( $datarray [ 'owner-link' ], 0 );
2010-12-22 17:16:22 -05:00
$datarray [ 'author-name' ] = $author [ 'name' ];
$datarray [ 'author-link' ] = $author [ 'url' ];
$datarray [ 'author-avatar' ] = $author [ 'thumb' ];
2017-11-19 17:03:39 -05:00
$datarray [ 'author-id' ] = Contact :: getIdForURL ( $datarray [ 'author-link' ], 0 );
2010-12-22 17:16:22 -05:00
$datarray [ 'created' ] = datetime_convert ();
$datarray [ 'edited' ] = datetime_convert ();
2011-09-18 22:04:11 -04:00
$datarray [ 'commented' ] = datetime_convert ();
2011-06-23 20:56:59 -04:00
$datarray [ 'received' ] = datetime_convert ();
2010-12-22 17:16:22 -05:00
$datarray [ 'changed' ] = datetime_convert ();
2014-10-20 02:21:23 -04:00
$datarray [ 'extid' ] = $extid ;
2014-07-21 18:36:20 -04:00
$datarray [ 'guid' ] = $guid ;
2010-12-22 17:16:22 -05:00
$datarray [ 'uri' ] = $uri ;
$datarray [ 'title' ] = $title ;
$datarray [ 'body' ] = $body ;
2011-06-20 22:08:40 -04:00
$datarray [ 'app' ] = $app ;
2010-12-22 17:16:22 -05:00
$datarray [ 'location' ] = $location ;
$datarray [ 'coord' ] = $coord ;
$datarray [ 'tag' ] = $str_tags ;
2012-03-22 19:17:10 -04:00
$datarray [ 'file' ] = $categories ;
2010-12-22 17:16:22 -05:00
$datarray [ 'inform' ] = $inform ;
$datarray [ 'verb' ] = $verb ;
2014-08-07 02:02:24 -04:00
$datarray [ 'object-type' ] = $objecttype ;
2010-12-22 17:16:22 -05:00
$datarray [ 'allow_cid' ] = $str_contact_allow ;
$datarray [ 'allow_gid' ] = $str_group_allow ;
$datarray [ 'deny_cid' ] = $str_contact_deny ;
$datarray [ 'deny_gid' ] = $str_group_deny ;
$datarray [ 'private' ] = $private ;
2018-01-20 08:54:14 -05:00
$datarray [ 'pubmail' ] = $pubmail_enabled ;
2011-05-25 05:08:15 -04:00
$datarray [ 'attach' ] = $attachments ;
2011-09-04 22:58:03 -04:00
$datarray [ 'bookmark' ] = intval ( $bookmark );
2018-01-20 09:10:37 -05:00
// This is not a bug. The item store function changes 'parent-uri' to 'thr-parent' and fetches 'parent-uri' new. (We should change this)
2018-01-20 08:54:14 -05:00
$datarray [ 'parent-uri' ] = $thr_parent_uri ;
2018-01-20 09:10:37 -05:00
2012-07-12 01:45:14 -04:00
$datarray [ 'postopts' ] = $postopts ;
2011-10-17 17:52:03 -04:00
$datarray [ 'origin' ] = $origin ;
2018-01-19 02:02:43 -05:00
$datarray [ 'moderated' ] = false ;
2018-01-15 08:05:12 -05:00
$datarray [ 'gcontact-id' ] = GContact :: getId ([ " url " => $datarray [ 'author-link' ], " network " => $datarray [ 'network' ],
" photo " => $datarray [ 'author-avatar' ], " name " => $datarray [ 'author-name' ]]);
2016-12-09 04:57:02 -05:00
$datarray [ 'object' ] = $object ;
2016-06-21 01:54:45 -04:00
2017-03-30 15:32:12 -04:00
/*
2010-12-22 17:16:22 -05:00
* These fields are for the convenience of plugins ...
* 'self' if true indicates the owner is posting on their own wall
* If parent is 0 it is a top - level post .
*/
$datarray [ 'parent' ] = $parent ;
$datarray [ 'self' ] = $self ;
2017-09-06 12:20:14 -04:00
// This triggers posts via API and the mirror functions
$datarray [ 'api_source' ] = $api_source ;
2018-01-11 14:17:40 -05:00
// This field is for storing the raw conversation data
2017-04-29 01:44:13 -04:00
$datarray [ 'protocol' ] = PROTOCOL_DFRN ;
$r = dba :: fetch_first ( " SELECT `conversation-uri`, `conversation-href` FROM `conversation` WHERE `item-uri` = ? " , $datarray [ 'parent-uri' ]);
2017-11-07 22:57:46 -05:00
if ( DBM :: is_result ( $r )) {
2017-04-29 01:44:13 -04:00
if ( $r [ 'conversation-uri' ] != '' ) {
$datarray [ 'conversation-uri' ] = $r [ 'conversation-uri' ];
}
if ( $r [ 'conversation-href' ] != '' ) {
$datarray [ 'conversation-href' ] = $r [ 'conversation-href' ];
}
}
2017-03-30 15:32:12 -04:00
if ( $orig_post ) {
$datarray [ 'edit' ] = true ;
}
2011-08-07 20:29:26 -04:00
2015-03-01 14:40:38 -05:00
// Search for hashtags
item_body_set_hashtags ( $datarray );
2012-01-05 18:02:44 -05:00
// preview mode - prepare the body for display and send it via json
2017-03-30 15:32:12 -04:00
if ( $preview ) {
2017-03-31 14:30:21 -04:00
require_once 'include/conversation.php' ;
2016-11-20 10:19:55 -05:00
// We set the datarray ID to -1 because in preview mode the dataray
// doesn't have an ID.
$datarray [ " id " ] = - 1 ;
2018-01-15 08:05:12 -05:00
$o = conversation ( $a ,[ array_merge ( $contact_record , $datarray )], 'search' , false , true );
2012-01-09 23:03:00 -05:00
logger ( 'preview: ' . $o );
2018-01-15 08:05:12 -05:00
echo json_encode ([ 'preview' => $o ]);
2012-01-05 18:02:44 -05:00
killme ();
}
2010-12-22 17:16:22 -05:00
call_hooks ( 'post_local' , $datarray );
2017-03-30 15:32:12 -04:00
if ( x ( $datarray , 'cancel' )) {
2012-01-30 23:49:54 -05:00
logger ( 'mod_item: post cancelled by plugin.' );
2017-03-30 15:32:12 -04:00
if ( $return_path ) {
2016-10-29 16:17:33 -04:00
goaway ( $return_path );
2012-01-30 23:49:54 -05:00
}
2018-01-15 08:05:12 -05:00
$json = [ 'cancel' => 1 ];
2017-03-31 14:47:23 -04:00
if ( x ( $_REQUEST , 'jsreload' ) && strlen ( $_REQUEST [ 'jsreload' ])) {
2017-08-26 03:32:10 -04:00
$json [ 'reload' ] = System :: baseUrl () . '/' . $_REQUEST [ 'jsreload' ];
2016-12-20 05:18:54 -05:00
}
2012-01-30 23:49:54 -05:00
echo json_encode ( $json );
killme ();
}
2017-03-30 15:32:12 -04:00
if ( $orig_post ) {
2018-01-09 17:35:50 -05:00
// Fill the cache field
2018-01-10 01:58:20 -05:00
// This could be done in Item::update as well - but we have to check for the existance of some fields.
2018-01-09 17:35:50 -05:00
put_item_in_cache ( $datarray );
2018-01-15 08:05:12 -05:00
$fields = [
2018-01-09 15:03:00 -05:00
'title' => $datarray [ 'title' ],
'body' => $datarray [ 'body' ],
'tag' => $datarray [ 'tag' ],
'attach' => $datarray [ 'attach' ],
'file' => $datarray [ 'file' ],
'rendered-html' => $datarray [ 'rendered-html' ],
'rendered-hash' => $datarray [ 'rendered-hash' ],
'edited' => datetime_convert (),
2018-01-15 08:05:12 -05:00
'changed' => datetime_convert ()];
2018-01-09 15:03:00 -05:00
2018-01-09 16:13:45 -05:00
Item :: update ( $fields , [ 'id' => $post_id ]);
2014-03-20 13:48:08 -04:00
2012-04-01 21:28:31 -04:00
// update filetags in pconfig
2014-08-27 19:06:41 -04:00
file_tag_update_pconfig ( $uid , $categories_old , $categories_new , 'category' );
2012-04-01 21:28:31 -04:00
2018-01-09 15:03:00 -05:00
if ( x ( $_REQUEST , 'return' ) && strlen ( $return_path )) {
2011-09-12 22:42:10 -04:00
logger ( 'return: ' . $return_path );
2016-10-29 16:17:33 -04:00
goaway ( $return_path );
2011-03-18 08:06:16 -04:00
}
killme ();
2017-03-30 15:32:12 -04:00
} else {
2011-03-18 08:06:16 -04:00
$post_id = 0 ;
2017-03-30 15:32:12 -04:00
}
2011-03-18 08:06:16 -04:00
2018-01-09 15:50:06 -05:00
unset ( $datarray [ 'edit' ]);
unset ( $datarray [ 'self' ]);
unset ( $datarray [ 'api_source' ]);
2018-01-09 15:03:00 -05:00
$post_id = item_store ( $datarray );
2014-03-09 04:19:14 -04:00
2018-01-18 14:38:51 -05:00
if ( ! $post_id ) {
logger ( " Item wasn't stored. " );
goaway ( $return_path );
}
$datarray = dba :: selectFirst ( 'item' , [], [ 'id' => $post_id ]);
if ( ! DBM :: is_result ( $datarray )) {
logger ( " Item with id " . $post_id . " couldn't be fetched. " );
goaway ( $return_path );
}
2011-08-28 22:22:27 -04:00
2015-03-07 15:24:39 -05:00
// update filetags in pconfig
2018-01-09 15:03:00 -05:00
file_tag_update_pconfig ( $uid , $categories_old , $categories_new , 'category' );
2011-08-28 22:22:27 -04:00
2018-01-09 15:03:00 -05:00
// These notifications are sent if someone else is commenting other your wall
2017-03-30 15:32:12 -04:00
if ( $parent ) {
if ( $contact_record != $author ) {
2018-01-15 08:05:12 -05:00
notification ([
2015-03-07 15:24:39 -05:00
'type' => NOTIFY_COMMENT ,
'notify_flags' => $user [ 'notify-flags' ],
'language' => $user [ 'language' ],
'to_name' => $user [ 'username' ],
'to_email' => $user [ 'email' ],
'uid' => $user [ 'uid' ],
'item' => $datarray ,
2017-08-26 03:32:10 -04:00
'link' => System :: baseUrl () . '/display/' . urlencode ( $datarray [ 'guid' ]),
2015-03-07 15:24:39 -05:00
'source_name' => $datarray [ 'author-name' ],
'source_link' => $datarray [ 'author-link' ],
'source_photo' => $datarray [ 'author-avatar' ],
'verb' => ACTIVITY_POST ,
'otype' => 'item' ,
'parent' => $parent ,
'parent_uri' => $parent_item [ 'uri' ]
2018-01-15 08:05:12 -05:00
]);
2015-03-07 15:24:39 -05:00
}
// Store the comment signature information in case we need to relay to Diaspora
2017-11-23 14:01:58 -05:00
Diaspora :: storeCommentSignature ( $datarray , $author , ( $self ? $user [ 'prvkey' ] : false ), $post_id );
2015-03-07 15:24:39 -05:00
} else {
2017-11-02 16:15:14 -04:00
if (( $contact_record != $author ) && ! count ( $forum_contact )) {
2018-01-15 08:05:12 -05:00
notification ([
2015-03-07 15:24:39 -05:00
'type' => NOTIFY_WALL ,
'notify_flags' => $user [ 'notify-flags' ],
'language' => $user [ 'language' ],
'to_name' => $user [ 'username' ],
'to_email' => $user [ 'email' ],
'uid' => $user [ 'uid' ],
'item' => $datarray ,
2017-08-26 03:32:10 -04:00
'link' => System :: baseUrl () . '/display/' . urlencode ( $datarray [ 'guid' ]),
2015-03-07 15:24:39 -05:00
'source_name' => $datarray [ 'author-name' ],
'source_link' => $datarray [ 'author-link' ],
'source_photo' => $datarray [ 'author-avatar' ],
'verb' => ACTIVITY_POST ,
'otype' => 'item'
2018-01-15 08:05:12 -05:00
]);
2010-08-10 04:21:38 -04:00
}
}
2015-03-07 15:24:39 -05:00
2010-12-28 02:28:34 -05:00
call_hooks ( 'post_local_end' , $datarray );
2011-01-31 21:18:28 -05:00
2017-03-30 15:32:12 -04:00
if ( strlen ( $emailcc ) && $profile_uid == local_user ()) {
2011-01-31 21:18:28 -05:00
$erecips = explode ( ',' , $emailcc );
2017-03-30 15:32:12 -04:00
if ( count ( $erecips )) {
foreach ( $erecips as $recip ) {
2011-01-31 21:18:28 -05:00
$addr = trim ( $recip );
2018-01-09 15:03:00 -05:00
if ( ! strlen ( $addr )) {
2011-01-31 21:18:28 -05:00
continue ;
2017-03-30 15:32:12 -04:00
}
2018-01-09 15:03:00 -05:00
$disclaimer = '<hr />' . sprintf ( t ( 'This message was sent to you by %s, a member of the Friendica social network.' ), $a -> user [ 'username' ])
2011-03-10 18:22:21 -05:00
. '<br />' ;
2018-01-09 15:03:00 -05:00
$disclaimer .= sprintf ( t ( 'You may visit them online at %s' ), System :: baseUrl () . '/profile/' . $a -> user [ 'nickname' ]) . EOL ;
2015-03-22 05:12:16 -04:00
$disclaimer .= t ( 'Please contact the sender by replying to this post if you do not wish to receive these messages.' ) . EOL ;
2014-08-27 19:06:41 -04:00
if ( ! $datarray [ 'title' ] == '' ) {
2017-12-01 21:05:06 -05:00
$subject = Email :: encodeHeader ( $datarray [ 'title' ], 'UTF-8' );
2014-08-27 19:06:41 -04:00
} else {
2018-01-09 15:03:00 -05:00
$subject = Email :: encodeHeader ( '[Friendica]' . ' ' . sprintf ( t ( '%s posted an update.' ), $a -> user [ 'username' ]), 'UTF-8' );
2014-08-27 19:06:41 -04:00
}
2017-08-26 03:32:10 -04:00
$link = '<a href="' . System :: baseUrl () . '/profile/' . $a -> user [ 'nickname' ] . '"><img src="' . $author [ 'thumb' ] . '" alt="' . $a -> user [ 'username' ] . '" /></a><br /><br />' ;
2011-01-31 21:18:28 -05:00
$html = prepare_body ( $datarray );
$message = '<html><body>' . $link . $html . $disclaimer . '</body></html>' ;
2017-03-31 14:30:21 -04:00
include_once 'include/html2plain.php' ;
2018-01-15 08:05:12 -05:00
$params = [
2017-11-20 19:03:58 -05:00
'fromName' => $a -> user [ 'username' ],
'fromEmail' => $a -> user [ 'email' ],
'toEmail' => $addr ,
'replyTo' => $a -> user [ 'email' ],
'messageSubject' => $subject ,
'htmlVersion' => $message ,
'textVersion' => html2plain ( $html . $disclaimer )
2018-01-15 08:05:12 -05:00
];
2015-03-22 05:12:16 -04:00
Emailer :: send ( $params );
2011-01-31 21:18:28 -05:00
}
}
}
2016-11-12 08:17:28 -05:00
// Insert an item entry for UID=0 for global entries.
// We now do it in the background to save some time.
// This is important in interactive environments like the frontend or the API.
// We don't fork a new process since this is done anyway with the following command
2018-01-15 08:05:12 -05:00
Worker :: add ([ 'priority' => PRIORITY_HIGH , 'dont_fork' => true ], " CreateShadowEntry " , $post_id );
2011-09-12 22:42:10 -04:00
2016-11-12 08:17:28 -05:00
// Call the background process that is delivering the item to the receivers
2017-11-19 13:59:55 -05:00
Worker :: add ( PRIORITY_HIGH , " Notifier " , $notify_type , $post_id );
2011-09-12 22:42:10 -04:00
2011-02-17 00:17:49 -05:00
logger ( 'post_complete' );
2011-08-03 19:29:25 -04:00
2017-08-26 03:32:10 -04:00
item_post_return ( System :: baseUrl (), $api_source , $return_path );
2012-11-01 19:14:42 -04:00
// NOTREACHED
}
2018-01-20 08:54:14 -05:00
// q(
2012-11-01 19:14:42 -04:00
function item_post_return ( $baseurl , $api_source , $return_path ) {
2011-08-03 19:29:25 -04:00
// figure out how to return, depending on from whence we came
2017-03-30 15:32:12 -04:00
if ( $api_source ) {
2011-08-03 19:29:25 -04:00
return ;
2017-03-30 15:32:12 -04:00
}
2011-08-03 19:29:25 -04:00
2016-12-20 05:18:54 -05:00
if ( $return_path ) {
2016-10-29 16:17:33 -04:00
goaway ( $return_path );
2011-02-17 00:17:49 -05:00
}
2011-09-12 00:52:50 -04:00
2018-01-15 08:05:12 -05:00
$json = [ 'success' => 1 ];
2017-03-31 14:30:21 -04:00
if ( x ( $_REQUEST , 'jsreload' ) && strlen ( $_REQUEST [ 'jsreload' ])) {
2012-11-01 19:14:42 -04:00
$json [ 'reload' ] = $baseurl . '/' . $_REQUEST [ 'jsreload' ];
2016-12-20 05:18:54 -05:00
}
2011-02-17 00:17:49 -05:00
logger ( 'post_json: ' . print_r ( $json , true ), LOGGER_DEBUG );
2011-02-14 07:43:49 -05:00
echo json_encode ( $json );
2011-02-12 06:14:59 -05:00
killme ();
2010-07-26 20:01:37 -04:00
}
2016-02-07 09:11:34 -05:00
2017-01-09 07:14:25 -05:00
function item_content ( App $a ) {
2010-07-26 20:01:37 -04:00
2018-01-09 15:03:00 -05:00
if ( ! local_user () && ! remote_user ()) {
2010-07-26 20:01:37 -04:00
return ;
2016-12-20 05:18:54 -05:00
}
2010-07-26 20:01:37 -04:00
2017-03-31 14:30:21 -04:00
require_once 'include/security.php' ;
2010-07-26 20:01:37 -04:00
2013-01-26 14:52:21 -05:00
$o = '' ;
2016-12-20 05:18:54 -05:00
if (( $a -> argc == 3 ) && ( $a -> argv [ 1 ] === 'drop' ) && intval ( $a -> argv [ 2 ])) {
2018-01-17 18:22:01 -05:00
if ( is_ajax ()) {
$o = Item :: delete ( $a -> argv [ 2 ]);
} else {
$o = drop_item ( $a -> argv [ 2 ]);
}
2016-12-20 05:18:54 -05:00
if ( is_ajax ()) {
2015-03-01 14:40:38 -05:00
// ajax return: [<item id>, 0 (no perm) | <owner id>]
2018-01-15 08:05:12 -05:00
echo json_encode ([ intval ( $a -> argv [ 2 ]), intval ( $o )]);
2013-03-24 04:37:11 -04:00
killme ();
2013-02-15 06:34:32 -05:00
}
2010-07-26 20:01:37 -04:00
}
2013-01-26 14:52:21 -05:00
return $o ;
2011-05-22 00:40:16 -04:00
}
2012-03-09 06:57:11 -05:00
2012-03-12 08:59:00 -04:00
/**
2015-03-01 14:40:38 -05:00
* This function removes the tag $tag from the text $body and replaces it with
* the appropiate link .
*
2016-12-20 05:18:54 -05:00
* @ param App $a Application instance @ TODO is unused in this function ' s scope ( excluding included files )
2012-03-12 08:59:00 -04:00
* @ param unknown_type $body the text to replace the tag in
2016-04-13 01:00:36 -04:00
* @ param string $inform a comma - seperated string containing everybody to inform
* @ param string $str_tags string to add the tag to
* @ param integer $profile_uid
* @ param string $tag the tag to replace
* @ param string $network The network of the post
2012-05-03 01:33:51 -04:00
*
* @ return boolean true if replaced , false if not replaced
2012-03-12 08:59:00 -04:00
*/
2017-11-15 10:53:16 -05:00
function handle_tag ( App $a , & $body , & $inform , & $str_tags , $profile_uid , $tag , $network = " " )
{
2012-05-03 01:33:51 -04:00
$replaced = false ;
2012-05-30 01:57:15 -04:00
$r = null ;
2017-10-31 15:33:23 -04:00
$tag_type = '@' ;
2012-05-03 01:33:51 -04:00
2014-08-25 08:09:56 -04:00
//is it a person tag?
2017-10-31 15:33:23 -04:00
if (( strpos ( $tag , '@' ) === 0 ) || ( strpos ( $tag , '!' ) === 0 )) {
$tag_type = substr ( $tag , 0 , 1 );
2014-08-25 08:09:56 -04:00
//is it already replaced?
2017-03-30 15:32:12 -04:00
if ( strpos ( $tag , '[url=' )) {
2015-06-07 17:18:02 -04:00
//append tag to str_tags
2017-03-31 14:30:21 -04:00
if ( ! stristr ( $str_tags , $tag )) {
2016-12-20 05:18:54 -05:00
if ( strlen ( $str_tags )) {
2015-06-07 17:18:02 -04:00
$str_tags .= ',' ;
2016-12-20 05:18:54 -05:00
}
2015-06-07 17:18:02 -04:00
$str_tags .= $tag ;
}
// Checking for the alias that is used for OStatus
2017-10-31 15:33:23 -04:00
$pattern = " /[@!] \ [url \ =(.*?) \ ](.*?) \ [ \ /url \ ]/ism " ;
2015-06-07 17:18:02 -04:00
if ( preg_match ( $pattern , $tag , $matches )) {
2016-04-25 15:35:42 -04:00
$r = q ( " SELECT `alias`, `name` FROM `contact` WHERE `nurl` = '%s' AND `alias` != '' AND `uid` = 0 " ,
normalise_link ( $matches [ 1 ]));
2017-11-07 22:57:46 -05:00
if ( ! DBM :: is_result ( $r )) {
2016-04-25 15:35:42 -04:00
$r = q ( " SELECT `alias`, `name` FROM `gcontact` WHERE `nurl` = '%s' AND `alias` != '' " ,
normalise_link ( $matches [ 1 ]));
2017-03-30 15:32:12 -04:00
}
2017-11-07 22:57:46 -05:00
if ( DBM :: is_result ( $r )) {
2016-04-25 15:35:42 -04:00
$data = $r [ 0 ];
2017-03-30 15:32:12 -04:00
} else {
2017-11-06 21:22:52 -05:00
$data = Probe :: uri ( $matches [ 1 ]);
2017-03-30 15:32:12 -04:00
}
2016-04-25 15:35:42 -04:00
2015-06-07 17:18:02 -04:00
if ( $data [ " alias " ] != " " ) {
2017-03-30 15:32:12 -04:00
$newtag = '@[url=' . $data [ " alias " ] . ']' . $data [ " name " ] . '[/url]' ;
if ( ! stristr ( $str_tags , $newtag )) {
if ( strlen ( $str_tags )) {
2015-06-07 17:18:02 -04:00
$str_tags .= ',' ;
2017-03-30 15:32:12 -04:00
}
2015-06-07 17:18:02 -04:00
$str_tags .= $newtag ;
}
}
}
2012-05-03 01:33:51 -04:00
return $replaced ;
2015-06-07 17:18:02 -04:00
}
2012-03-16 09:02:26 -04:00
$stat = false ;
2012-03-12 08:59:00 -04:00
//get the person's name
2017-03-30 15:32:12 -04:00
$name = substr ( $tag , 1 );
2016-01-07 17:43:16 -05:00
2016-01-07 18:35:46 -05:00
// Sometimes the tag detection doesn't seem to work right
// This is some workaround
$nameparts = explode ( " " , $name );
$name = $nameparts [ 0 ];
2016-01-07 17:43:16 -05:00
// Try to detect the contact in various ways
2017-03-30 15:32:12 -04:00
if (( strpos ( $name , '@' )) || ( strpos ( $name , 'http://' ))) {
2016-01-07 17:43:16 -05:00
// Is it in format @user@domain.tld or @http://domain.tld/...?
// First check the contact table for the address
2017-11-02 17:25:20 -04:00
$r = q ( " SELECT `id`, `url`, `nick`, `name`, `alias`, `network`, `notify`, `forum`, `prv` FROM `contact`
2016-04-23 04:46:16 -04:00
WHERE `addr` = '%s' AND `uid` = % d AND
( `network` != '%s' OR ( `notify` != '' AND `alias` != '' ))
LIMIT 1 " ,
2016-01-07 17:43:16 -05:00
dbesc ( $name ),
2016-04-23 04:46:16 -04:00
intval ( $profile_uid ),
dbesc ( NETWORK_OSTATUS )
2016-01-07 17:43:16 -05:00
);
// Then check in the contact table for the url
2017-11-07 22:57:46 -05:00
if ( ! DBM :: is_result ( $r )) {
2017-11-02 17:25:20 -04:00
$r = q ( " SELECT `id`, `url`, `nick`, `name`, `alias`, `network`, `notify`, `forum`, `prv` FROM `contact`
2016-04-23 04:46:16 -04:00
WHERE `nurl` = '%s' AND `uid` = % d AND
( `network` != '%s' OR ( `notify` != '' AND `alias` != '' ))
LIMIT 1 " ,
2016-01-07 17:43:16 -05:00
dbesc ( normalise_link ( $name )),
2016-04-23 04:46:16 -04:00
intval ( $profile_uid ),
dbesc ( NETWORK_OSTATUS )
2016-01-07 17:43:16 -05:00
);
2017-03-30 15:32:12 -04:00
}
2016-01-07 17:43:16 -05:00
// Then check in the global contacts for the address
2017-11-07 22:57:46 -05:00
if ( ! DBM :: is_result ( $r )) {
2016-04-23 04:46:16 -04:00
$r = q ( " SELECT `url`, `nick`, `name`, `alias`, `network`, `notify` FROM `gcontact`
WHERE `addr` = '%s' AND ( `network` != '%s' OR ( `notify` != '' AND `alias` != '' ))
LIMIT 1 " ,
dbesc ( $name ),
dbesc ( NETWORK_OSTATUS )
);
2017-03-30 15:32:12 -04:00
}
2016-01-07 17:43:16 -05:00
// Then check in the global contacts for the url
2017-11-07 22:57:46 -05:00
if ( ! DBM :: is_result ( $r )) {
2016-04-23 04:46:16 -04:00
$r = q ( " SELECT `url`, `nick`, `name`, `alias`, `network`, `notify` FROM `gcontact`
WHERE `nurl` = '%s' AND ( `network` != '%s' OR ( `notify` != '' AND `alias` != '' ))
LIMIT 1 " ,
dbesc ( normalise_link ( $name )),
dbesc ( NETWORK_OSTATUS )
);
2017-03-30 15:32:12 -04:00
}
2016-01-07 17:43:16 -05:00
2017-11-07 22:57:46 -05:00
if ( ! DBM :: is_result ( $r )) {
2017-11-06 21:22:52 -05:00
$probed = Probe :: uri ( $name );
2016-04-20 01:00:55 -04:00
if ( $result [ 'network' ] != NETWORK_PHANTOM ) {
2017-12-07 09:09:28 -05:00
GContact :: update ( $probed );
2016-01-07 17:43:16 -05:00
$r = q ( " SELECT `url`, `name`, `nick`, `network`, `alias`, `notify` FROM `gcontact` WHERE `nurl` = '%s' LIMIT 1 " ,
dbesc ( normalise_link ( $probed [ " url " ])));
}
}
2016-01-07 18:35:46 -05:00
} else {
2016-01-07 17:43:16 -05:00
$r = false ;
2017-03-31 14:51:18 -04:00
if ( strrpos ( $name , '+' )) {
2016-01-07 17:43:16 -05:00
// Is it in format @nick+number?
2017-03-31 14:51:18 -04:00
$tagcid = intval ( substr ( $name , strrpos ( $name , '+' ) + 1 ));
2016-01-07 17:43:16 -05:00
$r = q ( " SELECT `id`, `url`, `nick`, `name`, `alias`, `network` FROM `contact` WHERE `id` = %d AND `uid` = %d LIMIT 1 " ,
intval ( $tagcid ),
intval ( $profile_uid )
);
}
2017-03-30 15:32:12 -04:00
// select someone by attag or nick and the name passed in the current network
2018-01-09 15:50:06 -05:00
if ( ! DBM :: is_result ( $r ) && ( $network != " " ))
2016-01-07 17:43:16 -05:00
$r = q ( " SELECT `id`, `url`, `nick`, `name`, `alias`, `network` FROM `contact` WHERE `attag` = '%s' OR `nick` = '%s' AND `network` = '%s' AND `uid` = %d ORDER BY `attag` DESC LIMIT 1 " ,
dbesc ( $name ),
dbesc ( $name ),
dbesc ( $network ),
intval ( $profile_uid )
);
//select someone from this user's contacts by name in the current network
2017-11-07 22:57:46 -05:00
if ( ! DBM :: is_result ( $r ) && ( $network != " " )) {
2016-01-07 17:43:16 -05:00
$r = q ( " SELECT `id`, `url`, `nick`, `name`, `alias`, `network` FROM `contact` WHERE `name` = '%s' AND `network` = '%s' AND `uid` = %d LIMIT 1 " ,
2016-04-13 01:00:36 -04:00
dbesc ( $name ),
2016-01-07 17:43:16 -05:00
dbesc ( $network ),
intval ( $profile_uid )
);
2017-03-30 15:32:12 -04:00
}
2016-01-07 17:43:16 -05:00
2017-03-30 15:32:12 -04:00
// select someone by attag or nick and the name passed in
2018-01-09 15:50:06 -05:00
if ( ! DBM :: is_result ( $r )) {
2016-01-07 17:43:16 -05:00
$r = q ( " SELECT `id`, `url`, `nick`, `name`, `alias`, `network` FROM `contact` WHERE `attag` = '%s' OR `nick` = '%s' AND `uid` = %d ORDER BY `attag` DESC LIMIT 1 " ,
dbesc ( $name ),
dbesc ( $name ),
intval ( $profile_uid )
);
2017-03-30 15:32:12 -04:00
}
2017-03-21 12:02:59 -04:00
2017-03-30 15:32:12 -04:00
// select someone from this user's contacts by name
2018-01-09 15:50:06 -05:00
if ( ! DBM :: is_result ( $r )) {
2016-01-07 17:43:16 -05:00
$r = q ( " SELECT `id`, `url`, `nick`, `name`, `alias`, `network` FROM `contact` WHERE `name` = '%s' AND `uid` = %d LIMIT 1 " ,
2016-04-13 01:00:36 -04:00
dbesc ( $name ),
2016-01-07 17:43:16 -05:00
intval ( $profile_uid )
);
2017-03-30 15:32:12 -04:00
}
2016-01-07 17:43:16 -05:00
}
2017-11-07 22:57:46 -05:00
if ( DBM :: is_result ( $r )) {
2017-06-07 22:00:59 -04:00
if ( strlen ( $inform ) && ( isset ( $r [ 0 ][ " notify " ]) || isset ( $r [ 0 ][ " id " ]))) {
2016-01-07 17:43:16 -05:00
$inform .= ',' ;
2017-03-30 15:32:12 -04:00
}
2016-01-07 17:43:16 -05:00
2017-03-30 15:32:12 -04:00
if ( isset ( $r [ 0 ][ " id " ])) {
2016-01-07 17:43:16 -05:00
$inform .= 'cid:' . $r [ 0 ][ " id " ];
2017-03-30 15:32:12 -04:00
} elseif ( isset ( $r [ 0 ][ " notify " ])) {
2016-01-07 17:43:16 -05:00
$inform .= $r [ 0 ][ " notify " ];
2017-03-30 15:32:12 -04:00
}
2016-01-07 17:43:16 -05:00
$profile = $r [ 0 ][ " url " ];
$alias = $r [ 0 ][ " alias " ];
$newname = $r [ 0 ][ " nick " ];
2017-06-07 22:00:59 -04:00
if (( $newname == " " ) || (( $r [ 0 ][ " network " ] != NETWORK_OSTATUS ) && ( $r [ 0 ][ " network " ] != NETWORK_TWITTER )
&& ( $r [ 0 ][ " network " ] != NETWORK_STATUSNET ) && ( $r [ 0 ][ " network " ] != NETWORK_APPNET ))) {
2016-01-07 17:43:16 -05:00
$newname = $r [ 0 ][ " name " ];
2017-03-30 15:32:12 -04:00
}
2016-01-07 17:43:16 -05:00
}
2012-03-16 09:02:26 -04:00
//if there is an url for this persons profile
2017-06-07 22:00:59 -04:00
if ( isset ( $profile ) && ( $newname != " " )) {
2012-05-03 01:33:51 -04:00
$replaced = true ;
2017-03-30 15:32:12 -04:00
// create profile link
2017-03-31 14:52:32 -04:00
$profile = str_replace ( ',' , '%2c' , $profile );
2017-10-31 15:33:23 -04:00
$newtag = $tag_type . '[url=' . $profile . ']' . $newname . '[/url]' ;
$body = str_replace ( $tag_type . $name , $newtag , $body );
2017-03-30 15:32:12 -04:00
// append tag to str_tags
2018-01-09 15:03:00 -05:00
if ( ! stristr ( $str_tags , $newtag )) {
2017-03-30 15:32:12 -04:00
if ( strlen ( $str_tags )) {
2012-03-16 09:02:26 -04:00
$str_tags .= ',' ;
2017-03-30 15:32:12 -04:00
}
2012-03-16 09:02:26 -04:00
$str_tags .= $newtag ;
}
2014-08-25 08:09:56 -04:00
2017-03-31 14:51:18 -04:00
/*
* Status . Net seems to require the numeric ID URL in a mention if the person isn ' t
* subscribed to you . But the nickname URL is OK if they are . Grrr . We ' ll tag both .
*/
2017-03-30 15:32:12 -04:00
if ( strlen ( $alias )) {
2017-03-31 14:51:18 -04:00
$newtag = '@[url=' . $alias . ']' . $newname . '[/url]' ;
2018-01-09 15:03:00 -05:00
if ( ! stristr ( $str_tags , $newtag )) {
2017-03-30 15:32:12 -04:00
if ( strlen ( $str_tags )) {
2012-03-16 09:02:26 -04:00
$str_tags .= ',' ;
2017-03-30 15:32:12 -04:00
}
2012-03-16 09:02:26 -04:00
$str_tags .= $newtag ;
}
}
}
2012-03-09 06:57:11 -05:00
}
2012-05-03 01:33:51 -04:00
2018-01-15 08:05:12 -05:00
return [ 'replaced' => $replaced , 'contact' => $r [ 0 ]];
2012-03-09 06:57:11 -05:00
}