2017-11-19 21:55:28 +00:00
< ? php
/**
2022-01-02 07:27:47 +00:00
* @ copyright Copyright ( C ) 2010 - 2022 , the Friendica project
2020-02-09 14:45:36 +00:00
*
* @ license GNU AGPL version 3 or any later version
*
* This program is free software : you can redistribute it and / or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation , either version 3 of the
* License , or ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU Affero General Public License for more details .
*
* You should have received a copy of the GNU Affero General Public License
* along with this program . If not , see < https :// www . gnu . org / licenses />.
*
2017-11-19 21:55:28 +00:00
*/
2020-02-09 14:45:36 +00:00
2017-12-07 14:04:24 +00:00
namespace Friendica\Model ;
2017-11-19 21:55:28 +00:00
2022-05-09 06:27:46 +00:00
use Friendica\Contact\Avatar ;
2021-10-18 20:49:25 +00:00
use Friendica\Contact\Introduction\Exception\IntroductionNotFoundException ;
2018-10-24 06:15:24 +00:00
use Friendica\Content\Pager ;
2020-09-29 20:47:19 +00:00
use Friendica\Content\Text\HTML ;
2018-11-10 13:18:16 +00:00
use Friendica\Core\Hook ;
2018-10-29 21:20:46 +00:00
use Friendica\Core\Logger ;
2018-08-11 20:40:44 +00:00
use Friendica\Core\Protocol ;
2020-09-29 20:47:19 +00:00
use Friendica\Core\Renderer ;
2019-10-24 07:06:22 +00:00
use Friendica\Core\System ;
2017-11-19 21:55:28 +00:00
use Friendica\Core\Worker ;
2020-11-19 19:34:48 +00:00
use Friendica\Database\Database ;
2018-07-20 12:19:26 +00:00
use Friendica\Database\DBA ;
2019-12-15 21:34:11 +00:00
use Friendica\DI ;
2020-03-09 15:11:06 +00:00
use Friendica\Network\HTTPException ;
2018-01-25 01:47:33 +00:00
use Friendica\Network\Probe ;
2019-10-23 22:25:43 +00:00
use Friendica\Protocol\Activity ;
2022-04-07 21:52:25 +00:00
use Friendica\Protocol\ActivityPub ;
2018-01-27 02:38:34 +00:00
use Friendica\Util\DateTimeFormat ;
2019-10-18 01:26:15 +00:00
use Friendica\Util\Images ;
2018-01-27 04:51:41 +00:00
use Friendica\Util\Network ;
2020-07-28 12:58:19 +00:00
use Friendica\Util\Proxy ;
2018-11-08 13:45:46 +00:00
use Friendica\Util\Strings ;
2017-11-19 21:55:28 +00:00
2017-11-22 14:02:55 +00:00
/**
2020-01-19 06:05:23 +00:00
* functions for interacting with a contact
2017-11-22 14:02:55 +00:00
*/
2019-12-15 22:28:01 +00:00
class Contact
2017-11-19 21:55:28 +00:00
{
2020-08-18 20:30:24 +00:00
const DEFAULT_AVATAR_PHOTO = '/images/person-300.jpg' ;
const DEFAULT_AVATAR_THUMB = '/images/person-80.jpg' ;
const DEFAULT_AVATAR_MICRO = '/images/person-48.jpg' ;
2018-07-27 23:25:57 +00:00
/**
* @ }
*/
2020-10-30 17:26:12 +00:00
const LOCK_INSERT = 'contact-insert' ;
2018-07-27 23:25:57 +00:00
/**
2019-01-12 19:52:36 +00:00
* Account types
2018-07-27 23:25:57 +00:00
*
2020-08-01 16:15:18 +00:00
* TYPE_UNKNOWN - unknown type
2019-01-06 22:08:35 +00:00
*
* TYPE_PERSON - the account belongs to a person
2018-07-27 23:25:57 +00:00
* Associated page types : PAGE_NORMAL , PAGE_SOAPBOX , PAGE_FREELOVE
*
2019-01-06 22:08:35 +00:00
* TYPE_ORGANISATION - the account belongs to an organisation
2018-07-27 23:25:57 +00:00
* Associated page type : PAGE_SOAPBOX
*
2019-01-06 22:08:35 +00:00
* TYPE_NEWS - the account is a news reflector
2018-07-27 23:25:57 +00:00
* Associated page type : PAGE_SOAPBOX
*
2019-01-06 22:08:35 +00:00
* TYPE_COMMUNITY - the account is community forum
2018-07-27 23:25:57 +00:00
* Associated page types : PAGE_COMMUNITY , PAGE_PRVGROUP
*
2019-01-06 22:08:35 +00:00
* TYPE_RELAY - the account is a relay
2018-07-27 23:25:57 +00:00
* This will only be assigned to contacts , not to user accounts
* @ {
*/
2019-01-06 22:08:35 +00: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 23:25:57 +00:00
/**
* @ }
*/
2018-07-25 02:53:46 +00:00
/**
2019-01-06 21:06:53 +00:00
* Contact_is
2018-07-25 02:53:46 +00:00
*
* Relationship types
* @ {
*/
2020-09-29 05:06:37 +00:00
const NOTHING = 0 ;
2018-07-25 02:53:46 +00:00
const FOLLOWER = 1 ;
const SHARING = 2 ;
const FRIEND = 3 ;
2021-09-12 19:04:27 +00:00
const SELF = 4 ;
2018-07-25 02:53:46 +00:00
/**
* @ }
*/
2020-11-28 22:53:58 +00:00
const MIRROR_DEACTIVATED = 0 ;
const MIRROR_FORWARDED = 1 ;
const MIRROR_OWN_POST = 2 ;
const MIRROR_NATIVE_RESHARE = 3 ;
/**
2019-04-28 02:21:02 +00:00
* @ param array $fields Array of selected fields , empty for all
* @ param array $condition Array of fields for condition
* @ param array $params Array of several parameters
* @ return array
* @ throws \Exception
*/
2022-06-16 18:17:04 +00:00
public static function selectToArray ( array $fields = [], array $condition = [], array $params = []) : array
2019-04-28 02:21:02 +00:00
{
2019-07-27 15:57:23 +00:00
return DBA :: selectToArray ( 'contact' , $fields , $condition , $params );
2019-04-28 02:21:02 +00:00
}
2019-06-11 01:33:25 +00:00
/**
* @ param array $fields Array of selected fields , empty for all
* @ param array $condition Array of fields for condition
* @ param array $params Array of several parameters
2022-06-16 18:42:40 +00:00
* @ return array | bool
2019-06-11 01:33:25 +00:00
* @ throws \Exception
*/
2022-06-16 18:42:40 +00:00
public static function selectFirst ( array $fields = [], array $condition = [], array $params = [])
2019-06-11 01:33:25 +00:00
{
$contact = DBA :: selectFirst ( 'contact' , $fields , $condition , $params );
return $contact ;
}
2022-10-09 21:16:36 +00:00
/**
* @ param array $fields Array of selected fields , empty for all
* @ param array $condition Array of fields for condition
* @ param array $params Array of several parameters
* @ return array | bool
* @ throws \Exception
*/
public static function selectFirstAccount ( array $fields = [], array $condition = [], array $params = [])
{
return DBA :: selectFirst ( 'account-view' , $fields , $condition , $params );
}
2019-08-28 20:27:48 +00:00
/**
2019-08-29 04:07:07 +00:00
* Insert a row into the contact table
* Important : You can ' t use DBA :: lastInsertId () after this call since it will be set to 0.
2019-08-28 20:27:48 +00:00
*
2020-11-19 19:34:48 +00:00
* @ param array $fields field array
* @ param int $duplicate_mode Do an update on a duplicate entry
2019-08-28 20:27:48 +00:00
*
2021-09-10 13:05:16 +00:00
* @ return int id of the created contact
2019-08-28 20:27:48 +00:00
* @ throws \Exception
*/
2022-06-16 18:17:04 +00:00
public static function insert ( array $fields , int $duplicate_mode = Database :: INSERT_DEFAULT ) : int
2019-08-28 20:27:48 +00:00
{
2020-11-15 23:28:05 +00:00
if ( ! empty ( $fields [ 'baseurl' ]) && empty ( $fields [ 'gsid' ])) {
$fields [ 'gsid' ] = GServer :: getID ( $fields [ 'baseurl' ], true );
}
2021-07-09 07:09:33 +00:00
$fields [ 'uri-id' ] = ItemURI :: getIdByURI ( $fields [ 'url' ]);
2021-07-08 18:59:58 +00:00
2020-11-15 23:28:05 +00:00
if ( empty ( $fields [ 'created' ])) {
$fields [ 'created' ] = DateTimeFormat :: utcNow ();
}
2022-08-25 18:47:07 +00:00
$fields = DI :: dbaDefinition () -> truncateFieldsForTable ( 'contact' , $fields );
2021-09-10 13:05:16 +00:00
DBA :: insert ( 'contact' , $fields , $duplicate_mode );
$contact = DBA :: selectFirst ( 'contact' , [], [ 'id' => DBA :: lastInsertId ()]);
2019-08-28 20:27:48 +00:00
if ( ! DBA :: isResult ( $contact )) {
// Shouldn't happen
2021-09-10 13:05:16 +00:00
Logger :: warning ( 'Created contact could not be found' , [ 'fields' => $fields ]);
return 0 ;
2019-08-28 20:27:48 +00:00
}
2022-09-16 05:00:06 +00:00
$fields = DI :: dbaDefinition () -> truncateFieldsForTable ( 'account-user' , $contact );
DBA :: insert ( 'account-user' , $fields , Database :: INSERT_IGNORE );
$account_user = DBA :: selectFirst ( 'account-user' , [ 'id' ], [ 'uid' => $contact [ 'uid' ], 'uri-id' => $contact [ 'uri-id' ]]);
if ( empty ( $account_user [ 'id' ])) {
Logger :: warning ( 'Account-user entry not found' , [ 'cid' => $contact [ 'id' ], 'uid' => $contact [ 'uid' ], 'uri-id' => $contact [ 'uri-id' ], 'url' => $contact [ 'url' ]]);
} elseif ( $account_user [ 'id' ] != $contact [ 'id' ]) {
$duplicate = DBA :: selectFirst ( 'contact' , [], [ 'id' => $account_user [ 'id' ], 'deleted' => false ]);
if ( ! empty ( $duplicate [ 'id' ])) {
$ret = Contact :: deleteById ( $contact [ 'id' ]);
Logger :: notice ( 'Deleted duplicated contact' , [ 'ret' => $ret , 'account-user' => $account_user , 'cid' => $duplicate [ 'id' ], 'uid' => $duplicate [ 'uid' ], 'uri-id' => $duplicate [ 'uri-id' ], 'url' => $duplicate [ 'url' ]]);
$contact = $duplicate ;
} else {
$ret = DBA :: update ( 'account-user' , [ 'id' => $contact [ 'id' ]], [ 'uid' => $contact [ 'uid' ], 'uri-id' => $contact [ 'uri-id' ]]);
Logger :: notice ( 'Updated account-user' , [ 'ret' => $ret , 'account-user' => $account_user , 'cid' => $contact [ 'id' ], 'uid' => $contact [ 'uid' ], 'uri-id' => $contact [ 'uri-id' ], 'url' => $contact [ 'url' ]]);
}
2021-09-10 13:05:16 +00:00
}
2019-08-28 20:27:48 +00:00
2022-09-16 05:00:06 +00:00
Contact\User :: insertForContactArray ( $contact );
2021-09-10 13:05:16 +00:00
return $contact [ 'id' ];
2019-08-28 20:27:48 +00:00
}
2022-09-16 05:00:06 +00:00
/**
* Delete contact by id
*
* @ param integer $id
* @ return boolean
*/
public static function deleteById ( int $id ) : bool
{
Logger :: debug ( 'Delete contact' , [ 'id' => $id ]);
DBA :: delete ( 'account-user' , [ 'id' => $id ]);
return DBA :: delete ( 'contact' , [ 'id' => $id ]);
}
2021-09-10 18:21:19 +00:00
/**
* Updates rows in the contact table
*
* @ param array $fields contains the fields that are updated
* @ param array $condition condition array with the key values
* @ param array | boolean $old_fields array with the old field values that are about to be replaced ( true = update on duplicate , false = don ' t update identical fields )
*
* @ return boolean was the update successfull ?
* @ throws \Exception
2022-06-16 18:17:04 +00:00
* @ todo Let ' s get rid of boolean type of $old_fields
2021-09-10 18:21:19 +00:00
*/
public static function update ( array $fields , array $condition , $old_fields = [])
{
2022-08-25 18:47:07 +00:00
$fields = DI :: dbaDefinition () -> truncateFieldsForTable ( 'contact' , $fields );
2021-09-10 18:21:19 +00:00
$ret = DBA :: update ( 'contact' , $fields , $condition , $old_fields );
2021-09-10 20:22:24 +00:00
// Apply changes to the "user-contact" table on dedicated fields
2021-09-10 23:59:33 +00:00
Contact\User :: updateByContactUpdate ( $fields , $condition );
2019-08-28 20:27:48 +00:00
return $ret ;
}
2019-03-01 09:50:31 +00:00
/**
2019-05-06 18:46:30 +00:00
* @ param integer $id Contact ID
* @ param array $fields Array of selected fields , empty for all
2019-03-01 09:50:31 +00:00
* @ return array | boolean Contact record if it exists , false otherwise
* @ throws \Exception
*/
2022-06-16 18:17:04 +00:00
public static function getById ( int $id , array $fields = [])
2019-03-01 09:50:31 +00:00
{
2019-05-06 18:46:30 +00:00
return DBA :: selectFirst ( 'contact' , $fields , [ 'id' => $id ]);
2019-03-01 09:50:31 +00:00
}
2021-12-30 22:11:52 +00:00
/**
* Fetch the first contact with the provided uri - id .
*
* @ param integer $uri_id uri - id of the contact
* @ param array $fields Array of selected fields , empty for all
* @ return array | boolean Contact record if it exists , false otherwise
* @ throws \Exception
*/
2022-06-16 18:17:04 +00:00
public static function getByUriId ( int $uri_id , array $fields = [])
2021-12-30 22:11:52 +00:00
{
return DBA :: selectFirst ( 'contact' , $fields , [ 'uri-id' => $uri_id ], [ 'order' => [ 'uid' ]]);
}
2022-10-18 20:20:04 +00:00
/**
* Fetch all remote contacts for a given contact url
*
* @ param string $url The URL of the contact
* @ param array $fields The wanted fields
*
* @ return array all remote contacts
*
* @ throws \Exception
*/
public static function getVisitorByUrl ( string $url , array $fields = [ 'id' , 'uid' ]) : array
{
$remote = [];
$remote_contacts = DBA :: select ( 'contact' , [ 'id' , 'uid' ], [ 'nurl' => Strings :: normaliseLink ( $url ), 'rel' => [ Contact :: FOLLOWER , Contact :: FRIEND ], 'self' => false ]);
while ( $contact = DBA :: fetch ( $remote_contacts )) {
if (( $contact [ 'uid' ] == 0 ) || Contact\User :: isBlocked ( $contact [ 'id' ], $contact [ 'uid' ])) {
continue ;
}
$remote [ $contact [ 'uid' ]] = $contact [ 'id' ];
}
DBA :: close ( $remote_contacts );
return $remote ;
}
2020-06-26 05:28:25 +00:00
/**
* Fetches a contact by a given url
*
* @ param string $url profile url
* @ param boolean $update true = always update , false = never update , null = update when not found or outdated
2020-07-15 21:08:42 +00:00
* @ param array $fields Field list
* @ param integer $uid User ID of the contact
2020-06-26 05:28:25 +00:00
* @ return array contact array
*/
2022-06-16 18:17:04 +00:00
public static function getByURL ( string $url , $update = null , array $fields = [], int $uid = 0 ) : array
2020-06-26 05:28:25 +00:00
{
if ( $update || is_null ( $update )) {
2020-07-15 21:08:42 +00:00
$cid = self :: getIdForURL ( $url , $uid , $update );
2020-06-26 05:28:25 +00:00
if ( empty ( $cid )) {
return [];
}
2020-07-29 19:48:26 +00:00
$contact = self :: getById ( $cid , $fields );
if ( empty ( $contact )) {
return [];
}
return $contact ;
2020-06-26 05:28:25 +00:00
}
2020-07-15 21:08:42 +00:00
// Add internal fields
$removal = [];
2020-07-16 03:52:18 +00:00
if ( ! empty ( $fields )) {
2022-09-18 13:40:44 +00:00
foreach ([ 'id' , 'next-update' , 'network' ] as $internal ) {
2020-07-16 03:52:18 +00:00
if ( ! in_array ( $internal , $fields )) {
$fields [] = $internal ;
$removal [] = $internal ;
}
}
2020-07-15 21:08:42 +00:00
}
2020-06-26 05:28:25 +00:00
// We first try the nurl (http://server.tld/nick), most common case
$options = [ 'order' => [ 'id' ]];
$contact = DBA :: selectFirst ( 'contact' , $fields , [ 'nurl' => Strings :: normaliseLink ( $url ), 'uid' => $uid , 'deleted' => false ], $options );
// Then the addr (nick@server.tld)
if ( ! DBA :: isResult ( $contact )) {
$contact = DBA :: selectFirst ( 'contact' , $fields , [ 'addr' => str_replace ( 'acct:' , '' , $url ), 'uid' => $uid , 'deleted' => false ], $options );
}
// Then the alias (which could be anything)
if ( ! DBA :: isResult ( $contact )) {
// The link could be provided as http although we stored it as https
$ssl_url = str_replace ( 'http://' , 'https://' , $url );
$condition = [ '`alias` IN (?, ?, ?) AND `uid` = ? AND NOT `deleted`' , $url , Strings :: normaliseLink ( $url ), $ssl_url , $uid ];
$contact = DBA :: selectFirst ( 'contact' , $fields , $condition , $options );
}
2021-05-09 11:54:34 +00:00
2020-07-29 19:48:26 +00:00
if ( ! DBA :: isResult ( $contact )) {
return [];
}
2020-07-15 21:08:42 +00:00
// Update the contact in the background if needed
2022-09-18 13:40:44 +00:00
if ( Probe :: isProbable ( $contact [ 'network' ]) && ( $contact [ 'next-update' ] < DateTimeFormat :: utcNow ())) {
2022-10-17 05:49:55 +00:00
Worker :: add ([ 'priority' => Worker :: PRIORITY_LOW , 'dont_fork' => true ], 'UpdateContact' , $contact [ 'id' ]);
2020-07-15 21:08:42 +00:00
}
// Remove the internal fields
foreach ( $removal as $internal ) {
unset ( $contact [ $internal ]);
}
2020-06-26 05:28:25 +00:00
return $contact ;
}
2020-07-15 04:42:04 +00:00
/**
* Fetches a contact for a given user by a given url .
* In difference to " getByURL " the function will fetch a public contact when no user contact had been found .
*
* @ param string $url profile url
* @ param integer $uid User ID of the contact
* @ param boolean $update true = always update , false = never update , null = update when not found or outdated
2020-07-15 21:08:42 +00:00
* @ param array $fields Field list
2020-07-15 04:42:04 +00:00
* @ return array contact array
*/
2022-06-16 18:17:04 +00:00
public static function getByURLForUser ( string $url , int $uid = 0 , $update = false , array $fields = []) : array
2020-07-15 04:42:04 +00:00
{
if ( $uid != 0 ) {
2020-07-15 17:06:48 +00:00
$contact = self :: getByURL ( $url , $update , $fields , $uid );
2020-07-15 04:42:04 +00:00
if ( ! empty ( $contact )) {
if ( ! empty ( $contact [ 'id' ])) {
$contact [ 'cid' ] = $contact [ 'id' ];
$contact [ 'zid' ] = 0 ;
}
return $contact ;
}
}
2020-07-15 17:06:48 +00:00
$contact = self :: getByURL ( $url , $update , $fields );
2021-05-09 11:54:34 +00:00
if ( ! empty ( $contact [ 'id' ])) {
2020-07-15 04:42:04 +00:00
$contact [ 'cid' ] = 0 ;
$contact [ 'zid' ] = $contact [ 'id' ];
}
return $contact ;
}
2022-10-09 21:16:36 +00:00
/**
* Checks if a contact uses a specific platform
*
* @ param string $url
* @ param string $platform
* @ return boolean
*/
public static function isPlatform ( string $url , string $platform ) : bool
{
return DBA :: exists ( 'account-view' , [ 'nurl' => Strings :: normaliseLink ( $url ), 'platform' => $platform ]);
}
2018-12-08 20:28:01 +00:00
/**
2020-01-19 06:05:23 +00:00
* Tests if the given contact is a follower
2018-12-08 20:28:01 +00:00
*
2022-08-18 07:48:39 +00:00
* @ param int $cid Either public contact id or user ' s contact id
* @ param int $uid User ID
* @ param bool $strict If " true " then contact mustn ' t be set to pending or readonly
2018-12-08 20:28:01 +00:00
*
* @ return boolean is the contact id a follower ?
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-01-06 21:06:53 +00:00
* @ throws \ImagickException
2018-12-08 20:28:01 +00:00
*/
2022-08-18 07:48:39 +00:00
public static function isFollower ( int $cid , int $uid , bool $strict = false ) : bool
2018-12-08 20:28:01 +00:00
{
2020-08-04 04:47:02 +00:00
if ( Contact\User :: isBlocked ( $cid , $uid )) {
2018-12-08 20:28:01 +00:00
return false ;
}
2021-07-11 09:39:34 +00:00
$cdata = self :: getPublicAndUserContactID ( $cid , $uid );
2018-12-08 20:28:01 +00:00
if ( empty ( $cdata [ 'user' ])) {
return false ;
}
$condition = [ 'id' => $cdata [ 'user' ], 'rel' => [ self :: FOLLOWER , self :: FRIEND ]];
2022-08-18 07:48:39 +00:00
if ( $strict ) {
$condition = array_merge ( $condition , [ 'pending' => false , 'readonly' => false , 'blocked' => false ]);
}
2018-12-08 20:28:01 +00:00
return DBA :: exists ( 'contact' , $condition );
}
2019-07-17 21:37:13 +00:00
/**
2020-01-19 06:05:23 +00:00
* Tests if the given contact url is a follower
2019-07-17 21:37:13 +00:00
*
2022-08-18 07:48:39 +00:00
* @ param string $url Contact URL
* @ param int $uid User ID
* @ param bool $strict If " true " then contact mustn ' t be set to pending or readonly
2019-07-17 21:37:13 +00:00
*
* @ return boolean is the contact id a follower ?
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-07-17 21:37:13 +00:00
* @ throws \ImagickException
*/
2022-08-18 07:48:39 +00:00
public static function isFollowerByURL ( string $url , int $uid , bool $strict = false ) : bool
2019-07-17 21:37:13 +00:00
{
2020-08-07 13:49:59 +00:00
$cid = self :: getIdForURL ( $url , $uid );
2019-07-17 21:37:13 +00:00
if ( empty ( $cid )) {
return false ;
}
2022-08-18 07:48:39 +00:00
return self :: isFollower ( $cid , $uid , $strict );
2019-07-17 21:37:13 +00:00
}
/**
2022-06-16 18:17:04 +00:00
* Tests if the given user shares with the given contact
2019-07-17 21:37:13 +00:00
*
2022-08-18 07:48:39 +00:00
* @ param int $cid Either public contact id or user ' s contact id
* @ param int $uid User ID
* @ param bool $strict If " true " then contact mustn ' t be set to pending or readonly
2019-07-17 21:37:13 +00:00
*
2022-06-16 18:17:04 +00:00
* @ return boolean is the contact sharing with given user ?
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-07-17 21:37:13 +00:00
* @ throws \ImagickException
*/
2022-08-18 07:48:39 +00:00
public static function isSharing ( int $cid , int $uid , bool $strict = false ) : bool
2019-07-17 21:37:13 +00:00
{
2020-08-04 04:47:02 +00:00
if ( Contact\User :: isBlocked ( $cid , $uid )) {
2019-07-17 21:37:13 +00:00
return false ;
}
2021-07-11 09:39:34 +00:00
$cdata = self :: getPublicAndUserContactID ( $cid , $uid );
2019-07-17 21:37:13 +00:00
if ( empty ( $cdata [ 'user' ])) {
return false ;
}
$condition = [ 'id' => $cdata [ 'user' ], 'rel' => [ self :: SHARING , self :: FRIEND ]];
2022-08-18 07:48:39 +00:00
if ( $strict ) {
$condition = array_merge ( $condition , [ 'pending' => false , 'readonly' => false , 'blocked' => false ]);
}
2019-07-17 21:37:13 +00:00
return DBA :: exists ( 'contact' , $condition );
}
/**
2020-01-19 06:05:23 +00:00
* Tests if the given user follow the given contact url
2019-07-17 21:37:13 +00:00
*
2022-08-18 07:48:39 +00:00
* @ param string $url Contact URL
* @ param int $uid User ID
* @ param bool $strict If " true " then contact mustn ' t be set to pending or readonly
2019-07-17 21:37:13 +00:00
*
* @ return boolean is the contact url being followed ?
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-07-17 21:37:13 +00:00
* @ throws \ImagickException
*/
2022-08-18 07:48:39 +00:00
public static function isSharingByURL ( string $url , int $uid , bool $strict = false ) : bool
2019-07-17 21:37:13 +00:00
{
2020-08-07 13:49:59 +00:00
$cid = self :: getIdForURL ( $url , $uid );
2019-07-17 21:37:13 +00:00
if ( empty ( $cid )) {
return false ;
}
2022-08-18 07:48:39 +00:00
return self :: isSharing ( $cid , $uid , $strict );
2019-07-17 21:37:13 +00:00
}
2018-12-04 07:12:55 +00:00
/**
2020-01-19 06:05:23 +00:00
* Get the basepath for a given contact link
2018-12-04 07:12:55 +00:00
*
* @ param string $url The contact link
2020-01-01 18:57:55 +00:00
* @ param boolean $dont_update Don ' t update the contact
2018-12-04 07:12:55 +00:00
*
* @ return string basepath
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-01-06 21:06:53 +00:00
* @ throws \ImagickException
2018-12-04 07:12:55 +00:00
*/
2022-06-16 18:17:04 +00:00
public static function getBasepath ( string $url , bool $dont_update = false ) : string
2018-12-04 07:12:55 +00:00
{
2020-01-01 17:54:36 +00:00
$contact = DBA :: selectFirst ( 'contact' , [ 'id' , 'baseurl' ], [ 'uid' => 0 , 'nurl' => Strings :: normaliseLink ( $url )]);
if ( ! DBA :: isResult ( $contact )) {
return '' ;
}
2019-07-05 06:41:48 +00:00
if ( ! empty ( $contact [ 'baseurl' ])) {
return $contact [ 'baseurl' ];
2019-09-21 13:17:33 +00:00
} elseif ( $dont_update ) {
return '' ;
2018-12-04 07:12:55 +00:00
}
2020-01-01 17:54:36 +00:00
// Update the existing contact
2020-08-06 18:53:45 +00:00
self :: updateFromProbe ( $contact [ 'id' ]);
2019-07-05 06:41:48 +00:00
2020-01-01 17:54:36 +00:00
// And fetch the result
$contact = DBA :: selectFirst ( 'contact' , [ 'baseurl' ], [ 'id' => $contact [ 'id' ]]);
if ( empty ( $contact [ 'baseurl' ])) {
Logger :: info ( 'No baseurl for contact' , [ 'url' => $url ]);
return '' ;
2019-07-05 06:41:48 +00:00
}
2020-01-01 17:54:36 +00:00
Logger :: info ( 'Found baseurl for contact' , [ 'url' => $url , 'baseurl' => $contact [ 'baseurl' ]]);
return $contact [ 'baseurl' ];
2018-12-04 07:12:55 +00:00
}
2019-09-21 12:39:07 +00:00
/**
2019-09-21 13:19:00 +00:00
* Check if the given contact url is on the same server
2019-09-21 12:39:07 +00:00
*
* @ param string $url The contact link
*
2019-09-21 13:19:00 +00:00
* @ return boolean Is it the same server ?
2019-09-21 12:39:07 +00:00
*/
2022-06-16 18:17:04 +00:00
public static function isLocal ( string $url ) : bool
2019-09-21 12:39:07 +00:00
{
2021-07-19 04:15:57 +00:00
if ( ! parse_url ( $url , PHP_URL_SCHEME )) {
$addr_parts = explode ( '@' , $url );
2021-07-19 12:07:02 +00:00
return ( count ( $addr_parts ) == 2 ) && ( $addr_parts [ 1 ] == DI :: baseUrl () -> getHostname ());
2021-07-19 04:15:57 +00:00
}
2019-12-30 22:00:08 +00:00
return Strings :: compareLink ( self :: getBasepath ( $url , true ), DI :: baseUrl ());
2019-09-21 12:39:07 +00:00
}
2020-01-16 06:43:21 +00:00
/**
* Check if the given contact ID is on the same server
*
* @ param string $url The contact link
* @ return boolean Is it the same server ?
*/
2022-06-16 18:17:04 +00:00
public static function isLocalById ( int $cid ) : bool
2020-01-16 06:43:21 +00:00
{
$contact = DBA :: selectFirst ( 'contact' , [ 'url' , 'baseurl' ], [ 'id' => $cid ]);
if ( ! DBA :: isResult ( $contact )) {
return false ;
}
if ( empty ( $contact [ 'baseurl' ])) {
$baseurl = self :: getBasepath ( $contact [ 'url' ], true );
} else {
$baseurl = $contact [ 'baseurl' ];
}
return Strings :: compareLink ( $baseurl , DI :: baseUrl ());
}
2019-02-10 17:19:10 +00: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
2020-01-19 15:29:55 +00:00
* @ throws \Exception
2019-02-10 17:19:10 +00:00
*/
2022-06-16 18:17:04 +00:00
public static function getPublicIdByUserId ( int $uid )
2019-02-10 17:19:10 +00:00
{
$self = DBA :: selectFirst ( 'contact' , [ 'url' ], [ 'self' => true , 'uid' => $uid ]);
if ( ! DBA :: isResult ( $self )) {
return false ;
}
2020-08-07 13:49:59 +00:00
return self :: getIdForURL ( $self [ 'url' ]);
2019-02-10 17:19:10 +00:00
}
2018-08-25 13:48:00 +00:00
/**
2020-01-19 06:05:23 +00:00
* Returns the contact id for the user and the public contact id for a given contact id
2018-08-25 13:48:00 +00:00
*
* @ 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
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-01-06 21:06:53 +00:00
* @ throws \ImagickException
2018-08-25 13:48:00 +00:00
*/
2022-06-16 18:17:04 +00:00
public static function getPublicAndUserContactID ( int $cid , int $uid ) : array
2021-07-11 09:39:34 +00:00
{
// We have to use the legacy function as long as the post update hasn't finished
if ( DI :: config () -> get ( 'system' , 'post_update_version' ) < 1427 ) {
return self :: legacyGetPublicAndUserContactID ( $cid , $uid );
}
if ( empty ( $uid ) || empty ( $cid )) {
return [];
}
$contact = DBA :: selectFirst ( 'account-user-view' , [ 'id' , 'uid' , 'pid' ], [ 'id' => $cid ]);
if ( ! DBA :: isResult ( $contact ) || ! in_array ( $contact [ 'uid' ], [ 0 , $uid ])) {
return [];
}
$pcid = $contact [ 'pid' ];
if ( $contact [ 'uid' ] == $uid ) {
$ucid = $contact [ 'id' ];
} else {
$contact = DBA :: selectFirst ( 'account-user-view' , [ 'id' , 'uid' ], [ 'pid' => $cid , 'uid' => $uid ]);
if ( DBA :: isResult ( $contact )) {
$ucid = $contact [ 'id' ];
} else {
$ucid = 0 ;
}
}
return [ 'public' => $pcid , 'user' => $ucid ];
}
/**
* Helper function for " getPublicAndUserContactID "
*
* @ 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
* @ throws HTTPException\InternalServerErrorException
* @ throws \ImagickException
*/
2022-06-16 18:17:04 +00:00
private static function legacyGetPublicAndUserContactID ( int $cid , int $uid ) : array
2018-08-25 13:48:00 +00: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 ) {
2020-12-07 06:43:43 +00:00
$pcid = self :: getIdForURL ( $contact [ 'url' ], 0 , false , [ 'url' => $contact [ 'url' ]]);
2018-08-25 13:48:00 +00:00
if ( empty ( $pcid )) {
return [];
}
$ucid = $contact [ 'id' ];
} else {
$pcid = $contact [ 'id' ];
2020-12-07 06:43:43 +00:00
$ucid = self :: getIdForURL ( $contact [ 'url' ], $uid );
2018-08-25 13:48:00 +00:00
}
return [ 'public' => $pcid , 'user' => $ucid ];
}
2019-05-02 20:03:27 +00:00
/**
* Returns contact details for a given contact id in combination with a user id
*
* @ param int $cid A contact ID
* @ param int $uid The User ID
* @ param array $fields The selected fields for the contact
* @ return array The contact details
*
* @ throws \Exception
*/
2022-06-27 09:39:26 +00:00
public static function getContactForUser ( int $cid , int $uid , array $fields = []) : array
2019-05-02 20:03:27 +00:00
{
$contact = DBA :: selectFirst ( 'contact' , $fields , [ 'id' => $cid , 'uid' => $uid ]);
if ( ! DBA :: isResult ( $contact )) {
return [];
} else {
return $contact ;
}
}
2017-12-04 03:27:49 +00:00
/**
* Creates the self - contact for the provided user id
*
* @ param int $uid
* @ return bool Operation success
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2017-12-04 03:27:49 +00:00
*/
2022-06-27 09:39:26 +00:00
public static function createSelfFromUserId ( int $uid ) : bool
2017-12-04 03:27:49 +00:00
{
2021-03-20 09:56:35 +00:00
$user = DBA :: selectFirst ( 'user' , [ 'uid' , 'username' , 'nickname' , 'pubkey' , 'prvkey' ],
[ 'uid' => $uid , 'account_expired' => false ]);
2018-07-21 12:46:04 +00:00
if ( ! DBA :: isResult ( $user )) {
2017-12-04 03:27:49 +00:00
return false ;
}
2021-05-30 12:04:26 +00:00
$contact = [
2017-12-04 03:27:49 +00:00
'uid' => $user [ 'uid' ],
2018-01-27 02:38:34 +00:00
'created' => DateTimeFormat :: utcNow (),
2017-12-04 03:27:49 +00:00
'self' => 1 ,
'name' => $user [ 'username' ],
'nick' => $user [ 'nickname' ],
2020-09-26 20:59:28 +00:00
'pubkey' => $user [ 'pubkey' ],
'prvkey' => $user [ 'prvkey' ],
2021-10-02 21:28:29 +00:00
'photo' => User :: getAvatarUrl ( $user ),
'thumb' => User :: getAvatarUrl ( $user , Proxy :: SIZE_THUMB ),
'micro' => User :: getAvatarUrl ( $user , Proxy :: SIZE_MICRO ),
2017-12-04 03:27:49 +00:00
'blocked' => 0 ,
'pending' => 0 ,
2019-12-30 22:00:08 +00:00
'url' => DI :: baseUrl () . '/profile/' . $user [ 'nickname' ],
'nurl' => Strings :: normaliseLink ( DI :: baseUrl () . '/profile/' . $user [ 'nickname' ]),
'addr' => $user [ 'nickname' ] . '@' . substr ( DI :: baseUrl (), strpos ( DI :: baseUrl (), '://' ) + 3 ),
'request' => DI :: baseUrl () . '/dfrn_request/' . $user [ 'nickname' ],
'notify' => DI :: baseUrl () . '/dfrn_notify/' . $user [ 'nickname' ],
'poll' => DI :: baseUrl () . '/dfrn_poll/' . $user [ 'nickname' ],
'confirm' => DI :: baseUrl () . '/dfrn_confirm/' . $user [ 'nickname' ],
'poco' => DI :: baseUrl () . '/poco/' . $user [ 'nickname' ],
2018-01-27 02:38:34 +00:00
'name-date' => DateTimeFormat :: utcNow (),
'uri-date' => DateTimeFormat :: utcNow (),
'avatar-date' => DateTimeFormat :: utcNow (),
2017-12-04 03:27:49 +00:00
'closeness' => 0
2021-05-30 12:04:26 +00:00
];
$return = true ;
// Only create the entry if it doesn't exist yet
if ( ! DBA :: exists ( 'contact' , [ 'uid' => $uid , 'self' => true ])) {
2021-09-10 13:05:16 +00:00
$return = ( bool ) self :: insert ( $contact );
2021-05-30 12:04:26 +00:00
}
// Create the public contact
if ( ! DBA :: exists ( 'contact' , [ 'nurl' => $contact [ 'nurl' ], 'uid' => 0 ])) {
$contact [ 'self' ] = false ;
$contact [ 'uid' ] = 0 ;
$contact [ 'prvkey' ] = null ;
2021-09-10 13:05:16 +00:00
self :: insert ( $contact , Database :: INSERT_IGNORE );
2021-05-30 12:04:26 +00:00
}
2017-12-04 03:27:49 +00:00
return $return ;
}
2018-03-24 06:15:18 +00:00
/**
* Updates the self - contact for the provided user id
*
2022-06-27 09:39:26 +00:00
* @ param int $uid
* @ param bool $update_avatar Force the avatar update
* @ return bool " true " if updated
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2018-03-24 06:15:18 +00:00
*/
2022-06-27 09:39:26 +00:00
public static function updateSelfFromUserID ( int $uid , bool $update_avatar = false ) : bool
2018-03-24 06:15:18 +00:00
{
2022-05-29 17:48:09 +00:00
$fields = [ 'id' , 'uri-id' , 'name' , 'nick' , 'location' , 'about' , 'keywords' , 'avatar' , 'prvkey' , 'pubkey' , 'manually-approve' ,
2021-08-09 01:39:09 +00:00
'xmpp' , 'matrix' , 'contact-type' , 'forum' , 'prv' , 'avatar-date' , 'url' , 'nurl' , 'unsearchable' ,
2022-01-08 22:43:11 +00:00
'photo' , 'thumb' , 'micro' , 'header' , 'addr' , 'request' , 'notify' , 'poll' , 'confirm' , 'poco' , 'network' ];
2018-07-20 12:19:26 +00:00
$self = DBA :: selectFirst ( 'contact' , $fields , [ 'uid' => $uid , 'self' => true ]);
2018-07-21 12:46:04 +00:00
if ( ! DBA :: isResult ( $self )) {
2021-06-15 11:12:44 +00:00
return false ;
2018-03-24 06:15:18 +00:00
}
2021-10-02 21:28:29 +00:00
$fields = [ 'uid' , 'nickname' , 'page-flags' , 'account-type' , 'prvkey' , 'pubkey' ];
2021-03-20 09:56:35 +00:00
$user = DBA :: selectFirst ( 'user' , $fields , [ 'uid' => $uid , 'account_expired' => false ]);
2018-07-21 12:46:04 +00:00
if ( ! DBA :: isResult ( $user )) {
2021-06-15 11:12:44 +00:00
return false ;
2018-03-24 06:15:18 +00:00
}
2020-02-09 07:36:19 +00:00
$fields = [ 'name' , 'photo' , 'thumb' , 'about' , 'address' , 'locality' , 'region' ,
2021-08-09 01:39:09 +00:00
'country-name' , 'pub_keywords' , 'xmpp' , 'matrix' , 'net-publish' ];
2020-01-23 00:34:15 +00:00
$profile = DBA :: selectFirst ( 'profile' , $fields , [ 'uid' => $uid ]);
2018-07-21 12:46:04 +00:00
if ( ! DBA :: isResult ( $profile )) {
2021-06-15 11:12:44 +00:00
return false ;
2018-03-24 06:15:18 +00:00
}
2019-06-19 17:05:29 +00:00
$file_suffix = 'jpg' ;
2022-07-29 15:19:07 +00:00
$url = DI :: baseUrl () . '/profile/' . $user [ 'nickname' ];
2019-06-19 17:05:29 +00:00
2022-07-29 04:30:29 +00:00
$fields = [
'name' => $profile [ 'name' ],
'nick' => $user [ 'nickname' ],
'avatar-date' => $self [ 'avatar-date' ],
'location' => Profile :: formatLocation ( $profile ),
'about' => $profile [ 'about' ],
'keywords' => $profile [ 'pub_keywords' ],
'contact-type' => $user [ 'account-type' ],
'prvkey' => $user [ 'prvkey' ],
'pubkey' => $user [ 'pubkey' ],
'xmpp' => $profile [ 'xmpp' ],
'matrix' => $profile [ 'matrix' ],
'network' => Protocol :: DFRN ,
2022-07-29 15:19:07 +00:00
'url' => $url ,
// it seems as if ported accounts can have wrong values, so we make sure that now everything is fine.
'nurl' => Strings :: normaliseLink ( $url ),
'uri-id' => ItemURI :: getIdByURI ( $url ),
2022-07-29 04:30:29 +00:00
'addr' => $user [ 'nickname' ] . '@' . substr ( DI :: baseUrl (), strpos ( DI :: baseUrl (), '://' ) + 3 ),
'request' => DI :: baseUrl () . '/dfrn_request/' . $user [ 'nickname' ],
'notify' => DI :: baseUrl () . '/dfrn_notify/' . $user [ 'nickname' ],
'poll' => DI :: baseUrl () . '/dfrn_poll/' . $user [ 'nickname' ],
'confirm' => DI :: baseUrl () . '/dfrn_confirm/' . $user [ 'nickname' ],
'poco' => DI :: baseUrl () . '/poco/' . $user [ 'nickname' ],
];
2018-03-24 06:15:18 +00:00
2020-12-07 06:43:43 +00:00
2018-12-11 19:03:29 +00:00
$avatar = Photo :: selectFirst ([ 'resource-id' , 'type' ], [ 'uid' => $uid , 'profile' => true ]);
2018-07-21 12:46:04 +00:00
if ( DBA :: isResult ( $avatar )) {
2018-03-25 17:26:40 +00:00
if ( $update_avatar ) {
$fields [ 'avatar-date' ] = DateTimeFormat :: utcNow ();
}
2018-03-25 08:15:22 +00:00
2018-03-25 17:26:40 +00:00
// Creating the path to the avatar, beginning with the file suffix
2019-10-18 01:26:15 +00:00
$types = Images :: supportedTypes ();
2018-03-25 17:26:40 +00:00
if ( isset ( $types [ $avatar [ 'type' ]])) {
$file_suffix = $types [ $avatar [ 'type' ]];
}
2018-03-25 08:15:22 +00:00
2018-03-25 17:26:40 +00:00
// We are adding a timestamp value so that other systems won't use cached content
$timestamp = strtotime ( $fields [ 'avatar-date' ]);
2018-03-25 08:15:22 +00:00
2019-12-30 22:00:08 +00:00
$prefix = DI :: baseUrl () . '/photo/' . $avatar [ 'resource-id' ] . '-' ;
2018-03-25 17:26:40 +00:00
$suffix = '.' . $file_suffix . '?ts=' . $timestamp ;
2018-03-25 08:15:22 +00:00
2018-03-25 17:26:40 +00: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
2020-12-07 06:43:43 +00:00
$fields [ 'photo' ] = self :: getDefaultAvatar ( $fields , Proxy :: SIZE_SMALL );
$fields [ 'thumb' ] = self :: getDefaultAvatar ( $fields , Proxy :: SIZE_THUMB );
$fields [ 'micro' ] = self :: getDefaultAvatar ( $fields , Proxy :: SIZE_MICRO );
2018-03-25 17:26:40 +00:00
}
2018-03-24 06:15:18 +00:00
2021-10-02 21:28:29 +00:00
$fields [ 'avatar' ] = User :: getAvatarUrl ( $user );
2022-01-08 22:43:11 +00:00
$fields [ 'header' ] = User :: getBannerUrl ( $user );
2019-01-06 17:37:48 +00:00
$fields [ 'forum' ] = $user [ 'page-flags' ] == User :: PAGE_FLAGS_COMMUNITY ;
$fields [ 'prv' ] = $user [ 'page-flags' ] == User :: PAGE_FLAGS_PRVGROUP ;
2020-02-16 15:39:44 +00:00
$fields [ 'unsearchable' ] = ! $profile [ 'net-publish' ];
2022-02-12 18:38:36 +00:00
$fields [ 'manually-approve' ] = in_array ( $user [ 'page-flags' ], [ User :: PAGE_FLAGS_NORMAL , User :: PAGE_FLAGS_PRVGROUP ]);
2018-03-24 06:15:18 +00:00
$update = false ;
foreach ( $fields as $field => $content ) {
2018-12-22 20:12:32 +00:00
if ( $self [ $field ] != $content ) {
2018-03-24 06:15:18 +00:00
$update = true ;
}
}
if ( $update ) {
2019-04-09 05:15:23 +00:00
if ( $fields [ 'name' ] != $self [ 'name' ]) {
$fields [ 'name-date' ] = DateTimeFormat :: utcNow ();
}
$fields [ 'updated' ] = DateTimeFormat :: utcNow ();
2021-09-10 18:21:19 +00:00
self :: update ( $fields , [ 'id' => $self [ 'id' ]]);
2018-03-25 08:20:13 +00:00
2022-05-29 17:48:09 +00:00
// Update the other contacts as well
unset ( $fields [ 'prvkey' ]);
$fields [ 'self' ] = false ;
self :: update ( $fields , [ 'uri-id' => $self [ 'uri-id' ], 'self' => false ]);
2018-04-14 08:03:15 +00:00
// Update the profile
2021-09-17 18:36:20 +00:00
$fields = [
2021-10-02 21:28:29 +00:00
'photo' => User :: getAvatarUrl ( $user ),
'thumb' => User :: getAvatarUrl ( $user , Proxy :: SIZE_THUMB )
2021-09-17 18:36:20 +00:00
];
2020-01-23 00:34:15 +00:00
DBA :: update ( 'profile' , $fields , [ 'uid' => $uid ]);
2018-03-24 06:15:18 +00:00
}
2021-06-16 05:23:43 +00:00
2021-06-15 11:12:44 +00:00
return $update ;
2018-03-24 06:15:18 +00:00
}
2017-11-19 21:55:28 +00:00
/**
2020-01-19 06:05:23 +00:00
* Marks a contact for removal
2017-11-19 21:55:28 +00:00
*
2017-11-22 14:02:55 +00:00
* @ param int $id contact id
2022-06-27 09:39:26 +00:00
* @ return void
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2017-11-19 21:55:28 +00:00
*/
2022-06-27 09:39:26 +00:00
public static function remove ( int $id )
2017-11-19 21:55:28 +00:00
{
// We want just to make sure that we don't delete our "self" contact
2022-05-17 12:32:25 +00:00
$contact = DBA :: selectFirst ( 'contact' , [ 'uri-id' , 'photo' , 'thumb' , 'micro' , 'uid' ], [ 'id' => $id , 'self' => false ]);
2020-12-15 22:56:46 +00:00
if ( ! DBA :: isResult ( $contact )) {
2017-11-19 21:55:28 +00:00
return ;
}
2022-09-16 05:00:06 +00:00
DBA :: delete ( 'account-user' , [ 'id' => $id ]);
2022-05-17 12:32:25 +00:00
self :: clearFollowerFollowingEndpointCache ( $contact [ 'uid' ]);
2018-08-12 17:15:47 +00:00
// Archive the contact
2021-09-10 18:21:19 +00:00
self :: update ([ 'archive' => true , 'network' => Protocol :: PHANTOM , 'deleted' => true ], [ 'id' => $id ]);
2017-11-19 21:55:28 +00:00
2022-05-08 05:37:17 +00:00
if ( ! DBA :: exists ( 'contact' , [ 'uri-id' => $contact [ 'uri-id' ], 'deleted' => false ])) {
2022-05-09 06:27:46 +00:00
Avatar :: deleteCache ( $contact );
2022-05-08 05:37:17 +00:00
}
2018-08-12 17:15:47 +00:00
// Delete it in the background
2022-10-17 05:49:55 +00:00
Worker :: add ( Worker :: PRIORITY_MEDIUM , 'Contact\Remove' , $id );
2017-11-19 21:55:28 +00:00
}
/**
2021-10-17 01:24:34 +00:00
* Unfollow the remote contact
2017-11-19 21:55:28 +00:00
*
2021-10-17 01:24:34 +00:00
* @ param array $contact Target user - specific contact ( uid != 0 ) array
2022-06-27 09:39:26 +00:00
* @ return void
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-01-06 21:06:53 +00:00
* @ throws \ImagickException
2017-11-19 21:55:28 +00:00
*/
2021-10-17 01:24:34 +00:00
public static function unfollow ( array $contact ) : void
2017-11-19 21:55:28 +00:00
{
2021-10-17 01:24:34 +00:00
if ( empty ( $contact [ 'network' ])) {
throw new \InvalidArgumentException ( 'Empty network in contact array' );
}
2018-09-15 22:25:58 +00:00
2021-10-17 01:24:34 +00:00
if ( empty ( $contact [ 'uid' ])) {
throw new \InvalidArgumentException ( 'Unexpected public contact record' );
2017-11-19 21:55:28 +00:00
}
2021-09-26 14:30:44 +00:00
2021-10-17 01:24:34 +00:00
if ( in_array ( $contact [ 'rel' ], [ self :: SHARING , self :: FRIEND ])) {
2022-05-08 05:37:17 +00:00
$cdata = self :: getPublicAndUserContactID ( $contact [ 'id' ], $contact [ 'uid' ]);
2022-05-01 07:03:10 +00:00
if ( ! empty ( $cdata [ 'public' ])) {
2022-10-17 05:49:55 +00:00
Worker :: add ( Worker :: PRIORITY_HIGH , 'Contact\Unfollow' , $cdata [ 'public' ], $contact [ 'uid' ]);
2022-05-01 07:03:10 +00:00
}
2021-10-17 01:24:34 +00:00
}
self :: removeSharer ( $contact );
2017-11-19 21:55:28 +00:00
}
2021-10-02 15:44:47 +00:00
/**
* Revoke follow privileges of the remote user contact
*
2021-10-17 01:09:49 +00:00
* The local relationship is updated immediately , the eventual remote server is messaged in the background .
*
* @ param array $contact User - specific contact array ( uid != 0 ) to revoke the follow from
2022-06-27 09:39:26 +00:00
* @ return void
2021-10-02 15:44:47 +00:00
* @ throws HTTPException\InternalServerErrorException
* @ throws \ImagickException
*/
2021-10-17 01:09:49 +00:00
public static function revokeFollow ( array $contact ) : void
2021-10-02 15:44:47 +00:00
{
if ( empty ( $contact [ 'network' ])) {
throw new \InvalidArgumentException ( 'Empty network in contact array' );
}
if ( empty ( $contact [ 'uid' ])) {
throw new \InvalidArgumentException ( 'Unexpected public contact record' );
}
2021-10-17 01:09:49 +00:00
if ( in_array ( $contact [ 'rel' ], [ self :: FOLLOWER , self :: FRIEND ])) {
2022-05-08 05:37:17 +00:00
$cdata = self :: getPublicAndUserContactID ( $contact [ 'id' ], $contact [ 'uid' ]);
2022-05-01 07:03:10 +00:00
if ( ! empty ( $cdata [ 'public' ])) {
2022-10-17 05:49:55 +00:00
Worker :: add ( Worker :: PRIORITY_HIGH , 'Contact\RevokeFollow' , $cdata [ 'public' ], $contact [ 'uid' ]);
2022-05-01 07:03:10 +00:00
}
2021-10-02 15:44:47 +00:00
}
2021-10-17 01:09:49 +00:00
self :: removeFollower ( $contact );
2021-10-02 15:44:47 +00:00
}
2021-10-17 01:24:34 +00:00
/**
* Completely severs a relationship with a contact
*
* @ param array $contact User - specific contact ( uid != 0 ) array
2022-06-27 09:39:26 +00:00
* @ return void
2021-10-17 01:24:34 +00:00
* @ throws HTTPException\InternalServerErrorException
* @ throws \ImagickException
*/
public static function terminateFriendship ( array $contact )
{
if ( empty ( $contact [ 'network' ])) {
throw new \InvalidArgumentException ( 'Empty network in contact array' );
}
if ( empty ( $contact [ 'uid' ])) {
throw new \InvalidArgumentException ( 'Unexpected public contact record' );
}
2022-05-08 05:37:17 +00:00
$cdata = self :: getPublicAndUserContactID ( $contact [ 'id' ], $contact [ 'uid' ]);
2021-10-17 01:24:34 +00:00
2022-05-01 07:03:10 +00:00
if ( in_array ( $contact [ 'rel' ], [ self :: SHARING , self :: FRIEND ]) && ! empty ( $cdata [ 'public' ])) {
2022-10-17 05:49:55 +00:00
Worker :: add ( Worker :: PRIORITY_HIGH , 'Contact\Unfollow' , $cdata [ 'public' ], $contact [ 'uid' ]);
2021-10-17 01:24:34 +00:00
}
2022-05-01 07:03:10 +00:00
if ( in_array ( $contact [ 'rel' ], [ self :: FOLLOWER , self :: FRIEND ]) && ! empty ( $cdata [ 'public' ])) {
2022-10-17 05:49:55 +00:00
Worker :: add ( Worker :: PRIORITY_HIGH , 'Contact\RevokeFollow' , $cdata [ 'public' ], $contact [ 'uid' ]);
2021-10-17 01:24:34 +00:00
}
self :: remove ( $contact [ 'id' ]);
}
2022-05-17 12:32:25 +00:00
private static function clearFollowerFollowingEndpointCache ( int $uid )
{
if ( empty ( $uid )) {
return ;
}
DI :: cache () -> delete ( ActivityPub\Transmitter :: CACHEKEY_CONTACTS . 'followers:' . $uid );
DI :: cache () -> delete ( ActivityPub\Transmitter :: CACHEKEY_CONTACTS . 'following:' . $uid );
}
2021-10-02 15:44:47 +00:00
2017-11-19 21:55:28 +00:00
/**
2020-01-19 06:05:23 +00:00
* Marks a contact for archival after a communication issue delay
2017-11-19 21:55:28 +00:00
*
* 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 14:02:55 +00:00
* @ param array $contact contact to mark for archival
2022-06-27 09:39:26 +00:00
* @ return void
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2017-11-19 21:55:28 +00:00
*/
public static function markForArchival ( array $contact )
{
2018-08-21 15:35:09 +00:00
if ( ! isset ( $contact [ 'url' ]) && ! empty ( $contact [ 'id' ])) {
$fields = [ 'id' , 'url' , 'archive' , 'self' , 'term-date' ];
2019-01-07 18:26:54 +00:00
$contact = DBA :: selectFirst ( 'contact' , $fields , [ 'id' => $contact [ 'id' ]]);
2018-08-21 15:35:09 +00:00
if ( ! DBA :: isResult ( $contact )) {
return ;
}
} elseif ( ! isset ( $contact [ 'url' ])) {
2020-06-28 17:35:56 +00:00
Logger :: info ( 'Empty contact' , [ 'contact' => $contact , 'callstack' => System :: callstack ( 20 )]);
2018-08-17 03:19:42 +00:00
}
2020-12-12 16:45:23 +00:00
Logger :: info ( 'Contact is marked for archival' , [ 'id' => $contact [ 'id' ], 'term-date' => $contact [ 'term-date' ]]);
2019-01-16 21:39:56 +00:00
2017-12-05 21:29:33 +00:00
// Contact already archived or "self" contact? => nothing to do
if ( $contact [ 'archive' ] || $contact [ 'self' ]) {
2017-11-19 21:55:28 +00:00
return ;
}
2017-12-04 19:37:36 +00:00
2018-10-21 05:53:47 +00:00
if ( $contact [ 'term-date' ] <= DBA :: NULL_DATETIME ) {
2021-09-10 18:21:19 +00:00
self :: update ([ 'term-date' => DateTimeFormat :: utcNow ()], [ 'id' => $contact [ 'id' ]]);
self :: update ([ 'term-date' => DateTimeFormat :: utcNow ()], [ '`nurl` = ? AND `term-date` <= ? AND NOT `self`' , Strings :: normaliseLink ( $contact [ 'url' ]), DBA :: NULL_DATETIME ]);
2017-11-19 21:55:28 +00: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
2020-01-19 20:21:13 +00:00
$archival_days = DI :: config () -> get ( 'system' , 'archival_days' , 32 );
2018-04-10 11:10:02 +00:00
$expiry = $contact [ 'term-date' ] . ' + ' . $archival_days . ' days ' ;
2018-01-27 02:38:34 +00:00
if ( DateTimeFormat :: utcNow () > DateTimeFormat :: utc ( $expiry )) {
2017-11-19 21:55:28 +00: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 .
*/
2021-09-10 18:21:19 +00:00
self :: update ([ 'archive' => true ], [ 'id' => $contact [ 'id' ]]);
self :: update ([ 'archive' => true ], [ 'nurl' => Strings :: normaliseLink ( $contact [ 'url' ]), 'self' => false ]);
2017-11-19 21:55:28 +00:00
}
}
}
/**
2020-01-19 06:05:23 +00:00
* Cancels the archival countdown
2017-11-19 21:55:28 +00:00
*
2019-01-06 21:06:53 +00:00
* @ see Contact :: markForArchival ()
2017-11-19 21:55:28 +00:00
*
2017-11-22 14:02:55 +00:00
* @ param array $contact contact to be unmarked for archival
2022-06-27 09:39:26 +00:00
* @ return void
2019-01-06 21:06:53 +00:00
* @ throws \Exception
2017-11-19 21:55:28 +00:00
*/
public static function unmarkForArchival ( array $contact )
{
2019-08-29 06:41:55 +00:00
// Always unarchive the relay contact entry
2019-08-31 09:27:19 +00:00
if ( ! empty ( $contact [ 'batch' ]) && ! empty ( $contact [ 'term-date' ]) && ( $contact [ 'term-date' ] > DBA :: NULL_DATETIME )) {
2020-07-19 01:15:57 +00:00
$fields = [ 'failed' => false , 'term-date' => DBA :: NULL_DATETIME , 'archive' => false ];
2019-09-02 13:11:07 +00:00
$condition = [ 'uid' => 0 , 'network' => Protocol :: FEDERATED , 'batch' => $contact [ 'batch' ], 'contact-type' => self :: TYPE_RELAY ];
2021-03-06 16:52:36 +00:00
if ( ! DBA :: exists ( 'contact' , array_merge ( $condition , $fields ))) {
2021-09-10 18:21:19 +00:00
self :: update ( $fields , $condition );
2021-03-06 16:52:36 +00:00
}
2019-08-29 06:41:55 +00:00
}
2018-10-21 05:53:47 +00:00
$condition = [ '`id` = ? AND (`term-date` > ? OR `archive`)' , $contact [ 'id' ], DBA :: NULL_DATETIME ];
2018-07-20 12:19:26 +00:00
$exists = DBA :: exists ( 'contact' , $condition );
2017-11-19 21:55:28 +00:00
// We don't need to update, we never marked this contact for archival
2017-11-23 13:15:38 +00:00
if ( ! $exists ) {
2017-11-19 21:55:28 +00:00
return ;
}
2020-12-12 16:45:23 +00:00
Logger :: info ( 'Contact is marked as vital again' , [ 'id' => $contact [ 'id' ], 'term-date' => $contact [ 'term-date' ]]);
2019-01-16 21:39:56 +00:00
2018-08-21 15:35:09 +00:00
if ( ! isset ( $contact [ 'url' ]) && ! empty ( $contact [ 'id' ])) {
$fields = [ 'id' , 'url' , 'batch' ];
2019-01-07 18:26:54 +00:00
$contact = DBA :: selectFirst ( 'contact' , $fields , [ 'id' => $contact [ 'id' ]]);
2018-08-21 15:35:09 +00:00
if ( ! DBA :: isResult ( $contact )) {
return ;
}
}
2017-11-19 21:55:28 +00:00
// It's a miracle. Our dead contact has inexplicably come back to life.
2020-07-19 01:15:57 +00:00
$fields = [ 'failed' => false , 'term-date' => DBA :: NULL_DATETIME , 'archive' => false ];
2021-09-10 18:21:19 +00:00
self :: update ( $fields , [ 'id' => $contact [ 'id' ]]);
self :: update ( $fields , [ 'nurl' => Strings :: normaliseLink ( $contact [ 'url' ]), 'self' => false ]);
2017-11-19 21:55:28 +00:00
}
/**
2020-01-19 06:05:23 +00:00
* Returns the data array for the photo menu of a given contact
2017-11-19 21:55:28 +00:00
*
2017-11-22 14:02:55 +00:00
* @ param array $contact contact
* @ param int $uid optional , default 0
2017-11-19 21:55:28 +00:00
* @ return array
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-01-06 21:06:53 +00:00
* @ throws \ImagickException
2017-11-19 21:55:28 +00:00
*/
2022-06-27 09:39:26 +00:00
public static function photoMenu ( array $contact , int $uid = 0 ) : array
2017-11-19 21:55:28 +00:00
{
$pm_url = '' ;
$status_link = '' ;
$photos_link = '' ;
if ( $uid == 0 ) {
2022-10-20 20:14:50 +00:00
$uid = DI :: userSession () -> getLocalUserId ();
2017-11-19 21:55:28 +00:00
}
2018-07-10 12:27:56 +00:00
if ( empty ( $contact [ 'uid' ]) || ( $contact [ 'uid' ] != $uid )) {
2017-11-19 21:55:28 +00:00
if ( $uid == 0 ) {
2021-02-17 18:59:19 +00:00
$profile_link = self :: magicLinkByContact ( $contact );
2020-01-18 19:52:34 +00:00
$menu = [ 'profile' => [ DI :: l10n () -> t ( 'View Profile' ), $profile_link , true ]];
2017-11-19 21:55:28 +00:00
return $menu ;
}
2018-01-11 08:26:30 +00:00
// Look for our own contact if the uid doesn't match and isn't public
2018-07-20 12:19:26 +00:00
$contact_own = DBA :: selectFirst ( 'contact' , [], [ 'nurl' => $contact [ 'nurl' ], 'network' => $contact [ 'network' ], 'uid' => $uid ]);
2018-07-21 12:46:04 +00:00
if ( DBA :: isResult ( $contact_own )) {
2018-01-11 08:26:30 +00:00
return self :: photoMenu ( $contact_own , $uid );
2017-11-19 21:55:28 +00:00
}
}
$sparkle = false ;
2019-09-11 20:03:29 +00:00
if (( $contact [ 'network' ] === Protocol :: DFRN ) && ! $contact [ 'self' ] && empty ( $contact [ 'pending' ])) {
2017-11-19 21:55:28 +00:00
$sparkle = true ;
2019-12-30 22:00:08 +00:00
$profile_link = DI :: baseUrl () . '/redir/' . $contact [ 'id' ];
2017-11-19 21:55:28 +00:00
} else {
$profile_link = $contact [ 'url' ];
}
if ( $profile_link === 'mailbox' ) {
$profile_link = '' ;
}
if ( $sparkle ) {
2020-01-28 00:21:18 +00:00
$status_link = $profile_link . '/status' ;
2019-02-26 09:19:08 +00:00
$photos_link = str_replace ( '/profile/' , '/photos/' , $profile_link );
2020-01-28 00:21:18 +00:00
$profile_link = $profile_link . '/profile' ;
2017-11-19 21:55:28 +00:00
}
2019-09-11 20:03:29 +00:00
if ( self :: canReceivePrivateMessages ( $contact ) && empty ( $contact [ 'pending' ])) {
2019-12-30 22:00:08 +00:00
$pm_url = DI :: baseUrl () . '/message/new/' . $contact [ 'id' ];
2017-11-19 21:55:28 +00:00
}
2019-12-30 22:00:08 +00:00
$contact_url = DI :: baseUrl () . '/contact/' . $contact [ 'id' ];
2017-11-19 21:55:28 +00:00
2019-12-30 22:00:08 +00:00
$posts_link = DI :: baseUrl () . '/contact/' . $contact [ 'id' ] . '/conversations' ;
2018-03-17 06:17:32 +00:00
2019-10-17 01:16:23 +00:00
$follow_link = '' ;
$unfollow_link = '' ;
2021-10-02 15:44:47 +00:00
if ( ! $contact [ 'self' ] && Protocol :: supportsFollow ( $contact [ 'network' ])) {
2019-10-17 01:16:23 +00:00
if ( $contact [ 'uid' ] && in_array ( $contact [ 'rel' ], [ self :: SHARING , self :: FRIEND ])) {
2020-10-20 03:49:58 +00:00
$unfollow_link = 'unfollow?url=' . urlencode ( $contact [ 'url' ]) . '&auto=1' ;
2019-10-17 01:16:23 +00:00
} elseif ( ! $contact [ 'pending' ]) {
2020-10-20 03:49:58 +00:00
$follow_link = 'follow?url=' . urlencode ( $contact [ 'url' ]) . '&auto=1' ;
2019-10-17 01:16:23 +00:00
}
}
2017-11-19 21:55:28 +00:00
/**
2017-11-22 14:02:55 +00:00
* Menu array :
2017-11-19 21:55:28 +00:00
* " name " => [ " Label " , " link " , ( bool ) Should the link opened in a new tab ? ]
*/
2018-08-25 13:48:00 +00:00
if ( empty ( $contact [ 'uid' ])) {
$menu = [
2020-01-18 19:52:34 +00:00
'profile' => [ DI :: l10n () -> t ( 'View Profile' ) , $profile_link , true ],
'network' => [ DI :: l10n () -> t ( 'Network Posts' ) , $posts_link , false ],
'edit' => [ DI :: l10n () -> t ( 'View Contact' ) , $contact_url , false ],
'follow' => [ DI :: l10n () -> t ( 'Connect/Follow' ), $follow_link , true ],
'unfollow' => [ DI :: l10n () -> t ( 'UnFollow' ) , $unfollow_link , true ],
2018-08-25 13:48:00 +00:00
];
} else {
$menu = [
2020-01-18 19:52:34 +00:00
'status' => [ DI :: l10n () -> t ( 'View Status' ) , $status_link , true ],
'profile' => [ DI :: l10n () -> t ( 'View Profile' ) , $profile_link , true ],
'photos' => [ DI :: l10n () -> t ( 'View Photos' ) , $photos_link , true ],
'network' => [ DI :: l10n () -> t ( 'Network Posts' ) , $posts_link , false ],
'edit' => [ DI :: l10n () -> t ( 'View Contact' ) , $contact_url , false ],
'pm' => [ DI :: l10n () -> t ( 'Send PM' ) , $pm_url , false ],
'follow' => [ DI :: l10n () -> t ( 'Connect/Follow' ), $follow_link , true ],
'unfollow' => [ DI :: l10n () -> t ( 'UnFollow' ) , $unfollow_link , true ],
2018-08-25 13:48:00 +00:00
];
2019-09-09 05:29:33 +00:00
2019-09-11 20:03:29 +00:00
if ( ! empty ( $contact [ 'pending' ])) {
2021-10-18 20:49:25 +00:00
try {
$intro = DI :: intro () -> selectForContact ( $contact [ 'id' ]);
2021-10-21 22:58:18 +00:00
$menu [ 'follow' ] = [ DI :: l10n () -> t ( 'Approve' ), 'notifications/intros/' . $intro -> id , true ];
2021-10-18 20:49:25 +00:00
} catch ( IntroductionNotFoundException $exception ) {
DI :: logger () -> error ( 'Pending contact doesn\'t have an introduction.' , [ 'exception' => $exception ]);
2019-09-09 05:29:33 +00:00
}
}
2018-08-25 13:48:00 +00:00
}
2018-01-11 08:37:11 +00:00
$args = [ 'contact' => $contact , 'menu' => & $menu ];
2017-11-19 21:55:28 +00:00
2018-12-26 06:06:24 +00:00
Hook :: callAll ( 'contact_photo_menu' , $args );
2017-11-19 21:55:28 +00:00
2018-01-15 13:05:12 +00:00
$menucondensed = [];
2017-11-19 21:55:28 +00:00
2017-11-22 14:02:55 +00:00
foreach ( $menu as $menuname => $menuitem ) {
2017-11-19 21:55:28 +00:00
if ( $menuitem [ 1 ] != '' ) {
$menucondensed [ $menuname ] = $menuitem ;
}
}
return $menucondensed ;
}
/**
2020-01-19 06:05:23 +00:00
* Fetch the contact id for a given URL and user
2017-11-19 21:55:28 +00: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 08:37:11 +00:00
* Second , we probe the provided $url whether it ' s http :// server . tld / profile or
2017-11-19 21:55:28 +00: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 14:02:55 +00:00
* @ param string $url Contact URL
* @ param integer $uid The user id for the contact ( 0 = public contact )
2020-08-07 13:49:59 +00:00
* @ param boolean $update true = always update , false = never update , null = update when not found
* @ param array $default Default value for creating the contact when everything else fails
2017-11-19 21:55:28 +00:00
*
* @ return integer Contact ID
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-01-06 21:06:53 +00:00
* @ throws \ImagickException
2017-11-19 21:55:28 +00:00
*/
2022-07-17 11:47:12 +00:00
public static function getIdForURL ( string $url = null , int $uid = 0 , $update = null , array $default = []) : int
2017-11-19 21:55:28 +00:00
{
$contact_id = 0 ;
2022-07-17 11:47:12 +00:00
if ( empty ( $url )) {
2020-08-07 13:49:59 +00:00
Logger :: notice ( 'Empty url, quitting' , [ 'url' => $url , 'user' => $uid , 'default' => $default ]);
2017-11-19 21:55:28 +00:00
return 0 ;
}
2022-09-18 13:40:44 +00:00
$contact = self :: getByURL ( $url , false , [ 'id' , 'network' , 'uri-id' , 'next-update' ], $uid );
2017-11-19 21:55:28 +00:00
2020-06-26 05:28:25 +00:00
if ( ! empty ( $contact )) {
2022-06-27 11:49:26 +00:00
$contact_id = $contact [ 'id' ];
2017-11-19 21:55:28 +00:00
2022-09-18 13:40:44 +00:00
if ( Probe :: isProbable ( $contact [ 'network' ]) && ( $contact [ 'next-update' ] < DateTimeFormat :: utcNow ())) {
2022-10-17 05:49:55 +00:00
Worker :: add ([ 'priority' => Worker :: PRIORITY_LOW , 'dont_fork' => true ], 'UpdateContact' , $contact [ 'id' ]);
2022-09-18 13:40:44 +00:00
}
2021-07-09 17:13:54 +00:00
if ( empty ( $update ) && ( ! empty ( $contact [ 'uri-id' ]) || is_bool ( $update ))) {
2020-08-07 13:49:59 +00:00
Logger :: debug ( 'Contact found' , [ 'url' => $url , 'uid' => $uid , 'update' => $update , 'cid' => $contact_id ]);
2017-11-19 21:55:28 +00:00
return $contact_id ;
}
} elseif ( $uid != 0 ) {
2020-08-07 13:49:59 +00:00
Logger :: debug ( 'Contact does not exist for the user' , [ 'url' => $url , 'uid' => $uid , 'update' => $update ]);
return 0 ;
} elseif ( empty ( $default ) && ! is_null ( $update ) && ! $update ) {
Logger :: info ( 'Contact not found, update not desired' , [ 'url' => $url , 'uid' => $uid , 'update' => $update ]);
2017-11-19 21:55:28 +00:00
return 0 ;
}
2020-08-07 13:49:59 +00:00
$data = [];
2018-08-09 06:19:23 +00:00
2020-08-07 13:49:59 +00:00
if ( empty ( $default [ 'network' ]) || $update ) {
2022-06-27 11:49:26 +00:00
$data = Probe :: uri ( $url , '' , $uid );
2017-11-19 21:55:28 +00:00
2020-08-07 13:49:59 +00:00
// Take the default values when probing failed
2022-06-27 11:49:26 +00:00
if ( ! empty ( $default ) && ! in_array ( $data [ 'network' ], array_merge ( Protocol :: NATIVE_SUPPORT , [ Protocol :: PUMPIO ]))) {
2020-08-07 13:49:59 +00:00
$data = array_merge ( $data , $default );
}
} elseif ( ! empty ( $default [ 'network' ])) {
$data = $default ;
2019-04-09 05:15:23 +00:00
}
2020-08-07 13:49:59 +00:00
if (( $uid == 0 ) && ( empty ( $data [ 'network' ]) || ( $data [ 'network' ] == Protocol :: PHANTOM ))) {
// Fetch data for the public contact via the first found personal contact
/// @todo Check if this case can happen at all (possibly with mail accounts?)
2021-06-17 11:23:32 +00:00
$fields = [ 'name' , 'nick' , 'url' , 'addr' , 'alias' , 'avatar' , 'header' , 'contact-type' ,
2020-08-07 13:49:59 +00:00
'keywords' , 'location' , 'about' , 'unsearchable' , 'batch' , 'notify' , 'poll' ,
'request' , 'confirm' , 'poco' , 'subscribe' , 'network' , 'baseurl' , 'gsid' ];
$personal_contact = DBA :: selectFirst ( 'contact' , $fields , [ " `addr` = ? AND `uid` != 0 " , $url ]);
if ( ! DBA :: isResult ( $personal_contact )) {
$personal_contact = DBA :: selectFirst ( 'contact' , $fields , [ " `nurl` = ? AND `uid` != 0 " , Strings :: normaliseLink ( $url )]);
}
2017-11-19 21:55:28 +00:00
2020-08-07 13:49:59 +00:00
if ( DBA :: isResult ( $personal_contact )) {
Logger :: info ( 'Take contact data from personal contact' , [ 'url' => $url , 'update' => $update , 'contact' => $personal_contact , 'callstack' => System :: callstack ( 20 )]);
$data = $personal_contact ;
$data [ 'photo' ] = $personal_contact [ 'avatar' ];
$data [ 'account-type' ] = $personal_contact [ 'contact-type' ];
$data [ 'hide' ] = $personal_contact [ 'unsearchable' ];
unset ( $data [ 'avatar' ]);
unset ( $data [ 'contact-type' ]);
unset ( $data [ 'unsearchable' ]);
}
2020-05-24 20:40:00 +00:00
}
2020-08-07 13:49:59 +00:00
if ( empty ( $data [ 'network' ]) || ( $data [ 'network' ] == Protocol :: PHANTOM )) {
Logger :: notice ( 'No valid network found' , [ 'url' => $url , 'uid' => $uid , 'default' => $default , 'update' => $update , 'callstack' => System :: callstack ( 20 )]);
return 0 ;
2020-05-24 20:40:00 +00:00
}
2022-09-16 05:00:06 +00:00
if ( ! $contact_id && ! empty ( $data [ 'account-type' ]) && $data [ 'account-type' ] == User :: ACCOUNT_TYPE_DELETED ) {
Logger :: info ( 'Contact is a tombstone. It will not be inserted' , [ 'url' => $url , 'uid' => $uid ]);
return 0 ;
}
2020-08-05 14:57:49 +00:00
if ( ! $contact_id ) {
$urls = [ Strings :: normaliseLink ( $url ), Strings :: normaliseLink ( $data [ 'url' ])];
if ( ! empty ( $data [ 'alias' ])) {
$urls [] = Strings :: normaliseLink ( $data [ 'alias' ]);
2020-08-05 12:53:02 +00:00
}
2020-08-05 14:57:49 +00:00
$contact = self :: selectFirst ([ 'id' ], [ 'nurl' => $urls , 'uid' => $uid ]);
2020-08-05 12:53:02 +00:00
if ( ! empty ( $contact [ 'id' ])) {
$contact_id = $contact [ 'id' ];
2020-11-17 22:57:37 +00:00
Logger :: info ( 'Fetched id by url' , [ 'cid' => $contact_id , 'uid' => $uid , 'url' => $url , 'data' => $data ]);
2020-08-05 12:36:04 +00:00
}
2020-08-05 08:24:01 +00:00
}
2020-08-05 06:50:51 +00:00
2017-11-19 21:55:28 +00:00
if ( ! $contact_id ) {
2020-08-07 13:49:59 +00:00
// We only insert the basic data. The rest will be done in "updateFromProbeArray"
2018-12-02 16:25:25 +00:00
$fields = [
2018-01-11 08:37:11 +00:00
'uid' => $uid ,
2019-04-09 11:28:45 +00:00
'url' => $data [ 'url' ],
'nurl' => Strings :: normaliseLink ( $data [ 'url' ]),
'network' => $data [ 'network' ],
2020-08-07 13:49:59 +00:00
'created' => DateTimeFormat :: utcNow (),
2018-07-25 02:53:46 +00:00
'rel' => self :: SHARING ,
2018-01-11 08:37:11 +00:00
'writable' => 1 ,
'blocked' => 0 ,
'readonly' => 0 ,
2018-12-02 16:25:25 +00:00
'pending' => 0 ];
$condition = [ 'nurl' => Strings :: normaliseLink ( $data [ " url " ]), 'uid' => $uid , 'deleted' => false ];
2019-07-14 10:22:19 +00:00
// Before inserting we do check if the entry does exist now.
2022-09-16 05:00:06 +00:00
$contact = DBA :: selectFirst ( 'contact' , [ 'id' ], $condition , [ 'order' => [ 'id' ]]);
if ( DBA :: isResult ( $contact )) {
$contact_id = $contact [ 'id' ];
Logger :: notice ( 'Contact had been created (shortly) before' , [ 'id' => $contact_id , 'url' => $url , 'uid' => $uid ]);
2020-10-30 17:26:12 +00:00
} else {
2022-09-16 05:00:06 +00:00
$contact_id = self :: insert ( $fields );
if ( $contact_id ) {
Logger :: info ( 'Contact inserted' , [ 'id' => $contact_id , 'url' => $url , 'uid' => $uid ]);
}
2020-08-07 13:49:59 +00:00
}
2020-10-30 17:26:12 +00:00
2020-08-07 13:49:59 +00:00
if ( ! $contact_id ) {
2022-08-30 19:45:30 +00:00
Logger :: warning ( 'Contact was not inserted' , [ 'url' => $url , 'uid' => $uid ]);
2020-08-07 13:49:59 +00:00
return 0 ;
2017-11-19 21:55:28 +00:00
}
2019-07-12 21:07:47 +00:00
} else {
2020-08-07 13:49:59 +00:00
Logger :: info ( 'Contact will be updated' , [ 'url' => $url , 'uid' => $uid , 'update' => $update , 'cid' => $contact_id ]);
2019-07-02 09:06:48 +00:00
}
2021-12-30 22:40:52 +00:00
if ( $data [ 'network' ] == Protocol :: DIASPORA ) {
FContact :: updateFromProbeArray ( $data );
}
2020-08-07 13:49:59 +00:00
self :: updateFromProbeArray ( $contact_id , $data );
2021-02-28 17:56:56 +00:00
// Don't return a number for a deleted account
if ( ! empty ( $data [ 'account-type' ]) && $data [ 'account-type' ] == User :: ACCOUNT_TYPE_DELETED ) {
Logger :: info ( 'Contact is a tombstone' , [ 'url' => $url , 'uid' => $uid ]);
return 0 ;
}
2017-11-19 21:55:28 +00:00
return $contact_id ;
}
2019-08-27 19:01:11 +00:00
/**
2020-01-19 06:05:23 +00:00
* Checks if the contact is archived
2019-08-27 19:01:11 +00:00
*
* @ param int $cid contact id
*
* @ return boolean Is the contact archived ?
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-08-27 19:01:11 +00:00
*/
2022-06-27 09:39:26 +00:00
public static function isArchived ( int $cid ) : bool
2019-08-27 19:01:11 +00:00
{
if ( $cid == 0 ) {
return false ;
}
2019-08-28 14:54:49 +00:00
$contact = DBA :: selectFirst ( 'contact' , [ 'archive' , 'url' , 'batch' ], [ 'id' => $cid ]);
if ( ! DBA :: isResult ( $contact )) {
2019-08-27 19:01:11 +00:00
return false ;
}
2019-08-28 14:54:49 +00:00
if ( $contact [ 'archive' ]) {
2019-08-27 19:01:11 +00:00
return true ;
}
2019-08-28 14:54:49 +00:00
// Check status of ActivityPub endpoints
$apcontact = APContact :: getByURL ( $contact [ 'url' ], false );
if ( ! empty ( $apcontact )) {
if ( ! empty ( $apcontact [ 'inbox' ]) && DBA :: exists ( 'inbox-status' , [ 'archive' => true , 'url' => $apcontact [ 'inbox' ]])) {
return true ;
}
2019-08-27 19:01:11 +00:00
2019-08-28 14:54:49 +00:00
if ( ! empty ( $apcontact [ 'sharedinbox' ]) && DBA :: exists ( 'inbox-status' , [ 'archive' => true , 'url' => $apcontact [ 'sharedinbox' ]])) {
return true ;
}
2019-08-27 19:01:11 +00:00
}
2019-08-28 14:54:49 +00:00
// Check status of Diaspora endpoints
if ( ! empty ( $contact [ 'batch' ])) {
2019-09-02 13:11:07 +00:00
$condition = [ 'archive' => true , 'uid' => 0 , 'network' => Protocol :: FEDERATED , 'batch' => $contact [ 'batch' ], 'contact-type' => self :: TYPE_RELAY ];
return DBA :: exists ( 'contact' , $condition );
2019-08-28 14:02:19 +00:00
}
2019-08-27 19:01:11 +00:00
return false ;
}
2017-11-19 21:55:28 +00:00
/**
2020-01-19 06:05:23 +00:00
* Checks if the contact is blocked
2017-11-19 21:55:28 +00:00
*
* @ param int $cid contact id
* @ return boolean Is the contact blocked ?
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2017-11-19 21:55:28 +00:00
*/
2022-06-27 09:39:26 +00:00
public static function isBlocked ( int $cid ) : bool
2017-11-19 21:55:28 +00:00
{
if ( $cid == 0 ) {
return false ;
}
2018-11-22 21:43:16 +00:00
$blocked = DBA :: selectFirst ( 'contact' , [ 'blocked' , 'url' ], [ 'id' => $cid ]);
2018-07-21 12:46:04 +00:00
if ( ! DBA :: isResult ( $blocked )) {
2017-11-19 21:55:28 +00:00
return false ;
}
2018-11-22 21:43:16 +00:00
if ( Network :: isUrlBlocked ( $blocked [ 'url' ])) {
return true ;
}
2017-11-19 21:55:28 +00:00
return ( bool ) $blocked [ 'blocked' ];
}
/**
2020-01-19 06:05:23 +00:00
* Checks if the contact is hidden
2017-11-19 21:55:28 +00:00
*
* @ param int $cid contact id
* @ return boolean Is the contact hidden ?
2019-01-06 21:06:53 +00:00
* @ throws \Exception
2017-11-19 21:55:28 +00:00
*/
2022-06-27 09:39:26 +00:00
public static function isHidden ( int $cid ) : bool
2017-11-19 21:55:28 +00:00
{
if ( $cid == 0 ) {
return false ;
}
2018-07-20 12:19:26 +00:00
$hidden = DBA :: selectFirst ( 'contact' , [ 'hidden' ], [ 'id' => $cid ]);
2018-07-21 12:46:04 +00:00
if ( ! DBA :: isResult ( $hidden )) {
2017-11-19 21:55:28 +00:00
return false ;
}
return ( bool ) $hidden [ 'hidden' ];
}
/**
2020-01-19 06:05:23 +00:00
* Returns posts from a given contact url
2017-11-19 21:55:28 +00:00
*
2020-10-06 20:36:57 +00:00
* @ param string $contact_url Contact URL
* @ param bool $thread_mode
2021-05-09 11:54:34 +00:00
* @ param int $update Update mode
2020-10-06 20:36:57 +00:00
* @ param int $parent Item parent ID for the update mode
2021-10-02 15:09:43 +00:00
* @ param bool $only_media Only display media content
2017-11-19 21:55:28 +00:00
* @ return string posts in HTML
2019-01-06 21:06:53 +00:00
* @ throws \Exception
2017-11-19 21:55:28 +00:00
*/
2022-06-27 09:39:26 +00:00
public static function getPostsFromUrl ( string $contact_url , bool $thread_mode = false , int $update = 0 , int $parent = 0 , bool $only_media = false ) : string
2017-11-19 21:55:28 +00:00
{
2021-10-02 15:09:43 +00:00
return self :: getPostsFromId ( self :: getIdForURL ( $contact_url ), $thread_mode , $update , $parent , $only_media );
2020-06-09 22:38:06 +00:00
}
2017-11-24 22:15:35 +00:00
2020-06-09 22:38:06 +00:00
/**
* Returns posts from a given contact id
*
2020-10-06 20:36:57 +00:00
* @ param int $cid Contact ID
* @ param bool $thread_mode
2021-05-09 11:54:34 +00:00
* @ param int $update Update mode
2021-10-02 15:09:43 +00:00
* @ param int $parent Item parent ID for the update mode
* @ param bool $only_media Only display media content
2020-06-09 22:38:06 +00:00
* @ return string posts in HTML
* @ throws \Exception
*/
2022-06-27 09:39:26 +00:00
public static function getPostsFromId ( int $cid , bool $thread_mode = false , int $update = 0 , int $parent = 0 , bool $only_media = false ) : string
2020-06-09 22:38:06 +00:00
{
2018-09-16 09:06:09 +00:00
$contact = DBA :: selectFirst ( 'contact' , [ 'contact-type' , 'network' ], [ 'id' => $cid ]);
if ( ! DBA :: isResult ( $contact )) {
2017-11-19 21:55:28 +00:00
return '' ;
}
2019-07-01 22:14:34 +00:00
if ( empty ( $contact [ " network " ]) || in_array ( $contact [ " network " ], Protocol :: FEDERATED )) {
2021-01-16 22:37:27 +00:00
$sql = " (`uid` = 0 OR (`uid` = ? AND NOT `global`)) " ;
2017-11-19 21:55:28 +00:00
} else {
2021-01-16 22:37:27 +00:00
$sql = " `uid` = ? " ;
2017-11-19 21:55:28 +00:00
}
2019-12-08 05:19:15 +00:00
$contact_field = ((( $contact [ " contact-type " ] == self :: TYPE_COMMUNITY ) || ( $contact [ 'network' ] == Protocol :: MAIL )) ? 'owner-id' : 'author-id' );
2017-11-19 21:55:28 +00:00
2018-08-25 13:48:00 +00:00
if ( $thread_mode ) {
2022-09-28 09:48:48 +00:00
$condition = [ " ((` $contact_field ` = ? AND `gravity` = ?) OR (`author-id` = ? AND `gravity` = ? AND `vid` = ? AND `thr-parent-id` = `parent-uri-id`)) AND " . $sql ,
2022-10-20 20:14:50 +00:00
$cid , Item :: GRAVITY_PARENT , $cid , Item :: GRAVITY_ACTIVITY , Verb :: getID ( Activity :: ANNOUNCE ), DI :: userSession () -> getLocalUserId ()];
2018-08-25 13:48:00 +00:00
} else {
2018-09-16 09:06:09 +00:00
$condition = [ " ` $contact_field ` = ? AND `gravity` IN (?, ?) AND " . $sql ,
2022-10-20 20:14:50 +00:00
$cid , Item :: GRAVITY_PARENT , Item :: GRAVITY_COMMENT , DI :: userSession () -> getLocalUserId ()];
2018-08-25 13:48:00 +00:00
}
2020-10-06 18:47:23 +00:00
if ( ! empty ( $parent )) {
$condition = DBA :: mergeConditions ( $condition , [ 'parent' => $parent ]);
} else {
$last_received = isset ( $_GET [ 'last_received' ]) ? DateTimeFormat :: utc ( $_GET [ 'last_received' ]) : '' ;
if ( ! empty ( $last_received )) {
$condition = DBA :: mergeConditions ( $condition , [ " `received` < ? " , $last_received ]);
}
2020-09-30 19:14:13 +00:00
}
2021-10-02 18:31:30 +00:00
if ( $only_media ) {
2021-10-02 15:09:43 +00:00
$condition = DBA :: mergeConditions ( $condition , [ " `uri-id` IN (SELECT `uri-id` FROM `post-media` WHERE `type` IN (?, ?, ?)) " ,
Post\Media :: AUDIO , Post\Media :: IMAGE , Post\Media :: VIDEO ]);
}
2020-02-16 18:04:26 +00:00
if ( DI :: mode () -> isMobile ()) {
2022-10-20 20:14:50 +00:00
$itemsPerPage = DI :: pConfig () -> get ( DI :: userSession () -> getLocalUserId (), 'system' , 'itemspage_mobile_network' ,
2020-02-16 18:04:26 +00:00
DI :: config () -> get ( 'system' , 'itemspage_network_mobile' ));
} else {
2022-10-20 20:14:50 +00:00
$itemsPerPage = DI :: pConfig () -> get ( DI :: userSession () -> getLocalUserId (), 'system' , 'itemspage_network' ,
2020-02-16 18:04:26 +00:00
DI :: config () -> get ( 'system' , 'itemspage_network' ));
}
$pager = new Pager ( DI :: l10n (), DI :: args () -> getQueryString (), $itemsPerPage );
2018-10-24 06:15:24 +00:00
2020-11-30 20:44:21 +00:00
$params = [ 'order' => [ 'received' => true ], 'limit' => [ $pager -> getStart (), $pager -> getItemsPerPage ()]];
2017-11-19 21:55:28 +00:00
2022-10-20 20:14:50 +00:00
if ( DI :: pConfig () -> get ( DI :: userSession () -> getLocalUserId (), 'system' , 'infinite_scroll' )) {
2020-09-30 19:14:13 +00:00
$tpl = Renderer :: getMarkupTemplate ( 'infinite_scroll_head.tpl' );
$o = Renderer :: replaceMacros ( $tpl , [ '$reload_uri' => DI :: args () -> getQueryString ()]);
} else {
$o = '' ;
}
2021-05-09 11:54:34 +00:00
if ( $thread_mode ) {
2022-04-27 03:25:47 +00:00
$fields = [ 'uri-id' , 'thr-parent-id' , 'gravity' , 'author-id' , 'commented' ];
2022-10-20 20:14:50 +00:00
$items = Post :: toArray ( Post :: selectForUser ( DI :: userSession () -> getLocalUserId (), $fields , $condition , $params ));
2018-08-25 13:48:00 +00:00
2022-04-07 21:52:25 +00:00
if ( $pager -> getStart () == 0 ) {
2022-10-20 20:14:50 +00:00
$cdata = self :: getPublicAndUserContactID ( $cid , DI :: userSession () -> getLocalUserId ());
2022-04-08 04:17:52 +00:00
if ( ! empty ( $cdata [ 'public' ])) {
2022-04-27 03:25:47 +00:00
$pinned = Post\Collection :: selectToArrayForContact ( $cdata [ 'public' ], Post\Collection :: FEATURED , $fields );
2022-04-08 04:17:52 +00:00
$items = array_merge ( $items , $pinned );
}
2022-04-07 21:52:25 +00:00
}
2022-10-20 20:14:50 +00:00
$o .= DI :: conversation () -> create ( $items , 'contacts' , $update , false , 'pinned_commented' , DI :: userSession () -> getLocalUserId ());
2018-08-25 13:48:00 +00:00
} else {
2022-04-07 21:52:25 +00:00
$fields = array_merge ( Item :: DISPLAY_FIELDLIST , [ 'featured' ]);
2022-10-20 20:14:50 +00:00
$items = Post :: toArray ( Post :: selectForUser ( DI :: userSession () -> getLocalUserId (), $fields , $condition , $params ));
2022-04-07 21:52:25 +00:00
if ( $pager -> getStart () == 0 ) {
2022-10-20 20:14:50 +00:00
$cdata = self :: getPublicAndUserContactID ( $cid , DI :: userSession () -> getLocalUserId ());
2022-04-08 04:17:52 +00:00
if ( ! empty ( $cdata [ 'public' ])) {
2022-04-08 21:25:31 +00:00
$condition = [ " `uri-id` IN (SELECT `uri-id` FROM `collection-view` WHERE `cid` = ? AND `type` = ?) " ,
$cdata [ 'public' ], Post\Collection :: FEATURED ];
2022-10-20 20:14:50 +00:00
$pinned = Post :: toArray ( Post :: selectForUser ( DI :: userSession () -> getLocalUserId (), $fields , $condition , $params ));
2022-04-08 04:17:52 +00:00
$items = array_merge ( $pinned , $items );
2022-04-08 11:59:43 +00:00
}
2022-04-07 21:52:25 +00:00
}
2017-11-19 21:55:28 +00:00
2021-09-23 21:18:36 +00:00
$o .= DI :: conversation () -> create ( $items , 'contact-posts' , $update );
2018-08-25 13:48:00 +00:00
}
if ( ! $update ) {
2022-10-20 20:14:50 +00:00
if ( DI :: pConfig () -> get ( DI :: userSession () -> getLocalUserId (), 'system' , 'infinite_scroll' )) {
2020-09-29 20:47:19 +00:00
$o .= HTML :: scrollLoader ();
} else {
$o .= $pager -> renderMinimal ( count ( $items ));
}
2018-08-25 13:48:00 +00:00
}
2017-11-19 21:55:28 +00:00
return $o ;
}
/**
2020-01-19 06:05:23 +00:00
* Returns the account type name
2017-11-19 21:55:28 +00:00
*
* The function can be called with either the user or the contact array
*
2022-02-09 06:52:16 +00:00
* @ param int $type type of contact or account
2017-11-19 21:55:28 +00:00
* @ return string
*/
2022-06-16 19:57:02 +00:00
public static function getAccountType ( int $type ) : string
2022-02-09 06:52:16 +00:00
{
2017-11-19 21:55:28 +00:00
switch ( $type ) {
2019-01-06 22:08:35 +00:00
case self :: TYPE_ORGANISATION :
2020-01-18 19:52:34 +00:00
$account_type = DI :: l10n () -> t ( " Organisation " );
2017-11-19 21:55:28 +00:00
break ;
2018-07-27 23:25:57 +00:00
2019-01-06 22:08:35 +00:00
case self :: TYPE_NEWS :
2020-01-18 19:52:34 +00:00
$account_type = DI :: l10n () -> t ( 'News' );
2017-11-19 21:55:28 +00:00
break ;
2018-07-27 23:25:57 +00:00
2019-01-06 22:08:35 +00:00
case self :: TYPE_COMMUNITY :
2020-01-18 19:52:34 +00:00
$account_type = DI :: l10n () -> t ( " Forum " );
2017-11-19 21:55:28 +00:00
break ;
2018-07-27 23:25:57 +00:00
2017-11-19 21:55:28 +00:00
default :
$account_type = " " ;
break ;
}
return $account_type ;
}
2017-11-29 22:29:11 +00:00
/**
2020-01-19 06:05:23 +00:00
* Blocks a contact
2017-12-01 05:41:26 +00:00
*
2022-06-18 03:01:51 +00:00
* @ param int $cid Contact id to block
* @ param string $reason Block reason
* @ return bool Whether it was successful
2017-12-01 05:41:26 +00:00
*/
2022-06-18 03:01:51 +00:00
public static function block ( int $cid , string $reason = null ) : bool
2017-12-01 05:41:26 +00:00
{
2021-09-10 18:21:19 +00:00
$return = self :: update ([ 'blocked' => true , 'block_reason' => $reason ], [ 'id' => $cid ]);
2017-12-01 05:41:26 +00:00
return $return ;
}
/**
2020-01-19 06:05:23 +00:00
* Unblocks a contact
2017-12-01 05:41:26 +00:00
*
2022-06-18 03:01:51 +00:00
* @ param int $cid Contact id to unblock
* @ return bool Whether it was successfull
2017-12-01 05:41:26 +00:00
*/
2022-06-18 03:01:51 +00:00
public static function unblock ( int $cid ) : bool
2017-12-01 05:41:26 +00:00
{
2021-09-10 18:21:19 +00:00
$return = self :: update ([ 'blocked' => false , 'block_reason' => null ], [ 'id' => $cid ]);
2017-12-01 05:41:26 +00:00
return $return ;
2018-01-11 08:37:11 +00:00
}
2017-12-01 05:48:13 +00:00
2020-07-25 11:48:52 +00:00
/**
* Ensure that cached avatar exist
*
2022-06-18 03:01:51 +00:00
* @ param integer $cid Contact id
2020-07-25 11:48:52 +00:00
*/
public static function checkAvatarCache ( int $cid )
{
2021-10-23 17:18:30 +00:00
$contact = DBA :: selectFirst ( 'contact' , [ 'url' , 'network' , 'avatar' , 'photo' , 'thumb' , 'micro' ], [ 'id' => $cid , 'uid' => 0 , 'self' => false ]);
2020-07-25 11:48:52 +00:00
if ( ! DBA :: isResult ( $contact )) {
return ;
}
2022-05-11 18:30:59 +00:00
if ( Network :: isLocalLink ( $contact [ 'url' ])) {
return ;
}
2021-10-23 17:18:30 +00:00
if ( in_array ( $contact [ 'network' ], [ Protocol :: FEED , Protocol :: MAIL ]) || DI :: config () -> get ( 'system' , 'cache_contact_avatar' )) {
if ( ! empty ( $contact [ 'avatar' ]) && ( empty ( $contact [ 'photo' ]) || empty ( $contact [ 'thumb' ]) || empty ( $contact [ 'micro' ]))) {
Logger :: info ( 'Adding avatar cache' , [ 'id' => $cid , 'contact' => $contact ]);
self :: updateAvatar ( $cid , $contact [ 'avatar' ], true );
return ;
}
2022-05-09 06:57:47 +00:00
} elseif ( Photo :: isPhotoURI ( $contact [ 'photo' ]) || Photo :: isPhotoURI ( $contact [ 'thumb' ]) || Photo :: isPhotoURI ( $contact [ 'micro' ])) {
Logger :: info ( 'Replacing legacy avatar cache' , [ 'id' => $cid , 'contact' => $contact ]);
2021-10-23 17:18:30 +00:00
self :: updateAvatar ( $cid , $contact [ 'avatar' ], true );
2020-07-25 11:48:52 +00:00
return ;
2022-05-09 06:57:47 +00:00
} elseif ( DI :: config () -> get ( 'system' , 'avatar_cache' ) && ( empty ( $contact [ 'photo' ]) || empty ( $contact [ 'thumb' ]) || empty ( $contact [ 'micro' ]))) {
Logger :: info ( 'Adding avatar cache file' , [ 'id' => $cid , 'contact' => $contact ]);
self :: updateAvatar ( $cid , $contact [ 'avatar' ], true );
return ;
2020-07-25 11:48:52 +00:00
}
}
2020-07-28 12:58:19 +00:00
/**
* Return the photo path for a given contact array in the given size
*
2022-10-11 12:26:00 +00:00
* @ param array $contact contact array
2021-03-06 21:52:26 +00:00
* @ param string $size Size of the avatar picture
2022-10-11 12:26:00 +00:00
* @ param bool $no_update Don ' t perfom an update if no cached avatar was found
2020-07-28 12:58:19 +00:00
* @ return string photo path
*/
2022-06-18 03:01:51 +00:00
private static function getAvatarPath ( array $contact , string $size , bool $no_update = false ) : string
2020-07-28 12:58:19 +00:00
{
2021-07-06 10:36:00 +00:00
$contact = self :: checkAvatarCacheByArray ( $contact , $no_update );
2022-05-08 05:37:17 +00:00
2022-05-08 09:34:30 +00:00
if ( DI :: config () -> get ( 'system' , 'avatar_cache' )) {
2022-05-08 05:37:17 +00:00
switch ( $size ) {
case Proxy :: SIZE_MICRO :
2022-05-09 04:26:00 +00:00
if ( ! empty ( $contact [ 'micro' ]) && ! Photo :: isPhotoURI ( $contact [ 'micro' ])) {
2022-05-08 05:37:17 +00:00
return $contact [ 'micro' ];
}
break ;
case Proxy :: SIZE_THUMB :
2022-05-09 04:26:00 +00:00
if ( ! empty ( $contact [ 'thumb' ]) && ! Photo :: isPhotoURI ( $contact [ 'thumb' ])) {
2022-05-08 05:37:17 +00:00
return $contact [ 'thumb' ];
}
break ;
case Proxy :: SIZE_SMALL :
2022-05-09 04:26:00 +00:00
if ( ! empty ( $contact [ 'photo' ]) && ! Photo :: isPhotoURI ( $contact [ 'photo' ])) {
2022-05-08 05:37:17 +00:00
return $contact [ 'photo' ];
}
break ;
}
}
2022-10-11 12:26:00 +00:00
return self :: getAvatarUrlForId ( $contact [ 'id' ] ? ? 0 , $size , $contact [ 'updated' ] ? ? '' );
2020-07-28 12:58:19 +00:00
}
/**
* Return the photo path for a given contact array
*
2021-03-06 21:52:26 +00:00
* @ param array $contact Contact array
* @ param bool $no_update Don ' t perfom an update if no cached avatar was found
2020-07-28 12:58:19 +00:00
* @ return string photo path
*/
2022-06-18 03:01:51 +00:00
public static function getPhoto ( array $contact , bool $no_update = false ) : string
2020-07-28 12:58:19 +00:00
{
2021-07-06 10:36:00 +00:00
return self :: getAvatarPath ( $contact , Proxy :: SIZE_SMALL , $no_update );
2020-07-28 12:58:19 +00:00
}
/**
* Return the photo path ( thumb size ) for a given contact array
*
2021-03-06 21:52:26 +00:00
* @ param array $contact Contact array
* @ param bool $no_update Don ' t perfom an update if no cached avatar was found
2020-07-28 12:58:19 +00:00
* @ return string photo path
*/
2022-06-18 03:01:51 +00:00
public static function getThumb ( array $contact , bool $no_update = false ) : string
2020-07-28 12:58:19 +00:00
{
2021-07-06 10:36:00 +00:00
return self :: getAvatarPath ( $contact , Proxy :: SIZE_THUMB , $no_update );
2020-07-28 12:58:19 +00:00
}
/**
* Return the photo path ( micro size ) for a given contact array
*
2021-03-06 21:52:26 +00:00
* @ param array $contact Contact array
* @ param bool $no_update Don ' t perfom an update if no cached avatar was found
2020-07-28 12:58:19 +00:00
* @ return string photo path
*/
2022-06-18 03:01:51 +00:00
public static function getMicro ( array $contact , bool $no_update = false ) : string
2020-07-28 12:58:19 +00:00
{
2021-07-06 10:36:00 +00:00
return self :: getAvatarPath ( $contact , Proxy :: SIZE_MICRO , $no_update );
2020-07-28 12:58:19 +00:00
}
2020-07-27 10:11:12 +00:00
/**
* Check the given contact array for avatar cache fields
*
* @ param array $contact
2021-03-06 21:52:26 +00:00
* @ param bool $no_update Don ' t perfom an update if no cached avatar was found
2020-07-27 10:11:12 +00:00
* @ return array contact array with avatar cache fields
*/
2022-06-18 03:01:51 +00:00
private static function checkAvatarCacheByArray ( array $contact , bool $no_update = false ) : array
2020-07-27 10:11:12 +00:00
{
$update = false ;
$contact_fields = [];
$fields = [ 'photo' , 'thumb' , 'micro' ];
foreach ( $fields as $field ) {
if ( isset ( $contact [ $field ])) {
$contact_fields [] = $field ;
}
if ( isset ( $contact [ $field ]) && empty ( $contact [ $field ])) {
$update = true ;
}
}
2021-03-06 21:52:26 +00:00
if ( ! $update || $no_update ) {
2020-07-27 10:11:12 +00:00
return $contact ;
}
2022-05-11 18:30:59 +00:00
$local = ! empty ( $contact [ 'url' ]) && Network :: isLocalLink ( $contact [ 'url' ]);
if ( ! $local && ! empty ( $contact [ 'id' ]) && ! empty ( $contact [ 'avatar' ])) {
2020-07-27 10:11:12 +00:00
self :: updateAvatar ( $contact [ 'id' ], $contact [ 'avatar' ], true );
$new_contact = self :: getById ( $contact [ 'id' ], $contact_fields );
if ( DBA :: isResult ( $new_contact )) {
// We only update the cache fields
$contact = array_merge ( $contact , $new_contact );
}
2022-05-11 18:30:59 +00:00
} elseif ( $local && ! empty ( $contact [ 'avatar' ])) {
2022-05-10 18:18:24 +00:00
return $contact ;
}
2020-07-27 10:11:12 +00:00
/// add the default avatars if the fields aren't filled
if ( isset ( $contact [ 'photo' ]) && empty ( $contact [ 'photo' ])) {
2020-12-07 06:43:43 +00:00
$contact [ 'photo' ] = self :: getDefaultAvatar ( $contact , Proxy :: SIZE_SMALL );
2020-07-27 10:11:12 +00:00
}
if ( isset ( $contact [ 'thumb' ]) && empty ( $contact [ 'thumb' ])) {
2020-12-07 06:43:43 +00:00
$contact [ 'thumb' ] = self :: getDefaultAvatar ( $contact , Proxy :: SIZE_THUMB );
2020-07-27 10:11:12 +00:00
}
if ( isset ( $contact [ 'micro' ]) && empty ( $contact [ 'micro' ])) {
2020-12-07 06:43:43 +00:00
$contact [ 'micro' ] = self :: getDefaultAvatar ( $contact , Proxy :: SIZE_MICRO );
2020-07-27 10:11:12 +00:00
}
return $contact ;
}
2022-01-09 10:38:36 +00:00
/**
* Fetch the default header for the given contact
*
* @ param array $contact contact array
* @ return string avatar URL
*/
public static function getDefaultHeader ( array $contact ) : string
{
2022-01-09 11:19:31 +00:00
if ( ! empty ( $contact [ 'header' ])) {
return $contact [ 'header' ];
2022-01-09 10:38:36 +00:00
}
if ( ! empty ( $contact [ 'gsid' ])) {
// Use default banners for certain platforms
$gserver = DBA :: selectFirst ( 'gserver' , [ 'platform' ], [ 'id' => $contact [ 'gsid' ]]);
$platform = strtolower ( $gserver [ 'platform' ] ? ? '' );
} else {
$platform = '' ;
}
switch ( $platform ) {
case 'friendica' :
case 'friendika' :
/**
* Picture credits
* @ author Lostinlight < https :// mastodon . xyz /@ lightone >
* @ license CC0 https :// creativecommons . org / share - your - work / public - domain / cc0 /
* @ link https :// gitlab . com / lostinlight / per_aspera_ad_astra /-/ blob / master / friendica - 404 / friendica - promo - bubbles . jpg
*/
$header = DI :: baseUrl () . '/images/friendica-banner.jpg' ;
break ;
case 'diaspora' :
/**
* Picture credits
* @ author John Liu < https :// www . flickr . com / photos / 8047705 @ N02 />
* @ license CC BY 2.0 https :// creativecommons . org / licenses / by / 2.0 /
* @ link https :// www . flickr . com / photos / 8047705 @ N02 / 5572197407
*/
$header = DI :: baseUrl () . '/images/diaspora-banner.jpg' ;
break ;
default :
/**
2022-05-17 12:32:25 +00:00
* Use a random picture .
2022-01-09 10:38:36 +00:00
* The service provides random pictures from Unsplash .
* @ license https :// unsplash . com / license
*/
$header = 'https://picsum.photos/seed/' . hash ( 'ripemd128' , $contact [ 'url' ]) . '/960/300' ;
break ;
}
return $header ;
}
2020-12-07 06:43:43 +00:00
/**
* Fetch the default avatar for the given contact and size
*
* @ param array $contact contact array
* @ param string $size Size of the avatar picture
2021-06-24 07:08:38 +00:00
* @ return string avatar URL
2020-12-07 06:43:43 +00:00
*/
2022-06-18 03:01:51 +00:00
public static function getDefaultAvatar ( array $contact , string $size ) : string
2020-12-07 06:43:43 +00:00
{
switch ( $size ) {
case Proxy :: SIZE_MICRO :
$avatar [ 'size' ] = 48 ;
$default = self :: DEFAULT_AVATAR_MICRO ;
break ;
2021-05-09 11:54:34 +00:00
2020-12-07 06:43:43 +00:00
case Proxy :: SIZE_THUMB :
$avatar [ 'size' ] = 80 ;
$default = self :: DEFAULT_AVATAR_THUMB ;
break ;
2021-05-09 11:54:34 +00:00
2020-12-07 06:43:43 +00:00
case Proxy :: SIZE_SMALL :
default :
$avatar [ 'size' ] = 300 ;
$default = self :: DEFAULT_AVATAR_PHOTO ;
break ;
}
if ( ! DI :: config () -> get ( 'system' , 'remote_avatar_lookup' )) {
2022-06-13 05:18:54 +00:00
$platform = '' ;
2022-06-13 10:27:46 +00:00
$type = Contact :: TYPE_PERSON ;
2022-06-13 05:18:54 +00:00
if ( ! empty ( $contact [ 'id' ])) {
2022-06-13 10:27:46 +00:00
$account = DBA :: selectFirst ( 'account-user-view' , [ 'platform' , 'contact-type' ], [ 'id' => $contact [ 'id' ]]);
2022-06-13 05:18:54 +00:00
$platform = $account [ 'platform' ] ? ? '' ;
2022-06-13 10:27:46 +00:00
$type = $account [ 'contact-type' ] ? ? Contact :: TYPE_PERSON ;
2022-06-13 05:18:54 +00:00
}
2022-06-13 20:07:54 +00:00
2022-06-13 05:18:54 +00:00
if ( empty ( $platform ) && ! empty ( $contact [ 'uri-id' ])) {
2022-06-13 10:27:46 +00:00
$account = DBA :: selectFirst ( 'account-user-view' , [ 'platform' , 'contact-type' ], [ 'uri-id' => $contact [ 'uri-id' ]]);
2022-06-13 05:18:54 +00:00
$platform = $account [ 'platform' ] ? ? '' ;
2022-06-13 10:27:46 +00:00
$type = $account [ 'contact-type' ] ? ? Contact :: TYPE_PERSON ;
2022-06-13 05:18:54 +00:00
}
switch ( $platform ) {
2022-06-13 20:07:54 +00:00
case 'corgidon' :
2022-06-13 10:03:34 +00:00
/**
* Picture credits
* @ license GNU Affero General Public License v3 . 0
2022-06-13 20:07:54 +00:00
* @ link https :// github . com / msdos621 / corgidon / blob / main / public / avatars / original / missing . png
2022-06-13 10:03:34 +00:00
*/
2022-06-13 20:07:54 +00:00
$default = '/images/default/corgidon.png' ;
2022-06-13 05:18:54 +00:00
break ;
2022-06-13 20:07:54 +00:00
case 'diaspora' :
2022-06-13 10:03:34 +00:00
/**
* Picture credits
* @ license GNU Affero General Public License v3 . 0
2022-06-13 20:07:54 +00:00
* @ link https :// github . com / diaspora / diaspora /
2022-06-13 10:03:34 +00:00
*/
2022-06-13 20:07:54 +00:00
$default = '/images/default/diaspora.png' ;
2022-06-13 05:18:54 +00:00
break ;
2022-06-13 20:07:54 +00:00
case 'gotosocial' :
2022-06-13 10:03:34 +00:00
/**
* Picture credits
* @ license GNU Affero General Public License v3 . 0
2022-06-13 20:07:54 +00:00
* @ link https :// github . com / superseriousbusiness / gotosocial / blob / main / web / assets / default_avatars / GoToSocial_icon1 . svg
2022-06-13 10:03:34 +00:00
*/
2022-06-13 20:07:54 +00:00
$default = '/images/default/gotosocial.svg' ;
break ;
case 'hometown' :
/**
* Picture credits
* @ license GNU Affero General Public License v3 . 0
* @ link https :// github . com / hometown - fork / hometown / blob / hometown - dev / public / avatars / original / missing . png
*/
$default = '/images/default/hometown.png' ;
break ;
case 'koyuspace' :
/**
* Picture credits
* @ license GNU Affero General Public License v3 . 0
* @ link https :// github . com / koyuspace / mastodon / blob / main / public / avatars / original / missing . png
*/
$default = '/images/default/koyuspace.png' ;
break ;
case 'ecko' :
case 'qoto' :
case 'mastodon' :
/**
* Picture credits
* @ license GNU Affero General Public License v3 . 0
* @ link https :// github . com / mastodon / mastodon / tree / main / public / avatars / original / missing . png
*/
$default = '/images/default/mastodon.png' ;
2022-06-13 05:18:54 +00:00
break ;
case 'peertube' :
2022-06-13 10:27:46 +00:00
if ( $type == Contact :: TYPE_COMMUNITY ) {
2022-06-13 10:30:21 +00:00
/**
* Picture credits
* @ license GNU Affero General Public License v3 . 0
* @ link https :// github . com / Chocobozzz / PeerTube / blob / develop / client / src / assets / images / default - avatar - video - channel . png
*/
2022-06-13 10:27:46 +00:00
$default = '/images/default/peertube-channel.png' ;
} else {
2022-06-13 10:30:21 +00:00
/**
* Picture credits
* @ license GNU Affero General Public License v3 . 0
* @ link https :// github . com / Chocobozzz / PeerTube / blob / develop / client / src / assets / images / default - avatar - account . png
*/
2022-06-13 10:27:46 +00:00
$default = '/images/default/peertube-account.png' ;
}
2022-06-13 05:18:54 +00:00
break ;
2022-06-13 20:07:54 +00:00
case 'pleroma' :
/**
* Picture credits
* @ license GNU Affero General Public License v3 . 0
* @ link https :// git . pleroma . social / pleroma / pleroma /-/ blob / develop / priv / static / images / avi . png
*/
$default = '/images/default/pleroma.png' ;
break ;
case 'plume' :
/**
* Picture credits
* @ license GNU Affero General Public License v3 . 0
* @ link https :// github . com / Plume - org / Plume / blob / main / assets / images / default - avatar . png
*/
$default = '/images/default/plume.png' ;
break ;
2022-06-13 05:18:54 +00:00
}
2020-12-07 06:43:43 +00:00
return DI :: baseUrl () . $default ;
}
if ( ! empty ( $contact [ 'xmpp' ])) {
$avatar [ 'email' ] = $contact [ 'xmpp' ];
} elseif ( ! empty ( $contact [ 'addr' ])) {
$avatar [ 'email' ] = $contact [ 'addr' ];
} elseif ( ! empty ( $contact [ 'url' ])) {
$avatar [ 'email' ] = $contact [ 'url' ];
} else {
return DI :: baseUrl () . $default ;
}
$avatar [ 'url' ] = '' ;
$avatar [ 'success' ] = false ;
Hook :: callAll ( 'avatar_lookup' , $avatar );
if ( $avatar [ 'success' ] && ! empty ( $avatar [ 'url' ])) {
return $avatar [ 'url' ];
}
return DI :: baseUrl () . $default ;
}
2021-06-25 17:03:35 +00:00
/**
* Get avatar link for given contact id
*
2021-06-29 06:15:45 +00:00
* @ param integer $cid contact id
2021-10-05 20:18:19 +00:00
* @ param string $size One of the Proxy :: SIZE_ * constants
2021-06-29 06:15:45 +00:00
* @ param string $updated Contact update date
2021-06-27 11:50:10 +00:00
* @ return string avatar link
*/
2022-06-24 01:44:52 +00:00
public static function getAvatarUrlForId ( int $cid , string $size = '' , string $updated = '' , string $guid = '' ) : string
2021-06-27 11:50:10 +00:00
{
2021-06-29 06:15:45 +00:00
// We have to fetch the "updated" variable when it wasn't provided
// The parameter can be provided to improve performance
2022-04-29 07:30:13 +00:00
if ( empty ( $updated )) {
2021-10-04 06:13:52 +00:00
$account = DBA :: selectFirst ( 'account-user-view' , [ 'updated' , 'guid' ], [ 'id' => $cid ]);
$updated = $account [ 'updated' ] ? ? '' ;
$guid = $account [ 'guid' ] ? ? '' ;
2021-06-29 06:15:45 +00:00
}
2021-10-04 06:13:52 +00:00
$guid = urlencode ( $guid );
2021-06-27 11:50:10 +00:00
$url = DI :: baseUrl () . '/photo/contact/' ;
switch ( $size ) {
case Proxy :: SIZE_MICRO :
$url .= Proxy :: PIXEL_MICRO . '/' ;
break ;
case Proxy :: SIZE_THUMB :
$url .= Proxy :: PIXEL_THUMB . '/' ;
break ;
case Proxy :: SIZE_SMALL :
$url .= Proxy :: PIXEL_SMALL . '/' ;
break ;
case Proxy :: SIZE_MEDIUM :
$url .= Proxy :: PIXEL_MEDIUM . '/' ;
break ;
case Proxy :: SIZE_LARGE :
$url .= Proxy :: PIXEL_LARGE . '/' ;
break ;
}
2021-10-04 06:13:52 +00:00
return $url . ( $guid ? : $cid ) . ( $updated ? '?ts=' . strtotime ( $updated ) : '' );
2021-06-27 11:50:10 +00:00
}
/**
* Get avatar link for given contact URL
*
* @ param string $url contact url
* @ param integer $uid user id
2021-10-05 20:18:19 +00:00
* @ param string $size One of the Proxy :: SIZE_ * constants
2021-06-25 17:03:35 +00:00
* @ return string avatar link
*/
2022-06-24 01:44:52 +00:00
public static function getAvatarUrlForUrl ( string $url , int $uid , string $size = '' ) : string
2021-06-25 17:03:35 +00:00
{
2021-06-27 11:50:10 +00:00
$condition = [ " `nurl` = ? AND ((`uid` = ? AND `network` IN (?, ?)) OR `uid` = ?) " ,
Strings :: normaliseLink ( $url ), $uid , Protocol :: FEED , Protocol :: MAIL , 0 ];
2021-07-24 10:32:55 +00:00
$contact = self :: selectFirst ([ 'id' , 'updated' ], $condition , [ 'order' => [ 'uid' => true ]]);
2021-06-29 20:26:58 +00:00
return self :: getAvatarUrlForId ( $contact [ 'id' ] ? ? 0 , $size , $contact [ 'updated' ] ? ? '' );
2021-06-25 17:03:35 +00:00
}
/**
* Get header link for given contact id
*
2021-06-29 06:15:45 +00:00
* @ param integer $cid contact id
2021-10-05 20:18:19 +00:00
* @ param string $size One of the Proxy :: SIZE_ * constants
2021-06-29 06:15:45 +00:00
* @ param string $updated Contact update date
2021-06-25 17:03:35 +00:00
* @ return string header link
*/
2022-06-24 01:44:52 +00:00
public static function getHeaderUrlForId ( int $cid , string $size = '' , string $updated = '' , string $guid = '' ) : string
2021-06-25 17:03:35 +00:00
{
2021-06-29 06:15:45 +00:00
// We have to fetch the "updated" variable when it wasn't provided
// The parameter can be provided to improve performance
2021-10-04 06:13:52 +00:00
if ( empty ( $updated ) || empty ( $guid )) {
$account = DBA :: selectFirst ( 'account-user-view' , [ 'updated' , 'guid' ], [ 'id' => $cid ]);
$updated = $account [ 'updated' ] ? ? '' ;
$guid = $account [ 'guid' ] ? ? '' ;
2021-06-29 06:15:45 +00:00
}
2021-10-04 06:13:52 +00:00
$guid = urlencode ( $guid );
2021-06-29 06:15:45 +00:00
$url = DI :: baseUrl () . '/photo/header/' ;
switch ( $size ) {
case Proxy :: SIZE_MICRO :
$url .= Proxy :: PIXEL_MICRO . '/' ;
break ;
case Proxy :: SIZE_THUMB :
$url .= Proxy :: PIXEL_THUMB . '/' ;
break ;
case Proxy :: SIZE_SMALL :
$url .= Proxy :: PIXEL_SMALL . '/' ;
break ;
case Proxy :: SIZE_MEDIUM :
$url .= Proxy :: PIXEL_MEDIUM . '/' ;
break ;
case Proxy :: SIZE_LARGE :
$url .= Proxy :: PIXEL_LARGE . '/' ;
break ;
}
2021-10-04 06:13:52 +00:00
return $url . ( $guid ? : $cid ) . ( $updated ? '?ts=' . strtotime ( $updated ) : '' );
2021-06-25 17:03:35 +00:00
}
2018-01-11 08:37:11 +00:00
/**
2020-01-19 06:05:23 +00:00
* Updates the avatar links in a contact only if needed
2017-11-29 22:29:11 +00:00
*
2020-08-21 18:41:48 +00:00
* @ param int $cid Contact id
* @ param string $avatar Link to avatar picture
* @ param bool $force force picture update
* @ param bool $create_cache Enforces the creation of cached avatar fields
2017-11-29 22:29:11 +00:00
*
2020-03-09 15:39:48 +00:00
* @ return void
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2020-03-09 15:12:33 +00:00
* @ throws HTTPException\NotFoundException
2019-01-06 21:06:53 +00:00
* @ throws \ImagickException
2017-11-29 22:29:11 +00:00
*/
2020-08-21 18:41:48 +00:00
public static function updateAvatar ( int $cid , string $avatar , bool $force = false , bool $create_cache = false )
2017-11-29 22:29:11 +00:00
{
2022-05-08 05:37:17 +00:00
$contact = DBA :: selectFirst ( 'contact' , [ 'uid' , 'avatar' , 'photo' , 'thumb' , 'micro' , 'xmpp' , 'addr' , 'nurl' , 'url' , 'network' , 'uri-id' ],
2020-12-07 06:43:43 +00:00
[ 'id' => $cid , 'self' => false ]);
2018-07-21 12:46:04 +00:00
if ( ! DBA :: isResult ( $contact )) {
2020-03-09 15:39:48 +00:00
return ;
2017-11-29 22:29:11 +00:00
}
2020-07-25 11:48:52 +00:00
$uid = $contact [ 'uid' ];
// Only update the cached photo links of public contacts when they already are cached
2020-08-21 18:41:48 +00:00
if (( $uid == 0 ) && ! $force && empty ( $contact [ 'thumb' ]) && empty ( $contact [ 'micro' ]) && ! $create_cache ) {
2020-07-26 07:34:33 +00:00
if ( $contact [ 'avatar' ] != $avatar ) {
2021-09-10 18:21:19 +00:00
self :: update ([ 'avatar' => $avatar ], [ 'id' => $cid ]);
2020-07-26 07:34:33 +00:00
Logger :: info ( 'Only update the avatar' , [ 'id' => $cid , 'avatar' => $avatar , 'contact' => $contact ]);
}
2020-07-25 11:48:52 +00:00
return ;
}
2020-08-21 18:41:48 +00:00
// User contacts use are updated through the public contacts
if (( $uid != 0 ) && ! in_array ( $contact [ 'network' ], [ Protocol :: FEED , Protocol :: MAIL ])) {
2021-07-17 05:25:04 +00:00
$pcid = self :: getIdForURL ( $contact [ 'url' ], 0 , false );
2020-08-21 18:41:48 +00:00
if ( ! empty ( $pcid )) {
Logger :: debug ( 'Update the private contact via the public contact' , [ 'id' => $cid , 'uid' => $uid , 'public' => $pcid ]);
self :: updateAvatar ( $pcid , $avatar , $force , true );
return ;
}
2020-08-19 05:18:19 +00:00
}
2020-12-07 06:43:43 +00:00
2020-12-07 07:14:09 +00:00
$default_avatar = empty ( $avatar ) || strpos ( $avatar , self :: DEFAULT_AVATAR_PHOTO );
2020-12-07 06:43:43 +00:00
if ( $default_avatar ) {
$avatar = self :: getDefaultAvatar ( $contact , Proxy :: SIZE_SMALL );
}
2022-02-01 20:22:40 +00:00
$cache_avatar = DI :: config () -> get ( 'system' , 'cache_contact_avatar' );
// Local contact avatars don't need to be cached
if ( $cache_avatar && Network :: isLocalLink ( $contact [ 'url' ])) {
$cache_avatar = ! DBA :: exists ( 'contact' , [ 'nurl' => $contact [ 'nurl' ], 'self' => true ]);
}
if ( in_array ( $contact [ 'network' ], [ Protocol :: FEED , Protocol :: MAIL ]) || $cache_avatar ) {
2022-05-09 06:27:46 +00:00
Avatar :: deleteCache ( $contact );
2022-05-08 05:37:17 +00:00
2021-10-23 17:18:30 +00:00
if ( $default_avatar && Proxy :: isLocalImage ( $avatar )) {
$fields = [ 'avatar' => $avatar , 'avatar-date' => DateTimeFormat :: utcNow (),
'photo' => $avatar ,
'thumb' => self :: getDefaultAvatar ( $contact , Proxy :: SIZE_THUMB ),
'micro' => self :: getDefaultAvatar ( $contact , Proxy :: SIZE_MICRO )];
Logger :: debug ( 'Use default avatar' , [ 'id' => $cid , 'uid' => $uid ]);
2020-08-19 04:11:20 +00:00
}
2021-10-23 17:18:30 +00:00
// Use the data from the self account
if ( empty ( $fields )) {
$local_uid = User :: getIdForURL ( $contact [ 'url' ]);
if ( ! empty ( $local_uid )) {
$fields = self :: selectFirst ([ 'avatar' , 'avatar-date' , 'photo' , 'thumb' , 'micro' ], [ 'self' => true , 'uid' => $local_uid ]);
Logger :: debug ( 'Use owner data' , [ 'id' => $cid , 'uid' => $uid , 'owner-uid' => $local_uid ]);
}
}
2021-05-09 11:54:34 +00:00
2021-10-23 17:18:30 +00:00
if ( empty ( $fields )) {
$update = ( $contact [ 'avatar' ] != $avatar ) || $force ;
if ( ! $update ) {
$data = [
$contact [ 'photo' ] ? ? '' ,
$contact [ 'thumb' ] ? ? '' ,
$contact [ 'micro' ] ? ? '' ,
];
foreach ( $data as $image_uri ) {
$image_rid = Photo :: ridFromURI ( $image_uri );
if ( $image_rid && ! Photo :: exists ([ 'resource-id' => $image_rid , 'uid' => $uid ])) {
Logger :: debug ( 'Regenerating avatar' , [ 'contact uid' => $uid , 'cid' => $cid , 'missing photo' => $image_rid , 'avatar' => $contact [ 'avatar' ]]);
$update = true ;
}
2020-08-21 18:41:48 +00:00
}
}
2020-08-19 04:11:20 +00:00
2021-10-23 17:18:30 +00:00
if ( $update ) {
$photos = Photo :: importProfilePhoto ( $avatar , $uid , $cid , true );
if ( $photos ) {
$fields = [ 'avatar' => $avatar , 'photo' => $photos [ 0 ], 'thumb' => $photos [ 1 ], 'micro' => $photos [ 2 ], 'avatar-date' => DateTimeFormat :: utcNow ()];
$update = ! empty ( $fields );
Logger :: debug ( 'Created new cached avatars' , [ 'id' => $cid , 'uid' => $uid , 'owner-uid' => $local_uid ]);
} else {
$update = false ;
}
2020-07-26 07:34:33 +00:00
}
2021-10-23 17:18:30 +00:00
} else {
$update = ( $fields [ 'photo' ] . $fields [ 'thumb' ] . $fields [ 'micro' ] != $contact [ 'photo' ] . $contact [ 'thumb' ] . $contact [ 'micro' ]) || $force ;
2020-01-09 20:41:52 +00:00
}
2020-08-21 18:41:48 +00:00
} else {
2021-10-23 17:18:30 +00:00
Photo :: delete ([ 'uid' => $uid , 'contact-id' => $cid , 'photo-type' => Photo :: CONTACT_AVATAR ]);
2022-05-27 05:36:07 +00:00
$fields = Avatar :: fetchAvatarContact ( $contact , $avatar , $force );
2022-05-08 05:37:17 +00:00
$update = ( $avatar . $fields [ 'photo' ] . $fields [ 'thumb' ] . $fields [ 'micro' ] != $contact [ 'avatar' ] . $contact [ 'photo' ] . $contact [ 'thumb' ] . $contact [ 'micro' ]) || $force ;
2020-01-09 20:41:52 +00:00
}
2020-08-21 18:41:48 +00:00
if ( ! $update ) {
return ;
}
$cids = [];
$uids = [];
if (( $uid == 0 ) && ! in_array ( $contact [ 'network' ], [ Protocol :: FEED , Protocol :: MAIL ])) {
// Collect all user contacts of the given public contact
$personal_contacts = DBA :: select ( 'contact' , [ 'id' , 'uid' ],
[ " `nurl` = ? AND `id` != ? AND NOT `self` " , $contact [ 'nurl' ], $cid ]);
while ( $personal_contact = DBA :: fetch ( $personal_contacts )) {
$cids [] = $personal_contact [ 'id' ];
$uids [] = $personal_contact [ 'uid' ];
}
DBA :: close ( $personal_contacts );
if ( ! empty ( $cids )) {
// Delete possibly existing cached user contact avatars
2021-10-11 14:21:10 +00:00
Photo :: delete ([ 'uid' => $uids , 'contact-id' => $cids , 'photo-type' => Photo :: CONTACT_AVATAR ]);
2017-11-29 22:29:11 +00:00
}
}
2020-08-21 18:41:48 +00:00
$cids [] = $cid ;
$uids [] = $uid ;
Logger :: info ( 'Updating cached contact avatars' , [ 'cid' => $cids , 'uid' => $uids , 'fields' => $fields ]);
2021-09-10 18:21:19 +00:00
self :: update ( $fields , [ 'id' => $cids ]);
2017-11-29 22:29:11 +00:00
}
2018-01-09 14:40:45 +00:00
2020-12-15 22:56:46 +00:00
public static function deleteContactByUrl ( string $url )
{
// Update contact data for all users
$condition = [ 'self' => false , 'nurl' => Strings :: normaliseLink ( $url )];
$contacts = DBA :: select ( 'contact' , [ 'id' , 'uid' ], $condition );
while ( $contact = DBA :: fetch ( $contacts )) {
Logger :: info ( 'Deleting contact' , [ 'id' => $contact [ 'id' ], 'uid' => $contact [ 'uid' ], 'url' => $url ]);
self :: remove ( $contact [ 'id' ]);
}
}
2020-01-19 09:46:31 +00:00
/**
2020-01-19 06:05:23 +00:00
* Helper function for " updateFromProbe " . Updates personal and public contact
2019-06-24 03:25:01 +00:00
*
2022-09-16 05:00:06 +00:00
* @ param integer $id contact id
* @ param integer $uid user id
* @ param integer $uri_id Uri - Id
* @ param string $url The profile URL of the contact
* @ param array $fields The fields that are updated
2019-08-27 23:22:09 +00:00
*
2019-06-24 03:25:01 +00:00
* @ throws \Exception
*/
2022-09-16 05:00:06 +00:00
private static function updateContact ( int $id , int $uid , int $uri_id , string $url , array $fields )
2019-06-24 03:25:01 +00:00
{
2021-09-10 18:21:19 +00:00
if ( ! self :: update ( $fields , [ 'id' => $id ])) {
2019-08-27 23:22:09 +00:00
Logger :: info ( 'Couldn\'t update contact.' , [ 'id' => $id , 'fields' => $fields ]);
return ;
}
2019-06-24 03:25:01 +00:00
2022-09-16 05:00:06 +00:00
self :: setAccountUser ( $id , $uid , $uri_id , $url );
2019-06-24 03:25:01 +00:00
2020-12-04 05:53:11 +00:00
// Archive or unarchive the contact.
2019-06-27 05:03:58 +00:00
$contact = DBA :: selectFirst ( 'contact' , [], [ 'id' => $id ]);
2019-08-27 23:22:09 +00:00
if ( ! DBA :: isResult ( $contact )) {
Logger :: info ( 'Couldn\'t select contact for archival.' , [ 'id' => $id ]);
return ;
}
2020-12-04 05:53:11 +00:00
if ( isset ( $fields [ 'failed' ])) {
if ( $fields [ 'failed' ]) {
self :: markForArchival ( $contact );
} else {
self :: unmarkForArchival ( $contact );
}
}
if ( $contact [ 'uid' ] != 0 ) {
return ;
2019-06-27 05:03:58 +00:00
}
2020-12-04 05:53:11 +00:00
// Update contact data for all users
2022-09-16 05:00:06 +00:00
$condition = [ 'self' => false , 'nurl' => Strings :: normaliseLink ( $url )];
2019-06-24 03:25:01 +00:00
2020-12-04 05:53:11 +00:00
$condition [ 'network' ] = [ Protocol :: DFRN , Protocol :: DIASPORA , Protocol :: ACTIVITYPUB ];
2021-09-10 18:21:19 +00:00
self :: update ( $fields , $condition );
2019-06-24 03:25:01 +00:00
2020-12-04 05:53:11 +00:00
// We mustn't set the update fields for OStatus contacts since they are updated in OnePoll
$condition [ 'network' ] = Protocol :: OSTATUS ;
2020-11-22 14:42:24 +00:00
// If the contact failed, propagate the update fields to all contacts
if ( empty ( $fields [ 'failed' ])) {
unset ( $fields [ 'last-update' ]);
unset ( $fields [ 'success_update' ]);
unset ( $fields [ 'failure_update' ]);
}
2019-06-24 03:25:01 +00:00
if ( empty ( $fields )) {
return ;
}
2021-09-10 18:21:19 +00:00
self :: update ( $fields , $condition );
2019-06-24 03:25:01 +00:00
}
2022-09-16 05:00:06 +00:00
/**
* Create or update an " account-user " entry
*
* @ param integer $id
* @ param integer $uid
* @ param integer $uri_id
* @ param string $url
* @ return void
*/
public static function setAccountUser ( int $id , int $uid , int $uri_id , string $url )
{
if ( empty ( $uri_id )) {
return ;
}
$account_user = DBA :: selectFirst ( 'account-user' , [ 'id' , 'uid' , 'uri-id' ], [ 'id' => $id ]);
if ( ! empty ( $account_user [ 'uri-id' ]) && ( $account_user [ 'uri-id' ] != $uri_id )) {
if ( $account_user [ 'uid' ] == $uid ) {
$ret = DBA :: update ( 'account-user' , [ 'uri-id' => $uri_id ], [ 'id' => $id ]);
Logger :: notice ( 'Updated account-user uri-id' , [ 'ret' => $ret , 'account-user' => $account_user , 'cid' => $id , 'uid' => $uid , 'uri-id' => $uri_id , 'url' => $url ]);
} else {
// This should never happen
Logger :: warning ( 'account-user exists for a different uri-id and uid' , [ 'account_user' => $account_user , 'id' => $id , 'uid' => $uid , 'uri-id' => $uri_id , 'url' => $url ]);
}
}
$account_user = DBA :: selectFirst ( 'account-user' , [ 'id' , 'uid' , 'uri-id' ], [ 'uid' => $uid , 'uri-id' => $uri_id ]);
if ( ! empty ( $account_user [ 'id' ])) {
if ( $account_user [ 'id' ] == $id ) {
Logger :: debug ( 'account-user already exists' , [ 'id' => $id , 'uid' => $uid , 'uri-id' => $uri_id , 'url' => $url ]);
return ;
} elseif ( ! DBA :: exists ( 'contact' , [ 'id' => $account_user [ 'id' ], 'deleted' => false ])) {
$ret = DBA :: update ( 'account-user' , [ 'id' => $id ], [ 'uid' => $uid , 'uri-id' => $uri_id ]);
Logger :: notice ( 'Updated account-user' , [ 'ret' => $ret , 'account-user' => $account_user , 'cid' => $id , 'uid' => $uid , 'uri-id' => $uri_id , 'url' => $url ]);
return ;
}
Logger :: warning ( 'account-user exists for a different contact id' , [ 'account_user' => $account_user , 'id' => $id , 'uid' => $uid , 'uri-id' => $uri_id , 'url' => $url ]);
2022-10-17 05:49:55 +00:00
Worker :: add ( Worker :: PRIORITY_HIGH , 'MergeContact' , $account_user [ 'id' ], $id , $uid );
2022-09-16 05:00:06 +00:00
} elseif ( DBA :: insert ( 'account-user' , [ 'id' => $id , 'uri-id' => $uri_id , 'uid' => $uid ], Database :: INSERT_IGNORE )) {
Logger :: notice ( 'account-user was added' , [ 'id' => $id , 'uid' => $uid , 'uri-id' => $uri_id , 'url' => $url ]);
} else {
Logger :: warning ( 'account-user was not added' , [ 'id' => $id , 'uid' => $uid , 'uri-id' => $uri_id , 'url' => $url ]);
}
}
2020-01-19 09:46:31 +00:00
/**
2020-01-19 06:05:23 +00:00
* Remove duplicated contacts
2019-07-12 14:55:23 +00:00
*
* @ param string $nurl Normalised contact url
* @ param integer $uid User id
2019-07-13 07:25:01 +00:00
* @ return boolean
2019-07-12 14:55:23 +00:00
* @ throws \Exception
*/
2019-08-30 05:52:21 +00:00
public static function removeDuplicates ( string $nurl , int $uid )
2019-07-12 14:55:23 +00:00
{
2021-09-10 13:05:16 +00:00
$condition = [ 'nurl' => $nurl , 'uid' => $uid , 'self' => false , 'deleted' => false , 'network' => Protocol :: FEDERATED ];
2019-07-12 14:55:23 +00:00
$count = DBA :: count ( 'contact' , $condition );
if ( $count <= 1 ) {
return false ;
}
2019-08-26 15:51:56 +00:00
$first_contact = DBA :: selectFirst ( 'contact' , [ 'id' , 'network' ], $condition , [ 'order' => [ 'id' ]]);
2019-07-12 14:55:23 +00:00
if ( ! DBA :: isResult ( $first_contact )) {
// Shouldn't happen - so we handle it
return false ;
}
$first = $first_contact [ 'id' ];
2019-08-29 05:22:29 +00:00
Logger :: info ( 'Found duplicates' , [ 'count' => $count , 'first' => $first , 'uid' => $uid , 'nurl' => $nurl ]);
2019-07-12 14:55:23 +00:00
// Find all duplicates
$condition = [ " `nurl` = ? AND `uid` = ? AND `id` != ? AND NOT `self` AND NOT `deleted` " , $nurl , $uid , $first ];
2019-08-26 15:51:56 +00:00
$duplicates = DBA :: select ( 'contact' , [ 'id' , 'network' ], $condition );
2019-07-12 14:55:23 +00:00
while ( $duplicate = DBA :: fetch ( $duplicates )) {
2019-08-26 15:51:56 +00:00
if ( ! in_array ( $duplicate [ 'network' ], Protocol :: FEDERATED )) {
continue ;
}
2019-07-12 14:55:23 +00:00
2022-10-17 05:49:55 +00:00
Worker :: add ( Worker :: PRIORITY_HIGH , 'MergeContact' , $first , $duplicate [ 'id' ], $uid );
2019-07-12 14:55:23 +00:00
}
2020-04-28 07:10:18 +00:00
DBA :: close ( $duplicates );
2021-02-28 17:56:56 +00:00
Logger :: info ( 'Duplicates handled' , [ 'uid' => $uid , 'nurl' => $nurl , 'callstack' => System :: callstack ( 20 )]);
2019-07-12 14:55:23 +00:00
return true ;
}
2018-01-09 14:40:45 +00:00
/**
2022-06-24 02:42:35 +00:00
* Updates contact record by provided id and optional network
*
2018-09-15 18:54:45 +00:00
* @ param integer $id contact id
* @ param string $network Optional network we are probing for
2018-01-09 14:40:45 +00:00
* @ return boolean
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-01-06 21:06:53 +00:00
* @ throws \ImagickException
2018-01-09 14:40:45 +00:00
*/
2020-08-06 18:53:45 +00:00
public static function updateFromProbe ( int $id , string $network = '' )
2020-08-06 04:51:20 +00:00
{
$contact = DBA :: selectFirst ( 'contact' , [ 'uid' , 'url' ], [ 'id' => $id ]);
if ( ! DBA :: isResult ( $contact )) {
return false ;
}
2020-08-06 18:53:45 +00:00
$ret = Probe :: uri ( $contact [ 'url' ], $network , $contact [ 'uid' ]);
2021-12-30 22:40:52 +00:00
if ( $ret [ 'network' ] == Protocol :: DIASPORA ) {
FContact :: updateFromProbeArray ( $ret );
}
2020-08-06 18:53:45 +00:00
return self :: updateFromProbeArray ( $id , $ret );
2020-08-06 04:51:20 +00:00
}
2022-08-13 09:01:48 +00:00
/**
* Checks if the given contact has got local data
*
* @ param int $id
* @ param array $contact
*
* @ return boolean
*/
private static function hasLocalData ( int $id , array $contact ) : bool
{
if ( ! empty ( $contact [ 'uri-id' ]) && DBA :: exists ( 'contact' , [ " `uri-id` = ? AND `uid` != ? " , $contact [ 'uri-id' ], 0 ])) {
// User contacts with the same uri-id exist
return true ;
} elseif ( DBA :: exists ( 'contact' , [ " `nurl` = ? AND `uid` != ? " , Strings :: normaliseLink ( $contact [ 'url' ]), 0 ])) {
// User contacts with the same nurl exists (compatibility mode for systems with missing uri-id values)
return true ;
}
if ( DBA :: exists ( 'post-tag' , [ 'cid' => $id ])) {
// Is tagged in a post
return true ;
}
if ( DBA :: exists ( 'user-contact' , [ 'cid' => $id ])) {
// Has got user-contact data
return true ;
}
if ( Post :: exists ([ 'author-id' => $id ])) {
// Posts with this author exist
return true ;
}
if ( Post :: exists ([ 'owner-id' => $id ])) {
// Posts with this owner exist
return true ;
}
if ( Post :: exists ([ 'causer-id' => $id ])) {
// Posts with this causer exist
return true ;
}
// We don't have got this contact locally
return false ;
}
2020-08-06 04:51:20 +00:00
/**
2022-06-24 02:42:35 +00:00
* Updates contact record by provided id and probed data
*
2020-08-06 04:51:20 +00:00
* @ param integer $id contact id
* @ param array $ret Probed data
* @ return boolean
* @ throws HTTPException\InternalServerErrorException
* @ throws \ImagickException
*/
2022-06-24 02:42:35 +00:00
private static function updateFromProbeArray ( int $id , array $ret ) : bool
2018-01-09 14:40:45 +00:00
{
/*
2018-01-11 08:37:11 +00:00
Warning : Never ever fetch the public key via Probe :: uri and write it into the contacts .
2019-06-24 03:25:01 +00:00
This will reliably kill your communication with old Friendica contacts .
2018-01-11 08:37:11 +00:00
*/
2018-01-09 14:40:45 +00:00
2019-07-04 19:31:42 +00:00
// These fields aren't updated by this routine:
2021-08-09 01:39:09 +00:00
// 'sensitive'
2019-07-04 19:31:42 +00:00
2022-01-09 10:43:23 +00:00
$fields = [ 'uid' , 'uri-id' , 'avatar' , 'header' , 'name' , 'nick' , 'location' , 'keywords' , 'about' , 'subscribe' ,
2021-07-09 06:37:45 +00:00
'manually-approve' , 'unsearchable' , 'url' , 'addr' , 'batch' , 'notify' , 'poll' , 'request' , 'confirm' , 'poco' ,
2022-08-13 09:01:48 +00:00
'network' , 'alias' , 'baseurl' , 'gsid' , 'forum' , 'prv' , 'contact-type' , 'pubkey' , 'last-item' , 'xmpp' , 'matrix' ,
'created' , 'last-update' ];
2018-07-20 12:19:26 +00:00
$contact = DBA :: selectFirst ( 'contact' , $fields , [ 'id' => $id ]);
2018-07-21 12:46:04 +00:00
if ( ! DBA :: isResult ( $contact )) {
2018-01-09 14:40:45 +00:00
return false ;
}
2021-05-26 09:24:37 +00:00
if ( self :: isLocal ( $ret [ 'url' ])) {
2021-07-04 12:35:48 +00:00
if ( $contact [ 'uid' ] == 0 ) {
Logger :: info ( 'Local contacts are not updated here.' );
} else {
self :: updateFromPublicContact ( $id , $contact );
}
2021-05-22 08:25:30 +00:00
return true ;
}
2020-12-15 22:56:46 +00:00
if ( ! empty ( $ret [ 'account-type' ]) && $ret [ 'account-type' ] == User :: ACCOUNT_TYPE_DELETED ) {
Logger :: info ( 'Deleted account' , [ 'id' => $id , 'url' => $ret [ 'url' ], 'ret' => $ret ]);
self :: remove ( $id );
// Delete all contacts with the same URL
self :: deleteContactByUrl ( $ret [ 'url' ]);
return true ;
}
2019-03-07 00:13:39 +00:00
$uid = $contact [ 'uid' ];
unset ( $contact [ 'uid' ]);
2021-07-09 04:38:36 +00:00
$uriid = $contact [ 'uri-id' ];
unset ( $contact [ 'uri-id' ]);
2019-07-12 21:07:47 +00:00
$pubkey = $contact [ 'pubkey' ];
unset ( $contact [ 'pubkey' ]);
2022-08-13 09:01:48 +00:00
$created = $contact [ 'created' ];
unset ( $contact [ 'created' ]);
$last_update = $contact [ 'last-update' ];
unset ( $contact [ 'last-update' ]);
2019-03-07 00:13:39 +00:00
$contact [ 'photo' ] = $contact [ 'avatar' ];
unset ( $contact [ 'avatar' ]);
2019-06-24 03:25:01 +00:00
$updated = DateTimeFormat :: utcNow ();
2019-04-09 11:28:45 +00:00
2022-08-13 09:01:48 +00:00
$has_local_data = self :: hasLocalData ( $id , $contact );
2022-09-18 13:40:44 +00:00
if ( ! Probe :: isProbable ( $ret [ 'network' ])) {
2022-08-13 09:01:48 +00:00
// Periodical checks are only done on federated contacts
$failed_next_update = null ;
$success_next_update = null ;
} elseif ( $has_local_data ) {
$failed_next_update = GServer :: getNextUpdateDate ( false , $created , $last_update , ! in_array ( $contact [ 'network' ], Protocol :: FEDERATED ));
$success_next_update = GServer :: getNextUpdateDate ( true , $created , $last_update , ! in_array ( $contact [ 'network' ], Protocol :: FEDERATED ));
} else {
$failed_next_update = DateTimeFormat :: utc ( 'now +6 month' );
$success_next_update = DateTimeFormat :: utc ( 'now +1 month' );
}
2021-08-29 20:25:21 +00:00
if ( Strings :: normaliseLink ( $contact [ 'url' ]) != Strings :: normaliseLink ( $ret [ 'url' ])) {
2021-08-30 12:29:09 +00:00
Logger :: notice ( 'New URL differs from old URL' , [ 'id' => $id , 'uid' => $uid , 'old' => $contact [ 'url' ], 'new' => $ret [ 'url' ]]);
2022-09-16 05:00:06 +00:00
self :: updateContact ( $id , $uid , $uriid , $contact [ 'url' ], [ 'failed' => true , 'local-data' => $has_local_data , 'last-update' => $updated , 'next-update' => $failed_next_update , 'failure_update' => $updated ]);
2021-08-29 20:25:21 +00:00
return false ;
}
2019-07-13 07:25:01 +00:00
// We must not try to update relay contacts via probe. They are no real contacts.
// We check after the probing to be able to correct falsely detected contact types.
if (( $contact [ 'contact-type' ] == self :: TYPE_RELAY ) &&
( ! Strings :: compareLink ( $ret [ 'url' ], $contact [ 'url' ]) || in_array ( $ret [ 'network' ], [ Protocol :: FEED , Protocol :: PHANTOM ]))) {
2022-09-16 05:00:06 +00:00
self :: updateContact ( $id , $uid , $uriid , $contact [ 'url' ], [ 'failed' => false , 'local-data' => $has_local_data , 'last-update' => $updated , 'next-update' => $success_next_update , 'success_update' => $updated ]);
2019-07-13 07:25:01 +00:00
Logger :: info ( 'Not updating relais' , [ 'id' => $id , 'url' => $contact [ 'url' ]]);
return true ;
}
2019-09-20 21:01:52 +00:00
// If Probe::uri fails the network code will be different ("feed" or "unkn")
2021-03-01 22:19:47 +00:00
if (( $ret [ 'network' ] == Protocol :: PHANTOM ) || (( $ret [ 'network' ] == Protocol :: FEED ) && ( $ret [ 'network' ] != $contact [ 'network' ]))) {
2022-09-16 05:00:06 +00:00
self :: updateContact ( $id , $uid , $uriid , $contact [ 'url' ], [ 'failed' => true , 'local-data' => $has_local_data , 'last-update' => $updated , 'next-update' => $failed_next_update , 'failure_update' => $updated ]);
2018-01-09 14:40:45 +00:00
return false ;
}
2021-07-08 13:47:46 +00:00
if ( Strings :: normaliseLink ( $ret [ 'url' ]) != Strings :: normaliseLink ( $contact [ 'url' ])) {
2021-07-17 04:57:21 +00:00
$cid = self :: getIdForURL ( $ret [ 'url' ], 0 , false );
2021-07-08 13:47:46 +00:00
if ( ! empty ( $cid ) && ( $cid != $id )) {
Logger :: notice ( 'URL of contact changed.' , [ 'id' => $id , 'new_id' => $cid , 'old' => $contact [ 'url' ], 'new' => $ret [ 'url' ]]);
return self :: updateFromProbeArray ( $cid , $ret );
}
}
2019-07-12 14:55:23 +00:00
if ( isset ( $ret [ 'hide' ]) && is_bool ( $ret [ 'hide' ])) {
$ret [ 'unsearchable' ] = $ret [ 'hide' ];
}
if ( isset ( $ret [ 'account-type' ]) && is_int ( $ret [ 'account-type' ])) {
2019-07-04 19:31:42 +00:00
$ret [ 'forum' ] = false ;
$ret [ 'prv' ] = false ;
$ret [ 'contact-type' ] = $ret [ 'account-type' ];
2020-09-02 07:14:01 +00:00
if (( $ret [ 'contact-type' ] == User :: ACCOUNT_TYPE_COMMUNITY ) && isset ( $ret [ 'manually-approve' ])) {
$ret [ 'forum' ] = ( bool ) ! $ret [ 'manually-approve' ];
$ret [ 'prv' ] = ( bool ) ! $ret [ 'forum' ];
2019-07-04 19:31:42 +00:00
}
}
2020-08-06 04:51:20 +00:00
$new_pubkey = $ret [ 'pubkey' ] ? ? '' ;
2022-08-03 03:38:03 +00:00
if ( $uid == 0 && DI :: config () -> get ( 'system' , 'fetch_featured_posts' )) {
2022-04-07 21:52:25 +00:00
if ( $ret [ 'network' ] == Protocol :: ACTIVITYPUB ) {
2022-05-15 09:08:35 +00:00
$apcontact = APContact :: getByURL ( $ret [ 'url' ], false );
if ( ! empty ( $apcontact [ 'featured' ])) {
2022-10-17 05:49:55 +00:00
Worker :: add ( Worker :: PRIORITY_LOW , 'FetchFeaturedPosts' , $ret [ 'url' ]);
2022-05-15 09:08:35 +00:00
}
2022-04-07 21:52:25 +00:00
}
2022-05-17 12:32:25 +00:00
2020-08-06 04:51:20 +00:00
$ret [ 'last-item' ] = Probe :: getLastUpdate ( $ret );
Logger :: info ( 'Fetched last item' , [ 'id' => $id , 'probed_url' => $ret [ 'url' ], 'last-item' => $ret [ 'last-item' ], 'callstack' => System :: callstack ( 20 )]);
}
2019-07-12 21:07:47 +00:00
2018-01-09 14:40:45 +00:00
$update = false ;
2021-10-04 06:26:41 +00:00
$guid = ( $ret [ 'guid' ] ? ? '' ) ? : Item :: guidFromUri ( $ret [ 'url' ], parse_url ( $ret [ 'url' ], PHP_URL_HOST ));
2018-01-09 14:40:45 +00:00
2022-01-09 05:49:11 +00:00
// make sure to not overwrite existing values with blank entries except some technical fields
$keep = [ 'batch' , 'notify' , 'poll' , 'request' , 'confirm' , 'poco' , 'baseurl' ];
foreach ( $ret as $key => $val ) {
if ( ! array_key_exists ( $key , $contact )) {
unset ( $ret [ $key ]);
} elseif (( $contact [ $key ] != '' ) && ( $val === '' ) && ! is_bool ( $ret [ $key ]) && ! in_array ( $key , $keep )) {
$ret [ $key ] = $contact [ $key ];
} elseif ( $ret [ $key ] != $contact [ $key ]) {
$update = true ;
}
}
if ( ! empty ( $ret [ 'last-item' ]) && ( $contact [ 'last-item' ] < $ret [ 'last-item' ])) {
$update = true ;
} else {
unset ( $ret [ 'last-item' ]);
}
if ( empty ( $uriid )) {
$update = true ;
}
if ( ! empty ( $ret [ 'photo' ]) && ( $ret [ 'network' ] != Protocol :: FEED )) {
self :: updateAvatar ( $id , $ret [ 'photo' ], $update );
}
2018-01-09 14:40:45 +00:00
if ( ! $update ) {
2022-09-16 05:00:06 +00:00
self :: updateContact ( $id , $uid , $uriid , $contact [ 'url' ], [ 'failed' => false , 'local-data' => $has_local_data , 'last-update' => $updated , 'next-update' => $success_next_update , 'success_update' => $updated ]);
2020-01-16 06:43:21 +00:00
2020-10-03 10:52:34 +00:00
if ( Contact\Relation :: isDiscoverable ( $ret [ 'url' ])) {
2022-10-17 05:49:55 +00:00
Worker :: add ( Worker :: PRIORITY_LOW , 'ContactDiscovery' , $ret [ 'url' ]);
2020-10-03 10:52:34 +00:00
}
2021-05-09 11:54:34 +00:00
2020-01-16 06:43:21 +00:00
// Update the public contact
if ( $uid != 0 ) {
2020-08-06 18:53:45 +00:00
$contact = self :: getByURL ( $ret [ 'url' ], false , [ 'id' ]);
if ( ! empty ( $contact [ 'id' ])) {
self :: updateFromProbeArray ( $contact [ 'id' ], $ret );
}
2020-01-16 06:43:21 +00:00
}
2018-01-09 14:40:45 +00:00
return true ;
}
2022-09-16 05:00:06 +00:00
$ret [ 'uri-id' ] = ItemURI :: insert ([ 'uri' => $ret [ 'url' ], 'guid' => $guid ]);
2022-08-13 09:01:48 +00:00
$ret [ 'nurl' ] = Strings :: normaliseLink ( $ret [ 'url' ]);
$ret [ 'updated' ] = $updated ;
$ret [ 'failed' ] = false ;
$ret [ 'next-update' ] = $success_next_update ;
$ret [ 'local-data' ] = $has_local_data ;
2019-06-24 03:25:01 +00:00
2019-07-12 21:07:47 +00:00
// Only fill the pubkey if it had been empty before. We have to prevent identity theft.
if ( empty ( $pubkey ) && ! empty ( $new_pubkey )) {
$ret [ 'pubkey' ] = $new_pubkey ;
}
2020-09-19 03:16:26 +00:00
if (( ! empty ( $ret [ 'addr' ]) && ( $ret [ 'addr' ] != $contact [ 'addr' ])) || ( ! empty ( $ret [ 'alias' ]) && ( $ret [ 'alias' ] != $contact [ 'alias' ]))) {
2021-07-12 06:25:48 +00:00
$ret [ 'uri-date' ] = $updated ;
2019-07-12 21:07:47 +00:00
}
2021-07-12 06:25:48 +00:00
if (( ! empty ( $ret [ 'name' ]) && ( $ret [ 'name' ] != $contact [ 'name' ])) || ( ! empty ( $ret [ 'nick' ]) && ( $ret [ 'nick' ] != $contact [ 'nick' ]))) {
2019-07-12 21:07:47 +00:00
$ret [ 'name-date' ] = $updated ;
}
2020-12-04 05:53:11 +00:00
if (( $uid == 0 ) || in_array ( $ret [ 'network' ], [ Protocol :: DFRN , Protocol :: DIASPORA , Protocol :: ACTIVITYPUB ])) {
2019-06-24 03:25:01 +00:00
$ret [ 'last-update' ] = $updated ;
$ret [ 'success_update' ] = $updated ;
}
2019-03-07 00:13:39 +00:00
unset ( $ret [ 'photo' ]);
2018-01-09 14:40:45 +00:00
2022-09-16 05:00:06 +00:00
self :: updateContact ( $id , $uid , $ret [ 'uri-id' ], $ret [ 'url' ], $ret );
2019-06-23 09:27:40 +00:00
2020-10-03 10:52:34 +00:00
if ( Contact\Relation :: isDiscoverable ( $ret [ 'url' ])) {
2022-10-17 05:49:55 +00:00
Worker :: add ( Worker :: PRIORITY_LOW , 'ContactDiscovery' , $ret [ 'url' ]);
2020-10-03 10:52:34 +00:00
}
2018-01-09 14:40:45 +00:00
return true ;
}
2021-07-04 12:35:48 +00:00
private static function updateFromPublicContact ( int $id , array $contact )
{
$public = self :: getByURL ( $contact [ 'url' ], false );
$fields = [];
foreach ( $contact as $field => $value ) {
if ( $field == 'uid' ) {
continue ;
}
if ( $public [ $field ] != $value ) {
$fields [ $field ] = $public [ $field ];
}
}
if ( ! empty ( $fields )) {
2021-09-10 18:21:19 +00:00
self :: update ( $fields , [ 'id' => $id , 'self' => false ]);
2021-07-04 12:35:48 +00:00
Logger :: info ( 'Updating local contact' , [ 'id' => $id ]);
}
}
2020-08-06 18:53:45 +00:00
/**
2022-06-24 02:42:35 +00:00
* Updates contact record by provided URL
*
2020-08-06 18:53:45 +00:00
* @ param integer $url contact url
* @ return integer Contact id
* @ throws HTTPException\InternalServerErrorException
* @ throws \ImagickException
*/
2022-06-24 01:01:13 +00:00
public static function updateFromProbeByURL ( string $url ) : int
2019-07-04 19:31:42 +00:00
{
$id = self :: getIdForURL ( $url );
if ( empty ( $id )) {
2019-07-12 14:55:23 +00:00
return $id ;
2019-07-04 19:31:42 +00:00
}
2020-08-06 18:53:45 +00:00
self :: updateFromProbe ( $id );
2019-07-12 14:55:23 +00:00
return $id ;
2019-07-04 19:31:42 +00:00
}
2019-05-02 13:05:31 +00:00
/**
* Detects the communication protocol for a given contact url .
* This is used to detect Friendica contacts that we can communicate via AP .
*
* @ param string $url contact url
* @ param string $network Network of that contact
* @ return string with protocol
*/
2022-06-24 01:01:13 +00:00
public static function getProtocol ( string $url , string $network ) : string
2019-05-02 13:05:31 +00:00
{
if ( $network != Protocol :: DFRN ) {
return $network ;
}
$apcontact = APContact :: getByURL ( $url );
if ( ! empty ( $apcontact ) && ! empty ( $apcontact [ 'generator' ])) {
return Protocol :: ACTIVITYPUB ;
} else {
return $network ;
}
}
2018-01-09 14:40:45 +00:00
/**
* Takes a $uid and a url / handle and adds a new contact
2020-01-19 09:55:28 +00:00
*
2018-01-09 14:40:45 +00:00
* Currently if the contact is DFRN , interactive needs to be true , to redirect to the
* dfrn_request page .
*
2018-01-11 08:37:11 +00:00
* Otherwise this can be used to bulk add StatusNet contacts , Twitter contacts , etc .
2018-01-09 14:40:45 +00:00
*
* Returns an array
* $return [ 'success' ] boolean true if successful
* $return [ 'message' ] error text if success is false .
*
2020-01-19 06:05:23 +00:00
* Takes a $uid and a url / handle and adds a new contact
2020-06-10 14:36:42 +00:00
*
2021-08-08 19:30:21 +00:00
* @ param int $uid The user id the contact should be created for
2020-06-10 14:36:42 +00:00
* @ param string $url The profile URL of the contact
2018-01-09 14:40:45 +00:00
* @ param string $network
2019-01-06 21:06:53 +00:00
* @ return array
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2020-06-10 14:36:42 +00:00
* @ throws HTTPException\NotFoundException
2019-01-06 21:06:53 +00:00
* @ throws \ImagickException
2018-01-09 14:40:45 +00:00
*/
2022-06-16 18:17:04 +00:00
public static function createFromProbeForUser ( int $uid , string $url , string $network = '' ) : array
2018-01-09 14:40:45 +00:00
{
2018-01-15 13:05:12 +00:00
$result = [ 'cid' => - 1 , 'success' => false , 'message' => '' ];
2018-01-09 14:40:45 +00:00
// remove ajax junk, e.g. Twitter
$url = str_replace ( '/#!/' , '/' , $url );
2018-01-27 16:13:41 +00:00
if ( ! Network :: isUrlAllowed ( $url )) {
2020-01-18 19:52:34 +00:00
$result [ 'message' ] = DI :: l10n () -> t ( 'Disallowed profile URL.' );
2018-01-09 14:40:45 +00:00
return $result ;
}
2018-01-27 16:13:41 +00:00
if ( Network :: isUrlBlocked ( $url )) {
2020-01-18 19:52:34 +00:00
$result [ 'message' ] = DI :: l10n () -> t ( 'Blocked domain' );
2018-01-09 14:40:45 +00:00
return $result ;
}
if ( ! $url ) {
2020-01-18 19:52:34 +00:00
$result [ 'message' ] = DI :: l10n () -> t ( 'Connect URL missing.' );
2018-01-09 14:40:45 +00:00
return $result ;
}
2018-01-15 13:05:12 +00:00
$arr = [ 'url' => $url , 'contact' => []];
2018-01-09 14:40:45 +00:00
2018-11-10 13:18:16 +00:00
Hook :: callAll ( 'follow' , $arr );
2018-01-09 14:40:45 +00:00
2018-01-30 18:51:09 +00:00
if ( empty ( $arr )) {
2020-01-18 19:52:34 +00:00
$result [ 'message' ] = DI :: l10n () -> t ( 'The contact could not be added. Please check the relevant network credentials in your Settings -> Social Networks page.' );
2018-01-30 18:51:09 +00:00
return $result ;
}
2018-11-30 14:06:22 +00:00
if ( ! empty ( $arr [ 'contact' ][ 'name' ])) {
2021-07-04 12:35:48 +00:00
$probed = false ;
2018-01-09 14:40:45 +00:00
$ret = $arr [ 'contact' ];
} else {
2021-09-17 18:36:20 +00:00
$probed = true ;
2021-08-08 19:30:21 +00:00
$ret = Probe :: uri ( $url , $network , $uid );
2022-05-25 11:43:29 +00:00
// Ensure that the public contact exists
2022-05-25 11:46:58 +00:00
if ( $ret [ 'network' ] != Protocol :: PHANTOM ) {
self :: getIdForURL ( $url );
}
2018-01-09 14:40:45 +00:00
}
if (( $network != '' ) && ( $ret [ 'network' ] != $network )) {
2021-10-20 18:53:52 +00:00
Logger :: notice ( 'Expected network ' . $network . ' does not match actual network ' . $ret [ 'network' ]);
2018-05-15 01:23:24 +00:00
return $result ;
2018-01-09 14:40:45 +00:00
}
2018-03-16 06:43:10 +00: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
2021-08-08 19:30:21 +00:00
$condition = [ 'uid' => $uid , 'poll' => [ $ret [ 'poll' ], Strings :: normaliseLink ( $ret [ 'poll' ])], 'network' => $ret [ 'network' ], 'pending' => false ];
2018-08-19 12:46:11 +00:00
$contact = DBA :: selectFirst ( 'contact' , [ 'id' , 'rel' ], $condition );
if ( ! DBA :: isResult ( $contact )) {
2021-08-08 19:30:21 +00:00
$condition = [ 'uid' => $uid , 'nurl' => Strings :: normaliseLink ( $ret [ 'url' ]), 'network' => $ret [ 'network' ], 'pending' => false ];
2018-08-19 12:46:11 +00:00
$contact = DBA :: selectFirst ( 'contact' , [ 'id' , 'rel' ], $condition );
2018-03-16 06:43:10 +00:00
}
2020-06-25 00:57:47 +00:00
$protocol = self :: getProtocol ( $ret [ 'url' ], $ret [ 'network' ]);
2019-05-02 13:05:31 +00:00
2018-01-09 14:40:45 +00:00
// This extra param just confuses things, remove it
2019-05-02 13:05:31 +00:00
if ( $protocol === Protocol :: DIASPORA ) {
2018-01-09 14:40:45 +00:00
$ret [ 'url' ] = str_replace ( '?absolute=true' , '' , $ret [ 'url' ]);
}
// do we have enough information?
2020-08-23 07:37:14 +00:00
if ( empty ( $protocol ) || ( $protocol == Protocol :: PHANTOM ) || ( empty ( $ret [ 'url' ]) && empty ( $ret [ 'addr' ]))) {
2022-10-18 12:29:50 +00:00
$result [ 'message' ] .= DI :: l10n () -> t ( 'The profile address specified does not provide adequate information.' ) . '<br />' ;
2018-11-30 14:06:22 +00:00
if ( empty ( $ret [ 'poll' ])) {
2022-10-18 12:29:50 +00:00
$result [ 'message' ] .= DI :: l10n () -> t ( 'No compatible communication protocols or feeds were discovered.' ) . '<br />' ;
2018-01-09 14:40:45 +00:00
}
2018-11-30 14:06:22 +00:00
if ( empty ( $ret [ 'name' ])) {
2022-10-18 12:29:50 +00:00
$result [ 'message' ] .= DI :: l10n () -> t ( 'An author or name was not found.' ) . '<br />' ;
2018-01-09 14:40:45 +00:00
}
2018-11-30 14:06:22 +00:00
if ( empty ( $ret [ 'url' ])) {
2022-10-18 12:29:50 +00:00
$result [ 'message' ] .= DI :: l10n () -> t ( 'No browser URL could be matched to this address.' ) . '<br />' ;
2018-01-09 14:40:45 +00:00
}
2020-06-25 00:57:47 +00:00
if ( strpos ( $ret [ 'url' ], '@' ) !== false ) {
2022-10-18 12:29:50 +00:00
$result [ 'message' ] .= DI :: l10n () -> t ( 'Unable to match @-style Identity Address with a known protocol or email contact.' ) . '<br />' ;
$result [ 'message' ] .= DI :: l10n () -> t ( 'Use mailto: in front of address to force email check.' ) . '<br />' ;
2018-01-09 14:40:45 +00:00
}
return $result ;
}
2020-01-19 20:21:13 +00:00
if ( $protocol === Protocol :: OSTATUS && DI :: config () -> get ( 'system' , 'ostatus_disabled' )) {
2022-10-18 12:29:50 +00:00
$result [ 'message' ] .= DI :: l10n () -> t ( 'The profile address specified belongs to a network which has been disabled on this site.' ) . '<br />' ;
2018-01-09 14:40:45 +00:00
$ret [ 'notify' ] = '' ;
}
if ( ! $ret [ 'notify' ]) {
2022-10-18 12:29:50 +00:00
$result [ 'message' ] .= DI :: l10n () -> t ( 'Limited profile. This person will be unable to receive direct/personal notifications from you.' ) . '<br />' ;
2018-01-09 14:40:45 +00:00
}
2019-05-02 13:05:31 +00:00
$writeable = ((( $protocol === Protocol :: OSTATUS ) && ( $ret [ 'notify' ])) ? 1 : 0 );
2018-01-09 14:40:45 +00:00
2019-05-02 13:05:31 +00:00
$subhub = (( $protocol === Protocol :: OSTATUS ) ? true : false );
2018-01-09 14:40:45 +00:00
2019-05-02 13:05:31 +00:00
$hidden = (( $protocol === Protocol :: MAIL ) ? 1 : 0 );
2018-01-09 14:40:45 +00:00
2019-11-02 16:24:54 +00:00
$pending = false ;
2020-09-02 07:14:01 +00:00
if (( $protocol == Protocol :: ACTIVITYPUB ) && isset ( $ret [ 'manually-approve' ])) {
$pending = ( bool ) $ret [ 'manually-approve' ];
2019-11-02 16:20:17 +00:00
}
2019-01-09 13:23:11 +00:00
2019-05-02 13:05:31 +00:00
if ( in_array ( $protocol , [ Protocol :: MAIL , Protocol :: DIASPORA , Protocol :: ACTIVITYPUB ])) {
2018-01-09 14:40:45 +00:00
$writeable = 1 ;
}
2018-08-19 12:46:11 +00:00
if ( DBA :: isResult ( $contact )) {
2018-01-09 14:40:45 +00:00
// update contact
2021-10-19 02:05:04 +00:00
$new_relation = ( in_array ( $contact [ 'rel' ], [ self :: FOLLOWER , self :: FRIEND ]) ? self :: FRIEND : self :: SHARING );
2018-01-09 14:40:45 +00:00
2018-01-15 13:05:12 +00:00
$fields = [ 'rel' => $new_relation , 'subhub' => $subhub , 'readonly' => false ];
2021-09-10 18:21:19 +00:00
self :: update ( $fields , [ 'id' => $contact [ 'id' ]]);
2018-01-09 14:40:45 +00:00
} else {
2019-05-02 13:05:31 +00:00
$new_relation = ( in_array ( $protocol , [ Protocol :: MAIL ]) ? self :: FRIEND : self :: SHARING );
2018-01-09 14:40:45 +00:00
// create contact record
2019-08-29 04:07:07 +00:00
self :: insert ([
2021-08-08 19:30:21 +00:00
'uid' => $uid ,
2018-01-27 02:38:34 +00:00
'created' => DateTimeFormat :: utcNow (),
2018-01-11 08:37:11 +00:00
'url' => $ret [ 'url' ],
2018-11-08 16:28:29 +00:00
'nurl' => Strings :: normaliseLink ( $ret [ 'url' ]),
2018-01-11 08:37:11 +00: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' ],
2019-07-04 04:08:55 +00:00
'baseurl' => $ret [ 'baseurl' ],
2020-05-22 04:19:32 +00:00
'gsid' => $ret [ 'gsid' ] ? ? null ,
2019-05-02 13:05:31 +00:00
'protocol' => $protocol ,
2018-01-11 08:37:11 +00:00
'pubkey' => $ret [ 'pubkey' ],
'rel' => $new_relation ,
'priority' => $ret [ 'priority' ],
'writable' => $writeable ,
'hidden' => $hidden ,
'blocked' => 0 ,
'readonly' => 0 ,
2019-01-09 13:23:11 +00:00
'pending' => $pending ,
2018-01-11 08:37:11 +00:00
'subhub' => $subhub
]);
2018-01-09 14:40:45 +00:00
}
2021-08-08 19:30:21 +00:00
$contact = DBA :: selectFirst ( 'contact' , [], [ 'url' => $ret [ 'url' ], 'network' => $ret [ 'network' ], 'uid' => $uid ]);
2018-07-21 12:46:04 +00:00
if ( ! DBA :: isResult ( $contact )) {
2022-10-18 12:29:50 +00:00
$result [ 'message' ] .= DI :: l10n () -> t ( 'Unable to retrieve contact information.' ) . '<br />' ;
2018-01-09 14:40:45 +00:00
return $result ;
}
2018-01-11 01:13:51 +00:00
$contact_id = $contact [ 'id' ];
2018-01-09 14:40:45 +00:00
$result [ 'cid' ] = $contact_id ;
2021-11-06 04:07:07 +00:00
Group :: addMember ( User :: getDefaultGroup ( $uid ), $contact_id );
2018-01-09 14:40:45 +00:00
// Update the avatar
2020-07-25 11:48:52 +00:00
self :: updateAvatar ( $contact_id , $ret [ 'photo' ]);
2018-01-09 14:40:45 +00:00
// pull feed and consume it, which should subscribe to the hub.
2020-12-04 05:53:11 +00:00
if ( $contact [ 'network' ] == Protocol :: OSTATUS ) {
2022-10-17 05:49:55 +00:00
Worker :: add ( Worker :: PRIORITY_HIGH , 'OnePoll' , $contact_id , 'force' );
2021-07-04 12:35:48 +00:00
}
if ( $probed ) {
self :: updateFromProbeArray ( $contact_id , $ret );
2020-12-04 05:53:11 +00:00
} else {
2022-10-17 05:49:55 +00:00
Worker :: add ( Worker :: PRIORITY_HIGH , 'UpdateContact' , $contact_id );
2020-12-04 05:53:11 +00:00
}
2018-01-09 14:40:45 +00:00
2021-11-07 05:57:18 +00:00
$result [ 'success' ] = Protocol :: follow ( $uid , $contact , $protocol );
2018-01-09 14:40:45 +00:00
return $result ;
}
2018-01-27 16:13:41 +00:00
2019-05-19 22:43:19 +00:00
/**
* @ param array $importer Owner ( local user ) data
* @ param array $contact Existing owner - specific contact data we want to expand the relationship with . Optional .
* @ param array $datarray An item - like array with at least the 'author-id' and 'author-url' keys for the contact . Mandatory .
* @ param bool $sharing True : Contact is now sharing with Owner ; False : Contact is now following Owner ( default )
* @ param string $note Introduction additional message
2019-05-19 22:46:29 +00:00
* @ return bool | null True : follow request is accepted ; False : relationship is rejected ; Null : relationship is pending
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-05-19 22:43:19 +00:00
* @ throws \ImagickException
*/
2022-06-16 18:17:04 +00:00
public static function addRelationship ( array $importer , array $contact , array $datarray , bool $sharing = false , string $note = '' )
2019-05-19 22:43:19 +00:00
{
2018-08-02 05:21:01 +00:00
// Should always be set
if ( empty ( $datarray [ 'author-id' ])) {
2019-05-19 22:46:29 +00:00
return false ;
2018-01-28 11:18:08 +00:00
}
2022-03-06 11:36:39 +00:00
$fields = [ 'id' , 'url' , 'name' , 'nick' , 'avatar' , 'photo' , 'network' , 'blocked' ];
2018-08-02 05:21:01 +00:00
$pub_contact = DBA :: selectFirst ( 'contact' , $fields , [ 'id' => $datarray [ 'author-id' ]]);
if ( ! DBA :: isResult ( $pub_contact )) {
// Should never happen
2019-05-19 22:46:29 +00:00
return false ;
2018-08-02 05:21:01 +00:00
}
2019-05-20 20:34:17 +00:00
// Contact is blocked at node-level
if ( self :: isBlocked ( $datarray [ 'author-id' ])) {
2019-05-19 22:46:58 +00:00
return false ;
}
2019-10-16 12:35:14 +00:00
$url = ( $datarray [ 'author-link' ] ? ? '' ) ? : $pub_contact [ 'url' ];
2018-08-02 05:21:01 +00:00
$name = $pub_contact [ 'name' ];
2019-10-16 12:35:14 +00:00
$photo = ( $pub_contact [ 'avatar' ] ? ? '' ) ? : $pub_contact [ " photo " ];
2018-08-02 05:21:01 +00:00
$nick = $pub_contact [ 'nick' ];
$network = $pub_contact [ 'network' ];
2019-08-26 15:51:56 +00:00
// Ensure that we don't create a new contact when there already is one
$cid = self :: getIdForURL ( $url , $importer [ 'uid' ]);
if ( ! empty ( $cid )) {
$contact = DBA :: selectFirst ( 'contact' , [], [ 'id' => $cid ]);
}
2022-05-17 12:32:25 +00:00
self :: clearFollowerFollowingEndpointCache ( $importer [ 'uid' ]);
2019-05-19 22:43:19 +00:00
if ( ! empty ( $contact )) {
2019-08-26 15:51:56 +00:00
if ( ! empty ( $contact [ 'pending' ])) {
Logger :: info ( 'Pending contact request already exists.' , [ 'url' => $url , 'uid' => $importer [ 'uid' ]]);
return null ;
}
2019-06-19 17:05:29 +00:00
// Contact is blocked at user-level
if ( ! empty ( $contact [ 'id' ]) && ! empty ( $importer [ 'id' ]) &&
2020-08-04 04:47:02 +00:00
Contact\User :: isBlocked ( $contact [ 'id' ], $importer [ 'id' ])) {
2019-06-19 17:05:29 +00:00
return false ;
}
2019-05-20 20:34:17 +00:00
2019-05-03 05:54:40 +00:00
// Make sure that the existing contact isn't archived
self :: unmarkForArchival ( $contact );
2018-07-25 02:53:46 +00:00
if (( $contact [ 'rel' ] == self :: SHARING )
|| ( $sharing && $contact [ 'rel' ] == self :: FOLLOWER )) {
2021-09-10 18:21:19 +00:00
self :: update ([ 'rel' => self :: FRIEND , 'writable' => true , 'pending' => false ],
2018-01-28 11:18:08 +00:00
[ 'id' => $contact [ 'id' ], 'uid' => $importer [ 'uid' ]]);
}
2018-09-15 18:54:45 +00:00
2019-09-21 12:39:07 +00:00
// Ensure to always have the correct network type, independent from the connection request method
2020-08-06 18:53:45 +00:00
self :: updateFromProbe ( $contact [ 'id' ]);
2019-09-21 12:39:07 +00:00
2022-03-03 13:49:07 +00:00
Post\UserNotification :: insertNotification ( $pub_contact [ 'id' ], Activity :: FOLLOW , $importer [ 'uid' ]);
2021-06-01 21:13:16 +00:00
2019-05-19 22:46:29 +00:00
return true ;
2018-01-28 11:18:08 +00:00
} else {
2019-05-19 22:43:19 +00:00
// send email notification to owner?
2018-11-08 16:28:29 +00:00
if ( DBA :: exists ( 'contact' , [ 'nurl' => Strings :: normaliseLink ( $url ), 'uid' => $importer [ 'uid' ], 'pending' => true ])) {
2021-10-20 18:53:52 +00:00
Logger :: notice ( 'ignoring duplicated connection request from pending contact ' . $url );
2019-05-19 22:46:29 +00:00
return null ;
2018-04-18 05:02:59 +00:00
}
2019-05-19 22:46:29 +00:00
2018-01-28 11:18:08 +00:00
// create contact record
2021-09-10 13:05:16 +00:00
$contact_id = self :: insert ([
2019-05-19 22:43:19 +00:00
'uid' => $importer [ 'uid' ],
'created' => DateTimeFormat :: utcNow (),
'url' => $url ,
'nurl' => Strings :: normaliseLink ( $url ),
'name' => $name ,
'nick' => $nick ,
'network' => $network ,
'rel' => self :: FOLLOWER ,
'blocked' => 0 ,
'readonly' => 0 ,
'pending' => 1 ,
'writable' => 1 ,
]);
2018-01-28 11:18:08 +00:00
2019-09-21 12:39:07 +00:00
// Ensure to always have the correct network type, independent from the connection request method
2020-08-06 18:53:45 +00:00
self :: updateFromProbe ( $contact_id );
2019-09-21 12:39:07 +00:00
2020-07-25 11:48:52 +00:00
self :: updateAvatar ( $contact_id , $photo , true );
2018-07-10 12:27:56 +00:00
2022-03-03 13:49:07 +00:00
Post\UserNotification :: insertNotification ( $pub_contact [ 'id' ], Activity :: FOLLOW , $importer [ 'uid' ]);
2021-06-01 21:13:16 +00:00
2019-09-21 12:39:07 +00:00
$contact_record = DBA :: selectFirst ( 'contact' , [ 'id' , 'network' , 'name' , 'url' , 'photo' ], [ 'id' => $contact_id ]);
2018-01-28 11:18:08 +00:00
/// @TODO Encapsulate this into a function/method
2018-02-14 05:05:00 +00:00
$fields = [ 'uid' , 'username' , 'email' , 'page-flags' , 'notify-flags' , 'language' ];
2018-07-20 12:19:26 +00:00
$user = DBA :: selectFirst ( 'user' , $fields , [ 'uid' => $importer [ 'uid' ]]);
2019-01-06 17:37:48 +00: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 11:18:08 +00:00
// create notification
if ( is_array ( $contact_record )) {
2021-10-18 20:49:25 +00:00
$intro = DI :: introFactory () -> createNew (
$importer [ 'uid' ],
$contact_record [ 'id' ],
$note
);
DI :: intro () -> save ( $intro );
2018-01-28 11:18:08 +00:00
}
2021-11-06 04:07:07 +00:00
Group :: addMember ( User :: getDefaultGroup ( $importer [ 'uid' ]), $contact_record [ 'id' ]);
2018-01-28 11:18:08 +00:00
2022-03-03 13:49:07 +00:00
if (( $user [ 'notify-flags' ] & Notification\Type :: INTRO ) && $user [ 'page-flags' ] == User :: PAGE_FLAGS_NORMAL ) {
2021-10-19 19:45:36 +00:00
DI :: notify () -> createFromArray ([
2021-01-23 09:53:44 +00:00
'type' => Notification\Type :: INTRO ,
'otype' => Notification\ObjectType :: INTRO ,
2020-11-25 19:56:39 +00:00
'verb' => ( $sharing ? Activity :: FRIEND : Activity :: FOLLOW ),
'uid' => $user [ 'uid' ],
'cid' => $contact_record [ 'id' ],
'link' => DI :: baseUrl () . '/notifications/intros' ,
2018-01-28 11:18:08 +00:00
]);
}
2019-01-06 17:37:48 +00:00
} elseif ( DBA :: isResult ( $user ) && in_array ( $user [ 'page-flags' ], [ User :: PAGE_FLAGS_SOAPBOX , User :: PAGE_FLAGS_FREELOVE , User :: PAGE_FLAGS_COMMUNITY ])) {
2020-03-07 23:19:19 +00:00
if (( $user [ 'page-flags' ] == User :: PAGE_FLAGS_FREELOVE ) && ( $network != Protocol :: DIASPORA )) {
2021-08-09 15:29:07 +00:00
self :: createFromProbeForUser ( $importer [ 'uid' ], $url , $network );
2020-03-07 23:19:19 +00:00
}
2018-08-19 12:46:11 +00:00
$condition = [ 'uid' => $importer [ 'uid' ], 'url' => $url , 'pending' => true ];
2020-03-07 23:19:19 +00:00
$fields = [ 'pending' => false ];
if ( $user [ 'page-flags' ] == User :: PAGE_FLAGS_FREELOVE ) {
2020-12-07 06:43:43 +00:00
$fields [ 'rel' ] = self :: FRIEND ;
2020-03-07 23:19:19 +00:00
}
2021-09-10 18:21:19 +00:00
self :: update ( $fields , $condition );
2018-10-05 06:35:50 +00:00
2019-05-19 22:46:29 +00:00
return true ;
2018-01-28 11:18:08 +00:00
}
}
2019-05-19 22:46:29 +00:00
return null ;
2018-01-28 11:18:08 +00:00
}
2021-10-17 01:09:49 +00:00
/**
* Update the local relationship when a local user loses a follower
*
* @ param array $contact User - specific contact ( uid != 0 ) array
2022-06-24 01:01:13 +00:00
* @ return void
2021-10-17 01:09:49 +00:00
* @ throws HTTPException\InternalServerErrorException
* @ throws \ImagickException
*/
2021-09-13 18:22:55 +00:00
public static function removeFollower ( array $contact )
2018-07-25 02:53:46 +00:00
{
2021-09-14 22:31:33 +00:00
if ( in_array ( $contact [ 'rel' ] ? ? [], [ self :: FRIEND , self :: SHARING ])) {
2022-02-21 15:16:38 +00:00
self :: update ([ 'rel' => self :: SHARING ], [ 'id' => $contact [ 'id' ]]);
2021-09-13 18:22:55 +00:00
} elseif ( ! empty ( $contact [ 'id' ])) {
2020-12-07 06:43:43 +00:00
self :: remove ( $contact [ 'id' ]);
2021-09-13 18:22:55 +00:00
} else {
2021-09-15 06:51:26 +00:00
DI :: logger () -> info ( 'Couldn\'t remove follower because of invalid contact array' , [ 'contact' => $contact , 'callstack' => System :: callstack ()]);
2022-04-26 18:33:58 +00:00
return ;
2018-01-28 11:18:08 +00:00
}
2022-03-06 11:36:39 +00:00
2022-05-17 12:32:25 +00:00
self :: clearFollowerFollowingEndpointCache ( $contact [ 'uid' ]);
2022-05-08 05:37:17 +00:00
$cdata = self :: getPublicAndUserContactID ( $contact [ 'id' ], $contact [ 'uid' ]);
2022-03-06 11:36:39 +00:00
2022-07-29 09:56:41 +00:00
DI :: notification () -> deleteForUserByVerb ( $contact [ 'uid' ], Activity :: FOLLOW , [ 'actor-id' => $cdata [ 'public' ]]);
2018-01-28 11:18:08 +00:00
}
2021-10-17 01:24:34 +00:00
/**
* Update the local relationship when a local user unfollow a contact .
* Removes the contact for sharing - only protocols ( feed and mail ) .
*
* @ param array $contact User - specific contact ( uid != 0 ) array
* @ throws HTTPException\InternalServerErrorException
*/
public static function removeSharer ( array $contact )
2018-07-25 02:53:46 +00:00
{
2022-05-17 12:32:25 +00:00
self :: clearFollowerFollowingEndpointCache ( $contact [ 'uid' ]);
2021-10-17 01:24:34 +00:00
if ( $contact [ 'rel' ] == self :: SHARING || in_array ( $contact [ 'network' ], [ Protocol :: FEED , Protocol :: MAIL ])) {
2020-12-07 06:43:43 +00:00
self :: remove ( $contact [ 'id' ]);
2021-10-17 01:24:34 +00:00
} else {
self :: update ([ 'rel' => self :: FOLLOWER ], [ 'id' => $contact [ 'id' ]]);
2018-01-28 11:18:08 +00:00
}
}
2018-01-25 01:47:33 +00:00
/**
2020-01-19 06:05:23 +00:00
* Create a birthday event .
2018-01-25 01:47:33 +00:00
*
* Update the year and the birthday .
*/
public static function updateBirthdays ()
{
2018-11-22 05:15:44 +00:00
$condition = [
2021-03-08 18:57:19 +00:00
' `bd` > ?
2018-11-22 05:15:44 +00:00
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` ' ,
2021-03-08 18:57:19 +00:00
DBA :: NULL_DATE ,
2020-12-07 06:43:43 +00:00
self :: SHARING ,
self :: FRIEND
2018-11-22 05:15:44 +00:00
];
$contacts = DBA :: select ( 'contact' , [ 'id' , 'uid' , 'name' , 'url' , 'bd' ], $condition );
while ( $contact = DBA :: fetch ( $contacts )) {
2021-10-20 18:53:52 +00:00
Logger :: notice ( 'update_contact_birthday: ' . $contact [ 'bd' ]);
2018-11-22 05:15:44 +00:00
$nextbd = DateTimeFormat :: utcNow ( 'Y' ) . substr ( $contact [ 'bd' ], 4 );
if ( Event :: createBirthday ( $contact , $nextbd )) {
2018-01-25 01:47:33 +00:00
// update bdyear
2018-11-22 05:15:44 +00:00
DBA :: update (
'contact' ,
[ 'bdyear' => substr ( $nextbd , 0 , 4 ), 'bd' => $nextbd ],
[ 'id' => $contact [ 'id' ]]
2018-01-25 01:47:33 +00:00
);
}
}
2020-04-28 07:10:18 +00:00
DBA :: close ( $contacts );
2018-01-25 01:47:33 +00:00
}
2018-02-26 00:45:04 +00:00
/**
* Remove the unavailable contact ids from the provided list
*
* @ param array $contact_ids Contact id list
2020-01-05 22:07:33 +00:00
* @ return array
2019-01-06 21:06:53 +00:00
* @ throws \Exception
2018-02-26 00:45:04 +00:00
*/
2022-06-16 18:17:04 +00:00
public static function pruneUnavailable ( array $contact_ids ) : array
2018-02-26 00:45:04 +00:00
{
if ( empty ( $contact_ids )) {
2020-01-05 22:07:33 +00:00
return [];
2018-02-26 00:45:04 +00:00
}
2020-12-07 06:43:43 +00:00
$contacts = self :: selectToArray ([ 'id' ], [
2020-01-05 22:07:33 +00:00
'id' => $contact_ids ,
'blocked' => false ,
'pending' => false ,
'archive' => false ,
]);
2018-03-03 12:41:49 +00:00
2020-01-05 22:07:33 +00:00
return array_column ( $contacts , 'id' );
2018-02-26 00:45:04 +00:00
}
2018-06-01 06:46:34 +00:00
/**
2020-01-19 06:05:23 +00:00
* Returns a magic link to authenticate remote visitors
2018-06-01 06:46:34 +00:00
*
2019-01-06 21:06:53 +00:00
* @ todo check if the return is either a fully qualified URL or a relative path to Friendica basedir
2018-10-19 23:00:01 +00:00
*
2018-06-01 06:46:34 +00:00
* @ param string $contact_url The address of the target contact profile
2019-01-06 21:06:53 +00:00
* @ param string $url An url that we will be redirected to after the authentication
2018-06-01 06:46:34 +00:00
*
* @ return string with " redir " link
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-01-06 21:06:53 +00:00
* @ throws \ImagickException
2018-06-01 06:46:34 +00:00
*/
2022-06-16 18:17:04 +00:00
public static function magicLink ( string $contact_url , string $url = '' ) : string
2018-06-01 06:46:34 +00:00
{
2022-10-20 20:14:50 +00:00
if ( ! DI :: userSession () -> isAuthenticated ()) {
2018-12-08 20:28:01 +00:00
return $url ? : $contact_url ; // Equivalent to: ($url != '') ? $url : $contact_url;
}
2020-08-07 13:49:59 +00:00
$contact = self :: getByURL ( $contact_url , false );
if ( empty ( $contact )) {
2018-06-02 13:00:47 +00:00
return $url ? : $contact_url ; // Equivalent to: ($url != '') ? $url : $contact_url;
2018-06-01 06:46:34 +00:00
}
2019-06-10 23:10:39 +00:00
// Prevents endless loop in case only a non-public contact exists for the contact URL
2020-08-07 13:49:59 +00:00
unset ( $contact [ 'uid' ]);
2019-06-10 23:10:39 +00:00
2020-08-07 13:49:59 +00:00
return self :: magicLinkByContact ( $contact , $url ? : $contact_url );
2018-06-01 06:46:34 +00:00
}
/**
2020-01-19 06:05:23 +00:00
* Returns a magic link to authenticate remote visitors
2018-06-01 06:46:34 +00:00
*
* @ param integer $cid The contact id of the target contact profile
2019-01-06 21:06:53 +00:00
* @ param string $url An url that we will be redirected to after the authentication
2018-06-01 06:46:34 +00:00
*
* @ return string with " redir " link
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-01-06 21:06:53 +00:00
* @ throws \ImagickException
2018-06-01 06:46:34 +00:00
*/
2022-06-16 18:17:04 +00:00
public static function magicLinkById ( int $cid , string $url = '' ) : string
2018-06-01 06:46:34 +00:00
{
2018-07-20 12:19:26 +00:00
$contact = DBA :: selectFirst ( 'contact' , [ 'id' , 'network' , 'url' , 'uid' ], [ 'id' => $cid ]);
2018-06-01 06:46:34 +00:00
2019-02-22 02:29:22 +00:00
return self :: magicLinkByContact ( $contact , $url );
2019-01-02 16:47:53 +00:00
}
2018-07-02 05:41:55 +00:00
/**
2020-01-19 06:05:23 +00:00
* Returns a magic link to authenticate remote visitors
2018-07-02 05:41:55 +00:00
*
2019-01-06 21:06:53 +00: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 05:41:55 +00:00
*
* @ return string with " redir " link
2020-03-09 15:11:06 +00:00
* @ throws HTTPException\InternalServerErrorException
2019-01-06 21:06:53 +00:00
* @ throws \ImagickException
2018-07-02 05:41:55 +00:00
*/
2022-06-16 18:17:04 +00:00
public static function magicLinkByContact ( array $contact , string $url = '' ) : string
2018-07-02 05:41:55 +00:00
{
2019-09-10 04:04:07 +00:00
$destination = $url ? : $contact [ 'url' ]; // Equivalent to ($url != '') ? $url : $contact['url'];
2022-10-20 20:14:50 +00:00
if ( ! DI :: userSession () -> isAuthenticated ()) {
2019-09-10 04:04:07 +00:00
return $destination ;
2018-06-01 06:46:34 +00:00
}
2018-06-02 08:42:46 +00: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 ;
}
2022-10-20 20:14:50 +00:00
if ( DI :: pConfig () -> get ( DI :: userSession () -> getLocalUserId (), 'system' , 'stay_local' ) && ( $url == '' )) {
2020-09-30 17:30:26 +00:00
return 'contact/' . $contact [ 'id' ] . '/conversations' ;
}
2021-02-17 18:59:19 +00:00
if ( ! empty ( $contact [ 'network' ]) && $contact [ 'network' ] != Protocol :: DFRN ) {
2020-09-30 17:30:26 +00:00
return $destination ;
}
2019-05-10 07:38:10 +00:00
if ( empty ( $contact [ 'id' ])) {
2019-09-10 04:04:07 +00:00
return $destination ;
2019-05-10 07:38:10 +00:00
}
2018-07-02 05:41:55 +00:00
$redirect = 'redir/' . $contact [ 'id' ];
2018-06-01 06:46:34 +00:00
2019-09-24 21:44:37 +00:00
if (( $url != '' ) && ! Strings :: compareLink ( $contact [ 'url' ], $url )) {
2018-06-01 06:46:34 +00:00
$redirect .= '?url=' . $url ;
}
return $redirect ;
2018-07-27 23:25:57 +00:00
}
2019-02-23 20:26:06 +00:00
2019-03-14 18:44:41 +00:00
/**
* Is the contact a forum ?
*
* @ param integer $contactid ID of the contact
*
* @ return boolean " true " if it is a forum
*/
2022-06-16 18:17:04 +00:00
public static function isForum ( int $contactid ) : bool
2019-03-14 18:44:41 +00:00
{
2022-02-09 06:52:16 +00:00
$fields = [ 'contact-type' ];
2019-03-14 18:44:41 +00:00
$condition = [ 'id' => $contactid ];
$contact = DBA :: selectFirst ( 'contact' , $fields , $condition );
if ( ! DBA :: isResult ( $contact )) {
return false ;
}
// Is it a forum?
2022-02-09 06:52:16 +00:00
return ( $contact [ 'contact-type' ] == self :: TYPE_COMMUNITY );
2019-03-14 18:44:41 +00:00
}
2019-06-11 01:29:11 +00:00
/**
* Can the remote contact receive private messages ?
*
* @ param array $contact
* @ return bool
*/
2022-06-16 18:17:04 +00:00
public static function canReceivePrivateMessages ( array $contact ) : bool
2019-06-11 01:29:11 +00:00
{
$protocol = $contact [ 'network' ] ? ? $contact [ 'protocol' ] ? ? Protocol :: PHANTOM ;
$self = $contact [ 'self' ] ? ? false ;
return in_array ( $protocol , [ Protocol :: DFRN , Protocol :: DIASPORA , Protocol :: ACTIVITYPUB ]) && ! $self ;
}
2020-07-30 14:08:32 +00:00
/**
* Search contact table by nick or name
*
* @ param string $search Name or nick
* @ param string $mode Search mode ( e . g . " community " )
2021-05-09 09:35:51 +00:00
* @ param int $uid User ID
2020-07-30 14:08:32 +00:00
*
* @ return array with search results
* @ throws \Friendica\Network\HTTPException\InternalServerErrorException
*/
2022-06-16 18:17:04 +00:00
public static function searchByName ( string $search , string $mode = '' , int $uid = 0 ) : array
2020-07-30 14:08:32 +00:00
{
if ( empty ( $search )) {
return [];
}
// check supported networks
2021-10-12 05:53:29 +00:00
$networks = [ Protocol :: DFRN , Protocol :: ACTIVITYPUB ];
2020-07-30 14:08:32 +00:00
if ( DI :: config () -> get ( 'system' , 'diaspora_enabled' )) {
2021-10-12 05:53:29 +00:00
$networks [] = Protocol :: DIASPORA ;
2020-07-30 14:08:32 +00:00
}
if ( ! DI :: config () -> get ( 'system' , 'ostatus_disabled' )) {
2021-10-12 05:53:29 +00:00
$networks [] = Protocol :: OSTATUS ;
2020-07-30 14:08:32 +00:00
}
2021-10-13 05:11:36 +00:00
$condition = [ 'network' => $networks , 'failed' => false , 'deleted' => false , 'uid' => $uid ];
2021-10-12 05:53:29 +00:00
2021-10-13 21:04:46 +00:00
if ( $uid == 0 ) {
$condition [ 'blocked' ] = false ;
}
2020-07-30 14:08:32 +00:00
// check if we search only communities or every contact
if ( $mode === 'community' ) {
2021-10-12 05:53:29 +00:00
$condition [ 'contact-type' ] = self :: TYPE_COMMUNITY ;
2020-07-30 14:08:32 +00:00
}
$search .= '%' ;
2021-10-12 05:53:29 +00:00
$condition = DBA :: mergeConditions ( $condition ,
2021-10-13 05:11:36 +00:00
[ " (NOT `unsearchable` OR `nurl` IN (SELECT `nurl` FROM `owner-view` WHERE `publish` OR `net-publish`))
2021-10-12 05:53:29 +00:00
AND ( `addr` LIKE ? OR `name` LIKE ? OR `nick` LIKE ? ) " , $search , $search , $search ]);
2020-07-30 14:08:32 +00:00
2021-10-12 05:53:29 +00:00
$contacts = self :: selectToArray ([], $condition );
2020-07-30 14:08:32 +00:00
return $contacts ;
}
2020-08-01 16:15:18 +00:00
/**
* Add public contacts from an array
*
* @ param array $urls
* @ return array result " count " , " added " and " updated "
*/
2022-06-16 18:17:04 +00:00
public static function addByUrls ( array $urls ) : array
2020-08-01 16:15:18 +00:00
{
$added = 0 ;
$updated = 0 ;
2020-10-03 10:52:34 +00:00
$unchanged = 0 ;
2020-08-01 16:15:18 +00:00
$count = 0 ;
foreach ( $urls as $url ) {
2021-03-25 05:45:16 +00:00
if ( empty ( $url ) || ! is_string ( $url )) {
continue ;
}
2022-09-18 13:40:44 +00:00
$contact = self :: getByURL ( $url , false , [ 'id' , 'network' , 'next-update' ]);
2022-09-06 06:04:41 +00:00
if ( empty ( $contact [ 'id' ]) && Network :: isValidHttpUrl ( $url )) {
2022-10-17 05:49:55 +00:00
Worker :: add ( Worker :: PRIORITY_LOW , 'AddContact' , 0 , $url );
2020-08-01 16:15:18 +00:00
++ $added ;
2022-09-24 14:18:41 +00:00
} elseif ( ! empty ( $contact [ 'network' ]) && Probe :: isProbable ( $contact [ 'network' ]) && ( $contact [ 'next-update' ] < DateTimeFormat :: utcNow ())) {
2022-10-17 05:49:55 +00:00
Worker :: add ([ 'priority' => Worker :: PRIORITY_LOW , 'dont_fork' => true ], 'UpdateContact' , $contact [ 'id' ]);
2020-08-01 16:15:18 +00:00
++ $updated ;
2020-10-03 10:52:34 +00:00
} else {
++ $unchanged ;
2020-08-01 16:15:18 +00:00
}
++ $count ;
}
2020-10-03 10:52:34 +00:00
return [ 'count' => $count , 'added' => $added , 'updated' => $updated , 'unchanged' => $unchanged ];
2020-08-01 16:15:18 +00:00
}
2020-08-02 08:07:31 +00:00
/**
2021-02-17 18:59:19 +00:00
* Returns a random , global contact array of the current node
2020-08-02 08:07:31 +00:00
*
2021-02-17 18:59:19 +00:00
* @ return array The profile array
2020-08-02 08:07:31 +00:00
* @ throws Exception
*/
2022-06-16 18:17:04 +00:00
public static function getRandomContact () : array
2020-08-02 08:07:31 +00:00
{
2021-02-17 18:59:19 +00:00
$contact = DBA :: selectFirst ( 'contact' , [ 'id' , 'network' , 'url' , 'uid' ], [
2020-08-02 08:07:31 +00:00
" `uid` = ? AND `network` = ? AND NOT `failed` AND `last-item` > ? " ,
0 , Protocol :: DFRN , DateTimeFormat :: utc ( 'now - 1 month' ),
], [ 'order' => [ 'RAND()' ]]);
2021-02-17 18:59:19 +00:00
if ( DBA :: isResult ( $contact )) {
return $contact ;
2020-08-02 08:07:31 +00:00
}
2021-02-17 18:59:19 +00:00
return [];
2020-08-02 08:07:31 +00:00
}
2017-11-19 21:55:28 +00:00
}