def test_modify_order(self): orderbook = OrderBook("testInstrument") order_to_be_modified = Order(1, 10, 10, 1) orderbook.id_map[1] = order_to_be_modified orderbook.bid_book[10].append(order_to_be_modified) order = Order(2, 10, 10, 1) orderbook.id_map[2] = order orderbook.bid_book[10].append(order) self.assertEqual(len(orderbook.bid_book[10]), 2) self.assertEqual(orderbook.bid_book[10][0].id, 1) # Removing 8 shares from the order modify_message = Message(1, MessageType.MODIFY, 1, 8, 10, 1) orderbook.send(modify_message) # Ordering has not changed in the orderbook modified_order = orderbook.bid_book[10][0] self.assertEqual(modified_order.id, 1) self.assertEqual(modified_order.qty, 2) # Adding 8 shares to the order modify_message = Message(2, MessageType.MODIFY, 1, -8, 10, 1) orderbook.send(modify_message) # Ordering has changed modified_order = orderbook.bid_book[10][1] self.assertEqual(modified_order.id, 1) self.assertEqual(modified_order.qty, 10)
def test_add_message(self): if self.dbh.username_exists(self.user.username): self.user = self.dbh.get_user_by_username(self.user.username) else: user_id = self.dbh.add_user(self.user) self.user.id = user_id message = Message(self.user.id, 'Test twitter clone message number 1, yay!!!!') result = self.dbhm.post_message(message) self.assertTrue(result) stored_message = self.dbhm.get_message(message.id) self.assertEqual(stored_message.message, message.message) self.assertEqual(stored_message.user_id, str(message.user_id)) message = Message(self.user.id, 'Another test message wooo') result = self.dbhm.post_message(message) self.assertTrue(result) stored_message = self.dbhm.get_message(message.id) self.assertEqual(stored_message.message, message.message) self.assertEqual(stored_message.user_id, str(message.user_id)) messages = self.dbhm.get_user_messages(self.user.id) self.assertEqual(2, len(messages))
def answer(message, user, group): clue = group.clue if clue.is_endpoint: group.completed_at = datetime.now() return Result(response_type=CLUE, messages=[Message(text=group.story.end_message)], user=user, group=group) answers = group.clue.answers next_clue, answer_data = get_next_clue(message, answers) if next_clue: group.clue_uid = next_clue user_data, group_data = split_data(answer_data) user.data.update(user_data) group.data.update(group_data) if group.clue.is_endpoint: group.completed_at = datetime.now() return Result(response_type=CLUE, messages=[group.clue], user=user, group=group) # They got the answer wrong - send them a hint logging.info('Sending hint') if clue.hint: return Result(response_type=HINT, messages=[Message(text=clue.hint)], user=user, group=group) return Result(response_type=HINT, messages=[Message(text=group.story.default_hint)], user=user, group=group)
def run(self): User.drop_collection() Message.drop_collection() user1 = User() user2 = User() user3 = User() user4 = User() user1.firstName = "John" user1.lastName = "Doe" user1.birthDate = datetime.now() user1.userName = "******" user1.passHash = user1.userName user2.firstName = "Jane" user2.lastName = "Doe" user2.birthDate = datetime.now() user2.userName = "******" user2.passHash = user2.userName user3.firstName = "Michelle" user3.lastName = "Nielsen" user3.birthDate = datetime.now() user3.userName = "******" user3.passHash = user3.userName user4.firstName = "Leif" user4.lastName = "Paulsen" user4.birthDate = datetime.now() user4.userName = "******" user4.passHash = user4.userName user1.save() user2.save() user3.save() user4.save() message1 = Message() message1.subject = "First message" message1.text = "This is the first message ever in the system. Hello Jane this is John, how are you?" message1.sender = user1 message1.receiver = user2 message1.save() message2 = Message() message2.subject = "Second message" message2.text = "This is the second message ever in the system. Hello Jane this is Åge, how are you?" message2.sender = user4 message2.receiver = user2 message2.save() message3 = Message() message3.subject = "Second message" message3.text = "This is the Third message ever in the system. Hello Jane this is Åge, how are you?" message3.sender = user4 message3.receiver = user1 message3.save()
def draw_health_ui(screen, player_health, enemy_health): draw_message( screen, Message("Health : " + str(player_health), definitions.PLAYER_HEALTH), 15, (definitions.SCREEN_WIDTH - 95, definitions.SCREEN_HEIGHT - 25)) draw_message( screen, Message("Health : " + str(enemy_health), definitions.ENEMY_HEALTH), 15, (definitions.SCREEN_WIDTH - 95, 10))
def post(self): if self.request.POST.get('Body') is None or self.request.POST.get( 'From') is None: logging.error('Body and From params required') return self.abort(400, 'Body and From params required') user_message = Message( text=self.request.POST.get('Body').strip(), receiver=self.request.POST.get('To'), sender=self.request.POST.get('From'), media_url=self.request.POST.get('MediaUrl0'), ) from_phone = self.request.get('From') to_phone = self.request.get('To') logging.info('Received text from %s with media: %s message:\n%s', from_phone, user_message.media_url, user_message.text) user = User.get_by_id(from_phone) if user: logging.info('Found existing user for %s', from_phone) else: logging.info('Creating new user for %s', from_phone) user = User(id=from_phone) message_type = determine_message_type(user_message.text) logging.info('Message of type: %s', message_type) group = user.group response_type, messages, user, group = perform_action( message_type, user_message, user, group) responses = [format_message(m, user, group) for m in messages] logging.info('Responding with: %s', responses) self.response.body = twiml_response(user, group, response_type, responses) self.response.headers['Content-Type'] = 'text/xml' logging.info('Responding: %s', self.response.body) user_message.story_uid = group.story_uid if group else None user_message.group_uid = group.uid if group else None user_message.put() ndb.put_multi([ Message(receiver=from_phone, sender=to_phone, text=m.text, media_url=m.media_url, group_uid=group.uid if group else None, story_uid=group.story_uid if group else None) for m in responses ]) if group: group.put() user.group_uid = group.uid else: user.group_uid = None user.put()
def _backfill(initial_messages, n_duplicates): """Backfills for order ids found in the sample, but without a NEW_ORDER message. Also adds executions/deletions for order ids that are not closed in the sample.""" id_map = defaultdict(list) for i, msg in enumerate(initial_messages): if msg.id == 0: continue id_map[msg.id].append(Placement(i, msg)) id_diff = max(id_map) - min(id_map) + 1 backfilled = [] upper_delete_bound = int(len(initial_messages) / 10) for id_, placements in id_map.items(): first_place = placements[0] if first_place.message.message_type != MessageType.NEW_ORDER: # Order without a NEW_ORDER message new_index = _rand_range( max(0, first_place.index - 500), first_place.index) time_diff = initial_messages[new_index].time - \ initial_messages[max(0, new_index - 1)].time _time = initial_messages[new_index].time - \ random.random() * time_diff backfilled.append( Placement( new_index, Message(_time, MessageType.NEW_ORDER, id_, _initial_qty_for_messages( placements), first_place.message.price, first_place.message.direction) ) ) unfilled_qty = _unfilled_qty_for_messages(placements) if unfilled_qty: # Unfilled order new_index = _rand_range(0, upper_delete_bound) time_diff = initial_messages[new_index].time - \ initial_messages[max(0, new_index - 1)].time _time = initial_messages[new_index].time + \ random.random() * time_diff backfilled.append( Placement( # Subtract from id to apply on order from previous loop new_index, Message(_time, MessageType.DELETE, id_ - id_diff * n_duplicates, unfilled_qty, first_place.message.price, first_place.message.direction, fake=True) ) ) return sorted( backfilled, key=lambda msg: ( msg.index, msg.message.time, msg.message.id ) ), id_diff
def send_data(soc, data): try: soc.send(pickle.dumps(data)) except BlockingIOError: pass except AttributeError: glVars.messages.append( Message(definitions.SERVER_INACTIVE, definitions.ERROR_MESSAGE)) glVars.isServerActive = False except BrokenPipeError: glVars.messages.append( Message(definitions.GAME_CRASHED, definitions.ERROR_MESSAGE)) glVars.isServerActives = False
def add_message(lifelines): message_type_dict = { 1: 'Synchronous', 2: 'Assynchronous', 3: 'Reply' } message_name = input('Insert the Message name: ') while(len(message_name)==0): print('MessageFormatException - You must define a message name') print('Select the source Lifeline: ') print_lifelines(lifelines) try: source_lifeline = lifelines[int(input('Which is the initial Lifeline?'))] except: print('MessageFormatException - Please select a valid Lifeline') source_lifeline = lifelines[int(input('Which is the initial Lifeline?'))] try: target_lifeline = lifelines[int(input('Which is the final Lifeline?'))] except: print('MessageFormatException - Please select a valid Lifeline') target_lifeline = lifelines[int(input('Which is the initial Lifeline?'))] prob = input('How much is the message probability?') print_message_type() message_type = message_type_dict[int(input())] message = Message(name=message_name, source=source_lifeline, target=target_lifeline, prob=prob, message_type=message_type) return message
def grab(self): data = self.get(self.scrape_uri).content soup = bs4.BeautifulSoup(data, self.parser) for element in self.filter_soup(soup): m = Message(content=self.get_contents(element), date=datetime.now()) self.save_message(m)
def add_message(message): Message( name_lastname=message["name_lastname"], email=message["email"], subject=message["subject"], message=message["message"] )
def get(self, key, value): response = [] for rec in self.collection.find({key: value}): d = dict(rec) del (d['_id']) response.append(Message(**d)) return response
def add_follower(page_name=None): """ @param page_name: @return: @rtype: """ error = list() # get the id of the user you want to follow if request.method == 'GET': # via ajax message = request.args.get('follow-user-id', '', type=str) else: # via no javascript post message = request.form['follow-user-id'] if 'user' in session: dbh = MessageHelper(StrictRedis()) message_object = Message(session['user']['id'], message) dbh.post_message(message_object) else: return redirect(url_for('login')) if request.method == 'GET': return jsonify(post_time=message_object.posted_time, format_time=message_object.formatted_time, msg_id=message_object.id) return redirect(url_for('dash'))
def join_chat(chat_id): chat_ = Chat.query.filter_by(id=chat_id).first() user_in_db = User.query.filter_by(id=session['user_id']).first() if chat_ in user_in_db.chats: flash(f'You are already a member of chat {chat_.name}.', category='danger') return redirect(url_for('find_chat')) user_joined_message = Message(f'{user_in_db.login} has joined the chat.', datetime.now(), chat_id=chat_.id, author_id=0, author_login='******') # notify all members about new user joining for member in chat_.members: user_joined_message.seen_users_ids += str(member.id) + ' ' if str(chat_id) in member.notifications_chats_ids: EmailManager.send_message( to=member.email, message=f"Subject: Chat event notification\n\n" f"Chat {chat_.name} has a new member!\n" f"Go log in and say hi!") chat_.members.append(user_in_db) chat_.messages.append(user_joined_message) db.session.commit() flash(f'You have joined chat {chat_.name}.', category='success') return redirect(url_for('home'))
def mock_sequence_diagram(self, has_fragment, has_multiple_fragments): sequence_diagram = SequenceDiagram(name='SequenceDiagram', guard_condition=True) # LifeLines lifelines = {0 : Lifeline(id=0, name='LifeLineX')} sequence_diagram.set_life_lines(lifelines) # Message message = Message(name='MensagemX', source=lifelines[0], target=lifelines[0], prob=0.5, message_type='Synchronous') sequence_diagram.set_messages(message) if has_fragment: fragment = Fragment(name='Fragment1', represented_by=sequence_diagram.name, sequence_diagram=sequence_diagram) sequence_diagram.set_fragments(fragment) if has_multiple_fragments: fragment = Fragment(name='Fragment2', represented_by=sequence_diagram.name, sequence_diagram=self.mock_sequence_diagram(False, False)) sequence_diagram.set_fragments(fragment) if has_fragment: sequence_diagram.get_fragments()[0].sequence_diagram = sequence_diagram return sequence_diagram
def post(self): user = users.get_current_user() t_user = User.query(User.email == user.email()).get() email = user.email() userid = user.user_id() user_name = t_user.name user_handle = t_user.handle date = datetime.now().strftime("%d-%m-%Y at %H:%M:%S") text = self.request.get("text") delete = self.request.get("delete") if delete: message = Message.get_by_id(int(delete)) message.deleted = True message.put() if text: message = Message(user_name=user_name, email=email, text=text, date=date, userid=userid, user_handle=user_handle) message.put() return self.redirect_to("home")
def filter_messages(messages, timezone): try: filtered_messages = [] for msg in messages: # skip message if it's a user or it's a bot if msg.author.bot == True: continue # skip message if has no reactions if len(msg.reactions) == 0: continue for emote in msg.reactions: if hasattr(emote.emoji, 'name'): emote_name = emote.emoji.name.lower() else: emote_name = emote.emoji filtered_messages.append( Message(msg.id, emote_name, emote.count, msg.guild.id, msg.channel.id, datetime.now(timezone))) except: log.exception( "Exception occured when filtering messages at filter_messages") return filtered_messages
async def parse_chat_message(conn: Connection, room: Optional[Room], user: User, message: str) -> None: """Parses potential bot commands to their respective callback. Args: conn (Connection): Used to access the websocket. room (Optional[Room]): Command room if it isn't a PM. Defaults to None. user (User): User that requested the command. message (str): Command argument. """ if message[:len(conn.command_character)] == conn.command_character: command = message.split(" ")[0][len(conn.command_character):].lower() if command in conn.commands: message = message[(len(conn.command_character) + len(command) + 1):].strip() msg = Message(room, user, message) await conn.commands[command].callback(msg) elif room is None: await user.send("Invalid command") elif room is None: c = f"``{conn.command_character}help``" message = f"I'm a bot: type {c} to get a list of available commands. " message += ( f"Sono un bot: scrivi {c} per ottenere un elenco dei comandi disponibili." ) await user.send(message)
def test_device_not_found(self): response = self.client.get('/ping', headers={ 'Firmware-Version': '1', 'Device-ID': 'ABC' }) self.assert404(response) device = Device(device_id='ABC', receiver_id='CBA').save() response = self.client.get('/ping', headers={ 'Firmware-Version': '1', 'Device-ID': device.device_id }) self.assert200(response) try: data = json.loads(response.data) self.assertFalse('message' in data) except ValueError: self.assertTrue(False, "The ping request didn't return json") device.messages = [Message(message='This is a test')] device.save() response = self.client.get('/ping', headers={ 'Firmware-Version': '1', 'Device-ID': device.device_id }) self.assert200(response) try: data = json.loads(response.data) self.assertEqual(data['message'], 'This is a test') except ValueError: self.assertTrue(False, "The ping request didn't return json")
def add_message_reaction(message_id, emoji, guild_id, channel_id, updated_date, created_date): try: if created_date.year != updated_date.year or created_date.month != updated_date.month: return s = session() message = s.query(Message).filter_by( message_id=message_id, emoji=emoji, guild_id=guild_id, channel_id=channel_id).filter( extract('year', Message.updated_date) == updated_date.year, extract('month', Message.updated_date) == updated_date.month).first() if message is not None: # Update emoji count message.emoji_count += 1 message.updated_date = updated_date s.commit() return # create new record in message table message = Message(message_id, emoji, 1, guild_id, channel_id, updated_date) s.add(message) s.commit() except: log.exception("Exception occured when adding message at add_message")
def send_message(chat_id): user_in_db = User.query.filter_by(id=session['user_id']).first() chat_ = Chat.query.filter_by(id=chat_id).first() message_text = request.form['message'] message_date = datetime.now() author_id = user_in_db.id author_login = user_in_db.login new_message = Message(message_text, message_date, chat_id, author_id, author_login) for member in chat_.members: if member.id != user_in_db.id: new_message.seen_users_ids += str(member.id) + ' ' if str(chat_.id) in member.notifications_chats_ids: EmailManager.send_message( to=member.email, message=f'Subject: New message notification\n\n' f'You have a new message in chat {chat_.name}.\n' f'Log in and chat!') chat_.messages.append(new_message) db.session.commit() return redirect(url_for('chat', chat_id=chat_id))
def post(self, token): '''Create a new message''' parser = reqparse.RequestParser() parser.add_argument('content', type=str, location='json', required=True, help='Content is a required field.') args = parser.parse_args() #Validate content if len(args.content) == 0: raise bad_request('Message cannot be empty') #Create a new instance of Content and attempt to add it to db print token message = Message(content=args.content, user_id=token['id']) try: session.add(message) session.commit() except IntegrityError, exc: print exc.message session.rollback() raise bad_request('Cannot create message')
def leave_chat(chat_id): chat_ = Chat.query.filter_by(id=chat_id).first() user_in_db = User.query.filter_by(id=session['user_id']).first() chat_.members.pop(chat_.members.index(user_in_db)) if chat_.members: flash(f'You have left the chat {chat_.name}.', category='success') user_left_message = Message(f'{user_in_db.login} has left the chat.', datetime.now(), chat_.id, author_id=0, author_login='******') for member in chat_.members: user_left_message.seen_users_ids += str(member.id) + ' ' if str(chat_.id) in member.notifications_chats_ids: EmailManager.send_message( to=member.email, message=f"Subject: Chat event notification\n\n" f"Someone has left chat {chat_.name}.\n" f"Go log in and see what happened!") chat_.messages.append(user_left_message) else: for message in chat_.messages: db.session.delete(message) flash(f'No members in chat {chat_.name}. Chat has been deleted.', category='info') db.session.delete(chat_) db.session.commit() return redirect(url_for('home'))
def create(id): auth_header = request.headers.get('Authorization') if auth_header: auth_token = auth_header.split(" ")[1] else: responseObject = { 'status': 'failed', 'message': 'No authorization header found.' } return make_response(jsonify(responseObject)), 401 user_id = User.decode_auth_token(auth_token) sender = User.get(User.id == user_id) # find the current user(sender) receiver = User.get(User.id == id) # find the current user(receiver) if sender and receiver : post_data = request.get_json() message = Message(sender=sender.id,receiver=receiver.id,message=post_data['message']) if message.save(): responseObject = { 'status': 'success', 'message': 'Record successfully saved.' } return make_response(jsonify(responseObject)), 201 else: responseObject = { 'status': 'failed', 'message': 'Something happened,try again later.' } return make_response(jsonify(responseObject)), 400 else: responseObject = { 'status': 'failed', 'message': 'Authentication failed' } return make_response(jsonify(responseObject)), 401
def create_message(current_user: User): """ Writes a new message to the DB Args: current_user: logged in user Returns: JSON (message or error) """ data = request.get_json(force=True) try: # Check if receiver exist in DB receiver = User.query \ .filter_by(username=data['receiver']) \ .first_or_404(description="No receiver with that name") # Create new message new_message = Message(sender=current_user.username, receiver=data['receiver'], message=data['message'], subject=data['subject']) # Insert to DB db.session.add(new_message) db.session.commit() return message_schema.dump(new_message) except KeyError as e: return jsonify({'error': 'Missing values in request'}), 400
def create_message(): from models.message import Message from models.user import User incoming_json = request.get_json(force=True) if incoming_json is None: return abort(404) username = incoming_json.get("username") user = User.query.filter_by(username=username).first() if user is None: user = User(username) db.session.add(user) db.session.commit() # Create the Model m = Message(user.id, incoming_json.get("input", "")) # save it to the database db.session.add(m) db.session.commit() response = {"result": "ok"} return jsonify(response)
def _queue_message(self, sender, body, request): # Find any existing messages and merge... messages = list(Message.Query.filter(sender=sender.objectId)) if messages: message = messages[0] message.body += '\n--\n' + body message.save() message_sending.send_received_message(sender.phone) return "" # Otherwise, add a new palships = list(Palship.Query.filter(lhs=sender.objectId)) if palships: recipient = User.Query.get(objectId=palships[0].rhs) else: palships = list(Palship.Query.filter(rhs=sender)) if not palships: return None recipient = User.Query.get(objectId=palships[0].lhs) message = Message( body=body, sender=sender.objectId, recipient=recipient.objectId ) message.save() message_sending.send_received_message(sender.phone) return ""
def extract_message_object(telegram_message): return Message(message_id=telegram_message.message_id, text=telegram_message.text, date=telegram_message.date, chat_id=telegram_message.chat.id, author_id=telegram_message['from'].id, reply_message_id=telegram_message.reply_to_message if hasattr(telegram_message, 'reply_to_message') else "")
def convertFetchedToMessage(self, tweet: {}) -> Message: likes = tweet.get('public_metrics', {}).get('like_count') created_date_time = parser.parse(tweet['created_at']) # TODO: Look up how to get comments num on Twitter message = Message(tweet['id'], tweet['text'], tweet["author_id"], created_date_time, "Twitter", None, likes) return message
def post_message(): message = Message() message.user_id = current_user.id message.content = request.form['content'] message.posted = int(datetime.now().strftime("%s")) * 1000 db.session.add(message) db.session.commit() return jsonify(), 200