Deletes a user.

 @param [User\String] user
 @param [Hash] options
 @return [Boolean]

 ====Examples
 @example
   @coach.delete_user(user)
 @example
   @coach.delete_user('arueedlinger')
346823
def delete_user(user, options={})
      raise 'Error: Param user is nil!' if user.nil?

      url = if user.is_a?(Resource::User)
        url_for_resource(user)
      elsif user.is_a?(String)
        url_for_path(user_path(user))
      else
        raise 'Error: Invalid parameters!'
      end
      begin
        client.delete(url, options) do |response|
          response.code == 200
        end
      rescue => e
        raise e if debug
      end
    end
722741
def delete_user(self, user):
        
        user_id = utils.get_id(user)
        uri = "users/%s" % user_id
        resp, resp_body = self.method_delete(uri)
        if resp.status_code == 404:
            raise exc.UserNotFound("User '%s' does not exist." % user)
        elif resp.status_code in (401, 403):
            raise exc.AuthorizationFailure("You are not authorized to delete "
                    "users.")
478031
def delete(options = {})
      options = options.merge(platform_application_arn: @arn)
      resp = @client.delete_platform_application(options)
      resp.data
    end
377917
def delete(options = {})
      options = options.merge(
        vault_name: @name,
        account_id: @account_id
      )
      resp = @client.delete_vault(options)
      resp.data
    end
743874
@CommandArgument
  public void rmuser(
      @OptionArgument("username") String username) {

    if (users.containsKey(username)) {
      users.remove(username);
    } else {
      System.err.println(String.format("User '%s' does not exist", username));
    }
  }
581039
def delete(name, remove=False, force=False):
    '''
    
    '''
    if salt.utils.data.is_true(force):
        log.warning(
            'userdel does not support force-deleting user while user is '
            'logged in'
        )
    cmd = ['userdel']
    if remove:
        cmd.append('-r')
    cmd.append(name)
    return __salt__['cmd.retcode'](cmd, python_shell=False) == 0
391302
def delete(params = {})
      case @api.version
      when 'v1'
        response = self.class.post(@api.delete_config[:url],
                                  :query => { :auth_token => @token }.merge(params),
                                  :headers => @api.headers
        )
      when 'v2'
        response = self.class.delete(@api.delete_config[:url],
                                  :query => { :auth_token => @token },
                                  :headers => @api.headers
        )
      end

      ErrorHandler.response_code_to_exception_for :user, user_id, response
      true
    end
187753
def delete_reaction(user, reaction)
      reaction = reaction.to_reaction if reaction.respond_to?(:to_reaction)
      API::Channel.delete_user_reaction(@bot.token, @channel.id, @id, reaction, user.resolve_id)
    end
697838
def delete_user(self, uid=0, user_id=''):
        
        if not uid:
            users = self.get_users()
            users = list(filter(lambda x: x.user_id==str(user_id), users))
            if not users:
                return False
            uid = users[0].uid
        command = const.CMD_DELETE_USER
        command_string = pack('h', uid)
        cmd_response = self.__send_command(command, command_string)
        if not cmd_response.get('status'):
            raise ZKErrorResponse("Can't delete user")
        self.refresh_data()
        if uid == (self.next_uid - 1):
            self.next_uid = uid
168467
def delete(options = {}, invalidate = true)
      if invalidate
        self.invalidate
      end
      options = @options.merge(options)
      response = self.class.delete(@uri, options)
      if response.success?
        deserialize(response)
      else
        fail HttpError, response.response
      end
    end
566550
def delete(options = {})
      options = options.merge(stack_id: @id)
      resp = @client.delete_stack(options)
      resp.data
    end
1063235
def remove_member(self, user):
        
        username = Transform.to_user(user)
        extra = {
            'resource': self.__class__.__name__,
            'query': {
                'id': self.id,
                'user': user,
            }
        }
        logger.info('Removing member', extra=extra)
        self._api.delete(
            url=self._URL['member'].format(id=self.id, username=username)
        )
411182
def DeleteUser(self, user_link, options=None):
        
        if options is None:
            options = {}

        path = base.GetPathFromLink(user_link)
        user_id = base.GetResourceIdOrFullNameFromLink(user_link)
        return self.DeleteResource(path,
                                   'users',
                                   user_id,
                                   None,
                                   options)
344969
def delete_user(user_name, region=None, key=None, keyid=None,
                profile=None):
    '''
    
    '''
    if not get_user(user_name, region, key, keyid, profile):
        return True
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
    try:
        conn.delete_user(user_name)
        log.info('Deleted IAM user : %s .', user_name)
        return True
    except boto.exception.BotoServerError as e:
        log.debug(e)
        log.error('Failed to delete IAM user %s', user_name)
        return six.text_type(e)
708288
def _delete_account(self, username):
        

        # account deleted

        ds_user = self.get_user(username)
        if ds_user is not None:
            self._call(["delete", "user", "name=%s" % username])

        return
88930
def delete_users(user_list)
      raise ArgumentError unless user_list.is_a?(Array)
      validate_user_list(user_list)
      api.post('deleteUsers', user_list, 'application/json')
    end
1361710
def delete(options = {})
      options = options.merge(
        queue_url: @queue_url,
        receipt_handle: @receipt_handle
      )
      resp = @client.delete_message(options)
      resp.data
    end