def on_join_jobs(data): """ Somebody joined a room """ room = data['room'] join_room(room) flask.session['room'] = room
def joined(message): """Sent by clients when they enter a room. A status message is broadcast to all people in the room.""" global names room = session.get('name') if room == 'EndOfFile': contest_names = copy.deepcopy(names) winner = random.choice(contest_names.keys()) contest_names[winner] = True for name in contest_names: if contest_names[name]: emit('message', {'msg': 'You are the winner!'}, room=name) else: emit('message', {'msg': 'Sorry! Better luck next time!'}, room=name) fh = open('output.txt', 'a') fh.write("\n######## WINNER: {}! ########\n".format(winner)) fh.close() else: names[room] = False join_room(room) fh = open('output.txt', 'w') for name in sorted(names): fh.write("{}\n".format(name)) fh.close()
def search_room(message): #need user # TODO refact user_name = 'Andrew' dragon = message['dragon'] check_key = redis_store.get(user_name) session['receive_count'] = session.get('receive_count', 0) + 1 if not check_key: rooms = searching_room(dragon) if not rooms: room_id = str(uuid.uuid4()) redis_store.sadd('room:{}'.format(dragon),*[room_id]) redis_store.set(user_name, dragon +":"+ room_id) else : room_id = random.choice(list(rooms)) test_filter = filter(lambda room: room != room_id, request.namespace.rooms) if request.namespace.rooms: data = 'leave old rooms before!' else: join_room(room_id) redis_store.sadd('room:{}'.format(dragon),*[room_id]) redis_store.set(user_name, dragon +":"+ room_id) request.namespace.channel = room_id data = 'join_room: ' + ', '.join(request.namespace.rooms) emit('my response', {'data': data, 'count': session['receive_count']}) print request.namespace.channel else: _, room_id = check_key.split(":") request.namespace.channel = room_id if not request.namespace.rooms: join_room(room_id) emit('my response', {'data': 'in room: ' + ', '.join(request.namespace.rooms), 'count': session['receive_count']})
def personal_connect(): if current_user.is_authenticated(): #emit('response', {'data': 'You are now connected.', 'user': '******'}) join_room(current_user.id) else: disconnect()
def socketSetName(user): session['name'] = user['name'] session['room'] = findAvailableRoom() print "room: " + session['room'] addUserToRoom(session['name'], session['room']) join_room(session['room']) gameStart(session['room'])
def enterGame(msg, db, gameMsg): gameId = msg['gameId'] name = msg['name'] sameNameExists = False players = [parsePlayer(i) for i in db.fetchall('SELECT name, handJSON FROM players WHERE gameId = %d; ' % gameId)] for player in players: if player['name'] == name: sameNameExists = True send({ 'error': { 'event': 'enterGame', 'reason': 'same name exists' } }, json=True) break if not sameNameExists: db.execute("INSERT INTO players (gameId, name, handJSON, joined) VALUES (%d, '%s', '%s', 0)" % (gameId, name, '[]')) game = getGame(db, gameId) gameMsg.buildEnterGame() send({ 'event': 'enterGame', 'message' : gameMsg.message, 'game': game }, json=True, room=gameId) join_room(gameId) messages = [parseMessage(i) for i in db.fetchall("SELECT name, type, messageJSON, time FROM messages WHERE gameId = %d; " % gameId)] gameMsg.message['elements']['messages'] = messages send({ 'event': 'enterGame', 'message' : gameMsg.message, 'game': game }, json=True)
def join(message): """joins and adds clients to global var rooms""" global rooms if rooms.get(message["room"]) == None: rooms[message["room"]] = [] if len(rooms.get(message['room'], [])) < 2: if message['start'] == 1: join_room(message['room']) rooms[message['room']].append(session['login']) emit('invite_to_join', {'room_name': message['room']}, broadcast=True) elif message['start']==2: join_room(message['room']) rooms[message['room']].append(session['login']) starter = rooms[message['room']][0] joiner = rooms[message['room']][1] emit('start_game', {'room_name': message['room'], 'starter': starter, 'joiner': joiner}) # emit('full_room', {}, broadcast=True) else: print "full room"
def joined(message): """Sent by clients when they enter a room. A status message is broadcast to all people in the room.""" di={} room = session.get('room') #u=url+room+"/_search" join_room(room) emit('status', {'msg':"<span style='font-size:18px;color:#ff6600;text-align:center; margin-bottom:10px; border-bottom:1px solid black'>" + session.get('name') + ' has entered the room.'}, room=room) coll=db[room] chat=coll.find() l=[] for c in chat: try: emit('message',{'msg': "<div style='word-wrap:break-word; margin-right:5px;margin-top:3px;min-height:10px'>"+"<span id='names' style='float:left;max-width:10%;width:100%;margin-left:10px; color:#1234df'>"+c['name']+"</span>" + '<span style= "float:left;max-width:85%;width:100%;text-align:justify; margin-left:10px">'+ c['message']+"</span></div>"}) except: l=c['trending'] print l di={i:l.count(i) for i in l} #emit('notify',{'msg':'<div>Trending Now: <b>'+c['trend']+'</b></div>'}) print di da=[] for i in di.keys(): da.append({"label":i,"value":di[i]}) print da emit("draw",{'msg':str(da)}) #print l #print di for i in di.keys(): emit('notify',{'msg':'<div style="width:70%;bottom-border:1px solid #ff6600"><b>'+i+'</b></div>'}) '''
def join_into_room(id): data = False if id is not None: join_room(id) data = True return data
def makeConnection(): db = connectToDB() cur = db.cursor(cursor_factory=psycopg2.extras.DictCursor) global messages messages = [] #reset the message array on a reconnect rooms = [] messages = [{'text': 'Booting system', 'name': 'Bot'}, {'text': 'ISS Chat now live!', 'name': 'Bot'}] session['uuid'] = uuid.uuid1() session['username'] = '******' print('connected') users[session['uuid']] = {'username': '******', 'room': 'General'} join_room(users[session['uuid']]['room']) emit('joinedGeneral') print users[session['uuid']]['username'] + ' joined room ' + users[session['uuid']]['room'] cur.execute("SELECT roomname FROM rooms;") roomList = cur.fetchall() for room in roomList: rooms.append(room) emit('createRoom', room) cur.execute("select * from issmessages where room = %s;", (users[session['uuid']]['room'],)) results = cur.fetchall() if(len(results) > 0): for result in results: tmp = {'text': result[2], 'name': result[1]} messages.append(tmp) for message in messages: print(message) emit('message', message)
def joined(message): """Sent by clients when they enter a room. A status message is broadcast to all people in the room.""" room = session.get('room') join_room(room) print "joined" emit('status', {'msg': session.get('name') + ' has entered the room.'}, room=room,namespace='/chat')
def on_join(room): db = connectToDB() cur = db.cursor(cursor_factory=psycopg2.extras.DictCursor) global messages subbedRooms = [] cur.execute("SELECT rooms.roomname FROM rooms JOIN subscriptions ON rooms.id = subscriptions.room_id JOIN users ON subscriptions.user_id = users.id WHERE users.username = %s;", (users[session['uuid']]['username'],)) subbedRooms = cur.fetchall() print subbedRooms if room in subbedRooms: leave_room(users[session['uuid']]['room']) print 'Leaving room ' + users[session['uuid']]['room'] for message in messages: emit('refreshMessages') messages = [] users[session['uuid']]['room'] = room[0] join_room(users[session['uuid']]['room']) print users[session['uuid']]['username'] + ' joined room ' + users[session['uuid']]['room'] cur.execute("select * from issmessages where room = %s;", (users[session['uuid']]['room'],)) results = cur.fetchall() if(len(results) > 0): for result in results: tmp = {'text': result[2], 'name': result[1]} messages.append(tmp) emit('message', tmp, room=users[session['uuid']]['room']) emit('joined', users[session['uuid']]['room']) else: print 'You are not subscribed to that chatroom'
def join(message): """joins and adds clients to global var rooms""" global rooms if rooms.get(message["room"]) == None: rooms[message["room"]] = [] if len(rooms.get(message['room'], [])) < 2: if message['start'] == 1: join_room(message['room']) rooms[message['room']].append(session['login']) emit('invite_to_join', {'room_name': message['room']}, broadcast=True) elif message['start'] == 2: join_room(message['room']) rooms[message['room']].append(session['login']) starter = rooms[message['room']][0] joiner = rooms[message['room']][1] emit('start_game', { 'room_name': message['room'], 'starter': starter, 'joiner': joiner }) # emit('full_room', {}, broadcast=True) else: print "full room"
def handle_join(data): """User joins the room.""" username = data['username'] room = 'room' join_room(room) USERS.add(username) emit('users', {'users': sorted(USERS)}, room=room)
def state_connect(): game_id = STATE['game_id'] player_id = session['player_id'] join_room(game_id) emit('join', {'player_id': player_id, 'player_name': PLAYER.get(player_id)}, room=game_id) print('Client [%s] connected to game [%s]' % (player_id, game_id))
def joined(message): '''A new user has entered the room, status message sent to everybody in the room. Also, the list of active users is updated and setn to everybody in the room''' room = session.get('room') join_room(room) emit('status', {'msg': session.get('name') + ' has entered the room.'}, room=room) emit('active', {'msg': '\n'.join(list(active_users[room])) }, room=room)
def add_monitor(data): pvname = data['pv'] monitors = session.get('monitors', defaultdict(int)) monitors[pvname] += 1 session['monitors'] = monitors session.modified = True if monitors[pvname] > 1: # Client was already monitoring this PV so no need to create a # monitor or join room. return if pvname in pv_lookup: # A monitor has already been set up for this PV so we can just # join the room. join_room(pvname) return try: pv_lookup[pvname] = PV(pvname, callback=pv_changed) except CASeverityException: session['monitors'][pvname] -= 1 else: join_room(pvname)
def joined(message): """Sent by clients when they enter a room. A status message is broadcast to all people in the room.""" room = session.get('room') join_room(room) print "session1", session emit('status', {'msg': session.get('name') + ' has entered the room.'}, room=room)
def test_connect(): print("in connect") conn = connectToDB() cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor) join_room('general') session['uuid'] = uuid.uuid1() query = ("SELECT name1, message, room FROM messages WHERE room='general';") cur.execute(query) results = cur.fetchall() message = {} room = {} for result in results: message['name'] = result['name1'] message['text'] = result['message'] message['room'] = result['room'] emit('sendMessages', message) print(message) query = "SELECT room1 FROM rooms;" cur.execute(query) results = cur.fetchall() for result in results: room['room'] = result['room1'] emit('sendRooms', room) print(result) print 'connected'
def chat_window_open(message): """Sent by clients when they leave a room. A status message is broadcast to all people in the room.""" room = int(message["sender_id"][0:4]) + int(message["sender_id"][5:9]) room = room + int(message["receiver_id"][0:4]) + int(message["receiver_id"][5:9]) join_room(room) emit('status', {"status":"open"}, room = room)
def answer_student(data): """ Needs to make a socket call to shift student and TA to a specific room. There will be an another function which catches a signal that is emitted back (Python code will add both users to a room on this signal) and will return a href to redirect the users {unique roomID} and will be redirected using window's href in the javascript code :param data: data from socketio call """ join_room(data['ta']) # Joined ta's room new_data = {'room' : data['net_id'], 'student': data['net_id'], 'ta': data['ta']} path = os.path.abspath("VOH/codeshare.py") print path link = subprocess.check_output(["python", path]) # emit('answer_info', new_data, namespace='/queue', broadcast=True) # Adding a new collection for particular student, ta pair. Collection name is the ta's netID ts = time.time() st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S') client, db = open_db_connection() db['chat_log'][data['ta']].insert( dict(room=data['ta'].encode("utf-8"), message="Started Conversation", time=st.encode("utf-8"))) close_db_connection(client) emit('student_join_emit', {"student" : data['net_id'], "ta" : data['ta'], "link":link}, broadcast = True )
def joined(message): """Sent by clients when they enter a room. A status message is broadcast to all people in the room.""" room = session.get('room') with_bot = False if room in bot_rooms.keys(): with_bot = True # Store previous ID bot_room = room room = str(uuid.uuid4()) # Create private room session["room"] = room # Update session join_room(room) emit('status', {'msg': session.get('name') + ' has entered the room.'}, room=room) if with_bot: # Reverse name for CopyCat bot if bot_room == "60": bot_name = session.get('name')[::-1] # Keep instance of bot else: bot_name = bot_rooms[bot_room] b = Bot(bot_name) b.setup() active_bots[room] = b # Greet user emit('status', {'msg': b.name() + ' [BOT] has entered the room.'}, room=room) emit('message', {'msg': b.name() + ': ' + b.greet()}, room=room)
def joined(data): user_2 = data.get('id') if user_2 is None: return emit('status', {'flag': False, 'msg': 'id is empty'}) try: user_2 = int(user_2) except ValueError: return emit('status', {'flag': False, 'msg': 'ValueError : id is not int'}) except TypeError: return emit('status', {'flag': False, 'msg': 'TypeError'}) user_1 = session.get('user_id') extra = compare(user_1, user_2) room_id = '%d|%d' % extra session.setdefault('rooms', []) if room_id not in session['rooms']: join_room(room_id) session['rooms'].append(room_id) emit('unique_wire', {'flag': True, 'id': user_2, 'user': user_1}, room=user_2) save_room(room_id, user_1, user_2) chat = take_message(room_id, extra, number=0) context = { 'flag': True, 'room': room_id, 'history': chat, 'id': user_2, } emit('status', context)
def select(message): user = User.getUser(session['username']) user.joinRoom(message['room']) join_room(message['room']) room = Room.getRoom(message['room'], user) emit('selected', {'room': message['room'], 'messages':room.getMessages()})
def join_all_rooms(data): rooms = data.get('rooms') if rooms is not None: for x in rooms: if x: join_room(x) print('USER id :', session.get('user_id'), 'joining room : ' + x)
def join(message): new_game = False play_computer = message['data']['play_computer'] if not message['room']: new_game = True if new_game: game_room = 'game' + str(random.randint(1, 10000)) marker = 'X' else: game_room = message['room'] marker = 'O' join_room(game_room) session['receive_count'] = session.get('receive_count', 0) + 1 response_data = {} response_data['marker'] = marker response_data['room'] = game_room response_data['start'] = False response_data['count'] = session['receive_count'] emit('set-room', {'data': response_data}) # Now broadcast to other player in the room that game can start if new_game and not play_computer: response_data['start'] = False response_data['message'] = 'Waiting for Opponent to Join' else: response_data['start'] = True response_data['move_marker'] = 'X' emit('game-start', {'data': response_data}, room=response_data['room'])
def create_or_join(room): print 'Received request from clientid' + request.namespace.socket.sessid + ' to create or join room ' + str(room) if str(room) in clients: clients[str(room)].append(request.namespace.socket.sessid) print 'Dictionary being updated' else: clients.update({ str(room): [request.namespace.socket.sessid]}) print 'Dictionary entry being created' numClients = len(clients[str(room)]) print numClients if numClients <= 1: join_room(str(room)) logger('Client ID ' + request.namespace.socket.sessid + ' created room ' + str(room)) print 'Client ID ' + request.namespace.socket.sessid + ' created room ' + str(room) emit('created', room, request.namespace.socket.sessid) elif numClients <= 2: logger('Client ID ' + request.namespace.socket.sessid + ' joined room ' + str(room)) print 'Client ID ' + request.namespace.socket.sessid + ' joined room ' + str(room) join_room(str(room)) emit('joined', room, request.namespace.socket.sessid) emit('nowready', room=room) #This sends it to all the clients FROM the server since the socketio else:#Max 2 clients print "Room is full" emit('full', room)
def resumeGame(msg, db, gameMsg): gameId = msg['gameId'] name = msg['name'] players = db.fetchall("SELECT name FROM players WHERE gameId = %d AND name='%s'" % (gameId, name)) if len(players) != 0: game = getGame(db, gameId) gameMsg.buildResumeGame() send({ 'event': 'resumeGame', 'message' : gameMsg.message, 'game': game }, json=True, room=gameId) join_room(gameId) messages = [parseMessage(i) for i in db.fetchall("SELECT name, type, messageJSON, time FROM messages WHERE gameId = %d; " % gameId)] gameMsg.message['elements']['messages'] = messages send({ 'event': 'resumeGame', 'message' : gameMsg.message, 'game': game }, json=True) else: send({ 'error': { 'event': 'resumeGame', 'reason': 'no player with name exists' } }, json=True)
def api_call(self, msg_str): msgJson = json.loads(msg_str); sessionJson = msgJson.values()[0]['session'] print 'session[id]:', 'id' in session if 'id' in session: print 'session[id]:', session['id'] print "sessionJson['uuid']", sessionJson['uuid'] if 'id' in session: print session['id'] == sessionJson['uuid'] if 'id' not in session or session['id'] != sessionJson['uuid']: print 'Join Room: ', sessionJson['uuid'], ' ...............................' join_room(sessionJson['uuid']) session['id'] = sessionJson['uuid'] # receipt = self.Receipt() def cb(evt): # receipt.status = receipt.DONE # receipt.rsp = evt evt.values()[0]['session'] = sessionJson socketio.emit('call_ret', {'msg': json.dumps(evt)}, room=sessionJson['uuid']) # self.api_tasks[receipt.id] = receipt try: self.bus.send(msg_str, cb) # return receipt.to_json() except Exception as e: del self.api_tasks[receipt.id] log.debug(utils.get_exception_stacktrace())
def on_join(room): db = connectToDB() cur = db.cursor(cursor_factory=psycopg2.extras.DictCursor) global messages subbedRooms = [] cur.execute( "SELECT rooms.roomname FROM rooms JOIN subscriptions ON rooms.id = subscriptions.room_id JOIN users ON subscriptions.user_id = users.id WHERE users.username = %s;", (users[session['uuid']]['username'], )) subbedRooms = cur.fetchall() print subbedRooms if room in subbedRooms: leave_room(users[session['uuid']]['room']) print 'Leaving room ' + users[session['uuid']]['room'] for message in messages: emit('refreshMessages') messages = [] users[session['uuid']]['room'] = room[0] join_room(users[session['uuid']]['room']) print users[session['uuid']]['username'] + ' joined room ' + users[ session['uuid']]['room'] cur.execute("select * from issmessages where room = %s;", (users[session['uuid']]['room'], )) results = cur.fetchall() if (len(results) > 0): for result in results: tmp = {'text': result[2], 'name': result[1]} messages.append(tmp) emit('message', tmp, room=users[session['uuid']]['room']) emit('joined', users[session['uuid']]['room']) else: print 'You are not subscribed to that chatroom'
def test_getroom(message): print "join room" print message join_room(message['room']) emit('set room', { 'room': list(request.namespace.rooms)[0], 'sender': message['u_id'] })
def joined(message): """Sent by clients when they enter a room. A status message is broadcast to all people in the room.""" C = chat_session() start_chat(C.room_id) join_room(C.room_id) app.logger.debug("Testing logger: User {} has entered room {}.".format(C.my_id, C.room)) emit_message_to_userid("Your partner has entered the room.", C.partner_id, status_message=True)
def joined(message): '''A new user has entered the room, status message sent to everybody in the room. Also, the list of active users is updated and setn to everybody in the room''' room = session.get('room') join_room(room) emit('status', {'msg': session.get('name') + ' has entered the room.'}, room=room) emit('active', {'msg': '\n'.join(list(active_users[room]))}, room=room)
def handle_ping(data): if not keyword_test(data['keyword']): return join_room(data['keyword']) result = keywordsmanager.ping_keyword(data['keyword']) if result: emit('keywords_synced', {'synced': True})
def on_join(data): room = data['room'] socketio.join_room(room) message = {} insert_user_info(message) join_room(data['room'], message['user_id']) socketio.emit('userJoin', message, namespace='/chat', room=room) socketio.emit('users', {'users': rooms[room]['users']}, namespace='/chat', room=room)
def handle_open_stream(data): track = translate_track(data['track']) if 'rooms' in session: session['rooms'][track] = True else: session['rooms'] = {track: True} join_room(track) open_stream(socketio, track)
def join(message): join_room(message['room']) console = Console.query.filter_by(name=message['room']).first() for button in console.buttons: if button.is_running(): if 'serving-{}'.format(button.id) not in greenlets.keys(): greenlets['serving-{}'.format(button.id)] = gevent.spawn(serve_log, button.log_file, button.id, console.name)
def loginChat(): print('Trying to pass username to socketio') if 'username' in session: emit('loginChat', session['username']) join_room('public') session['roomname'] = 'public' else: emit('login', '')
def join(message): join_room(message['room']) session['receive_count'] = session.get('receive_count', 0) + 1 emit( 'my response', { 'data': 'In rooms: ' + ', '.join(request.namespace.rooms), 'count': session['receive_count'] })
def request_random(message): print (message) room = random.choice(foods) join_room(room) if room not in peers: peers[room] = [] peers[room].append(message['peer']) emit('join confirm', {'room': room, 'peers': peers[room]})
def joined(message): """Sent by clients when they enter a room. A status message is broadcast to all people in the room.""" room = message.get('room') user = message.get('user') join_room(room) app.logger.info('User %s joined %s room' % (user, room)) emit('status', {'msg': user + ' has entered the room.', 'username': user}, room=room)
def join(data): """ Function is called when a TA and Student need to join a particular room so that they can be directed to a unique URL to start their chat :param data: Data Containing information about the room """ join_room(data['id']) emit('join_room_ta', {'msg': "hi, you are in room " + data['id']}, room=data['id']) # Emits signal to a particular chat conversation
def on_join(data): """ Sent by clients when they enter a room. """ username = session["login"][0] room = find_room(data["bookgroup_id"], data.get("chapter_number")) join_room(room) emit('joined_status', {'msg': username + " has entered room " + str(room)}, room=room)
def join(message): room = session.get('room') join_room(room) if not room in rooms: rooms[room] = set() rooms[room].add(session.get('user')) msg = '<' + session.get('user') + ' joined the chat>' emit('message', {'msg': msg}, room=room)
def socketio_full_image(message): # print('full image', message) bid = message['data']['board_id'] key = message['data']['key'] board = whiteboards[bid] if board.may_view(key): socketio.join_room(bid) data = {'data': {'board_id': bid, 'actions': board.full_image()}} socketio.emit('paint', data)
def join(message): room = message['room'] join_room(room) session['room'] = room player_id = session['user_id'] game = games[room] game.join(player_id) update(game, room) request.namespace.emit('userId', session['user_id'])
def joined(message): """Sent by clients when they enter a room. A status message is broadcast to all people in the room.""" username = session.get("name") room = session.get('room') join_room(room) app.logger.debug("Testing logger: User {} has entered room {}.".format( username, room)) emit('status', {'msg': username + ' has entered the room.'}, room=room)
def state_connect(): game_id = STATE['game_id'] player_id = session['player_id'] join_room(game_id) emit('join', { 'player_id': player_id, 'player_name': PLAYER.get(player_id) }, room=game_id) print('Client [%s] connected to game [%s]' % (player_id, game_id))
def tutor_ready(): for i in session['subjects'].split(','): if unifiedQueue.can_service(i): tuteeName, tuteeLocation = unifiedQueue.service(i, session['name'], session['location']) emit('found_tutee', {'tuteeName' : tuteeName, 'tuteeLocation' : tuteeLocation}) return room = unifiedQueue.offer(session['subjects'].split(','), session['name'], session['location']) join_room(room) print('Joined room since no tutees') emit('no_tutees', {'data' : room}, room=room)
def on_connect(): join_room(current_user.email) try: connected_clients[current_user.email].append(request.namespace) except KeyError: connected_clients[current_user.email] = [request.namespace] emit('connected', { 'user': current_user.email, "count": len(connected_clients[current_user.email]) }, room=current_user.email)
def joined(message): """Sent by clients when they enter a room. A status message is broadcast to all people in the room.""" room = session.get('room') join_room(room) msg = find_links_in_message( u'<i> has entered the <strong>${}</strong> room.</i>'.format(room), session.get('name'), session.get('avatar') ) emit('status', {'msg': msg}, room=room)
def success_connect(msg): #print(msg['room']) #print(msg['user']) users_obj = Room.query.filter_by(name=msg['room']).first().users join_room(msg['room']) emit('success join room', { 'log': '[' + msg['user'] + '] : Joined room => ' + msg['room'], 'users': [u.name for u in users_obj], 'points': [u.point for u in users_obj] }, room=msg['room'])
def handle_join(raw_data, data=None, user=None, error=None): if error: return emit('error', error) requested_room = data.get('room') if requested_room != 'default': # we will only restrict the room for the MVP error = "Sorry, but only the 'default' room is available" return emit('error', error) join_room(requested_room) emit('joined', {'room': requested_room})
def socketio_full_image(message): bid = message['board_id'].upper() key = message['key'] board = whiteboards[bid] # Ensure the user may see this board if board.may_view(key): socketio.join_room(bid) data = { 'board_id': bid, 'actions': board.full_image() } socketio.emit('paint', data)
def joined(message): """Sent by clients when they enter a room. A status message is broadcast to all people in the room.""" room = session.get('room') u=url+room+"/_search" join_room(room) emit('status', {'msg': session.get('name') + ' has entered the room.'}, room=room) coll=db[room] chat=coll.find() for c in chat: emit('message',{'msg':c['name']+": "+c['message']}) '''
def joined(message): """Sent by clients when they enter a room. A status message is broadcast to all people in the room.""" room = message.get('room') user = message.get('user') join_room(room) app.logger.info('User %s joined %s room' % (user, room)) emit('status', { 'msg': user + ' has entered the room.', 'username': user }, room=room)
def on_join(data): story_id = data['story_id'] current_segment = Segment.last(story_id=story_id) if current_segment is None: current_segment = Segment.create(story_id=story_id) join_room(story_id) emit('welcome', { 'current_segment_id': current_segment.id }, room=story_id) emit('user_joined', { 'user': current_user.name, }, broadcast=True, room=story_id)