3 * @copyright Copyright (C) 2010-2023, the Friendica project
5 * @license GNU AGPL version 3 or any later version
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU Affero General Public License as
9 * published by the Free Software Foundation, either version 3 of the
10 * License, or (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU Affero General Public License for more details.
17 * You should have received a copy of the GNU Affero General Public License
18 * along with this program. If not, see <https://www.gnu.org/licenses/>.
22 namespace Friendica\Model;
24 use DivineOmega\DOFileCachePSR6\CacheItemPool;
25 use DivineOmega\PasswordExposed;
28 use Friendica\Content\Pager;
29 use Friendica\Core\Hook;
30 use Friendica\Core\L10n;
31 use Friendica\Core\Logger;
32 use Friendica\Core\Protocol;
33 use Friendica\Core\Search;
34 use Friendica\Core\System;
35 use Friendica\Core\Worker;
36 use Friendica\Database\DBA;
38 use Friendica\Network\HTTPClient\Client\HttpClientAccept;
39 use Friendica\Security\TwoFactor\Model\AppSpecificPassword;
40 use Friendica\Network\HTTPException;
41 use Friendica\Object\Image;
42 use Friendica\Protocol\Delivery;
43 use Friendica\Util\Crypto;
44 use Friendica\Util\DateTimeFormat;
45 use Friendica\Util\Images;
46 use Friendica\Util\Network;
47 use Friendica\Util\Proxy;
48 use Friendica\Util\Strings;
53 * This class handles User related functions
60 * PAGE_FLAGS_NORMAL is a typical personal profile account
61 * PAGE_FLAGS_SOAPBOX automatically approves all friend requests as Contact::SHARING, (readonly)
62 * PAGE_FLAGS_COMMUNITY automatically approves all friend requests as Contact::SHARING, but with
63 * write access to wall and comments (no email and not included in page owner's ACL lists)
64 * PAGE_FLAGS_FREELOVE automatically approves all friend requests as full friends (Contact::FRIEND).
68 const PAGE_FLAGS_NORMAL = 0;
69 const PAGE_FLAGS_SOAPBOX = 1;
70 const PAGE_FLAGS_COMMUNITY = 2;
71 const PAGE_FLAGS_FREELOVE = 3;
72 const PAGE_FLAGS_BLOG = 4;
73 const PAGE_FLAGS_PRVGROUP = 5;
81 * ACCOUNT_TYPE_PERSON - the account belongs to a person
82 * Associated page types: PAGE_FLAGS_NORMAL, PAGE_FLAGS_SOAPBOX, PAGE_FLAGS_FREELOVE
84 * ACCOUNT_TYPE_ORGANISATION - the account belongs to an organisation
85 * Associated page type: PAGE_FLAGS_SOAPBOX
87 * ACCOUNT_TYPE_NEWS - the account is a news reflector
88 * Associated page type: PAGE_FLAGS_SOAPBOX
90 * ACCOUNT_TYPE_COMMUNITY - the account is community forum
91 * Associated page types: PAGE_COMMUNITY, PAGE_FLAGS_PRVGROUP
93 * ACCOUNT_TYPE_RELAY - the account is a relay
94 * This will only be assigned to contacts, not to user accounts
97 const ACCOUNT_TYPE_PERSON = 0;
98 const ACCOUNT_TYPE_ORGANISATION = 1;
99 const ACCOUNT_TYPE_NEWS = 2;
100 const ACCOUNT_TYPE_COMMUNITY = 3;
101 const ACCOUNT_TYPE_RELAY = 4;
102 const ACCOUNT_TYPE_DELETED = 127;
107 private static $owner;
110 * Returns the numeric account type by their string
112 * @param string $accounttype as string constant
113 * @return int|null Numeric account type - or null when not set
115 public static function getAccountTypeByString(string $accounttype)
117 switch ($accounttype) {
119 return User::ACCOUNT_TYPE_PERSON;
122 return User::ACCOUNT_TYPE_ORGANISATION;
125 return User::ACCOUNT_TYPE_NEWS;
128 return User::ACCOUNT_TYPE_COMMUNITY;
135 * Fetch the system account
137 * @return array system account
139 public static function getSystemAccount(): array
141 $system = Contact::selectFirst([], ['self' => true, 'uid' => 0]);
142 if (!DBA::isResult($system)) {
143 self::createSystemAccount();
144 $system = Contact::selectFirst([], ['self' => true, 'uid' => 0]);
145 if (!DBA::isResult($system)) {
150 $system['sprvkey'] = $system['uprvkey'] = $system['prvkey'];
151 $system['spubkey'] = $system['upubkey'] = $system['pubkey'];
152 $system['nickname'] = $system['nick'];
153 $system['page-flags'] = User::PAGE_FLAGS_SOAPBOX;
154 $system['account-type'] = $system['contact-type'];
155 $system['guid'] = '';
156 $system['picdate'] = '';
157 $system['theme'] = '';
158 $system['publish'] = false;
159 $system['net-publish'] = false;
160 $system['hide-friends'] = true;
161 $system['hidewall'] = true;
162 $system['prv_keywords'] = '';
163 $system['pub_keywords'] = '';
164 $system['address'] = '';
165 $system['locality'] = '';
166 $system['region'] = '';
167 $system['postal-code'] = '';
168 $system['country-name'] = '';
169 $system['homepage'] = DI::baseUrl()->get();
170 $system['dob'] = '0000-00-00';
172 // Ensure that the user contains data
173 $user = DBA::selectFirst('user', ['prvkey', 'guid'], ['uid' => 0]);
174 if (empty($user['prvkey']) || empty($user['guid'])) {
176 'username' => $system['name'],
177 'nickname' => $system['nick'],
178 'register_date' => $system['created'],
179 'pubkey' => $system['pubkey'],
180 'prvkey' => $system['prvkey'],
181 'spubkey' => $system['spubkey'],
182 'sprvkey' => $system['sprvkey'],
183 'guid' => System::createUUID(),
185 'page-flags' => User::PAGE_FLAGS_SOAPBOX,
186 'account-type' => User::ACCOUNT_TYPE_RELAY,
189 DBA::update('user', $fields, ['uid' => 0]);
191 $system['guid'] = $fields['guid'];
193 $system['guid'] = $user['guid'];
200 * Create the system account
204 private static function createSystemAccount()
206 $system_actor_name = self::getActorName();
207 if (empty($system_actor_name)) {
211 $keys = Crypto::newKeypair(4096);
212 if ($keys === false) {
213 throw new Exception(DI::l10n()->t('SERIOUS ERROR: Generation of security keys failed.'));
218 'created' => DateTimeFormat::utcNow(),
220 'network' => Protocol::ACTIVITYPUB,
221 'name' => 'System Account',
222 'addr' => $system_actor_name . '@' . DI::baseUrl()->getHostname(),
223 'nick' => $system_actor_name,
224 'url' => DI::baseUrl() . '/friendica',
225 'pubkey' => $keys['pubkey'],
226 'prvkey' => $keys['prvkey'],
229 'contact-type' => Contact::TYPE_RELAY, // In AP this is translated to 'Application'
230 'name-date' => DateTimeFormat::utcNow(),
231 'uri-date' => DateTimeFormat::utcNow(),
232 'avatar-date' => DateTimeFormat::utcNow(),
234 'baseurl' => DI::baseUrl(),
237 $system['avatar'] = $system['photo'] = Contact::getDefaultAvatar($system, Proxy::SIZE_SMALL);
238 $system['thumb'] = Contact::getDefaultAvatar($system, Proxy::SIZE_THUMB);
239 $system['micro'] = Contact::getDefaultAvatar($system, Proxy::SIZE_MICRO);
240 $system['nurl'] = Strings::normaliseLink($system['url']);
241 $system['gsid'] = GServer::getID($system['baseurl']);
243 Contact::insert($system);
247 * Detect a usable actor name
249 * @return string actor account name
251 public static function getActorName(): string
253 $system_actor_name = DI::config()->get('system', 'actor_name');
254 if (!empty($system_actor_name)) {
255 $self = Contact::selectFirst(['nick'], ['uid' => 0, 'self' => true]);
256 if (!empty($self['nick'])) {
257 if ($self['nick'] != $system_actor_name) {
258 // Reset the actor name to the already used name
259 DI::config()->set('system', 'actor_name', $self['nick']);
260 $system_actor_name = $self['nick'];
263 return $system_actor_name;
266 // List of possible actor names
267 $possible_accounts = ['friendica', 'actor', 'system', 'internal'];
268 foreach ($possible_accounts as $name) {
269 if (!DBA::exists('user', ['nickname' => $name, 'account_removed' => false, 'account_expired' => false]) &&
270 !DBA::exists('userd', ['username' => $name])) {
271 DI::config()->set('system', 'actor_name', $name);
279 * Returns true if a user record exists with the provided id
286 public static function exists(int $uid): bool
288 return DBA::exists('user', ['uid' => $uid]);
292 * @param integer $uid
293 * @param array $fields
294 * @return array|boolean User record if it exists, false otherwise
297 public static function getById(int $uid, array $fields = [])
299 return !empty($uid) ? DBA::selectFirst('user', $fields, ['uid' => $uid]) : [];
303 * Returns a user record based on it's GUID
305 * @param string $guid The guid of the user
306 * @param array $fields The fields to retrieve
307 * @param bool $active True, if only active records are searched
309 * @return array|boolean User record if it exists, false otherwise
312 public static function getByGuid(string $guid, array $fields = [], bool $active = true)
315 $cond = ['guid' => $guid, 'account_expired' => false, 'account_removed' => false];
317 $cond = ['guid' => $guid];
320 return DBA::selectFirst('user', $fields, $cond);
324 * @param string $nickname
325 * @param array $fields
326 * @return array|boolean User record if it exists, false otherwise
329 public static function getByNickname(string $nickname, array $fields = [])
331 return DBA::selectFirst('user', $fields, ['nickname' => $nickname]);
335 * Returns the user id of a given profile URL
339 * @return integer user id
342 public static function getIdForURL(string $url): int
344 // Avoid database queries when the local node hostname isn't even part of the url.
345 if (!Contact::isLocal($url)) {
349 $self = Contact::selectFirst(['uid'], ['self' => true, 'nurl' => Strings::normaliseLink($url)]);
350 if (!empty($self['uid'])) {
354 $self = Contact::selectFirst(['uid'], ['self' => true, 'addr' => $url]);
355 if (!empty($self['uid'])) {
359 $self = Contact::selectFirst(['uid'], ['self' => true, 'alias' => [$url, Strings::normaliseLink($url)]]);
360 if (!empty($self['uid'])) {
368 * Get a user based on its email
370 * @param string $email
371 * @param array $fields
372 * @return array|boolean User record if it exists, false otherwise
375 public static function getByEmail(string $email, array $fields = [])
377 return DBA::selectFirst('user', $fields, ['email' => $email]);
381 * Fetch the user array of the administrator. The first one if there are several.
383 * @param array $fields
387 public static function getFirstAdmin(array $fields = []) : array
389 if (!empty(DI::config()->get('config', 'admin_nickname'))) {
390 return self::getByNickname(DI::config()->get('config', 'admin_nickname'), $fields);
393 return self::getAdminList()[0] ?? [];
397 * Get owner data by user id
400 * @param boolean $repairMissing Repair the owner data if it's missing
401 * @return boolean|array
404 public static function getOwnerDataById(int $uid, bool $repairMissing = true)
407 return self::getSystemAccount();
410 if (!empty(self::$owner[$uid])) {
411 return self::$owner[$uid];
414 $owner = DBA::selectFirst('owner-view', [], ['uid' => $uid]);
415 if (!DBA::isResult($owner)) {
416 if (!self::exists($uid) || !$repairMissing) {
419 if (!DBA::exists('profile', ['uid' => $uid])) {
420 DBA::insert('profile', ['uid' => $uid]);
422 if (!DBA::exists('contact', ['uid' => $uid, 'self' => true])) {
423 Contact::createSelfFromUserId($uid);
425 $owner = self::getOwnerDataById($uid, false);
428 if (empty($owner['nickname'])) {
432 if (!$repairMissing || $owner['account_expired']) {
436 // Check if the returned data is valid, otherwise fix it. See issue #6122
438 // Check for correct url and normalised nurl
439 $url = DI::baseUrl() . '/profile/' . $owner['nickname'];
440 $repair = empty($owner['network']) || ($owner['url'] != $url) || ($owner['nurl'] != Strings::normaliseLink($owner['url']));
443 // Check if "addr" is present and correct
444 $addr = $owner['nickname'] . '@' . substr(DI::baseUrl(), strpos(DI::baseUrl(), '://') + 3);
445 $repair = ($addr != $owner['addr']) || empty($owner['prvkey']) || empty($owner['pubkey']);
449 // Check if the avatar field is filled and the photo directs to the correct path
450 $avatar = Photo::selectFirst(['resource-id'], ['uid' => $uid, 'profile' => true]);
451 if (DBA::isResult($avatar)) {
452 $repair = empty($owner['avatar']) || !strpos($owner['photo'], $avatar['resource-id']);
457 Contact::updateSelfFromUserID($uid);
458 // Return the corrected data and avoid a loop
459 $owner = self::getOwnerDataById($uid, false);
462 self::$owner[$uid] = $owner;
467 * Get owner data by nick name
470 * @return boolean|array
473 public static function getOwnerDataByNick(string $nick)
475 $user = DBA::selectFirst('user', ['uid'], ['nickname' => $nick]);
477 if (!DBA::isResult($user)) {
481 return self::getOwnerDataById($user['uid']);
485 * Returns the default group for a given user and network
487 * @param int $uid User id
489 * @return int group id
492 public static function getDefaultGroup(int $uid): int
494 $user = DBA::selectFirst('user', ['def_gid'], ['uid' => $uid]);
495 if (DBA::isResult($user)) {
496 $default_group = $user["def_gid"];
501 return $default_group;
505 * Authenticate a user with a clear text password
507 * Returns the user id associated with a successful password authentication
509 * @param mixed $user_info
510 * @param string $password
511 * @param bool $third_party
512 * @return int User Id if authentication is successful
513 * @throws HTTPException\ForbiddenException
514 * @throws HTTPException\NotFoundException
516 public static function getIdFromPasswordAuthentication($user_info, string $password, bool $third_party = false): int
518 // Addons registered with the "authenticate" hook may create the user on the
519 // fly. `getAuthenticationInfo` will fail if the user doesn't exist yet. If
520 // the user doesn't exist, we should give the addons a chance to create the
521 // user in our database, if applicable, before re-throwing the exception if
524 $user = self::getAuthenticationInfo($user_info);
525 } catch (Exception $e) {
526 $username = (is_string($user_info) ? $user_info : $user_info['nickname'] ?? '');
528 // Addons can create users, and since this 'catch' branch should only
529 // execute if getAuthenticationInfo can't find an existing user, that's
530 // exactly what will happen here. Creating a numeric username would create
531 // abiguity with user IDs, possibly opening up an attack vector.
532 // So let's be very careful about that.
533 if (empty($username) || is_numeric($username)) {
537 return self::getIdFromAuthenticateHooks($username, $password);
540 if ($third_party && DI::pConfig()->get($user['uid'], '2fa', 'verified')) {
541 // Third-party apps can't verify two-factor authentication, we use app-specific passwords instead
542 if (AppSpecificPassword::authenticateUser($user['uid'], $password)) {
545 } elseif (strpos($user['password'], '$') === false) {
546 //Legacy hash that has not been replaced by a new hash yet
547 if (self::hashPasswordLegacy($password) === $user['password']) {
548 self::updatePasswordHashed($user['uid'], self::hashPassword($password));
552 } elseif (!empty($user['legacy_password'])) {
553 //Legacy hash that has been double-hashed and not replaced by a new hash yet
554 //Warning: `legacy_password` is not necessary in sync with the content of `password`
555 if (password_verify(self::hashPasswordLegacy($password), $user['password'])) {
556 self::updatePasswordHashed($user['uid'], self::hashPassword($password));
560 } elseif (password_verify($password, $user['password'])) {
562 if (password_needs_rehash($user['password'], PASSWORD_DEFAULT)) {
563 self::updatePasswordHashed($user['uid'], self::hashPassword($password));
568 return self::getIdFromAuthenticateHooks($user['nickname'], $password); // throws
571 throw new HTTPException\ForbiddenException(DI::l10n()->t('Login failed'));
575 * Try to obtain a user ID via "authenticate" hook addons
577 * Returns the user id associated with a successful password authentication
579 * @param string $username
580 * @param string $password
581 * @return int User Id if authentication is successful
582 * @throws HTTPException\ForbiddenException
584 public static function getIdFromAuthenticateHooks(string $username, string $password): int
587 'username' => $username,
588 'password' => $password,
589 'authenticated' => 0,
590 'user_record' => null
594 * An addon indicates successful login by setting 'authenticated' to non-zero value and returning a user record
595 * Addons should never set 'authenticated' except to indicate success - as hooks may be chained
596 * and later addons should not interfere with an earlier one that succeeded.
598 Hook::callAll('authenticate', $addon_auth);
600 if ($addon_auth['authenticated'] && $addon_auth['user_record']) {
601 return $addon_auth['user_record']['uid'];
604 throw new HTTPException\ForbiddenException(DI::l10n()->t('Login failed'));
608 * Returns authentication info from various parameters types
610 * User info can be any of the following:
613 * - User email or username or nickname
614 * - User array with at least the uid and the hashed password
616 * @param mixed $user_info
617 * @return array|null Null if not found/determined
618 * @throws HTTPException\NotFoundException
620 public static function getAuthenticationInfo($user_info)
624 if (is_object($user_info) || is_array($user_info)) {
625 if (is_object($user_info)) {
626 $user = (array) $user_info;
633 || !isset($user['password'])
634 || !isset($user['legacy_password'])
636 throw new Exception(DI::l10n()->t('Not enough information to authenticate'));
638 } elseif (is_int($user_info) || is_string($user_info)) {
639 if (is_int($user_info)) {
640 $user = DBA::selectFirst(
642 ['uid', 'nickname', 'password', 'legacy_password'],
646 'account_expired' => 0,
647 'account_removed' => 0,
652 $fields = ['uid', 'nickname', 'password', 'legacy_password'];
654 "(`email` = ? OR `username` = ? OR `nickname` = ?)
655 AND NOT `blocked` AND NOT `account_expired` AND NOT `account_removed` AND `verified`",
656 $user_info, $user_info, $user_info
658 $user = DBA::selectFirst('user', $fields, $condition);
661 if (!DBA::isResult($user)) {
662 throw new HTTPException\NotFoundException(DI::l10n()->t('User not found'));
670 * Update the day of the last activity of the given user
672 * @param integer $uid
675 public static function updateLastActivity(int $uid)
677 $user = User::getById($uid, ['last-activity']);
682 $current_day = DateTimeFormat::utcNow('Y-m-d');
684 if ($user['last-activity'] != $current_day) {
685 User::update(['last-activity' => $current_day], $uid);
686 // Set the last actitivy for all identities of the user
687 DBA::update('user', ['last-activity' => $current_day], ['parent-uid' => $uid, 'account_removed' => false]);
692 * Generates a human-readable random password
697 public static function generateNewPassword(): string
699 return ucfirst(Strings::getRandomName(8)) . random_int(1000, 9999);
703 * Checks if the provided plaintext password has been exposed or not
705 * @param string $password
709 public static function isPasswordExposed(string $password): bool
711 $cache = new CacheItemPool();
712 $cache->changeConfig([
713 'cacheDirectory' => System::getTempPath() . '/password-exposed-cache/',
717 $passwordExposedChecker = new PasswordExposed\PasswordExposedChecker(null, $cache);
719 return $passwordExposedChecker->passwordExposed($password) === PasswordExposed\PasswordStatus::EXPOSED;
720 } catch (Exception $e) {
721 Logger::error('Password Exposed Exception: ' . $e->getMessage(), [
722 'code' => $e->getCode(),
723 'file' => $e->getFile(),
724 'line' => $e->getLine(),
725 'trace' => $e->getTraceAsString()
733 * Legacy hashing function, kept for password migration purposes
735 * @param string $password
738 private static function hashPasswordLegacy(string $password): string
740 return hash('whirlpool', $password);
744 * Global user password hashing function
746 * @param string $password
750 public static function hashPassword(string $password): string
752 if (!trim($password)) {
753 throw new Exception(DI::l10n()->t('Password can\'t be empty'));
756 return password_hash($password, PASSWORD_DEFAULT);
760 * Allowed characters are a-z, A-Z, 0-9 and special characters except white spaces and accentuated letters.
762 * Password length is limited to 72 characters if the current default password hashing algorithm is Blowfish.
763 * From the manual: "Using the PASSWORD_BCRYPT as the algorithm, will result in the password parameter being
764 * truncated to a maximum length of 72 bytes."
766 * @see https://www.php.net/manual/en/function.password-hash.php#refsect1-function.password-hash-parameters
768 * @param string|null $delimiter Whether the regular expression is meant to be wrapper in delimiter characters
771 public static function getPasswordRegExp(string $delimiter = null): string
773 $allowed_characters = ':!"#$%&\'()*+,-./;<=>?@[\]^_`{|}~';
776 $allowed_characters = preg_quote($allowed_characters, $delimiter);
779 return '^[a-zA-Z0-9' . $allowed_characters . ']' . (PASSWORD_DEFAULT === PASSWORD_BCRYPT ? '{1,72}' : '+') . '$';
783 * Updates a user row with a new plaintext password
786 * @param string $password
790 public static function updatePassword(int $uid, string $password): bool
792 $password = trim($password);
794 if (empty($password)) {
795 throw new Exception(DI::l10n()->t('Empty passwords are not allowed.'));
798 if (!DI::config()->get('system', 'disable_password_exposed', false) && self::isPasswordExposed($password)) {
799 throw new Exception(DI::l10n()->t('The new password has been exposed in a public data dump, please choose another.'));
802 if (PASSWORD_DEFAULT === PASSWORD_BCRYPT && strlen($password) > 72) {
803 throw new Exception(DI::l10n()->t('The password length is limited to 72 characters.'));
806 if (!preg_match('/' . self::getPasswordRegExp('/') . '/', $password)) {
807 throw new Exception(DI::l10n()->t("The password can't contain white spaces nor accentuated letters"));
810 return self::updatePasswordHashed($uid, self::hashPassword($password));
814 * Updates a user row with a new hashed password.
815 * Empties the password reset token field just in case.
818 * @param string $pasword_hashed
822 private static function updatePasswordHashed(int $uid, string $pasword_hashed): bool
825 'password' => $pasword_hashed,
827 'pwdreset_time' => null,
828 'legacy_password' => false
830 return DBA::update('user', $fields, ['uid' => $uid]);
834 * Returns if the given uid is valid and in the admin list
841 public static function isSiteAdmin(int $uid): bool
843 return DBA::exists('user', [
845 'email' => self::getAdminEmailList()
850 * Checks if a nickname is in the list of the forbidden nicknames
852 * Check if a nickname is forbidden from registration on the node by the
853 * admin. Forbidden nicknames (e.g. role namess) can be configured in the
856 * @param string $nickname The nickname that should be checked
857 * @return boolean True is the nickname is blocked on the node
859 public static function isNicknameBlocked(string $nickname): bool
861 $forbidden_nicknames = DI::config()->get('system', 'forbidden_nicknames', '');
862 if (!empty($forbidden_nicknames)) {
863 $forbidden = explode(',', $forbidden_nicknames);
864 $forbidden = array_map('trim', $forbidden);
869 // Add the name of the internal actor to the "forbidden" list
870 $actor_name = self::getActorName();
871 if (!empty($actor_name)) {
872 $forbidden[] = $actor_name;
875 if (empty($forbidden)) {
879 // check if the nickname is in the list of blocked nicknames
880 if (in_array(strtolower($nickname), $forbidden)) {
889 * Get avatar link for given user
892 * @param string $size One of the Proxy::SIZE_* constants
893 * @return string avatar link
896 public static function getAvatarUrl(array $user, string $size = ''): string
898 if (empty($user['nickname'])) {
899 DI::logger()->warning('Missing user nickname key', ['trace' => System::callstack(20)]);
902 $url = DI::baseUrl() . '/photo/';
905 case Proxy::SIZE_MICRO:
909 case Proxy::SIZE_THUMB:
922 $photo = Photo::selectFirst(['type', 'created', 'edited', 'updated'], ["scale" => $scale, 'uid' => $user['uid'], 'profile' => true]);
923 if (!empty($photo)) {
924 $updated = max($photo['created'], $photo['edited'], $photo['updated']);
925 $mimetype = $photo['type'];
928 return $url . $user['nickname'] . Images::getExtensionByMimeType($mimetype) . ($updated ? '?ts=' . strtotime($updated) : '');
932 * Get banner link for given user
935 * @return string banner link
938 public static function getBannerUrl(array $user): string
940 if (empty($user['nickname'])) {
941 DI::logger()->warning('Missing user nickname key', ['trace' => System::callstack(20)]);
944 $url = DI::baseUrl() . '/photo/banner/';
949 $photo = Photo::selectFirst(['type', 'created', 'edited', 'updated'], ["scale" => 3, 'uid' => $user['uid'], 'photo-type' => Photo::USER_BANNER]);
950 if (!empty($photo)) {
951 $updated = max($photo['created'], $photo['edited'], $photo['updated']);
952 $mimetype = $photo['type'];
954 // Only for the RC phase: Don't return an image link for the default picture
958 return $url . $user['nickname'] . Images::getExtensionByMimeType($mimetype) . ($updated ? '?ts=' . strtotime($updated) : '');
962 * Catch-all user creation function
964 * Creates a user from the provided data array, either form fields or OpenID.
965 * Required: { username, nickname, email } or { openid_url }
967 * Performs the following:
968 * - Sends to the OpenId auth URL (if relevant)
969 * - Creates new key pairs for crypto
970 * - Create self-contact
971 * - Create profile image
975 * @throws ErrorException
976 * @throws HTTPException\InternalServerErrorException
977 * @throws ImagickException
980 public static function create(array $data): array
982 $return = ['user' => null, 'password' => ''];
984 $using_invites = DI::config()->get('system', 'invitation_only');
986 $invite_id = !empty($data['invite_id']) ? trim($data['invite_id']) : '';
987 $username = !empty($data['username']) ? trim($data['username']) : '';
988 $nickname = !empty($data['nickname']) ? trim($data['nickname']) : '';
989 $email = !empty($data['email']) ? trim($data['email']) : '';
990 $openid_url = !empty($data['openid_url']) ? trim($data['openid_url']) : '';
991 $photo = !empty($data['photo']) ? trim($data['photo']) : '';
992 $password = !empty($data['password']) ? trim($data['password']) : '';
993 $password1 = !empty($data['password1']) ? trim($data['password1']) : '';
994 $confirm = !empty($data['confirm']) ? trim($data['confirm']) : '';
995 $blocked = !empty($data['blocked']);
996 $verified = !empty($data['verified']);
997 $language = !empty($data['language']) ? trim($data['language']) : 'en';
999 $netpublish = $publish = !empty($data['profile_publish_reg']);
1001 if ($password1 != $confirm) {
1002 throw new Exception(DI::l10n()->t('Passwords do not match. Password unchanged.'));
1003 } elseif ($password1 != '') {
1004 $password = $password1;
1007 if ($using_invites) {
1009 throw new Exception(DI::l10n()->t('An invitation is required.'));
1012 if (!Register::existsByHash($invite_id)) {
1013 throw new Exception(DI::l10n()->t('Invitation could not be verified.'));
1017 /// @todo Check if this part is really needed. We should have fetched all this data in advance
1018 if (empty($username) || empty($email) || empty($nickname)) {
1020 if (!Network::isUrlValid($openid_url)) {
1021 throw new Exception(DI::l10n()->t('Invalid OpenID url'));
1023 $_SESSION['register'] = 1;
1024 $_SESSION['openid'] = $openid_url;
1026 $openid = new LightOpenID(DI::baseUrl()->getHostname());
1027 $openid->identity = $openid_url;
1028 $openid->returnUrl = DI::baseUrl() . '/openid';
1029 $openid->required = ['namePerson/friendly', 'contact/email', 'namePerson'];
1030 $openid->optional = ['namePerson/first', 'media/image/aspect11', 'media/image/default'];
1032 $authurl = $openid->authUrl();
1033 } catch (Exception $e) {
1034 throw new Exception(DI::l10n()->t('We encountered a problem while logging in with the OpenID you provided. Please check the correct spelling of the ID.') . '<br />' . DI::l10n()->t('The error message was:') . $e->getMessage(), 0, $e);
1036 System::externalRedirect($authurl);
1040 throw new Exception(DI::l10n()->t('Please enter the required information.'));
1043 if (!Network::isUrlValid($openid_url)) {
1047 // collapse multiple spaces in name
1048 $username = preg_replace('/ +/', ' ', $username);
1050 $username_min_length = max(1, min(64, intval(DI::config()->get('system', 'username_min_length', 3))));
1051 $username_max_length = max(1, min(64, intval(DI::config()->get('system', 'username_max_length', 48))));
1053 if ($username_min_length > $username_max_length) {
1054 Logger::error(DI::l10n()->t('system.username_min_length (%s) and system.username_max_length (%s) are excluding each other, swapping values.', $username_min_length, $username_max_length));
1055 $tmp = $username_min_length;
1056 $username_min_length = $username_max_length;
1057 $username_max_length = $tmp;
1060 if (mb_strlen($username) < $username_min_length) {
1061 throw new Exception(DI::l10n()->tt('Username should be at least %s character.', 'Username should be at least %s characters.', $username_min_length));
1064 if (mb_strlen($username) > $username_max_length) {
1065 throw new Exception(DI::l10n()->tt('Username should be at most %s character.', 'Username should be at most %s characters.', $username_max_length));
1068 // So now we are just looking for a space in the full name.
1069 $loose_reg = DI::config()->get('system', 'no_regfullname');
1071 $username = mb_convert_case($username, MB_CASE_TITLE, 'UTF-8');
1072 if (strpos($username, ' ') === false) {
1073 throw new Exception(DI::l10n()->t("That doesn't appear to be your full (First Last) name."));
1077 if (!Network::isEmailDomainAllowed($email)) {
1078 throw new Exception(DI::l10n()->t('Your email domain is not among those allowed on this site.'));
1081 if (!filter_var($email, FILTER_VALIDATE_EMAIL) || !Network::isEmailDomainValid($email)) {
1082 throw new Exception(DI::l10n()->t('Not a valid email address.'));
1084 if (self::isNicknameBlocked($nickname)) {
1085 throw new Exception(DI::l10n()->t('The nickname was blocked from registration by the nodes admin.'));
1088 if (DI::config()->get('system', 'block_extended_register', false) && DBA::exists('user', ['email' => $email])) {
1089 throw new Exception(DI::l10n()->t('Cannot use that email.'));
1092 // Disallow somebody creating an account using openid that uses the admin email address,
1093 // since openid bypasses email verification. We'll allow it if there is not yet an admin account.
1094 if (strlen($openid_url) && in_array(strtolower($email), self::getAdminEmailList())) {
1095 throw new Exception(DI::l10n()->t('Cannot use that email.'));
1098 $nickname = $data['nickname'] = strtolower($nickname);
1100 if (!preg_match('/^[a-z0-9][a-z0-9_]*$/', $nickname)) {
1101 throw new Exception(DI::l10n()->t('Your nickname can only contain a-z, 0-9 and _.'));
1104 // Check existing and deleted accounts for this nickname.
1106 DBA::exists('user', ['nickname' => $nickname])
1107 || DBA::exists('userd', ['username' => $nickname])
1109 throw new Exception(DI::l10n()->t('Nickname is already registered. Please choose another.'));
1112 $new_password = strlen($password) ? $password : User::generateNewPassword();
1113 $new_password_encoded = self::hashPassword($new_password);
1115 $return['password'] = $new_password;
1117 $keys = Crypto::newKeypair(4096);
1118 if ($keys === false) {
1119 throw new Exception(DI::l10n()->t('SERIOUS ERROR: Generation of security keys failed.'));
1122 $prvkey = $keys['prvkey'];
1123 $pubkey = $keys['pubkey'];
1125 // Create another keypair for signing/verifying salmon protocol messages.
1126 $sres = Crypto::newKeypair(512);
1127 $sprvkey = $sres['prvkey'];
1128 $spubkey = $sres['pubkey'];
1130 $insert_result = DBA::insert('user', [
1131 'guid' => System::createUUID(),
1132 'username' => $username,
1133 'password' => $new_password_encoded,
1135 'openid' => $openid_url,
1136 'nickname' => $nickname,
1137 'pubkey' => $pubkey,
1138 'prvkey' => $prvkey,
1139 'spubkey' => $spubkey,
1140 'sprvkey' => $sprvkey,
1141 'verified' => $verified,
1142 'blocked' => $blocked,
1143 'language' => $language,
1144 'timezone' => 'UTC',
1145 'register_date' => DateTimeFormat::utcNow(),
1146 'default-location' => ''
1149 if ($insert_result) {
1150 $uid = DBA::lastInsertId();
1151 $user = DBA::selectFirst('user', [], ['uid' => $uid]);
1153 throw new Exception(DI::l10n()->t('An error occurred during registration. Please try again.'));
1157 throw new Exception(DI::l10n()->t('An error occurred during registration. Please try again.'));
1160 // if somebody clicked submit twice very quickly, they could end up with two accounts
1161 // due to race condition. Remove this one.
1162 $user_count = DBA::count('user', ['nickname' => $nickname]);
1163 if ($user_count > 1) {
1164 DBA::delete('user', ['uid' => $uid]);
1166 throw new Exception(DI::l10n()->t('Nickname is already registered. Please choose another.'));
1169 $insert_result = DBA::insert('profile', [
1171 'name' => $username,
1172 'photo' => self::getAvatarUrl($user),
1173 'thumb' => self::getAvatarUrl($user, Proxy::SIZE_THUMB),
1174 'publish' => $publish,
1175 'net-publish' => $netpublish,
1177 if (!$insert_result) {
1178 DBA::delete('user', ['uid' => $uid]);
1180 throw new Exception(DI::l10n()->t('An error occurred creating your default profile. Please try again.'));
1183 // Create the self contact
1184 if (!Contact::createSelfFromUserId($uid)) {
1185 DBA::delete('user', ['uid' => $uid]);
1187 throw new Exception(DI::l10n()->t('An error occurred creating your self contact. Please try again.'));
1190 // Create a group with no members. This allows somebody to use it
1191 // right away as a default group for new contacts.
1192 $def_gid = Group::create($uid, DI::l10n()->t('Friends'));
1194 DBA::delete('user', ['uid' => $uid]);
1196 throw new Exception(DI::l10n()->t('An error occurred creating your default contact group. Please try again.'));
1199 $fields = ['def_gid' => $def_gid];
1200 if (DI::config()->get('system', 'newuser_private') && $def_gid) {
1201 $fields['allow_gid'] = '<' . $def_gid . '>';
1204 DBA::update('user', $fields, ['uid' => $uid]);
1206 // if we have no OpenID photo try to look up an avatar
1207 if (!strlen($photo)) {
1208 $photo = Network::lookupAvatarByEmail($email);
1211 // unless there is no avatar-addon loaded
1212 if (strlen($photo)) {
1213 $photo_failure = false;
1215 $filename = basename($photo);
1216 $curlResult = DI::httpClient()->get($photo, HttpClientAccept::IMAGE);
1217 if ($curlResult->isSuccess()) {
1218 Logger::debug('Got picture', ['Content-Type' => $curlResult->getHeader('Content-Type'), 'url' => $photo]);
1219 $img_str = $curlResult->getBody();
1220 $type = $curlResult->getContentType();
1226 $type = Images::getMimeTypeByData($img_str, $photo, $type);
1228 $image = new Image($img_str, $type);
1229 if ($image->isValid()) {
1230 $image->scaleToSquare(300);
1232 $resource_id = Photo::newResource();
1234 // Not using Photo::PROFILE_PHOTOS here, so that it is discovered as translateble string
1235 $profile_album = DI::l10n()->t('Profile Photos');
1237 $r = Photo::store($image, $uid, 0, $resource_id, $filename, $profile_album, 4);
1240 $photo_failure = true;
1243 $image->scaleDown(80);
1245 $r = Photo::store($image, $uid, 0, $resource_id, $filename, $profile_album, 5);
1248 $photo_failure = true;
1251 $image->scaleDown(48);
1253 $r = Photo::store($image, $uid, 0, $resource_id, $filename, $profile_album, 6);
1256 $photo_failure = true;
1259 if (!$photo_failure) {
1260 Photo::update(['profile' => true, 'photo-type' => Photo::USER_AVATAR], ['resource-id' => $resource_id]);
1264 Contact::updateSelfFromUserID($uid, true);
1267 Hook::callAll('register_account', $uid);
1269 $return['user'] = $user;
1274 * Update a user entry and distribute the changes if needed
1276 * @param array $fields
1277 * @param integer $uid
1280 public static function update(array $fields, int $uid): bool
1282 $old_owner = self::getOwnerDataById($uid);
1283 if (empty($old_owner)) {
1287 if (!DBA::update('user', $fields, ['uid' => $uid])) {
1291 $update = Contact::updateSelfFromUserID($uid);
1293 $owner = self::getOwnerDataById($uid);
1294 if (empty($owner)) {
1298 if ($old_owner['name'] != $owner['name']) {
1299 Profile::update(['name' => $owner['name']], $uid);
1303 Profile::publishUpdate($uid);
1310 * Sets block state for a given user
1312 * @param int $uid The user id
1313 * @param bool $block Block state (default is true)
1315 * @return bool True, if successfully blocked
1319 public static function block(int $uid, bool $block = true): bool
1321 return DBA::update('user', ['blocked' => $block], ['uid' => $uid]);
1325 * Allows a registration based on a hash
1327 * @param string $hash
1329 * @return bool True, if the allow was successful
1331 * @throws HTTPException\InternalServerErrorException
1334 public static function allow(string $hash): bool
1336 $register = Register::getByHash($hash);
1337 if (!DBA::isResult($register)) {
1341 $user = User::getById($register['uid']);
1342 if (!DBA::isResult($user)) {
1346 Register::deleteByHash($hash);
1348 DBA::update('user', ['blocked' => false, 'verified' => true], ['uid' => $register['uid']]);
1350 $profile = DBA::selectFirst('profile', ['net-publish'], ['uid' => $register['uid']]);
1352 if (DBA::isResult($profile) && $profile['net-publish'] && Search::getGlobalDirectory()) {
1353 $url = DI::baseUrl() . '/profile/' . $user['nickname'];
1354 Worker::add(Worker::PRIORITY_LOW, "Directory", $url);
1357 $l10n = DI::l10n()->withLang($register['language']);
1359 return User::sendRegisterOpenEmail(
1362 DI::config()->get('config', 'sitename'),
1363 DI::baseUrl()->get(),
1364 ($register['password'] ?? '') ?: 'Sent in a previous email'
1369 * Denys a pending registration
1371 * @param string $hash The hash of the pending user
1373 * This does not have to go through user_remove() and save the nickname
1374 * permanently against re-registration, as the person was not yet
1375 * allowed to have friends on this system
1377 * @return bool True, if the deny was successfull
1380 public static function deny(string $hash): bool
1382 $register = Register::getByHash($hash);
1383 if (!DBA::isResult($register)) {
1387 $user = User::getById($register['uid']);
1388 if (!DBA::isResult($user)) {
1392 // Delete the avatar
1393 Photo::delete(['uid' => $register['uid']]);
1395 return DBA::delete('user', ['uid' => $register['uid']]) &&
1396 Register::deleteByHash($register['hash']);
1400 * Creates a new user based on a minimal set and sends an email to this user
1402 * @param string $name The user's name
1403 * @param string $email The user's email address
1404 * @param string $nick The user's nick name
1405 * @param string $lang The user's language (default is english)
1406 * @return bool True, if the user was created successfully
1407 * @throws HTTPException\InternalServerErrorException
1408 * @throws ErrorException
1409 * @throws ImagickException
1411 public static function createMinimal(string $name, string $email, string $nick, string $lang = L10n::DEFAULT): bool
1416 throw new HTTPException\InternalServerErrorException('Invalid arguments.');
1419 $result = self::create([
1420 'username' => $name,
1422 'nickname' => $nick,
1427 $user = $result['user'];
1428 $preamble = Strings::deindent(DI::l10n()->t('
1430 the administrator of %2$s has set up an account for you.'));
1431 $body = Strings::deindent(DI::l10n()->t('
1432 The login details are as follows:
1438 You may change your password from your account "Settings" page after logging
1441 Please take a few moments to review the other account settings on that page.
1443 You may also wish to add some basic information to your default profile
1444 (on the "Profiles" page) so that other people can easily find you.
1446 We recommend setting your full name, adding a profile photo,
1447 adding some profile "keywords" (very useful in making new friends) - and
1448 perhaps what country you live in; if you do not wish to be more specific
1451 We fully respect your right to privacy, and none of these items are necessary.
1452 If you are new and do not know anybody here, they may help
1453 you to make some new and interesting friends.
1455 If you ever want to delete your account, you can do so at %1$s/settings/removeme
1457 Thank you and welcome to %4$s.'));
1459 $preamble = sprintf($preamble, $user['username'], DI::config()->get('config', 'sitename'));
1460 $body = sprintf($body, DI::baseUrl()->get(), $user['nickname'], $result['password'], DI::config()->get('config', 'sitename'));
1462 $email = DI::emailer()
1464 ->withMessage(DI::l10n()->t('Registration details for %s', DI::config()->get('config', 'sitename')), $preamble, $body)
1466 ->withRecipient($user['email'])
1468 return DI::emailer()->send($email);
1472 * Sends pending registration confirmation email
1474 * @param array $user User record array
1475 * @param string $sitename
1476 * @param string $siteurl
1477 * @param string $password Plaintext password
1478 * @return NULL|boolean from notification() and email() inherited
1479 * @throws HTTPException\InternalServerErrorException
1481 public static function sendRegisterPendingEmail(array $user, string $sitename, string $siteurl, string $password)
1483 $body = Strings::deindent(DI::l10n()->t(
1486 Thank you for registering at %2$s. Your account is pending for approval by the administrator.
1488 Your login details are as follows:
1501 $email = DI::emailer()
1503 ->withMessage(DI::l10n()->t('Registration at %s', $sitename), $body)
1505 ->withRecipient($user['email'])
1507 return DI::emailer()->send($email);
1511 * Sends registration confirmation
1513 * It's here as a function because the mail is sent from different parts
1515 * @param L10n $l10n The used language
1516 * @param array $user User record array
1517 * @param string $sitename
1518 * @param string $siteurl
1519 * @param string $password Plaintext password
1521 * @return NULL|boolean from notification() and email() inherited
1522 * @throws HTTPException\InternalServerErrorException
1524 public static function sendRegisterOpenEmail(L10n $l10n, array $user, string $sitename, string $siteurl, string $password)
1526 $preamble = Strings::deindent($l10n->t(
1529 Thank you for registering at %2$s. Your account has been created.
1534 $body = Strings::deindent($l10n->t(
1536 The login details are as follows:
1542 You may change your password from your account "Settings" page after logging
1545 Please take a few moments to review the other account settings on that page.
1547 You may also wish to add some basic information to your default profile
1548 ' . "\x28" . 'on the "Profiles" page' . "\x29" . ' so that other people can easily find you.
1550 We recommend setting your full name, adding a profile photo,
1551 adding some profile "keywords" ' . "\x28" . 'very useful in making new friends' . "\x29" . ' - and
1552 perhaps what country you live in; if you do not wish to be more specific
1555 We fully respect your right to privacy, and none of these items are necessary.
1556 If you are new and do not know anybody here, they may help
1557 you to make some new and interesting friends.
1559 If you ever want to delete your account, you can do so at %3$s/settings/removeme
1561 Thank you and welcome to %2$s.',
1569 $email = DI::emailer()
1571 ->withMessage(DI::l10n()->t('Registration details for %s', $sitename), $preamble, $body)
1573 ->withRecipient($user['email'])
1575 return DI::emailer()->send($email);
1579 * @param int $uid user to remove
1581 * @throws HTTPException\InternalServerErrorException
1583 public static function remove(int $uid): bool
1589 Logger::notice('Removing user', ['user' => $uid]);
1591 $user = DBA::selectFirst('user', [], ['uid' => $uid]);
1593 Hook::callAll('remove_user', $user);
1595 // save username (actually the nickname as it is guaranteed
1596 // unique), so it cannot be re-registered in the future.
1597 DBA::insert('userd', ['username' => $user['nickname']]);
1599 // Remove all personal settings, especially connector settings
1600 DBA::delete('pconfig', ['uid' => $uid]);
1602 // The user and related data will be deleted in Friendica\Worker\ExpireAndRemoveUsers
1603 DBA::update('user', ['account_removed' => true, 'account_expires_on' => DateTimeFormat::utc('now + 7 day')], ['uid' => $uid]);
1604 Worker::add(Worker::PRIORITY_HIGH, 'Notifier', Delivery::REMOVAL, $uid);
1606 // Send an update to the directory
1607 $self = DBA::selectFirst('contact', ['url'], ['uid' => $uid, 'self' => true]);
1608 Worker::add(Worker::PRIORITY_LOW, 'Directory', $self['url']);
1610 // Remove the user relevant data
1611 Worker::add(Worker::PRIORITY_NEGLIGIBLE, 'RemoveUser', $uid);
1617 * Return all identities to a user
1619 * @param int $uid The user id
1620 * @return array All identities for this user
1622 * Example for a return:
1626 * 'username' => 'maxmuster',
1627 * 'nickname' => 'Max Mustermann'
1631 * 'username' => 'johndoe',
1632 * 'nickname' => 'John Doe'
1637 public static function identities(int $uid): array
1645 $user = DBA::selectFirst('user', ['uid', 'nickname', 'username', 'parent-uid'], ['uid' => $uid]);
1646 if (!DBA::isResult($user)) {
1650 if ($user['parent-uid'] == 0) {
1651 // First add our own entry
1653 'uid' => $user['uid'],
1654 'username' => $user['username'],
1655 'nickname' => $user['nickname']
1658 // Then add all the children
1661 ['uid', 'username', 'nickname'],
1662 ['parent-uid' => $user['uid'], 'account_removed' => false]
1664 if (DBA::isResult($r)) {
1665 $identities = array_merge($identities, DBA::toArray($r));
1668 // First entry is our parent
1671 ['uid', 'username', 'nickname'],
1672 ['uid' => $user['parent-uid'], 'account_removed' => false]
1674 if (DBA::isResult($r)) {
1675 $identities = DBA::toArray($r);
1678 // Then add all siblings
1681 ['uid', 'username', 'nickname'],
1682 ['parent-uid' => $user['parent-uid'], 'account_removed' => false]
1684 if (DBA::isResult($r)) {
1685 $identities = array_merge($identities, DBA::toArray($r));
1690 "SELECT `user`.`uid`, `user`.`username`, `user`.`nickname`
1692 INNER JOIN `user` ON `manage`.`mid` = `user`.`uid`
1693 WHERE `user`.`account_removed` = 0 AND `manage`.`uid` = ?",
1696 if (DBA::isResult($r)) {
1697 $identities = array_merge($identities, DBA::toArray($r));
1704 * Check if the given user id has delegations or is delegated
1709 public static function hasIdentities(int $uid): bool
1715 $user = DBA::selectFirst('user', ['parent-uid'], ['uid' => $uid, 'account_removed' => false]);
1716 if (!DBA::isResult($user)) {
1720 if ($user['parent-uid'] != 0) {
1724 if (DBA::exists('user', ['parent-uid' => $uid, 'account_removed' => false])) {
1728 if (DBA::exists('manage', ['uid' => $uid])) {
1736 * Returns statistical information about the current users of this node
1742 public static function getStatistics(): array
1746 'active_users_halfyear' => 0,
1747 'active_users_monthly' => 0,
1748 'active_users_weekly' => 0,
1751 $userStmt = DBA::select('owner-view', ['uid', 'last-activity', 'last-item'],
1752 ["`verified` AND `last-activity` > ? AND NOT `blocked`
1753 AND NOT `account_removed` AND NOT `account_expired`",
1754 DBA::NULL_DATETIME]);
1755 if (!DBA::isResult($userStmt)) {
1759 $halfyear = time() - (180 * 24 * 60 * 60);
1760 $month = time() - (30 * 24 * 60 * 60);
1761 $week = time() - (7 * 24 * 60 * 60);
1763 while ($user = DBA::fetch($userStmt)) {
1764 $statistics['total_users']++;
1766 if ((strtotime($user['last-activity']) > $halfyear) || (strtotime($user['last-item']) > $halfyear)
1768 $statistics['active_users_halfyear']++;
1771 if ((strtotime($user['last-activity']) > $month) || (strtotime($user['last-item']) > $month)
1773 $statistics['active_users_monthly']++;
1776 if ((strtotime($user['last-activity']) > $week) || (strtotime($user['last-item']) > $week)
1778 $statistics['active_users_weekly']++;
1781 DBA::close($userStmt);
1787 * Get all users of the current node
1789 * @param int $start Start count (Default is 0)
1790 * @param int $count Count of the items per page (Default is @see Pager::ITEMS_PER_PAGE)
1791 * @param string $type The type of users, which should get (all, bocked, removed)
1792 * @param string $order Order of the user list (Default is 'contact.name')
1793 * @param bool $descending Order direction (Default is ascending)
1794 * @return array|bool The list of the users
1797 public static function getList(int $start = 0, int $count = Pager::ITEMS_PER_PAGE, string $type = 'all', string $order = 'name', bool $descending = false)
1799 $param = ['limit' => [$start, $count], 'order' => [$order => $descending]];
1803 $condition['account_removed'] = false;
1804 $condition['blocked'] = false;
1808 $condition['account_removed'] = false;
1809 $condition['blocked'] = true;
1810 $condition['verified'] = true;
1814 $condition['account_removed'] = true;
1818 return DBA::selectToArray('owner-view', [], $condition, $param);
1822 * Returns a list of lowercase admin email addresses from the comma-separated list in the config
1826 public static function getAdminEmailList(): array
1828 $adminEmails = strtolower(str_replace(' ', '', DI::config()->get('config', 'admin_email')));
1829 if (!$adminEmails) {
1833 return explode(',', $adminEmails);
1837 * Returns the complete list of admin user accounts
1839 * @param array $fields
1843 public static function getAdminList(array $fields = []): array
1846 'email' => self::getAdminEmailList(),
1850 'account_removed' => false,
1851 'account_expired' => false,
1854 return DBA::selectToArray('user', $fields, $condition, ['order' => ['uid']]);
1858 * Return a list of admin user accounts where each unique email address appears only once.
1860 * This method is meant for admin notifications that do not need to be sent multiple times to the same email address.
1862 * @param array $fields
1866 public static function getAdminListForEmailing(array $fields = []): array
1868 return array_filter(self::getAdminList($fields), function ($user) {
1869 static $emails = [];
1871 if (in_array($user['email'], $emails)) {
1875 $emails[] = $user['email'];