wcfsetup/install/files/lib/system/clipboard/action/UserClipboardAction.class.php

   1 <?php
   2
   3 namespace wcf\system\clipboard\action;
   4
   5 use wcf\data\clipboard\action\ClipboardAction;
   6 use wcf\data\user\group\UserGroup;
   7 use wcf\data\user\User;
   8 use wcf\data\user\UserAction;
   9 use wcf\system\database\util\PreparedStatementConditionBuilder;
  10 use wcf\system\request\LinkHandler;
  11 use wcf\system\WCF;
  12
  13 /**
  14  * Prepares clipboard editor items for user objects.
  15  *
  16  * @author  Alexander Ebert
  17  * @copyright   2001-2019 WoltLab GmbH
  18  * @license GNU Lesser General Public License <http://opensource.org/licenses/lgpl-license.php>
  19  */
  20 class UserClipboardAction extends AbstractClipboardAction
  21 {
  22     /**
  23      * @inheritDoc
  24      */
  25     protected $actionClassActions = ['delete', 'resendActivationMail', 'confirmEmail', 'unconfirmEmail'];
  26
  27     /**
  28      * @inheritDoc
  29      */
  30     protected $supportedActions = [
  31         'assignToGroup',
  32         'ban',
  33         'confirmEmail',
  34         'delete',
  35         'deleteUserContent',
  36         'enable',
  37         'exportMailAddress',
  38         'merge',
  39         'sendMail',
  40         'sendNewPassword',
  41         'resendActivationMail',
  42         'unconfirmEmail',
  43     ];
  44
  45     /**
  46      * @inheritDoc
  47      */
  48     public function execute(array $objects, ClipboardAction $action)
  49     {
  50         $item = parent::execute($objects, $action);
  51
  52         if ($item === null) {
  53             return;
  54         }
  55
  56         // handle actions
  57         switch ($action->actionName) {
  58             case 'assignToGroup':
  59                 $item->setURL(LinkHandler::getInstance()->getLink('UserAssignToGroup'));
  60                 break;
  61
  62             case 'delete':
  63                 $item->addInternalData(
  64                     'confirmMessage',
  65                     WCF::getLanguage()->getDynamicVariable(
  66                         'wcf.clipboard.item.com.woltlab.wcf.user.delete.confirmMessage',
  67                         [
  68                             'count' => $item->getCount(),
  69                         ]
  70                     )
  71                 );
  72                 break;
  73
  74             case 'exportMailAddress':
  75                 $item->setURL(LinkHandler::getInstance()->getLink('UserEmailAddressExport'));
  76                 break;
  77
  78             case 'merge':
  79                 $item->setURL(LinkHandler::getInstance()->getLink('UserMerge'));
  80                 break;
  81
  82             case 'sendMail':
  83                 $item->setURL(LinkHandler::getInstance()->getLink('UserMail'));
  84                 break;
  85
  86             case 'sendNewPassword':
  87                 $item->addParameter(
  88                     'confirmMessage',
  89                     WCF::getLanguage()->getDynamicVariable(
  90                         'wcf.clipboard.item.com.woltlab.wcf.user.sendNewPassword.confirmMessage',
  91                         [
  92                             'count' => $item->getCount(),
  93                         ]
  94                     )
  95                 );
  96                 break;
  97         }
  98
  99         return $item;
 100     }
 101
 102     /**
 103      * @inheritDoc
 104      */
 105     public function getClassName()
 106     {
 107         return UserAction::class;
 108     }
 109
 110     /**
 111      * @inheritDoc
 112      */
 113     public function getTypeName()
 114     {
 115         return 'com.woltlab.wcf.user';
 116     }
 117
 118     /**
 119      * Returns the ids of the users which can be deleted.
 120      *
 121      * @return  int[]
 122      */
 123     protected function validateDelete()
 124     {
 125         // check permissions
 126         if (!WCF::getSession()->getPermission('admin.user.canDeleteUser')) {
 127             return [];
 128         }
 129
 130         return $this->__validateAccessibleGroups(\array_keys($this->objects));
 131     }
 132
 133     /**
 134      * Returns the ids of the users which can be banned.
 135      *
 136      * @return  int[]
 137      */
 138     protected function validateBan()
 139     {
 140         // check permissions
 141         if (!WCF::getSession()->getPermission('admin.user.canBanUser')) {
 142             return [];
 143         }
 144
 145         $userIDs = [];
 146         foreach ($this->objects as $user) {
 147             if (!$user->banned) {
 148                 $userIDs[] = $user->userID;
 149             }
 150         }
 151
 152         return $this->__validateAccessibleGroups($userIDs);
 153     }
 154
 155     /**
 156      * Validates accessible groups.
 157      *
 158      * @param int[] $userIDs
 159      * @param bool $ignoreOwnUser
 160      * @return  int[]
 161      */
 162     protected function __validateAccessibleGroups(array $userIDs, $ignoreOwnUser = true)
 163     {
 164         if ($ignoreOwnUser) {
 165             foreach ($userIDs as $index => $userID) {
 166                 if ($userID == WCF::getUser()->userID) {
 167                     unset($userIDs[$index]);
 168                 }
 169             }
 170         }
 171
 172         // no valid users found
 173         if (empty($userIDs)) {
 174             return [];
 175         }
 176
 177         // fetch user to group associations
 178         $conditions = new PreparedStatementConditionBuilder();
 179         $conditions->add("userID IN (?)", [$userIDs]);
 180
 181         $sql = "SELECT  userID, groupID
 182                 FROM    wcf" . WCF_N . "_user_to_group
 183                 " . $conditions;
 184         $statement = WCF::getDB()->prepareStatement($sql);
 185         $statement->execute($conditions->getParameters());
 186
 187         $userToGroup = $statement->fetchMap('userID', 'groupID', false);
 188
 189         // validate if user's group is accessible for current user
 190         foreach ($userIDs as $index => $userID) {
 191             if (!isset($userToGroup[$userID]) || !UserGroup::isAccessibleGroup($userToGroup[$userID])) {
 192                 unset($userIDs[$index]);
 193             }
 194         }
 195
 196         return \array_values($userIDs);
 197     }
 198
 199     /**
 200      * Returns the ids of the users which can be marked as email confirmed.
 201      *
 202      * @return  int[]
 203      * @since   5.3
 204      */
 205     protected function validateConfirmEmail()
 206     {
 207         // check permissions
 208         if (!WCF::getSession()->getPermission('admin.user.canEnableUser')) {
 209             return [];
 210         }
 211
 212         $userIDs = [];
 213         foreach ($this->objects as $user) {
 214             /** @var User $user */
 215             if (!$user->isEmailConfirmed()) {
 216                 $userIDs[] = $user->userID;
 217             }
 218         }
 219
 220         return $this->__validateAccessibleGroups($userIDs);
 221     }
 222
 223     /**
 224      * Returns the ids of the users which can be unmarked as email confirmed.
 225      *
 226      * @return  int[]
 227      * @since   5.3
 228      */
 229     protected function validateUnconfirmEmail()
 230     {
 231         // check permissions
 232         if (!WCF::getSession()->getPermission('admin.user.canEnableUser')) {
 233             return [];
 234         }
 235
 236         $userIDs = [];
 237         foreach ($this->objects as $user) {
 238             /** @var User $user */
 239             if ($user->isEmailConfirmed()) {
 240                 $userIDs[] = $user->userID;
 241             }
 242         }
 243
 244         return $this->__validateAccessibleGroups($userIDs);
 245     }
 246
 247     /**
 248      * Returns the ids of the users which can be sent new passwords.
 249      *
 250      * @return  int[]
 251      */
 252     public function validateSendNewPassword()
 253     {
 254         // check permissions
 255         if (!WCF::getSession()->getPermission('admin.user.canEditPassword')) {
 256             return [];
 257         }
 258
 259         $userIDs = [];
 260         /** @var User $user */
 261         foreach ($this->objects as $user) {
 262             if (empty($user->authData)) {
 263                 $userIDs[] = $user->userID;
 264             }
 265         }
 266
 267         return $this->__validateAccessibleGroups($userIDs);
 268     }
 269
 270     /**
 271      * Returns the ids of the users which can be enabled.
 272      *
 273      * @return  int[]
 274      * @since   3.0
 275      */
 276     protected function validateEnable()
 277     {
 278         // check permissions
 279         if (!WCF::getSession()->getPermission('admin.user.canEnableUser')) {
 280             return [];
 281         }
 282
 283         $userIDs = [];
 284         foreach ($this->objects as $user) {
 285             /** @var User $user */
 286             if ($user->pendingActivation()) {
 287                 $userIDs[] = $user->userID;
 288             }
 289         }
 290
 291         return $userIDs;
 292     }
 293
 294     /**
 295      * Returns the ids of the users which can be merge.
 296      *
 297      * @return  int[]
 298      * @since   3.0
 299      */
 300     protected function validateMerge()
 301     {
 302         // check permissions
 303         if (!WCF::getSession()->getPermission('admin.user.canEditUser')) {
 304             return [];
 305         }
 306
 307         $userIDs = \array_keys($this->objects);
 308         if (\count($userIDs) < 2) {
 309             return [];
 310         }
 311
 312         return $userIDs;
 313     }
 314
 315     /**
 316      * Returns the ids of the users which aren't activated.
 317      *
 318      * @return  int[]
 319      * @since   5.2
 320      */
 321     protected function validateResendActivationMail()
 322     {
 323         // check permissions
 324         if (
 325             !WCF::getSession()->getPermission('admin.user.canEnableUser')
 326             || !(REGISTER_ACTIVATION_METHOD & User::REGISTER_ACTIVATION_USER)
 327         ) {
 328             return [];
 329         }
 330
 331         $userIDs = [];
 332         foreach ($this->objects as $user) {
 333             /** @var User $user */
 334             if ($user->canEmailConfirm()) {
 335                 $userIDs[] = $user->userID;
 336             }
 337         }
 338
 339         return $userIDs;
 340     }
 341
 342     /**
 343      * Returns the ids of the users whose contents can be deleted.
 344      *
 345      * @return      int[]
 346      * @since       5.4
 347      */
 348     protected function validateDeleteUserContent()
 349     {
 350         if (!WCF::getSession()->getPermission('admin.user.canDeleteUser')) {
 351             return [];
 352         }
 353
 354         return $this->__validateAccessibleGroups(\array_keys($this->objects));
 355     }
 356 }