import os

import time

from core.response import APIResponse

from core.storage import FileStorageInterface, storages

from core.settings import settings

from apps.base.models import FileCodes, KeyValue

from apps.base.utils import get_expire_info, get_file_path_name

from fastapi import HTTPException

from core.settings import data_root

class FileService:

def __init__(self):

self.file_storage: FileStorageInterface = storages[settings.file_storage]()

async def delete_file(self, file_id: int):

file_code = await FileCodes.get(id=file_id)

await self.file_storage.delete_file(file_code)

await file_code.delete()

async def list_files(self, page: int, size: int, keyword: str = ""):

offset = (page - 1) * size

files = (

await FileCodes.filter(prefix__icontains=keyword).limit(size).offset(offset)

)

total = await FileCodes.filter(prefix__icontains=keyword).count()

return files, total

async def download_file(self, file_id: int):

file_code = await FileCodes.filter(id=file_id).first()

if not file_code:

raise HTTPException(status_code=404, detail="文件不存在")

if file_code.text:

return APIResponse(detail=file_code.text)

else:

return await self.file_storage.get_file_response(file_code)

async def share_local_file(self, item):

local_file = LocalFileClass(item.filename)

if not await local_file.exists():

raise HTTPException(status_code=404, detail="文件不存在")

text = await local_file.read()

expired_at, expired_count, used_count, code = await get_expire_info(

item.expire_value, item.expire_style

)

path, suffix, prefix, uuid_file_name, save_path = await get_file_path_name(item)

await self.file_storage.save_file(text, save_path)

await FileCodes.create(

code=code,

prefix=prefix,

suffix=suffix,

uuid_file_name=uuid_file_name,

file_path=path,

size=local_file.size,

expired_at=expired_at,

expired_count=expired_count,

used_count=used_count,

)

return {

"code": code,

"name": local_file.file,

}

class ConfigService:

def get_config(self):

return settings.items()

async def update_config(self, data: dict):

admin_token = data.get("admin_token")

if admin_token is None or admin_token == "":

raise HTTPException(status_code=400, detail="管理员密码不能为空")

for key, value in data.items():

if key not in settings.default_config:

continue

if key in [

"errorCount",

"errorMinute",

"max_save_seconds",

"onedrive_proxy",

"openUpload",

"port",

"s3_proxy",

"uploadCount",

"uploadMinute",

"uploadSize",

]:

data[key] = int(value)

elif key in ["opacity"]:

data[key] = float(value)

else:

data[key] = value

await KeyValue.filter(key="settings").update(value=data)

for k, v in data.items():

settings.__setattr__(k, v)

class LocalFileService:

async def list_files(self):

files = []

if not os.path.exists(data_root / "local"):

os.makedirs(data_root / "local")

for file in os.listdir(data_root / "local"):

files.append(LocalFileClass(file))

return files

async def delete_file(self, filename: str):

file = LocalFileClass(filename)

if await file.exists():

await file.delete()

return "删除成功"

raise HTTPException(status_code=404, detail="文件不存在")

class LocalFileClass:

def __init__(self, file):

self.file = file

self.path = data_root / "local" / file

self.ctime = time.strftime(

"%Y-%m-%d %H:%M:%S", time.localtime(os.path.getctime(self.path))

)

self.size = os.path.getsize(self.path)

async def read(self):

return open(self.path, "rb")

async def write(self, data):

with open(self.path, "w") as f:

f.write(data)

async def delete(self):

os.remove(self.path)

async def exists(self):

return os.path.exists(self.path)