def leave(message): print("leave") leave_room(message['room']) session['receive_count'] = session.get('receive_count', 0) + 1 emit('my response', {'data': 'In rooms: ' + ', '.join(rooms()), 'count': session['receive_count']})
def leave_match(sid): with match_lock: try: match_id = sid_match[sid] # leave match if in one except KeyError: print('session {} not leaving room!'.format(sid)) pass # do nothing if not in a match else: print('session {} leaving room {}!'.format(sid, match_id)) del sid_match[sid] leave_room(match_id, sid) # todo: can be lifted out of locked region match_players[match_id].remove(current_user.username) if match_players[match_id].is_empty(): # destroy the match if empty del match_players[match_id] data = [{'player1': v.player1, 'player2': v.player2, 'match_id': k} for k, v in match_players.items()] print(sid_match) print(match_players) print(data) socketio.emit('room_list', json.dumps(data), namespace='/lobby_event', room=0)
def on_join(room): from .database import BTSBlock, TestBlock, SteemBlock # Leave all rooms! for r in rooms: leave_room(r) # Join only one room join_room(room) log("joined " + room) # Send all the stored data for that room if room == "bts": blocks = BTSBlock elif room == "test": blocks = TestBlock else: blocks = SteemBlock block_time = 3 allblocks = [[ b.timestamp, b.num_ops, b.num_txs, b.block_num ] for b in blocks.recent(1000)] socketio.emit( 'init', { "data": sorted(allblocks, key=lambda x: x[0]), "block_time": block_time }, namespace=namespace, room=room, broadcast=True)
def left(message): """ """ print 'socketio left' room = session.get('room') leave_room(room) emit('status', {'msg':session.get('name')+ 'has left'}, room='room')
def handle_game(): print("Play") if currentGame.playing == 0: leave_room('ready') join_room('play') start_wait() currentGame.start_game(session['id']) notify_players()
def ui_state_update(key_val): leave_room("raSlaves") key, val = key_val # print 'ui state SET', key UI_STATE[key.replace("reduxPersist:", "")] = json.loads(val) emit("state_update", json.dumps(UI_STATE), namespace="/ui_state", room="raSlaves")
def leave(message): leave_room(message['room_id']) current_app.config[message['room_id']]['current_user_num'] -= 1 data = { 'user_num': current_app.config[message['room_id']]['current_user_num'], 'info': message['nick_name'] + u"离开了房间!" } emit('user update', data, room=message['room_id'])
def socketio_disconnect_handler(): room = session.get('username', None) rooms = IoTSensorWebLauncher.socketio.server.manager.rooms namesapce = IoTSensorWebLauncher.socketio_namespace logging.info(request.sid + ' is disconnecting...') leave_room(room) if ((namesapce in rooms) and (room in rooms.get(namesapce))) is False: IoTSensorWebLauncher.socketio_room_set.discard(room)
def leave(message): room = sanitize_html(message['room']) log.debug("%s left %s" % (current_user.username, room)) leave_room(room) emit('event response room', {'data': room, 'userleave': current_user.username}, broadcast=True)
def leave_calendar_room(room): leave_room(room['room']) emit( 'leave room response', {'msg': "left room" + room['room']}, broadcast=True, room=room['room'], )
def on_leave(data): print('mamma i made it') username = data['username'] room = data['room'] userList[room].remove(username) leave_room(room) user_message = 'Sever: ' + username + ' has left the chat.' emit('new-message', user_message, broadcast=True, room=flask.session['room']) emit('remove-user', username, broadcast=True, room=flask.session['room'])
def leave(data): room = data['room'] username = data['username'] leave_room(room) emit('left room', { 'username': username, 'room': room }, room=room)
def leave(message): room_id = message['room_id'] nick_name = session[room_id] uid = session['uid'] leave_room(room_id) redis.srem(room_id, room_id + ':' + uid) emit('system message', {'content': session[room_id] + u'离开了房间' + message['room_id']}, room=room_id) emit('user update', {'flag': 'leave', 'uid': uid, 'nick_name': nick_name}, room=room_id)
def clientDisconnect(pads): projectId = pads['projectId'] # Remove user from dictionary and room. project_users[projectId].remove(request.sid) if not project_users[projectId]: del project_users[projectId] leave_room(projectId) # Write state in db. updateDBPads(pads)
def handle_leave(): room = cache.get(request.sid+"-room") # print "DISCONNECT from " + room leave_room(room) count = cache.get(room+":count") if count is not None: person_count = int(cache.get(room+":count")) cache.set(room+":count", int(person_count)-1) emit('userLeft', {"count": cache.get(room+":count")}, broadcast=True, room=room)
def left(data): user = session['username'] room = session['room_id'] print '{} left room {}'.format(user, room) leave_room(room) if user in rooms[room]['users']: rooms[room]['users'].pop(user, None) user_list = sorted(rooms[room]['users'].keys()) emit('list of users', { 'users': user_list }, room=room) emit('update locations', { 'userData': rooms[room]['users'] }, room=room)
def leave(message): if message['room'] not in rooms(): return leave_room(message['room']) emit('leave', {'user': message['user'], 'room': message['room']}, broadcast=True) room_list = [room for room in rooms() if room != request.sid] emit('my response', {'data': 'In rooms: ' + ', '.join(room_list)})
def on_disconnect(): sid = request.cookies.get("id") if sid is not None: leave_room(sid) all_rooms.remove(sid) # broadcast user disconnection to all online users for u in all_rooms: if u == sid: continue emit("join", [users[sid]], room=u)
def leave(message): leave_room(message['room']) room_title = message['room'] user_id = session['user_id'] leaveRoom.leave(dc, user_id, room_title) session['receive_count'] = session.get('receive_count', 0) + 1 emit('response', {'data': 'In rooms: ' + ', '.join(rooms()), 'count': session['receive_count']})
def leave(message): leave_room(message['room']) emit('fight status', {'data': message['player'] + ' left the battlefield.', 'player': message['player']}, room=message['room']) front = Battlefront() front.remove_player(message['player']) player_list = front.get_player_list() emit('fight players', {'player': player_list}, room=message['room'], broadcast=True)
def left(): uid, sid = session.get('user_id'), session.get('poker_session_id') user = r.hgetall(uid) poker_session = r.hgetall('session:' + sid) r.delete(uid) r.srem(poker_session['people_key'], uid) if r.scard(poker_session['people_key']) == 0: r.delete(poker_session['people_key'], 'session:' + sid) leave_room(sid) emit('left', { 'user': user['username'], 'id': uid, 'role': user['role'] }, room=sid)
def on_leave(data): username = data["username"] user = get_or_create(User, name=username) room = get_or_create(Room, name=data["room"]) if user in room.users: room.users.remove(user) db.session.commit() leave_room(room.id)
def disconnect(): user_rooms = rooms() for user_room in user_rooms: leave_room(user_room) user_id = get_id_from_rooms(user_rooms) user = DelhiveryUser.objects.get(id=user_id) user.become_offline() active_users = get_active_user_ids() online_friends = get_all_online_delhivery_boys(user) for friend in online_friends: emit('refresh_online_friends',room = str(friend.id)) emit('disconnected_offline',{'users':active_users},room='main')
def newchallenger(): print('in challenger ') print(game[flask.session['room']]) if len(game[flask.session['room']]) < 4: print('trying to join game', game[flask.session['room']]) #join game. game[flask.session['room']].append(flask.session['sid']) flask_socketio.leave_room('observing'+flask.session['room']) io.emit('anotherplayerentered', {'myTurnWillBe':'O'}, room = game[flask.session['room']][0] ) io.emit('anotherplayerentered', {'myTurnWillBe':'X'}, room = game[flask.session['room']][1] ) print('trying to join game', game[flask.session['room']])
def leave(data): name = data['name'] global game if game is not None: game.playerLeft(name) print name + ' has left!' global player_names player_names.remove(name) leave_room(room) emit('playerLeft', player_names, room=room)
def on_leave(json): """ Sent by client to leave a room :param json: :return: """ LOG.debug('Received room leave: ' + str(json)) room_name = json.get('room_name') parts = room_name.split('::') cluster_name = parts[0] metrics = parts[1] leave_room(room_name) print(rooms())
def leave(message): """ Leave desired room to stop further communication :param message: Contains room name """ try: remove_user_from_room(message['room'], request.sid) leave_room(message['room']) send_message("NOTIFICATION", "Room status", "Room left.", {"room":message['room']}) except InvalidRoomNameError: send_message("ERROR", "Room status", "Invalid room name.", {"room":message['room']})
def on_leave(data): room = data['room'] leave_room(room) username = data['username'] # delete the room. for name in chats.copy(): if chats[name] == room: del chats[name] userList[room].remove(username) user_message = 'Sever: ' + username + ' has left the chat.' emit('new-message', user_message, broadcast=True, room=flask.session['room']) emit('remove-user', username, broadcast=True, room=flask.session['room'])
def leaveRoom(roomName): leave_room(roomName) email = session['user'].get('email') roomMgmt.removePersonFromRoom(email, roomName) emit('room_leave', { 'room': roomName, 'user': { 'email': email, 'name': session['user'].get('name'), 'picture': session['user'].get('picture') } }, room=roomName)
def leave(message): global roomsDict leave_room(message['room']) leave_room(message['username']) roomsDict[message['room']]['users'].remove(session['username']) del roomsDict[message['username']] session['receive_count'] = session.get('receive_count', 0) + 1 emit('my response', {'user': '******', 'data': 'Left ' + message['room'], 'count': session['receive_count']}) emit('my response', {'user': message['room'].capitalize() + 'Bot', 'data': session['username'] + ' has left the room', 'count': session['receive_count']}, room=message['room']) return True
def on_leave_room(data_doc_id): data_doc_id = int(data_doc_id) leave_room(data_doc_id) # Update the list of users in This room update_user_list(data_doc_id) update_user_cursor(data_doc_id)
def disconnect(): data_doc_ids = rooms(request.sid, namespace=DATA_DOC_NAMESPACE) for data_doc_id in data_doc_ids: leave_room(data_doc_id) update_user_list(data_doc_id)
def test_disconnect(): leave_room("rasp") print('Client disconnected')
def close(): #cleanUserBySid(request.sid) if request.sid in SidToUid: cur_room = SidToUid[request.sid] ##################### leave_room(cur_room)
def handle_leave_room_event(data): app.logger.info("{} has join the room {}".format(data['username'], data['room'])) leave_room(data['room']) socketio.emit('leave_room_announcement', data)
def on_leave(data): username = data['username'] room = data['room'] leave_room(room) send(username + ' has left the room.', room=room)
def left(message): room = session.get('room') session.pop(room) leave_room(room) emit('message', {'msg': session.get('name') + ' has left the room'}, room=room)
def on_leave(data): room = data['room'] debug(f"Client {request.sid} leaves {room}") leave_room(room) send(f'You has leaved room {room} ')
def leave(data): leave_room(data['room']) send( {'msg': data['username'] + " has left the " + data['room'] + " room."}, room=data['room'])
def on_leave(data): room = int(data['id']) leave_room(room) print('Left room: {}'.format(room))
def on_leave(room): leave_room(room)
def ws_on_leave_job_status(data): room = data[const.KEY_QUEUE_ID] + '/' + data[const.KEY_JOB_ID] leave_room(room)
def leave(): """ Salir de la partida actual. :return: * Si la partida no se borra porque quedan jugadores: - Un mensaje de tipo :ref:`msg_users_waiting`. - Un broadcast de :ref:`msg_chat` indicando que el jugador ha abandonado la partida. - Si se ha delegado el cargo de líder, el nuevo líder recibirá un mensaje de tipo :ref:`msg_game_owner`. * Si la partida se borra porque no quedan jugadores: - Si ya había terminado, un :ref:`error <errores>`. - Si no había terminado y se ha cancelado, un mensaje de tipo :ref:`msg_game_cancelled`. Requiere que el usuario esté en una partida o se devolverá un :ref:`error <errores>`. """ # No hay partida de la que salir ni limpieza que hacer if session.get("game") is None: return {"error": "No hay ninguna partida de la que salir"} game_code = session["game"] leave_room(game_code) emit( "chat", { "msg": session["user"].name + " ha abandonado la partida", "owner": "[GATOVID]", }, room=game_code, ) del session["game"] match = MM.get_match(game_code) if match is None: return # Limpieza de partidas ya canceladas, no hace falta seguir match.remove_user(session["user"]) logger.info(f"User {session['user'].name} has left the game {game_code}") if len(match.users) == 0: match.end() MM.remove_match(game_code) return # La partida ha acabado, no seguir emit("users_waiting", len(match.users), room=game_code) # Comprobar si hay que delegar el cargo de lider if isinstance(match, PrivateMatch): if match.owner == session["user"]: # Si él es el lider, delegamos el cargo de lider a otro jugador match.owner = match.users[0] emit( "chat", { "msg": match.owner.name + " es el nuevo líder", "owner": "[GATOVID]", }, room=game_code, ) # Mensaje solo al nuevo dueño de la sala emit("game_owner", room=match.owner.sid)
def leave(data): leave_room(data['room']) emit('leaving_event', {'msg': (data['username'] + " went offline")}, room=data['room'])
def on_leave(message): leave_room(message['room'])
def on_leave_room(self, message_json): """Handler to leave a room""" leave_room(message_json['room_id']) response_json, _ = create_system_message('{} left the room'.format( current_user.email)) emit('chat_response', response_json, room=message_json['room_id'])
def leave(data): nickname = data["nickname"] room = data["room"] leave_room(room) emit("show_massege", {"nick": nickname, "leave": "true"}, room=room)
def on_leave(data): i = data['auth'] table_id = data['table_id'] username = get_user_data(i)['userName'] leave_room(table_id) print(username + ' has left the room. ' + table_id)
def on_leave(data): room = data['room'] print('on leave', room) leave_room(room) emit('response', 'someone has left the room.', room=room)
def left(message): """Envia un mensaje a los clientes cuando un usuario deja la sala.""" room = message['room'] leave_room(room) emit('status', {'msg': 'has left the room.'}, room=room)
def left(): room = session.get("room") leave_room(room) emit("status", f"Successfull left room with id {room }")
def leave(data): room = session.get('room') leave_room(room) name = session.get('name') d = dict(message='{} 离开了房间'.format(name), ) emit('status', d, room=room)
def handle_leave_request(data): """Remove user from given room""" logger.info('Received {}'.format(data)) leave_room(data['room']) emit('leaveRoom')
def logout(data): user = data['user'] channel = data['channel'] online_users.remove(user) leave_room(channel)
def close(): leave_room('abcd') print("disconnect")
def join_channel(data): channel = data['channel'] current_channel = data['currentChannel'] leave_room(current_channel) join_room(channel) emit('change channel', {'channel': channel})
def on_close_room(self, message): user = get_username(request.sid) temp_room_name = message['room'].split('_') room_name = '_'.join(temp_room_name[1:len(temp_room_name)]) # if admin, close the room if user == room_lists[room_name]['admin']: # broadcast to users in the room emit('message_response', { 'type': 'room_feed', 'data': { 'text': '{0} 님이 방을 없앴습니다.'.format(user), 'room': room_name, 'from': user, } }, room=room_name) # update room user list emit('feed_response', { 'type': 'update_room_users', 'message': '', 'data': room_lists[room_name]['users'], 'room': room_name, 'user_action': user, 'act': 'close', }, broadcast=True) # close room close_room(room_name) # remove room from list room_lists.pop(room_name) # send message to feed emit('feed_response', { 'type': 'rooms', 'message': '{0} 님이 {1} 을(를) 닫았습니다.'.format(user, room_name), 'data': room_lists }, broadcast=True) else: # if not admin, leave room # broadcast to users in room emit('message_response', { 'type': 'room_feed', 'data': { 'text': '{0} 님이 떠나셨습니다.'.format(user), 'room': room_name, 'from': user, } }, room=room_name) # update room user list emit('feed_response', { 'type': 'update_room_users', 'message': '', 'data': room_lists[room_name]['users'], 'room': room_name, 'user_action': user, 'act': 'leave', }, room=room_name) # leave room leave_room(room_name) # remove user from room room_lists[room_name]['users'].remove(user) # broadcast to users in room that there is user leaving the room emit('feed_response', { 'type': 'rooms', 'message': '{0} 님이 {1} 을(를) 떠나셨습니다.'.format(user, room_name), 'data': room_lists }, broadcast=True)
def disconnect_handle(): try: leave_room('vip') except Exception: pass
def on_leave(data): room = data['room_id'] leave_room(room)
def on_leave(self, message): leave_room(message['room']) session['receive_count'] = session.get('receive_count', 0) + 1 emit('my_response', {'data': 'In rooms: ' + ', '.join(rooms()), 'count': session['receive_count']})