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;
39 use Friendica\Network\HTTPClient\Client\HttpClientAccept;
40 use Friendica\Security\TwoFactor\Model\AppSpecificPassword;
41 use Friendica\Network\HTTPException;
42 use Friendica\Object\Image;
43 use Friendica\Protocol\Delivery;
44 use Friendica\Util\Crypto;
45 use Friendica\Util\DateTimeFormat;
46 use Friendica\Util\Images;
47 use Friendica\Util\Network;
48 use Friendica\Util\Proxy;
49 use Friendica\Util\Strings;
54 * This class handles User related functions
61 * PAGE_FLAGS_NORMAL is a typical personal profile account
62 * PAGE_FLAGS_SOAPBOX automatically approves all friend requests as Contact::SHARING, (readonly)
63 * PAGE_FLAGS_COMMUNITY automatically approves all friend requests as Contact::SHARING, but with
64 * write access to wall and comments (no email and not included in page owner's ACL lists)
65 * PAGE_FLAGS_FREELOVE automatically approves all friend requests as full friends (Contact::FRIEND).
69 const PAGE_FLAGS_NORMAL = 0;
70 const PAGE_FLAGS_SOAPBOX = 1;
71 const PAGE_FLAGS_COMMUNITY = 2;
72 const PAGE_FLAGS_FREELOVE = 3;
73 const PAGE_FLAGS_BLOG = 4;
74 const PAGE_FLAGS_PRVGROUP = 5;
82 * ACCOUNT_TYPE_PERSON - the account belongs to a person
83 * Associated page types: PAGE_FLAGS_NORMAL, PAGE_FLAGS_SOAPBOX, PAGE_FLAGS_FREELOVE
85 * ACCOUNT_TYPE_ORGANISATION - the account belongs to an organisation
86 * Associated page type: PAGE_FLAGS_SOAPBOX
88 * ACCOUNT_TYPE_NEWS - the account is a news reflector
89 * Associated page type: PAGE_FLAGS_SOAPBOX
91 * ACCOUNT_TYPE_COMMUNITY - the account is community group
92 * Associated page types: PAGE_COMMUNITY, PAGE_FLAGS_PRVGROUP
94 * ACCOUNT_TYPE_RELAY - the account is a relay
95 * This will only be assigned to contacts, not to user accounts
98 const ACCOUNT_TYPE_PERSON = 0;
99 const ACCOUNT_TYPE_ORGANISATION = 1;
100 const ACCOUNT_TYPE_NEWS = 2;
101 const ACCOUNT_TYPE_COMMUNITY = 3;
102 const ACCOUNT_TYPE_RELAY = 4;
103 const ACCOUNT_TYPE_DELETED = 127;
108 private static $owner;
111 * Returns the numeric account type by their string
113 * @param string $accounttype as string constant
114 * @return int|null Numeric account type - or null when not set
116 public static function getAccountTypeByString(string $accounttype)
118 switch ($accounttype) {
120 return User::ACCOUNT_TYPE_PERSON;
123 return User::ACCOUNT_TYPE_ORGANISATION;
126 return User::ACCOUNT_TYPE_NEWS;
129 return User::ACCOUNT_TYPE_COMMUNITY;
136 * Fetch the system account
138 * @return array system account
140 public static function getSystemAccount(): array
142 $system = Contact::selectFirst([], ['self' => true, 'uid' => 0]);
143 if (!DBA::isResult($system)) {
144 self::createSystemAccount();
145 $system = Contact::selectFirst([], ['self' => true, 'uid' => 0]);
146 if (!DBA::isResult($system)) {
151 $system['sprvkey'] = $system['uprvkey'] = $system['prvkey'];
152 $system['spubkey'] = $system['upubkey'] = $system['pubkey'];
153 $system['nickname'] = $system['nick'];
154 $system['page-flags'] = User::PAGE_FLAGS_SOAPBOX;
155 $system['account-type'] = $system['contact-type'];
156 $system['guid'] = '';
157 $system['picdate'] = '';
158 $system['theme'] = '';
159 $system['publish'] = false;
160 $system['net-publish'] = false;
161 $system['hide-friends'] = true;
162 $system['hidewall'] = true;
163 $system['prv_keywords'] = '';
164 $system['pub_keywords'] = '';
165 $system['address'] = '';
166 $system['locality'] = '';
167 $system['region'] = '';
168 $system['postal-code'] = '';
169 $system['country-name'] = '';
170 $system['homepage'] = (string)DI::baseUrl();
171 $system['dob'] = '0000-00-00';
173 // Ensure that the user contains data
174 $user = DBA::selectFirst('user', ['prvkey', 'guid'], ['uid' => 0]);
175 if (empty($user['prvkey']) || empty($user['guid'])) {
177 'username' => $system['name'],
178 'nickname' => $system['nick'],
179 'register_date' => $system['created'],
180 'pubkey' => $system['pubkey'],
181 'prvkey' => $system['prvkey'],
182 'spubkey' => $system['spubkey'],
183 'sprvkey' => $system['sprvkey'],
184 'guid' => System::createUUID(),
186 'page-flags' => User::PAGE_FLAGS_SOAPBOX,
187 'account-type' => User::ACCOUNT_TYPE_RELAY,
190 DBA::update('user', $fields, ['uid' => 0]);
192 $system['guid'] = $fields['guid'];
194 $system['guid'] = $user['guid'];
201 * Create the system account
205 private static function createSystemAccount()
207 $system_actor_name = self::getActorName();
208 if (empty($system_actor_name)) {
212 $keys = Crypto::newKeypair(4096);
213 if ($keys === false) {
214 throw new Exception(DI::l10n()->t('SERIOUS ERROR: Generation of security keys failed.'));
219 'created' => DateTimeFormat::utcNow(),
221 'network' => Protocol::ACTIVITYPUB,
222 'name' => 'System Account',
223 'addr' => $system_actor_name . '@' . DI::baseUrl()->getHost(),
224 'nick' => $system_actor_name,
225 'url' => DI::baseUrl() . '/friendica',
226 'pubkey' => $keys['pubkey'],
227 'prvkey' => $keys['prvkey'],
230 'contact-type' => Contact::TYPE_RELAY, // In AP this is translated to 'Application'
231 'name-date' => DateTimeFormat::utcNow(),
232 'uri-date' => DateTimeFormat::utcNow(),
233 'avatar-date' => DateTimeFormat::utcNow(),
235 'baseurl' => DI::baseUrl(),
238 $system['avatar'] = $system['photo'] = Contact::getDefaultAvatar($system, Proxy::SIZE_SMALL);
239 $system['thumb'] = Contact::getDefaultAvatar($system, Proxy::SIZE_THUMB);
240 $system['micro'] = Contact::getDefaultAvatar($system, Proxy::SIZE_MICRO);
241 $system['nurl'] = Strings::normaliseLink($system['url']);
242 $system['gsid'] = GServer::getID($system['baseurl']);
244 Contact::insert($system);
248 * Detect a usable actor name
250 * @return string actor account name
252 public static function getActorName(): string
254 $system_actor_name = DI::config()->get('system', 'actor_name');
255 if (!empty($system_actor_name)) {
256 $self = Contact::selectFirst(['nick'], ['uid' => 0, 'self' => true]);
257 if (!empty($self['nick'])) {
258 if ($self['nick'] != $system_actor_name) {
259 // Reset the actor name to the already used name
260 DI::config()->set('system', 'actor_name', $self['nick']);
261 $system_actor_name = $self['nick'];
264 return $system_actor_name;
267 // List of possible actor names
268 $possible_accounts = ['friendica', 'actor', 'system', 'internal'];
269 foreach ($possible_accounts as $name) {
270 if (!DBA::exists('user', ['nickname' => $name, 'account_removed' => false, 'account_expired' => false]) &&
271 !DBA::exists('userd', ['username' => $name])) {
272 DI::config()->set('system', 'actor_name', $name);
280 * Returns true if a user record exists with the provided id
287 public static function exists(int $uid): bool
289 return DBA::exists('user', ['uid' => $uid]);
293 * @param integer $uid
294 * @param array $fields
295 * @return array|boolean User record if it exists, false otherwise
298 public static function getById(int $uid, array $fields = [])
300 return !empty($uid) ? DBA::selectFirst('user', $fields, ['uid' => $uid]) : [];
304 * Returns a user record based on it's GUID
306 * @param string $guid The guid of the user
307 * @param array $fields The fields to retrieve
308 * @param bool $active True, if only active records are searched
310 * @return array|boolean User record if it exists, false otherwise
313 public static function getByGuid(string $guid, array $fields = [], bool $active = true)
316 $cond = ['guid' => $guid, 'account_expired' => false, 'account_removed' => false];
318 $cond = ['guid' => $guid];
321 return DBA::selectFirst('user', $fields, $cond);
325 * @param string $nickname
326 * @param array $fields
327 * @return array|boolean User record if it exists, false otherwise
330 public static function getByNickname(string $nickname, array $fields = [])
332 return DBA::selectFirst('user', $fields, ['nickname' => $nickname]);
336 * Returns the user id of a given profile URL
340 * @return integer user id
343 public static function getIdForURL(string $url): int
345 // Avoid database queries when the local node hostname isn't even part of the url.
346 if (!Contact::isLocal($url)) {
350 $self = Contact::selectFirst(['uid'], ['self' => true, 'nurl' => Strings::normaliseLink($url)]);
351 if (!empty($self['uid'])) {
355 $self = Contact::selectFirst(['uid'], ['self' => true, 'addr' => $url]);
356 if (!empty($self['uid'])) {
360 $self = Contact::selectFirst(['uid'], ['self' => true, 'alias' => [$url, Strings::normaliseLink($url)]]);
361 if (!empty($self['uid'])) {
369 * Get a user based on its email
371 * @param string $email
372 * @param array $fields
373 * @return array|boolean User record if it exists, false otherwise
376 public static function getByEmail(string $email, array $fields = [])
378 return DBA::selectFirst('user', $fields, ['email' => $email]);
382 * Fetch the user array of the administrator. The first one if there are several.
384 * @param array $fields
388 public static function getFirstAdmin(array $fields = []) : array
390 if (!empty(DI::config()->get('config', 'admin_nickname'))) {
391 return self::getByNickname(DI::config()->get('config', 'admin_nickname'), $fields);
394 return self::getAdminList()[0] ?? [];
398 * Get owner data by user id
401 * @param boolean $repairMissing Repair the owner data if it's missing
402 * @return boolean|array
405 public static function getOwnerDataById(int $uid, bool $repairMissing = true)
408 return self::getSystemAccount();
411 if (!empty(self::$owner[$uid])) {
412 return self::$owner[$uid];
415 $owner = DBA::selectFirst('owner-view', [], ['uid' => $uid]);
416 if (!DBA::isResult($owner)) {
417 if (!self::exists($uid) || !$repairMissing) {
420 if (!DBA::exists('profile', ['uid' => $uid])) {
421 DBA::insert('profile', ['uid' => $uid]);
423 if (!DBA::exists('contact', ['uid' => $uid, 'self' => true])) {
424 Contact::createSelfFromUserId($uid);
426 $owner = self::getOwnerDataById($uid, false);
429 if (empty($owner['nickname'])) {
433 if (!$repairMissing || $owner['account_expired']) {
437 // Check if the returned data is valid, otherwise fix it. See issue #6122
439 // Check for correct url and normalised nurl
440 $url = DI::baseUrl() . '/profile/' . $owner['nickname'];
441 $repair = empty($owner['network']) || ($owner['url'] != $url) || ($owner['nurl'] != Strings::normaliseLink($owner['url']));
444 // Check if "addr" is present and correct
445 $addr = $owner['nickname'] . '@' . substr(DI::baseUrl(), strpos(DI::baseUrl(), '://') + 3);
446 $repair = ($addr != $owner['addr']) || empty($owner['prvkey']) || empty($owner['pubkey']);
450 // Check if the avatar field is filled and the photo directs to the correct path
451 $avatar = Photo::selectFirst(['resource-id'], ['uid' => $uid, 'profile' => true]);
452 if (DBA::isResult($avatar)) {
453 $repair = empty($owner['avatar']) || !strpos($owner['photo'], $avatar['resource-id']);
458 Contact::updateSelfFromUserID($uid);
459 // Return the corrected data and avoid a loop
460 $owner = self::getOwnerDataById($uid, false);
463 self::$owner[$uid] = $owner;
468 * Get owner data by nick name
471 * @return boolean|array
474 public static function getOwnerDataByNick(string $nick)
476 $user = DBA::selectFirst('user', ['uid'], ['nickname' => $nick]);
478 if (!DBA::isResult($user)) {
482 return self::getOwnerDataById($user['uid']);
486 * Returns the default circle for a given user
488 * @param int $uid User id
490 * @return int circle id
493 public static function getDefaultCircle(int $uid): int
495 $user = DBA::selectFirst('user', ['def_gid'], ['uid' => $uid]);
496 if (DBA::isResult($user)) {
497 $default_circle = $user['def_gid'];
502 return $default_circle;
506 * Returns the default circle for groups for a given user
508 * @param int $uid User id
510 * @return int circle id
513 public static function getDefaultGroupCircle(int $uid): int
515 $default_circle = DI::pConfig()->get($uid, 'system', 'default-group-gid');
516 if (empty($default_circle)) {
517 $default_circle = self::getDefaultCircle($uid);
520 return $default_circle;
524 * Authenticate a user with a clear text password
526 * Returns the user id associated with a successful password authentication
528 * @param mixed $user_info
529 * @param string $password
530 * @param bool $third_party
531 * @return int User Id if authentication is successful
532 * @throws HTTPException\ForbiddenException
533 * @throws HTTPException\NotFoundException
535 public static function getIdFromPasswordAuthentication($user_info, string $password, bool $third_party = false): int
537 // Addons registered with the "authenticate" hook may create the user on the
538 // fly. `getAuthenticationInfo` will fail if the user doesn't exist yet. If
539 // the user doesn't exist, we should give the addons a chance to create the
540 // user in our database, if applicable, before re-throwing the exception if
543 $user = self::getAuthenticationInfo($user_info);
544 } catch (Exception $e) {
545 $username = (is_string($user_info) ? $user_info : $user_info['nickname'] ?? '');
547 // Addons can create users, and since this 'catch' branch should only
548 // execute if getAuthenticationInfo can't find an existing user, that's
549 // exactly what will happen here. Creating a numeric username would create
550 // ambiguity with user IDs, possibly opening up an attack vector.
551 // So let's be very careful about that.
552 if (empty($username) || is_numeric($username)) {
556 return self::getIdFromAuthenticateHooks($username, $password);
559 if ($third_party && DI::pConfig()->get($user['uid'], '2fa', 'verified')) {
560 // Third-party apps can't verify two-factor authentication, we use app-specific passwords instead
561 if (AppSpecificPassword::authenticateUser($user['uid'], $password)) {
564 } elseif (strpos($user['password'], '$') === false) {
565 //Legacy hash that has not been replaced by a new hash yet
566 if (self::hashPasswordLegacy($password) === $user['password']) {
567 self::updatePasswordHashed($user['uid'], self::hashPassword($password));
571 } elseif (!empty($user['legacy_password'])) {
572 //Legacy hash that has been double-hashed and not replaced by a new hash yet
573 //Warning: `legacy_password` is not necessary in sync with the content of `password`
574 if (password_verify(self::hashPasswordLegacy($password), $user['password'])) {
575 self::updatePasswordHashed($user['uid'], self::hashPassword($password));
579 } elseif (password_verify($password, $user['password'])) {
581 if (password_needs_rehash($user['password'], PASSWORD_DEFAULT)) {
582 self::updatePasswordHashed($user['uid'], self::hashPassword($password));
587 return self::getIdFromAuthenticateHooks($user['nickname'], $password); // throws
590 throw new HTTPException\ForbiddenException(DI::l10n()->t('Login failed'));
594 * Try to obtain a user ID via "authenticate" hook addons
596 * Returns the user id associated with a successful password authentication
598 * @param string $username
599 * @param string $password
600 * @return int User Id if authentication is successful
601 * @throws HTTPException\ForbiddenException
603 public static function getIdFromAuthenticateHooks(string $username, string $password): int
606 'username' => $username,
607 'password' => $password,
608 'authenticated' => 0,
609 'user_record' => null
613 * An addon indicates successful login by setting 'authenticated' to non-zero value and returning a user record
614 * Addons should never set 'authenticated' except to indicate success - as hooks may be chained
615 * and later addons should not interfere with an earlier one that succeeded.
617 Hook::callAll('authenticate', $addon_auth);
619 if ($addon_auth['authenticated'] && $addon_auth['user_record']) {
620 return $addon_auth['user_record']['uid'];
623 throw new HTTPException\ForbiddenException(DI::l10n()->t('Login failed'));
627 * Returns authentication info from various parameters types
629 * User info can be any of the following:
632 * - User email or username or nickname
633 * - User array with at least the uid and the hashed password
635 * @param mixed $user_info
636 * @return array|null Null if not found/determined
637 * @throws HTTPException\NotFoundException
639 public static function getAuthenticationInfo($user_info)
643 if (is_object($user_info) || is_array($user_info)) {
644 if (is_object($user_info)) {
645 $user = (array) $user_info;
652 || !isset($user['password'])
653 || !isset($user['legacy_password'])
655 throw new Exception(DI::l10n()->t('Not enough information to authenticate'));
657 } elseif (is_int($user_info) || is_string($user_info)) {
658 if (is_int($user_info)) {
659 $user = DBA::selectFirst(
661 ['uid', 'nickname', 'password', 'legacy_password'],
665 'account_expired' => 0,
666 'account_removed' => 0,
671 $fields = ['uid', 'nickname', 'password', 'legacy_password'];
673 "(`email` = ? OR `username` = ? OR `nickname` = ?)
674 AND NOT `blocked` AND NOT `account_expired` AND NOT `account_removed` AND `verified`",
675 $user_info, $user_info, $user_info
677 $user = DBA::selectFirst('user', $fields, $condition);
680 if (!DBA::isResult($user)) {
681 throw new HTTPException\NotFoundException(DI::l10n()->t('User not found'));
689 * Update the day of the last activity of the given user
691 * @param integer $uid
694 public static function updateLastActivity(int $uid)
700 $user = User::getById($uid, ['last-activity']);
705 $current_day = DateTimeFormat::utcNow('Y-m-d');
707 if ($user['last-activity'] != $current_day) {
708 User::update(['last-activity' => $current_day], $uid);
709 // Set the last activity for all identities of the user
710 DBA::update('user', ['last-activity' => $current_day], ['parent-uid' => $uid, 'account_removed' => false]);
715 * Generates a human-readable random password
720 public static function generateNewPassword(): string
722 return ucfirst(Strings::getRandomName(8)) . random_int(1000, 9999);
726 * Checks if the provided plaintext password has been exposed or not
728 * @param string $password
732 public static function isPasswordExposed(string $password): bool
734 $cache = new CacheItemPool();
735 $cache->changeConfig([
736 'cacheDirectory' => System::getTempPath() . '/password-exposed-cache/',
740 $passwordExposedChecker = new PasswordExposed\PasswordExposedChecker(null, $cache);
742 return $passwordExposedChecker->passwordExposed($password) === PasswordExposed\PasswordStatus::EXPOSED;
743 } catch (Exception $e) {
744 Logger::error('Password Exposed Exception: ' . $e->getMessage(), [
745 'code' => $e->getCode(),
746 'file' => $e->getFile(),
747 'line' => $e->getLine(),
748 'trace' => $e->getTraceAsString()
756 * Legacy hashing function, kept for password migration purposes
758 * @param string $password
761 private static function hashPasswordLegacy(string $password): string
763 return hash('whirlpool', $password);
767 * Global user password hashing function
769 * @param string $password
773 public static function hashPassword(string $password): string
775 if (!trim($password)) {
776 throw new Exception(DI::l10n()->t('Password can\'t be empty'));
779 return password_hash($password, PASSWORD_DEFAULT);
783 * Allowed characters are a-z, A-Z, 0-9 and special characters except white spaces and accentuated letters.
785 * Password length is limited to 72 characters if the current default password hashing algorithm is Blowfish.
786 * From the manual: "Using the PASSWORD_BCRYPT as the algorithm, will result in the password parameter being
787 * truncated to a maximum length of 72 bytes."
789 * @see https://www.php.net/manual/en/function.password-hash.php#refsect1-function.password-hash-parameters
791 * @param string|null $delimiter Whether the regular expression is meant to be wrapper in delimiter characters
794 public static function getPasswordRegExp(string $delimiter = null): string
796 $allowed_characters = ':!"#$%&\'()*+,-./;<=>?@[\]^_`{|}~';
799 $allowed_characters = preg_quote($allowed_characters, $delimiter);
802 return '^[a-zA-Z0-9' . $allowed_characters . ']' . (PASSWORD_DEFAULT === PASSWORD_BCRYPT ? '{1,72}' : '+') . '$';
806 * Updates a user row with a new plaintext password
809 * @param string $password
813 public static function updatePassword(int $uid, string $password): bool
815 $password = trim($password);
817 if (empty($password)) {
818 throw new Exception(DI::l10n()->t('Empty passwords are not allowed.'));
821 if (!DI::config()->get('system', 'disable_password_exposed', false) && self::isPasswordExposed($password)) {
822 throw new Exception(DI::l10n()->t('The new password has been exposed in a public data dump, please choose another.'));
825 if (PASSWORD_DEFAULT === PASSWORD_BCRYPT && strlen($password) > 72) {
826 throw new Exception(DI::l10n()->t('The password length is limited to 72 characters.'));
829 if (!preg_match('/' . self::getPasswordRegExp('/') . '/', $password)) {
830 throw new Exception(DI::l10n()->t("The password can't contain white spaces nor accentuated letters"));
833 return self::updatePasswordHashed($uid, self::hashPassword($password));
837 * Updates a user row with a new hashed password.
838 * Empties the password reset token field just in case.
841 * @param string $password_hashed
845 private static function updatePasswordHashed(int $uid, string $password_hashed): bool
848 'password' => $password_hashed,
850 'pwdreset_time' => null,
851 'legacy_password' => false
853 return DBA::update('user', $fields, ['uid' => $uid]);
857 * Returns if the given uid is valid and in the admin list
864 public static function isSiteAdmin(int $uid): bool
866 return DBA::exists('user', [
868 'email' => self::getAdminEmailList()
873 * Checks if a nickname is in the list of the forbidden nicknames
875 * Check if a nickname is forbidden from registration on the node by the
876 * admin. Forbidden nicknames (e.g. role names) can be configured in the
879 * @param string $nickname The nickname that should be checked
880 * @return boolean True is the nickname is blocked on the node
882 public static function isNicknameBlocked(string $nickname): bool
884 $forbidden_nicknames = DI::config()->get('system', 'forbidden_nicknames', '');
885 if (!empty($forbidden_nicknames)) {
886 $forbidden = explode(',', $forbidden_nicknames);
887 $forbidden = array_map('trim', $forbidden);
892 // Add the name of the internal actor to the "forbidden" list
893 $actor_name = self::getActorName();
894 if (!empty($actor_name)) {
895 $forbidden[] = $actor_name;
898 if (empty($forbidden)) {
902 // check if the nickname is in the list of blocked nicknames
903 if (in_array(strtolower($nickname), $forbidden)) {
912 * Get avatar link for given user
915 * @param string $size One of the Proxy::SIZE_* constants
916 * @return string avatar link
919 public static function getAvatarUrl(array $user, string $size = ''): string
921 if (empty($user['nickname'])) {
922 DI::logger()->warning('Missing user nickname key', ['trace' => System::callstack(20)]);
925 $url = DI::baseUrl() . '/photo/';
928 case Proxy::SIZE_MICRO:
932 case Proxy::SIZE_THUMB:
945 $photo = Photo::selectFirst(['type', 'created', 'edited', 'updated'], ["scale" => $scale, 'uid' => $user['uid'], 'profile' => true]);
946 if (!empty($photo)) {
947 $updated = max($photo['created'], $photo['edited'], $photo['updated']);
948 $mimetype = $photo['type'];
951 return $url . $user['nickname'] . Images::getExtensionByMimeType($mimetype) . ($updated ? '?ts=' . strtotime($updated) : '');
955 * Get banner link for given user
958 * @return string banner link
961 public static function getBannerUrl(array $user): string
963 if (empty($user['nickname'])) {
964 DI::logger()->warning('Missing user nickname key', ['trace' => System::callstack(20)]);
967 $url = DI::baseUrl() . '/photo/banner/';
972 $photo = Photo::selectFirst(['type', 'created', 'edited', 'updated'], ["scale" => 3, 'uid' => $user['uid'], 'photo-type' => Photo::USER_BANNER]);
973 if (!empty($photo)) {
974 $updated = max($photo['created'], $photo['edited'], $photo['updated']);
975 $mimetype = $photo['type'];
977 // Only for the RC phase: Don't return an image link for the default picture
981 return $url . $user['nickname'] . Images::getExtensionByMimeType($mimetype) . ($updated ? '?ts=' . strtotime($updated) : '');
985 * Catch-all user creation function
987 * Creates a user from the provided data array, either form fields or OpenID.
988 * Required: { username, nickname, email } or { openid_url }
990 * Performs the following:
991 * - Sends to the OpenId auth URL (if relevant)
992 * - Creates new key pairs for crypto
993 * - Create self-contact
994 * - Create profile image
998 * @throws ErrorException
999 * @throws HTTPException\InternalServerErrorException
1000 * @throws ImagickException
1003 public static function create(array $data): array
1005 $return = ['user' => null, 'password' => ''];
1007 $using_invites = DI::config()->get('system', 'invitation_only');
1009 $invite_id = !empty($data['invite_id']) ? trim($data['invite_id']) : '';
1010 $username = !empty($data['username']) ? trim($data['username']) : '';
1011 $nickname = !empty($data['nickname']) ? trim($data['nickname']) : '';
1012 $email = !empty($data['email']) ? trim($data['email']) : '';
1013 $openid_url = !empty($data['openid_url']) ? trim($data['openid_url']) : '';
1014 $photo = !empty($data['photo']) ? trim($data['photo']) : '';
1015 $password = !empty($data['password']) ? trim($data['password']) : '';
1016 $password1 = !empty($data['password1']) ? trim($data['password1']) : '';
1017 $confirm = !empty($data['confirm']) ? trim($data['confirm']) : '';
1018 $blocked = !empty($data['blocked']);
1019 $verified = !empty($data['verified']);
1020 $language = !empty($data['language']) ? trim($data['language']) : 'en';
1022 $netpublish = $publish = !empty($data['profile_publish_reg']);
1024 if ($password1 != $confirm) {
1025 throw new Exception(DI::l10n()->t('Passwords do not match. Password unchanged.'));
1026 } elseif ($password1 != '') {
1027 $password = $password1;
1030 if ($using_invites) {
1032 throw new Exception(DI::l10n()->t('An invitation is required.'));
1035 if (!Register::existsByHash($invite_id)) {
1036 throw new Exception(DI::l10n()->t('Invitation could not be verified.'));
1040 /// @todo Check if this part is really needed. We should have fetched all this data in advance
1041 if (empty($username) || empty($email) || empty($nickname)) {
1043 if (!Network::isUrlValid($openid_url)) {
1044 throw new Exception(DI::l10n()->t('Invalid OpenID url'));
1046 $_SESSION['register'] = 1;
1047 $_SESSION['openid'] = $openid_url;
1049 $openid = new LightOpenID(DI::baseUrl()->getHost());
1050 $openid->identity = $openid_url;
1051 $openid->returnUrl = DI::baseUrl() . '/openid';
1052 $openid->required = ['namePerson/friendly', 'contact/email', 'namePerson'];
1053 $openid->optional = ['namePerson/first', 'media/image/aspect11', 'media/image/default'];
1055 $authurl = $openid->authUrl();
1056 } catch (Exception $e) {
1057 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);
1059 System::externalRedirect($authurl);
1063 throw new Exception(DI::l10n()->t('Please enter the required information.'));
1066 if (!Network::isUrlValid($openid_url)) {
1070 // collapse multiple spaces in name
1071 $username = preg_replace('/ +/', ' ', $username);
1073 $username_min_length = max(1, min(64, intval(DI::config()->get('system', 'username_min_length', 3))));
1074 $username_max_length = max(1, min(64, intval(DI::config()->get('system', 'username_max_length', 48))));
1076 if ($username_min_length > $username_max_length) {
1077 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));
1078 $tmp = $username_min_length;
1079 $username_min_length = $username_max_length;
1080 $username_max_length = $tmp;
1083 if (mb_strlen($username) < $username_min_length) {
1084 throw new Exception(DI::l10n()->tt('Username should be at least %s character.', 'Username should be at least %s characters.', $username_min_length));
1087 if (mb_strlen($username) > $username_max_length) {
1088 throw new Exception(DI::l10n()->tt('Username should be at most %s character.', 'Username should be at most %s characters.', $username_max_length));
1091 // So now we are just looking for a space in the full name.
1092 $loose_reg = DI::config()->get('system', 'no_regfullname');
1094 $username = mb_convert_case($username, MB_CASE_TITLE, 'UTF-8');
1095 if (strpos($username, ' ') === false) {
1096 throw new Exception(DI::l10n()->t("That doesn't appear to be your full (First Last) name."));
1100 if (!Network::isEmailDomainAllowed($email)) {
1101 throw new Exception(DI::l10n()->t('Your email domain is not among those allowed on this site.'));
1104 if (!filter_var($email, FILTER_VALIDATE_EMAIL) || !Network::isEmailDomainValid($email)) {
1105 throw new Exception(DI::l10n()->t('Not a valid email address.'));
1107 if (self::isNicknameBlocked($nickname)) {
1108 throw new Exception(DI::l10n()->t('The nickname was blocked from registration by the nodes admin.'));
1111 if (DI::config()->get('system', 'block_extended_register', false) && DBA::exists('user', ['email' => $email])) {
1112 throw new Exception(DI::l10n()->t('Cannot use that email.'));
1115 // Disallow somebody creating an account using openid that uses the admin email address,
1116 // since openid bypasses email verification. We'll allow it if there is not yet an admin account.
1117 if (strlen($openid_url) && in_array(strtolower($email), self::getAdminEmailList())) {
1118 throw new Exception(DI::l10n()->t('Cannot use that email.'));
1121 $nickname = $data['nickname'] = strtolower($nickname);
1123 if (!preg_match('/^[a-z0-9][a-z0-9_]*$/', $nickname)) {
1124 throw new Exception(DI::l10n()->t('Your nickname can only contain a-z, 0-9 and _.'));
1127 // Check existing and deleted accounts for this nickname.
1129 DBA::exists('user', ['nickname' => $nickname])
1130 || DBA::exists('userd', ['username' => $nickname])
1132 throw new Exception(DI::l10n()->t('Nickname is already registered. Please choose another.'));
1135 $new_password = strlen($password) ? $password : User::generateNewPassword();
1136 $new_password_encoded = self::hashPassword($new_password);
1138 $return['password'] = $new_password;
1140 $keys = Crypto::newKeypair(4096);
1141 if ($keys === false) {
1142 throw new Exception(DI::l10n()->t('SERIOUS ERROR: Generation of security keys failed.'));
1145 $prvkey = $keys['prvkey'];
1146 $pubkey = $keys['pubkey'];
1148 // Create another keypair for signing/verifying salmon protocol messages.
1149 $sres = Crypto::newKeypair(512);
1150 $sprvkey = $sres['prvkey'];
1151 $spubkey = $sres['pubkey'];
1153 $insert_result = DBA::insert('user', [
1154 'guid' => System::createUUID(),
1155 'username' => $username,
1156 'password' => $new_password_encoded,
1158 'openid' => $openid_url,
1159 'nickname' => $nickname,
1160 'pubkey' => $pubkey,
1161 'prvkey' => $prvkey,
1162 'spubkey' => $spubkey,
1163 'sprvkey' => $sprvkey,
1164 'verified' => $verified,
1165 'blocked' => $blocked,
1166 'language' => $language,
1167 'timezone' => 'UTC',
1168 'register_date' => DateTimeFormat::utcNow(),
1169 'default-location' => ''
1172 if ($insert_result) {
1173 $uid = DBA::lastInsertId();
1174 $user = DBA::selectFirst('user', [], ['uid' => $uid]);
1176 throw new Exception(DI::l10n()->t('An error occurred during registration. Please try again.'));
1180 throw new Exception(DI::l10n()->t('An error occurred during registration. Please try again.'));
1183 // if somebody clicked submit twice very quickly, they could end up with two accounts
1184 // due to race condition. Remove this one.
1185 $user_count = DBA::count('user', ['nickname' => $nickname]);
1186 if ($user_count > 1) {
1187 DBA::delete('user', ['uid' => $uid]);
1189 throw new Exception(DI::l10n()->t('Nickname is already registered. Please choose another.'));
1192 $insert_result = DBA::insert('profile', [
1194 'name' => $username,
1195 'photo' => self::getAvatarUrl($user),
1196 'thumb' => self::getAvatarUrl($user, Proxy::SIZE_THUMB),
1197 'publish' => $publish,
1198 'net-publish' => $netpublish,
1200 if (!$insert_result) {
1201 DBA::delete('user', ['uid' => $uid]);
1203 throw new Exception(DI::l10n()->t('An error occurred creating your default profile. Please try again.'));
1206 // Create the self contact
1207 if (!Contact::createSelfFromUserId($uid)) {
1208 DBA::delete('user', ['uid' => $uid]);
1210 throw new Exception(DI::l10n()->t('An error occurred creating your self contact. Please try again.'));
1213 // Create a circle with no members. This allows somebody to use it
1214 // right away as a default circle for new contacts.
1215 $def_gid = Circle::create($uid, DI::l10n()->t('Friends'));
1217 DBA::delete('user', ['uid' => $uid]);
1219 throw new Exception(DI::l10n()->t('An error occurred creating your default contact circle. Please try again.'));
1222 $fields = ['def_gid' => $def_gid];
1223 if (DI::config()->get('system', 'newuser_private') && $def_gid) {
1224 $fields['allow_gid'] = '<' . $def_gid . '>';
1227 DBA::update('user', $fields, ['uid' => $uid]);
1229 $def_gid_groups = Circle::create($uid, DI::l10n()->t('Groups'));
1230 if ($def_gid_groups) {
1231 DI::pConfig()->set($uid, 'system', 'default-group-gid', $def_gid_groups);
1234 // if we have no OpenID photo try to look up an avatar
1235 if (!strlen($photo)) {
1236 $photo = Network::lookupAvatarByEmail($email);
1239 // unless there is no avatar-addon loaded
1240 if (strlen($photo)) {
1241 $photo_failure = false;
1243 $filename = basename($photo);
1244 $curlResult = DI::httpClient()->get($photo, HttpClientAccept::IMAGE);
1245 if ($curlResult->isSuccess()) {
1246 Logger::debug('Got picture', ['Content-Type' => $curlResult->getHeader('Content-Type'), 'url' => $photo]);
1247 $img_str = $curlResult->getBody();
1248 $type = $curlResult->getContentType();
1254 $type = Images::getMimeTypeByData($img_str, $photo, $type);
1256 $image = new Image($img_str, $type);
1257 if ($image->isValid()) {
1258 $image->scaleToSquare(300);
1260 $resource_id = Photo::newResource();
1262 // Not using Photo::PROFILE_PHOTOS here, so that it is discovered as translatable string
1263 $profile_album = DI::l10n()->t('Profile Photos');
1265 $r = Photo::store($image, $uid, 0, $resource_id, $filename, $profile_album, 4);
1268 $photo_failure = true;
1271 $image->scaleDown(80);
1273 $r = Photo::store($image, $uid, 0, $resource_id, $filename, $profile_album, 5);
1276 $photo_failure = true;
1279 $image->scaleDown(48);
1281 $r = Photo::store($image, $uid, 0, $resource_id, $filename, $profile_album, 6);
1284 $photo_failure = true;
1287 if (!$photo_failure) {
1288 Photo::update(['profile' => true, 'photo-type' => Photo::USER_AVATAR], ['resource-id' => $resource_id]);
1292 Contact::updateSelfFromUserID($uid, true);
1295 Hook::callAll('register_account', $uid);
1297 self::setRegisterMethodByUserCount();
1299 $return['user'] = $user;
1304 * Update a user entry and distribute the changes if needed
1306 * @param array $fields
1307 * @param integer $uid
1310 public static function update(array $fields, int $uid): bool
1312 $old_owner = self::getOwnerDataById($uid);
1313 if (empty($old_owner)) {
1317 if (!DBA::update('user', $fields, ['uid' => $uid])) {
1321 $update = Contact::updateSelfFromUserID($uid);
1323 $owner = self::getOwnerDataById($uid);
1324 if (empty($owner)) {
1328 if ($old_owner['name'] != $owner['name']) {
1329 Profile::update(['name' => $owner['name']], $uid);
1333 Profile::publishUpdate($uid);
1340 * Sets block state for a given user
1342 * @param int $uid The user id
1343 * @param bool $block Block state (default is true)
1345 * @return bool True, if successfully blocked
1349 public static function block(int $uid, bool $block = true): bool
1351 return DBA::update('user', ['blocked' => $block], ['uid' => $uid]);
1355 * Allows a registration based on a hash
1357 * @param string $hash
1359 * @return bool True, if the allow was successful
1361 * @throws HTTPException\InternalServerErrorException
1364 public static function allow(string $hash): bool
1366 $register = Register::getByHash($hash);
1367 if (!DBA::isResult($register)) {
1371 $user = User::getById($register['uid']);
1372 if (!DBA::isResult($user)) {
1376 Register::deleteByHash($hash);
1378 DBA::update('user', ['blocked' => false, 'verified' => true], ['uid' => $register['uid']]);
1380 $profile = DBA::selectFirst('profile', ['net-publish'], ['uid' => $register['uid']]);
1382 if (DBA::isResult($profile) && $profile['net-publish'] && Search::getGlobalDirectory()) {
1383 $url = DI::baseUrl() . '/profile/' . $user['nickname'];
1384 Worker::add(Worker::PRIORITY_LOW, "Directory", $url);
1387 $l10n = DI::l10n()->withLang($register['language']);
1389 return User::sendRegisterOpenEmail(
1392 DI::config()->get('config', 'sitename'),
1394 ($register['password'] ?? '') ?: 'Sent in a previous email'
1399 * Denys a pending registration
1401 * @param string $hash The hash of the pending user
1403 * This does not have to go through user_remove() and save the nickname
1404 * permanently against re-registration, as the person was not yet
1405 * allowed to have friends on this system
1407 * @return bool True, if the deny was successful
1410 public static function deny(string $hash): bool
1412 $register = Register::getByHash($hash);
1413 if (!DBA::isResult($register)) {
1417 $user = User::getById($register['uid']);
1418 if (!DBA::isResult($user)) {
1422 // Delete the avatar
1423 Photo::delete(['uid' => $register['uid']]);
1425 return DBA::delete('user', ['uid' => $register['uid']]) &&
1426 Register::deleteByHash($register['hash']);
1430 * Creates a new user based on a minimal set and sends an email to this user
1432 * @param string $name The user's name
1433 * @param string $email The user's email address
1434 * @param string $nick The user's nick name
1435 * @param string $lang The user's language (default is english)
1436 * @return bool True, if the user was created successfully
1437 * @throws HTTPException\InternalServerErrorException
1438 * @throws ErrorException
1439 * @throws ImagickException
1441 public static function createMinimal(string $name, string $email, string $nick, string $lang = L10n::DEFAULT): bool
1446 throw new HTTPException\InternalServerErrorException('Invalid arguments.');
1449 $result = self::create([
1450 'username' => $name,
1452 'nickname' => $nick,
1457 $user = $result['user'];
1458 $preamble = Strings::deindent(DI::l10n()->t('
1460 the administrator of %2$s has set up an account for you.'));
1461 $body = Strings::deindent(DI::l10n()->t('
1462 The login details are as follows:
1468 You may change your password from your account "Settings" page after logging
1471 Please take a few moments to review the other account settings on that page.
1473 You may also wish to add some basic information to your default profile
1474 (on the "Profiles" page) so that other people can easily find you.
1476 We recommend setting your full name, adding a profile photo,
1477 adding some profile "keywords" (very useful in making new friends) - and
1478 perhaps what country you live in; if you do not wish to be more specific
1481 We fully respect your right to privacy, and none of these items are necessary.
1482 If you are new and do not know anybody here, they may help
1483 you to make some new and interesting friends.
1485 If you ever want to delete your account, you can do so at %1$s/settings/removeme
1487 Thank you and welcome to %4$s.'));
1489 $preamble = sprintf($preamble, $user['username'], DI::config()->get('config', 'sitename'));
1490 $body = sprintf($body, DI::baseUrl(), $user['nickname'], $result['password'], DI::config()->get('config', 'sitename'));
1492 $email = DI::emailer()
1494 ->withMessage(DI::l10n()->t('Registration details for %s', DI::config()->get('config', 'sitename')), $preamble, $body)
1496 ->withRecipient($user['email'])
1498 return DI::emailer()->send($email);
1502 * Sends pending registration confirmation email
1504 * @param array $user User record array
1505 * @param string $sitename
1506 * @param string $siteurl
1507 * @param string $password Plaintext password
1508 * @return NULL|boolean from notification() and email() inherited
1509 * @throws HTTPException\InternalServerErrorException
1511 public static function sendRegisterPendingEmail(array $user, string $sitename, string $siteurl, string $password)
1513 $body = Strings::deindent(DI::l10n()->t(
1516 Thank you for registering at %2$s. Your account is pending for approval by the administrator.
1518 Your login details are as follows:
1531 $email = DI::emailer()
1533 ->withMessage(DI::l10n()->t('Registration at %s', $sitename), $body)
1535 ->withRecipient($user['email'])
1537 return DI::emailer()->send($email);
1541 * Sends registration confirmation
1543 * It's here as a function because the mail is sent from different parts
1545 * @param L10n $l10n The used language
1546 * @param array $user User record array
1547 * @param string $sitename
1548 * @param string $siteurl
1549 * @param string $password Plaintext password
1551 * @return NULL|boolean from notification() and email() inherited
1552 * @throws HTTPException\InternalServerErrorException
1554 public static function sendRegisterOpenEmail(L10n $l10n, array $user, string $sitename, string $siteurl, string $password)
1556 $preamble = Strings::deindent($l10n->t(
1559 Thank you for registering at %2$s. Your account has been created.
1564 $body = Strings::deindent($l10n->t(
1566 The login details are as follows:
1572 You may change your password from your account "Settings" page after logging
1575 Please take a few moments to review the other account settings on that page.
1577 You may also wish to add some basic information to your default profile
1578 ' . "\x28" . 'on the "Profiles" page' . "\x29" . ' so that other people can easily find you.
1580 We recommend setting your full name, adding a profile photo,
1581 adding some profile "keywords" ' . "\x28" . 'very useful in making new friends' . "\x29" . ' - and
1582 perhaps what country you live in; if you do not wish to be more specific
1585 We fully respect your right to privacy, and none of these items are necessary.
1586 If you are new and do not know anybody here, they may help
1587 you to make some new and interesting friends.
1589 If you ever want to delete your account, you can do so at %3$s/settings/removeme
1591 Thank you and welcome to %2$s.',
1599 $email = DI::emailer()
1601 ->withMessage(DI::l10n()->t('Registration details for %s', $sitename), $preamble, $body)
1603 ->withRecipient($user['email'])
1605 return DI::emailer()->send($email);
1609 * @param int $uid user to remove
1611 * @throws HTTPException\InternalServerErrorException
1613 public static function remove(int $uid): bool
1619 Logger::notice('Removing user', ['user' => $uid]);
1621 $user = DBA::selectFirst('user', [], ['uid' => $uid]);
1623 Hook::callAll('remove_user', $user);
1625 // save username (actually the nickname as it is guaranteed
1626 // unique), so it cannot be re-registered in the future.
1627 DBA::insert('userd', ['username' => $user['nickname']]);
1629 // Remove all personal settings, especially connector settings
1630 DBA::delete('pconfig', ['uid' => $uid]);
1632 // The user and related data will be deleted in Friendica\Worker\ExpireAndRemoveUsers
1633 DBA::update('user', ['account_removed' => true, 'account_expires_on' => DateTimeFormat::utc('now + 7 day')], ['uid' => $uid]);
1634 Worker::add(Worker::PRIORITY_HIGH, 'Notifier', Delivery::REMOVAL, $uid);
1636 // Send an update to the directory
1637 $self = DBA::selectFirst('contact', ['url'], ['uid' => $uid, 'self' => true]);
1638 Worker::add(Worker::PRIORITY_LOW, 'Directory', $self['url']);
1640 // Remove the user relevant data
1641 Worker::add(Worker::PRIORITY_NEGLIGIBLE, 'RemoveUser', $uid);
1643 self::setRegisterMethodByUserCount();
1648 * Return all identities to a user
1650 * @param int $uid The user id
1651 * @return array All identities for this user
1653 * Example for a return:
1657 * 'username' => 'maxmuster',
1658 * 'nickname' => 'Max Mustermann'
1662 * 'username' => 'johndoe',
1663 * 'nickname' => 'John Doe'
1668 public static function identities(int $uid): array
1676 $user = DBA::selectFirst('user', ['uid', 'nickname', 'username', 'parent-uid'], ['uid' => $uid]);
1677 if (!DBA::isResult($user)) {
1681 if (!$user['parent-uid']) {
1682 // First add our own entry
1684 'uid' => $user['uid'],
1685 'username' => $user['username'],
1686 'nickname' => $user['nickname']
1689 // Then add all the children
1692 ['uid', 'username', 'nickname'],
1693 ['parent-uid' => $user['uid'], 'account_removed' => false]
1695 if (DBA::isResult($r)) {
1696 $identities = array_merge($identities, DBA::toArray($r));
1699 // First entry is our parent
1702 ['uid', 'username', 'nickname'],
1703 ['uid' => $user['parent-uid'], 'account_removed' => false]
1705 if (DBA::isResult($r)) {
1706 $identities = DBA::toArray($r);
1709 // Then add all siblings
1712 ['uid', 'username', 'nickname'],
1713 ['parent-uid' => $user['parent-uid'], 'account_removed' => false]
1715 if (DBA::isResult($r)) {
1716 $identities = array_merge($identities, DBA::toArray($r));
1721 "SELECT `user`.`uid`, `user`.`username`, `user`.`nickname`
1723 INNER JOIN `user` ON `manage`.`mid` = `user`.`uid`
1724 WHERE `user`.`account_removed` = 0 AND `manage`.`uid` = ?",
1727 if (DBA::isResult($r)) {
1728 $identities = array_merge($identities, DBA::toArray($r));
1735 * Check if the given user id has delegations or is delegated
1740 public static function hasIdentities(int $uid): bool
1746 $user = DBA::selectFirst('user', ['parent-uid'], ['uid' => $uid, 'account_removed' => false]);
1747 if (!DBA::isResult($user)) {
1751 if ($user['parent-uid']) {
1755 if (DBA::exists('user', ['parent-uid' => $uid, 'account_removed' => false])) {
1759 if (DBA::exists('manage', ['uid' => $uid])) {
1767 * Returns statistical information about the current users of this node
1773 public static function getStatistics(): array
1777 'active_users_halfyear' => 0,
1778 'active_users_monthly' => 0,
1779 'active_users_weekly' => 0,
1782 $userStmt = DBA::select('owner-view', ['uid', 'last-activity', 'last-item'],
1783 ["`verified` AND `last-activity` > ? AND NOT `blocked`
1784 AND NOT `account_removed` AND NOT `account_expired`",
1785 DBA::NULL_DATETIME]);
1786 if (!DBA::isResult($userStmt)) {
1790 $halfyear = time() - (180 * 24 * 60 * 60);
1791 $month = time() - (30 * 24 * 60 * 60);
1792 $week = time() - (7 * 24 * 60 * 60);
1794 while ($user = DBA::fetch($userStmt)) {
1795 $statistics['total_users']++;
1797 if ((strtotime($user['last-activity']) > $halfyear) || (strtotime($user['last-item']) > $halfyear)
1799 $statistics['active_users_halfyear']++;
1802 if ((strtotime($user['last-activity']) > $month) || (strtotime($user['last-item']) > $month)
1804 $statistics['active_users_monthly']++;
1807 if ((strtotime($user['last-activity']) > $week) || (strtotime($user['last-item']) > $week)
1809 $statistics['active_users_weekly']++;
1812 DBA::close($userStmt);
1818 * Get all users of the current node
1820 * @param int $start Start count (Default is 0)
1821 * @param int $count Count of the items per page (Default is @see Pager::ITEMS_PER_PAGE)
1822 * @param string $type The type of users, which should get (all, blocked, removed)
1823 * @param string $order Order of the user list (Default is 'contact.name')
1824 * @param bool $descending Order direction (Default is ascending)
1825 * @return array|bool The list of the users
1828 public static function getList(int $start = 0, int $count = Pager::ITEMS_PER_PAGE, string $type = 'all', string $order = 'name', bool $descending = false)
1830 $param = ['limit' => [$start, $count], 'order' => [$order => $descending]];
1834 $condition['account_removed'] = false;
1835 $condition['blocked'] = false;
1839 $condition['account_removed'] = false;
1840 $condition['blocked'] = true;
1841 $condition['verified'] = true;
1845 $condition['account_removed'] = true;
1849 return DBA::selectToArray('owner-view', [], $condition, $param);
1853 * Returns a list of lowercase admin email addresses from the comma-separated list in the config
1857 public static function getAdminEmailList(): array
1859 $adminEmails = strtolower(str_replace(' ', '', DI::config()->get('config', 'admin_email')));
1860 if (!$adminEmails) {
1864 return explode(',', $adminEmails);
1868 * Returns the complete list of admin user accounts
1870 * @param array $fields
1874 public static function getAdminList(array $fields = []): array
1877 'email' => self::getAdminEmailList(),
1878 'parent-uid' => null,
1881 'account_removed' => false,
1882 'account_expired' => false,
1885 return DBA::selectToArray('user', $fields, $condition, ['order' => ['uid']]);
1889 * Return a list of admin user accounts where each unique email address appears only once.
1891 * This method is meant for admin notifications that do not need to be sent multiple times to the same email address.
1893 * @param array $fields
1897 public static function getAdminListForEmailing(array $fields = []): array
1899 return array_filter(self::getAdminList($fields), function ($user) {
1900 static $emails = [];
1902 if (in_array($user['email'], $emails)) {
1906 $emails[] = $user['email'];
1912 public static function setRegisterMethodByUserCount()
1914 $max_registered_users = DI::config()->get('config', 'max_registered_users');
1915 if ($max_registered_users <= 0) {
1919 $register_policy = DI::config()->get('config', 'register_policy');
1920 if (!in_array($register_policy, [Module\Register::OPEN, Module\Register::CLOSED])) {
1921 Logger::debug('Unsupported register policy.', ['policy' => $register_policy]);
1925 $users = DBA::count('user', ['blocked' => false, 'account_removed' => false, 'account_expired' => false]);
1926 if (($users >= $max_registered_users) && ($register_policy == Module\Register::OPEN)) {
1927 DI::config()->set('config', 'register_policy', Module\Register::CLOSED);
1928 Logger::notice('Max users reached, registration is closed.', ['users' => $users, 'max' => $max_registered_users]);
1929 } elseif (($users < $max_registered_users) && ($register_policy == Module\Register::CLOSED)) {
1930 DI::config()->set('config', 'register_policy', Module\Register::OPEN);
1931 Logger::notice('Below maximum users, registration is opened.', ['users' => $users, 'max' => $max_registered_users]);
1933 Logger::debug('Unchanged register policy', ['policy' => $register_policy, 'users' => $users, 'max' => $max_registered_users]);