Bans a member from the group

        :param group_jid: The JID of the relevant group
        :param peer_jid: The JID of the user to ban
162230
def ban_member_from_group(self, group_jid, peer_jid):
        
        log.info("[+] Requesting ban of user {} from group {}".format(peer_jid, group_jid))
        return self._send_xmpp_element(group_adminship.BanMemberRequest(group_jid, peer_jid))
1258919
def promote_to_admin(self, group_jid, peer_jid):
        
        log.info("[+] Promoting user {} to admin in group {}".format(peer_jid, group_jid))
        return self._send_xmpp_element(group_adminship.PromoteToAdminRequest(group_jid, peer_jid))
723256
public void blockUsers(DomainBareJid mucLightService, List<Jid> usersJids)
            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
        HashMap<Jid, Boolean> users = new HashMap<>();
        for (Jid jid : usersJids) {
            users.put(jid, false);
        }
        sendBlockUsers(mucLightService, users);
    }
962929
def delete_group(self, name):
        
        self.service.delete_group(
            name, self.url_prefix, self.auth, self.session,
            self.session_send_opts)
891569
def purge(self, jid, node):
        

        iq = aioxmpp.stanza.IQ(
            type_=aioxmpp.structs.IQType.SET,
            to=jid,
            payload=pubsub_xso.OwnerRequest(
                pubsub_xso.OwnerPurge(
                    node
                )
            )
        )

        yield from self.client.send(iq)
473596
def unsubscribe(self, peer_jid):
        
        self.client.enqueue(
            stanza.Presence(type_=structs.PresenceType.UNSUBSCRIBE,
                            to=peer_jid)
        )
1090490
def security_group_rule_delete(auth=None, **kwargs):
    '''
    

    '''
    cloud = get_operator_cloud(auth)
    kwargs = _clean_kwargs(**kwargs)
    return cloud.delete_security_group_rule(**kwargs)
485244
def delete_security_group_rule(self, sec_grp_rule_id):
        '''
        
        '''
        ret = self.network_conn.delete_security_group_rule(
            security_group_rule=sec_grp_rule_id)
        return ret if ret else True
498796
def atlasdb_remove_peer( peer_hostport, con=None, path=None, peer_table=None ):
    
    # remove from db
    with AtlasDBOpen(con=con, path=path) as dbcon:

        log.debug("Delete peer '%s'" % peer_hostport)

        sql = "DELETE FROM peers WHERE peer_hostport = ?;"
        args = (peer_hostport,)

        cur = dbcon.cursor()
        res = atlasdb_query_execute( cur, sql, args )
        dbcon.commit()

    # remove from the peer table as well
    with AtlasPeerTableLocked(peer_table) as ptbl:

        if ptbl.has_key(peer_hostport):
            if not atlas_peer_is_whitelisted( peer_hostport, peer_table=ptbl ) and not atlas_peer_is_blacklisted( peer_hostport, peer_table=ptbl ):
                del ptbl[peer_hostport]

    return True
1159685
def RemoveConnectedPeer(self, peer):
        
        if peer in self.Peers:
            self.Peers.remove(peer)
1205230
def kick_user(self, jid):
        """"""
        for member in filter(lambda m: m['JID'] == jid, self.params['MEMBERS']):
            member['STATUS'] = 'KICKED'
            self.send_message('You have been kicked from %s' % (self.name,), member)

            self.client.sendPresence(jid=member['JID'], typ='unsubscribed')
            self.client.sendPresence(jid=member['JID'], typ='unsubscribe')
            self.broadcast('kicking %s from the room' % (jid,))
1147468
def remove_from_group(self, group, user):
        
        data = {'group': group, 'user': user}
        return self.post('removeUserFromGroup', data)
528194
def unban_chat_member(self, *args, **kwargs):
        """"""
        return unban_chat_member(*args, **self._merge_overrides(**kwargs)).run()
592812
def remove_unhealthy_peers( self, count, con=None, path=None, peer_table=None, min_request_count=10, min_health=MIN_PEER_HEALTH ):
        
        
        if path is None:
            path = self.atlasdb_path

        removed = []
        rank_peer_list = atlas_rank_peers_by_health( peer_table=peer_table, with_rank=True )
        for rank, peer in rank_peer_list:
            reqcount = atlas_peer_get_request_count( peer, peer_table=peer_table )
            if reqcount >= min_request_count and rank < min_health and not atlas_peer_is_whitelisted( peer, peer_table=peer_table ) and not atlas_peer_is_blacklisted( peer, peer_table=peer_table ):
                removed.append( peer )

        random.shuffle(removed)
        if len(removed) > count:
            removed = removed[:count]

        for peer in removed:
            log.debug("Remove unhealthy peer %s" % (peer))
            atlasdb_remove_peer( peer, con=con, path=path, peer_table=peer_table )

        return removed
88546
def revoke_ip_permission(
        self, group_name, ip_protocol, from_port, to_port, cidr_ip):
        
        d = self.revoke_security_group(
            group_name,
            ip_protocol=ip_protocol, from_port=from_port, to_port=to_port,
            cidr_ip=cidr_ip)
        return d
3008
public void removePeer(Peer peer) throws InvalidArgumentException {
        if (shutdown) {
            throw new InvalidArgumentException(format("Can not remove peer from channel %s already shutdown.", name));
        }
        logger.debug(format("removePeer %s from channel %s", peer, toString()));

        checkPeer(peer);
        removePeerInternal(peer);
        peer.shutdown(true);

    }
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)