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))