The active groups

@return array
190425
public function getGroups()
    {
        $sql = "SELECT ggp_id_group, ggp_name
            FROM gems__groups
            WHERE ggp_group_active = 1
            ORDER BY ggp_name";

        return $this->util->getTranslated()->getEmptyDropdownArray() +
                $this->_getSelectPairsCached(__FUNCTION__, $sql, null, 'groups');
    }
897792
public function getGroup() {

		if(false !== $this -> file -> getExists()) {

			$this -> refresh();
			
			return $this -> file -> getGroup();
		}
	}
283476
public function getGroup()
    {
        if (-1 === $this->index || !$this->valid()) {
            return null;
        }

        return $this->processors[$this->index][1]['group'] ?? null;
    }
1363893
public function groups()
    {
        if (empty($this->_compiledGroupNames)) {
            foreach ($this->_config['groups'] as $group) {
                $this->_compiledGroupNames[] = $this->_config['prefix'] . $group;
            }
        }

        $groups = $this->_Memcached->getMulti($this->_compiledGroupNames) ?: [];
        if (count($groups) !== count($this->_config['groups'])) {
            foreach ($this->_compiledGroupNames as $group) {
                if (!isset($groups[$group])) {
                    $this->_Memcached->set($group, 1, 0);
                    $groups[$group] = 1;
                }
            }
            ksort($groups);
        }

        $result = [];
        $groups = array_values($groups);
        foreach ($this->_config['groups'] as $i => $group) {
            $result[] = $group . $groups[$i];
        }

        return $result;
    }
475813
public static function groupNames()
    {
        $groups = [];

        foreach(static::groups() as $groupname => $group) {
            $groups[$groupname] = $group['readableName'] ?? $groupname;
        }

        return $groups;
    }
1150619
protected function getGroups() {
    $types = [];
    /** @var \Drupal\group\Entity\GroupType $group_type */
    foreach (GroupType::loadMultiple() as $group_type) {
      // We can only select group types that have the 'join group'
      // permission enabled.
      if (in_array('join group', $group_type->getOutsiderRole()->getPermissions())) {
        $types[] = $group_type;
      }
    }
    return $types;
  }
1014410
public function getGroup()
    {
        /** @var Request $request */
        $request = $this->container->get('request');

        $groupInfo = $request->getSession()->get(CustomerGroup::getModuleCode());

        return $groupInfo;
    }
574746
public function getGroupNames()
    {
        if (empty($this->groups)) {
            return [];
        }

        $result = [];
        foreach ($this->groups as $group) {
            $result[] = $group->name;
        }

        return $result;
    }
100050
public function getGroup()
    {
        if ( null === $this->group && $this->groupId )
        {
            $this->group = $this->getMapper()
                                ->getUserGroupMapper()
                                ->find( $this->groupId );
        }

        return $this->group;
    }
250304
public function listAction()
    {
        $groupManager = $this->get('phlexible_user.group_manager');

        $groups = [];
        foreach ($groupManager->findAll() as $group) {
            $members = [];
            foreach ($group->getUsers() as $user) {
                $members[] = $user->getDisplayName();
            }
            sort($members);

            $groups[] = [
                'gid' => $group->getId(),
                'name' => $group->getName(),
                'readonly' => false,
                'memberCnt' => count($members),
                'members' => $members,
            ];
        }

        return new JsonResponse($groups);
    }
1256606
public function get_group_list() {

        // No groups for system.
        if (empty($this->course)) {
            return array();
        }

        $context = context_course::instance($this->course->id);
        $groups = array();
        $groupmode = groups_get_course_groupmode($this->course);
        if (($groupmode == VISIBLEGROUPS) ||
                ($groupmode == SEPARATEGROUPS and has_capability('moodle/site:accessallgroups', $context))) {
            // Get all groups.
            if ($cgroups = groups_get_all_groups($this->course->id)) {
                foreach ($cgroups as $cgroup) {
                    $groups[$cgroup->id] = $cgroup->name;
                }
            }
        }
        return $groups;
    }
504434
public function getSitesGroups()
    {
        $db = $this->getDb();
        $groups = $db->fetchAll("SELECT DISTINCT `group` FROM " . $this->table);

        $cleanedGroups = array();
        foreach ($groups as $group) {
            $cleanedGroups[] = $group['group'];
        }

        return $cleanedGroups;
    }
1222692
public static function getConversionGroups() {
		$conversionGroups = array();
		foreach(self::$_conversionUnits as $conversionUnit) {
			$conversionGroups[] = $conversionUnit['Group'];
		}
		return array_merge(array_unique($conversionGroups));
	}
259044
public function getGroups()
    {
        $result = [];

        $this->addHeader();
        try {
            $rawGroups = $this->getSoap()->GetAcsEmployeeGroups()->GetAcsEmployeeGroupsResult;
            if (isset($rawGroups->AcsEmployeeGroup) && is_array($rawGroups->AcsEmployeeGroup)) {
                $rawGroups = $rawGroups->AcsEmployeeGroup;
            }
            foreach ($rawGroups as $group) {
                $result[] = new EmployeeGroup((array)$group);
            }
        } catch (\SoapFault $ex) {
            $this->logError();
        }

        return $result;
    }
315837
public function get_groups_info() {

        if ($this->cachegroups !== null) {
            return $this->cachegroups;
        }

        $groups = [];

        foreach (core_filetypes::get_types() as $ext => $info) {
            if (isset($info['groups']) && is_array($info['groups'])) {
                foreach ($info['groups'] as $group) {
                    if (!isset($groups[$group])) {
                        $groups[$group] = (object) [
                            'extensions' => [],
                            'mimetypes' => [],
                        ];
                    }
                    $groups[$group]->extensions['.'.$ext] = true;
                    if (isset($info['type'])) {
                        $groups[$group]->mimetypes[$info['type']] = true;
                    }
                }
            }
        }

        foreach ($groups as $group => $info) {
            $info->extensions = array_keys($info->extensions);
            $info->mimetypes = array_keys($info->mimetypes);
        }

        $this->cachegroups = $groups;
        return $this->cachegroups;
    }
750961
public function getCounts()
    {
        return array(
            'habbo' => count($this->habbo),
            'badges' => count($this->badges),
            'friends' => count($this->friends),
            'groups' => count($this->groups),
            'rooms' => count($this->rooms),
        );
    }
378228
protected function getCurrentGroupName()
    {
        if (!$this->currentGroup) {
            $this->with($this->admin->getLabel(), ['auto_created' => true]);
        }

        return $this->currentGroup;
    }