Retrieve a list of all users the user is authorized to view or manage.

 @return [Array[MultiTenantUserSummary]] Array of MultiTenantUserSummary objects.
506034
def list_silo_users
      r = execute(make_xml('MultiTenantUserListingRequest'), '1.2')
      arr = []
      if r.success
        r.res.elements.each('MultiTenantUserListingResponse/MultiTenantUserSummaries/MultiTenantUserSummary') do |user|
          arr << MultiTenantUserSummary.parse(user)
        end
      end
      arr
    end
1254900
def GetAllUserSummaries():
  """"""
  grr_api = maintenance_utils.InitGRRRootAPI()
  user_wrappers = sorted(grr_api.ListGrrUsers(), key=lambda x: x.username)
  summaries = [_Summarize(w.data) for w in user_wrappers]
  return "\n\n".join(summaries)
1074306
public function getUsersPairs()
    {
        // Check and init cache
        if (!self::$cached_users_pairs) {
            $user_collection = new AdminUserRepository;
            $user_collection->addOrderByField('name');
            foreach ($user_collection->getAsArrayOfObjects() as $v) {
                /** @var AdminUser $v */
                self::$cached_users_pairs[$v->getId()] = $v->getName() . ' ' . $v->getSurname() . ' [' . $v->getLogin() . ']';
            }
        }

        return self::$cached_users_pairs;
    }
623094
def users(options = {})
      batches = Enumerator.new do |y|
        options = options.merge(group_name: @name)
        resp = @client.get_group(options)
        resp.each_page do |page|
          batch = []
          page.data.users.each do |u|
            batch << User.new(
              name: u.user_name,
              data: u,
              client: @client
            )
          end
          y.yield(batch)
        end
      end
      User::Collection.new(batches)
    end
1234794
def list(self):
        
        
        uri = URITemplate(self.baseuri + '/{owner}').expand(
            owner=self.username)
        return self.session.get(uri)
425566
def users(self):
        
        if not self.__users:
            self.__users = Users(self.__connection)
        return self.__users
508855
def users(self):
        
        if self._user_manager is None:
            self._user_manager = UserManager(session=self._session)
        return self._user_manager
1203734
def obtain_users(access = nil)
      admins = obtain_users
      if access.is_a?(Array)
        admins = admins.where(:id => access) if !access.blank?
      else
        admins = admins.where(:access_level => access) if !access.blank?
      end

      admins
    end
64031
def get_users(self, attr_map=None):
        
        kwargs = {"UserPoolId":self.user_pool_id}

        response = self.client.list_users(**kwargs)
        return [self.get_user_obj(user.get('Username'),
                                  attribute_list=user.get('Attributes'),
                                  metadata={'username':user.get('Username')},
                                  attr_map=attr_map)
                for user in response.get('Users')]
1302328
public function index()
    {
        $userGroupPermission = $this->UserGroupPermission->newEntity();
        
        $controllers = $this->Acl->getControllers();
        $groups = $users = [];
        
        if( !empty($controllers['user']) ) {
            $Users = TableRegistry::get($controllers['user']);
            $users = $Users->find()->select(['id','email'])->toArray();
        }
        if( !empty($controllers['group']) ) {
            $groups = TableRegistry::get($controllers['group']);
            $groups = $groups->find()->select(['id','name'])->toArray();
        }

        $permission = $this->UserGroupPermission->Permission->find()->select(['id','unique_string'])
            ->order(['unique_string'=>'DESC'])->toArray();
        $this->set(compact('userGroupPermission', 'permission', 'users', 'groups'));
        $this->set('_serialize', ['userGroupPermission']);
    }
1097257
def sorted_users
      users = []
      ::User.find_each do |user|
        users.push(UserRecord.new(user.id, user.user_key, date_since_last_cache(user)))
      end
      users.sort_by(&:last_stats_update)
    end
636429
def get_all_permissions(self):
        
        if self.all_permissions is None:
            permissions = self.client.call('User_Customer_CustomerPermission_Permission', 'getAllObjects')
            self.all_permissions = sorted(permissions, key=itemgetter('keyName'))
        return self.all_permissions
1199165
def users(self):
        
        if not hasattr(self, "_users"):
            us = {}
            if "users" in self.doc:
                for ur in self.doc["users"]:
                    us[ur["name"]] = u = copy.deepcopy(ur["user"])
                    BytesOrFile.maybe_set(u, "client-certificate")
                    BytesOrFile.maybe_set(u, "client-key")
            self._users = us
        return self._users
447236
def managed_users
      Dir.glob("#{USER_DIR}/*.yml").map do |file|
        YAML.load_file(file).map do |role, users|
          users.map do |user|
            User.new(
              role: role,
              user: user.keys.first,
              host: user['host'] || HOST_ALL
            )
          end
        end
      end.flatten
    end
782730
def list_users(self):
    
        '''  '''
        
    # construct url
        url = self.bucket_url + '/_user/'

    # send request and unwrap response
        response = requests.get(url)
        response = response.json()

        return response
564796
def users(self):
        
        return Users(url="%s/users" % self.root,
                     securityHandler=self._securityHandler,
                     proxy_url=self._proxy_url,
                     proxy_port=self._proxy_port)
1358879
List<User> getAllUsers(AccessToken accessToken, String... attributes) {
        return super.getAllResources(accessToken, attributes);
    }