Delete member from chatroom.

@param roomName
the room name
@param jid
the jid
@return the response
973786
public Response deleteMember(String roomName, String jid) {
		return restClient.delete("chatrooms/" + roomName + "/members/" + jid,
				new HashMap<String, String>());
	}
871665
function( userID ) {

		var id = curId;

		curId++;

		if( curId == Number.MAX_VALUE )
			curId = Number.MIN_VALUE;

		roomUsers[ id ] = [];

		return this.setRoomData( id, {} )
			   .then( this.joinRoom.bind( this, userID, id ) )
			   .then( function() {

			   		return id;
			   });
	}
536323
func (r *RoomService) RemoveMember(roomID string, userID string) (*http.Response, error) {
	req, err := r.client.NewRequest("DELETE", fmt.Sprintf("room/%s/member/%s", roomID, userID), nil, nil)
	if err != nil {
		return nil, err
	}

	return r.client.Do(req, nil)
}
335901
public function deleteFromRoster($username, $jid)
    {
        $endpoint = '/users/'.$username.'/roster/'.$jid;
        return $this->doRequest('DELETE', $endpoint, $jid);
    }
202983
def join_room(self, room_name):   
             
        logging.debug('Joining room {ro}'.format(ro=room_name))

        for room in self.rooms:
            if room.name == room_name:
                room.add_user(self)
                self._rooms[room_name] = room
                room.welcome(self)
                break
        else:
            room = Room(room_name)
            self.rooms.append(room)
            self._rooms[room_name] = room
            room.add_user(self)
1324936
public void deleteSpaceSync(String spaceId) {
        log.debug("deleteSpaceSync(" + spaceId + ")");
        throwIfSpaceNotExist(spaceId);

        Map<String, String> allProps = getAllSpaceProperties(spaceId);
        allProps.put("is-delete", "true");
        doSetSpaceProperties(spaceId, allProps);

        SpaceDeleteWorker deleteWorker = getSpaceDeleteWorker(spaceId);
        deleteWorker.run();
    }
96215
def leave_room(self, sid, room, namespace=None):
        
        return self.server.leave_room(sid, room,
                                      namespace=namespace or self.namespace)
441438
public Response deleteOutcastGroup(String roomName, String groupName) {
        return restClient.delete("chatrooms/" + roomName + "/outcasts/group/" + groupName,
                new HashMap<String, String>());
    }
780128
def getRoom(self, _id):
        
        if SockJSRoomHandler._room.has_key(self._gcls() + _id):
            return SockJSRoomHandler._room[self._gcls() + _id]
        return None
451753
public Response deleteOwner(String roomName, String jid) {
		return restClient.delete("chatrooms/" + roomName + "/owners/" + jid,
				new HashMap<String, String>());
	}
1115882
public void blockRoom(DomainBareJid mucLightService, Jid roomJid)
            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
        HashMap<Jid, Boolean> rooms = new HashMap<>();
        rooms.put(roomJid, false);
        sendBlockRooms(mucLightService, rooms);
    }
1113175
public function delete_room($room_id){
     $args = array(
       'room_id' => $room_id
     );

     $response = $this->make_request('rooms/delete', $args, 'POST');

     return ($response->deleted == 'true');
   }
172323
public void create(String roomName, List<Jid> occupants) throws Exception {
        create(roomName, null, null, occupants);
    }
1201326
def delete_room(room, reason=''):
    """"""

    if room.custom_server:
        return

    def _delete_room(xmpp):
        muc = xmpp.plugin['xep_0045']
        muc.destroy(room.jid, reason=reason)

    current_plugin.logger.info('Deleting room %s', room.jid)
    _execute_xmpp(_delete_room)
    delete_logs(room)
1260003
def close_room(self, room, namespace):
        """"""
        try:
            for sid in self.get_participants(namespace, room):
                self.leave_room(sid, namespace, room)
        except KeyError:
            pass
1297497
function( userId, id ) {

		return this.memory.leaveRoom( userId, id )
		.then( function( numUsers ) {

			if( numUsers == 0 ) {

				// remove all listeners from room since there should be one
				rooms[ id ].removeAllListeners();
				rooms[ id ].setPrivate();
				delete rooms[ id ];
				
				return promise.resolve( null );
			} else {

				return promise.resolve( rooms[ id ] );
			}
		});
	}
724850
def delete(self, reason=''):
        
        db.session.delete(self)
        db.session.flush()
        if not self.chatroom.events:
            db.session.delete(self.chatroom)
            db.session.flush()
            delete_room(self.chatroom, reason)
            return True
        return False