Use this method to unban a previously kicked user in a supergroup.
        The bot must be an administrator in the group for this to work.

        :param int user_id: Unique identifier of the target user
10403
def unban_chat_member(self, user_id):
        
        return self.bot.api_call("unbanChatMember", chat_id=self.id, user_id=user_id)
284482
def do_kick(self, sender, body, args):
        """"""
        if sender.get('ADMIN') != True: return
        for user in args:
            self.kick_user(user)
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
87744
def kick_user(self, room_id, user_id, reason=""):
        
        self.set_membership(room_id, user_id, "leave", reason)
241823
def account_unblock(self, id):
        
        id = self.__unpack_id(id)
        url = '/api/v1/accounts/{0}/unblock'.format(str(id))
        return self.__api_request('POST', url)
407908
def untag_users(self, tag_id, open_id_list):
        
        return self.post(
            url="https://api.weixin.qq.com/cgi-bin/tags/members/batchuntagging",
            data={
                "openid_list": open_id_list,
                "tagid": tag_id
            }
        )
528194
def unban_chat_member(self, *args, **kwargs):
        """"""
        return unban_chat_member(*args, **self._merge_overrides(**kwargs)).run()
1038699
public Ability unbanUser() {
    return builder()
        .name(UNBAN)
        .locality(ALL)
        .privacy(ADMIN)
        .input(1)
        .action(ctx -> {
          String username = stripTag(ctx.firstArg());
          Integer userId = getUserIdSendError(username, ctx);

          Set<Integer> blacklist = blacklist();

          if (!blacklist.remove(userId))
            silent.sendMd(getLocalizedMessage(ABILITY_UNBAN_FAIL, ctx.user().getLanguageCode(), escape(username)), ctx.chatId());
          else {
            silent.sendMd(getLocalizedMessage(ABILITY_UNBAN_SUCCESS, ctx.user().getLanguageCode(), escape(username)), ctx.chatId());
          }
        })
        .post(commitTo(db))
        .build();
  }
655695
def delete_user_action(model, request):
    
    try:
        users = model.parent.backend
        uid = model.model.name
        del users[uid]
        users()
        model.parent.invalidate()
        localizer = get_localizer(request)
        message = localizer.translate(_(
            'delete_user_from_database',
            default="Deleted user '${uid}' from database.",
            mapping={'uid': uid}
        ))
        return {
            'success': True,
            'message': message
        }
    except Exception as e:
        return {
            'success': False,
            'message': str(e)
        }
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
218023
def remove_user_from_group(self, username, groupname):
        
        url = self._options['server'] + '/rest/api/latest/group/user'
        x = {'groupname': groupname,
             'username': username}

        self._session.delete(url, params=x)

        return True
1330154
def revoke_member(context, request):
    """"""

    mapping = request.json['mapping']
    for entry in mapping:
        user = entry['user']
        roles = entry['roles']
        username = user.get('username', None)
        userid = user.get('userid', None)
        if userid:
            u = context.get_user_by_userid(userid)
        elif username:
            u = context.get_user_by_username(username)
        else:
            u = None
        if u is None:
            raise UnprocessableError(
                'User %s does not exists' % (userid or username))
        for rolename in roles:
            context.revoke_member_role(u.userid, rolename)
    return {'status': 'success'}
245796
def GroupsUsersDelete(self, group_id, user_id):
        
        if self.__SenseApiCall__('/groups/{group_id}/users/{user_id}.json'.format(group_id = group_id, user_id = user_id), 'DELETE'):
            return True
        else:
            self.__error__ = "api call unsuccessful"
            return False
755796
def removeUserFromGroup(self, user_id, thread_id=None):
        
        thread_id, thread_type = self._getThread(thread_id, None)

        data = {"uid": user_id, "tid": thread_id}
        j = self._post(self.req_url.REMOVE_USER, data, fix_request=True, as_json=True)
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
32512
def remove_users_from_group(id, user_list = [])
      wf_usergroup_id?(id)
      validate_user_list(user_list)
      api.post([id, 'removeUsers'].uri_concat, user_list,
               'application/json')
    end
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)