def messages():
if not session.get("logged_in"):
return login()
conversation = Conversation.get_by_id(int(request.form["conversation"]))
conversation.put()
recipient = conversation.user1
if session["user_id"] == recipient:
recipient = conversation.user2
print "popopo"
notification = Notification(user=conversation.user1,
body="New Message",
ntype="new-message",
item=conversation.item,
item_category="",
noticed=False,
link="/view_conversations/" +
str(conversation.key.id()))
notification.put()
print "pop-" + notification.body + "-pop"
message = Message(sender=session["user_id"],
recipient=recipient,
body=request.form["message_body"],
conversation=conversation.key.id())
message.put()
return "success"
def update(chat_id=None, offset=None):
if offset is None:
url = "https://api.telegram.org/bot" + bot_token + "/getUpdates"
else:
url = "https://api.telegram.org/bot" + bot_token + "/getUpdates?offset=" + str(offset)
response = requests.get(url)
if not response.text.startswith('{"ok":true'):
return False
json_obj = json.loads(response.text)['result']
to_return = []
for result in json_obj:
current = None
if 'message' in result:
current = Message(json_obj=result['message'])
if 'edited_message' in result:
current = Message(json_obj=result['edited_message'])
if current is not None and filter_message(current, chat_id):
to_return.append(current)
if len(json_obj):
return int(json_obj[-1]['update_id']) + 1, to_return
else:
return offset, to_return
def load_by_sender(self, sender, recipient, msgType):
if msgType == 'ALL':
msg_query = Message.query(ndb.OR(
Message.sender == recipient,
Message.recipient == recipient
))
elif msgType == 'ALL_CONTACT':
msg_query = Message.query(ndb.AND(
ndb.OR(
Message.sender == sender,
Message.sender == recipient
),
ndb.OR(
Message.recipient == sender,
Message.recipient == recipient
)
))
elif msgType == 'UNREAD':
msg_query = Message.query(ndb.AND(
ndb.OR(
Message.sender == recipient,
Message.recipient == recipient
),
Message.readed == None
))
elif msgType == 'UNREAD_CONTACT':
msg_query = Message.query(ndb.AND(
ndb.OR(
Message.sender == sender,
Message.sender == recipient
),
ndb.OR(
Message.recipient == sender,
Message.recipient == recipient
),
Message.readed == None
))
messages = msg_query.fetch()
msg_result = []
for msg in messages:
# Mark message as readed!
msg.readed = datetime.today()
msg.put()
# Save message in memcache
key = str(msg.key.integer_id())
msg_json = self.get_message_as_json(msg)
memcache.set(key,msg_json,namespace='app.arcanum.backend.messages')
# Add message to result
msg_result.append(msg_json)
return msg_result
def process_message(self, message: Message) -> None:
logger.debug("New %s", message)
if message.forward_from_chat:
if self.process_forward_message(message):
return
elif message.command:
if self.process_command_message(message):
return
elif tags := message.get_tags():
if self.process_tags(message, tags):
return
def execute(self):
sender = self.msg.sender
messenger = Messenger.get_instance(sender.messenger)
if len(self.msg.cmd.args) == 0:
messenger.send(sender.id,
Message('MESSAGE.WRONG_ARGS').localize(sender.lang),
keyboards.ConnectKeyboard(sender))
return
sender.lang = self.msg.cmd.args[0]
Storage().update(sender.key, {'lang': sender.lang})
messenger.send(sender.id,
Message('MESSAGE.LANG_CHANGED').localize(sender.lang),
keyboards.ConnectKeyboard(sender))
def execute(self):
sender = self.msg.sender
for connected in sender.connections:
Storage().update(connected.key, {'receiver': None})
messenger_to = Messenger.get_instance(connected.messenger)
messenger_to.send(
connected.id,
Message('MESSAGE.FRIEND_OFF').localize(connected.lang),
keyboards.StartKeyboard(connected))
Storage().delete(sender.key)
messenger = Messenger.get_instance(sender.messenger)
messenger.send(
sender.id,
Message('MESSAGE.BYE').localize(sender.lang,
messenger=sender.messenger),
keyboards.StartKeyboard(sender))
def process_update(self, update: dict) -> None:
logger.debug("Processing new update: %s", update)
if "message" in update:
message = Message.from_json(update["message"])
self.process_message(message)
elif "callback_query" in update:
callback = CallbackQuery.from_json(update["callback_query"])
self.process_callback(callback)
def on_message(self, message):
entity = Message.from_dict(json.loads(message))
self.application.db.messages.insert_one(entity.__dict__)
conn = ToRedisClient()
conn.connect(host="redis")
def publish_message(channel,message):
conn.publish(channel,message)
self.io_loop.add_timeout(time.time(), partial(publish_message,self.channel,format_entity(entity.__dict__)))
def execute(self):
sender = self.msg.sender
messenger_from = Messenger.get_instance(sender.messenger)
if sender.receiver is not None:
receiver = Storage().get_user(sender.receiver)
Storage().update(sender.key, {'receiver': None})
Storage().update(receiver.key, {'receiver': None})
messenger_to = Messenger.get_instance(receiver.messenger)
messenger_to.send(
receiver.id,
Message('MESSAGE.FRIEND_OFF').localize(receiver.lang),
keyboards.ConnectKeyboard(receiver))
messenger_from.send(sender.id,
Message('MESSAGE.OFF').localize(sender.lang),
keyboards.ConnectKeyboard(sender))
else:
messenger_from.send(
sender.id,
Message('MESSAGE.OFF_BLANK').localize(sender.lang),
keyboards.ConnectKeyboard(sender))
def send(self, chat, text, reply_to=None, keyboard=None):
params = {
'chat_id': chat.id,
'text': text,
}
if reply_to is not None:
params.update({'reply_to_message_id': reply_to.message_id})
if keyboard is not None:
params.update({'reply_markup': keyboard.as_dict()})
message = self.request('sendMessage', params=params)
if message is not None:
return Message(**message)
def execute(self):
sender = self.msg.sender
messenger = Messenger.get_instance(sender.messenger)
if len(self.msg.cmd.args) == 0:
messenger.send(sender.id,
Message('MESSAGE.WRONG_ARGS').localize(sender.lang),
keyboards.ConnectKeyboard(sender))
return
keyboard = self.msg.cmd.args[0]
try:
messenger.send(
sender.id,
Message(f'KEYBOARD.{keyboard.upper()}').localize(sender.lang),
getattr(keyboards, f'{keyboard.capitalize()}Keyboard')(sender))
except KeyError:
messenger.send(sender.id,
Message('MESSAGE.WRONG_ARGS').localize(sender.lang),
keyboards.ConnectKeyboard(sender))
def view_conversation(conversation_id):
if not session.get("logged_in"):
return login()
conversation_id = int(conversation_id)
conversation = Conversation.get_by_id(conversation_id)
messages = Message.query(Message.conversation == conversation_id).order(
Message.time)
notifications = Notification.query(
Notification.user == session["user_id"]).order(-Notification.time)
return render_template("view_conversation.html",
messages=messages,
conversation=conversation,
notifications=notifications)
def delete_item(item_id):
if not session.get("logged_in"):
return login()
item_id = int(item_id)
item = Item.get_by_id(item_id)
if item.seller_id != session["user_id"]:
return "oops", 500
previous_notifications = Notification.query(Notification.item == item_id)
notification_body = item.name + " removed"
for prev_not in previous_notifications:
notification = Notification(user=prev_not.user,
body=notification_body,
ntype="item-removed",
item=item.key.id(),
item_category=item.category,
noticed=False,
link="/browse/" + item.category)
notification.put()
prev_not.key.delete()
offers = Offer.query(Offer.item == item.key.id())
conversation = Conversation.query(Conversation.item == item_id).get()
if conversation:
messages = Message.query(Message.conversation == conversation.key.id())
for message in messages:
message.key.delete()
conversation.key.delete()
for offer in offers:
offer.key.delete()
item_tags = Item_Tag.query(Item_Tag.item == item.key.id())
for item_tag in item_tags:
item_tag.key.delete()
item.key.delete()
return "success"
def execute(self):
sender = self.msg.sender
messenger_from = Messenger.get_instance(sender.messenger)
if len(self.msg.cmd.args) < 2:
messenger_from.send(
sender.id,
Message('MESSAGE.WRONG_ARGS').localize(sender.lang),
keyboards.ConnectKeyboard(sender)
)
return
messenger, id_ = self.msg.cmd.args
receiver = Storage().find_user(messenger, id_)
if receiver is None:
messenger_from.send(
sender.id,
Message('MESSAGE.INVALID_USER').localize(sender.lang),
keyboards.ConnectKeyboard(sender)
)
return
Storage().update(sender.key, {'receiver': receiver.key})
messenger_to = Messenger.get_instance(receiver.messenger)
if receiver.receiver == sender.key:
message_to_sender = Message('MESSAGE.CONNECTED').localize(sender.lang, name=receiver.name)
message_to_receiver = Message('MESSAGE.CONNECTED').localize(receiver.lang, name=sender.name)
else:
message_to_sender = Message('MESSAGE.CONN_WAIT').localize(
sender.lang,
name=receiver.name,
messenger=receiver.messenger
)
message_to_receiver = Message('MESSAGE.CONN_NOTIFICATION').localize(
receiver.lang,
name=sender.name,
messenger=sender.messenger,
id=sender.nick or sender.phone or sender.id
)
messenger_from.send(
sender.id,
message_to_sender,
keyboards.ConnectKeyboard(sender)
)
messenger_to.send(
receiver.id,
message_to_receiver,
keyboards.ConnectKeyboard(receiver)
)
def parse(data):
if 'message' in data or 'callback_query' in data:
msg = data.get('message') or data.get('callback_query')
name = msg['from']['first_name']
if 'last_name' in msg['from']:
name += f" {msg['from']['last_name']}"
user = User(id=msg['from']['id'],
name=name,
messenger='telegram',
nick=msg['from'].get('username'),
lang=msg['from'].get('language_code'))
return Message(sender=user,
text=msg.get('text', ''),
cmd=Telegram.parse_cmd(msg),
attachments=[])
else:
return None
def post(self):
eid = self.request.get('id', default_value='')
self.response.write('<h1>'+eid+'</h1>')
key = self.request.get('key', default_value='')
if eid is not None and eid != '':
msg = Message.get_by_id(int(eid))
elif key is not None and key != '':
msg = ndb.Key(urlsafe=key).get()
else:
self.err('Neither id or key is passed!\n')
return
if msg is None:
self.err('Loading message failed!\n')
return
# Send to phone notification!
usr = User()
usr.hash = msg.recipient
usr = usr.loadme()
if usr is None:
self.err('User-Recipient not found!');
return
data = {'type': 'message', 'sender': msg.sender}
notfication = GCM('AIzaSyD-z2JuoBkD51RyRHG6ULoWX2gE84apP7M')
response = notfication.json_request(registration_ids=usr.registration_ids,
data=data,
collapse_key=None,
delay_while_idle=False,
time_to_live=None,
retries=5)
self.response.headers['Content-Type'] = 'application/json; charset=utf-8'
self.debug(response)
# Mark message as pushed.
msg.pushed = datetime.now()
msg.put()
def post(self):
msg = self.request.body
self.response.headers['Content-Type'] = 'text/html; charset=utf-8'
self.response.write('<p>Message posted:</p>\n')
self.response.write('<p>' + escape(msg) + '</p>\n')
raw = RawMessage()
raw.content = base64.standard_b64decode(msg)
raw.put()
self.response.write('<p>Saved raw message in datastore.</p>\n')
msg_version = unpack(">I", raw.content[0:4])[0]
self.response.write('<p>Message version is ' + str(msg_version) + '</p>\n')
if msg_version == 1:
message = Message()
#message.raw_key = raw.key
message.version = msg_version
message.sender = base64.standard_b64encode(raw.content[4:4+32])
message.recipient = base64.standard_b64encode(raw.content[36:36+32])
#message.iv = raw.content[68:68+16]
#message.secretkey = raw.content[84:84+32]
#message.content_length = raw.content[116:116+4]
message.content = raw.content
#message.contentType = 'TEXT'
message.created = datetime.today()
msg_key = message.put()
self.response.write('<p>Datastore key: ' + str(msg_key) + '</p>\n')
self.response.write('<p>Datastore key_urlsafe: ' + str(msg_key.urlsafe()) + '</p>\n')
self.response.write('<p>Datastore key_integer: ' + str(msg_key.integer_id()) + '</p>\n')
taskqueue.add(queue_name='notifications',
url='/task/msg',
params={
'key':msg_key.urlsafe(),
'id':msg_key.integer_id()
})
else:
self.error(404)
def parse(data):
data_type = data['type']
if data_type == 'message_new':
msg = data['object']['message']
client_info = data['object']['client_info']
name, nick = Vk._get_info(msg['from_id'])
user = User(id=msg['from_id'],
name=name,
messenger='vk',
nick=nick,
lang=Vk._get_lang(client_info['lang_id']))
return Message(
sender=user,
text=msg['text'],
cmd=Vk.parse_cmd(msg),
attachments=[] # TODO attachments
)
elif data_type == 'confirmation' and str(
data.get('group_id')) == os.getenv('VK_GROUP'):
abort(Response(os.getenv('VK_CONFIRMATION')))
else:
return None
def parse(data) -> Message:
user = User(id=123,
nick='nick',
name='Name Surname',
messenger='discord')
return Message(sender=user, text=data['text'], attachments=[])
def on_message(self, message):
entity = Message.from_dict(json.loads(message))
self.application.db.messages.insert_one(entity.__dict__)
self.application.manager.notify(entity.channel,format_entity(entity.__dict__))
def test_msg_header(self):
self.assertEqual(str(Message(123, 456)), "Message---123---456---",
"wrong message header")
def execute(self):
sender = self.msg.sender
messenger = Messenger.get_instance(sender.messenger)
messenger.send(sender.id,
Message('MESSAGE.FULL_HELP').localize(sender.lang),
keyboards.ConnectKeyboard(sender))
def main(messenger):
messenger_from = Messenger.get_instance(messenger)
if messenger_from is None:
abort(404)
return
logger.info('Parsing the message')
msg: Optional[Message] = messenger_from.parse(request.json)
if msg is None:
logger.info('Not new message')
return 'ok'
logger.info('Message was parsed successfully')
if not msg.sender.registered:
logger.info('Registering user')
msg.sender.key = Storage().add_user(msg.sender)
logger.info('Sending welcome message')
messenger_from.send(
msg.sender.id,
Message('MESSAGE.REGISTER').localize(msg.sender.lang),
keyboards.ConnectKeyboard(msg.sender)
)
if msg.cmd is None:
return 'ok'
if msg.cmd is not None:
logger.info('Command detected')
cmd_class = commands.get_class(msg.cmd.name)
logger.info('Executing command')
cmd_class(msg).execute()
return 'ok'
if msg.sender.receiver is None:
logger.info('No receiver')
messenger_from.send(
msg.sender.id,
Message('MESSAGE.NO_RECIPIENT').localize(msg.sender.lang),
keyboards.ConnectKeyboard(msg.sender)
)
return 'ok'
logger.info('Getting receiver')
receiver = Storage().get_user(msg.sender.receiver)
if receiver.receiver != msg.sender.key:
logger.info('Receiver does not confirm the connection')
messenger_from.send(
msg.sender.id,
Message('MESSAGE.CONN_WAIT').localize(msg.sender.lang,
name=receiver.name,
messenger=receiver.messenger),
keyboards.ConnectKeyboard(msg.sender)
)
return 'ok'
logger.info('Getting receiver messenger instance')
messenger_to = Messenger.get_instance(receiver.messenger)
logger.info('Forwarding')
messenger_to.send(
receiver.id,
Message('MESSAGE.TEMPLATE', msg.attachments).localize('', name=msg.sender.name, msg=msg.text),
keyboards.ConnectKeyboard(receiver)
)
return 'ok'
def __init__(self, msg: Message):
super().__init__(
Message(sender=msg.sender,
cmd=CommandInfo('chat', [msg.cmd.name, *msg.cmd.args])))
def execute(self):
sender = self.msg.sender
if sender.registered:
messenger_from = Messenger.get_instance(sender.messenger)
messenger_from.send(sender.id, Message('MESSAGE.UNDEFINED_CMD').localize(sender.lang))
