See Also: updateGroupResponse()

        Args:
          group:
          vendorSpecific:

        Returns:
762823
def updateGroup(self, group, vendorSpecific=None):
        
        response = self.updateGroupResponse(group, vendorSpecific)
        return self._read_boolean_response(response)
10009
def update_security_group(self, sec_grp, name=None, desc=None):
        '''
        
        '''
        sec_grp_id = self._find_security_group_id(sec_grp)
        body = {'security_group': {}}
        if name:
            body['security_group']['name'] = name
        if desc:
            body['security_group']['description'] = desc
        return self.network_conn.update_security_group(sec_grp_id,
                                                       body=body)
286499
def update(self):
        """"""
        if "tag_groups" not in self._device_dict:
            return
        for group in self.tag_groups:
            group.update()
        for i in range(len(self._device_dict["tag_groups"])):
            tag_group_dict = self._device_dict["tag_groups"][i]
            for group in self.tag_groups:
                if group.name == tag_group_dict["common.ALLTYPES_NAME"]:
                    self._device_dict["tag_groups"][i] = group.as_dict()
1304669
def add_group(self, groupname):
        
        url = self._options['server'] + '/rest/api/latest/group'

        # implementation based on
        # https://docs.atlassian.com/jira/REST/ondemand/#d2e5173

        x = OrderedDict()

        x['name'] = groupname

        payload = json.dumps(x)

        self._session.post(url, data=payload)

        return True
542993
def add_group(self, name, desc, status):
        

        existing_group = get_session().query(ResourceGroup).filter(ResourceGroup.name==name, ResourceGroup.network_id==self.id).first()
        if existing_group is not None:
            raise HydraError("A resource group with name %s is already in network %s"%(name, self.id))

        group_i             = ResourceGroup()
        group_i.name        = name
        group_i.description = desc
        group_i.status      = status

        get_session().add(group_i)

        self.resourcegroups.append(group_i)


        return group_i
1291562
def update_membership(self, group_id, users=[]):
        
        data = {
            'groupId': group_id,
            'users': users,
        }
        return _fix_group(self.post('updateMembership', data))
717837
def group(self, groupId):
        
        url = "%s/%s" % (self.root, groupId)
        return Group(url=url,
                     securityHandler=self._securityHandler,
                     proxy_url=self._proxy_url,
                     proxy_port=self._proxy_port,
                     initalize=False)
1070529
def group_refresh(name, **kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('group:refresh', **{
        'locator': ctx.locator,
        'storage': ctx.repo.create_secure_service('storage'),
        'name': name,
    })
16533
def group_protocols(self):
        """"""
        if self._subscription.subscription is None:
            raise Errors.IllegalStateError('Consumer has not subscribed to topics')
        # dpkp note: I really dislike this.
        # why? because we are using this strange method group_protocols,
        # which is seemingly innocuous, to set internal state (_joined_subscription)
        # that is later used to check whether metadata has changed since we joined a group
        # but there is no guarantee that this method, group_protocols, will get called
        # in the correct sequence or that it will only be called when we want it to be.
        # So this really should be moved elsewhere, but I don't have the energy to
        # work that out right now. If you read this at some later date after the mutable
        # state has bitten you... I'm sorry! It mimics the java client, and that's the
        # best I've got for now.
        self._joined_subscription = set(self._subscription.subscription)
        metadata_list = []
        for assignor in self.config['assignors']:
            metadata = assignor.metadata(self._joined_subscription)
            group_protocol = (assignor.name, metadata)
            metadata_list.append(group_protocol)
        return metadata_list
622216
def listFormats(self, vendorSpecific=None):
        
        response = self.listFormatsResponse(vendorSpecific)
        return self._read_dataone_type_response(response, 'ObjectFormatList')
620920
function updateGroup(oContext) {
			var oNewGroup = oBinding.getGroup(oContext);
			if (oNewGroup.key !== sGroup) {
				var oGroupHeader;
				//If factory is defined use it
				if (oBindingInfo.groupHeaderFactory) {
					oGroupHeader = oBindingInfo.groupHeaderFactory(oNewGroup);
				}
				that[sGroupFunction](oNewGroup, oGroupHeader);
				sGroup = oNewGroup.key;
			}
		}
315620
@Override
    public void updateGroup(IEntityGroup group) throws GroupsException {
        throwExceptionIfNotInternallyManaged();
        getGroupStore().update(group);
        if (cacheInUse()) {
            cacheUpdate(group);
        }
        synchronizeGroupMembersOnUpdate(group);
    }
494106
def register(self, node, vendorSpecific=None):
        
        response = self.registerResponse(node, vendorSpecific)
        return self._read_boolean_response(response)
430366
def get_group_admin(self, group):
        
        data = {
            'name': group,
        }
        response = _fix_group(self.post('getGroupAdmin', data))
        return response
190263
def update(self, group_id, new_group_name, session):
        ''''''
        request = TOPRequest('taobao.crm.group.update')
        request['group_id'] = group_id
        request['new_group_name'] = new_group_name
        self.create(self.execute(request, session), fields=['is_success',])
        return self.is_success
1057241
def updateAccount(self, subject, person, vendorSpecific=None):
        
        response = self.updateAccountResponse(subject, person, vendorSpecific)
        return self._read_boolean_response(response)
436883
def list_consumer_group(self, project, logstore):
        

        resource = "/logstores/" + logstore + "/consumergroups"
        params = {}
        headers = {}

        (resp, header) = self._send("GET", project, None, resource, params, headers)
        return ListConsumerGroupResponse(resp, header)