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 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 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 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 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 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):
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 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 __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))
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'
