Retreives a contact group by its id.
160065
def get_contact_group_by_id(contact_group_id)
      request_params = { :ContactGroupID => contact_group_id }
      response_xml = http_get(@client, "#{@xero_url}/ContactGroups/#{CGI.escape(contact_group_id)}", request_params)

      parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/contactgroup'})
    end
1108803
def get_group(id):
    
    acl_url = urljoin(_acl_url(), 'groups/{}'.format(id))
    try:
        r = http.get(acl_url)
        return r.json()
    except DCOSHTTPException as e:
        if e.response.status_code != 400:
            raise
331207
def getCallSet(self, id_):
        
        if id_ not in self._callSetIdMap:
            raise exceptions.CallSetNotFoundException(id_)
        return self._callSetIdMap[id_]
41884
def rejoin(self, group_id):
        
        url = utils.urljoin(self.url, 'join')
        payload = {'group_id': group_id}
        response = self.session.post(url, json=payload)
        return Group(self, **response.data)
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))
846042
public void sendGroupContact(final String groupId, final String[] contactIds) throws NotFoundException, GeneralException, UnauthorizedException {
        // reuestByID appends the "ID" to the base path, so this workaround
        // lets us add a query string.
        String path = String.format("%s%s?%s", groupId, CONTACTPATH, getQueryString(contactIds));
        messageBirdService.requestByID(GROUPPATH, path, null);
    }
1337396
def get_id2gos(self, **kws):
        """"""
        return self._get_id2gos(self.associations, **kws) if kws else self.id2gos
790601
def _restore_group(self, group_id):
        """"""
        meta = self.TaskSetModel._default_manager.restore_taskset(group_id)
        if meta:
            return meta.to_dict()
686863
function ContactsGroupsAssignmentsAdd(options, contactId, groupId) {
    ActionAbstract.call(this, options);
    this._groupId = groupId;
    this._contactId = contactId;
}
410558
def contact_of
      @contact_of ||= Person.distinct
                            .joins(activity_object: { circles: :ties })
                            .merge(Tie.with_contact_id(contact_id: guid))
    end
1065062
def getContactUIDForUser(self):
        
        membership_tool = api.get_tool("portal_membership")
        member = membership_tool.getAuthenticatedMember()
        username = member.getUserName()
        r = self.portal_catalog(
            portal_type="Contact",
            getUsername=username
        )
        if len(r) == 1:
            return r[0].UID
1358040
def get_contact(self, contact_id):
        
        url = self.CONTACTS_ID_URL % contact_id

        connection = Connection(self.token)
        connection.set_url(self.production, url)

        return connection.get_request()
88587
public GroupContact getContact(Group group1, Group group2) {
		return contacts.get(
				new Pair<ResidueNumber>(group1.getResidueNumber(),group2.getResidueNumber()));
	}
375678
public function removeContact($contact_id = null, $id = null)
    {
        if (is_null($contact_id) || is_null($id)) {
            throw new InvalidArgumentException('Null Contact or Group id.');
        }
        $ResourceName = $this->resourceName . ($id ? '/' . $id . '/contacts/' . $contact_id : null);

        list($responseStatus, , $responseBody) = $this->HttpClient->performHttpRequest(
            Common\HttpClient::REQUEST_DELETE,
            $ResourceName
        );
        if ($responseStatus !== Common\HttpClient::HTTP_NO_CONTENT) {
            return json_decode($responseBody);
        }
    }
1191528
def delete_contacts(self, ids):
        

        str_ids = self._return_comma_list(ids)
        self.request('ContactAction', {'action': {'op': 'delete',
                                                  'id': str_ids}})
801484
def get_group_by_id(self, group_id) -> typing.Optional['Group']:
        
        for group in self.groups:

            if group.group_id == group_id:
                return group

        return None
308984
def group(self, id, expand=None):
        
        group = Group(self._options, self._session)
        params = {}
        if expand is not None:
            params['expand'] = expand
        group.find(id, params=params)
        return group