def close(message):
print("close")
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my response', {'data': 'Room ' + message['room'] + ' is closing.',
'count': session['receive_count']},
room=message['room'])
close_room(message['room'])
def close(message):
session['receive_count'] = session.get('receive_count', 0) + 1
emit(SERVER_GEN_RESPONSE, {'data': 'Room ' + message['room'] + ' is closing.', 'count': session['receive_count']},
room=message['room'])
close_room(message['room'])
if message['room'] == ROOM_PGRC_PROD:
show_client_status(CLIENT_STATUS_CODE['CLOSED'])
def close(message):
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my_response', {
'data': 'Room ' + message['room'] + ' is closing.',
'count': session['receive_count']
},
room=message['room'])
close_room(message['room'])
def close(message):
global roomsDict
session['receive_count'] = session.get('receive_count', 0) + 1
if message['room'] in roomsDict:
del roomsDict[message['room']]
emit('my response', {'user': '******', 'data': 'Room ' + message['room'] + ' is closing.',
'count': session['receive_count']},
room=message['room'])
close_room(message['room'])
def on_disconnect(self):
sid = request.sid
client = self.clients_controller.get_client_by_sid(sid)
if client:
self.dir_controller.disconnect_user(client.get_login())
self.clients_controller.remove_client(sid)
close_room(client.get_login())
self.log.info('Room ' + client.get_login() + ' removed')
self.log.info('User #%s disconnected', sid)
def on_leave(data):
print('离开房间')
username = data['user_id']
player_pool.popPlayer(username)
room = data['room']
leave_room(room)
close_room(room)
print(username + ' has left the %s' % room)
return {'data': 'ok'}
def close_game(game_id):
db = get_db()
db.execute('DELETE FROM game WHERE id = ?', (game_id, ))
db.execute('DELETE FROM question WHERE game_id = ?', (game_id, ))
emit('room_closed', room=game_id)
close_room(game_id)
db.commit()
def close(message):
"""Listener for socket room closing event"""
session[ec.SArgReceivedCount] = session.get(ec.SArgReceivedCount, 0) + 1
emit(ec.MOutPrefabResponse, {
ec.MOutArgData: "Room " + message[ec.MArgRoom] + " is closing.",
ec.MOutArgCount: session[ec.SArgReceivedCount]
},
room=message[ec.MArgRoom])
close_room(message[ec.MArgRoom])
def close(message):
session['receive_count'] = session.get('receive_count', 0) + 1
emit(SERVER_GEN_RESPONSE, {
'data': 'Room ' + message['room'] + ' is closing.',
'count': session['receive_count']
},
room=message['room'])
close_room(message['room'])
if message['room'] == ROOM_PGRC_PROD:
show_client_status(CLIENT_STATUS_CODE['CLOSED'])
def leave(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']})
roomstats[message['room']] -= 1
if roomstats[message['room']] < 1:
close_room(message['room'])
emit('delete_room', message['room'])
def close(message):
"""
fechando uma sala
Ex: quando um usuário faz logout
"""
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my_response', {'data': 'Room ' + message['room'] + ' is closing.',
'count': session['receive_count']},
room=message['room'])
close_room(message['room'])
def on_leave_room(data):
room = data['room_id']
name = data['name']
active = Room.query.filter_by(unique_id=room).first()
leave_room(active.unique_id)
if name == active.host:
close_room(active.unique_id)
db.session.delete(active.unique_id)
return redirect(url_for("api.home"))
io.emit("Left_user", {"message": f"{name} has left the room"}, room=active.unique_id, broadcast=True)
def close(message):
if message['room'] not in rooms():
return
emit('close',
{'user': message['user'], 'room': message['room']},
broadcast=True)
close_room(message['room'])
room_list = [room for room in rooms() if room != request.sid]
emit('my response',
{'data': 'In rooms: ' + ', '.join(room_list)})
def close(message):
session["receive_count"] = session.get("receive_count", 0) + 1
emit(
"my_response",
{
"data": "Room " + message["room"] + " is closing.",
"count": session["receive_count"],
},
room=message["room"],
)
close_room(message["room"])
def close(message):
if message['room'] not in rooms():
return
emit('close', {
'user': message['user'],
'room': message['room']
},
broadcast=True)
close_room(message['room'])
room_list = [room for room in rooms() if room != request.sid]
emit('my response', {'data': 'In rooms: ' + ', '.join(room_list)})
def handleDeleteSession(json):
name = json['name']
if name not in sessions:
return
if request.sid != sessions[name]['sid']:
return #only the controller can send updates
emit('leave session response', room=name)
close_room(name)
print("Session Deleted:" + str(json))
del sessions[name]
emit('delete session response')
def close(form):
if (isinstance(form, str)):
form = json.loads(form)
session['receive_count'] = session.get('receive_count', 0) + 1
emit('match_response', {
'action': 'match_closed - ' + str(form['match_data']['id']),
'count': session['receive_count'],
'data': ''
},
room=form['match_data']['id'])
close_room(form['match_data']['id'])
def logoff():
global game
if "username" in session:
uname = session["username"]
game.arena[game.players[uname].pos] = " "
game.players.pop(uname)
close_room(uname)
if not game.players:
game.thread.kill()
game = Game() # reset board
def close(message):
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my_response', {
'data': 'Room ' + message['room'] + ' is closing.',
'count': session['receive_count']
},
room=message['room'])
close_room(message['room'])
print(
f"Close room emission received from client. Emitting my_response: 'Received: #{session['receive_count']}: Room {message['room']} is closing.' Only users in Room {message['room']} can see this message"
)
def close(data):
room = data['room']
r=query_room(room)
ip = request.headers.getlist("X-Forwarded-For")[0]
browser = request.user_agent.browser
if ip == r.ip and browser == r.browser:
emit('close_room', {'room':room}, room=room)
close_room(room)
r=query_room(room)
db.session.delete(r)
db.session.commit()
rd.delete(room)
def left(message):
"""Sent by clients when they leave a room.
A status message is broadcast to all people in the room."""
global room_dict
room = session.get('room')
leave_room(room)
emit('status', {
'msg':
session.get('name') + ' has left the room. The conversation is end'
},
room=room)
close_room(room)
def removefromroom(sid):
for roomname in rooms:
if(sid in rooms[roomname]["users"]):
print("Bruger " + rooms[roomname]["users"][sid] + " afbrød forbindelsen til rummet " + roomname)
del rooms[roomname]["users"][sid]
emitUsersConnected(roomname)
if len(rooms[roomname]["users"]) == 0:
print("Da et rum er tomt slettes dette " + roomname)
close_room(roomname)
del rooms[roomname]
return True
return False
def close(message):
global roomsDict
session['receive_count'] = session.get('receive_count', 0) + 1
if message['room'] in roomsDict:
del roomsDict[message['room']]
emit('my response', {
'user': '******',
'data': 'Room ' + message['room'] + ' is closing.',
'count': session['receive_count']
},
room=message['room'])
close_room(message['room'])
def close_radio():
print("closing radio")
sid = request.sid
radio = _radios.get(sid)
if radio:
close_room(sid)
key = radio.hardware.key
radio.stop()
radio.close()
_radios.pop(sid)
print(f"{key} released")
return "ok"
def stop_game(data):
alive_user_id = data['user_id']
game_id = data['game_id']
game = ROOMS[game_id]
if not game.finished:
game.finished = True
game.winner = alive_user_id
emit("game-extra-finished",
Signals(249, game=game, id=alive_user_id).__str__(),
room=game_id)
leave_room(game_id)
close_room(game_id)
def close(message):
cpas = message['close_password']
rtoclose = message['roomtoclose']
print(cpas, rtoclose)
if rtoclose in roomlist:
if roomstats[rtoclose][1] == cpas:
close_room(rtoclose)
emit('my_response', {'data': 'GLOBAL EVENT:' + rtoclose + 'was closed'})
emit('delete_room', rtoclose,broadcast=True)
roomlist.remove(rtoclose)
del roomstats[rtoclose]
print('roomclosed')
def test_disconnect():
global userscount
userscount -= 1
print('Client disconnected', request.sid, userscount)
if request.sid in usersdata:
rtoclose=usersdata[request.sid]
close_room(rtoclose)
emit('my_response', {'data': 'GLOBAL EVENT:' + rtoclose + 'was closed after leave'})
emit('delete_room', rtoclose, broadcast=True)
roomlist.remove(rtoclose)
del roomstats[rtoclose]
print('closed after leave the chat')
def close_Session(ev):
if ev['uid'] == ev['sessionid'].split('-')[-1]:
emit('session_closed', {
'status': 0,
'message': 'session {0} is closing.'.format(ev['sessionid'])
},
room=ev['sessionid'])
time.sleep(2)
close_room(ev['sessionid'])
else:
emit('server_event', {
'message': 'Not owner of the session. Can not close the session.'
})
def handle_leave(data):
username = data['username']
room = data['room']
session_id = request.sid
leave_room(room)
print(username + ' left ' + room)
send(username + ' has left the chatroom.', room=room)
del common.rooms[room]['users'][session_id]
# Delete room if all users have left
if len(common.rooms[room]['users']) == 0:
print('disposing room ' + room)
close_room(room)
del common.rooms[room]
def close(message):
# Recibe cuenta de session = session.obtener('recibe_cuenta', 0) + 1
session['receive_count'] = session.get('receive_count', 0) + 1
# my_response, { data: 'room' + message[cuarto] + 'esta cerrando', cuenta = session
emit(
'my_response',
{
'data': 'Room ' + message['room'] + ' is closing.',
'count': session['receive_count']
},
# cuarto = mensaje [cuarto], cierra_cuarto[cuarto]
room=message['room'])
close_room(message['room'])
def beforeunload(data):
username = data['username']
online.pop(online.index(username))
# 离开在线房间
leave_room(onlineroomname)
# 发送到前台 做离开、离线
socket.emit('listfriends', {'friends': online}, room=onlineroomname)
socket.emit('isloginout', {'res': "ok"}, room=username)
socket.emit('listfriends', {'friends': []}, room=username)
# 关闭自身房间
close_room(username)
def joinRoom(data):
print(request.sid)
authResponse = authentication()
print("authRes : ", authResponse)
if authResponse["statusCode"] == 200 and authResponse["isVerified"]:
convoId = data.get("conversation_id")
userId = authResponse.get("data").get("user_id")
join_room(userId, request.sid, namespace="/memo")
if convoId is None:
emit("join", {
"status": "failure",
"error": "Invalid request",
"data": None
},
namespace="/memo",
room=userId)
else:
userMemosRes = db.fetchUserMemos(userId, convoId)
if userMemosRes.get("status"):
emit("join",
json.dumps(
{
"status": "success",
"error": None,
"data": userMemosRes.get("data")
},
default=json_util.default),
namespace="/memo",
room=userId)
join_room(convoId, request.sid, namespace="/memo")
else:
emit("join",
json.dumps(
{
"status": "failure",
"error": userMemosRes.get("error"),
"data": userMemosRes.get("data")
},
default=json_util.default),
namespace="/memo",
room=userId)
close_room(userId, namespace="/memo")
else:
raise ConnectionRefusedError('unauthorized!')
def kill(cls, gID):
keys = cls.games[gID].users.keys()
for id in keys:
if not DEBUG:
leave_room(gID, sid=id)
cls.players.pop(id, None)
if not DEBUG:
close_room(gID)
for thread in cls.threads[gID]:
thread.kill()
game = cls.games[gID]
del cls.threads[gID]
del cls.games[gID]
del game
def disconnect_request():
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my_response',
{'data': 'Disconnected!', 'count': session['receive_count']})
print('disconnect')
if request.sid in usersdata:
rtoclose=usersdata[request.sid]
close_room(rtoclose)
emit('my_response', {'data': 'GLOBAL EVENT:' + rtoclose + 'was closed after leave'})
emit('delete_room', rtoclose, broadcast=True)
roomlist.remove(rtoclose)
del roomstats[rtoclose]
print('closed after leave the chat')
disconnect()
def victoryHandler(data):
emit(
"victory",
{
"winner": current_user.username,
"time": data["time"],
"members": db.getRoomMembers(data["room"]),
},
room=data["room"],
broadcast=True,
namespace="/multiplayer",
)
close_room(data["room"])
db.deleteRoom(data["room"])
def leave_match(msg):
"""
If one of them, leaves broadcast the message to all members of room
"""
user = msg['user']
users.remove(user)
if 'matchId' in msg:
roomId = msg['matchId']
if user in rooms[roomId]:
del rooms[roomId][user]
leave_room(roomId)
emit(cs.LEAVE, {"user": user}, room=roomId, include_self=False)
if(len(rooms[roomId].keys()) == 0):
close_room(roomId)
del rooms[roomId]
def close(message):
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my response', {'data': 'Room ' + message['room'] + ' is closing.',
'user': flask_login.current_user.username},
room=message['room'])
close_room(message['room'])
def on_close_room(self, message):
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my_response', {'data': 'Room ' + message['room'] + ' is closing.',
'count': session['receive_count']},
room=message['room'])
close_room(message['room'])
def close(message):
room = message['room']
data = room + ' closing.'
emit('receive room', {'data': data}, room=room)
close_room(room)
def close(message):
emit('my response', {'data': 'Room ' + message['room'] + ' is closing.'}, room=message['room'])
close_room(message['room'])
