@param $guildId

@return \GameBackend\Entity\SRO\Shard\GuildMember[]|null
480027
public function getGuildMember4GuildId($guildId)
    {
        $query = $this->createQueryBuilder('p')
            ->select('p', 'character')
            ->join('p.character', 'character')
            ->where('p.guild = :guild')
            ->setParameter('guild', $guildId)
            ->orderBy('p.memberClass', 'asc')
            ->addOrderBy('p.level', 'desc');

        return $query->getQuery()->getResult();
    }
1036877
public function GetPlayerAchievementsAPI($appId)
    {
        // Set up the api details
        $this->method  = 'GetPlayerAchievementsAPI';
        $this->version = 'v0001';

        // Set up the arguments
        $arguments = [
            'steamid' => $this->steamId,
            'appid'   => $appId,
            'l'       => 'english',
        ];

        // Get the client
        $stats = $this->GetSchemaForGame($appId);

        // Make sure the game has achievements
        if ($stats == null || $stats->game->availableGameStats->achievements == null) {
            return null;
        }

        $client = $this->setUpClient($arguments)->playerstats;
        $stats  = $stats->game->availableGameStats->achievements;

        // Clean up the games
        $achievements = $this->convertToObjects($client->achievements, $stats);

        return $achievements;
    }
1141349
protected function loadUserRolesViaData($userId)
    {
        $crudRoles = $this->userRoleIdentifier->listEntries(['user' => $userId], ['user' => '=']);
        $roles = ['ROLE_USER'];
        if ($crudRoles !== null) {
            foreach ($crudRoles as $crudRole) {
                $role = $crudRole->get('role');
                $roles[] = $role['name'];
            }
        }
        return $roles;
    }
208611
public function getMessageIds(?string $blockId = null): GetMessageIdsResponse
    {
        $command = new GetMessageIdsCommand($blockId);
        $response = $this->driver->executeCommand($command);

        return new GetMessageIdsResponse($response->getRawData());
    }
1052884
public function runePage($runePageId)
	{
		if ( ! isset($this->info['runePages']))
		{
			// no rune pages
			return null;
		}
		$runePages = $this->info['runePages'];
		if (isset($runePages[$runePageId]))
		{
			return $runePages[$runePageId];
		}

		return null;
	}
711234
public function getNode($nodeId)
    {
        static $instance = array();
        if (isset($instance[$nodeId]))
            return $instance[$nodeId];
        $nodes = $this->nodeSet;
        if (empty($nodes))
            return NULL;
        foreach ($nodes as $node):
            if ($node->getId() == $nodeId):
                $instance[$nodeId] = &$node;
                break;
            endif;
        endforeach;
        return NULL;
    }
993144
protected function getCache($documentId)
    {
        if (isset($this->cache[$documentId])) {
            return $this->cache[$documentId];
        }

        return null;
    }
375052
public static function getByID($gID)
    {
        $db = Database::connection();
        $g = CacheLocal::getEntry('group', $gID);
        if (is_object($g)) {
            return $g;
        }

        $row = $db->fetchAssoc('select * from ' . $db->getDatabasePlatform()->quoteSingleIdentifier('Groups') . ' where gID = ?', [$gID]);
        if ($row) {
            $g = \Core::make('\Concrete\Core\User\Group\Group');
            $g->setPropertiesFromArray($row);
            CacheLocal::set('group', $gID, $g);

            return $g;
        }
    }
489385
public function get_roles($group = null)
	{
		// When group is empty, attempt to get groups from a current login
		if ($group === null)
		{
			if ($login = \Auth::instance()
				and is_array($groups = $login->get_groups())
				and isset($groups[0][1]))
			{
				$group = $groups[0][1];
			}
		}

		// if it's a group id, find the corresponding object
		elseif (is_numeric($group) and isset(static::$_valid_groups[$group]))
		{
			$group = static::$_valid_groups[$group];
		}

		// if the group was found, return the roles
		if ($group instanceOf Model\Auth_Group)
		{
			return $group->roles;
		}
		else
		{
			// no group found, so no roles either
			return array();
		}
	}
528901
public function getGroups( $uid ) {
        static $groups = [];
        if ( isset($groups[$uid]) )
            return $groups[$uid];
        $user_groups = Db::table( $this->prefix.$this->_config['auth_group_access'] )
            ->alias('a')
            ->join( $this->prefix.$this->_config['auth_group']." g", "g.id=a.group_id" )
            ->where( "a.uid='$uid' and g.status='1'" )
            ->field( 'uid,group_id,title,rules' )->select();
        $groups[$uid] = $user_groups ? $user_groups : [];
        return $groups[$uid];
    }
1019043
protected function getMemberIDList()
    {
        if (!$this->owner || !$this->owner->exists()) {
            return null;
        }

        if ($this->owner instanceof Group) {
            return $this->owner->Members()->column('ID');
        }

        return [$this->owner->ID];
    }
1147778
public static function getProviderById($providerId)
    {
        foreach (self::getAllProviders() as $provider) {
            if ($provider->getId() == $providerId && $provider->isAvailable()) {
                return $provider;
            }
        }
        
        return null;
    }
1340913
protected function loadEntities(array $entityIds)
    {
        if (count($entityIds) === 0) {
            return null;
        }

        $entities = [];

        // Create and store the entities associated with each Id
        foreach ($entityIds as $entityId) {
            $hash = $this->getEntityHashById($entityId);

            if ($hash === null) {
                return null;
            }

            $entities[] = $this->loadEntity($hash);
        }

        return $entities;
    }
168751
public function recentGame($gameId)
	{
		if ( ! isset($this->info['recentGames']))
		{
			// no rune pages
			return null;
		}
		$recentGames = $this->info['recentGames'];

		return $recentGames->game($gameId);
	}
107136
public function member($memberId)
	{
		if (isset($this->info['memberList'][$memberId]))
		{
			return $this->info['memberList'][$memberId];
		}

		// could not find the member
		return null;
	}
144595
public function getObjectInstanceByGuid($guid)
    {
        if (isset($this->objectsByGuid[$guid])) {
            return $this->objectsByGuid[$guid];
        } else {
            return null;
        }
    }
384784
public function participantsUserIds($userId = null)
    {
        $users = $this->participants()->lists('user_id');

        if ($userId) {
            $users[] = $userId;
        }

        return $users;
    }