Retreives all contact groups from Xero

 Usage:
   groups = gateway.get_contact_groups()
336993
def get_contact_groups(options = {})
      request_params = {}

      request_params[:ContactGroupID] = options[:contact_group_id] if options[:contact_group_id]
      request_params[:order]          = options[:order] if options[:order]
      request_params[:where]          = options[:where] if options[:where]

      response_xml = http_get(@client, "#{@xero_url}/ContactGroups", request_params)

      parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/contactgroups'})
    end
1362442
def prior_groups(self):
        
        og = list(self.prior_information.groupby("obgnme").groups.keys())
        #og = list(map(pst_utils.SFMT, og))
        return og
753560
function get_record_groups($id)
    {
        $results = array();

        if (!$this->groups) {
            return $results;
        }

        $sql_result = $this->db->query(
            "SELECT cgm.`contactgroup_id`, cg.`name` "
            . " FROM " . $this->db->table_name($this->db_groupmembers, true) . " AS cgm"
            . " LEFT JOIN " . $this->db->table_name($this->db_groups, true) . " AS cg"
                . " ON (cgm.`contactgroup_id` = cg.`contactgroup_id` AND cg.`del` <> 1)"
            . " WHERE cgm.`contact_id` = ?",
            $id
        );

        while ($sql_result && ($sql_arr = $this->db->fetch_assoc($sql_result))) {
            $results[$sql_arr['contactgroup_id']] = $sql_arr['name'];
        }

        return $results;
    }
913359
def get_all_role_config_groups(self):
    
    return role_config_groups.get_all_role_config_groups(
        self._get_resource_root(), self.name, self._get_cluster_name())
1049218
def get_all_contacts_of_client(self, client_id):
        
        return self._iterate_through_pages(
            get_function=self.get_contacts_of_client_per_page,
            resource=CONTACTS,
            **{'client_id': client_id}
        )
724659
def groups_pools_getGroups():
    """"""
    method = 'flickr.groups.pools.getGroups'
    data = _doget(method, auth=True)
    groups = []
    if isinstance(data.rsp.groups.group, list):
        for group in data.rsp.groups.group:
            groups.append(Group(group.id, name=group.name, \
                                privacy=group.privacy))
    else:
        group = data.rsp.groups.group
        groups = [Group(group.id, name=group.name, privacy=group.privacy)]
    return groups
232115
def get_groups(options = {})
      limit = options[:limit] || 1000000
      response = make_request(:get, group + "#{options[:extra]}" + "?startGroup=#{options[:start]}", headers: {'content-type' => 'application/atom+xml'})
      pages = fetch_pages(response, limit, :feed)

      return_all(pages)
    end
995052
def getContacts(self, only_active=True):
        
        contacts = self.objectValues("Contact")
        if only_active:
            contacts = filter(api.is_active, contacts)
        return contacts
495416
def usergroups_list(self, **kwargs) -> SlackResponse:
        """"""
        self._validate_xoxp_token()
        return self.api_call("usergroups.list", http_verb="GET", params=kwargs)
1341502
def get_members_of_group(self, gname):
        
        hostgroup = self.find_by_name(gname)
        if hostgroup:
            return hostgroup.get_hosts()
        return []
322235
def get_groups(self, username):
        
        try:
            return self.users[username]['groups']
        except Exception as e:
            raise UserDoesntExist(username, self.backend_name)
215472
def get_hosts_by_explosion(self, hostgroups):
        # pylint: disable=access-member-before-definition
        
        # First we tag the hg so it will not be explode
        # if a son of it already call it
        self.already_exploded = True

        # Now the recursive part
        # rec_tag is set to False every HG we explode
        # so if True here, it must be a loop in HG
        # calls... not GOOD!
        if self.rec_tag:
            logger.error("[hostgroup::%s] got a loop in hostgroup definition", self.get_name())
            return self.get_hosts()

        # Ok, not a loop, we tag it and continue
        self.rec_tag = True

        hg_mbrs = self.get_hostgroup_members()
        for hg_mbr in hg_mbrs:
            hostgroup = hostgroups.find_by_name(hg_mbr.strip())
            if hostgroup is not None:
                value = hostgroup.get_hosts_by_explosion(hostgroups)
                if value is not None:
                    self.add_members(value)

        return self.get_hosts()
999163
def get_group(self, group_descriptor):
        
        route_values = {}
        if group_descriptor is not None:
            route_values['groupDescriptor'] = self._serialize.url('group_descriptor', group_descriptor, 'str')
        response = self._send(http_method='GET',
                              location_id='ebbe6af8-0b91-4c13-8cf1-777c14858188',
                              version='5.0-preview.1',
                              route_values=route_values)
        return self._deserialize('GraphGroup', response)
265524
def get_groups(self, load):
        '''
        
        '''
        if 'eauth' not in load:
            return False
        fstr = '{0}.groups'.format(load['eauth'])
        if fstr not in self.auth:
            return False
        fcall = salt.utils.args.format_call(
            self.auth[fstr],
            load,
            expected_extra_kws=AUTH_INTERNAL_KEYWORDS)
        try:
            return self.auth[fstr](*fcall['args'], **fcall['kwargs'])
        except IndexError:
            return False
        except Exception:
            return None
1297255
def get_group(self, group_id):
        
        def process_result(result):
            return Group(self, result)

        return Command('get', [ROOT_GROUPS, group_id],
                       process_result=process_result)
1272147
def _get_group_infos(self):
        
        if self._group_infos is None:
            self._group_infos = self._group_type.user_groups(
                self._ldap_user, self._group_search
            )

        return self._group_infos
371524
def get_group(self, name):
        

        groups = self.get_groups()
        for group in groups:
            if group['contactgroupname'] == name:
                return group

        msg = 'No group named: "{name}" found.'
        raise FMBaseError(msg.format(name=name))