283 lines
9.6 KiB
Python
283 lines
9.6 KiB
Python
import logging
|
|
|
|
from aiohttp import web
|
|
import aiohttp_jinja2
|
|
from jinja2 import Markup
|
|
from telethon.tl import types
|
|
from telethon.tl.custom import Message
|
|
|
|
from .util import get_file_name, get_human_size
|
|
from .config import chat_ids, alias_ids
|
|
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
class Views:
|
|
|
|
def __init__(self, client):
|
|
self.client = client
|
|
|
|
|
|
@aiohttp_jinja2.template('home.html')
|
|
async def home(self, req):
|
|
if len(chat_ids) == 1:
|
|
raise web.HTTPFound(f"{alias_ids[0]}")
|
|
chats = []
|
|
for chat_id, alias_id in zip(chat_ids, alias_ids):
|
|
chat = await self.client.get_entity(chat_id)
|
|
chats.append({
|
|
'id': alias_id,
|
|
'name': chat.title
|
|
})
|
|
return {'chats':chats}
|
|
|
|
|
|
@aiohttp_jinja2.template('index.html')
|
|
async def index(self, req):
|
|
alias_id = req.rel_url.path.split('/')[1]
|
|
chat_id = chat_ids[alias_ids.index(alias_id)]
|
|
chat = await self.client.get_entity(chat_id)
|
|
log_msg = ''
|
|
try:
|
|
offset_val = int(req.query.get('page', '1'))
|
|
except:
|
|
offset_val = 1
|
|
log_msg += f"page: {offset_val} | "
|
|
try:
|
|
search_query = req.query.get('search', '')
|
|
except:
|
|
search_query = ''
|
|
log_msg += f"search query: {search_query} | "
|
|
offset_val = 0 if offset_val <=1 else offset_val-1
|
|
try:
|
|
kwargs = {
|
|
'entity': chat_id,
|
|
'limit': 20,
|
|
'add_offset': 20*offset_val
|
|
}
|
|
if search_query:
|
|
kwargs.update({'search': search_query})
|
|
messages = (await self.client.get_messages(**kwargs)) or []
|
|
|
|
except:
|
|
log.debug("failed to get messages", exc_info=True)
|
|
messages = []
|
|
log_msg += f"found {len(messages)} results | "
|
|
log.debug(log_msg)
|
|
results = []
|
|
for m in messages:
|
|
if m.file and not isinstance(m.media, types.MessageMediaWebPage):
|
|
entry = dict(
|
|
file_id=m.id,
|
|
media=True,
|
|
mime_type=m.file.mime_type,
|
|
insight = get_file_name(m)[:55],
|
|
date = m.date.isoformat(),
|
|
size=get_human_size(m.file.size),
|
|
url=req.rel_url.with_path(f"/{alias_id}/{m.id}/view")
|
|
)
|
|
elif m.message:
|
|
entry = dict(
|
|
file_id=m.id,
|
|
media=False,
|
|
mime_type='text/plain',
|
|
insight = m.raw_text[:55],
|
|
date = m.date.isoformat(),
|
|
size=get_human_size(len(m.raw_text)),
|
|
url=req.rel_url.with_path(f"/{alias_id}/{m.id}/view")
|
|
)
|
|
results.append(entry)
|
|
prev_page = False
|
|
next_page = False
|
|
if offset_val:
|
|
query = {'page':offset_val}
|
|
if search_query:
|
|
query.update({'search':search_query})
|
|
prev_page = {
|
|
'url': req.rel_url.with_query(query),
|
|
'no': offset_val
|
|
}
|
|
|
|
if len(messages)==20:
|
|
query = {'page':offset_val+2}
|
|
if search_query:
|
|
query.update({'search':search_query})
|
|
next_page = {
|
|
'url': req.rel_url.with_query(query),
|
|
'no': offset_val+2
|
|
}
|
|
|
|
return {
|
|
'item_list':results,
|
|
'prev_page': prev_page,
|
|
'cur_page' : offset_val+1,
|
|
'next_page': next_page,
|
|
'search': search_query,
|
|
'name' : chat.title,
|
|
'logo': req.rel_url.with_path(f"/{alias_id}/logo")
|
|
}
|
|
|
|
|
|
@aiohttp_jinja2.template('info.html')
|
|
async def info(self, req):
|
|
file_id = int(req.match_info["id"])
|
|
alias_id = req.rel_url.path.split('/')[1]
|
|
chat_id = chat_ids[alias_ids.index(alias_id)]
|
|
message = await self.client.get_messages(entity=chat_id, ids=file_id)
|
|
if not message or not isinstance(message, Message):
|
|
log.debug(f"no valid entry for {file_id} in {chat_id}")
|
|
return {
|
|
'found':False,
|
|
'reason' : "Entry you are looking for cannot be retrived!",
|
|
}
|
|
return_val = {}
|
|
if message.file and not isinstance(message.media, types.MessageMediaWebPage):
|
|
file_name = get_file_name(message)
|
|
file_size = get_human_size(message.file.size)
|
|
media = {
|
|
'type':message.file.mime_type
|
|
}
|
|
if 'video/' in message.file.mime_type:
|
|
media.update({
|
|
'video' : True
|
|
})
|
|
elif 'audio/' in message.file.mime_type:
|
|
media['audio'] = True
|
|
elif 'image/' in message.file.mime_type:
|
|
media['image'] = True
|
|
|
|
if message.text:
|
|
caption = Markup.escape(message.raw_text).__str__().replace('\n', '<br>')
|
|
|
|
else:
|
|
caption = False
|
|
return_val = {
|
|
'found': True,
|
|
'name': file_name,
|
|
'id': file_id,
|
|
'size': file_size,
|
|
'media': media,
|
|
'caption': caption,
|
|
'title': f"Download | {file_name} | {file_size}"
|
|
}
|
|
elif message.message:
|
|
text = Markup.escape(message.raw_text).__str__().replace('\n', '<br>')
|
|
return_val = {
|
|
'found': True,
|
|
'media': False,
|
|
'text': text,
|
|
}
|
|
else:
|
|
return_val = {
|
|
'found':False,
|
|
'reason' : "Some kind of entry that I cannot display",
|
|
}
|
|
|
|
log.debug(f"data for {file_id} in {chat_id} returned as {return_val}")
|
|
return return_val
|
|
|
|
|
|
async def download_get(self, req):
|
|
return await self.handle_request(req)
|
|
|
|
|
|
async def download_head(self, req):
|
|
return await self.handle_request(req, head=True)
|
|
|
|
|
|
async def thumbnail_get(self, req):
|
|
return await self.handle_request(req, thumb=True)
|
|
|
|
|
|
async def thumbnail_head(self, req):
|
|
return await self.handle_request(req, head=True, thumb=True)
|
|
|
|
|
|
async def logo(self, req):
|
|
alias_id = req.rel_url.path.split('/')[1]
|
|
chat_id = chat_ids[alias_ids.index(alias_id)]
|
|
photo = await self.client.get_profile_photos(chat_id)
|
|
if not photo:
|
|
return web.Response(status=404, text="404: Chat has no profile photo")
|
|
photo = photo[0]
|
|
size = photo.sizes[0]
|
|
media = types.InputPhotoFileLocation(
|
|
id=photo.id,
|
|
access_hash=photo.access_hash,
|
|
file_reference=photo.file_reference,
|
|
thumb_size=size.type
|
|
)
|
|
body = self.client.iter_download(media)
|
|
r = web.Response(
|
|
status=200,
|
|
body=body,
|
|
)
|
|
r.enable_chunked_encoding()
|
|
return r
|
|
|
|
|
|
async def handle_request(self, req, head=False, thumb=False):
|
|
file_id = int(req.match_info["id"])
|
|
alias_id = req.rel_url.path.split('/')[1]
|
|
chat_id = chat_ids[alias_ids.index(alias_id)]
|
|
message = await self.client.get_messages(entity=chat_id, ids=file_id)
|
|
if not message or not message.file:
|
|
log.info(f"no result for {file_id} in {chat_id}")
|
|
return web.Response(status=410, text="410: Gone. Access to the target resource is no longer available!")
|
|
|
|
if thumb and message.document:
|
|
thumbnail = message.document.thumbs
|
|
if not thumbnail:
|
|
log.info(f"no thumbnail for {file_id} in {chat_id}")
|
|
return web.Response(status=404, text="404: Not Found")
|
|
thumbnail = thumbnail[-1]
|
|
mime_type = 'image/jpeg'
|
|
size = thumbnail.size
|
|
file_name = f"{file_id}_thumbnail.jpg"
|
|
media = types.InputDocumentFileLocation(
|
|
id=message.document.id,
|
|
access_hash=message.document.access_hash,
|
|
file_reference=message.document.file_reference,
|
|
thumb_size=thumbnail.type
|
|
)
|
|
else:
|
|
media = message.media
|
|
size = message.file.size
|
|
file_name = get_file_name(message)
|
|
mime_type = message.file.mime_type
|
|
|
|
try:
|
|
offset = req.http_range.start or 0
|
|
limit = req.http_range.stop or size
|
|
if (limit > size) or (offset < 0) or (limit < offset):
|
|
raise ValueError("range not in acceptable format")
|
|
except ValueError:
|
|
log.info("Range Not Satisfiable", exc_info=True)
|
|
return web.Response(
|
|
status=416,
|
|
text="416: Range Not Satisfiable",
|
|
headers = {
|
|
"Content-Range": f"bytes */{size}"
|
|
}
|
|
)
|
|
|
|
body = None
|
|
if not head:
|
|
body = self.client.download(media, size, offset, limit)
|
|
log.info(f"Serving file {message.id} in {chat_id} ; Range: {offset} - {limit}")
|
|
|
|
headers = {
|
|
"Content-Type": mime_type,
|
|
"Content-Range": f"bytes {offset}-{limit}/{size}",
|
|
"Content-Length": str(limit - offset),
|
|
"Accept-Ranges": "bytes",
|
|
"Content-Disposition": f'attachment; filename="{file_name}"'
|
|
}
|
|
|
|
return web.Response(
|
|
status=206 if offset else 200,
|
|
body=body,
|
|
headers=headers
|
|
)
|