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