@param string $groupName

@return boolean
168543
public function deletePausedTriggerGroup($groupName)
    {
        $result = $this->res->getPausedTriggerCol()->deleteOne(['groupName' => $groupName]);

        return $result->isAcknowledged() && $result->getDeletedCount();
    }
1117901
protected function getUserGroup($groupName)
    {
        $groupName = "admin:$groupName";

        $group = $this->userGroupFactory->getGroup($groupName);
        if (!$group) {
            $this->userGroupFactory->create($groupName);
            $group = $this->userGroupFactory->getGroup($groupName);
        }

        return $group;
    }
1334786
public function indexAction($groupName)
    {
        $acl = $this->get('bacon_acl.service.authorization');

        if (!$acl->authorize('acl', 'ACL')) {
            throw $this->createAccessDeniedException();
        }

        $groupClassName     =   $this->getParameter('bacon_acl.group_class');
        $moduleClassName    =   $this->getParameter('bacon_acl.entities.module_class');

        $module = $this->getDoctrine()->getRepository($moduleClassName)->findAll();
        $group  = $this->getDoctrine()->getRepository($groupClassName)->findOneBy(array('name' => urldecode($groupName)));

        return [
            'modules' => $module,
            'group'  => $group
        ];
    }
1238334
private function updateTranslationGroups($groupname)
    {
    	$group = TranslationGroup::firstOrCreate(['name' => $groupname]);
    	array_push($this->translation_groups, $group);
    }
1311073
public function userHasGroup($groupName, DeterminableUserInterface $user)
    {
        $userHasGroup = false;
        if (true === in_array($groupName, $user->getGroups())) {
            $userHasGroup = true;
        }
        return $userHasGroup;
    }
673972
public function getResourceGroupUrl($groupName) {
        $url = sprintf($this->getBaseUrl() . '/groups/%s.json', $groupName);

        return Http\ResourceGroupUrl::factory(
            $url,
            $this->getConfig('privateKey'),
            $this->getPublicKey()
        );
    }
704540
protected function validateData(EntityGroup $group, $groupname)
    {
        $errors = array();
        
        // Groupname
        if ($this->groupManager->hasGroupForName($groupname) && $this->groupManager->getGroupForName($groupname)->getUuid() != $group->getUuid()) {
            $errors[] = new Error(Error::GENERAL_ERROR, $this->translate('The groupname is already in use.', '\\Zepi\\Web\\AccessControl'));
        }
        
        if (count($errors) > 0) {
            return $errors;
        }
        
        return true;
    }
770917
public function addGroup($groupName)
    {
        if (true === is_string($groupName) && false === in_array($groupName, $this->groups)) {
            $this->groups[] = $groupName;
        }
        return $this;
    }
723837
public static function remove($groupname)
    {
        $grav = Grav::instance();

        /** @var Config $config */
        $config = $grav['config'];

        $blueprints = new Blueprints();
        $blueprint = $blueprints->get('user/group');

        $type = 'groups';

        $groups = $config->get($type);
        unset($groups[$groupname]);
        $config->set($type, $groups);

        $filename = CompiledYamlFile::instance($grav['locator']->findResource("config://{$type}.yaml"));

        $obj = new Data($groups, $blueprint);
        $obj->file($filename);
        $obj->save();

        return true;
    }
756513
public function getRouteGroup(string $groupName): \Nofuzz\Route\Group
  {
    foreach ($this->routeGroups as $routeGroup)
    {
      if ( strcasecmp($routeGroup->getName(),$groupName)==0 ) {
        return $routeGroup;
      }
    }

    return null;
  }
1054393
public function removeGroup(string $groupName)
    {
        $tagGroup = TagGroup::query()->where('slug', $this->taggingUtility->slug($groupName))->first();

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

            return $this;
        } else {
            throw new \RuntimeException('No Tag Group found: '. $groupName);
        }
    }
431062
public function getGroupLabel($groupName)
    {
        if (!isset($this->config[$groupName])) {
            return "";
        }

        return $this->config[$groupName]['label']->get();
    }
781832
public function hasGroupPermissionSelected(Group $group)
    {
        $definition = (new Query())->select("inheritance")->from("cms_nav_permission")->where(['group_id' => $group->id, 'nav_id' => $this->id])->one();
        
        if ($definition) {
            return true;
        }
        
        return false;
    }
889798
public function groupCall(string $groupName, string $methodName, ...$args)
    {
        return $this->createGroup($groupName)->$methodName(...$args);
    }
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;
    }
431734
public function hasGroupId(int $id) : bool
    {
        $usergroups = $this->usergroups;

        foreach ($usergroups as $index => $usergroup) {
            if ($usergroup->group_id === $id) {
                return true;
            }
        }

        return false;
    }
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)
            {

            }
        });
    }