Delete group to user
@method
@memberOf iam.UserBuilder
@param {Object} groups     The data of the groups
@return {Promise}  Q promise that resolves to undefined (void) or rejects with a {@link SilkRoadError}
174564
function(group) {
                console.log('iamInterface.user.deleteGroup');
                corbel.validate.values(['id', 'group'], {
                    'id': this.id,
                    'group': group
                });
                return this.request({
                    url: this._buildUriWithDomain(this.uri, this.id) + '/group/' + group,
                    method: corbel.request.method.DELETE
                });
            }
1291384
def remove_group_from_favorites(self, id):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - id
        """the ID or SIS ID of the group to remove"""
        path["id"] = id

        self.logger.debug("DELETE /api/v1/users/self/favorites/groups/{id} with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("DELETE", "/api/v1/users/self/favorites/groups/{id}".format(**path), data=data, params=params, single_item=True)
1237757
public function removeUserGroups(UserGroup ...$groups)
    {
        foreach ($groups as $group) {
            $this->getUserGroups()->removeElement($group);
        }

        return $this;
    }
386426
public Response deleteOwnerGroup(String roomName, String groupName) {
        return restClient.delete("chatrooms/" + roomName + "/owners/group/" + groupName,
                new HashMap<String, String>());
    }
1147468
def remove_from_group(self, group, user):
        
        data = {'group': group, 'user': user}
        return self.post('removeUserFromGroup', data)
577286
def delete_user_from_group(self, GroupID, UserID):
        """"""
        # http://teampasswordmanager.com/docs/api-groups/#del_user
        log.info('Delete user %s from group %s' % (UserID, GroupID))
        self.put('groups/%s/delete_user/%s.json' % (GroupID, UserID))
372991
function getUserGroups(user) {
  try {
    const output = runProgram('groups', [user]).trim();
    const groupsText = isBusyboxCommand('groups') ? output : output.split(':')[1].trim();
    return groupsText.split(/\s+/);
  } catch (e) {
    throw new Error(`Cannot resolve user ${user}`);
  }
}
807310
def delete(self, group_id, session):
        ''''''
        request = TOPRequest('taobao.crm.group.delete')
        request['group_id'] = group_id
        self.create(self.execute(request, session), fields=['is_success',])
        return self.is_success
307497
public void deleteGroupMember(GitlabGroup group, GitlabUser user) throws IOException {
        deleteGroupMember(group.getId(), user.getId());
    }
308342
public Response deleteMemberGroup(String roomName, String groupName) {
        return restClient.delete("chatrooms/" + roomName + "/members/group/" + groupName,
                new HashMap<String, String>());
    }
1119666
def delete_group(group_id, tasks=False, cached=Conf.CACHED):
    
    if cached:
        return delete_group_cached(group_id)
    return Task.delete_group(group_id, tasks)
921314
@Nonnull
  public EChange deleteUserGroup (@Nullable final String sUserGroupID)
  {
    if (StringHelper.hasNoText (sUserGroupID))
      return EChange.UNCHANGED;

    final UserGroup aDeletedUserGroup = getOfID (sUserGroupID);
    if (aDeletedUserGroup == null)
    {
      AuditHelper.onAuditDeleteFailure (UserGroup.OT, "no-such-usergroup-id", sUserGroupID);
      return EChange.UNCHANGED;
    }
    if (aDeletedUserGroup.isDeleted ())
    {
      AuditHelper.onAuditDeleteFailure (UserGroup.OT, "already-deleted", sUserGroupID);
      return EChange.UNCHANGED;
    }

    m_aRWLock.writeLock ().lock ();
    try
    {
      if (BusinessObjectHelper.setDeletionNow (aDeletedUserGroup).isUnchanged ())
      {
        AuditHelper.onAuditDeleteFailure (UserGroup.OT, "already-deleted", sUserGroupID);
        return EChange.UNCHANGED;
      }
      internalMarkItemDeleted (aDeletedUserGroup);
    }
    finally
    {
      m_aRWLock.writeLock ().unlock ();
    }
    AuditHelper.onAuditDeleteSuccess (UserGroup.OT, sUserGroupID);

    // Execute callback as the very last action
    m_aCallbacks.forEach (aCB -> aCB.onUserGroupDeleted (aDeletedUserGroup));

    return EChange.CHANGED;
  }
1001224
def remove_from_group(server_context, user_ids, group_id, container_path=None):
    
    return __make_security_group_api_request(server_context, 'removeGroupMember.api', user_ids,
                                             group_id, container_path)
1111449
def remove_group(self, groupname):
        
        # implementation based on
        # https://docs.atlassian.com/jira/REST/ondemand/#d2e5173
        url = self._options['server'] + '/rest/api/latest/group'
        x = {'groupname': groupname}
        self._session.delete(url, params=x)
        return True
193897
function(groupName, callback) {
        request.get(
            this.getResourceUrl({ path: '/groups/' + groupName, user: null }),
            function onResourceGroupResponse(err, res, body) {
                callback(err, body && body.resources, res);
            }
        );
        return this;
    }
565047
private void preDelete(Group group) throws Exception
   {
      for (GroupEventListener listener : listeners)
      {
         listener.preDelete(group);
      }
   }
888151
@Override
    public void deleteGroup(IEntityGroup group) throws GroupsException {
        throwExceptionIfNotInternallyManaged();
        synchronizeGroupMembersOnDelete(group);
        getGroupStore().delete(group);
        if (cacheInUse()) {
            cacheRemove(group);
        }
    }