273 lines
10 KiB
Python
273 lines
10 KiB
Python
import asyncio
|
|
import json
|
|
import os
|
|
import logging
|
|
import traceback
|
|
from urllib.parse import quote
|
|
|
|
import uvicorn
|
|
from fastapi import FastAPI, status, Request
|
|
from fastapi.middleware.cors import CORSMiddleware
|
|
from fastapi.responses import Response, StreamingResponse
|
|
from contextlib import asynccontextmanager
|
|
from telethon import types, hints, utils
|
|
from pydantic import BaseModel
|
|
|
|
import configParse
|
|
from backend import apiutils
|
|
from backend.TgFileSystemClientManager import TgFileSystemClientManager
|
|
|
|
logger = logging.getLogger(__file__.split("/")[-1])
|
|
|
|
clients_mgr: TgFileSystemClientManager = None
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app: FastAPI):
|
|
for handler in logging.getLogger().handlers:
|
|
if isinstance(handler, logging.handlers.TimedRotatingFileHandler):
|
|
handler.suffix = "%Y-%m-%d"
|
|
global clients_mgr
|
|
param = configParse.get_TgToFileSystemParameter()
|
|
clients_mgr = TgFileSystemClientManager(param)
|
|
yield
|
|
|
|
app = FastAPI(lifespan=lifespan)
|
|
|
|
app.add_middleware(
|
|
CORSMiddleware,
|
|
allow_origins=["*"],
|
|
allow_credentials=True,
|
|
allow_methods=["*"],
|
|
allow_headers=["*"],
|
|
)
|
|
|
|
class TgToFileListRequestBody(BaseModel):
|
|
token: str
|
|
search: str = ""
|
|
chat_id: int = 0
|
|
index: int = 0
|
|
length: int = 10
|
|
refresh: bool = False
|
|
inner: bool = False
|
|
inc: bool = False
|
|
|
|
@app.post("/tg/api/v1/file/search")
|
|
@apiutils.atimeit
|
|
async def search_tg_file_list(body: TgToFileListRequestBody):
|
|
try:
|
|
param = configParse.get_TgToFileSystemParameter()
|
|
res = hints.TotalList()
|
|
res_type = "msg"
|
|
client = await clients_mgr.get_client_force(body.token)
|
|
res_dict = []
|
|
res = await client.get_messages_by_search_db(body.chat_id, body.search, limit=body.length, inc=body.inc, offset=body.index)
|
|
for item in res:
|
|
msg_info = json.loads(item)
|
|
file_name = apiutils.get_message_media_name_from_dict(msg_info)
|
|
chat_id = apiutils.get_message_chat_id_from_dict(msg_info)
|
|
msg_id = apiutils.get_message_msg_id_from_dict(msg_info)
|
|
msg_info['file_name'] = file_name
|
|
msg_info['download_url'] = f"{param.base.exposed_url}/tg/api/v1/file/get/{chat_id}/{msg_id}/{file_name}"
|
|
msg_info['src_tg_link'] = f"https://t.me/c/{chat_id}/{msg_id}"
|
|
res_dict.append(msg_info)
|
|
|
|
client_dict = json.loads(client.to_json())
|
|
client_dict['sign'] = body.token
|
|
|
|
response_dict = {
|
|
"client": client_dict,
|
|
"type": res_type,
|
|
"length": len(res_dict),
|
|
"list": res_dict,
|
|
}
|
|
return Response(json.dumps(response_dict), status_code=status.HTTP_200_OK)
|
|
except Exception as err:
|
|
logger.error(f"{err=},{traceback.format_exc()}")
|
|
return Response(json.dumps({"detail": f"{err=}"}), status_code=status.HTTP_404_NOT_FOUND)
|
|
|
|
|
|
@app.post("/tg/api/v1/file/list")
|
|
@apiutils.atimeit
|
|
async def get_tg_file_list(body: TgToFileListRequestBody):
|
|
try:
|
|
res = hints.TotalList()
|
|
res_type = "chat"
|
|
client = await clients_mgr.get_client_force(body.token)
|
|
res_dict = []
|
|
if body.search != "":
|
|
res = await client.get_messages_by_search(body.chat_id, search_word=body.search, limit=body.length, offset=body.index, inner_search=body.inner)
|
|
else:
|
|
res = await client.get_messages(body.chat_id, limit=body.length, offset=body.index)
|
|
res_type = "msg"
|
|
for item in res:
|
|
file_name = apiutils.get_message_media_name(item)
|
|
if file_name == "":
|
|
file_name = "unknown.tmp"
|
|
msg_info = json.loads(item.to_json())
|
|
msg_info['file_name'] = file_name
|
|
msg_info['download_url'] = f"{param.base.exposed_url}/tg/api/v1/file/get/{body.chat_id}/{item.id}/{file_name}?sign={body.token}"
|
|
res_dict.append(msg_info)
|
|
|
|
response_dict = {
|
|
"client": json.loads(client.to_json()),
|
|
"type": res_type,
|
|
"length": len(res_dict),
|
|
"list": res_dict,
|
|
}
|
|
return Response(json.dumps(response_dict), status_code=status.HTTP_200_OK)
|
|
except Exception as err:
|
|
logger.error(f"{err=},{traceback.format_exc()}")
|
|
return Response(json.dumps({"detail": f"{err=}"}), status_code=status.HTTP_404_NOT_FOUND)
|
|
|
|
|
|
@app.get("/tg/api/v1/file/msg")
|
|
@apiutils.atimeit
|
|
async def get_tg_file_media_stream(token: str, cid: int, mid: int, request: Request):
|
|
msg_id = mid
|
|
chat_id = cid
|
|
headers = {
|
|
# "content-type": "video/mp4",
|
|
"accept-ranges": "bytes",
|
|
"content-encoding": "identity",
|
|
# "content-length": stream_file_size,
|
|
"access-control-expose-headers": (
|
|
"content-type, accept-ranges, content-length, "
|
|
"content-range, content-encoding"
|
|
),
|
|
}
|
|
range_header = request.headers.get("range")
|
|
try:
|
|
client = await clients_mgr.get_client_force(token)
|
|
msg = await client.get_message(chat_id, msg_id)
|
|
file_size = msg.media.document.size
|
|
start = 0
|
|
end = file_size - 1
|
|
status_code = status.HTTP_200_OK
|
|
mime_type = msg.media.document.mime_type
|
|
headers["content-type"] = mime_type
|
|
# headers["content-length"] = str(file_size)
|
|
file_name = apiutils.get_message_media_name(msg)
|
|
if file_name == "":
|
|
maybe_file_type = mime_type.split("/")[-1]
|
|
file_name = f"{chat_id}.{msg_id}.{maybe_file_type}"
|
|
headers[
|
|
"Content-Disposition"] = f"inline; filename*=utf-8'{quote(file_name)}'"
|
|
|
|
if range_header is not None:
|
|
start, end = apiutils.get_range_header(range_header, file_size)
|
|
size = end - start + 1
|
|
# headers["content-length"] = str(size)
|
|
headers["content-range"] = f"bytes {start}-{end}/{file_size}"
|
|
status_code = status.HTTP_206_PARTIAL_CONTENT
|
|
else:
|
|
headers["content-length"] = str(file_size)
|
|
headers["content-range"] = f"bytes 0-{file_size-1}/{file_size}"
|
|
return StreamingResponse(
|
|
client.streaming_get_iter(msg, start, end, request),
|
|
headers=headers,
|
|
media_type=mime_type,
|
|
status_code=status_code,
|
|
)
|
|
except Exception as err:
|
|
logger.error(f"{err=},{traceback.format_exc()}")
|
|
return Response(json.dumps({"detail": f"{err=}"}), status_code=status.HTTP_404_NOT_FOUND)
|
|
|
|
|
|
@app.get("/tg/api/v1/file/get/{chat_id}/{msg_id}/{file_name}")
|
|
@apiutils.atimeit
|
|
async def get_tg_file_media(chat_id: int|str, msg_id: int, file_name: str, sign: str, req: Request):
|
|
try:
|
|
if isinstance(chat_id, str):
|
|
chat_id = int(chat_id)
|
|
return await get_tg_file_media_stream(sign, chat_id, msg_id, req)
|
|
except Exception as err:
|
|
logger.error(f"{err=},{traceback.format_exc()}")
|
|
return Response(json.dumps({"detail": f"{err=}"}), status_code=status.HTTP_404_NOT_FOUND)
|
|
|
|
|
|
@app.get("/tg/api/v1/client/login")
|
|
@apiutils.atimeit
|
|
async def login_new_tg_file_client():
|
|
url = await clients_mgr.login_clients()
|
|
return {"url": url}
|
|
|
|
|
|
@app.get("/tg/api/v1/client/status")
|
|
async def get_tg_file_client_status(request: Request):
|
|
return await clients_mgr.get_status()
|
|
|
|
|
|
@app.get("/tg/api/v1/client/link_convert")
|
|
@apiutils.atimeit
|
|
async def convert_tg_msg_link_media_stream(link: str):
|
|
try:
|
|
link_slice = link.split("/")
|
|
if len(link_slice) < 5:
|
|
raise RuntimeError("link format invalid")
|
|
chat_id_or_name, msg_id = link_slice[-2:]
|
|
is_msg_id = msg_id.isascii() and msg_id.isdecimal()
|
|
if not is_msg_id:
|
|
raise RuntimeError("message id invalid")
|
|
msg_id = int(msg_id)
|
|
is_chat_name = chat_id_or_name.isascii() and not chat_id_or_name.isdecimal()
|
|
is_chat_id = chat_id_or_name.isascii() and chat_id_or_name.isdecimal()
|
|
if not is_chat_name and not is_chat_id:
|
|
raise RuntimeError("chat id invalid")
|
|
client = clients_mgr.get_first_client()
|
|
if client is None:
|
|
raise RuntimeError("client not ready, login first pls.")
|
|
if is_chat_id:
|
|
chat_id_or_name = int(chat_id_or_name)
|
|
msg = await client.get_message(chat_id_or_name, msg_id)
|
|
file_name = apiutils.get_message_media_name(msg)
|
|
param = configParse.get_TgToFileSystemParameter()
|
|
url = f"{param.base.exposed_url}/tg/api/v1/file/get/{utils.get_peer_id(msg.peer_id)}/{msg.id}/{file_name}?sign={client.sign}"
|
|
logger.info(f"{link}: link convert to: {url}")
|
|
return Response(json.dumps({"url": url}), status_code=status.HTTP_200_OK)
|
|
except Exception as err:
|
|
logger.error(f"{err=},{traceback.format_exc()}")
|
|
return Response(json.dumps({"detail": "link invalid", "err": f"{err}"}), status_code=status.HTTP_404_NOT_FOUND)
|
|
|
|
|
|
@app.get("/tg/api/v1/client/profile_photo")
|
|
@apiutils.atimeit
|
|
async def get_tg_chat_profile_photo(chat_id: int, sign: str):
|
|
raise NotImplementedError
|
|
|
|
|
|
class TgToChatListRequestBody(BaseModel):
|
|
token: str
|
|
search: str = ""
|
|
index: int = 0
|
|
length: int = 0
|
|
refresh: bool = False
|
|
|
|
@app.post("/tg/api/v1/client/chat")
|
|
@apiutils.atimeit
|
|
async def get_tg_client_chat_list(body: TgToChatListRequestBody, request: Request):
|
|
try:
|
|
res = hints.TotalList()
|
|
res_type = "chat"
|
|
client = await clients_mgr.get_client_force(body.token)
|
|
res_dict = {}
|
|
|
|
res = await client.get_dialogs(limit=body.length, offset=body.index, refresh=body.refresh)
|
|
res_dict = [{"id": item.id, "is_channel": item.is_channel,
|
|
"is_group": item.is_group, "is_user": item.is_user, "name": item.name, } for item in res]
|
|
|
|
response_dict = {
|
|
"client": json.loads(client.to_json()),
|
|
"type": res_type,
|
|
"length": len(res_dict),
|
|
"list": res_dict,
|
|
}
|
|
return Response(json.dumps(response_dict), status_code=status.HTTP_200_OK)
|
|
except Exception as err:
|
|
logger.error(f"{err=}")
|
|
return Response(json.dumps({"detail": f"{err=}"}), status_code=status.HTTP_404_NOT_FOUND)
|
|
|
|
if __name__ == "__main__":
|
|
param = configParse.get_TgToFileSystemParameter()
|
|
uvicorn.run(app, host="0.0.0.0", port=param.base.port)
|