shanxia2.0/backend/app/services/doclib_service.py

"""文档库业务权限：租户隔离 + 上传人/明确分享人/超级管理员。

该模块采用用户确认的逐文件 ACL，部门数据范围不扩大私人资料访问权限。
目录只暴露可见文件的祖先路径，不将目录可见性当作文件授权。
"""
from datetime import datetime
from typing import Optional
from uuid import uuid4

from fastapi import HTTPException
from sqlalchemy import and_, exists, or_
from sqlalchemy.orm import Session

from app.core.config import settings
from app.core.tenant_context import get_tenant_no
from app.models.doclib import DoclibFile, DoclibFolder, DoclibShare
from app.models.models import SysDept, SysUser


class DoclibService:
    def __init__(self, db: Session, user: dict):
        self.db = db
        self.user = user
        self.uid = user.get('user_id')
        if not self.uid:
            raise HTTPException(401, '请先登录')
        self.tenant = get_tenant_no(db, user)
        self.is_admin = user.get('role') == 'super_admin'

    def _base(self, model):
        return self.db.query(model).filter(model.tenant_no == self.tenant, model.del_flag == 0)

    def _public(self):
        return dict(id=str(uuid4()), tenant_no=self.tenant, create_by=self.uid,
                    update_by=self.uid, create_dept_id=self.user.get('region_id') or '')

    def _shared(self):
        return exists().where(and_(DoclibShare.tenant_no == self.tenant,
                                  DoclibShare.file_id == DoclibFile.id,
                                  DoclibShare.user_id == self.uid, DoclibShare.del_flag == 0))

    def _files(self, scope: Optional[str] = None):
        query = self._base(DoclibFile)
        if scope == 'mine':
            return query.filter(DoclibFile.create_by == self.uid)
        if scope == 'shared':
            return query.filter(DoclibFile.create_by != self.uid, self._shared())
        if scope == 'all':
            if not self.is_admin:
                raise HTTPException(403, '仅超级管理员可查看全部文档')
            return query
        if scope is not None:
            raise HTTPException(400, '无效文档范围')
        return query if self.is_admin else query.filter(or_(DoclibFile.create_by == self.uid, self._shared()))

    def _file(self, file_id, *, manage=False, lock=False):
        query = self._files().filter(DoclibFile.id == file_id)
        row = (query.populate_existing().with_for_update() if lock else query).first()
        if row is None:
            raise HTTPException(404, '文档不存在或无权访问')
        if manage and not (self.is_admin or row.create_by == self.uid):
            raise HTTPException(403, '只有上传人和超级管理员可以管理文档')
        return row

    def _folder(self, folder_id, *, own=False, manage=False, lock=False):
        query = self._base(DoclibFolder).filter(DoclibFolder.id == folder_id)
        row = (query.populate_existing().with_for_update() if lock else query).first()
        if row is None:
            raise HTTPException(404, '文件夹不存在')
        if (own and row.create_by != self.uid) or (manage and row.create_by != self.uid and not self.is_admin):
            raise HTTPException(403, '无权管理此文件夹')
        return row

    def _lock_owner(self, owner_id):
        # 所有目录写操作锁同一所有者，避免检查空目录与并发上传/建子目录之间的竞争。
        row = self._base(SysUser).filter(SysUser.id == owner_id).with_for_update().first()
        if row is None:
            raise HTTPException(404, '文件夹所属用户不存在')

    def _folder_map(self):
        return {r.id: r for r in self._base(DoclibFolder).all()}

    @staticmethod
    def _path(folder_id, folder_map):
        names, seen = [], set()
        while folder_id and folder_id not in seen and folder_id in folder_map:
            seen.add(folder_id)
            row = folder_map[folder_id]
            names.append(row.name)
            folder_id = row.parent_id
        return ' / '.join(reversed(names))

    def _person_map(self, ids):
        if not ids:
            return {}
        rows = (self.db.query(SysUser, SysDept.dept_name)
                .outerjoin(SysDept, and_(SysDept.id == SysUser.dept_id, SysDept.tenant_no == self.tenant,
                                        SysDept.del_flag == 0))
                .filter(SysUser.tenant_no == self.tenant, SysUser.id.in_(ids)).all())
        return {u.id: {'id': u.id, 'name': u.nick_name or u.user_no, 'deptName': dept or ''} for u, dept in rows}

    def _serialize_files(self, rows):
        if not rows:
            return []
        shares = self._base(DoclibShare).filter(DoclibShare.file_id.in_([r.id for r in rows])).all()
        people = self._person_map({r.create_by for r in rows} | {s.user_id for s in shares})
        folder_map = self._folder_map()
        by_file = {}
        for share in shares:
            by_file.setdefault(share.file_id, []).append(people.get(share.user_id, {
                'id': share.user_id, 'name': '已删除用户', 'deptName': ''}))
        return [self._row_to_dict(row, folder_map, people, by_file.get(row.id, [])) for row in rows]

    def _row_to_dict(self, row, folder_map, people, shares):
        """文件可读字段的唯一转换入口；所有身份和对象属性均为只读。"""
        return {
            'id': row.id, 'name': row.name, 'folderId': row.folder_id,
            'folderPath': self._path(row.folder_id, folder_map) or '根目录',
            'size': row.size, 'contentType': row.content_type, 'ownerId': row.create_by,
            'ownerName': people.get(row.create_by, {}).get('name', '已删除用户'),
            'createTime': row.create_time.strftime('%Y-%m-%d %H:%M:%S'),
            'updateTime': row.update_time.strftime('%Y-%m-%d %H:%M:%S'),
            'canManage': self.is_admin or row.create_by == self.uid,
            'shares': sorted(shares, key=lambda x: x['id']),
        }

    def get_file(self, file_id):
        return self._serialize_files([self._file(file_id)])[0]

    def download_record(self, file_id):
        # 仅供服务端下载使用；不得直接序列化 object_key 返回给前端。
        return self._file(file_id)

    def list_files(self, scope='mine', folder_id='', keyword='', page=1, page_size=20):
        query = self._files(scope)
        if folder_id:
            query = query.filter(DoclibFile.folder_id == folder_id)
        if keyword.strip():
            query = query.filter(DoclibFile.name.contains(keyword.strip(), autoescape=True))
        total = query.count()
        rows = (query.order_by(DoclibFile.create_time.desc(), DoclibFile.id.desc())
                .offset((page - 1) * page_size).limit(page_size).all())
        return {'list': self._serialize_files(rows), 'total': total}

    def _folder_node(self, row, scope, folder_map, count=0):
        return {'id': f'{scope}:{row.id}', 'name': row.name, 'scope': scope,
                'folderId': row.id, 'fullPath': self._path(row.id, folder_map),
                'ownerId': row.create_by, 'canManage': scope != 'shared' and (self.is_admin or row.create_by == self.uid),
                'count': count, 'children': []}

    def tree(self):
        from sqlalchemy import func
        folder_map = self._folder_map()
        roots = []
        scopes = [('mine', '我的文档'), ('shared', '分享给我')]
        if self.is_admin:
            scopes.append(('all', '全部文档'))
        for scope, title in scopes:
            counts = dict(self._files(scope).with_entities(DoclibFile.folder_id, func.count(DoclibFile.id))
                          .group_by(DoclibFile.folder_id).all())
            if scope == 'mine':
                allowed = {fid for fid, f in folder_map.items() if f.create_by == self.uid}
            elif scope == 'all':
                allowed = set(folder_map)
            else:
                allowed = set(counts) & set(folder_map)
                for fid in list(allowed):
                    seen = set()
                    while fid in folder_map and fid not in seen:
                        seen.add(fid)
                        allowed.add(fid)
                        fid = folder_map[fid].parent_id
            nodes = {fid: self._folder_node(folder_map[fid], scope, folder_map, counts.get(fid, 0))
                     for fid in sorted(allowed, key=lambda x: (folder_map[x].create_time, x), reverse=True)}
            root = {'id': scope, 'name': title, 'scope': scope, 'folderId': '', 'fullPath': title,
                    'ownerId': self.uid if scope == 'mine' else '', 'canManage': False,
                    'count': sum(counts.values()), 'children': []}
            for fid, node in nodes.items():
                parent = nodes.get(folder_map[fid].parent_id, root)
                parent['children'].append(node)
            roots.append(root)
        return {'nodes': roots, 'isSuperAdmin': self.is_admin, 'maxUploadBytes': settings.DOCLIB_MAX_UPLOAD_BYTES}

    def _unique_name(self, name, parent_id, owner_id, exclude=''):
        found = self._base(DoclibFolder).filter(DoclibFolder.create_by == owner_id,
                    DoclibFolder.parent_id == parent_id, DoclibFolder.name == name, DoclibFolder.id != exclude).with_for_update().first()
        if found:
            raise HTTPException(409, '同一目录下已存在此名称')

    def create_folder(self, name, parent_id=''):
        self._lock_owner(self.uid)
        if parent_id:
            self._folder(parent_id, own=True, lock=True)
        self._unique_name(name, parent_id, self.uid)
        row = DoclibFolder(name=name, parent_id=parent_id, **self._public())
        self.db.add(row)
        self.db.commit()
        return self._folder_node(row, 'mine', self._folder_map())

    def rename_folder(self, folder_id, name):
        row = self._folder(folder_id, manage=True)
        self._lock_owner(row.create_by)
        row = self._folder(folder_id, manage=True, lock=True)
        self._unique_name(name, row.parent_id, row.create_by, row.id)
        row.name, row.update_by = name, self.uid
        self.db.commit()
        return self._folder_node(row, 'mine' if row.create_by == self.uid else 'all', self._folder_map())

    def delete_folder(self, folder_id):
        row = self._folder(folder_id, manage=True)
        self._lock_owner(row.create_by)
        row = self._folder(folder_id, manage=True, lock=True)
        if (self._base(DoclibFolder).filter(DoclibFolder.parent_id == row.id).with_for_update().first() or
                self._base(DoclibFile).filter(DoclibFile.folder_id == row.id).with_for_update().first()):
            raise HTTPException(409, '文件夹非空，请先删除文件和子文件夹')
        row.del_flag, row.update_by = 1, self.uid
        self.db.commit()

    def create_file(self, *, name, folder_id, size, content_type, object_key):
        self._lock_owner(self.uid)
        if folder_id:
            self._folder(folder_id, own=True, lock=True)
        row = DoclibFile(name=name, folder_id=folder_id, size=size, content_type=content_type,
                         object_key=object_key, **self._public())
        self.db.add(row)
        self.db.flush()
        result = self._serialize_files([row])[0]
        self.db.commit()
        return result

    def set_shares(self, file_id, user_ids):
        row = self._file(file_id, manage=True, lock=True)
        requested = set(user_ids) - {row.create_by}
        valid = {u.id for u in self._base(SysUser).filter(SysUser.id.in_(requested), SysUser.status == '1').all()}
        if requested != valid:
            raise HTTPException(400, '分享人员不存在、已停用或不属于当前租户')
        history = {s.user_id: s for s in self.db.query(DoclibShare).filter(
            DoclibShare.tenant_no == self.tenant, DoclibShare.file_id == file_id).populate_existing().with_for_update().all()}
        for uid, share in history.items():
            share.del_flag = 0 if uid in requested else 1
            share.update_by = self.uid
        for uid in requested - set(history):
            self.db.add(DoclibShare(file_id=file_id, user_id=uid, **self._public()))
        row.update_by, row.update_time = self.uid, datetime.now()
        self.db.commit()
        return self._serialize_files([row])[0]

    def delete_files(self, ids):
        rows = [self._file(fid, manage=True, lock=True) for fid in sorted(set(ids))]
        for row in rows:
            row.del_flag, row.update_by = 1, self.uid
        self._base(DoclibShare).filter(DoclibShare.file_id.in_(ids)).update(
            {DoclibShare.del_flag: 1, DoclibShare.update_by: self.uid}, synchronize_session=False)
        self.db.commit()

    def users(self, keyword=''):
        query = self._base(SysUser).filter(SysUser.status == '1', SysUser.id != self.uid)
        if keyword.strip():
            query = query.filter(or_(SysUser.nick_name.contains(keyword.strip(), autoescape=True),
                                     SysUser.user_no.contains(keyword.strip(), autoescape=True)))
        rows = query.order_by(SysUser.nick_name, SysUser.id).limit(100).all()
        people = self._person_map([r.id for r in rows])
        return [people[r.id] for r in rows]