def create_message(data):
receiver = data['receiver']
body = data['body']
message = Message(receiver=receiver, body=body)
message.save()
return message
def send_message(*, account: Account, id: int, type: str, content: str):
def get_account_name():
if account.account_type == 'user':
u = get_user_account(account)
return u.firstname + ' ' + u.lastname
else:
c = get_company_account(account)
return c.name
receiver = get_account_with_id(id=id)
if receiver is None:
return False
check_message_type(type)
m = Message(
sender=account,
receiver=receiver,
type=type,
content=content,
published_date=int(time.time()),
)
m.save()
device = FCMDevice.objects.filter(user=receiver)
for d in device:
response = d.send_message(title=get_account_name() +
' sent you a message',
body=m.content,
sound=True)
# print(response)
return True
def test_returns_expected_joined_group(self, group_mock):
clue = Clue(text='clue text')
group = Mock(uid='code', clue_uid='MYSTORY:MYCLUE', clue=clue)
group_mock.get_by_id.return_value = group
user = User()
result = perform_action(JOIN_GROUP, Message(text='join code'), user, None)
self.assertEqual([JOINED_GROUP.text, 'clue text'], [m.text for m in result.messages])
def test_returns_expected_end_of_story(self):
clue = Clue(text='blah', answer_uids=[])
group_mock = Mock(clue=clue)
group_mock.story.end_message = "END"
user = Mock()
result = perform_action(ANSWER, Message(text='asdf'), user, group_mock)
self.assertEqual([group_mock.story.end_message], [m.text for m in result.messages])
def test_gives_hints_if_incorrect(self):
answers = [Answer(pattern=r'tough answer', next_clue='SOME:NEXTCLUE')]
user = MagicMock()
message = Message(text='this is not the correct answer')
group_mock = Mock(clue=Mock(is_endpoint=False, hint='My Hint', answers=answers))
result = answer(message, user, group_mock)
self.assertEqual(['My Hint'], [r.text for r in result.messages])
def searchMessage(terms):
q = Q.PriorityQueue()
messages = SlackMessage.query.all()
terms = strip_terms(terms)
'''
Create a new Message object here to put in the queue
because at the moment, it's easier to just create an object with the property
`score`, rather than injecting score into SlackMessage model
'''
for message in messages:
msg = Message(id=message.id,
url=message.url,
description=message.description,
message_text=message.message_text,
score=0,
tags=message.tags,
author=message.author,
annotator=message.annotator)
text = msg.description.lower() + " " + msg.message_text.lower(
) + " " + msg.annotator.lower()
tags = set()
for tag in msg.tags:
tags.add(tag)
for term in terms:
if term in text:
msg.setScore(msg.getScore() + 1)
for tag in tags:
if term in tag or tag in term:
msg.setScore(msg.getScore() + 5)
if msg.getScore() > 0:
q.put(msg)
app.logger.info(q)
return q
def home_page():
db = Database()
form = AddMessageForm()
answerForm = AddAnswerForm()
if form.validate_on_submit():
title = form.data['title']
text = form.data['text']
message = Message(title, text)
message.username = current_user.username
db.add_message(message)
flash('message added')
return redirect(url_for('site.home_page'))
if answerForm.validate_on_submit():
text = answerForm.data['text']
messageId = answerForm.data['messageID']
db.add_message_answer(
MessageAnswer(text, 0, current_user.username, messageId))
flash('answer added')
return redirect(url_for('site.home_page'))
messages = db.get_messages()
messageAnswer = db.get_message_answers()
return render_template('home.html',
answers=messageAnswer,
answerForm=answerForm,
form=form,
messages=messages)
def test_returns_expected_restarted(self):
start_message = 'Start the story'
clue = Clue(text=start_message)
user = Mock()
group_mock = Mock(clue_uid='something', clue=clue)
result = perform_action(RESTART, Message(text='restart'), user, group_mock)
self.assertEqual([RESTARTED.text, start_message], [m.text for m in result.messages])
def searchMessageByTags(terms, tags):
q = Q.PriorityQueue()
db_messages = SlackMessage.query.all()
messages = []
# Iterate through each message in the database
for msg in db_messages:
# Create a Message object
message = Message(id=msg.id,
url=msg.url,
description=msg.description,
message_text=msg.message_text,
score=0,
tags=msg.tags,
author=msg.author,
annotator=msg.annotator)
# Check if the Message object has any tag that's in the query tags
for tag in message.tags:
# If so add the message into the messages list
if tag in tags:
messages.append(message)
break
# Now iterate through the list of messages that have relevant tag
# and score them based on the terms in its description
for message in messages:
text = message.description.lower() + " " + message.message_text.lower(
) + " " + message.annotator.lower()
for term in terms:
if term in text:
message.setScore(message.getScore() + 1)
if message.getScore() > 0:
q.put(message)
return q
def send_message(data):
bro_id = data["bro_id"]
bros_bro_id = data["bros_bro_id"]
message = data["message"]
text_message = data["text_message"]
message_data = None
if "message_data" in data:
message_data = data["message_data"]
own_chat = BroBros.query.filter_by(bro_id=bro_id, bros_bro_id=bros_bro_id).first()
other_bro_chat = BroBros.query.filter_by(bro_id=bros_bro_id, bros_bro_id=bro_id).first()
# We assume this won't happen
if own_chat is None:
return None
bro_message = Message(
sender_id=bro_id,
recipient_id=bros_bro_id,
body=message,
text_message=text_message,
timestamp=datetime.utcnow(),
info=False,
data=message_data
)
if other_bro_chat is not None and not other_bro_chat.is_blocked():
send_notification(data)
# The other bro now gets an extra unread message
if not other_bro_chat.is_removed() and not other_bro_chat.is_blocked():
other_bro_chat.update_unread_messages()
other_bro_chat.update_last_activity()
other_bro_chat.check_mute()
db.session.add(other_bro_chat)
# We only have to update the other bro's chat.
room_bro_2 = "room_%s" % bros_bro_id
emit("message_event_chat_changed", other_bro_chat.serialize, room=room_bro_2)
# We update the activity on our own chat object as well
own_chat.update_last_activity()
# We send the message so we've obviously read it as well.
# own_chat.update_last_message_read_time_bro()
own_chat.check_mute()
db.session.add(own_chat)
db.session.add(bro_message)
db.session.commit()
# We do it after saving so the message will have it's id.
if other_bro_chat is not None and not other_bro_chat.is_blocked():
room = get_a_room_you_two(bro_id, bros_bro_id)
emit("message_event_send", bro_message.serialize, room=room)
else:
# If the user is blocked or reported we don't want to send an update to the other bro.
own_room = "room_%s" % bro_id
emit("message_event_send", bro_message.serialize, room=own_room)
def __send_text(cls, content: dict) -> Message:
"""
Business method to send a text message.
"""
SendTextMessageQueryValidation.validate(content)
new_message = Message()
new_message.text = content[cls.TEXT]
return new_message
def insert_message(user_id, room_id, content, type):
message = Message(user_id=user_id,
room_id=room_id,
content=content,
type=type)
session.add(message)
session.commit()
def __send_video(cls, content: dict) -> Message:
"""
Business method to send a video message.
"""
SendVideoMessageQueryValidation.validate(content)
new_message = Message()
new_message.url = content[cls.URL]
new_message.source = content[cls.SOURCE]
return new_message
def create_message():
payload = request.get_json()
new_message = Message(channel_type=payload.get('channelType', None),
message_template=payload.get('message', None),
group_id=payload.get('groupId', None),
company_id=payload.get('companyId', None))
#TODO: Add validation of request before hitting the database
created_message = Message.add(db.session, new_message)
return jsonify(created_message.serialize)
def test_returns_expected_starting_new_story(self, story_code_mock, clue_mock, group_mock):
story_code_mock.build_key.return_value.get.return_value = StoryCode(story_uid="STORY")
clue_mock.get_by_id.return_value = Clue(text='test')
clue = Clue(text='test')
group_mock.return_value.current_clue = clue
group_mock.gen_uid.return_value = 'abcd'
user = User()
result = perform_action(START_STORY, Message(text='start blah'), user, None)
expected_message_text = [INTRO_INSTRUCTIONS.text, clue.text]
self.assertEqual(expected_message_text, [m.text for m in result.messages])
def __send_image(cls, content: dict) -> Message:
"""
Business method to send an imagem message.
"""
SendImageMessageQueryValidation.validate(content)
new_message = Message()
new_message.url = content[cls.URL]
new_message.width = content[cls.WIDTH]
new_message.height = content[cls.HEIGHT]
return new_message
def on_message(self, message_entity):
mac.receive_message(self, message_entity)
message = Message(message_entity)
if message.valid:
signals.message_received.send(message)
if helper.is_command(message.message):
signals.command_received.send(message)
mac.disconnect(self)
def get_message(self, messageId):
with dbapi2.connect(current_app.config['dsn']) as connection:
cursor = connection.cursor()
query = "SELECT * FROM MESSAGES WHERE ID = %s"
cursor.execute(query, (messageId, ))
message = cursor.fetchall()
if message is not None and len(message) == 1:
return Message(message[0][1], message[0][2], message[0][0])
else:
return None
async def append_msg(websocket):
logger.info("WEBSOKET ACCEPT CONNECTION")
await websocket.accept()
msg_txt = await websocket.receive_text()
msg_json = json.loads(msg_txt)
message = Message(**msg_json)
msg_list.add_msg(message)
await websocket.send_text(MESSAGE_REPLICATION_STATUS_OK)
await websocket.close()
logger.info("WEBSOKET CLOSED")
def addMessage():
form = request.json
if request.method == 'POST':
with db.auto_commit():
message = Message()
message.set_attrs(form)
db.session.add(message)
return jsonify({'code': 0, 'message': '留言成功'})
return jsonify({'code': 0, 'message': '操作不当'})
def test_answers_clue_properly(self):
answers = [
Answer(pattern=r'\w+\s+(?P<second_word>\w+)', next_clue='TWOWORDS'),
Answer(pattern=r'steve', next_clue="STEVE"),
Answer(pattern=r'.*', next_clue='CATCHALL'),
]
message = Message(text='test answer')
next_clue, answer_data = get_next_clue(message, answers)
self.assertEqual('TWOWORDS', next_clue)
self.assertEqual({'second_word': 'answer'}, answer_data)
def test_requires_matching_receiver(self):
answers = [
Answer(pattern=r'.*', next_clue='STORY:FIRSTCLUE', receiver=SECONDARY_SERVER_PHONE),
Answer(pattern=r'.*', next_clue='STORY:SECONDCLUE')
]
user = MagicMock()
message = Message(text='correct answer')
group_mock = Mock(clue=Mock(is_endpoint=False, hint='My Hint', answers=answers))
result = answer(message, user, group_mock)
self.assertEqual(CLUE, result.response_type)
self.assertEqual('STORY:SECONDCLUE', result.group.clue_uid)
def update_message():
payload = request.get_json()
updated_message = Message(message_id=payload.get('messageId', None),
channel_type=payload.get('channelType', None),
message_template=payload.get('message', None),
group_id=payload.get('groupId', None),
company_id=payload.get('companyId', None),
active=payload.get('active', True))
#TODO: Add validation of request before hitting the database
updated_message = Message.update(db.session, updated_message)
return jsonify(updated_message.serialize)
def test_requires_media(self):
answers = [
Answer(pattern=r'.*', next_clue='STORY:FIRSTCLUE', require_media=True),
Answer(pattern=r'.*', next_clue='STORY:SECONDCLUE')
]
user = MagicMock()
message_without_media = Message(text='correct answer')
group_mock = Mock(clue=Mock(is_endpoint=False, hint='My Hint', answers=answers))
result_without_media = answer(message_without_media, user, group_mock)
self.assertEqual('STORY:SECONDCLUE', result_without_media.group.clue_uid)
def test_matches_if_media_given(self):
answers = [
Answer(pattern=r'.*', next_clue='STORY:FIRSTCLUE', require_media=True),
Answer(pattern=r'.*', next_clue='STORY:SECONDCLUE')
]
user = MagicMock()
message_with_media = Message(text='correct answer', media_url='www.example.com/caturday.png')
group_mock = Mock(clue=Mock(is_endpoint=False, hint='My Hint', answers=answers))
result_with_media = answer(message_with_media, user, group_mock)
self.assertEqual('STORY:FIRSTCLUE', result_with_media.group.clue_uid)
def sendMessage(self):
message = self.messageBox.toPlainText()
if not message == '':
keys = self.api.getAllPublicKeys()
for key in keys:
m = Message(message, key["publicKey"])
me = m.getFinal(key["username"])
self.irc.sendMessage(me)
mess = '<span style="color:green; font-weight: bolder";>' + self.username + "</span>" + " : " + message
self.appendMessage(mess)
self.messageBox.clear()
def onTextMessage(self, messageProtocolEntity):
# just print info
print(" ->>>>>> TEXT MESSAGE RECEIVED!!!!!!")
# Make message
message = Message(messageProtocolEntity)
if message.valid:
signals.message_received.send(message)
if helper.is_command(message.message):
signals.command_received.send(message)
mac.disconnect(self)
def on_message(self, message_entity):
# Set received (double v) and add to ack queue
mac.receive_message(self, message_entity)
# Make message
message = Message(message_entity)
if message.valid:
signals.message_received.send(message)
if helper.is_command(message.message):
signals.command_received.send(message)
mac.disconnect(self)
def edit_message_page(message_id):
if current_user.is_admin:
form = AddMessageForm()
db = Database()
message = db.get_message(message_id)
if form.validate_on_submit():
message = Message(form.data['title'], form.data['text'])
message.id = message_id
db.edit_message(message)
flash('message edited')
return redirect(url_for('site.home_page'))
return render_template('message.html', form=form, message=message)
return redirect(url_for('site.home_page'))
def test_get_messages(self):
message_dates = [
'2015-12-12 12:12:12',
'2015-11-11 11:11:11',
'2016-01-01 01:01:01',
'2014-04-04 04:04:04',
'2015-11-11 12:12:12',
'2015-11-11 10:10:10',
]
# Create the messages
for date in message_dates:
message = Message(
receiver='pjot',
date_created=datetime.strptime(date, '%Y-%m-%d %H:%M:%S'),
body='Some random body',
)
message.save()
# Fetch them using API
response = self.get_json('/api/v1/messages')
assert response.status_code == 200
data = json.loads(response.data)
messages = data['messages']
assert len(messages) == len(message_dates)
# Check that they are sorted by date
sorted_messages = sorted(messages,
key=lambda message: message['date_created'],
reverse=True)
for m1, m2 in zip(messages, sorted_messages):
assert m1['id'] == m2['id']
# Fetch first 3
response = self.get_json('/api/v1/messages?limit=3')
assert response.status_code == 200
data = json.loads(response.data)
# Check that they are the first ones
for i, message in enumerate(data['messages']):
assert message['id'] == sorted_messages[i]['id']
# Fetch next 3
response = self.get_json('/api/v1/messages?limit=3&offset=3')
assert response.status_code == 200
data = json.loads(response.data)
# Check that they are the next ones
for i, message in enumerate(data['messages']):
assert message['id'] == sorted_messages[i + 3]['id']
