PHP IGroupManager::get方法代码示例

 protected function tearDown()
 {
     foreach ($this->users as $user) {
         $user->delete();
     }
     $this->groupManager->get('admin')->delete();
     parent::tearDown();
 }

 /**
  * @param string $id
  * @return DataResponse
  */
 public function destroy($id)
 {
     $group = $this->groupManager->get($id);
     if ($group) {
         if ($group->delete()) {
             return new DataResponse(array('status' => 'success', 'data' => array('groupname' => $id)), Http::STATUS_NO_CONTENT);
         }
     }
     return new DataResponse(array('status' => 'error', 'data' => array('message' => (string) $this->l10n->t('Unable to delete group.'))), Http::STATUS_FORBIDDEN);
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $uid = $input->getArgument('uid');
     if ($this->userManager->userExists($uid)) {
         $output->writeln('<error>The user "' . $uid . '" already exists.</error>');
         return 1;
     }
     if ($input->getOption('password-from-env')) {
         $password = getenv('OC_PASS');
         if (!$password) {
             $output->writeln('<error>--password-from-env given, but OC_PASS is empty!</error>');
             return 1;
         }
     } elseif ($input->isInteractive()) {
         /** @var $dialog \Symfony\Component\Console\Helper\DialogHelper */
         $dialog = $this->getHelperSet()->get('dialog');
         $password = $dialog->askHiddenResponse($output, '<question>Enter password: </question>', false);
         $confirm = $dialog->askHiddenResponse($output, '<question>Confirm password: </question>', false);
         if ($password !== $confirm) {
             $output->writeln("<error>Passwords did not match!</error>");
             return 1;
         }
     } else {
         $output->writeln("<error>Interactive input or --password-from-env is needed for entering a password!</error>");
         return 1;
     }
     $user = $this->userManager->createUser($input->getArgument('uid'), $password);
     if ($user instanceof IUser) {
         $output->writeln('<info>The user "' . $user->getUID() . '" was created successfully</info>');
     } else {
         $output->writeln('<error>An error occurred while creating the user</error>');
         return 1;
     }
     if ($input->getOption('display-name')) {
         $user->setDisplayName($input->getOption('display-name'));
         $output->writeln('Display name set to "' . $user->getDisplayName() . '"');
     }
     foreach ($input->getOption('group') as $groupName) {
         $group = $this->groupManager->get($groupName);
         if (!$group) {
             $this->groupManager->createGroup($groupName);
             $group = $this->groupManager->get($groupName);
             $output->writeln('Created group "' . $group->getGID() . '"');
         }
         $group->addUser($user);
         $output->writeln('User "' . $user->getUID() . '" added to group "' . $group->getGID() . '"');
     }
 }

 /**
  * @NoAdminRequired
  *
  * @param string $username
  * @param string $password
  * @param array $groups
  * @param string $email
  * @return DataResponse
  */
 public function create($username, $password, array $groups = array(), $email = '')
 {
     if ($email !== '' && !$this->mail->validateAddress($email)) {
         return new DataResponse(array('message' => (string) $this->l10n->t('Invalid mail address')), Http::STATUS_UNPROCESSABLE_ENTITY);
     }
     if (!$this->isAdmin) {
         $userId = $this->userSession->getUser()->getUID();
         if (!empty($groups)) {
             foreach ($groups as $key => $group) {
                 if (!$this->subAdminFactory->isGroupAccessible($userId, $group)) {
                     unset($groups[$key]);
                 }
             }
         }
         if (empty($groups)) {
             $groups = $this->subAdminFactory->getSubAdminsOfGroups($userId);
         }
     }
     if ($this->userManager->userExists($username)) {
         return new DataResponse(array('message' => (string) $this->l10n->t('A user with that name already exists.')), Http::STATUS_CONFLICT);
     }
     try {
         $user = $this->userManager->createUser($username, $password);
     } catch (\Exception $exception) {
         return new DataResponse(array('message' => (string) $this->l10n->t('Unable to create user.')), Http::STATUS_FORBIDDEN);
     }
     if ($user instanceof User) {
         if ($groups !== null) {
             foreach ($groups as $groupName) {
                 $group = $this->groupManager->get($groupName);
                 if (empty($group)) {
                     $group = $this->groupManager->createGroup($groupName);
                 }
                 $group->addUser($user);
             }
         }
         /**
          * Send new user mail only if a mail is set
          */
         if ($email !== '') {
             $this->config->setUserValue($username, 'settings', 'email', $email);
             // data for the mail template
             $mailData = array('username' => $username, 'url' => $this->urlGenerator->getAbsoluteURL('/'));
             $mail = new TemplateResponse('settings', 'email.new_user', $mailData, 'blank');
             $mailContent = $mail->render();
             $mail = new TemplateResponse('settings', 'email.new_user_plain_text', $mailData, 'blank');
             $plainTextMailContent = $mail->render();
             $subject = $this->l10n->t('Your %s account was created', [$this->defaults->getName()]);
             try {
                 $this->mail->send($email, $username, $subject, $mailContent, $this->fromMailAddress, $this->defaults->getName(), 1, $plainTextMailContent);
             } catch (\Exception $e) {
                 $this->log->error("Can't send new user mail to {$email}: " . $e->getMessage(), array('app' => 'settings'));
             }
         }
         // fetch users groups
         $userGroups = $this->groupManager->getUserGroupIds($user);
         return new DataResponse($this->formatUserForIndex($user, $userGroups), Http::STATUS_CREATED);
     }
     return new DataResponse(array('message' => (string) $this->l10n->t('Unable to create user.')), Http::STATUS_FORBIDDEN);
 }

 public function testIsUserAccessibleAdmin()
 {
     $subAdmin = new \OC\SubAdmin($this->userManager, $this->groupManager, $this->dbConn);
     $this->assertTrue($subAdmin->createSubAdmin($this->users[0], $this->groups[0]));
     $this->groupManager->get('admin')->addUser($this->users[1]);
     $this->assertFalse($subAdmin->isUserAccessible($this->users[0], $this->users[1]));
 }

 /**
  * Sharing a file or folder with a group
  *
  * @param string $shareWith
  * @param int $fileSource File ID that is being shared
  * @param string $itemType File type that is being shared (file or folder)
  * @param string $fileTarget File path
  * @param int $shareId The Share ID of this share
  * @param bool $isSharing True if sharing, false if unsharing
  */
 protected function shareFileOrFolderWithGroup($shareWith, $fileSource, $itemType, $fileTarget, $shareId, $isSharing)
 {
     if ($isSharing) {
         $actionSharer = 'shared_group_self';
         $actionOwner = 'reshared_group_by';
         $actionUser = 'shared_with_by';
     } else {
         $actionSharer = 'unshared_group_self';
         $actionOwner = 'unshared_group_by';
         $actionUser = 'unshared_by';
     }
     // Members of the new group
     $group = $this->groupManager->get($shareWith);
     if (!$group instanceof IGroup) {
         return;
     }
     // User performing the share
     $this->shareNotificationForSharer($actionSharer, $shareWith, $fileSource, $itemType);
     $this->shareNotificationForOriginalOwners($this->currentUser, $actionOwner, $shareWith, $fileSource, $itemType);
     $offset = 0;
     $users = $group->searchUsers('', self::USER_BATCH_SIZE, $offset);
     while (!empty($users)) {
         $this->addNotificationsForGroupUsers($users, $actionUser, $fileSource, $itemType, $fileTarget, $shareId);
         $offset += self::USER_BATCH_SIZE;
         $users = $group->searchUsers('', self::USER_BATCH_SIZE, $offset);
     }
 }

 /**
  * Count all unique users visible for the current admin/subadmin.
  *
  * @NoAdminRequired
  *
  * @return DataResponse
  */
 public function stats()
 {
     $userCount = 0;
     if ($this->isAdmin) {
         $countByBackend = $this->userManager->countUsers();
         if (!empty($countByBackend)) {
             foreach ($countByBackend as $count) {
                 $userCount += $count;
             }
         }
     } else {
         $groupNames = $this->subAdminFactory->getSubAdminsOfGroups($this->userSession->getUser()->getUID());
         $uniqueUsers = [];
         foreach ($groupNames as $groupName) {
             $group = $this->groupManager->get($groupName);
             if (!is_null($group)) {
                 foreach ($group->getUsers() as $uid => $displayName) {
                     $uniqueUsers[$uid] = true;
                 }
             }
         }
         $userCount = count($uniqueUsers);
     }
     return new DataResponse(['totalUsers' => $userCount]);
 }

 /**
  * Sharing a file or folder with a group
  *
  * @param string $shareWith
  * @param int $fileSource File ID that is being shared
  * @param string $itemType File type that is being shared (file or folder)
  * @param string $fileTarget File path
  * @param int $shareId The Share ID of this share
  */
 protected function shareFileOrFolderWithGroup($shareWith, $fileSource, $itemType, $fileTarget, $shareId)
 {
     // Members of the new group
     $affectedUsers = array();
     $group = $this->groupManager->get($shareWith);
     if (!$group instanceof \OCP\IGroup) {
         return;
     }
     // User performing the share
     $this->shareNotificationForSharer('shared_group_self', $shareWith, $fileSource, $itemType);
     $this->shareNotificationForOriginalOwners($this->currentUser, 'reshared_group_by', $shareWith, $fileSource, $itemType);
     $usersInGroup = $group->searchUsers('');
     foreach ($usersInGroup as $user) {
         $affectedUsers[$user->getUID()] = $fileTarget;
     }
     // Remove the triggering user, we already managed his notifications
     unset($affectedUsers[$this->currentUser]);
     if (empty($affectedUsers)) {
         return;
     }
     $filteredStreamUsersInGroup = $this->userSettings->filterUsersBySetting(array_keys($affectedUsers), 'stream', Files_Sharing::TYPE_SHARED);
     $filteredEmailUsersInGroup = $this->userSettings->filterUsersBySetting(array_keys($affectedUsers), 'email', Files_Sharing::TYPE_SHARED);
     $affectedUsers = $this->fixPathsForShareExceptions($affectedUsers, $shareId);
     foreach ($affectedUsers as $user => $path) {
         if (empty($filteredStreamUsersInGroup[$user]) && empty($filteredEmailUsersInGroup[$user])) {
             continue;
         }
         $this->addNotificationsForUser($user, 'shared_with_by', array($path, $this->currentUser), $fileSource, $path, $itemType === 'file', !empty($filteredStreamUsersInGroup[$user]), !empty($filteredEmailUsersInGroup[$user]) ? $filteredEmailUsersInGroup[$user] : 0);
     }
 }

 /**
  * Returns a specific principal, specified by it's path.
  * The returned structure should be the exact same as from
  * getPrincipalsByPrefix.
  *
  * @param string $path
  * @return array
  */
 public function getPrincipalByPath($path)
 {
     $elements = explode('/', $path);
     if ($elements[0] !== 'principals') {
         return null;
     }
     if ($elements[1] !== 'groups') {
         return null;
     }
     $name = $elements[2];
     $user = $this->groupManager->get($name);
     if (!is_null($user)) {
         return $this->groupToPrincipal($user);
     }
     return null;
 }

 /**
  * @param string $search
  */
 protected function getGroups($search)
 {
     $this->result['groups'] = $this->result['exact']['groups'] = [];
     $groups = $this->groupManager->search($search, $this->limit, $this->offset);
     $groups = array_map(function (IGroup $group) {
         return $group->getGID();
     }, $groups);
     if (sizeof($groups) < $this->limit) {
         $this->reachedEndFor[] = 'groups';
     }
     $userGroups = [];
     if (!empty($groups) && $this->shareWithGroupOnly) {
         // Intersect all the groups that match with the groups this user is a member of
         $userGroups = $this->groupManager->getUserGroups($this->userSession->getUser());
         $userGroups = array_map(function (IGroup $group) {
             return $group->getGID();
         }, $userGroups);
         $groups = array_intersect($groups, $userGroups);
     }
     foreach ($groups as $gid) {
         if (strtolower($gid) === $search) {
             $this->result['exact']['groups'][] = ['label' => $search, 'value' => ['shareType' => Share::SHARE_TYPE_GROUP, 'shareWith' => $search]];
         } else {
             $this->result['groups'][] = ['label' => $gid, 'value' => ['shareType' => Share::SHARE_TYPE_GROUP, 'shareWith' => $gid]];
         }
     }
     if ($this->offset === 0 && empty($this->result['exact']['groups'])) {
         // On page one we try if the search result has a direct hit on the
         // user id and if so, we add that to the exact match list
         $group = $this->groupManager->get($search);
         if ($group instanceof IGroup && (!$this->shareWithGroupOnly || in_array($group->getGID(), $userGroups))) {
             array_push($this->result['exact']['groups'], ['label' => $group->getGID(), 'value' => ['shareType' => Share::SHARE_TYPE_GROUP, 'shareWith' => $group->getGID()]]);
         }
     }
 }

 /**
  * Create a share object from an database row
  *
  * @param mixed[] $data
  * @return Share
  */
 private function createShare($data)
 {
     $share = new Share();
     $share->setId((int) $data['id'])->setShareType((int) $data['share_type'])->setPermissions((int) $data['permissions'])->setTarget($data['file_target'])->setShareTime((int) $data['stime'])->setMailSend((bool) $data['mail_send']);
     if ($share->getShareType() === \OCP\Share::SHARE_TYPE_USER) {
         $share->setSharedWith($this->userManager->get($data['share_with']));
     } else {
         if ($share->getShareType() === \OCP\Share::SHARE_TYPE_GROUP) {
             $share->setSharedWith($this->groupManager->get($data['share_with']));
         } else {
             if ($share->getShareType() === \OCP\Share::SHARE_TYPE_LINK) {
                 $share->setPassword($data['share_with']);
                 $share->setToken($data['token']);
             } else {
                 $share->setSharedWith($data['share_with']);
             }
         }
     }
     $share->setSharedBy($this->userManager->get($data['uid_owner']));
     // TODO: getById can return an array. How to handle this properly??
     $folder = $this->rootFolder->getUserFolder($share->getSharedBy()->getUID());
     $path = $folder->getById((int) $data['file_source'])[0];
     $owner = $path->getOwner();
     $share->setShareOwner($owner);
     $path = $this->rootFolder->getUserFolder($owner->getUID())->getById((int) $data['file_source'])[0];
     $share->setPath($path);
     if ($data['expiration'] !== null) {
         $expiration = \DateTime::createFromFormat('Y-m-d H:i:s', $data['expiration']);
         $share->setExpirationDate($expiration);
     }
     return $share;
 }

 /**
  * @param ManagerEvent $event
  */
 public function event(ManagerEvent $event)
 {
     $actor = $this->session->getUser();
     if ($actor instanceof IUser) {
         $actor = $actor->getUID();
     } else {
         $actor = '';
     }
     $activity = $this->activityManager->generateEvent();
     $activity->setApp(Extension::APP_NAME)->setType(Extension::APP_NAME)->setAuthor($actor);
     if ($event->getEvent() === ManagerEvent::EVENT_CREATE) {
         $activity->setSubject(Extension::CREATE_TAG, [$actor, $this->prepareTagAsParameter($event->getTag())]);
     } else {
         if ($event->getEvent() === ManagerEvent::EVENT_UPDATE) {
             $activity->setSubject(Extension::UPDATE_TAG, [$actor, $this->prepareTagAsParameter($event->getTag()), $this->prepareTagAsParameter($event->getTagBefore())]);
         } else {
             if ($event->getEvent() === ManagerEvent::EVENT_DELETE) {
                 $activity->setSubject(Extension::DELETE_TAG, [$actor, $this->prepareTagAsParameter($event->getTag())]);
             } else {
                 return;
             }
         }
     }
     $group = $this->groupManager->get('admin');
     if ($group instanceof IGroup) {
         foreach ($group->getUsers() as $user) {
             $activity->setAffectedUser($user->getUID());
             $this->activityManager->publish($activity);
         }
     }
 }

 /**
  * Create a share object from an database row
  *
  * @param mixed[] $data
  * @return \OCP\Share\IShare
  * @throws InvalidShare
  */
 private function createShare($data)
 {
     $share = new Share();
     $share->setId((int) $data['id'])->setShareType((int) $data['share_type'])->setPermissions((int) $data['permissions'])->setTarget($data['file_target'])->setMailSend((bool) $data['mail_send']);
     $shareTime = new \DateTime();
     $shareTime->setTimestamp((int) $data['stime']);
     $share->setShareTime($shareTime);
     if ($share->getShareType() === \OCP\Share::SHARE_TYPE_USER) {
         $sharedWith = $this->userManager->get($data['share_with']);
         if ($sharedWith === null) {
             throw new InvalidShare();
         }
         $share->setSharedWith($sharedWith);
     } else {
         if ($share->getShareType() === \OCP\Share::SHARE_TYPE_GROUP) {
             $sharedWith = $this->groupManager->get($data['share_with']);
             if ($sharedWith === null) {
                 throw new InvalidShare();
             }
             $share->setSharedWith($sharedWith);
         } else {
             if ($share->getShareType() === \OCP\Share::SHARE_TYPE_LINK) {
                 $share->setPassword($data['share_with']);
                 $share->setToken($data['token']);
             }
         }
     }
     if ($data['uid_initiator'] === null) {
         //OLD SHARE
         $sharedBy = $this->userManager->get($data['uid_owner']);
         if ($sharedBy === null) {
             throw new InvalidShare();
         }
         $share->setSharedBy($sharedBy);
         $path = $this->getNode($share->getSharedBy(), (int) $data['file_source']);
         $owner = $path->getOwner();
         $share->setShareOwner($owner);
     } else {
         //New share!
         $sharedBy = $this->userManager->get($data['uid_initiator']);
         $shareOwner = $this->userManager->get($data['uid_owner']);
         if ($sharedBy === null || $shareOwner === null) {
             throw new InvalidShare();
         }
         $share->setSharedBy($sharedBy);
         $share->setShareOwner($shareOwner);
     }
     $path = $this->getNode($share->getShareOwner(), (int) $data['file_source']);
     $share->setNode($path);
     if ($data['expiration'] !== null) {
         $expiration = \DateTime::createFromFormat('Y-m-d H:i:s', $data['expiration']);
         $share->setExpirationDate($expiration);
     }
     $share->setProviderId($this->identifier());
     return $share;
 }

 public function testAddGroup()
 {
     $group = $this->getUniqueId();
     $_POST = ['groupid' => $group];
     $result = $this->api->addGroup([]);
     $this->assertInstanceOf('OC_OCS_Result', $result);
     $this->assertTrue($result->succeeded());
     $this->assertTrue($this->groupManager->groupExists($group));
     $this->groupManager->get($group)->delete();
 }

 /**
  * get all SubAdmins
  * @return array
  */
 public function getAllSubAdmins()
 {
     $qb = $this->dbConn->getQueryBuilder();
     $result = $qb->select('*')->from('group_admin')->execute();
     $subadmins = [];
     while ($row = $result->fetch()) {
         $subadmins[] = ['user' => $this->userManager->get($row['uid']), 'group' => $this->groupManager->get($row['gid'])];
     }
     return $subadmins;
 }