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
