telematrix/app_service.py
Sijmen Schoon a6007a8902 Support Tg forwards and replies
Fixes #2 and #3.
2016-09-25 22:59:54 +02:00

290 lines
12 KiB
Python

import json
import requests
import threading
import aiotg
import asyncio
import logging
import mimetypes
import time
import html
import datetime
from urllib.parse import unquote, quote, urlparse, parse_qs
from aiohttp import web, ClientSession, MultipartWriter
from pprint import pprint
from bs4 import BeautifulSoup
try:
with open('config.json', 'r') as f:
config = json.load(f)
HS_TOKEN = config['tokens']['hs']
AS_TOKEN = config['tokens']['as']
TG_TOKEN = config['tokens']['telegram']
GOOGLE_TOKEN = config['tokens']['google']
MATRIX_HOST = config['hosts']['internal']
MATRIX_HOST_EXT = config['hosts']['external']
MATRIX_PREFIX = MATRIX_HOST + '_matrix/client/r0/'
MATRIX_MEDIA_PREFIX = MATRIX_HOST + '_matrix/media/r0/'
USER_ID_FORMAT = config['user_id_format']
telegram_chats = config['chats']
matrix_rooms = {v: k for k, v in telegram_chats.items()}
except (OSError, IOError) as e:
print('Error opening config file:')
print(e)
exit(1)
bot = aiotg.Bot(api_token=TG_TOKEN)
client_session = ClientSession()
def create_response(code, obj):
return web.Response(text=json.dumps(obj), status=code, content_type='application/json', charset='utf-8')
VALID_TAGS = ['b', 'strong', 'i', 'em', 'a', 'pre']
def sanitize_html(h):
h = h.replace('\n', '')
h = h.replace('<br>', '\n').replace('<br/>', '\n').replace('<br />', '\n')
soup = BeautifulSoup(h, 'html.parser')
for tag in soup.find_all(True):
if tag.name == 'blockquote':
tag.string = ('\n' + tag.text).replace('\n', '\n> ').rstrip('\n>')
if tag.name not in VALID_TAGS:
tag.hidden = True
return soup.renderContents().decode('utf-8')
async def matrix_transaction(request):
transaction = request.match_info['transaction']
body = await request.json()
events = body['events']
for event in events:
room_id = event['room_id']
if room_id not in matrix_rooms:
print('{} not in matrix_rooms!'.format(room_id))
elif event['type'] == 'm.room.message':
group = bot.group(matrix_rooms[room_id])
username = event['user_id'].split(':')[0][1:]
if username.startswith('telegram_'):
return create_response(200, {})
content = event['content']
if content['msgtype'] == 'm.text':
if 'formatted_body' in content:
await group.send_text('&lt;{}&gt; {}'.format(username, sanitize_html(content['formatted_body'])), parse_mode='HTML')
else:
await group.send_text('<{}> {}'.format(username, content['body']))
elif content['msgtype'] == 'm.notice':
if 'formatted_body' in content:
await group.send_text('[{}] {}'.format(username, sanitize_html(content['formatted_body'])), parse_mode='HTML')
else:
await group.send_text('[{}] {}'.format(username, content['body']))
elif content['msgtype'] == 'm.emote':
if 'formatted_body' in content:
await group.send_text('*** {} {}'.format(username, sanitize_html(content['formatted_body'])), parse_mode='HTML')
else:
await group.send_text('*** {} {}'.format(username, content['body']))
elif content['msgtype'] == 'm.image':
url = urlparse(content['url'])
async with client_session.get(MATRIX_MEDIA_PREFIX + 'download/{}{}'.format(url.netloc, url.path)) as response:
b = await response.read()
with open('/tmp/{}'.format(content['body']), 'wb') as f:
f.write(b)
with open('/tmp/{}'.format(content['body']), 'rb') as f:
url_str = MATRIX_HOST_EXT + '_matrix/media/r0/download/{}{}'.format(url.netloc, quote(url.path))
async with ClientSession() as shorten_session:
async with shorten_session.post('https://www.googleapis.com/urlshortener/v1/url',
params={'key': GOOGLE_TOKEN},
data=json.dumps({'longUrl': url_str}),
headers={'Content-Type': 'application/json'}) as response:
j = await response.json()
if 'id' in j:
url_str = j['id']
else:
print('Something went wrong while shortening:')
pprint(j)
caption = '<{}> {} ({})'.format(username, content['body'], url_str)
await group.send_photo(f, caption=caption)
else:
print(json.dumps(content, indent=4))
return create_response(200, {})
async def _matrix_request(method_fun, category, path, user_id, data=None, content_type=None):
if data is not None:
if isinstance(data, dict):
data = json.dumps(data)
content_type = 'application/json; charset=utf-8'
elif content_type is None:
content_type = 'application/octet-stream'
params = {'access_token': AS_TOKEN}
if user_id is not None:
params['user_id'] = user_id
async with method_fun('{}_matrix/{}/r0/{}'.format(MATRIX_HOST, quote(category), quote(path)),
params=params, data=data, headers={'Content-Type': content_type}) as response:
if response.headers['Content-Type'].split(';')[0] == 'application/json':
return await response.json()
else:
return await response.read()
def matrix_post(category, path, user_id, data, content_type=None):
return _matrix_request(client_session.post, category, path, user_id, data, content_type)
def matrix_put(category, path, user_id, data, content_type=None):
return _matrix_request(client_session.put, category, path, user_id, data, content_type)
def matrix_get(category, path, user_id):
return _matrix_request(client_session.get, category, path, user_id)
def matrix_delete(category, path, user_id):
return _matrix_request(client_session.delete, category, path, user_id)
async def matrix_room(request):
room_alias = request.match_info['room_alias']
args = parse_qs(urlparse(request.path_qs).query)
print('Checking for {} | {}'.format(unquote(room_alias), args['access_token'][0]))
try:
if args['access_token'][0] != HS_TOKEN:
return create_response(403, {'errcode': 'M_FORBIDDEN'})
except KeyError:
return create_response(401, {'errcode': 'NL.SIJMENSCHOON.TELEMATRIX_UNAUTHORIZED'})
localpart, host = room_alias.split(':')
chat = '_'.join(localpart.split('_')[1:])
if chat in telegram_chats:
await matrix_post('client', 'createRoom', None, {'room_alias_name': localpart[1:]})
return create_response(200, {})
else:
return create_response(404, {'errcode': 'NL.SIJMENSCHOON.TELEMATRIX_NOT_FOUND'})
def send_matrix_message(room_id, user_id, txn_id, **kwargs):
return matrix_put('client', 'rooms/{}/send/m.room.message/{}'.format(room_id, txn_id), user_id, kwargs)
async def upload_tgfile_to_matrix(file_id, user_id):
file_path = (await bot.get_file(file_id))['file_path']
request = await bot.download_file(file_path)
mimetype = request.headers['Content-Type']
data = await request.read()
j = await matrix_post('media', 'upload', user_id, data, mimetype)
if 'content_uri' in j:
return (j['content_uri'], mimetype, len(data))
else:
return None, None, 0
async def register_join_matrix(chat, room_id, user_id):
name = chat.sender['first_name']
if 'last_name' in chat.sender:
name += ' ' + chat.sender['last_name']
name += ' (Telegram)'
user = user_id.split(':')[0][1:]
await matrix_post('client', 'register', None, {'type': 'm.login.application_service', 'user': user})
profile_photos = await bot.get_user_profile_photos(chat.sender['id'])
try:
pp_file_id = profile_photos['result']['photos'][0][-1]['file_id']
pp_uri, _, _ = await upload_tgfile_to_matrix(pp_file_id, user_id)
if pp_uri:
await matrix_put('client', 'profile/{}/avatar_url'.format(user_id), user_id, {'avatar_url': pp_uri})
except IndexError:
pass
await matrix_put('client', 'profile/{}/displayname'.format(user_id), user_id, {'displayname': name})
await matrix_post('client', 'join/{}'.format(room_id), user_id, {})
@bot.handle('photo')
async def aiotg_photo(chat, photo):
try:
room_id = telegram_chats[str(chat.id)]
except KeyError:
print('Unknown telegram chat {}'.format(chat))
return
user_id = USER_ID_FORMAT.format(chat.sender['id'])
txn_id = quote('{}:{}'.format(chat.message['message_id'], chat.id))
file_id = photo[-1]['file_id']
uri, mime, length = await upload_tgfile_to_matrix(file_id, user_id)
info = {'mimetype': mime, 'size': length, 'h': photo[-1]['height'], 'w': photo[-1]['width']}
body = 'Image_{}{}'.format(int(time.time() * 1000), mimetypes.guess_extension(mime))
if uri:
j = await send_matrix_message(room_id, user_id, txn_id, body=body, url=uri, info=info, msgtype='m.image')
if 'errcode' in j and j['errcode'] == 'M_FORBIDDEN':
await register_join_matrix(chat, room_id, user_id)
await send_matrix_message(room_id, user_id, txn_id, body=body, url=uri, info=info, msgtype='m.image')
@bot.command(r'(?s)(.*)')
async def aiotg_message(chat, match):
try:
room_id = telegram_chats[str(chat.id)]
except KeyError:
print('Unknown telegram chat {}'.format(chat))
return
user_id = USER_ID_FORMAT.format(chat.sender['id'])
txn_id = quote('{}:{}'.format(chat.message['message_id'], chat.id))
message = match.group(0)
if 'forward_from' in chat.message:
fw_from = chat.message['forward_from']
if 'last_name' in fw_from:
msg_from = '{} {} (Telegram)'.format(fw_from['first_name'], fw_from['last_name'])
else:
msg_from = '{} (Telegram)'.format(fw_from['first_name'])
date = datetime.datetime.fromtimestamp(fw_from['date'])
quoted_msg = '\n'.join(['>{}'.format(x) for x in message.split('\n')])
quoted_msg = 'Forwarded from {}, said at {}:\n{}'.format(msg_from, date, quoted_msg)
quoted_html = '<blockquote>{}</blockquote>'.format(html.escape(message).replace('\n', '<br />'))
quoted_html = '<i>Forwarded from {}, said at {}:</i>\n{}'.format(html.escape(msg_from), html.escape(str(date)), quoted_html)
j = await send_matrix_message(room_id, user_id, txn_id, body=quoted_msg, formatted_body=quoted_html, format='org.matrix.custom.html', msgtype='m.text')
elif 'reply_to_message' in chat.message:
re_msg = chat.message['reply_to_message']
if 'last_name' in re_msg['from']:
msg_from = '{} {} (Telegram)'.format(re_msg['from']['first_name'], re_msg['from']['last_name'])
else:
msg_from = '{} (Telegram)'.format(re_msg['from']['first_name'])
date = datetime.datetime.fromtimestamp(re_msg['date'])
quoted_msg = '\n'.join(['>{}'.format(x) for x in re_msg['text'].split('\n')])
quoted_msg = 'Reply to {}, said at {}:\n{}\n\n{}'.format(msg_from, date, quoted_msg, message)
quoted_html = '<blockquote>{}</blockquote>'.format(html.escape(re_msg['text']).replace('\n', '<br />'))
quoted_html = '<i>Reply to {}, said at {}:</i><br />{}<p>{}</p>'.format(html.escape(msg_from), html.escape(str(date)), quoted_html, html.escape(message).replace('\n', '<br />'))
j = await send_matrix_message(room_id, user_id, txn_id, body=quoted_msg, formatted_body=quoted_html, format='org.matrix.custom.html', msgtype='m.text')
else:
j = await send_matrix_message(room_id, user_id, txn_id, body=message, msgtype='m.text')
if 'errcode' in j and j['errcode'] == 'M_FORBIDDEN':
await asyncio.sleep(1)
await register_join_matrix(chat, room_id, user_id)
await asyncio.sleep(1)
await send_matrix_message(room_id, user_id, txn_id, body=message, msgtype='m.text')
if __name__ == "__main__":
logging.basicConfig(level=logging.WARNING)
loop = asyncio.get_event_loop()
asyncio.ensure_future(bot.loop())
app = web.Application(loop=loop)
app.router.add_route('GET', '/rooms/{room_alias}', matrix_room)
app.router.add_route('PUT', '/transactions/{transaction}', matrix_transaction)
web.run_app(app, port=5000)