def join(message): join_room(message['room']) session['receive_count'] = session.get('receive_count', 0) + 1 emit(SERVER_GEN_RESPONSE, {'data': 'In rooms: ' + ', '.join(rooms()), 'count': session['receive_count']}) if message['room'] == ROOM_PGRC_PROD: emit(PROD_RESPONSE, {'data': 'In rooms: ' + ', '.join(rooms()), 'count': session['receive_count']}) show_client_status(CLIENT_STATUS_CODE['JOINED'], request.sid)
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 connect(): print('socektid # ', flask_socketio.rooms(), 'connecting in io: .... ') # if they are connected, socketId = flask_socketio.rooms() print(socketId) # how to send to just them? print('emitting to connect so user can just rejoin the room') print('user is in the rooms: ', flask_socketio.rooms())
def no_longer_typing(data): typing_user_rooms = rooms() typing_user_id = get_id_from_rooms(typing_user_rooms) typing_user = DelhiveryUser.objects.get(id=typing_user_id) friend = DelhiveryUser.objects.get(id=data['friend']) if friend.is_online: emit('sender_stopped_typing',{'typing_user': str(typing_user_id)},room=str(friend.id))
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 on_disconnect(): if app.debug: print('Received disconnect') for room in rooms(): if room in module_listeners: module_listeners[room] -= 1
def submitMove(data): print("-------------------------------") print(data) print(flask_socketio.rooms()) room = flask.session['room'] print(room) if game[flask.session['room']] : if flask.session['sid'] in game[flask.session['room']]: game[flask.session['room']].append(data) if data['turn'] =='X': print('############################### emitting to O') io.emit('otherplayermademove', {"row":data['row'], "col":data['col'] }, room =game[room][0]) elif data['turn'] =='O': print('############################### emitting to X') io.emit('otherplayermademove', {"row":data['row'], "col":data['col'] }, room = game[room][1] ) else: print('what the hell are you trying to pull? ') io.emit('observing', {"row":data['row'], "col":data['col'], "turn": data['turn']}, room = "observing"+flask.session['room'] )
def disconnect(): for room in rooms(): if room in game_rooms: try: game_rooms[room].removeSnake(request.sid) del user_snakes[request.sid] except KeyError: pass
def on_edit(ident, content): my_rooms = rooms() my_rooms.remove(request.sid) edit_document(ident, content) emit("edit", get_document(ident), room=my_rooms[-1], json=True)
def on_leave(): conn_rooms = rooms() for room in conn_rooms: if room != req.sid: leave_room(room) rc.client_leave_room(sid=req.sid, room=room) emit("info", req.sid + ' left the room.', room=room) emit("clients", rc.all_clients_in_room(room=room), room=room)
def on_disconnect(): conn_rooms = rooms() for room in conn_rooms: leave_room(room) rc.client_leave_room(sid=req.sid, room=room) # print('Client disconnected') # emit("info", req.sid + ' left the room.', room=room) emit("clients", rc.all_clients_in_room(room=room), room=room)
def on_leave(self, message): leave_room(message['room']) session['receive_count'] = session.get('receive_count', 0) + 1 emit( 'reply', { 'data': 'In rooms: ' + ', '.join(rooms()), 'count': session['receive_count'] })
def handle_server(server): session["room"] = server print("Id: {} is now joining room {}".format(request.__getattr__("sid"), server)) joined_rooms = len(rooms()) if joined_rooms==1: join_room(server) bots[server].force_event()
def no_longer_typing(data): typing_user_rooms = rooms() typing_user_id = get_id_from_rooms(typing_user_rooms) typing_user = DelhiveryUser.objects.get(id=typing_user_id) friend = DelhiveryUser.objects.get(id=data['friend']) if friend.is_online: emit('sender_stopped_typing', {'typing_user': str(typing_user_id)}, room=str(friend.id))
def join(message): join_room(message['room']) session['receive_count'] = session.get('receive_count', 0) + 1 emit( 'Server response', { 'data': 'In rooms: ' + ', '.join(rooms()), 'count': session['receive_count'] })
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'] })
def handle_message(message): print(request.__dict__) print(auth_ids) print(rooms()) if session["room"] is not None and request.__getattr__("sid") in auth_ids: bots[session["room"]].writeLine(message) else: print("user {} was not authenticated".format(request.__getattr__("sid")))
def join(message): join_room(message['room']) emit( 'ServerResponse', { 'data': 'In rooms: ' + ', '.join(rooms()), 'user': "******", 'date': message['date'] })
def on_leave(self, data): room_id = data.pop('room', '') if room_id not in rooms(): return leave_room(room_id) print('有人离开了?') data = {'msg': data['name'] + '离开了房间', 'change': -1} emit('response', data, broadcast=True, room=room_id)
def no_longer_typing(data): typing_user_rooms = rooms() typing_user_id = get_id_from_rooms(typing_user_rooms) typing_user = FakeBookUser.objects.get(id=typing_user_id) friend = FakeBookUser.objects.get(id=data['friend']) if friend in typing_user.friends and typing_user in friend.friends and friend.is_online: emit('sender_stopped_typing', {'typing_user': str(typing_user_id)}, room=str(friend.id))
def on_message(data): if 'from' in data and 'text' in data: if data['from'] in clients: # else received a message from fake client sid = clients[data['from']] if sid is rooms()[0]: # else client is faking his identity !' distribute_message(data)
def join(message): join_room(message['room']) emit('join', {'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 join(json): from flask import (current_app, session) room = json['room'] join_room(room) current_app.logger.info( "Client (sid: {}) joined the room ({}).".format(session.sid, room)) data = {"status": "Joined room ({})".format(room), "rooms": rooms()} emit("message", data)
def on_online_cnt(self, data): room_id = data['room'] if room_id not in rooms(): emit('online_count', 0, room=room_id) return num = len(r_members['/chat'][room_id].keys()) print('是谁再问人数', num) emit('online_count', num, room=room_id)
def leave(message): room = int(message['room']) if manager.operator_leave_room(room, request.sid): leave_room(message['room']) emit('my_response', {'data': 'In rooms: ' + ', '.join(rooms())}) else: emit('my_response', {'data': 'Cannot delete operator from this room'})
def disconnect_handler(): """ Received when the socket is removed or if the client closes the tab. Remove the client from every game and room he's in. """ player_id = get_client_player_id() for room in rooms()[1:]: on_game_leave({"game_id": room, "player_id": player_id}) delete_player(player_id)
def join(message): join_room(message['room']) session['receive_count'] = session.get('receive_count', 0) + 1 emit('my response', {'data': 'In rooms: ' + ', '.join(rooms()), 'count': session['receive_count']}) while(True): emit('my response',{'data': 'In rooms: ','count': 1}) time.sleep(1)
def rate(data): sid = rooms()[0] col = reputationdb[getDomain(data['url']) + '_rating'] myquery = {'rater': sid} result = col.find(myquery) if result.count() == 0: col.insert({'rater': sid, 'rate': data['rate']}) else: col.update(myquery, {'$set': {'rate': data['rate']}})
def leave(json): from flask import (current_app, session) current_app.logger.info("Client (sid: {}) connected".format(session.sid)) room = json['room'] leave_room(room) current_app.logger.info( "Client (sid: {}) left the room ({}).".format(session.sid, room)) data = {"status": "Left room ({})".format(room), "rooms": rooms()} emit("message", data)
def leave(message): """Listener for socket room leaving""" leave_room(message[ec.MArgRoom]) session[ec.SArgReceivedCount] = session.get(ec.SArgReceivedCount, 0) + 1 emit( ec.MOutPrefabResponse, { ec.MOutArgData: "In rooms: " + ", ".join(rooms()), ec.MOutArgCount: session[ec.SArgReceivedCount] })
def join(message): global clients join_room(clients[message['room']]) session['receive_count'] = session.get('receive_count', 0) + 1 emit('qkd', {'data': 'In rooms ' + ', '.join(rooms()), 'laser': message['laser'], 'count': session['receive_count'] }, room=clients[message['room']])
def socket_connect(js): user = get_real_or_anonymous_user() user_id = user.id join_room('user-%s' % user.id) rooms_list = rooms() payload = {'user_id': user_id, 'datetime': str(get_utcnow()), 'rooms_list': rooms_list} print('< SYN: ' + str(js)) print('> SYN/ACK: ' + str(payload)) emit('SYN/ACK', payload)
def join(message): session['room'] = message['room'] join_room(message['room']) emit('log_message_response', {'data': 'In rooms: ' + ', '.join(rooms())}) emit('join_response_global', {'username':session['username'], 'user_id':message['user_id']}, broadcast=True) emit('join_response_local')
def join(message): join_room(message['room']) print(f'from join(), message[\'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 join(message): join_room(message['room']) emit('join', { '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(self): whole = rooms() room = private_chats.query.filter_by(name=whole[1]).first() msg = private_messages(chat_id=room.id, message=current_user.username + '_DISCONNECTED', server_event='D', user=current_user.username) db.session.add(msg) db.session.commit()
def emit_users_info(sid): r = rooms(sid=sid) logger.info("{} now is in: {}".format(current_user.username, r)) emit('users info', { 'amount': len(online_users), 'users': render_template('chat/_users.html', users=online_users), 'rooms_amount': len(r), 'rooms': render_template('chat/_rooms.html', rooms=r) }, broadcast=True)
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"] }, )
def on_join(self, message): join_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 on_disconnect(): global ACTIVE_CLIENTS ACTIVE_CLIENTS -= 1 for room in rooms(sid=request.sid): gm = get_game(room) if gm: join_room(room) gm.players.remove(request.sid) save_game(gm) send(gm.to_json(), room=room)
def get_state(data): session = data["session"] if session not in rooms(): join_room(session) gamestate = init.get_gamestate_from_data(data) if "effects_timestamp" not in data or data["effects_timestamp"] != gamestate.effects_timestamp: emit('neweffects', get_effects_state(gamestate)) if not "initiatives_timestamp" in data or data["initiatives_timestamp"] != gamestate.initiatives_timestamp: emit('newstate', get_initiative_state(gamestate))
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 disconnect_socket(): import flask_socketio for room in flask_socketio.rooms(): leave_room(room) global num_sockets print num_sockets if num_sockets == 0: raise Exception('Num sockets is already zero') num_sockets -= 1
def enterchat(data): print('entering chat') # data: # name, roomid, sid sid = flask_socketio.rooms() print('........ ',sid[0]) print('........ ',flask_socketio.rooms()) if flask.session['room'] not in flask_socketio.rooms(): flask_socketio.join_room(flask.session['room']) print("............", rooms) #get all the users in this room . #for each user in this room, print('sid: ',flask.session['sid']) # for each in rooms[ flask.session['room']]: # # if each != flask.session['name']: # io.emit("user-joined", { "name": each} , room=flask.session['sid']) # # # emit a user joined to only me. io.emit("joined", { "name": data['name']} , room=flask.session['sid']) # for eachuser in theRoom: # io.emit("user-joined", { "name": data['name']} , room=flask.session['sid'] ) #send to everyone in the room io.emit("user-joined", { "name": data['name']}, room=flask.session['room'] )
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 register_user(data): """ Register a user with username:sid. """ username = data['username'] sid = rooms()[0] # add the user to the clients dictionary clients[username] = sid emit('user_registered', username, broadcast=True)
def do_msg(message): """ This will echo out a message sent here: socket.send('SOME MESSAGE'); :param message: :return: """ print(rooms()) emit('event', {'data': 'MESSAGE ECHO: ' + message})
def join(message): join_room(message['room']) emit('fight status', {'data': 'In rooms: ' + ', '.join(rooms())}) emit('fight status', {'data': message['player'] + ' joined the battlefield.', 'player': message['player']}, room=message['room']) front = Battlefront() front.add_player(message['player'], message['player_room']) player_list = front.get_player_list() emit('fight players', {'player': player_list}, room=message['room'], broadcast=True)
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 create_room(data): user_id = data['user_id'] user = DelhiveryUser.objects.get(id=user_id) user.become_online() if user_id not in rooms(): join_room(data['user_id']) join_room(user.role.role) 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('connected_online',{'users':active_users},room='main')
def send_message(data): sender_rooms = rooms() sender_id = get_id_from_rooms(sender_rooms) receiver = DelhiveryUser.objects.get(id=data['sent_to']) sender = DelhiveryUser.objects.get(id=sender_id) chat = DelhiveryChat.get_or_create_chat(sender,receiver) message = DelhiveryMessages.new_message(data['message'],sender,receiver) chat.messages.insert(0,message) chat.save() if receiver.is_online: emit('new_message',room=str(receiver.id)) emit('refresh_sender',room=str(sender.id))
def on_disconnect(): sid = rooms()[0] username = None for client in clients: if clients[client] is sid: username = client clients.pop(client, None) break if username is not None: emit('user_disconnected', username, broadcast=True)
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 joined(json): """ Sent by clients when they enter a room. """ LOG.debug('Received room join: ' + str(json)) room_name = json.get('room_name') parts = room_name.split('::') cluster_name = parts[0] metric = parts[1] join_room(room_name) # sid = request.sid print(rooms()) task_procesor(room_name, cluster_name=cluster_name, metric=metric)
def chat(data): #print("lkasdf", flask.request.args) print("chat data",data) sender = flask.session['name'] room = flask.session['room'] message = data['message'] print('++++ ',room) print('is it one of these?', flask_socketio.rooms()) io.emit("new-chat", { 'sender': sender, 'message': message } , room=room )
def disconnect(): print("someone in these rooms disconected", flask_socketio.rooms()) for room in flask_socketio.rooms(): io.emit('someoneleftaroom', room=room) #flask_socketio.leave_room(room) if room in rooms: print("removing user from room") print (rooms[room]) rooms[room].remove(flask.session['name']) print (rooms[room]) if room in game: if flask.session['sid'] in game[room]: print('removing player from game.') print(game[room]) game[room].remove(flask.session['sid']) io.emit('playerleftgame', room=room) print(game[room])
def join(message): join_room(message['room']) session['receive_count'] = session.get('receive_count', 0) + 1 emit('Server response', {'data': 'In rooms: ' + ', '.join(rooms()), 'count': session['receive_count']})
def join(message): join_room(message['room']) emit('my response', {'data': 'In rooms: ' + ', '.join(rooms()), 'count': session['receive_count']})
def leave(message): leave_room(message['room']) session['receive_count'] = session.get('receive_count', 0) + 1 emit('my response', {'data': 'In rooms: ' + ', '.join(rooms()), 'user': flask_login.current_user.username})