@param string $groupName

@return boolean
179427
public function insertPausedTriggerGroup($groupName)
    {
        $result = $this->res->getPausedTriggerCol()->updateOne(
            ['groupName' => $groupName],
            ['$set' => ['groupName' => $groupName]],
            ['upsert' => true]
        );

        return $result->isAcknowledged() && $result->getUpsertedCount();
    }
1041200
public function closeGroup(string $groupName)
    {
        $this->useRedis(function($resource, $redis) use($groupName){
            $key = $this->getGroupNameKey($groupName);
            try{
                $redis->del($key);
                $redis->sRem($this->getGroupsKey(), $groupName);
            }
            catch(\Throwable $ex)
            {

            }
        });
    }
873719
public function removeUser($groupName, $username)
    {
        $groupDn = $this->dn($groupName);

        $userDn = $this->adldap->user()->dn($username);

        if (is_string($groupDn) && is_string($userDn)) {
            $del = [];
            $del['member'] = $userDn;

            return $this->connection->modDelete($groupDn, $del);
        }

        return false;
    }
178765
public function joinGroup(string $groupName, int $fd): bool
    {
        return $this->useRedis(function($resource, $redis) use($groupName, $fd){
            $key = $this->getGroupNameKey($groupName);
            return $redis->sadd($key, $fd) > 0;
        });
    }
1087033
public function setGroupClass(string $classname)
    {
        if (!class_exists($classname) || !is_subclass_of($classname, GroupInterface::class))
            throw new DomainException("Invalid group class: $classname");
        $this->group_class = $classname;
        return $this;
    }
846126
public boolean belongsToGroup(String groupName) {
        if (workgroups == null || workgroups.length == 0) {
            return false;
        }
        for (Workgroup g : workgroups) {
            if (g.getName().equals(groupName)) return true;
        }
        return false;
    }
939190
public function hasGroup($group)
    {
        if (is_string($group)) {
            return $this->groups->contains('name', $group);
        }

        return ! ! $group->intersect($this->groups)->count();
    }
1372178
public boolean belongsTo(String groupname) {
        if (groupname == null) {
            return false;
        }
        for (PMSecurityUserGroup g : getGroups()) {
            if (groupname.equalsIgnoreCase(g.getName())) {
                return true;
            }
        }
        return false;
    }
604938
public function load($groupName)
    {
        if (! count($this->readers)) {
            throw new \RuntimeException('No config readers attached');
        }

        if (! $groupName) {
            throw new \InvalidArgumentException('No config group specified');
        }

        if (! is_string($groupName)) {
            throw new \InvalidArgumentException('Config group must be a string');
        }

        if (isset($this->groups[$groupName])) {
            return $this->groups[$groupName];
        }

        $config = [];

        foreach ($this->readers as $reader) {
            if ($groupConfig = $reader->load($groupName)) {
                $config = array_replace_recursive($config, $groupConfig);
            }
        }

        $this->groups[$groupName] = $config;

        return $this->groups[$groupName];
    }
1368061
public function  getArguments($groupName = null, $multiple = false)
    {
        return $this->setRequired($this->updateRelations($this->builder->getArguments(), true, $multiple), $groupName);
    }
1008611
public function setGroup($groupName)
    {
        $tagGroup = TagGroup::where('slug', $this->taggingUtility->slug($groupName))->first();

        if ($tagGroup) {
            $this->group()->associate($tagGroup);
            $this->save();

            return $this;
        } else {
            throw new \RuntimeException('No Tag Group found: '. $groupName);
        }
    }
556433
private CmsGroup checkGroup(String groupName) {

        try {
            return getCms().readGroup(groupName);
        } catch (CmsException e) {
            throw new CmsIllegalArgumentException(e.getMessageContainer());
        }
    }
509115
public function getGroupPermissions($groupName)
    {
        if (!isset($this->config[$groupName])) {
            return [];
        }

        return array_keys($this->config[$groupName]['permissions']);
    }
1133030
public function deactivateGroup($featureName, $groupName)
    {
        $feature = $this->getFeature($featureName);
        $feature->removeGroup($groupName);
        $this->saveFeature($feature);
    }
1311073
public function userHasGroup($groupName, DeterminableUserInterface $user)
    {
        $userHasGroup = false;
        if (true === in_array($groupName, $user->getGroups())) {
            $userHasGroup = true;
        }
        return $userHasGroup;
    }
1127219
public function createGroupConversation($groupName, array $users)
    {
        $group = $this->query()->create([
            'name' => $groupName,
        ]);

        if ($group) {
            $group->users()->attach($users);

            return true;
        }

        return false;
    }
718428
public function joinGroup(string $groupName, int $fd)
    {
        $this->createGroup($groupName)->join($fd);
    }