2017-11-19 16:55:28 -05:00
< ? php
/**
2017-12-07 09:04:24 -05:00
* @ file src / Model / Contact . php
2017-11-19 16:55:28 -05:00
*/
2017-12-07 09:04:24 -05:00
namespace Friendica\Model ;
2017-11-19 16:55:28 -05:00
use Friendica\BaseObject ;
2018-10-24 02:15:24 -04:00
use Friendica\Content\Pager ;
2018-01-09 10:02:53 -05:00
use Friendica\Core\Config ;
2018-11-10 08:18:16 -05:00
use Friendica\Core\Hook ;
2018-01-22 09:54:13 -05:00
use Friendica\Core\L10n ;
2018-10-29 17:20:46 -04:00
use Friendica\Core\Logger ;
2018-08-11 16:40:44 -04:00
use Friendica\Core\Protocol ;
2017-11-19 16:55:28 -05:00
use Friendica\Core\System ;
use Friendica\Core\Worker ;
2018-07-20 08:19:26 -04:00
use Friendica\Database\DBA ;
2018-01-24 20:47:33 -05:00
use Friendica\Network\Probe ;
2018-07-19 22:15:21 -04:00
use Friendica\Object\Image ;
2018-09-15 14:54:45 -04:00
use Friendica\Protocol\ActivityPub ;
2018-09-05 01:02:06 -04:00
use Friendica\Protocol\DFRN ;
2018-10-21 01:53:47 -04:00
use Friendica\Protocol\Diaspora ;
2017-11-19 16:55:28 -05:00
use Friendica\Protocol\OStatus ;
2018-01-09 09:44:22 -05:00
use Friendica\Protocol\PortableContact ;
2017-12-02 09:32:45 -05:00
use Friendica\Protocol\Salmon ;
2018-01-26 21:38:34 -05:00
use Friendica\Util\DateTimeFormat ;
2018-01-26 23:51:41 -05:00
use Friendica\Util\Network ;
2018-11-08 08:45:46 -05:00
use Friendica\Util\Strings ;
2017-11-19 16:55:28 -05:00
2017-11-22 09:02:55 -05:00
/**
* @ brief functions for interacting with a contact
*/
2017-11-19 16:55:28 -05:00
class Contact extends BaseObject
{
2018-07-27 19:25:57 -04:00
/**
2019-01-06 12:37:48 -05:00
* @ deprecated since version 2019.03
* @ see User :: PAGE_FLAGS_NORMAL
2018-07-27 19:25:57 -04:00
*/
2019-01-06 12:37:48 -05:00
const PAGE_NORMAL = User :: PAGE_FLAGS_NORMAL ;
/**
* @ deprecated since version 2019.03
* @ see User :: PAGE_FLAGS_SOAPBOX
*/
const PAGE_SOAPBOX = User :: PAGE_FLAGS_SOAPBOX ;
/**
* @ deprecated since version 2019.03
* @ see User :: PAGE_FLAGS_COMMUNITY
*/
const PAGE_COMMUNITY = User :: PAGE_FLAGS_COMMUNITY ;
/**
* @ deprecated since version 2019.03
* @ see User :: PAGE_FLAGS_FREELOVE
*/
const PAGE_FREELOVE = User :: PAGE_FLAGS_FREELOVE ;
/**
* @ deprecated since version 2019.03
* @ see User :: PAGE_FLAGS_BLOG
*/
const PAGE_BLOG = User :: PAGE_FLAGS_BLOG ;
/**
* @ deprecated since version 2019.03
* @ see User :: PAGE_FLAGS_PRVGROUP
*/
const PAGE_PRVGROUP = User :: PAGE_FLAGS_PRVGROUP ;
2018-07-27 19:25:57 -04:00
/**
* @ }
*/
/**
2019-01-12 14:52:36 -05:00
* Account types
2018-07-27 19:25:57 -04:00
*
2019-01-06 17:08:35 -05:00
* TYPE_UNKNOWN - the account has been imported from gcontact where this is the default type value
*
* TYPE_PERSON - the account belongs to a person
2018-07-27 19:25:57 -04:00
* Associated page types : PAGE_NORMAL , PAGE_SOAPBOX , PAGE_FREELOVE
*
2019-01-06 17:08:35 -05:00
* TYPE_ORGANISATION - the account belongs to an organisation
2018-07-27 19:25:57 -04:00
* Associated page type : PAGE_SOAPBOX
*
2019-01-06 17:08:35 -05:00
* TYPE_NEWS - the account is a news reflector
2018-07-27 19:25:57 -04:00
* Associated page type : PAGE_SOAPBOX
*
2019-01-06 17:08:35 -05:00
* TYPE_COMMUNITY - the account is community forum
2018-07-27 19:25:57 -04:00
* Associated page types : PAGE_COMMUNITY , PAGE_PRVGROUP
*
2019-01-06 17:08:35 -05:00
* TYPE_RELAY - the account is a relay
2018-07-27 19:25:57 -04:00
* This will only be assigned to contacts , not to user accounts
* @ {
*/
2019-01-06 17:08:35 -05:00
const TYPE_UNKNOWN = - 1 ;
const TYPE_PERSON = User :: ACCOUNT_TYPE_PERSON ;
const TYPE_ORGANISATION = User :: ACCOUNT_TYPE_ORGANISATION ;
const TYPE_NEWS = User :: ACCOUNT_TYPE_NEWS ;
const TYPE_COMMUNITY = User :: ACCOUNT_TYPE_COMMUNITY ;
const TYPE_RELAY = User :: ACCOUNT_TYPE_RELAY ;
2018-07-27 19:25:57 -04:00
/**
* @ }
*/
2018-07-24 22:53:46 -04:00
/**
2019-01-06 16:06:53 -05:00
* Contact_is
2018-07-24 22:53:46 -04:00
*
* Relationship types
* @ {
*/
const FOLLOWER = 1 ;
const SHARING = 2 ;
const FRIEND = 3 ;
/**
* @ }
*/
2019-03-01 04:50:31 -05:00
/**
* @ param integer $id
* @ return array | boolean Contact record if it exists , false otherwise
* @ throws \Exception
*/
public static function getById ( $id )
{
return DBA :: selectFirst ( 'contact' , [], [ 'id' => $id ]);
}
2018-12-08 15:28:01 -05:00
/**
* @ brief Tests if the given contact is a follower
*
* @ param int $cid Either public contact id or user ' s contact id
* @ param int $uid User ID
*
* @ return boolean is the contact id a follower ?
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2018-12-08 15:28:01 -05:00
*/
public static function isFollower ( $cid , $uid )
{
if ( self :: isBlockedByUser ( $cid , $uid )) {
return false ;
}
$cdata = self :: getPublicAndUserContacID ( $cid , $uid );
if ( empty ( $cdata [ 'user' ])) {
return false ;
}
$condition = [ 'id' => $cdata [ 'user' ], 'rel' => [ self :: FOLLOWER , self :: FRIEND ]];
return DBA :: exists ( 'contact' , $condition );
}
2018-12-04 02:12:55 -05:00
/**
* @ brief Get the basepath for a given contact link
2019-01-06 16:06:53 -05:00
* @ todo Add functionality to store this value in the contact table
2018-12-04 02:12:55 -05:00
*
* @ param string $url The contact link
*
* @ return string basepath
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2018-12-04 02:12:55 -05:00
*/
public static function getBasepath ( $url )
{
$data = Probe :: uri ( $url );
if ( ! empty ( $data [ 'baseurl' ])) {
return $data [ 'baseurl' ];
}
2018-12-04 09:17:55 -05:00
// When we can't probe the server, we use some ugly function that does some pattern matching
return PortableContact :: detectServer ( $url );
2018-12-04 02:12:55 -05:00
}
2019-02-10 12:19:10 -05:00
/**
* Returns the public contact id of the given user id
*
* @ param integer $uid User ID
*
* @ return integer | boolean Public contact id for given user id
* @ throws Exception
*/
public static function getPublicIdByUserId ( $uid )
{
$self = DBA :: selectFirst ( 'contact' , [ 'url' ], [ 'self' => true , 'uid' => $uid ]);
if ( ! DBA :: isResult ( $self )) {
return false ;
}
return self :: getIdForURL ( $self [ 'url' ], 0 , true );
}
2018-08-25 09:48:00 -04:00
/**
* @ brief Returns the contact id for the user and the public contact id for a given contact id
*
* @ param int $cid Either public contact id or user ' s contact id
* @ param int $uid User ID
*
* @ return array with public and user ' s contact id
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2018-08-25 09:48:00 -04:00
*/
2018-12-08 15:28:01 -05:00
public static function getPublicAndUserContacID ( $cid , $uid )
2018-08-25 09:48:00 -04:00
{
if ( empty ( $uid ) || empty ( $cid )) {
return [];
}
$contact = DBA :: selectFirst ( 'contact' , [ 'id' , 'uid' , 'url' ], [ 'id' => $cid ]);
if ( ! DBA :: isResult ( $contact )) {
return [];
}
// We quit when the user id don't match the user id of the provided contact
if (( $contact [ 'uid' ] != $uid ) && ( $contact [ 'uid' ] != 0 )) {
return [];
}
if ( $contact [ 'uid' ] != 0 ) {
$pcid = Contact :: getIdForURL ( $contact [ 'url' ], 0 , true , [ 'url' => $contact [ 'url' ]]);
if ( empty ( $pcid )) {
return [];
}
$ucid = $contact [ 'id' ];
} else {
$pcid = $contact [ 'id' ];
$ucid = Contact :: getIdForURL ( $contact [ 'url' ], $uid , true );
}
return [ 'public' => $pcid , 'user' => $ucid ];
}
/**
* @ brief Block contact id for user id
*
* @ param int $cid Either public contact id or user ' s contact id
* @ param int $uid User ID
* @ param boolean $blocked Is the contact blocked or unblocked ?
2019-01-06 16:06:53 -05:00
* @ throws \Exception
2018-08-25 09:48:00 -04:00
*/
public static function setBlockedForUser ( $cid , $uid , $blocked )
{
$cdata = self :: getPublicAndUserContacID ( $cid , $uid );
if ( empty ( $cdata )) {
return ;
}
if ( $cdata [ 'user' ] != 0 ) {
DBA :: update ( 'contact' , [ 'blocked' => $blocked ], [ 'id' => $cdata [ 'user' ], 'pending' => false ]);
}
DBA :: update ( 'user-contact' , [ 'blocked' => $blocked ], [ 'cid' => $cdata [ 'public' ], 'uid' => $uid ], true );
2019-02-23 15:26:06 -05:00
if ( $blocked ) {
// Blocked contact can't be in any group
self :: removeFromGroups ( $cid );
}
2018-08-25 09:48:00 -04:00
}
/**
* @ brief Returns " block " state for contact id and user id
*
* @ param int $cid Either public contact id or user ' s contact id
* @ param int $uid User ID
*
* @ return boolean is the contact id blocked for the given user ?
2019-01-06 16:06:53 -05:00
* @ throws \Exception
2018-08-25 09:48:00 -04:00
*/
public static function isBlockedByUser ( $cid , $uid )
{
$cdata = self :: getPublicAndUserContacID ( $cid , $uid );
if ( empty ( $cdata )) {
return ;
}
$public_blocked = false ;
if ( ! empty ( $cdata [ 'public' ])) {
$public_contact = DBA :: selectFirst ( 'user-contact' , [ 'blocked' ], [ 'cid' => $cdata [ 'public' ], 'uid' => $uid ]);
if ( DBA :: isResult ( $public_contact )) {
$public_blocked = $public_contact [ 'blocked' ];
}
}
$user_blocked = $public_blocked ;
if ( ! empty ( $cdata [ 'user' ])) {
$user_contact = DBA :: selectFirst ( 'contact' , [ 'blocked' ], [ 'id' => $cdata [ 'user' ], 'pending' => false ]);
if ( DBA :: isResult ( $user_contact )) {
$user_blocked = $user_contact [ 'blocked' ];
}
}
if ( $user_blocked != $public_blocked ) {
DBA :: update ( 'user-contact' , [ 'blocked' => $user_blocked ], [ 'cid' => $cdata [ 'public' ], 'uid' => $uid ], true );
}
return $user_blocked ;
}
/**
* @ brief Ignore contact id for user id
*
* @ param int $cid Either public contact id or user ' s contact id
* @ param int $uid User ID
* @ param boolean $ignored Is the contact ignored or unignored ?
2019-01-06 16:06:53 -05:00
* @ throws \Exception
2018-08-25 09:48:00 -04:00
*/
public static function setIgnoredForUser ( $cid , $uid , $ignored )
{
$cdata = self :: getPublicAndUserContacID ( $cid , $uid );
if ( empty ( $cdata )) {
return ;
}
if ( $cdata [ 'user' ] != 0 ) {
DBA :: update ( 'contact' , [ 'readonly' => $ignored ], [ 'id' => $cdata [ 'user' ], 'pending' => false ]);
}
DBA :: update ( 'user-contact' , [ 'ignored' => $ignored ], [ 'cid' => $cdata [ 'public' ], 'uid' => $uid ], true );
}
/**
* @ brief Returns " ignore " state for contact id and user id
*
* @ param int $cid Either public contact id or user ' s contact id
* @ param int $uid User ID
*
* @ return boolean is the contact id ignored for the given user ?
2019-01-06 16:06:53 -05:00
* @ throws \Exception
2018-08-25 09:48:00 -04:00
*/
public static function isIgnoredByUser ( $cid , $uid )
{
$cdata = self :: getPublicAndUserContacID ( $cid , $uid );
if ( empty ( $cdata )) {
return ;
}
$public_ignored = false ;
if ( ! empty ( $cdata [ 'public' ])) {
$public_contact = DBA :: selectFirst ( 'user-contact' , [ 'ignored' ], [ 'cid' => $cdata [ 'public' ], 'uid' => $uid ]);
if ( DBA :: isResult ( $public_contact )) {
$public_ignored = $public_contact [ 'ignored' ];
}
}
$user_ignored = $public_ignored ;
if ( ! empty ( $cdata [ 'user' ])) {
$user_contact = DBA :: selectFirst ( 'contact' , [ 'readonly' ], [ 'id' => $cdata [ 'user' ], 'pending' => false ]);
if ( DBA :: isResult ( $user_contact )) {
$user_ignored = $user_contact [ 'readonly' ];
}
}
if ( $user_ignored != $public_ignored ) {
DBA :: update ( 'user-contact' , [ 'ignored' => $user_ignored ], [ 'cid' => $cdata [ 'public' ], 'uid' => $uid ], true );
}
return $user_ignored ;
}
/**
* @ brief Set " collapsed " for contact id and user id
*
* @ param int $cid Either public contact id or user ' s contact id
* @ param int $uid User ID
* @ param boolean $collapsed are the contact ' s posts collapsed or uncollapsed ?
2019-01-06 16:06:53 -05:00
* @ throws \Exception
2018-08-25 09:48:00 -04:00
*/
public static function setCollapsedForUser ( $cid , $uid , $collapsed )
{
$cdata = self :: getPublicAndUserContacID ( $cid , $uid );
if ( empty ( $cdata )) {
return ;
}
DBA :: update ( 'user-contact' , [ 'collapsed' => $collapsed ], [ 'cid' => $cdata [ 'public' ], 'uid' => $uid ], true );
}
/**
* @ brief Returns " collapsed " state for contact id and user id
*
* @ param int $cid Either public contact id or user ' s contact id
* @ param int $uid User ID
*
* @ return boolean is the contact id blocked for the given user ?
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2018-08-25 09:48:00 -04:00
*/
public static function isCollapsedByUser ( $cid , $uid )
{
$cdata = self :: getPublicAndUserContacID ( $cid , $uid );
if ( empty ( $cdata )) {
return ;
}
$collapsed = false ;
if ( ! empty ( $cdata [ 'public' ])) {
$public_contact = DBA :: selectFirst ( 'user-contact' , [ 'collapsed' ], [ 'cid' => $cdata [ 'public' ], 'uid' => $uid ]);
if ( DBA :: isResult ( $public_contact )) {
$collapsed = $public_contact [ 'collapsed' ];
}
}
return $collapsed ;
}
2017-12-09 13:31:00 -05:00
/**
* @ brief Returns a list of contacts belonging in a group
*
* @ param int $gid
* @ return array
2019-01-06 16:06:53 -05:00
* @ throws \Exception
2017-12-09 13:31:00 -05:00
*/
public static function getByGroupId ( $gid )
{
$return = [];
2018-07-27 19:25:57 -04:00
2017-12-09 13:31:00 -05:00
if ( intval ( $gid )) {
2018-07-20 08:19:26 -04:00
$stmt = DBA :: p ( ' SELECT `group_member` . `contact-id` , `contact` .*
2017-12-09 13:31:00 -05:00
FROM `contact`
INNER JOIN `group_member`
ON `contact` . `id` = `group_member` . `contact-id`
WHERE `gid` = ?
2017-12-14 22:47:58 -05:00
AND `contact` . `uid` = ?
2017-12-09 13:31:00 -05:00
AND NOT `contact` . `self`
2019-01-12 08:28:14 -05:00
AND NOT `contact` . `deleted`
2017-12-09 13:31:00 -05:00
AND NOT `contact` . `blocked`
AND NOT `contact` . `pending`
ORDER BY `contact` . `name` ASC ' ,
$gid ,
local_user ()
);
2018-07-27 19:25:57 -04:00
2018-07-21 08:46:04 -04:00
if ( DBA :: isResult ( $stmt )) {
2018-07-20 22:03:40 -04:00
$return = DBA :: toArray ( $stmt );
2017-12-09 13:31:00 -05:00
}
}
return $return ;
}
/**
* @ brief Returns the count of OStatus contacts in a group
*
* @ param int $gid
* @ return int
2019-01-06 16:06:53 -05:00
* @ throws \Exception
2017-12-09 13:31:00 -05:00
*/
public static function getOStatusCountByGroupId ( $gid )
{
$return = 0 ;
if ( intval ( $gid )) {
2018-07-20 22:01:53 -04:00
$contacts = DBA :: fetchFirst ( ' SELECT COUNT ( * ) AS `count`
2017-12-09 13:31:00 -05:00
FROM `contact`
INNER JOIN `group_member`
ON `contact` . `id` = `group_member` . `contact-id`
WHERE `gid` = ?
2017-12-14 22:47:58 -05:00
AND `contact` . `uid` = ?
2017-12-09 13:31:00 -05:00
AND `contact` . `network` = ?
AND `contact` . `notify` != " " ' ,
$gid ,
local_user (),
2018-08-11 16:40:44 -04:00
Protocol :: OSTATUS
2017-12-09 13:31:00 -05:00
);
$return = $contacts [ 'count' ];
}
return $return ;
}
2017-12-03 22:27:49 -05:00
/**
* Creates the self - contact for the provided user id
*
* @ param int $uid
* @ return bool Operation success
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
2017-12-03 22:27:49 -05:00
*/
public static function createSelfFromUserId ( $uid )
{
// Only create the entry if it doesn't exist yet
2018-07-20 08:19:26 -04:00
if ( DBA :: exists ( 'contact' , [ 'uid' => $uid , 'self' => true ])) {
2017-12-03 22:27:49 -05:00
return true ;
}
2018-07-20 08:19:26 -04:00
$user = DBA :: selectFirst ( 'user' , [ 'uid' , 'username' , 'nickname' ], [ 'uid' => $uid ]);
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $user )) {
2017-12-03 22:27:49 -05:00
return false ;
}
2018-07-20 08:19:26 -04:00
$return = DBA :: insert ( 'contact' , [
2017-12-03 22:27:49 -05:00
'uid' => $user [ 'uid' ],
2018-01-26 21:38:34 -05:00
'created' => DateTimeFormat :: utcNow (),
2017-12-03 22:27:49 -05:00
'self' => 1 ,
'name' => $user [ 'username' ],
'nick' => $user [ 'nickname' ],
'photo' => System :: baseUrl () . '/photo/profile/' . $user [ 'uid' ] . '.jpg' ,
'thumb' => System :: baseUrl () . '/photo/avatar/' . $user [ 'uid' ] . '.jpg' ,
'micro' => System :: baseUrl () . '/photo/micro/' . $user [ 'uid' ] . '.jpg' ,
'blocked' => 0 ,
'pending' => 0 ,
'url' => System :: baseUrl () . '/profile/' . $user [ 'nickname' ],
2018-11-08 11:28:29 -05:00
'nurl' => Strings :: normaliseLink ( System :: baseUrl () . '/profile/' . $user [ 'nickname' ]),
2017-12-03 22:27:49 -05:00
'addr' => $user [ 'nickname' ] . '@' . substr ( System :: baseUrl (), strpos ( System :: baseUrl (), '://' ) + 3 ),
'request' => System :: baseUrl () . '/dfrn_request/' . $user [ 'nickname' ],
'notify' => System :: baseUrl () . '/dfrn_notify/' . $user [ 'nickname' ],
'poll' => System :: baseUrl () . '/dfrn_poll/' . $user [ 'nickname' ],
'confirm' => System :: baseUrl () . '/dfrn_confirm/' . $user [ 'nickname' ],
'poco' => System :: baseUrl () . '/poco/' . $user [ 'nickname' ],
2018-01-26 21:38:34 -05:00
'name-date' => DateTimeFormat :: utcNow (),
'uri-date' => DateTimeFormat :: utcNow (),
'avatar-date' => DateTimeFormat :: utcNow (),
2017-12-03 22:27:49 -05:00
'closeness' => 0
]);
return $return ;
}
2018-03-24 02:15:18 -04:00
/**
* Updates the self - contact for the provided user id
*
2019-01-06 16:06:53 -05:00
* @ param int $uid
2018-03-24 02:15:18 -04:00
* @ param boolean $update_avatar Force the avatar update
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
2018-03-24 02:15:18 -04:00
*/
public static function updateSelfFromUserID ( $uid , $update_avatar = false )
{
$fields = [ 'id' , 'name' , 'nick' , 'location' , 'about' , 'keywords' , 'gender' , 'avatar' ,
2018-12-22 15:12:32 -05:00
'xmpp' , 'contact-type' , 'forum' , 'prv' , 'avatar-date' , 'url' , 'nurl' ,
'photo' , 'thumb' , 'micro' , 'addr' , 'request' , 'notify' , 'poll' , 'confirm' , 'poco' ];
2018-07-20 08:19:26 -04:00
$self = DBA :: selectFirst ( 'contact' , $fields , [ 'uid' => $uid , 'self' => true ]);
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $self )) {
2018-03-24 02:15:18 -04:00
return ;
}
$fields = [ 'nickname' , 'page-flags' , 'account-type' ];
2018-07-20 08:19:26 -04:00
$user = DBA :: selectFirst ( 'user' , $fields , [ 'uid' => $uid ]);
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $user )) {
2018-03-24 02:15:18 -04:00
return ;
}
$fields = [ 'name' , 'photo' , 'thumb' , 'about' , 'address' , 'locality' , 'region' ,
'country-name' , 'gender' , 'pub_keywords' , 'xmpp' ];
2018-07-20 08:19:26 -04:00
$profile = DBA :: selectFirst ( 'profile' , $fields , [ 'uid' => $uid , 'is-default' => true ]);
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $profile )) {
2018-03-24 02:15:18 -04:00
return ;
}
$fields = [ 'name' => $profile [ 'name' ], 'nick' => $user [ 'nickname' ],
2018-03-25 04:15:22 -04:00
'avatar-date' => $self [ 'avatar-date' ], 'location' => Profile :: formatLocation ( $profile ),
2018-03-24 02:15:18 -04:00
'about' => $profile [ 'about' ], 'keywords' => $profile [ 'pub_keywords' ],
'gender' => $profile [ 'gender' ], 'avatar' => $profile [ 'photo' ],
'contact-type' => $user [ 'account-type' ], 'xmpp' => $profile [ 'xmpp' ]];
2018-12-11 14:03:29 -05:00
$avatar = Photo :: selectFirst ([ 'resource-id' , 'type' ], [ 'uid' => $uid , 'profile' => true ]);
2018-07-21 08:46:04 -04:00
if ( DBA :: isResult ( $avatar )) {
2018-03-25 13:26:40 -04:00
if ( $update_avatar ) {
$fields [ 'avatar-date' ] = DateTimeFormat :: utcNow ();
}
2018-03-25 04:15:22 -04:00
2018-03-25 13:26:40 -04:00
// Creating the path to the avatar, beginning with the file suffix
$types = Image :: supportedTypes ();
if ( isset ( $types [ $avatar [ 'type' ]])) {
$file_suffix = $types [ $avatar [ 'type' ]];
} else {
$file_suffix = 'jpg' ;
}
2018-03-25 04:15:22 -04:00
2018-03-25 13:26:40 -04:00
// We are adding a timestamp value so that other systems won't use cached content
$timestamp = strtotime ( $fields [ 'avatar-date' ]);
2018-03-25 04:15:22 -04:00
2018-03-25 13:26:40 -04:00
$prefix = System :: baseUrl () . '/photo/' . $avatar [ 'resource-id' ] . '-' ;
$suffix = '.' . $file_suffix . '?ts=' . $timestamp ;
2018-03-25 04:15:22 -04:00
2018-03-25 13:26:40 -04:00
$fields [ 'photo' ] = $prefix . '4' . $suffix ;
$fields [ 'thumb' ] = $prefix . '5' . $suffix ;
$fields [ 'micro' ] = $prefix . '6' . $suffix ;
} else {
// We hadn't found a photo entry, so we use the default avatar
2018-10-23 10:36:57 -04:00
$fields [ 'photo' ] = System :: baseUrl () . '/images/person-300.jpg' ;
2018-03-25 13:26:40 -04:00
$fields [ 'thumb' ] = System :: baseUrl () . '/images/person-80.jpg' ;
$fields [ 'micro' ] = System :: baseUrl () . '/images/person-48.jpg' ;
}
2018-03-24 02:15:18 -04:00
2019-01-06 12:37:48 -05:00
$fields [ 'forum' ] = $user [ 'page-flags' ] == User :: PAGE_FLAGS_COMMUNITY ;
$fields [ 'prv' ] = $user [ 'page-flags' ] == User :: PAGE_FLAGS_PRVGROUP ;
2018-03-24 02:15:18 -04:00
2018-05-18 08:26:10 -04:00
// it seems as if ported accounts can have wrong values, so we make sure that now everything is fine.
$fields [ 'url' ] = System :: baseUrl () . '/profile/' . $user [ 'nickname' ];
2018-11-08 11:28:29 -05:00
$fields [ 'nurl' ] = Strings :: normaliseLink ( $fields [ 'url' ]);
2018-05-18 08:26:10 -04:00
$fields [ 'addr' ] = $user [ 'nickname' ] . '@' . substr ( System :: baseUrl (), strpos ( System :: baseUrl (), '://' ) + 3 );
$fields [ 'request' ] = System :: baseUrl () . '/dfrn_request/' . $user [ 'nickname' ];
2018-12-22 15:12:32 -05:00
$fields [ 'notify' ] = System :: baseUrl () . '/dfrn_notify/' . $user [ 'nickname' ];
$fields [ 'poll' ] = System :: baseUrl () . '/dfrn_poll/' . $user [ 'nickname' ];
2018-05-18 08:26:10 -04:00
$fields [ 'confirm' ] = System :: baseUrl () . '/dfrn_confirm/' . $user [ 'nickname' ];
2018-12-22 15:12:32 -05:00
$fields [ 'poco' ] = System :: baseUrl () . '/poco/' . $user [ 'nickname' ];
2018-05-18 08:26:10 -04:00
2018-03-24 02:15:18 -04:00
$update = false ;
foreach ( $fields as $field => $content ) {
2018-12-22 15:12:32 -05:00
if ( $self [ $field ] != $content ) {
2018-03-24 02:15:18 -04:00
$update = true ;
}
}
if ( $update ) {
2019-04-09 01:15:23 -04:00
if ( $fields [ 'name' ] != $self [ 'name' ]) {
$fields [ 'name-date' ] = DateTimeFormat :: utcNow ();
}
$fields [ 'updated' ] = DateTimeFormat :: utcNow ();
2018-07-20 08:19:26 -04:00
DBA :: update ( 'contact' , $fields , [ 'id' => $self [ 'id' ]]);
2018-03-25 04:20:13 -04:00
// Update the public contact as well
2018-07-20 08:19:26 -04:00
DBA :: update ( 'contact' , $fields , [ 'uid' => 0 , 'nurl' => $self [ 'nurl' ]]);
2018-04-14 04:03:15 -04:00
// Update the profile
$fields = [ 'photo' => System :: baseUrl () . '/photo/profile/' . $uid . '.jpg' ,
'thumb' => System :: baseUrl () . '/photo/avatar/' . $uid . '.jpg' ];
2018-07-20 08:19:26 -04:00
DBA :: update ( 'profile' , $fields , [ 'uid' => $uid , 'is-default' => true ]);
2018-03-24 02:15:18 -04:00
}
}
2017-11-19 16:55:28 -05:00
/**
* @ brief Marks a contact for removal
*
2017-11-22 09:02:55 -05:00
* @ param int $id contact id
2017-11-19 16:55:28 -05:00
* @ return null
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
2017-11-19 16:55:28 -05:00
*/
public static function remove ( $id )
{
// We want just to make sure that we don't delete our "self" contact
2018-07-20 08:19:26 -04:00
$contact = DBA :: selectFirst ( 'contact' , [ 'uid' ], [ 'id' => $id , 'self' => false ]);
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $contact ) || ! intval ( $contact [ 'uid' ])) {
2017-11-19 16:55:28 -05:00
return ;
}
2018-08-12 13:15:47 -04:00
// Archive the contact
2018-10-13 14:13:01 -04:00
DBA :: update ( 'contact' , [ 'archive' => true , 'network' => Protocol :: PHANTOM , 'deleted' => true ], [ 'id' => $id ]);
2017-11-19 16:55:28 -05:00
2018-08-12 13:15:47 -04:00
// Delete it in the background
2019-02-21 14:32:31 -05:00
Worker :: add ( PRIORITY_MEDIUM , 'RemoveContact' , $id );
2017-11-19 16:55:28 -05:00
}
/**
* @ brief Sends an unfriend message . Does not remove the contact
*
2018-09-05 01:02:06 -04:00
* @ param array $user User unfriending
* @ param array $contact Contact unfriended
* @ param boolean $dissolve Remove the contact on the remote side
2017-11-22 23:13:12 -05:00
* @ return void
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2017-11-19 16:55:28 -05:00
*/
2018-09-05 01:02:06 -04:00
public static function terminateFriendship ( array $user , array $contact , $dissolve = false )
2017-11-19 16:55:28 -05:00
{
2019-01-13 13:03:13 -05:00
if ( empty ( $contact [ 'network' ])) {
return ;
}
2018-09-05 01:02:06 -04:00
if (( $contact [ 'network' ] == Protocol :: DFRN ) && $dissolve ) {
DFRN :: deliver ( $user , $contact , 'placeholder' , true );
} elseif ( in_array ( $contact [ 'network' ], [ Protocol :: OSTATUS , Protocol :: DFRN ])) {
2017-11-19 16:55:28 -05:00
// create an unfollow slap
2018-01-15 08:05:12 -05:00
$item = [];
2017-11-19 16:55:28 -05:00
$item [ 'verb' ] = NAMESPACE_OSTATUS . " /unfollow " ;
$item [ 'follow' ] = $contact [ " url " ];
2018-08-01 01:29:58 -04:00
$item [ 'body' ] = '' ;
$item [ 'title' ] = '' ;
$item [ 'guid' ] = '' ;
$item [ 'tag' ] = '' ;
$item [ 'attach' ] = '' ;
2017-11-19 16:55:28 -05:00
$slap = OStatus :: salmon ( $item , $user );
2018-03-16 02:43:10 -04:00
if ( ! empty ( $contact [ 'notify' ])) {
2017-12-02 09:32:45 -05:00
Salmon :: slapper ( $user , $contact [ 'notify' ], $slap );
2017-11-19 16:55:28 -05:00
}
2018-08-11 16:40:44 -04:00
} elseif ( $contact [ 'network' ] == Protocol :: DIASPORA ) {
2017-11-19 16:55:28 -05:00
Diaspora :: sendUnshare ( $user , $contact );
2018-09-15 14:54:45 -04:00
} elseif ( $contact [ 'network' ] == Protocol :: ACTIVITYPUB ) {
2019-01-10 02:24:12 -05:00
ActivityPub\Transmitter :: sendContactUndo ( $contact [ 'url' ], $contact [ 'id' ], $user [ 'uid' ]);
2018-09-15 18:25:58 -04:00
if ( $dissolve ) {
2018-10-03 11:41:51 -04:00
ActivityPub\Transmitter :: sendContactReject ( $contact [ 'url' ], $contact [ 'hub-verify' ], $user [ 'uid' ]);
2018-09-15 18:25:58 -04:00
}
2017-11-19 16:55:28 -05:00
}
}
/**
* @ brief Marks a contact for archival after a communication issue delay
*
* Contact has refused to recognise us as a friend . We will start a countdown .
* If they still don ' t recognise us in 32 days , the relationship is over ,
* and we won ' t waste any more time trying to communicate with them .
* This provides for the possibility that their database is temporarily messed
* up or some other transient event and that there ' s a possibility we could recover from it .
*
2017-11-22 09:02:55 -05:00
* @ param array $contact contact to mark for archival
2017-12-17 15:27:50 -05:00
* @ return null
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
2017-11-19 16:55:28 -05:00
*/
public static function markForArchival ( array $contact )
{
2018-08-21 11:35:09 -04:00
if ( ! isset ( $contact [ 'url' ]) && ! empty ( $contact [ 'id' ])) {
$fields = [ 'id' , 'url' , 'archive' , 'self' , 'term-date' ];
2019-01-07 13:26:54 -05:00
$contact = DBA :: selectFirst ( 'contact' , $fields , [ 'id' => $contact [ 'id' ]]);
2018-08-21 11:35:09 -04:00
if ( ! DBA :: isResult ( $contact )) {
return ;
}
} elseif ( ! isset ( $contact [ 'url' ])) {
2018-10-30 09:58:45 -04:00
Logger :: log ( 'Empty contact: ' . json_encode ( $contact ) . ' - ' . System :: callstack ( 20 ), Logger :: DEBUG );
2018-08-16 23:19:42 -04:00
}
2019-01-16 16:39:56 -05:00
Logger :: log ( 'Contact ' . $contact [ 'id' ] . ' is marked for archival' , Logger :: DEBUG );
2017-12-05 16:29:33 -05:00
// Contact already archived or "self" contact? => nothing to do
if ( $contact [ 'archive' ] || $contact [ 'self' ]) {
2017-11-19 16:55:28 -05:00
return ;
}
2017-12-04 14:37:36 -05:00
2018-10-21 01:53:47 -04:00
if ( $contact [ 'term-date' ] <= DBA :: NULL_DATETIME ) {
2018-07-20 08:19:26 -04:00
DBA :: update ( 'contact' , [ 'term-date' => DateTimeFormat :: utcNow ()], [ 'id' => $contact [ 'id' ]]);
2018-11-08 11:28:29 -05:00
DBA :: update ( 'contact' , [ 'term-date' => DateTimeFormat :: utcNow ()], [ '`nurl` = ? AND `term-date` <= ? AND NOT `self`' , Strings :: normaliseLink ( $contact [ 'url' ]), DBA :: NULL_DATETIME ]);
2017-11-19 16:55:28 -05:00
} else {
/* @ todo
* We really should send a notification to the owner after 2 - 3 weeks
* so they won ' t be surprised when the contact vanishes and can take
* remedial action if this was a serious mistake or glitch
*/
/// @todo Check for contact vitality via probing
2018-04-10 07:10:02 -04:00
$archival_days = Config :: get ( 'system' , 'archival_days' , 32 );
$expiry = $contact [ 'term-date' ] . ' + ' . $archival_days . ' days ' ;
2018-01-26 21:38:34 -05:00
if ( DateTimeFormat :: utcNow () > DateTimeFormat :: utc ( $expiry )) {
2017-11-19 16:55:28 -05:00
/* Relationship is really truly dead . archive them rather than
* delete , though if the owner tries to unarchive them we ' ll start
* the whole process over again .
*/
2018-07-20 08:19:26 -04:00
DBA :: update ( 'contact' , [ 'archive' => 1 ], [ 'id' => $contact [ 'id' ]]);
2018-11-08 11:28:29 -05:00
DBA :: update ( 'contact' , [ 'archive' => 1 ], [ 'nurl' => Strings :: normaliseLink ( $contact [ 'url' ]), 'self' => false ]);
2017-11-19 16:55:28 -05:00
}
}
}
/**
* @ brief Cancels the archival countdown
*
2019-01-06 16:06:53 -05:00
* @ see Contact :: markForArchival ()
2017-11-19 16:55:28 -05:00
*
2017-11-22 09:02:55 -05:00
* @ param array $contact contact to be unmarked for archival
2017-11-19 16:55:28 -05:00
* @ return null
2019-01-06 16:06:53 -05:00
* @ throws \Exception
2017-11-19 16:55:28 -05:00
*/
public static function unmarkForArchival ( array $contact )
{
2018-10-21 01:53:47 -04:00
$condition = [ '`id` = ? AND (`term-date` > ? OR `archive`)' , $contact [ 'id' ], DBA :: NULL_DATETIME ];
2018-07-20 08:19:26 -04:00
$exists = DBA :: exists ( 'contact' , $condition );
2017-11-19 16:55:28 -05:00
// We don't need to update, we never marked this contact for archival
2017-11-23 08:15:38 -05:00
if ( ! $exists ) {
2017-11-19 16:55:28 -05:00
return ;
}
2019-01-16 16:39:56 -05:00
Logger :: log ( 'Contact ' . $contact [ 'id' ] . ' is marked as vital again' , Logger :: DEBUG );
2018-08-21 11:35:09 -04:00
if ( ! isset ( $contact [ 'url' ]) && ! empty ( $contact [ 'id' ])) {
$fields = [ 'id' , 'url' , 'batch' ];
2019-01-07 13:26:54 -05:00
$contact = DBA :: selectFirst ( 'contact' , $fields , [ 'id' => $contact [ 'id' ]]);
2018-08-21 11:35:09 -04:00
if ( ! DBA :: isResult ( $contact )) {
return ;
}
}
2017-11-19 16:55:28 -05:00
// It's a miracle. Our dead contact has inexplicably come back to life.
2018-10-21 01:53:47 -04:00
$fields = [ 'term-date' => DBA :: NULL_DATETIME , 'archive' => false ];
2018-07-20 08:19:26 -04:00
DBA :: update ( 'contact' , $fields , [ 'id' => $contact [ 'id' ]]);
2018-11-08 11:28:29 -05:00
DBA :: update ( 'contact' , $fields , [ 'nurl' => Strings :: normaliseLink ( $contact [ 'url' ])]);
2018-04-11 14:56:22 -04:00
if ( ! empty ( $contact [ 'batch' ])) {
2019-01-06 17:08:35 -05:00
$condition = [ 'batch' => $contact [ 'batch' ], 'contact-type' => self :: TYPE_RELAY ];
2018-07-20 08:19:26 -04:00
DBA :: update ( 'contact' , $fields , $condition );
2018-04-11 14:56:22 -04:00
}
2017-11-19 16:55:28 -05:00
}
/**
* @ brief Get contact data for a given profile link
*
* The function looks at several places ( contact table and gcontact table ) for the contact
* It caches its result for the same script execution to prevent duplicate calls
*
2017-11-22 09:02:55 -05:00
* @ param string $url The profile link
* @ param int $uid User id
* @ param array $default If not data was found take this data as default value
2017-11-19 16:55:28 -05:00
*
* @ return array Contact data
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
2017-11-19 16:55:28 -05:00
*/
public static function getDetailsByURL ( $url , $uid = - 1 , array $default = [])
{
2018-01-15 08:05:12 -05:00
static $cache = [];
2017-11-19 16:55:28 -05:00
if ( $url == '' ) {
return $default ;
}
if ( $uid == - 1 ) {
$uid = local_user ();
}
if ( isset ( $cache [ $url ][ $uid ])) {
return $cache [ $url ][ $uid ];
}
$ssl_url = str_replace ( 'http://' , 'https://' , $url );
// Fetch contact data from the contact table for the given user
2018-07-20 08:19:26 -04:00
$s = DBA :: p ( " SELECT `id`, `id` AS `cid`, 0 AS `gid`, 0 AS `zid`, `uid`, `url`, `nurl`, `alias`, `network`, `name`, `nick`, `addr`, `location`, `about`, `xmpp`,
2017-11-19 16:55:28 -05:00
`keywords` , `gender` , `photo` , `thumb` , `micro` , `forum` , `prv` , ( `forum` | `prv` ) AS `community` , `contact-type` , `bd` AS `birthday` , `self`
2018-11-08 11:28:29 -05:00
FROM `contact` WHERE `nurl` = ? AND `uid` = ? " , Strings::normaliseLink( $url ), $uid );
2018-07-20 22:03:40 -04:00
$r = DBA :: toArray ( $s );
2017-11-19 16:55:28 -05:00
// Fetch contact data from the contact table for the given user, checking with the alias
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $r )) {
2018-07-20 08:19:26 -04:00
$s = DBA :: p ( " SELECT `id`, `id` AS `cid`, 0 AS `gid`, 0 AS `zid`, `uid`, `url`, `nurl`, `alias`, `network`, `name`, `nick`, `addr`, `location`, `about`, `xmpp`,
2017-11-19 16:55:28 -05:00
`keywords` , `gender` , `photo` , `thumb` , `micro` , `forum` , `prv` , ( `forum` | `prv` ) AS `community` , `contact-type` , `bd` AS `birthday` , `self`
2018-11-08 11:28:29 -05:00
FROM `contact` WHERE `alias` IN ( ? , ? , ? ) AND `uid` = ? " , Strings::normaliseLink( $url ), $url , $ssl_url , $uid );
2018-07-20 22:03:40 -04:00
$r = DBA :: toArray ( $s );
2017-11-19 16:55:28 -05:00
}
// Fetch the data from the contact table with "uid=0" (which is filled automatically)
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $r )) {
2018-07-20 08:19:26 -04:00
$s = DBA :: p ( " SELECT `id`, 0 AS `cid`, `id` AS `zid`, 0 AS `gid`, `uid`, `url`, `nurl`, `alias`, `network`, `name`, `nick`, `addr`, `location`, `about`, `xmpp`,
2017-11-19 16:55:28 -05:00
`keywords` , `gender` , `photo` , `thumb` , `micro` , `forum` , `prv` , ( `forum` | `prv` ) AS `community` , `contact-type` , `bd` AS `birthday` , 0 AS `self`
2018-11-08 11:28:29 -05:00
FROM `contact` WHERE `nurl` = ? AND `uid` = 0 " , Strings::normaliseLink( $url ));
2018-07-20 22:03:40 -04:00
$r = DBA :: toArray ( $s );
2017-11-19 16:55:28 -05:00
}
// Fetch the data from the contact table with "uid=0" (which is filled automatically) - checked with the alias
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $r )) {
2018-07-20 08:19:26 -04:00
$s = DBA :: p ( " SELECT `id`, 0 AS `cid`, `id` AS `zid`, 0 AS `gid`, `uid`, `url`, `nurl`, `alias`, `network`, `name`, `nick`, `addr`, `location`, `about`, `xmpp`,
2017-11-19 16:55:28 -05:00
`keywords` , `gender` , `photo` , `thumb` , `micro` , `forum` , `prv` , ( `forum` | `prv` ) AS `community` , `contact-type` , `bd` AS `birthday` , 0 AS `self`
2018-11-08 11:28:29 -05:00
FROM `contact` WHERE `alias` IN ( ? , ? , ? ) AND `uid` = 0 " , Strings::normaliseLink( $url ), $url , $ssl_url );
2018-07-20 22:03:40 -04:00
$r = DBA :: toArray ( $s );
2017-11-19 16:55:28 -05:00
}
// Fetch the data from the gcontact table
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $r )) {
2018-07-20 08:19:26 -04:00
$s = DBA :: p ( " SELECT 0 AS `id`, 0 AS `cid`, `id` AS `gid`, 0 AS `zid`, 0 AS `uid`, `url`, `nurl`, `alias`, `network`, `name`, `nick`, `addr`, `location`, `about`, '' AS `xmpp`,
2018-04-21 17:59:02 -04:00
`keywords` , `gender` , `photo` , `photo` AS `thumb` , `photo` AS `micro` , 0 AS `forum` , 0 AS `prv` , `community` , `contact-type` , `birthday` , 0 AS `self`
2018-11-08 11:28:29 -05:00
FROM `gcontact` WHERE `nurl` = ? " , Strings::normaliseLink( $url ));
2018-07-20 22:03:40 -04:00
$r = DBA :: toArray ( $s );
2017-11-19 16:55:28 -05:00
}
2018-07-21 08:46:04 -04:00
if ( DBA :: isResult ( $r )) {
2017-11-19 16:55:28 -05:00
// If there is more than one entry we filter out the connector networks
if ( count ( $r ) > 1 ) {
2017-11-22 09:02:55 -05:00
foreach ( $r as $id => $result ) {
2018-08-11 16:40:44 -04:00
if ( $result [ " network " ] == Protocol :: STATUSNET ) {
2017-11-19 16:55:28 -05:00
unset ( $r [ $id ]);
}
}
}
$profile = array_shift ( $r );
// "bd" always contains the upcoming birthday of a contact.
// "birthday" might contain the birthday including the year of birth.
2018-11-21 23:53:45 -05:00
if ( $profile [ " birthday " ] > DBA :: NULL_DATE ) {
2017-11-19 16:55:28 -05:00
$bd_timestamp = strtotime ( $profile [ " birthday " ]);
$month = date ( " m " , $bd_timestamp );
$day = date ( " d " , $bd_timestamp );
$current_timestamp = time ();
$current_year = date ( " Y " , $current_timestamp );
$current_month = date ( " m " , $current_timestamp );
$current_day = date ( " d " , $current_timestamp );
$profile [ " bd " ] = $current_year . " - " . $month . " - " . $day ;
$current = $current_year . " - " . $current_month . " - " . $current_day ;
if ( $profile [ " bd " ] < $current ) {
$profile [ " bd " ] = ( ++ $current_year ) . " - " . $month . " - " . $day ;
}
} else {
2018-11-21 23:53:45 -05:00
$profile [ " bd " ] = DBA :: NULL_DATE ;
2017-11-19 16:55:28 -05:00
}
} else {
$profile = $default ;
}
2018-07-10 08:27:56 -04:00
if ( empty ( $profile [ " photo " ]) && isset ( $default [ " photo " ])) {
2017-11-19 16:55:28 -05:00
$profile [ " photo " ] = $default [ " photo " ];
}
2018-07-10 08:27:56 -04:00
if ( empty ( $profile [ " name " ]) && isset ( $default [ " name " ])) {
2017-11-19 16:55:28 -05:00
$profile [ " name " ] = $default [ " name " ];
}
2018-07-10 08:27:56 -04:00
if ( empty ( $profile [ " network " ]) && isset ( $default [ " network " ])) {
2017-11-19 16:55:28 -05:00
$profile [ " network " ] = $default [ " network " ];
}
2018-07-10 08:27:56 -04:00
if ( empty ( $profile [ " thumb " ]) && isset ( $profile [ " photo " ])) {
2017-11-19 16:55:28 -05:00
$profile [ " thumb " ] = $profile [ " photo " ];
}
2018-07-10 08:27:56 -04:00
if ( empty ( $profile [ " micro " ]) && isset ( $profile [ " thumb " ])) {
2017-11-19 16:55:28 -05:00
$profile [ " micro " ] = $profile [ " thumb " ];
}
2018-07-10 08:27:56 -04:00
if (( empty ( $profile [ " addr " ]) || empty ( $profile [ " name " ])) && ( defaults ( $profile , " gid " , 0 ) != 0 )
2018-09-14 12:51:32 -04:00
&& in_array ( $profile [ " network " ], [ Protocol :: ACTIVITYPUB , Protocol :: DFRN , Protocol :: DIASPORA , Protocol :: OSTATUS ])
2017-11-22 09:02:55 -05:00
) {
2017-11-19 16:55:28 -05:00
Worker :: add ( PRIORITY_LOW , " UpdateGContact " , $profile [ " gid " ]);
}
// Show contact details of Diaspora contacts only if connected
2018-08-11 16:40:44 -04:00
if (( defaults ( $profile , " cid " , 0 ) == 0 ) && ( defaults ( $profile , " network " , " " ) == Protocol :: DIASPORA )) {
2017-11-19 16:55:28 -05:00
$profile [ " location " ] = " " ;
$profile [ " about " ] = " " ;
$profile [ " gender " ] = " " ;
2018-11-21 23:53:45 -05:00
$profile [ " birthday " ] = DBA :: NULL_DATE ;
2017-11-19 16:55:28 -05:00
}
$cache [ $url ][ $uid ] = $profile ;
return $profile ;
}
/**
* @ brief Get contact data for a given address
*
* The function looks at several places ( contact table and gcontact table ) for the contact
*
* @ param string $addr The profile link
2017-11-22 09:02:55 -05:00
* @ param int $uid User id
2017-11-19 16:55:28 -05:00
*
* @ return array Contact data
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2017-11-19 16:55:28 -05:00
*/
public static function getDetailsByAddr ( $addr , $uid = - 1 )
{
if ( $addr == '' ) {
2018-01-15 08:05:12 -05:00
return [];
2017-11-19 16:55:28 -05:00
}
if ( $uid == - 1 ) {
$uid = local_user ();
}
// Fetch contact data from the contact table for the given user
$r = q ( " SELECT `id`, `id` AS `cid`, 0 AS `gid`, 0 AS `zid`, `uid`, `url`, `nurl`, `alias`, `network`, `name`, `nick`, `addr`, `location`, `about`, `xmpp`,
`keywords` , `gender` , `photo` , `thumb` , `micro` , `forum` , `prv` , ( `forum` | `prv` ) AS `community` , `contact-type` , `bd` AS `birthday` , `self`
2018-10-13 14:13:01 -04:00
FROM `contact` WHERE `addr` = '%s' AND `uid` = % d AND NOT `deleted` " ,
2018-07-21 09:10:13 -04:00
DBA :: escape ( $addr ),
2018-01-11 03:37:11 -05:00
intval ( $uid )
);
2017-11-19 16:55:28 -05:00
// Fetch the data from the contact table with "uid=0" (which is filled automatically)
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $r )) {
2017-11-19 16:55:28 -05:00
$r = q ( " SELECT `id`, 0 AS `cid`, `id` AS `zid`, 0 AS `gid`, `uid`, `url`, `nurl`, `alias`, `network`, `name`, `nick`, `addr`, `location`, `about`, `xmpp`,
2018-01-11 03:37:11 -05:00
`keywords` , `gender` , `photo` , `thumb` , `micro` , `forum` , `prv` , ( `forum` | `prv` ) AS `community` , `contact-type` , `bd` AS `birthday` , 0 AS `self`
2018-10-13 14:13:01 -04:00
FROM `contact` WHERE `addr` = '%s' AND `uid` = 0 AND NOT `deleted` " ,
2018-07-21 09:10:13 -04:00
DBA :: escape ( $addr )
2018-01-11 03:37:11 -05:00
);
}
2017-11-19 16:55:28 -05:00
// Fetch the data from the gcontact table
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $r )) {
2017-11-19 16:55:28 -05:00
$r = q ( " SELECT 0 AS `id`, 0 AS `cid`, `id` AS `gid`, 0 AS `zid`, 0 AS `uid`, `url`, `nurl`, `alias`, `network`, `name`, `nick`, `addr`, `location`, `about`, '' AS `xmpp`,
2018-01-11 03:37:11 -05:00
`keywords` , `gender` , `photo` , `photo` AS `thumb` , `photo` AS `micro` , `community` AS `forum` , 0 AS `prv` , `community` , `contact-type` , `birthday` , 0 AS `self`
FROM `gcontact` WHERE `addr` = '%s' " ,
2018-07-21 09:10:13 -04:00
DBA :: escape ( $addr )
2018-01-11 03:37:11 -05:00
);
}
2017-11-19 16:55:28 -05:00
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $r )) {
2017-11-19 16:55:28 -05:00
$data = Probe :: uri ( $addr );
$profile = self :: getDetailsByURL ( $data [ 'url' ], $uid );
} else {
$profile = $r [ 0 ];
}
return $profile ;
}
/**
* @ brief Returns the data array for the photo menu of a given contact
*
2017-11-22 09:02:55 -05:00
* @ param array $contact contact
* @ param int $uid optional , default 0
2017-11-19 16:55:28 -05:00
* @ return array
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2017-11-19 16:55:28 -05:00
*/
public static function photoMenu ( array $contact , $uid = 0 )
{
$pm_url = '' ;
$status_link = '' ;
$photos_link = '' ;
$contact_drop_link = '' ;
$poke_link = '' ;
if ( $uid == 0 ) {
$uid = local_user ();
}
2018-07-10 08:27:56 -04:00
if ( empty ( $contact [ 'uid' ]) || ( $contact [ 'uid' ] != $uid )) {
2017-11-19 16:55:28 -05:00
if ( $uid == 0 ) {
2018-06-02 04:05:06 -04:00
$profile_link = self :: magicLink ( $contact [ 'url' ]);
2018-01-22 09:54:13 -05:00
$menu = [ 'profile' => [ L10n :: t ( 'View Profile' ), $profile_link , true ]];
2017-11-19 16:55:28 -05:00
return $menu ;
}
2018-01-11 03:26:30 -05:00
// Look for our own contact if the uid doesn't match and isn't public
2018-07-20 08:19:26 -04:00
$contact_own = DBA :: selectFirst ( 'contact' , [], [ 'nurl' => $contact [ 'nurl' ], 'network' => $contact [ 'network' ], 'uid' => $uid ]);
2018-07-21 08:46:04 -04:00
if ( DBA :: isResult ( $contact_own )) {
2018-01-11 03:26:30 -05:00
return self :: photoMenu ( $contact_own , $uid );
2017-11-19 16:55:28 -05:00
}
}
$sparkle = false ;
2018-08-11 16:40:44 -04:00
if (( $contact [ 'network' ] === Protocol :: DFRN ) && ! $contact [ 'self' ]) {
2017-11-19 16:55:28 -05:00
$sparkle = true ;
2019-02-26 04:19:08 -05:00
$profile_link = System :: baseUrl () . '/redir/' . $contact [ 'id' ] . '?url=' . $contact [ 'url' ];
2017-11-19 16:55:28 -05:00
} else {
$profile_link = $contact [ 'url' ];
}
if ( $profile_link === 'mailbox' ) {
$profile_link = '' ;
}
if ( $sparkle ) {
2019-02-26 04:19:08 -05:00
$status_link = $profile_link . '?tab=status' ;
$photos_link = str_replace ( '/profile/' , '/photos/' , $profile_link );
$profile_link = $profile_link . '?tab=profile' ;
2017-11-19 16:55:28 -05:00
}
2018-08-11 16:40:44 -04:00
if ( in_array ( $contact [ 'network' ], [ Protocol :: DFRN , Protocol :: DIASPORA ]) && ! $contact [ 'self' ]) {
2017-11-19 16:55:28 -05:00
$pm_url = System :: baseUrl () . '/message/new/' . $contact [ 'id' ];
}
2018-08-11 16:40:44 -04:00
if (( $contact [ 'network' ] == Protocol :: DFRN ) && ! $contact [ 'self' ]) {
2017-11-19 16:55:28 -05:00
$poke_link = System :: baseUrl () . '/poke/?f=&c=' . $contact [ 'id' ];
}
2018-10-13 07:29:56 -04:00
$contact_url = System :: baseUrl () . '/contact/' . $contact [ 'id' ];
2017-11-19 16:55:28 -05:00
2018-10-13 07:29:56 -04:00
$posts_link = System :: baseUrl () . '/contact/' . $contact [ 'id' ] . '/conversations' ;
2018-03-17 02:17:32 -04:00
if ( ! $contact [ 'self' ]) {
2018-10-13 07:29:56 -04:00
$contact_drop_link = System :: baseUrl () . '/contact/' . $contact [ 'id' ] . '/drop?confirm=1' ;
2018-03-17 02:17:32 -04:00
}
2017-11-19 16:55:28 -05:00
/**
2017-11-22 09:02:55 -05:00
* Menu array :
2017-11-19 16:55:28 -05:00
* " name " => [ " Label " , " link " , ( bool ) Should the link opened in a new tab ? ]
*/
2018-08-25 09:48:00 -04:00
if ( empty ( $contact [ 'uid' ])) {
$connlnk = 'follow/?url=' . $contact [ 'url' ];
$menu = [
'profile' => [ L10n :: t ( 'View Profile' ), $profile_link , true ],
'network' => [ L10n :: t ( 'Network Posts' ), $posts_link , false ],
'edit' => [ L10n :: t ( 'View Contact' ), $contact_url , false ],
'follow' => [ L10n :: t ( 'Connect/Follow' ), $connlnk , true ],
];
} else {
$menu = [
'status' => [ L10n :: t ( 'View Status' ), $status_link , true ],
'profile' => [ L10n :: t ( 'View Profile' ), $profile_link , true ],
'photos' => [ L10n :: t ( 'View Photos' ), $photos_link , true ],
'network' => [ L10n :: t ( 'Network Posts' ), $posts_link , false ],
'edit' => [ L10n :: t ( 'View Contact' ), $contact_url , false ],
'drop' => [ L10n :: t ( 'Drop Contact' ), $contact_drop_link , false ],
'pm' => [ L10n :: t ( 'Send PM' ), $pm_url , false ],
'poke' => [ L10n :: t ( 'Poke' ), $poke_link , false ],
];
}
2018-01-11 03:37:11 -05:00
$args = [ 'contact' => $contact , 'menu' => & $menu ];
2017-11-19 16:55:28 -05:00
2018-12-26 01:06:24 -05:00
Hook :: callAll ( 'contact_photo_menu' , $args );
2017-11-19 16:55:28 -05:00
2018-01-15 08:05:12 -05:00
$menucondensed = [];
2017-11-19 16:55:28 -05:00
2017-11-22 09:02:55 -05:00
foreach ( $menu as $menuname => $menuitem ) {
2017-11-19 16:55:28 -05:00
if ( $menuitem [ 1 ] != '' ) {
$menucondensed [ $menuname ] = $menuitem ;
}
}
return $menucondensed ;
}
/**
2017-11-22 09:02:55 -05:00
* @ brief Returns ungrouped contact count or list for user
*
2017-11-19 16:55:28 -05:00
* Returns either the total number of ungrouped contacts for the given user
* id or a paginated list of ungrouped contacts .
*
2019-01-06 16:06:53 -05:00
* @ param int $uid uid
2017-11-19 16:55:28 -05:00
* @ return array
2019-01-07 10:24:06 -05:00
* @ throws \Exception
2017-11-19 16:55:28 -05:00
*/
2018-07-09 18:36:50 -04:00
public static function getUngroupedList ( $uid )
2017-11-19 16:55:28 -05:00
{
2018-07-09 18:36:50 -04:00
return q ( " SELECT *
FROM `contact`
WHERE `uid` = % d
AND NOT `self`
2019-01-12 08:28:14 -05:00
AND NOT `deleted`
2018-07-09 18:36:50 -04:00
AND NOT `blocked`
AND NOT `pending`
AND `id` NOT IN (
SELECT DISTINCT ( `contact-id` )
FROM `group_member`
INNER JOIN `group` ON `group` . `id` = `group_member` . `gid`
WHERE `group` . `uid` = % d
) " , intval( $uid ), intval( $uid ));
2017-11-19 16:55:28 -05:00
}
2019-04-08 16:41:18 -04:00
/**
* Have a look at all contact tables for a given profile url .
* This function works as a replacement for probing the contact .
*
* @ param string $url Contact URL
*
* @ return array Contact array in the " probe " structure
*/
private static function getProbeDataFromDatabase ( $url )
{
// The link could be provided as http although we stored it as https
$ssl_url = str_replace ( 'http://' , 'https://' , $url );
$fields = [ 'url' , 'addr' , 'alias' , 'notify' , 'poll' , 'name' , 'nick' ,
'photo' , 'keywords' , 'location' , 'about' , 'network' ,
'priority' , 'batch' , 'request' , 'confirm' , 'poco' ];
$data = DBA :: selectFirst ( 'contact' , $fields , [ 'nurl' => Strings :: normaliseLink ( $url )]);
2019-04-09 01:15:23 -04:00
if ( ! DBA :: isResult ( $data )) {
2019-04-08 16:41:18 -04:00
$condition = [ 'alias' => [ $url , Strings :: normaliseLink ( $url ), $ssl_url ]];
$data = DBA :: selectFirst ( 'contact' , $fields , $condition );
}
if ( DBA :: isResult ( $data )) {
// For security reasons we don't fetch key data from our users
$data [ " pubkey " ] = '' ;
return $data ;
}
$fields = [ 'url' , 'addr' , 'alias' , 'notify' , 'name' , 'nick' ,
'photo' , 'keywords' , 'location' , 'about' , 'network' ];
$data = DBA :: selectFirst ( 'gcontact' , $fields , [ 'nurl' => Strings :: normaliseLink ( $url )]);
2019-04-09 01:15:23 -04:00
if ( ! DBA :: isResult ( $data )) {
2019-04-08 16:41:18 -04:00
$condition = [ 'alias' => [ $url , Strings :: normaliseLink ( $url ), $ssl_url ]];
$data = DBA :: selectFirst ( 'contact' , $fields , $condition );
}
if ( DBA :: isResult ( $data )) {
$data [ " pubkey " ] = '' ;
$data [ " poll " ] = '' ;
$data [ " priority " ] = 0 ;
$data [ " batch " ] = '' ;
$data [ " request " ] = '' ;
$data [ " confirm " ] = '' ;
$data [ " poco " ] = '' ;
return $data ;
}
$data = ActivityPub :: probeProfile ( $url , false );
if ( ! empty ( $data )) {
return $data ;
}
$fields = [ 'url' , 'addr' , 'alias' , 'notify' , 'poll' , 'name' , 'nick' ,
'photo' , 'network' , 'priority' , 'batch' , 'request' , 'confirm' ];
$data = DBA :: selectFirst ( 'fcontact' , $fields , [ 'url' => $url ]);
2019-04-09 01:15:23 -04:00
if ( ! DBA :: isResult ( $data )) {
2019-04-08 16:41:18 -04:00
$condition = [ 'alias' => [ $url , Strings :: normaliseLink ( $url ), $ssl_url ]];
$data = DBA :: selectFirst ( 'contact' , $fields , $condition );
}
if ( DBA :: isResult ( $data )) {
$data [ " pubkey " ] = '' ;
$data [ " keywords " ] = '' ;
$data [ " location " ] = '' ;
$data [ " about " ] = '' ;
$data [ " poco " ] = '' ;
return $data ;
}
return [];
}
2017-11-19 16:55:28 -05:00
/**
2018-01-11 03:37:11 -05:00
* @ brief Fetch the contact id for a given URL and user
2017-11-19 16:55:28 -05:00
*
* First lookup in the contact table to find a record matching either `url` , `nurl` ,
* `addr` or `alias` .
*
* If there 's no record and we aren' t looking for a public contact , we quit .
* If there 's one, we check that it isn' t time to update the picture else we
* directly return the found contact id .
*
2018-01-11 03:37:11 -05:00
* Second , we probe the provided $url whether it ' s http :// server . tld / profile or
2017-11-19 16:55:28 -05:00
* nick @ server . tld . We quit if we can ' t get any info back .
*
* Third , we create the contact record if it doesn ' t exist
*
* Fourth , we update the existing record with the new data ( avatar , alias , nick )
* if there ' s any updates
*
2017-11-22 09:02:55 -05:00
* @ param string $url Contact URL
* @ param integer $uid The user id for the contact ( 0 = public contact )
2017-11-19 16:55:28 -05:00
* @ param boolean $no_update Don ' t update the contact
2018-05-08 13:50:06 -04:00
* @ param array $default Default value for creating the contact when every else fails
2018-10-17 23:33:08 -04:00
* @ param boolean $in_loop Internally used variable to prevent an endless loop
2017-11-19 16:55:28 -05:00
*
* @ return integer Contact ID
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2017-11-19 16:55:28 -05:00
*/
2018-10-17 23:33:08 -04:00
public static function getIdForURL ( $url , $uid = 0 , $no_update = false , $default = [], $in_loop = false )
2017-11-19 16:55:28 -05:00
{
2018-10-30 09:58:45 -04:00
Logger :: log ( " Get contact data for url " . $url . " and user " . $uid . " - " . System :: callstack (), Logger :: DEBUG );
2017-11-19 16:55:28 -05:00
$contact_id = 0 ;
if ( $url == '' ) {
return 0 ;
}
/// @todo Verify if we can't use Contact::getDetailsByUrl instead of the following
// We first try the nurl (http://server.tld/nick), most common case
2019-04-09 01:15:23 -04:00
$contact = DBA :: selectFirst ( 'contact' , [ 'id' , 'avatar' , 'updated' ], [ 'nurl' => Strings :: normaliseLink ( $url ), 'uid' => $uid , 'deleted' => false ]);
2017-11-19 16:55:28 -05:00
// Then the addr (nick@server.tld)
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $contact )) {
2019-04-09 01:15:23 -04:00
$contact = DBA :: selectFirst ( 'contact' , [ 'id' , 'avatar' , 'updated' ], [ 'addr' => $url , 'uid' => $uid , 'deleted' => false ]);
2017-11-19 16:55:28 -05:00
}
// Then the alias (which could be anything)
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $contact )) {
2017-11-19 16:55:28 -05:00
// The link could be provided as http although we stored it as https
$ssl_url = str_replace ( 'http://' , 'https://' , $url );
2018-11-08 11:28:29 -05:00
$condition = [ '`alias` IN (?, ?, ?) AND `uid` = ? AND NOT `deleted`' , $url , Strings :: normaliseLink ( $url ), $ssl_url , $uid ];
2019-04-09 01:15:23 -04:00
$contact = DBA :: selectFirst ( 'contact' , [ 'id' , 'avatar' , 'updated' ], $condition );
2017-11-19 16:55:28 -05:00
}
2018-07-21 08:46:04 -04:00
if ( DBA :: isResult ( $contact )) {
2017-11-19 16:55:28 -05:00
$contact_id = $contact [ " id " ];
// Update the contact every 7 days
2019-04-09 01:15:23 -04:00
$update_contact = ( $contact [ 'updated' ] < DateTimeFormat :: utc ( 'now -7 days' ));
2017-11-19 16:55:28 -05:00
// We force the update if the avatar is empty
2018-11-30 09:06:22 -05:00
if ( empty ( $contact [ 'avatar' ])) {
2017-11-19 16:55:28 -05:00
$update_contact = true ;
}
2019-04-08 17:05:33 -04:00
2019-04-09 01:15:23 -04:00
// Update the contact in the background if needed but it is called by the frontend
if ( $update_contact && $no_update ) {
Worker :: add ( PRIORITY_LOW , " UpdateContact " , $contact_id );
}
2017-11-19 16:55:28 -05:00
if ( ! $update_contact || $no_update ) {
return $contact_id ;
}
} elseif ( $uid != 0 ) {
// Non-existing user-specific contact, exiting
return 0 ;
}
2019-04-08 16:41:18 -04:00
// When we don't want to update, we look if we know this contact in any way
if ( $no_update && empty ( $default )) {
$data = self :: getProbeDataFromDatabase ( $url );
2019-04-08 17:05:33 -04:00
$background_update = true ;
2018-08-09 02:19:23 -04:00
} else {
$data = [];
2019-04-08 17:05:33 -04:00
$background_update = false ;
2018-08-09 02:19:23 -04:00
}
if ( empty ( $data )) {
$data = Probe :: uri ( $url , " " , $uid );
2018-08-30 05:52:38 -04:00
// Ensure that there is a gserver entry
if ( ! empty ( $data [ 'baseurl' ]) && ( $data [ 'network' ] != Protocol :: PHANTOM )) {
PortableContact :: checkServer ( $data [ 'baseurl' ]);
}
2018-08-09 02:19:23 -04:00
}
2017-11-19 16:55:28 -05:00
// Last try in gcontact for unsupported networks
2018-09-14 12:51:32 -04:00
if ( ! in_array ( $data [ " network " ], [ Protocol :: ACTIVITYPUB , Protocol :: DFRN , Protocol :: OSTATUS , Protocol :: DIASPORA , Protocol :: PUMPIO , Protocol :: MAIL , Protocol :: FEED ])) {
2017-11-19 16:55:28 -05:00
if ( $uid != 0 ) {
return 0 ;
}
2018-05-08 13:50:06 -04:00
if ( ! empty ( $default )) {
$contact = $default ;
2019-04-08 16:41:18 -04:00
} else {
$contact = self :: getProbeDataFromDatabase ( $url );
2019-04-09 01:15:23 -04:00
if ( empty ( $contact )) {
return 0 ;
}
2017-11-19 16:55:28 -05:00
}
2019-04-09 01:15:23 -04:00
$data = array_merge ( $data , $contact );
}
if ( empty ( $data )) {
return 0 ;
2017-11-19 16:55:28 -05:00
}
2018-10-17 23:33:08 -04:00
if ( ! $contact_id && ( $data [ " alias " ] != '' ) && ( $data [ " alias " ] != $url ) && ! $in_loop ) {
$contact_id = self :: getIdForURL ( $data [ " alias " ], $uid , true , $default , true );
2017-11-19 16:55:28 -05:00
}
if ( ! $contact_id ) {
2018-12-02 11:25:25 -05:00
$fields = [
2018-01-11 03:37:11 -05:00
'uid' => $uid ,
2018-01-26 21:38:34 -05:00
'created' => DateTimeFormat :: utcNow (),
2018-01-11 03:37:11 -05:00
'url' => $data [ " url " ],
2018-11-08 11:28:29 -05:00
'nurl' => Strings :: normaliseLink ( $data [ " url " ]),
2018-01-11 03:37:11 -05:00
'addr' => $data [ " addr " ],
'alias' => $data [ " alias " ],
'notify' => $data [ " notify " ],
'poll' => $data [ " poll " ],
'name' => $data [ " name " ],
'nick' => $data [ " nick " ],
'photo' => $data [ " photo " ],
'keywords' => $data [ " keywords " ],
'location' => $data [ " location " ],
'about' => $data [ " about " ],
'network' => $data [ " network " ],
'pubkey' => $data [ " pubkey " ],
2018-07-24 22:53:46 -04:00
'rel' => self :: SHARING ,
2018-01-11 03:37:11 -05:00
'priority' => $data [ " priority " ],
'batch' => $data [ " batch " ],
'request' => $data [ " request " ],
'confirm' => $data [ " confirm " ],
'poco' => $data [ " poco " ],
2018-01-26 21:38:34 -05:00
'name-date' => DateTimeFormat :: utcNow (),
'uri-date' => DateTimeFormat :: utcNow (),
'avatar-date' => DateTimeFormat :: utcNow (),
2018-01-11 03:37:11 -05:00
'writable' => 1 ,
'blocked' => 0 ,
'readonly' => 0 ,
2018-12-02 11:25:25 -05:00
'pending' => 0 ];
$condition = [ 'nurl' => Strings :: normaliseLink ( $data [ " url " ]), 'uid' => $uid , 'deleted' => false ];
DBA :: update ( 'contact' , $fields , $condition , true );
2017-11-19 16:55:28 -05:00
2018-12-02 11:25:25 -05:00
$s = DBA :: select ( 'contact' , [ 'id' ], $condition , [ 'order' => [ 'id' ], 'limit' => 2 ]);
2018-07-20 22:03:40 -04:00
$contacts = DBA :: toArray ( $s );
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $contacts )) {
2017-11-19 16:55:28 -05:00
return 0 ;
}
$contact_id = $contacts [ 0 ][ " id " ];
2019-04-08 17:05:33 -04:00
// Update in the background when we fetched the data solely from the database
if ( $background_update ) {
Worker :: add ( PRIORITY_LOW , " UpdateContact " , $contact_id );
}
2017-11-19 16:55:28 -05:00
// Update the newly created contact from data in the gcontact table
2018-11-08 11:28:29 -05:00
$gcontact = DBA :: selectFirst ( 'gcontact' , [ 'location' , 'about' , 'keywords' , 'gender' ], [ 'nurl' => Strings :: normaliseLink ( $data [ " url " ])]);
2018-07-21 08:46:04 -04:00
if ( DBA :: isResult ( $gcontact )) {
2017-11-19 16:55:28 -05:00
// Only use the information when the probing hadn't fetched these values
if ( $data [ 'keywords' ] != '' ) {
unset ( $gcontact [ 'keywords' ]);
}
if ( $data [ 'location' ] != '' ) {
unset ( $gcontact [ 'location' ]);
}
if ( $data [ 'about' ] != '' ) {
unset ( $gcontact [ 'about' ]);
}
2018-07-20 08:19:26 -04:00
DBA :: update ( 'contact' , $gcontact , [ 'id' => $contact_id ]);
2017-11-19 16:55:28 -05:00
}
if ( count ( $contacts ) > 1 && $uid == 0 && $contact_id != 0 && $data [ " url " ] != " " ) {
2018-12-02 11:25:25 -05:00
$condition = [ " `nurl` = ? AND `uid` = ? AND `id` != ? AND NOT `self` " ,
Strings :: normaliseLink ( $data [ " url " ]), 0 , $contact_id ];
Logger :: log ( 'Deleting duplicate contact ' . json_encode ( $condition ), Logger :: DEBUG );
DBA :: delete ( 'contact' , $condition );
2017-11-19 16:55:28 -05:00
}
}
2017-11-29 17:29:11 -05:00
self :: updateAvatar ( $data [ " photo " ], $uid , $contact_id );
2017-11-19 16:55:28 -05:00
2018-01-09 22:20:33 -05:00
$fields = [ 'url' , 'nurl' , 'addr' , 'alias' , 'name' , 'nick' , 'keywords' , 'location' , 'about' , 'avatar-date' , 'pubkey' ];
2018-07-20 08:19:26 -04:00
$contact = DBA :: selectFirst ( 'contact' , $fields , [ 'id' => $contact_id ]);
2017-11-19 16:55:28 -05:00
// This condition should always be true
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $contact )) {
2017-11-19 16:55:28 -05:00
return $contact_id ;
}
2018-01-15 08:05:12 -05:00
$updated = [ 'addr' => $data [ 'addr' ],
2017-11-19 16:55:28 -05:00
'alias' => $data [ 'alias' ],
'url' => $data [ 'url' ],
2018-11-08 11:28:29 -05:00
'nurl' => Strings :: normaliseLink ( $data [ 'url' ]),
2017-11-19 16:55:28 -05:00
'name' => $data [ 'name' ],
2018-01-15 08:05:12 -05:00
'nick' => $data [ 'nick' ]];
2017-11-19 16:55:28 -05:00
if ( $data [ 'keywords' ] != '' ) {
$updated [ 'keywords' ] = $data [ 'keywords' ];
}
if ( $data [ 'location' ] != '' ) {
$updated [ 'location' ] = $data [ 'location' ];
}
2018-06-03 04:36:05 -04:00
// Update the technical stuff as well - if filled
if ( $data [ 'notify' ] != '' ) {
$updated [ 'notify' ] = $data [ 'notify' ];
}
if ( $data [ 'poll' ] != '' ) {
$updated [ 'poll' ] = $data [ 'poll' ];
}
if ( $data [ 'batch' ] != '' ) {
$updated [ 'batch' ] = $data [ 'batch' ];
}
if ( $data [ 'request' ] != '' ) {
$updated [ 'request' ] = $data [ 'request' ];
}
if ( $data [ 'confirm' ] != '' ) {
$updated [ 'confirm' ] = $data [ 'confirm' ];
}
if ( $data [ 'poco' ] != '' ) {
$updated [ 'poco' ] = $data [ 'poco' ];
}
// Only fill the pubkey if it had been empty before. We have to prevent identity theft.
if ( empty ( $contact [ 'pubkey' ])) {
$updated [ 'pubkey' ] = $data [ 'pubkey' ];
2017-11-19 16:55:28 -05:00
}
if (( $data [ " addr " ] != $contact [ " addr " ]) || ( $data [ " alias " ] != $contact [ " alias " ])) {
2018-01-26 21:38:34 -05:00
$updated [ 'uri-date' ] = DateTimeFormat :: utcNow ();
2017-11-19 16:55:28 -05:00
}
if (( $data [ " name " ] != $contact [ " name " ]) || ( $data [ " nick " ] != $contact [ " nick " ])) {
2018-01-26 21:38:34 -05:00
$updated [ 'name-date' ] = DateTimeFormat :: utcNow ();
2017-11-19 16:55:28 -05:00
}
2019-04-09 01:15:23 -04:00
$updated [ 'updated' ] = DateTimeFormat :: utcNow ();
2017-11-19 16:55:28 -05:00
2018-07-20 08:19:26 -04:00
DBA :: update ( 'contact' , $updated , [ 'id' => $contact_id ], $contact );
2017-11-19 16:55:28 -05:00
return $contact_id ;
}
/**
* @ brief Checks if the contact is blocked
*
* @ param int $cid contact id
*
* @ return boolean Is the contact blocked ?
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
2017-11-19 16:55:28 -05:00
*/
public static function isBlocked ( $cid )
{
if ( $cid == 0 ) {
return false ;
}
2018-11-22 16:43:16 -05:00
$blocked = DBA :: selectFirst ( 'contact' , [ 'blocked' , 'url' ], [ 'id' => $cid ]);
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $blocked )) {
2017-11-19 16:55:28 -05:00
return false ;
}
2018-11-22 16:43:16 -05:00
if ( Network :: isUrlBlocked ( $blocked [ 'url' ])) {
return true ;
}
2017-11-19 16:55:28 -05:00
return ( bool ) $blocked [ 'blocked' ];
}
/**
* @ brief Checks if the contact is hidden
*
* @ param int $cid contact id
*
* @ return boolean Is the contact hidden ?
2019-01-06 16:06:53 -05:00
* @ throws \Exception
2017-11-19 16:55:28 -05:00
*/
public static function isHidden ( $cid )
{
if ( $cid == 0 ) {
return false ;
}
2018-07-20 08:19:26 -04:00
$hidden = DBA :: selectFirst ( 'contact' , [ 'hidden' ], [ 'id' => $cid ]);
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $hidden )) {
2017-11-19 16:55:28 -05:00
return false ;
}
return ( bool ) $hidden [ 'hidden' ];
}
/**
* @ brief Returns posts from a given contact url
*
* @ param string $contact_url Contact URL
*
2019-01-06 16:06:53 -05:00
* @ param bool $thread_mode
* @ param int $update
2017-11-19 16:55:28 -05:00
* @ return string posts in HTML
2019-01-06 16:06:53 -05:00
* @ throws \Exception
2017-11-19 16:55:28 -05:00
*/
2018-08-25 09:48:00 -04:00
public static function getPostsFromUrl ( $contact_url , $thread_mode = false , $update = 0 )
2017-11-19 16:55:28 -05:00
{
2017-11-24 17:15:35 -05:00
$a = self :: getApp ();
2019-01-07 12:51:48 -05:00
$cid = self :: getIdForURL ( $contact_url );
2017-11-19 16:55:28 -05:00
2018-09-16 05:06:09 -04:00
$contact = DBA :: selectFirst ( 'contact' , [ 'contact-type' , 'network' ], [ 'id' => $cid ]);
if ( ! DBA :: isResult ( $contact )) {
2017-11-19 16:55:28 -05:00
return '' ;
}
2018-09-16 05:06:09 -04:00
if ( in_array ( $contact [ " network " ], [ Protocol :: ACTIVITYPUB , Protocol :: DFRN , Protocol :: DIASPORA , Protocol :: OSTATUS , " " ])) {
2018-06-10 06:14:53 -04:00
$sql = " (`item`.`uid` = 0 OR (`item`.`uid` = ? AND NOT `item`.`global`)) " ;
2017-11-19 16:55:28 -05:00
} else {
2018-06-10 06:14:53 -04:00
$sql = " `item`.`uid` = ? " ;
2017-11-19 16:55:28 -05:00
}
2019-01-06 17:08:35 -05:00
$contact_field = ( $contact [ " contact-type " ] == self :: TYPE_COMMUNITY ? 'owner-id' : 'author-id' );
2017-11-19 16:55:28 -05:00
2018-08-25 09:48:00 -04:00
if ( $thread_mode ) {
2018-09-16 05:06:09 -04:00
$condition = [ " ` $contact_field ` = ? AND `gravity` = ? AND " . $sql ,
$cid , GRAVITY_PARENT , local_user ()];
2018-08-25 09:48:00 -04:00
} else {
2018-09-16 05:06:09 -04:00
$condition = [ " ` $contact_field ` = ? AND `gravity` IN (?, ?) AND " . $sql ,
$cid , GRAVITY_PARENT , GRAVITY_COMMENT , local_user ()];
2018-08-25 09:48:00 -04:00
}
2018-10-24 02:15:24 -04:00
$pager = new Pager ( $a -> query_string );
2018-06-10 06:14:53 -04:00
$params = [ 'order' => [ 'created' => true ],
2018-10-24 02:15:24 -04:00
'limit' => [ $pager -> getStart (), $pager -> getItemsPerPage ()]];
2017-11-19 16:55:28 -05:00
2018-08-25 09:48:00 -04:00
if ( $thread_mode ) {
$r = Item :: selectThreadForUser ( local_user (), [ 'uri' ], $condition , $params );
$items = Item :: inArray ( $r );
2019-01-18 01:22:15 -05:00
$o = conversation ( $a , $items , $pager , 'contacts' , $update , false , 'commented' , local_user ());
2018-08-25 09:48:00 -04:00
} else {
$r = Item :: selectForUser ( local_user (), [], $condition , $params );
2018-06-17 02:27:52 -04:00
2018-08-25 09:48:00 -04:00
$items = Item :: inArray ( $r );
2017-11-19 16:55:28 -05:00
2018-10-24 02:15:24 -04:00
$o = conversation ( $a , $items , $pager , 'contact-posts' , false );
2018-08-25 09:48:00 -04:00
}
if ( ! $update ) {
2018-10-24 02:15:24 -04:00
$o .= $pager -> renderMinimal ( count ( $items ));
2018-08-25 09:48:00 -04:00
}
2017-11-19 16:55:28 -05:00
return $o ;
}
/**
* @ brief Returns the account type name
*
* The function can be called with either the user or the contact array
*
* @ param array $contact contact or user array
* @ return string
*/
public static function getAccountType ( array $contact )
{
// There are several fields that indicate that the contact or user is a forum
// "page-flags" is a field in the user table,
2019-01-06 12:37:48 -05:00
// "forum" and "prv" are used in the contact table. They stand for User::PAGE_FLAGS_COMMUNITY and User::PAGE_FLAGS_PRVGROUP.
// "community" is used in the gcontact table and is true if the contact is User::PAGE_FLAGS_COMMUNITY or User::PAGE_FLAGS_PRVGROUP.
if (( isset ( $contact [ 'page-flags' ]) && ( intval ( $contact [ 'page-flags' ]) == User :: PAGE_FLAGS_COMMUNITY ))
|| ( isset ( $contact [ 'page-flags' ]) && ( intval ( $contact [ 'page-flags' ]) == User :: PAGE_FLAGS_PRVGROUP ))
2017-11-19 16:55:28 -05:00
|| ( isset ( $contact [ 'forum' ]) && intval ( $contact [ 'forum' ]))
|| ( isset ( $contact [ 'prv' ]) && intval ( $contact [ 'prv' ]))
|| ( isset ( $contact [ 'community' ]) && intval ( $contact [ 'community' ]))
) {
2019-01-06 17:08:35 -05:00
$type = self :: TYPE_COMMUNITY ;
2017-11-19 16:55:28 -05:00
} else {
2019-01-06 17:08:35 -05:00
$type = self :: TYPE_PERSON ;
2017-11-19 16:55:28 -05:00
}
// The "contact-type" (contact table) and "account-type" (user table) are more general then the chaos from above.
if ( isset ( $contact [ " contact-type " ])) {
$type = $contact [ " contact-type " ];
}
2018-01-11 03:37:11 -05:00
2017-11-19 16:55:28 -05:00
if ( isset ( $contact [ " account-type " ])) {
$type = $contact [ " account-type " ];
}
switch ( $type ) {
2019-01-06 17:08:35 -05:00
case self :: TYPE_ORGANISATION :
2018-01-22 09:54:13 -05:00
$account_type = L10n :: t ( " Organisation " );
2017-11-19 16:55:28 -05:00
break ;
2018-07-27 19:25:57 -04:00
2019-01-06 17:08:35 -05:00
case self :: TYPE_NEWS :
2018-01-22 09:54:13 -05:00
$account_type = L10n :: t ( 'News' );
2017-11-19 16:55:28 -05:00
break ;
2018-07-27 19:25:57 -04:00
2019-01-06 17:08:35 -05:00
case self :: TYPE_COMMUNITY :
2018-01-22 09:54:13 -05:00
$account_type = L10n :: t ( " Forum " );
2017-11-19 16:55:28 -05:00
break ;
2018-07-27 19:25:57 -04:00
2017-11-19 16:55:28 -05:00
default :
$account_type = " " ;
break ;
}
return $account_type ;
}
2017-11-29 17:29:11 -05:00
/**
2017-12-01 00:41:26 -05:00
* @ brief Blocks a contact
*
* @ param int $uid
* @ return bool
2019-01-06 16:06:53 -05:00
* @ throws \Exception
2017-12-01 00:41:26 -05:00
*/
public static function block ( $uid )
{
2018-07-20 08:19:26 -04:00
$return = DBA :: update ( 'contact' , [ 'blocked' => true ], [ 'id' => $uid ]);
2017-12-01 00:41:26 -05:00
return $return ;
}
/**
* @ brief Unblocks a contact
*
* @ param int $uid
* @ return bool
2019-01-06 16:06:53 -05:00
* @ throws \Exception
2017-12-01 00:41:26 -05:00
*/
public static function unblock ( $uid )
{
2018-07-20 08:19:26 -04:00
$return = DBA :: update ( 'contact' , [ 'blocked' => false ], [ 'id' => $uid ]);
2017-12-01 00:41:26 -05:00
return $return ;
2018-01-11 03:37:11 -05:00
}
2017-12-01 00:48:13 -05:00
2018-01-11 03:37:11 -05:00
/**
* @ brief Updates the avatar links in a contact only if needed
2017-11-29 17:29:11 -05:00
*
* @ param string $avatar Link to avatar picture
* @ param int $uid User id of contact owner
* @ param int $cid Contact id
* @ param bool $force force picture update
*
* @ return array Returns array of the different avatar sizes
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2017-11-29 17:29:11 -05:00
*/
public static function updateAvatar ( $avatar , $uid , $cid , $force = false )
{
2018-07-20 08:19:26 -04:00
$contact = DBA :: selectFirst ( 'contact' , [ 'avatar' , 'photo' , 'thumb' , 'micro' , 'nurl' ], [ 'id' => $cid ]);
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $contact )) {
2017-11-29 17:29:11 -05:00
return false ;
} else {
2018-01-15 08:05:12 -05:00
$data = [ $contact [ " photo " ], $contact [ " thumb " ], $contact [ " micro " ]];
2017-11-29 17:29:11 -05:00
}
2018-01-11 03:26:30 -05:00
if (( $contact [ " avatar " ] != $avatar ) || $force ) {
2017-12-08 01:15:06 -05:00
$photos = Photo :: importProfilePhoto ( $avatar , $uid , $cid , true );
2017-11-29 17:29:11 -05:00
if ( $photos ) {
2018-07-20 08:19:26 -04:00
DBA :: update (
2017-11-29 17:29:11 -05:00
'contact' ,
2018-01-26 21:38:34 -05:00
[ 'avatar' => $avatar , 'photo' => $photos [ 0 ], 'thumb' => $photos [ 1 ], 'micro' => $photos [ 2 ], 'avatar-date' => DateTimeFormat :: utcNow ()],
2018-01-15 08:05:12 -05:00
[ 'id' => $cid ]
2017-11-29 17:29:11 -05:00
);
// Update the public contact (contact id = 0)
if ( $uid != 0 ) {
2018-07-20 08:19:26 -04:00
$pcontact = DBA :: selectFirst ( 'contact' , [ 'id' ], [ 'nurl' => $contact [ 'nurl' ], 'uid' => 0 ]);
2018-07-21 08:46:04 -04:00
if ( DBA :: isResult ( $pcontact )) {
2017-11-29 17:29:11 -05:00
self :: updateAvatar ( $avatar , 0 , $pcontact [ 'id' ], $force );
}
}
return $photos ;
}
}
return $data ;
}
2018-01-09 09:40:45 -05:00
/**
2018-09-15 14:54:45 -04:00
* @ param integer $id contact id
* @ param string $network Optional network we are probing for
2019-03-06 19:13:39 -05:00
* @ param boolean $force Optional forcing of network probing ( otherwise we use the cached data )
2018-01-09 09:40:45 -05:00
* @ return boolean
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2018-01-09 09:40:45 -05:00
*/
2019-03-06 19:13:39 -05:00
public static function updateFromProbe ( $id , $network = '' , $force = false )
2018-01-09 09:40:45 -05:00
{
/*
2018-01-11 03:37:11 -05:00
Warning : Never ever fetch the public key via Probe :: uri and write it into the contacts .
This will reliably kill your communication with Friendica contacts .
*/
2018-01-09 09:40:45 -05:00
2019-03-06 19:13:39 -05:00
$fields = [ 'avatar' , 'uid' , 'name' , 'nick' , 'url' , 'addr' , 'batch' , 'notify' ,
'poll' , 'request' , 'confirm' , 'poco' , 'network' , 'alias' ];
2018-07-20 08:19:26 -04:00
$contact = DBA :: selectFirst ( 'contact' , $fields , [ 'id' => $id ]);
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $contact )) {
2018-01-09 09:40:45 -05:00
return false ;
}
2019-03-06 19:13:39 -05:00
$uid = $contact [ 'uid' ];
unset ( $contact [ 'uid' ]);
$contact [ 'photo' ] = $contact [ 'avatar' ];
unset ( $contact [ 'avatar' ]);
$ret = Probe :: uri ( $contact [ 'url' ], $network , $uid , ! $force );
2018-01-09 09:40:45 -05:00
2019-01-16 16:39:56 -05:00
// If Probe::uri fails the network code will be different (mostly "feed" or "unkn")
2019-03-06 19:13:39 -05:00
if (( in_array ( $ret [ 'network' ], [ Protocol :: FEED , Protocol :: PHANTOM ])) && ( $ret [ 'network' ] != $contact [ 'network' ])) {
2018-01-09 09:40:45 -05:00
return false ;
}
$update = false ;
// make sure to not overwrite existing values with blank entries
2018-01-09 09:44:22 -05:00
foreach ( $ret as $key => $val ) {
2019-03-06 19:13:39 -05:00
if ( ! isset ( $contact [ $key ])) {
unset ( $ret [ $key ]);
} elseif (( $contact [ $key ] != '' ) && ( $val == '' )) {
2018-01-11 03:26:30 -05:00
$ret [ $key ] = $contact [ $key ];
2019-03-06 19:13:39 -05:00
} elseif ( $ret [ $key ] != $contact [ $key ]) {
2018-01-09 09:40:45 -05:00
$update = true ;
2018-01-11 03:26:30 -05:00
}
2018-01-09 09:40:45 -05:00
}
if ( ! $update ) {
return true ;
}
2019-03-06 19:13:39 -05:00
$ret [ 'nurl' ] = Strings :: normaliseLink ( $ret [ 'url' ]);
2019-04-09 01:15:23 -04:00
$ret [ 'updated' ] = DateTimeFormat :: utcNow ();
2019-03-06 19:13:39 -05:00
self :: updateAvatar ( $ret [ 'photo' ], $uid , $id , true );
unset ( $ret [ 'photo' ]);
DBA :: update ( 'contact' , $ret , [ 'id' => $id ]);
2018-01-09 09:40:45 -05:00
// Update the corresponding gcontact entry
PortableContact :: lastUpdated ( $ret [ " url " ]);
return true ;
}
/**
* Takes a $uid and a url / handle and adds a new contact
* Currently if the contact is DFRN , interactive needs to be true , to redirect to the
* dfrn_request page .
*
2018-01-11 03:37:11 -05:00
* Otherwise this can be used to bulk add StatusNet contacts , Twitter contacts , etc .
2018-01-09 09:40:45 -05:00
*
* Returns an array
* $return [ 'success' ] boolean true if successful
* $return [ 'message' ] error text if success is false .
*
* @ brief Takes a $uid and a url / handle and adds a new contact
* @ param int $uid
* @ param string $url
* @ param bool $interactive
* @ param string $network
2019-01-06 16:06:53 -05:00
* @ return array
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2018-01-09 09:40:45 -05:00
*/
2018-01-09 11:40:25 -05:00
public static function createFromProbe ( $uid , $url , $interactive = false , $network = '' )
2018-01-09 09:40:45 -05:00
{
2018-01-15 08:05:12 -05:00
$result = [ 'cid' => - 1 , 'success' => false , 'message' => '' ];
2018-01-09 09:40:45 -05:00
2018-12-27 19:22:35 -05:00
$a = \get_app ();
2018-01-09 09:40:45 -05:00
// remove ajax junk, e.g. Twitter
$url = str_replace ( '/#!/' , '/' , $url );
2018-01-27 11:13:41 -05:00
if ( ! Network :: isUrlAllowed ( $url )) {
2018-01-22 09:54:13 -05:00
$result [ 'message' ] = L10n :: t ( 'Disallowed profile URL.' );
2018-01-09 09:40:45 -05:00
return $result ;
}
2018-01-27 11:13:41 -05:00
if ( Network :: isUrlBlocked ( $url )) {
2018-01-22 09:54:13 -05:00
$result [ 'message' ] = L10n :: t ( 'Blocked domain' );
2018-01-09 09:40:45 -05:00
return $result ;
}
if ( ! $url ) {
2018-01-22 09:54:13 -05:00
$result [ 'message' ] = L10n :: t ( 'Connect URL missing.' );
2018-01-09 09:40:45 -05:00
return $result ;
}
2018-01-15 08:05:12 -05:00
$arr = [ 'url' => $url , 'contact' => []];
2018-01-09 09:40:45 -05:00
2018-11-10 08:18:16 -05:00
Hook :: callAll ( 'follow' , $arr );
2018-01-09 09:40:45 -05:00
2018-01-30 13:51:09 -05:00
if ( empty ( $arr )) {
2018-01-30 15:48:12 -05:00
$result [ 'message' ] = L10n :: t ( 'The contact could not be added. Please check the relevant network credentials in your Settings -> Social Networks page.' );
2018-01-30 13:51:09 -05:00
return $result ;
}
2018-11-30 09:06:22 -05:00
if ( ! empty ( $arr [ 'contact' ][ 'name' ])) {
2018-01-09 09:40:45 -05:00
$ret = $arr [ 'contact' ];
} else {
$ret = Probe :: uri ( $url , $network , $uid , false );
}
if (( $network != '' ) && ( $ret [ 'network' ] != $network )) {
2018-10-29 17:20:46 -04:00
Logger :: log ( 'Expected network ' . $network . ' does not match actual network ' . $ret [ 'network' ]);
2018-05-14 21:23:24 -04:00
return $result ;
2018-01-09 09:40:45 -05:00
}
2018-03-16 02:43:10 -04:00
// check if we already have a contact
// the poll url is more reliable than the profile url, as we may have
// indirect links or webfinger links
2018-11-08 11:28:29 -05:00
$condition = [ 'uid' => $uid , 'poll' => [ $ret [ 'poll' ], Strings :: normaliseLink ( $ret [ 'poll' ])], 'network' => $ret [ 'network' ], 'pending' => false ];
2018-08-19 08:46:11 -04:00
$contact = DBA :: selectFirst ( 'contact' , [ 'id' , 'rel' ], $condition );
if ( ! DBA :: isResult ( $contact )) {
2018-11-08 11:28:29 -05:00
$condition = [ 'uid' => $uid , 'nurl' => Strings :: normaliseLink ( $url ), 'network' => $ret [ 'network' ], 'pending' => false ];
2018-08-19 08:46:11 -04:00
$contact = DBA :: selectFirst ( 'contact' , [ 'id' , 'rel' ], $condition );
2018-03-16 02:43:10 -04:00
}
2018-08-19 08:46:11 -04:00
if (( $ret [ 'network' ] === Protocol :: DFRN ) && ! DBA :: isResult ( $contact )) {
2018-01-09 09:40:45 -05:00
if ( $interactive ) {
2018-10-09 19:18:47 -04:00
if ( strlen ( $a -> getURLPath ())) {
2018-01-09 09:40:45 -05:00
$myaddr = bin2hex ( System :: baseUrl () . '/profile/' . $a -> user [ 'nickname' ]);
} else {
2018-10-09 13:58:58 -04:00
$myaddr = bin2hex ( $a -> user [ 'nickname' ] . '@' . $a -> getHostName ());
2018-01-09 09:40:45 -05:00
}
2018-10-19 14:11:27 -04:00
$a -> internalRedirect ( $ret [ 'request' ] . " &addr= $myaddr " );
2018-01-09 09:40:45 -05:00
// NOTREACHED
}
2018-08-11 16:40:44 -04:00
} elseif ( Config :: get ( 'system' , 'dfrn_only' ) && ( $ret [ 'network' ] != Protocol :: DFRN )) {
2018-01-22 09:54:13 -05:00
$result [ 'message' ] = L10n :: t ( 'This site is not configured to allow communications with other networks.' ) . EOL ;
2019-01-07 13:28:55 -05:00
$result [ 'message' ] .= L10n :: t ( 'No compatible communication protocols or feeds were discovered.' ) . EOL ;
2018-01-09 09:40:45 -05:00
return $result ;
}
// This extra param just confuses things, remove it
2018-08-11 16:40:44 -04:00
if ( $ret [ 'network' ] === Protocol :: DIASPORA ) {
2018-01-09 09:40:45 -05:00
$ret [ 'url' ] = str_replace ( '?absolute=true' , '' , $ret [ 'url' ]);
}
// do we have enough information?
2018-11-30 09:06:22 -05:00
if ( empty ( $ret [ 'name' ]) || empty ( $ret [ 'poll' ]) || ( empty ( $ret [ 'url' ]) && empty ( $ret [ 'addr' ]))) {
2018-01-22 09:54:13 -05:00
$result [ 'message' ] .= L10n :: t ( 'The profile address specified does not provide adequate information.' ) . EOL ;
2018-11-30 09:06:22 -05:00
if ( empty ( $ret [ 'poll' ])) {
2018-01-22 09:54:13 -05:00
$result [ 'message' ] .= L10n :: t ( 'No compatible communication protocols or feeds were discovered.' ) . EOL ;
2018-01-09 09:40:45 -05:00
}
2018-11-30 09:06:22 -05:00
if ( empty ( $ret [ 'name' ])) {
2018-01-22 09:54:13 -05:00
$result [ 'message' ] .= L10n :: t ( 'An author or name was not found.' ) . EOL ;
2018-01-09 09:40:45 -05:00
}
2018-11-30 09:06:22 -05:00
if ( empty ( $ret [ 'url' ])) {
2018-01-22 09:54:13 -05:00
$result [ 'message' ] .= L10n :: t ( 'No browser URL could be matched to this address.' ) . EOL ;
2018-01-09 09:40:45 -05:00
}
if ( strpos ( $url , '@' ) !== false ) {
2018-01-22 09:54:13 -05:00
$result [ 'message' ] .= L10n :: t ( 'Unable to match @-style Identity Address with a known protocol or email contact.' ) . EOL ;
$result [ 'message' ] .= L10n :: t ( 'Use mailto: in front of address to force email check.' ) . EOL ;
2018-01-09 09:40:45 -05:00
}
return $result ;
}
2018-08-11 16:40:44 -04:00
if ( $ret [ 'network' ] === Protocol :: OSTATUS && Config :: get ( 'system' , 'ostatus_disabled' )) {
2018-01-22 09:54:13 -05:00
$result [ 'message' ] .= L10n :: t ( 'The profile address specified belongs to a network which has been disabled on this site.' ) . EOL ;
2018-01-09 09:40:45 -05:00
$ret [ 'notify' ] = '' ;
}
if ( ! $ret [ 'notify' ]) {
2018-01-22 09:54:13 -05:00
$result [ 'message' ] .= L10n :: t ( 'Limited profile. This person will be unable to receive direct/personal notifications from you.' ) . EOL ;
2018-01-09 09:40:45 -05:00
}
2018-08-11 16:40:44 -04:00
$writeable = ((( $ret [ 'network' ] === Protocol :: OSTATUS ) && ( $ret [ 'notify' ])) ? 1 : 0 );
2018-01-09 09:40:45 -05:00
2018-08-11 16:40:44 -04:00
$subhub = (( $ret [ 'network' ] === Protocol :: OSTATUS ) ? true : false );
2018-01-09 09:40:45 -05:00
2018-08-11 16:40:44 -04:00
$hidden = (( $ret [ 'network' ] === Protocol :: MAIL ) ? 1 : 0 );
2018-01-09 09:40:45 -05:00
2019-01-09 08:23:11 -05:00
$pending = in_array ( $ret [ 'network' ], [ Protocol :: ACTIVITYPUB ]);
2018-09-15 14:54:45 -04:00
if ( in_array ( $ret [ 'network' ], [ Protocol :: MAIL , Protocol :: DIASPORA , Protocol :: ACTIVITYPUB ])) {
2018-01-09 09:40:45 -05:00
$writeable = 1 ;
}
2018-08-19 08:46:11 -04:00
if ( DBA :: isResult ( $contact )) {
2018-01-09 09:40:45 -05:00
// update contact
2018-08-19 08:46:11 -04:00
$new_relation = (( $contact [ 'rel' ] == self :: FOLLOWER ) ? self :: FRIEND : self :: SHARING );
2018-01-09 09:40:45 -05:00
2018-01-15 08:05:12 -05:00
$fields = [ 'rel' => $new_relation , 'subhub' => $subhub , 'readonly' => false ];
2018-08-19 08:46:11 -04:00
DBA :: update ( 'contact' , $fields , [ 'id' => $contact [ 'id' ]]);
2018-01-09 09:40:45 -05:00
} else {
2018-08-19 08:46:11 -04:00
$new_relation = ( in_array ( $ret [ 'network' ], [ Protocol :: MAIL ]) ? self :: FRIEND : self :: SHARING );
2018-01-09 09:40:45 -05:00
// create contact record
2018-07-20 08:19:26 -04:00
DBA :: insert ( 'contact' , [
2018-01-11 03:37:11 -05:00
'uid' => $uid ,
2018-01-26 21:38:34 -05:00
'created' => DateTimeFormat :: utcNow (),
2018-01-11 03:37:11 -05:00
'url' => $ret [ 'url' ],
2018-11-08 11:28:29 -05:00
'nurl' => Strings :: normaliseLink ( $ret [ 'url' ]),
2018-01-11 03:37:11 -05:00
'addr' => $ret [ 'addr' ],
'alias' => $ret [ 'alias' ],
'batch' => $ret [ 'batch' ],
'notify' => $ret [ 'notify' ],
'poll' => $ret [ 'poll' ],
'poco' => $ret [ 'poco' ],
'name' => $ret [ 'name' ],
'nick' => $ret [ 'nick' ],
'network' => $ret [ 'network' ],
'pubkey' => $ret [ 'pubkey' ],
'rel' => $new_relation ,
'priority' => $ret [ 'priority' ],
'writable' => $writeable ,
'hidden' => $hidden ,
'blocked' => 0 ,
'readonly' => 0 ,
2019-01-09 08:23:11 -05:00
'pending' => $pending ,
2018-01-11 03:37:11 -05:00
'subhub' => $subhub
]);
2018-01-09 09:40:45 -05:00
}
2018-07-20 08:19:26 -04:00
$contact = DBA :: selectFirst ( 'contact' , [], [ 'url' => $ret [ 'url' ], 'network' => $ret [ 'network' ], 'uid' => $uid ]);
2018-07-21 08:46:04 -04:00
if ( ! DBA :: isResult ( $contact )) {
2018-01-22 09:54:13 -05:00
$result [ 'message' ] .= L10n :: t ( 'Unable to retrieve contact information.' ) . EOL ;
2018-01-09 09:40:45 -05:00
return $result ;
}
2018-01-10 20:13:51 -05:00
$contact_id = $contact [ 'id' ];
2018-01-09 09:40:45 -05:00
$result [ 'cid' ] = $contact_id ;
Group :: addMember ( User :: getDefaultGroup ( $uid , $contact [ " network " ]), $contact_id );
// Update the avatar
2018-01-09 10:02:53 -05:00
self :: updateAvatar ( $ret [ 'photo' ], $uid , $contact_id );
2018-01-09 09:40:45 -05:00
// pull feed and consume it, which should subscribe to the hub.
Worker :: add ( PRIORITY_HIGH , " OnePoll " , $contact_id , " force " );
2018-08-19 08:46:11 -04:00
$owner = User :: getOwnerDataById ( $uid );
2018-01-09 09:40:45 -05:00
2018-08-19 08:46:11 -04:00
if ( DBA :: isResult ( $owner )) {
2018-08-11 16:40:44 -04:00
if ( in_array ( $contact [ 'network' ], [ Protocol :: OSTATUS , Protocol :: DFRN ])) {
2018-01-09 09:40:45 -05:00
// create a follow slap
2018-01-15 08:05:12 -05:00
$item = [];
2018-01-09 09:40:45 -05:00
$item [ 'verb' ] = ACTIVITY_FOLLOW ;
$item [ 'follow' ] = $contact [ " url " ];
2018-08-01 01:29:58 -04:00
$item [ 'body' ] = '' ;
$item [ 'title' ] = '' ;
$item [ 'guid' ] = '' ;
$item [ 'tag' ] = '' ;
$item [ 'attach' ] = '' ;
Cleanups: isResult() more used, readability improved (#5608)
* [diaspora]: Maybe SimpleXMLElement is the right type-hint?
* Changes proposed + pre-renaming:
- pre-renamed $db -> $connection
- added TODOs for not allowing bad method invocations (there is a
BadMethodCallException in SPL)
* If no record is found, below $r[0] will fail with a E_NOTICE and the code
doesn't behave as expected.
* Ops, one more left ...
* Continued:
- added documentation for Contact::updateSslPolicy() method
- added type-hint for $contact of same method
- empty lines added + TODO where the bug origins that $item has no element 'body'
* Added empty lines for better readability
* Cleaned up:
- no more x() (deprecated) usage but empty() instead
- fixed mixing of space/tab indending
- merged else/if block goether in elseif() (lesser nested code blocks)
* Re-fixed DBM -> DBA switch
* Fixes/rewrites:
- use empty()/isset() instead of deprecated x()
- merged 2 nested if() blocks into one
- avoided nested if() block inside else block by rewriting it to elseif()
- $contact_id is an integer, let's test on > 0 here
- added a lot spaces and some empty lines for better readability
* Rewrite:
- moved all CONTACT_* constants from boot.php to Contact class
* CR request:
- renamed Contact::CONTACT_IS_* -> Contact::* ;-)
* Rewrites:
- moved PAGE_* to Friendica\Model\Profile class
- fixed mixure with "Contact::* rewrite"
* Ops, one still there (return is no function)
* Rewrite to Proxy class:
- introduced new Friendica\Network\Proxy class for in exchange of proxy_*()
functions
- moved also all PROXY_* constants there as Proxy::*
- removed now no longer needed mod/proxy.php loading as composer's auto-load
will do this for us
- renamed those proxy_*() functions to better names:
+ proxy_init() -> Proxy::init() (public)
+ proxy_url() -> Proxy::proxifyUrl() (public)
+ proxy_parse_html() -> Proxy::proxifyHtml() (public)
+ proxy_is_local_image() -> Proxy::isLocalImage() (private)
+ proxy_parse_query() -> Proxy::parseQuery() (private)
+ proxy_img_cb() -> Proxy::replaceUrl() (private)
* CR request:
- moved all PAGE_* constants to Friendica\Model\Contact class
- fixed all references of both classes
* Ops, need to set $a here ...
* CR request:
- moved Proxy class to Friendica\Module
- extended BaseModule
* Ops, no need for own instance of $a when self::getApp() is around.
* Proxy-rewrite:
- proxy_url() and proxy_parse_html() are both non-module functions (now
methods)
- so they must be splitted into a seperate class
- also the SIZE_* and DEFAULT_TIME constants are both not relevant to module
* No instances from utility classes
* Fixed error:
- proxify*() is now located in `Friendica\Util\ProxyUtils`
* Moved back to original place, ops? How did they move here? Well, it was not
intended by me.
* Removed duplicate (left-over from split) constants and static array. Thank to
MrPetovan finding it.
* Renamed ProxyUtils -> Proxy and aliased it back to ProxyUtils.
* Rewrite:
- stopped using deprecated NETWORK_* constants, now Protocol::* should be used
- still left them intact for slow/lazy developers ...
* Ops, was added accidentally ...
* Ops, why these wrong moves?
* Ops, one to much (thanks to MrPetovan)
* Ops, wrong moving ...
* moved back to original place ...
* spaces added
* empty lines add for better readability.
* convertered spaces -> tab for code indenting.
* CR request: Add space between if and brace.
* CR requests fixed + move reverted
- ops, src/Module/*.php has been moved to src/Network/ accidentally
- reverted some parts in src/Database/DBA.php as pointed out by Annando
- removed internal TODO items
- added some spaces for better readability
2018-08-24 01:05:49 -04:00
2018-08-19 08:46:11 -04:00
$slap = OStatus :: salmon ( $item , $owner );
Cleanups: isResult() more used, readability improved (#5608)
* [diaspora]: Maybe SimpleXMLElement is the right type-hint?
* Changes proposed + pre-renaming:
- pre-renamed $db -> $connection
- added TODOs for not allowing bad method invocations (there is a
BadMethodCallException in SPL)
* If no record is found, below $r[0] will fail with a E_NOTICE and the code
doesn't behave as expected.
* Ops, one more left ...
* Continued:
- added documentation for Contact::updateSslPolicy() method
- added type-hint for $contact of same method
- empty lines added + TODO where the bug origins that $item has no element 'body'
* Added empty lines for better readability
* Cleaned up:
- no more x() (deprecated) usage but empty() instead
- fixed mixing of space/tab indending
- merged else/if block goether in elseif() (lesser nested code blocks)
* Re-fixed DBM -> DBA switch
* Fixes/rewrites:
- use empty()/isset() instead of deprecated x()
- merged 2 nested if() blocks into one
- avoided nested if() block inside else block by rewriting it to elseif()
- $contact_id is an integer, let's test on > 0 here
- added a lot spaces and some empty lines for better readability
* Rewrite:
- moved all CONTACT_* constants from boot.php to Contact class
* CR request:
- renamed Contact::CONTACT_IS_* -> Contact::* ;-)
* Rewrites:
- moved PAGE_* to Friendica\Model\Profile class
- fixed mixure with "Contact::* rewrite"
* Ops, one still there (return is no function)
* Rewrite to Proxy class:
- introduced new Friendica\Network\Proxy class for in exchange of proxy_*()
functions
- moved also all PROXY_* constants there as Proxy::*
- removed now no longer needed mod/proxy.php loading as composer's auto-load
will do this for us
- renamed those proxy_*() functions to better names:
+ proxy_init() -> Proxy::init() (public)
+ proxy_url() -> Proxy::proxifyUrl() (public)
+ proxy_parse_html() -> Proxy::proxifyHtml() (public)
+ proxy_is_local_image() -> Proxy::isLocalImage() (private)
+ proxy_parse_query() -> Proxy::parseQuery() (private)
+ proxy_img_cb() -> Proxy::replaceUrl() (private)
* CR request:
- moved all PAGE_* constants to Friendica\Model\Contact class
- fixed all references of both classes
* Ops, need to set $a here ...
* CR request:
- moved Proxy class to Friendica\Module
- extended BaseModule
* Ops, no need for own instance of $a when self::getApp() is around.
* Proxy-rewrite:
- proxy_url() and proxy_parse_html() are both non-module functions (now
methods)
- so they must be splitted into a seperate class
- also the SIZE_* and DEFAULT_TIME constants are both not relevant to module
* No instances from utility classes
* Fixed error:
- proxify*() is now located in `Friendica\Util\ProxyUtils`
* Moved back to original place, ops? How did they move here? Well, it was not
intended by me.
* Removed duplicate (left-over from split) constants and static array. Thank to
MrPetovan finding it.
* Renamed ProxyUtils -> Proxy and aliased it back to ProxyUtils.
* Rewrite:
- stopped using deprecated NETWORK_* constants, now Protocol::* should be used
- still left them intact for slow/lazy developers ...
* Ops, was added accidentally ...
* Ops, why these wrong moves?
* Ops, one to much (thanks to MrPetovan)
* Ops, wrong moving ...
* moved back to original place ...
* spaces added
* empty lines add for better readability.
* convertered spaces -> tab for code indenting.
* CR request: Add space between if and brace.
* CR requests fixed + move reverted
- ops, src/Module/*.php has been moved to src/Network/ accidentally
- reverted some parts in src/Database/DBA.php as pointed out by Annando
- removed internal TODO items
- added some spaces for better readability
2018-08-24 01:05:49 -04:00
2018-03-16 02:43:10 -04:00
if ( ! empty ( $contact [ 'notify' ])) {
2018-08-19 08:46:11 -04:00
Salmon :: slapper ( $owner , $contact [ 'notify' ], $slap );
2018-03-16 02:43:10 -04:00
}
2018-08-11 16:40:44 -04:00
} elseif ( $contact [ 'network' ] == Protocol :: DIASPORA ) {
2018-01-09 09:40:45 -05:00
$ret = Diaspora :: sendShare ( $a -> user , $contact );
2018-10-29 17:20:46 -04:00
Logger :: log ( 'share returns: ' . $ret );
2018-09-15 14:54:45 -04:00
} elseif ( $contact [ 'network' ] == Protocol :: ACTIVITYPUB ) {
2019-01-10 02:24:12 -05:00
$activity_id = ActivityPub\Transmitter :: activityIDFromContact ( $contact_id );
if ( empty ( $activity_id )) {
// This really should never happen
return false ;
}
$ret = ActivityPub\Transmitter :: sendActivity ( 'Follow' , $contact [ 'url' ], $uid , $activity_id );
2018-10-29 17:20:46 -04:00
Logger :: log ( 'Follow returns: ' . $ret );
2018-01-09 09:40:45 -05:00
}
}
$result [ 'success' ] = true ;
return $result ;
}
2018-01-27 11:13:41 -05:00
Cleanups: isResult() more used, readability improved (#5608)
* [diaspora]: Maybe SimpleXMLElement is the right type-hint?
* Changes proposed + pre-renaming:
- pre-renamed $db -> $connection
- added TODOs for not allowing bad method invocations (there is a
BadMethodCallException in SPL)
* If no record is found, below $r[0] will fail with a E_NOTICE and the code
doesn't behave as expected.
* Ops, one more left ...
* Continued:
- added documentation for Contact::updateSslPolicy() method
- added type-hint for $contact of same method
- empty lines added + TODO where the bug origins that $item has no element 'body'
* Added empty lines for better readability
* Cleaned up:
- no more x() (deprecated) usage but empty() instead
- fixed mixing of space/tab indending
- merged else/if block goether in elseif() (lesser nested code blocks)
* Re-fixed DBM -> DBA switch
* Fixes/rewrites:
- use empty()/isset() instead of deprecated x()
- merged 2 nested if() blocks into one
- avoided nested if() block inside else block by rewriting it to elseif()
- $contact_id is an integer, let's test on > 0 here
- added a lot spaces and some empty lines for better readability
* Rewrite:
- moved all CONTACT_* constants from boot.php to Contact class
* CR request:
- renamed Contact::CONTACT_IS_* -> Contact::* ;-)
* Rewrites:
- moved PAGE_* to Friendica\Model\Profile class
- fixed mixure with "Contact::* rewrite"
* Ops, one still there (return is no function)
* Rewrite to Proxy class:
- introduced new Friendica\Network\Proxy class for in exchange of proxy_*()
functions
- moved also all PROXY_* constants there as Proxy::*
- removed now no longer needed mod/proxy.php loading as composer's auto-load
will do this for us
- renamed those proxy_*() functions to better names:
+ proxy_init() -> Proxy::init() (public)
+ proxy_url() -> Proxy::proxifyUrl() (public)
+ proxy_parse_html() -> Proxy::proxifyHtml() (public)
+ proxy_is_local_image() -> Proxy::isLocalImage() (private)
+ proxy_parse_query() -> Proxy::parseQuery() (private)
+ proxy_img_cb() -> Proxy::replaceUrl() (private)
* CR request:
- moved all PAGE_* constants to Friendica\Model\Contact class
- fixed all references of both classes
* Ops, need to set $a here ...
* CR request:
- moved Proxy class to Friendica\Module
- extended BaseModule
* Ops, no need for own instance of $a when self::getApp() is around.
* Proxy-rewrite:
- proxy_url() and proxy_parse_html() are both non-module functions (now
methods)
- so they must be splitted into a seperate class
- also the SIZE_* and DEFAULT_TIME constants are both not relevant to module
* No instances from utility classes
* Fixed error:
- proxify*() is now located in `Friendica\Util\ProxyUtils`
* Moved back to original place, ops? How did they move here? Well, it was not
intended by me.
* Removed duplicate (left-over from split) constants and static array. Thank to
MrPetovan finding it.
* Renamed ProxyUtils -> Proxy and aliased it back to ProxyUtils.
* Rewrite:
- stopped using deprecated NETWORK_* constants, now Protocol::* should be used
- still left them intact for slow/lazy developers ...
* Ops, was added accidentally ...
* Ops, why these wrong moves?
* Ops, one to much (thanks to MrPetovan)
* Ops, wrong moving ...
* moved back to original place ...
* spaces added
* empty lines add for better readability.
* convertered spaces -> tab for code indenting.
* CR request: Add space between if and brace.
* CR requests fixed + move reverted
- ops, src/Module/*.php has been moved to src/Network/ accidentally
- reverted some parts in src/Database/DBA.php as pointed out by Annando
- removed internal TODO items
- added some spaces for better readability
2018-08-24 01:05:49 -04:00
/**
* @ brief Updated contact ' s SSL policy
*
2019-01-06 16:06:53 -05:00
* @ param array $contact Contact array
Cleanups: isResult() more used, readability improved (#5608)
* [diaspora]: Maybe SimpleXMLElement is the right type-hint?
* Changes proposed + pre-renaming:
- pre-renamed $db -> $connection
- added TODOs for not allowing bad method invocations (there is a
BadMethodCallException in SPL)
* If no record is found, below $r[0] will fail with a E_NOTICE and the code
doesn't behave as expected.
* Ops, one more left ...
* Continued:
- added documentation for Contact::updateSslPolicy() method
- added type-hint for $contact of same method
- empty lines added + TODO where the bug origins that $item has no element 'body'
* Added empty lines for better readability
* Cleaned up:
- no more x() (deprecated) usage but empty() instead
- fixed mixing of space/tab indending
- merged else/if block goether in elseif() (lesser nested code blocks)
* Re-fixed DBM -> DBA switch
* Fixes/rewrites:
- use empty()/isset() instead of deprecated x()
- merged 2 nested if() blocks into one
- avoided nested if() block inside else block by rewriting it to elseif()
- $contact_id is an integer, let's test on > 0 here
- added a lot spaces and some empty lines for better readability
* Rewrite:
- moved all CONTACT_* constants from boot.php to Contact class
* CR request:
- renamed Contact::CONTACT_IS_* -> Contact::* ;-)
* Rewrites:
- moved PAGE_* to Friendica\Model\Profile class
- fixed mixure with "Contact::* rewrite"
* Ops, one still there (return is no function)
* Rewrite to Proxy class:
- introduced new Friendica\Network\Proxy class for in exchange of proxy_*()
functions
- moved also all PROXY_* constants there as Proxy::*
- removed now no longer needed mod/proxy.php loading as composer's auto-load
will do this for us
- renamed those proxy_*() functions to better names:
+ proxy_init() -> Proxy::init() (public)
+ proxy_url() -> Proxy::proxifyUrl() (public)
+ proxy_parse_html() -> Proxy::proxifyHtml() (public)
+ proxy_is_local_image() -> Proxy::isLocalImage() (private)
+ proxy_parse_query() -> Proxy::parseQuery() (private)
+ proxy_img_cb() -> Proxy::replaceUrl() (private)
* CR request:
- moved all PAGE_* constants to Friendica\Model\Contact class
- fixed all references of both classes
* Ops, need to set $a here ...
* CR request:
- moved Proxy class to Friendica\Module
- extended BaseModule
* Ops, no need for own instance of $a when self::getApp() is around.
* Proxy-rewrite:
- proxy_url() and proxy_parse_html() are both non-module functions (now
methods)
- so they must be splitted into a seperate class
- also the SIZE_* and DEFAULT_TIME constants are both not relevant to module
* No instances from utility classes
* Fixed error:
- proxify*() is now located in `Friendica\Util\ProxyUtils`
* Moved back to original place, ops? How did they move here? Well, it was not
intended by me.
* Removed duplicate (left-over from split) constants and static array. Thank to
MrPetovan finding it.
* Renamed ProxyUtils -> Proxy and aliased it back to ProxyUtils.
* Rewrite:
- stopped using deprecated NETWORK_* constants, now Protocol::* should be used
- still left them intact for slow/lazy developers ...
* Ops, was added accidentally ...
* Ops, why these wrong moves?
* Ops, one to much (thanks to MrPetovan)
* Ops, wrong moving ...
* moved back to original place ...
* spaces added
* empty lines add for better readability.
* convertered spaces -> tab for code indenting.
* CR request: Add space between if and brace.
* CR requests fixed + move reverted
- ops, src/Module/*.php has been moved to src/Network/ accidentally
- reverted some parts in src/Database/DBA.php as pointed out by Annando
- removed internal TODO items
- added some spaces for better readability
2018-08-24 01:05:49 -04:00
* @ param string $new_policy New policy , valid : self , full
*
* @ return array Contact array with updated values
2019-01-06 16:06:53 -05:00
* @ throws \Exception
Cleanups: isResult() more used, readability improved (#5608)
* [diaspora]: Maybe SimpleXMLElement is the right type-hint?
* Changes proposed + pre-renaming:
- pre-renamed $db -> $connection
- added TODOs for not allowing bad method invocations (there is a
BadMethodCallException in SPL)
* If no record is found, below $r[0] will fail with a E_NOTICE and the code
doesn't behave as expected.
* Ops, one more left ...
* Continued:
- added documentation for Contact::updateSslPolicy() method
- added type-hint for $contact of same method
- empty lines added + TODO where the bug origins that $item has no element 'body'
* Added empty lines for better readability
* Cleaned up:
- no more x() (deprecated) usage but empty() instead
- fixed mixing of space/tab indending
- merged else/if block goether in elseif() (lesser nested code blocks)
* Re-fixed DBM -> DBA switch
* Fixes/rewrites:
- use empty()/isset() instead of deprecated x()
- merged 2 nested if() blocks into one
- avoided nested if() block inside else block by rewriting it to elseif()
- $contact_id is an integer, let's test on > 0 here
- added a lot spaces and some empty lines for better readability
* Rewrite:
- moved all CONTACT_* constants from boot.php to Contact class
* CR request:
- renamed Contact::CONTACT_IS_* -> Contact::* ;-)
* Rewrites:
- moved PAGE_* to Friendica\Model\Profile class
- fixed mixure with "Contact::* rewrite"
* Ops, one still there (return is no function)
* Rewrite to Proxy class:
- introduced new Friendica\Network\Proxy class for in exchange of proxy_*()
functions
- moved also all PROXY_* constants there as Proxy::*
- removed now no longer needed mod/proxy.php loading as composer's auto-load
will do this for us
- renamed those proxy_*() functions to better names:
+ proxy_init() -> Proxy::init() (public)
+ proxy_url() -> Proxy::proxifyUrl() (public)
+ proxy_parse_html() -> Proxy::proxifyHtml() (public)
+ proxy_is_local_image() -> Proxy::isLocalImage() (private)
+ proxy_parse_query() -> Proxy::parseQuery() (private)
+ proxy_img_cb() -> Proxy::replaceUrl() (private)
* CR request:
- moved all PAGE_* constants to Friendica\Model\Contact class
- fixed all references of both classes
* Ops, need to set $a here ...
* CR request:
- moved Proxy class to Friendica\Module
- extended BaseModule
* Ops, no need for own instance of $a when self::getApp() is around.
* Proxy-rewrite:
- proxy_url() and proxy_parse_html() are both non-module functions (now
methods)
- so they must be splitted into a seperate class
- also the SIZE_* and DEFAULT_TIME constants are both not relevant to module
* No instances from utility classes
* Fixed error:
- proxify*() is now located in `Friendica\Util\ProxyUtils`
* Moved back to original place, ops? How did they move here? Well, it was not
intended by me.
* Removed duplicate (left-over from split) constants and static array. Thank to
MrPetovan finding it.
* Renamed ProxyUtils -> Proxy and aliased it back to ProxyUtils.
* Rewrite:
- stopped using deprecated NETWORK_* constants, now Protocol::* should be used
- still left them intact for slow/lazy developers ...
* Ops, was added accidentally ...
* Ops, why these wrong moves?
* Ops, one to much (thanks to MrPetovan)
* Ops, wrong moving ...
* moved back to original place ...
* spaces added
* empty lines add for better readability.
* convertered spaces -> tab for code indenting.
* CR request: Add space between if and brace.
* CR requests fixed + move reverted
- ops, src/Module/*.php has been moved to src/Network/ accidentally
- reverted some parts in src/Database/DBA.php as pointed out by Annando
- removed internal TODO items
- added some spaces for better readability
2018-08-24 01:05:49 -04:00
*/
public static function updateSslPolicy ( array $contact , $new_policy )
2018-01-27 11:13:41 -05:00
{
$ssl_changed = false ;
if (( intval ( $new_policy ) == SSL_POLICY_SELFSIGN || $new_policy === 'self' ) && strstr ( $contact [ 'url' ], 'https:' )) {
$ssl_changed = true ;
$contact [ 'url' ] = str_replace ( 'https:' , 'http:' , $contact [ 'url' ]);
$contact [ 'request' ] = str_replace ( 'https:' , 'http:' , $contact [ 'request' ]);
$contact [ 'notify' ] = str_replace ( 'https:' , 'http:' , $contact [ 'notify' ]);
$contact [ 'poll' ] = str_replace ( 'https:' , 'http:' , $contact [ 'poll' ]);
$contact [ 'confirm' ] = str_replace ( 'https:' , 'http:' , $contact [ 'confirm' ]);
$contact [ 'poco' ] = str_replace ( 'https:' , 'http:' , $contact [ 'poco' ]);
}
if (( intval ( $new_policy ) == SSL_POLICY_FULL || $new_policy === 'full' ) && strstr ( $contact [ 'url' ], 'http:' )) {
$ssl_changed = true ;
$contact [ 'url' ] = str_replace ( 'http:' , 'https:' , $contact [ 'url' ]);
$contact [ 'request' ] = str_replace ( 'http:' , 'https:' , $contact [ 'request' ]);
$contact [ 'notify' ] = str_replace ( 'http:' , 'https:' , $contact [ 'notify' ]);
$contact [ 'poll' ] = str_replace ( 'http:' , 'https:' , $contact [ 'poll' ]);
$contact [ 'confirm' ] = str_replace ( 'http:' , 'https:' , $contact [ 'confirm' ]);
$contact [ 'poco' ] = str_replace ( 'http:' , 'https:' , $contact [ 'poco' ]);
}
if ( $ssl_changed ) {
$fields = [ 'url' => $contact [ 'url' ], 'request' => $contact [ 'request' ],
'notify' => $contact [ 'notify' ], 'poll' => $contact [ 'poll' ],
'confirm' => $contact [ 'confirm' ], 'poco' => $contact [ 'poco' ]];
2018-07-20 08:19:26 -04:00
DBA :: update ( 'contact' , $fields , [ 'id' => $contact [ 'id' ]]);
2018-01-27 11:13:41 -05:00
}
return $contact ;
}
2018-01-28 06:18:08 -05:00
2018-09-15 14:54:45 -04:00
public static function addRelationship ( $importer , $contact , $datarray , $item = '' , $sharing = false ) {
2018-08-02 01:21:01 -04:00
// Should always be set
if ( empty ( $datarray [ 'author-id' ])) {
return ;
2018-01-28 06:18:08 -05:00
}
2018-08-02 01:21:01 -04:00
$fields = [ 'url' , 'name' , 'nick' , 'photo' , 'network' ];
$pub_contact = DBA :: selectFirst ( 'contact' , $fields , [ 'id' => $datarray [ 'author-id' ]]);
if ( ! DBA :: isResult ( $pub_contact )) {
// Should never happen
return ;
}
2018-09-15 16:31:05 -04:00
$url = defaults ( $datarray , 'author-link' , $pub_contact [ 'url' ]);
2018-08-02 01:21:01 -04:00
$name = $pub_contact [ 'name' ];
$photo = $pub_contact [ 'photo' ];
$nick = $pub_contact [ 'nick' ];
$network = $pub_contact [ 'network' ];
2018-01-28 06:18:08 -05:00
if ( is_array ( $contact )) {
2018-07-24 22:53:46 -04:00
if (( $contact [ 'rel' ] == self :: SHARING )
|| ( $sharing && $contact [ 'rel' ] == self :: FOLLOWER )) {
DBA :: update ( 'contact' , [ 'rel' => self :: FRIEND , 'writable' => true ],
2018-01-28 06:18:08 -05:00
[ 'id' => $contact [ 'id' ], 'uid' => $importer [ 'uid' ]]);
}
2018-09-15 14:54:45 -04:00
if ( $contact [ 'network' ] == Protocol :: ACTIVITYPUB ) {
2018-10-03 11:41:51 -04:00
ActivityPub\Transmitter :: sendContactAccept ( $contact [ 'url' ], $contact [ 'hub-verify' ], $importer [ 'uid' ]);
2018-09-15 14:54:45 -04:00
}
2018-01-28 06:18:08 -05:00
// send email notification to owner?
} else {
2018-11-08 11:28:29 -05:00
if ( DBA :: exists ( 'contact' , [ 'nurl' => Strings :: normaliseLink ( $url ), 'uid' => $importer [ 'uid' ], 'pending' => true ])) {
2018-10-29 17:20:46 -04:00
Logger :: log ( 'ignoring duplicated connection request from pending contact ' . $url );
2018-04-18 01:02:59 -04:00
return ;
}
2018-01-28 06:18:08 -05:00
// create contact record
q ( " INSERT INTO `contact` (`uid`, `created`, `url`, `nurl`, `name`, `nick`, `photo`, `network`, `rel`,
`blocked` , `readonly` , `pending` , `writable` )
VALUES ( % d , '%s' , '%s' , '%s' , '%s' , '%s' , '%s' , '%s' , % d , 0 , 0 , 1 , 1 ) " ,
intval ( $importer [ 'uid' ]),
2018-07-21 09:10:13 -04:00
DBA :: escape ( DateTimeFormat :: utcNow ()),
DBA :: escape ( $url ),
2018-11-08 11:28:29 -05:00
DBA :: escape ( Strings :: normaliseLink ( $url )),
2018-07-21 09:10:13 -04:00
DBA :: escape ( $name ),
DBA :: escape ( $nick ),
DBA :: escape ( $photo ),
2018-08-02 01:21:01 -04:00
DBA :: escape ( $network ),
2018-07-24 22:53:46 -04:00
intval ( self :: FOLLOWER )
2018-01-28 06:18:08 -05:00
);
2018-02-14 00:05:00 -05:00
$contact_record = [
2018-07-20 08:19:26 -04:00
'id' => DBA :: lastInsertId (),
2018-08-02 01:21:01 -04:00
'network' => $network ,
2018-07-10 08:27:56 -04:00
'name' => $name ,
'url' => $url ,
'photo' => $photo
2018-02-14 00:05:00 -05:00
];
2018-07-10 08:27:56 -04:00
2018-02-14 00:05:00 -05:00
Contact :: updateAvatar ( $photo , $importer [ " uid " ], $contact_record [ " id " ], true );
2018-01-28 06:18:08 -05:00
/// @TODO Encapsulate this into a function/method
2018-02-14 00:05:00 -05:00
$fields = [ 'uid' , 'username' , 'email' , 'page-flags' , 'notify-flags' , 'language' ];
2018-07-20 08:19:26 -04:00
$user = DBA :: selectFirst ( 'user' , $fields , [ 'uid' => $importer [ 'uid' ]]);
2019-01-06 12:37:48 -05:00
if ( DBA :: isResult ( $user ) && ! in_array ( $user [ 'page-flags' ], [ User :: PAGE_FLAGS_SOAPBOX , User :: PAGE_FLAGS_FREELOVE , User :: PAGE_FLAGS_COMMUNITY ])) {
2018-01-28 06:18:08 -05:00
// create notification
2018-11-08 08:45:46 -05:00
$hash = Strings :: getRandomHex ();
2018-01-28 06:18:08 -05:00
if ( is_array ( $contact_record )) {
2018-07-20 08:19:26 -04:00
DBA :: insert ( 'intro' , [ 'uid' => $importer [ 'uid' ], 'contact-id' => $contact_record [ 'id' ],
2018-01-28 06:18:08 -05:00
'blocked' => false , 'knowyou' => false ,
2018-02-03 20:44:19 -05:00
'hash' => $hash , 'datetime' => DateTimeFormat :: utcNow ()]);
2018-01-28 06:18:08 -05:00
}
Group :: addMember ( User :: getDefaultGroup ( $importer [ 'uid' ], $contact_record [ " network " ]), $contact_record [ 'id' ]);
2018-02-14 00:05:00 -05:00
if (( $user [ 'notify-flags' ] & NOTIFY_INTRO ) &&
2019-01-06 12:37:48 -05:00
in_array ( $user [ 'page-flags' ], [ User :: PAGE_FLAGS_NORMAL ])) {
2018-01-28 06:18:08 -05:00
notification ([
'type' => NOTIFY_INTRO ,
2018-02-14 00:05:00 -05:00
'notify_flags' => $user [ 'notify-flags' ],
'language' => $user [ 'language' ],
'to_name' => $user [ 'username' ],
'to_email' => $user [ 'email' ],
'uid' => $user [ 'uid' ],
2018-07-27 19:25:57 -04:00
'link' => System :: baseUrl () . '/notifications/intro' ,
2018-01-28 06:18:08 -05:00
'source_name' => (( strlen ( stripslashes ( $contact_record [ 'name' ]))) ? stripslashes ( $contact_record [ 'name' ]) : L10n :: t ( '[Name Withheld]' )),
'source_link' => $contact_record [ 'url' ],
'source_photo' => $contact_record [ 'photo' ],
'verb' => ( $sharing ? ACTIVITY_FRIEND : ACTIVITY_FOLLOW ),
'otype' => 'intro'
]);
}
2019-01-06 12:37:48 -05:00
} elseif ( DBA :: isResult ( $user ) && in_array ( $user [ 'page-flags' ], [ User :: PAGE_FLAGS_SOAPBOX , User :: PAGE_FLAGS_FREELOVE , User :: PAGE_FLAGS_COMMUNITY ])) {
2018-08-19 08:46:11 -04:00
$condition = [ 'uid' => $importer [ 'uid' ], 'url' => $url , 'pending' => true ];
DBA :: update ( 'contact' , [ 'pending' => false ], $condition );
2018-10-05 02:35:50 -04:00
$contact = DBA :: selectFirst ( 'contact' , [ 'url' , 'network' , 'hub-verify' ], [ 'id' => $contact_record [ 'id' ]]);
if ( $contact [ 'network' ] == Protocol :: ACTIVITYPUB ) {
ActivityPub\Transmitter :: sendContactAccept ( $contact [ 'url' ], $contact [ 'hub-verify' ], $importer [ 'uid' ]);
}
2018-01-28 06:18:08 -05:00
}
}
}
2018-07-24 22:53:46 -04:00
public static function removeFollower ( $importer , $contact , array $datarray = [], $item = " " )
{
if (( $contact [ 'rel' ] == self :: FRIEND ) || ( $contact [ 'rel' ] == self :: SHARING )) {
DBA :: update ( 'contact' , [ 'rel' => self :: SHARING ], [ 'id' => $contact [ 'id' ]]);
2018-01-28 06:18:08 -05:00
} else {
Contact :: remove ( $contact [ 'id' ]);
}
}
2018-07-24 22:53:46 -04:00
public static function removeSharer ( $importer , $contact , array $datarray = [], $item = " " )
{
if (( $contact [ 'rel' ] == self :: FRIEND ) || ( $contact [ 'rel' ] == self :: FOLLOWER )) {
DBA :: update ( 'contact' , [ 'rel' => self :: FOLLOWER ], [ 'id' => $contact [ 'id' ]]);
2018-01-28 06:18:08 -05:00
} else {
Contact :: remove ( $contact [ 'id' ]);
}
}
2018-01-24 20:47:33 -05:00
/**
* @ brief Create a birthday event .
*
* Update the year and the birthday .
*/
public static function updateBirthdays ()
{
2018-11-22 00:15:44 -05:00
$condition = [
' `bd` != " "
AND `bd` > " 0001-01-01 "
AND SUBSTRING ( `bd` , 1 , 4 ) != `bdyear`
AND ( `contact` . `rel` = ? OR `contact` . `rel` = ? )
AND NOT `contact` . `pending`
AND NOT `contact` . `hidden`
AND NOT `contact` . `blocked`
AND NOT `contact` . `archive`
AND NOT `contact` . `deleted` ' ,
Contact :: SHARING ,
Contact :: FRIEND
];
$contacts = DBA :: select ( 'contact' , [ 'id' , 'uid' , 'name' , 'url' , 'bd' ], $condition );
while ( $contact = DBA :: fetch ( $contacts )) {
Logger :: log ( 'update_contact_birthday: ' . $contact [ 'bd' ]);
$nextbd = DateTimeFormat :: utcNow ( 'Y' ) . substr ( $contact [ 'bd' ], 4 );
if ( Event :: createBirthday ( $contact , $nextbd )) {
2018-01-24 20:47:33 -05:00
// update bdyear
2018-11-22 00:15:44 -05:00
DBA :: update (
'contact' ,
[ 'bdyear' => substr ( $nextbd , 0 , 4 ), 'bd' => $nextbd ],
[ 'id' => $contact [ 'id' ]]
2018-01-24 20:47:33 -05:00
);
}
}
}
2018-02-25 19:45:04 -05:00
/**
* Remove the unavailable contact ids from the provided list
*
* @ param array $contact_ids Contact id list
2019-01-06 16:06:53 -05:00
* @ throws \Exception
2018-02-25 19:45:04 -05:00
*/
public static function pruneUnavailable ( array & $contact_ids )
{
if ( empty ( $contact_ids )) {
return ;
}
2018-07-21 09:10:13 -04:00
$str = DBA :: escape ( implode ( ',' , $contact_ids ));
2018-02-25 19:45:04 -05:00
2018-07-20 08:19:26 -04:00
$stmt = DBA :: p ( " SELECT `id` FROM `contact` WHERE `id` IN ( " . $str . " ) AND `blocked` = 0 AND `pending` = 0 AND `archive` = 0 " );
2018-02-25 19:45:04 -05:00
$return = [];
2018-07-20 08:19:26 -04:00
while ( $contact = DBA :: fetch ( $stmt )) {
2018-02-25 19:45:04 -05:00
$return [] = $contact [ 'id' ];
}
2018-07-20 08:19:26 -04:00
DBA :: close ( $stmt );
2018-03-03 07:41:49 -05:00
2018-02-25 19:45:04 -05:00
$contact_ids = $return ;
}
2018-06-01 02:46:34 -04:00
/**
* @ brief Returns a magic link to authenticate remote visitors
*
2019-01-06 16:06:53 -05:00
* @ todo check if the return is either a fully qualified URL or a relative path to Friendica basedir
2018-10-19 19:00:01 -04:00
*
2018-06-01 02:46:34 -04:00
* @ param string $contact_url The address of the target contact profile
2019-01-06 16:06:53 -05:00
* @ param string $url An url that we will be redirected to after the authentication
2018-06-01 02:46:34 -04:00
*
* @ return string with " redir " link
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2018-06-01 02:46:34 -04:00
*/
public static function magicLink ( $contact_url , $url = '' )
{
2019-01-18 11:50:21 -05:00
if ( ! local_user () && ! remote_user ()) {
2018-12-08 15:28:01 -05:00
return $url ? : $contact_url ; // Equivalent to: ($url != '') ? $url : $contact_url;
}
2018-06-02 04:05:06 -04:00
$cid = self :: getIdForURL ( $contact_url , 0 , true );
2018-06-01 02:46:34 -04:00
if ( empty ( $cid )) {
2018-06-02 09:00:47 -04:00
return $url ? : $contact_url ; // Equivalent to: ($url != '') ? $url : $contact_url;
2018-06-01 02:46:34 -04:00
}
return self :: magicLinkbyId ( $cid , $url );
}
/**
* @ brief Returns a magic link to authenticate remote visitors
*
* @ param integer $cid The contact id of the target contact profile
2019-01-06 16:06:53 -05:00
* @ param string $url An url that we will be redirected to after the authentication
2018-06-01 02:46:34 -04:00
*
* @ return string with " redir " link
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2018-06-01 02:46:34 -04:00
*/
public static function magicLinkbyId ( $cid , $url = '' )
{
2018-07-20 08:19:26 -04:00
$contact = DBA :: selectFirst ( 'contact' , [ 'id' , 'network' , 'url' , 'uid' ], [ 'id' => $cid ]);
2018-06-01 02:46:34 -04:00
2019-02-21 21:29:22 -05:00
return self :: magicLinkByContact ( $contact , $url );
2019-01-02 11:47:53 -05:00
}
2018-07-02 01:41:55 -04:00
/**
* @ brief Returns a magic link to authenticate remote visitors
*
2019-01-06 16:06:53 -05:00
* @ param array $contact The contact array with " uid " , " network " and " url "
* @ param string $url An url that we will be redirected to after the authentication
2018-07-02 01:41:55 -04:00
*
* @ return string with " redir " link
2019-01-06 16:06:53 -05:00
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
* @ throws \ImagickException
2018-07-02 01:41:55 -04:00
*/
2019-02-21 21:29:22 -05:00
public static function magicLinkByContact ( $contact , $url = '' )
2018-07-02 01:41:55 -04:00
{
2019-01-02 11:47:53 -05:00
if (( ! local_user () && ! remote_user ()) || ( $contact [ 'network' ] != Protocol :: DFRN )) {
2018-06-02 09:00:47 -04:00
return $url ? : $contact [ 'url' ]; // Equivalent to ($url != '') ? $url : $contact['url'];
2018-06-01 02:46:34 -04:00
}
2018-06-02 04:42:46 -04:00
// Only redirections to the same host do make sense
if (( $url != '' ) && ( parse_url ( $url , PHP_URL_HOST ) != parse_url ( $contact [ 'url' ], PHP_URL_HOST ))) {
return $url ;
}
2018-06-02 04:05:06 -04:00
if ( $contact [ 'uid' ] != 0 ) {
return self :: magicLink ( $contact [ 'url' ], $url );
}
2018-07-02 01:41:55 -04:00
$redirect = 'redir/' . $contact [ 'id' ];
2018-06-01 02:46:34 -04:00
if ( $url != '' ) {
$redirect .= '?url=' . $url ;
}
return $redirect ;
2018-07-27 19:25:57 -04:00
}
2019-02-23 15:26:06 -05:00
2019-03-14 14:44:41 -04:00
/**
* Remove a contact from all groups
*
* @ param integer $contact_id
*
* @ return boolean Success
*/
2019-02-23 15:26:06 -05:00
public static function removeFromGroups ( $contact_id )
{
return DBA :: delete ( 'group_member' , [ 'contact-id' => $contact_id ]);
}
2019-03-14 14:44:41 -04:00
/**
* Is the contact a forum ?
*
* @ param integer $contactid ID of the contact
*
* @ return boolean " true " if it is a forum
*/
public static function isForum ( $contactid )
{
$fields = [ 'forum' , 'prv' ];
$condition = [ 'id' => $contactid ];
$contact = DBA :: selectFirst ( 'contact' , $fields , $condition );
if ( ! DBA :: isResult ( $contact )) {
return false ;
}
// Is it a forum?
return ( $contact [ 'forum' ] || $contact [ 'prv' ]);
}
2017-11-19 16:55:28 -05:00
}