/* (non-Javadoc)
@see com.tvd12.ezyfox.core.command.UpdateRoomInfo#removeUser(com.tvd12.ezyfox.core.entities.ApiBaseUser)
548051
@Override
    public void removeUser(ApiBaseUser user) {
        room.removeUser(CommandUtil.getSfsUser(user, api));
    }
1268079
def channels_remove_owner(self, room_id, user_id, **kwargs):
        """"""
        return self.__call_api_post('channels.removeOwner', roomId=room_id, userId=user_id, kwargs=kwargs)
683131
def delete_user(self, user):
        
        name = utils.get_name(user)
        self._user_manager.delete(name)
171553
public ItemRequest<Workspace> removeUser(String workspace) {
    
        String path = String.format("/workspaces/%s/removeUser", workspace);
        return new ItemRequest<Workspace>(this, Workspace.class, path, "POST");
    }
1320046
def remove_users_from_organization(self, organization_id, users_list):
        
        log.warning('Removing users...')
        url = 'rest/servicedeskapi/organization/{}/user'.format(organization_id)
        data = {'usernames': users_list}

        return self.delete(url, headers=self.experimental_headers, data=data)
508826
public ResponseWrapper removeChatRoomMembers(long roomId, Members members)
            throws APIConnectionException, APIRequestException {
        Preconditions.checkArgument(roomId > 0, "room id is invalid");
        Preconditions.checkArgument(members != null, "members should not be empty");
        return _httpClient.sendDelete(_baseUrl + mChatRoomPath + "/" + roomId + "/members", members.toString());
    }
655099
public void removeEntry(AclEntry entry) {
    switch (entry.getType()) {
      case NAMED_USER:  // fall through
      case NAMED_GROUP: // fall through
      case MASK:
        if (mExtendedEntries != null) {
          mExtendedEntries.removeEntry(entry);
        }
        return;
      case OWNING_USER:  // fall through
      case OWNING_GROUP: // fall through
      case OTHER:
        throw new IllegalStateException(
            "Deleting base entry is not allowed. entry: " + entry);
      default:
        throw new IllegalStateException("Unknown ACL entry type: " + entry.getType());
    }
  }
1322826
synchronized void removeUserProfile(String id) {

        if (id == null) return;
        final String tableName = Table.USER_PROFILES.getName();
        try {
            final SQLiteDatabase db = dbHelper.getWritableDatabase();
            db.delete(tableName, "_id = ?", new String[]{id});
        } catch (final SQLiteException e) {
            getConfigLogger().verbose("Error removing user profile from " + tableName + " Recreating DB");
            dbHelper.deleteDatabase();
        } finally {
            dbHelper.close();
        }
    }
850709
def user_remove_prj(self, *args, **kwargs):
        
        if not self.cur_user:
            return
        i = self.user_prj_tablev.currentIndex()
        item = i.internalPointer()
        if item:
            prj = item.internal_data()
            prj.users.remove(self.cur_user)
            item.set_parent(None)
70153
private User removeUser(Session session, String userName, boolean broadcast) throws Exception
   {
      Node userNode = utils.getUserNode(session, userName);
      User user = readUser(userNode);

      if (broadcast)
      {
         preDelete(user);
      }

      removeMemberships(userNode, broadcast);

      userNode.remove();
      session.save();

      removeFromCache(userName);
      removeAllRelatedFromCache(userName);

      if (broadcast)
      {
         postDelete(user);
      }

      return user;
   }
1073375
def remove_user(self, user, **kwargs):
        """"""
        if isinstance(user, Entity):
            user = user['id']

        assert isinstance(user, six.string_types)

        endpoint = '{0}/{1}/users/{2}'.format(
            self.endpoint,
            self['id'],
            user,
        )
        return self.request('DELETE', endpoint=endpoint, query_params=kwargs)
216302
def delete_user(self, user):
        
        self.project_service.set_auth(self._token_project)
        self.project_service.delete_user(user)
602276
@Override
	public void removeRole(String username, String oldrole) throws RolesException {
		List<String> users_with_role = new ArrayList<String>();

		if (user_list.containsKey(username)) {
			List<String> roles_of_user = user_list.get(username);
			if (roles_of_user.contains(oldrole)) {
				// Update our user list
				roles_of_user.remove(oldrole);
				user_list.put(username, roles_of_user);
				// Update our roles list
				if (role_list.containsKey(oldrole))
					users_with_role = role_list.get(oldrole);
				users_with_role.remove(username);
				if (users_with_role.size() < 1) {
					role_list.remove(oldrole);
				} else {
					role_list.put(oldrole, users_with_role);
				}

				// Don't forget to update our file_store
				String roles = StringUtils.join(roles_of_user.toArray(new String[0]), ",");
				file_store.setProperty(username, roles);

				// And commit the file_store to disk
				try {
					saveRoles();
				} catch (IOException e) {
					throw new RolesException(e);
				}
			} else {
				throw new RolesException("User '" + username + "' does not have the role '" + oldrole + "'!");
			}
		} else {
			throw new RolesException("User '" + username + "' does not exist!");
		}
	}
1361931
public void setUser(final String user) {
        final String old = this.user;

        this.user = user;
        this.connectionConfig = System.currentTimeMillis();
        this.connectionValidated = false;

        this.pcs.firePropertyChange("user", old, this.user);
    }
762157
@Override
    public <U extends ApiBaseUser> Response exclude(Collection<U> users) {
    	for(U user : users)
    		this.usernames.remove(user.getName());
    	return this;
    }
853478
public ApiResponse<DeleteUsers> deleteUsersWithHttpInfo(String dbid) throws ApiException {
        com.squareup.okhttp.Call call = deleteUsersValidateBeforeCall(dbid, null, null);
        Type localVarReturnType = new TypeToken<DeleteUsers>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
1277908
def remove_user(self, user):
        
        org_user = self._org_user_model.objects.get(user=user, organization=self)
        org_user.delete()

        # User removed signal
        user_removed.send(sender=self, user=user)