497 lines
18 KiB
Python
497 lines
18 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
"""
|
|
文档生成服务层
|
|
"""
|
|
from typing import Optional, List, Tuple, Dict, Any
|
|
from datetime import datetime, date
|
|
|
|
from sqlalchemy import select, func, and_, or_
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.base_service import BaseService
|
|
from online_dev.document_generator.model import DocumentTemplate, GeneratedDocument
|
|
from online_dev.document_generator.schema import (
|
|
DocumentTemplateCreate, DocumentTemplateUpdate
|
|
)
|
|
|
|
|
|
class DocumentTemplateService(BaseService[DocumentTemplate, DocumentTemplateCreate, DocumentTemplateUpdate]):
|
|
"""文档模板服务"""
|
|
|
|
model = DocumentTemplate
|
|
|
|
@classmethod
|
|
async def get_list(
|
|
cls,
|
|
db: AsyncSession,
|
|
page: int = 1,
|
|
page_size: int = 20,
|
|
application_id: Optional[str] = None,
|
|
category: Optional[str] = None,
|
|
status: Optional[str] = None,
|
|
form_code: Optional[str] = None,
|
|
workflow_code: Optional[str] = None,
|
|
keyword: Optional[str] = None,
|
|
is_builtin: Optional[bool] = None,
|
|
) -> Tuple[List[DocumentTemplate], int]:
|
|
"""获取模板列表"""
|
|
conditions = [cls.model.is_deleted == False]
|
|
|
|
# 子应用过滤：有 application_id 时过滤该应用，无则只返回主应用数据
|
|
if application_id:
|
|
conditions.append(cls.model.application_id == application_id)
|
|
else:
|
|
conditions.append(cls.model.application_id.is_(None))
|
|
if category:
|
|
conditions.append(cls.model.category == category)
|
|
if status:
|
|
conditions.append(cls.model.status == status)
|
|
if form_code:
|
|
conditions.append(cls.model.form_code == form_code)
|
|
if workflow_code:
|
|
conditions.append(cls.model.workflow_code == workflow_code)
|
|
if is_builtin is not None:
|
|
conditions.append(cls.model.is_builtin == is_builtin)
|
|
if keyword:
|
|
conditions.append(
|
|
or_(
|
|
cls.model.name.ilike(f"%{keyword}%"),
|
|
cls.model.code.ilike(f"%{keyword}%"),
|
|
cls.model.description.ilike(f"%{keyword}%"),
|
|
)
|
|
)
|
|
|
|
# 查询总数
|
|
count_stmt = select(func.count()).select_from(cls.model).where(and_(*conditions))
|
|
total = (await db.execute(count_stmt)).scalar() or 0
|
|
|
|
# 查询列表
|
|
stmt = (
|
|
select(cls.model)
|
|
.where(and_(*conditions))
|
|
.order_by(cls.model.sys_create_datetime.desc())
|
|
.offset((page - 1) * page_size)
|
|
.limit(page_size)
|
|
)
|
|
result = await db.execute(stmt)
|
|
items = list(result.scalars().all())
|
|
|
|
return items, total
|
|
|
|
@classmethod
|
|
async def get_by_code(cls, db: AsyncSession, code: str) -> Optional[DocumentTemplate]:
|
|
"""根据编码获取模板"""
|
|
stmt = select(cls.model).where(
|
|
and_(cls.model.code == code, cls.model.is_deleted == False)
|
|
)
|
|
result = await db.execute(stmt)
|
|
return result.scalar_one_or_none()
|
|
|
|
@classmethod
|
|
async def get_by_workflow_code(cls, db: AsyncSession, workflow_code: str) -> List[DocumentTemplate]:
|
|
"""根据工作流编码获取绑定的已发布模板列表"""
|
|
stmt = select(cls.model).where(
|
|
and_(
|
|
cls.model.workflow_code == workflow_code,
|
|
cls.model.status == "published",
|
|
cls.model.is_deleted == False
|
|
)
|
|
).order_by(cls.model.sort, cls.model.sys_create_datetime)
|
|
result = await db.execute(stmt)
|
|
return list(result.scalars().all())
|
|
|
|
@classmethod
|
|
async def get_by_form_code(cls, db: AsyncSession, form_code: str) -> List[DocumentTemplate]:
|
|
"""根据表单编码获取绑定的已发布模板列表"""
|
|
import logging
|
|
logger = logging.getLogger(__name__)
|
|
|
|
logger.info(f"Querying templates for form_code: {form_code}")
|
|
|
|
# 先查询所有绑定该表单的模板（不限状态）用于调试
|
|
debug_stmt = select(cls.model).where(
|
|
and_(
|
|
cls.model.form_code == form_code,
|
|
cls.model.is_deleted == False
|
|
)
|
|
)
|
|
debug_result = await db.execute(debug_stmt)
|
|
all_templates = list(debug_result.scalars().all())
|
|
logger.info(f"Found {len(all_templates)} templates (all statuses) for form_code {form_code}")
|
|
for t in all_templates:
|
|
logger.info(f" - Template: {t.name} (code={t.code}, status={t.status}, form_code={t.form_code})")
|
|
|
|
# 正式查询：只返回已发布的模板
|
|
stmt = select(cls.model).where(
|
|
and_(
|
|
cls.model.form_code == form_code,
|
|
cls.model.status == "published",
|
|
cls.model.is_deleted == False
|
|
)
|
|
).order_by(cls.model.sort, cls.model.sys_create_datetime)
|
|
result = await db.execute(stmt)
|
|
published_templates = list(result.scalars().all())
|
|
logger.info(f"Returning {len(published_templates)} published templates")
|
|
return published_templates
|
|
|
|
@classmethod
|
|
async def has_templates_by_form_code(cls, db: AsyncSession, form_code: str) -> bool:
|
|
"""检查表单是否绑定了已发布的单据模板"""
|
|
stmt = select(func.count()).select_from(cls.model).where(
|
|
and_(
|
|
cls.model.form_code == form_code,
|
|
cls.model.status == "published",
|
|
cls.model.is_deleted == False
|
|
)
|
|
)
|
|
result = await db.execute(stmt)
|
|
count = result.scalar() or 0
|
|
return count > 0
|
|
|
|
@classmethod
|
|
async def publish(cls, db: AsyncSession, template_id: str) -> Optional[DocumentTemplate]:
|
|
"""发布模板"""
|
|
template = await cls.get_by_id(db, template_id)
|
|
if not template:
|
|
return None
|
|
|
|
template.status = "published"
|
|
template.version += 1
|
|
await db.commit()
|
|
await db.refresh(template)
|
|
return template
|
|
|
|
@classmethod
|
|
async def unpublish(cls, db: AsyncSession, template_id: str) -> Optional[DocumentTemplate]:
|
|
"""取消发布"""
|
|
template = await cls.get_by_id(db, template_id)
|
|
if not template:
|
|
return None
|
|
|
|
template.status = "draft"
|
|
await db.commit()
|
|
await db.refresh(template)
|
|
return template
|
|
|
|
@classmethod
|
|
async def copy(cls, db: AsyncSession, template_id: str, new_code: str, new_name: str) -> Optional[DocumentTemplate]:
|
|
"""复制模板"""
|
|
template = await cls.get_by_id(db, template_id)
|
|
if not template:
|
|
return None
|
|
|
|
# 创建新模板
|
|
new_template = DocumentTemplate(
|
|
application_id=template.application_id,
|
|
name=new_name,
|
|
code=new_code,
|
|
category=template.category,
|
|
description=template.description,
|
|
form_code=template.form_code,
|
|
workflow_code=template.workflow_code,
|
|
template_type=template.template_type,
|
|
template_content=template.template_content,
|
|
template_css=template.template_css,
|
|
page_size=template.page_size,
|
|
page_orientation=template.page_orientation,
|
|
page_margin=template.page_margin,
|
|
watermark_enabled=template.watermark_enabled,
|
|
watermark_text=template.watermark_text,
|
|
watermark_type=template.watermark_type,
|
|
watermark_image_id=template.watermark_image_id,
|
|
watermark_opacity=template.watermark_opacity,
|
|
watermark_angle=template.watermark_angle,
|
|
seal_enabled=template.seal_enabled,
|
|
seal_positions=template.seal_positions,
|
|
header_enabled=template.header_enabled,
|
|
header_template=template.header_template,
|
|
footer_enabled=template.footer_enabled,
|
|
footer_template=template.footer_template,
|
|
show_page_number=template.show_page_number,
|
|
status="draft",
|
|
is_builtin=False,
|
|
version=1,
|
|
)
|
|
|
|
db.add(new_template)
|
|
await db.commit()
|
|
await db.refresh(new_template)
|
|
return new_template
|
|
|
|
@classmethod
|
|
async def get_categories(cls, db: AsyncSession, application_id: Optional[str] = None) -> List[Dict[str, Any]]:
|
|
"""获取模板分类统计"""
|
|
conditions = [cls.model.is_deleted == False]
|
|
# 子应用过滤
|
|
if application_id:
|
|
conditions.append(cls.model.application_id == application_id)
|
|
else:
|
|
conditions.append(cls.model.application_id.is_(None))
|
|
|
|
stmt = (
|
|
select(cls.model.category, func.count(cls.model.id).label("count"))
|
|
.where(and_(*conditions))
|
|
.group_by(cls.model.category)
|
|
)
|
|
result = await db.execute(stmt)
|
|
rows = result.all()
|
|
|
|
category_labels = {
|
|
"leave": "请假单",
|
|
"expense": "报销单",
|
|
"purchase": "采购单",
|
|
"contract": "合同",
|
|
"certificate": "证明",
|
|
"other": "其他",
|
|
}
|
|
|
|
return [
|
|
{
|
|
"value": row.category,
|
|
"label": category_labels.get(row.category, row.category),
|
|
"count": row.count,
|
|
}
|
|
for row in rows
|
|
]
|
|
|
|
@staticmethod
|
|
def _template_to_export_dict(template: DocumentTemplate) -> Dict[str, Any]:
|
|
"""将模板转为可导出的 JSON 结构"""
|
|
return {
|
|
"name": template.name,
|
|
"code": template.code,
|
|
"category": template.category or "other",
|
|
"description": template.description or "",
|
|
"form_code": template.form_code,
|
|
"workflow_code": template.workflow_code,
|
|
"template_type": template.template_type or "designer",
|
|
"template_content": template.template_content,
|
|
"template_css": template.template_css,
|
|
"page_size": template.page_size or "A4",
|
|
"page_orientation": template.page_orientation or "portrait",
|
|
"page_margin": template.page_margin,
|
|
"watermark_enabled": template.watermark_enabled or False,
|
|
"watermark_text": template.watermark_text,
|
|
"watermark_type": template.watermark_type or "text",
|
|
"watermark_image_id": template.watermark_image_id,
|
|
"watermark_opacity": template.watermark_opacity if template.watermark_opacity is not None else 30,
|
|
"watermark_angle": template.watermark_angle if template.watermark_angle is not None else -45,
|
|
"seal_enabled": template.seal_enabled or False,
|
|
"seal_positions": template.seal_positions,
|
|
"header_enabled": template.header_enabled or False,
|
|
"header_template": template.header_template,
|
|
"footer_enabled": template.footer_enabled or False,
|
|
"footer_template": template.footer_template,
|
|
"show_page_number": template.show_page_number if template.show_page_number is not None else True,
|
|
"calculation_rules": template.calculation_rules,
|
|
}
|
|
|
|
@classmethod
|
|
async def export_config(cls, db: AsyncSession, template_id: str) -> Dict[str, Any]:
|
|
"""导出单据模板配置"""
|
|
template = await cls.get_by_id(db, template_id)
|
|
if not template:
|
|
return None
|
|
return cls._template_to_export_dict(template)
|
|
|
|
@classmethod
|
|
async def check_import(cls, db: AsyncSession, code: str) -> Dict[str, Any]:
|
|
"""导入预检查：编码是否冲突"""
|
|
existing = await cls.get_by_code(db, code) if code else None
|
|
code_exists = existing is not None
|
|
return {
|
|
"code_exists": code_exists,
|
|
"can_import": not code_exists,
|
|
}
|
|
|
|
@classmethod
|
|
async def import_config(
|
|
cls,
|
|
db: AsyncSession,
|
|
data: Dict[str, Any],
|
|
) -> DocumentTemplate:
|
|
"""导入单据模板配置（创建新草稿模板）"""
|
|
if not data.get("name") or not data.get("code"):
|
|
raise ValueError("缺少必要字段: name 或 code")
|
|
|
|
existing = await cls.get_by_code(db, data["code"])
|
|
if existing:
|
|
raise ValueError(f"模板编码已存在: {data['code']}")
|
|
|
|
create_data = DocumentTemplateCreate(**data)
|
|
return await cls.create(db, create_data)
|
|
|
|
|
|
class GeneratedDocumentService(BaseService[GeneratedDocument, None, None]):
|
|
"""生成的文档服务"""
|
|
|
|
model = GeneratedDocument
|
|
|
|
@classmethod
|
|
async def get_list(
|
|
cls,
|
|
db: AsyncSession,
|
|
page: int = 1,
|
|
page_size: int = 20,
|
|
template_id: Optional[str] = None,
|
|
form_code: Optional[str] = None,
|
|
form_data_id: Optional[str] = None,
|
|
instance_id: Optional[str] = None,
|
|
generator_id: Optional[str] = None,
|
|
keyword: Optional[str] = None,
|
|
) -> Tuple[List[GeneratedDocument], int]:
|
|
"""获取文档列表"""
|
|
conditions = [cls.model.is_deleted == False]
|
|
|
|
if template_id:
|
|
conditions.append(cls.model.template_id == template_id)
|
|
if form_code:
|
|
conditions.append(cls.model.form_code == form_code)
|
|
if form_data_id:
|
|
conditions.append(cls.model.form_data_id == form_data_id)
|
|
if instance_id:
|
|
conditions.append(cls.model.instance_id == instance_id)
|
|
if generator_id:
|
|
conditions.append(cls.model.generator_id == generator_id)
|
|
if keyword:
|
|
conditions.append(
|
|
or_(
|
|
cls.model.document_name.ilike(f"%{keyword}%"),
|
|
cls.model.document_no.ilike(f"%{keyword}%"),
|
|
)
|
|
)
|
|
|
|
# 查询总数
|
|
count_stmt = select(func.count()).select_from(cls.model).where(and_(*conditions))
|
|
total = (await db.execute(count_stmt)).scalar() or 0
|
|
|
|
# 查询列表
|
|
stmt = (
|
|
select(cls.model)
|
|
.where(and_(*conditions))
|
|
.order_by(cls.model.sys_create_datetime.desc())
|
|
.offset((page - 1) * page_size)
|
|
.limit(page_size)
|
|
)
|
|
result = await db.execute(stmt)
|
|
items = list(result.scalars().all())
|
|
|
|
return items, total
|
|
|
|
@classmethod
|
|
async def get_by_instance_id(
|
|
cls,
|
|
db: AsyncSession,
|
|
instance_id: str,
|
|
) -> List[GeneratedDocument]:
|
|
"""根据流程实例ID获取文档列表"""
|
|
stmt = (
|
|
select(cls.model)
|
|
.where(
|
|
and_(
|
|
cls.model.instance_id == instance_id,
|
|
cls.model.is_deleted == False,
|
|
)
|
|
)
|
|
.order_by(cls.model.sys_create_datetime.desc())
|
|
)
|
|
result = await db.execute(stmt)
|
|
return list(result.scalars().all())
|
|
|
|
@classmethod
|
|
async def get_by_template_and_form_data(
|
|
cls,
|
|
db: AsyncSession,
|
|
template_id: str,
|
|
form_data_id: str,
|
|
) -> List[GeneratedDocument]:
|
|
"""根据模板ID和表单数据ID获取文档列表"""
|
|
stmt = (
|
|
select(cls.model)
|
|
.where(
|
|
and_(
|
|
cls.model.template_id == template_id,
|
|
cls.model.form_data_id == form_data_id,
|
|
cls.model.is_deleted == False,
|
|
)
|
|
)
|
|
.order_by(cls.model.sys_create_datetime.desc())
|
|
)
|
|
result = await db.execute(stmt)
|
|
return list(result.scalars().all())
|
|
|
|
@classmethod
|
|
async def create_document(
|
|
cls,
|
|
db: AsyncSession,
|
|
template: DocumentTemplate,
|
|
file_id: str,
|
|
file_size: int,
|
|
page_count: int,
|
|
document_name: str,
|
|
form_data_id: Optional[str] = None,
|
|
instance_id: Optional[str] = None,
|
|
generator_id: Optional[str] = None,
|
|
generator_name: Optional[str] = None,
|
|
generate_type: str = "manual",
|
|
) -> GeneratedDocument:
|
|
"""创建文档记录"""
|
|
# 生成文档编号
|
|
today = date.today()
|
|
document_no = f"DOC{today.strftime('%Y%m%d')}{datetime.now().strftime('%H%M%S%f')[:10]}"
|
|
|
|
document = GeneratedDocument(
|
|
template_id=template.id,
|
|
template_code=template.code,
|
|
template_name=template.name,
|
|
form_code=template.form_code,
|
|
form_data_id=form_data_id,
|
|
workflow_code=template.workflow_code,
|
|
instance_id=instance_id,
|
|
document_name=document_name,
|
|
document_no=document_no,
|
|
file_id=file_id,
|
|
file_size=file_size,
|
|
page_count=page_count,
|
|
generate_type=generate_type,
|
|
generator_id=generator_id,
|
|
generator_name=generator_name,
|
|
status="generated",
|
|
)
|
|
|
|
db.add(document)
|
|
await db.commit()
|
|
await db.refresh(document)
|
|
return document
|
|
|
|
@classmethod
|
|
async def increment_download_count(cls, db: AsyncSession, document_id: str) -> None:
|
|
"""增加下载次数"""
|
|
document = await cls.get_by_id(db, document_id)
|
|
if document:
|
|
document.download_count += 1
|
|
document.status = "downloaded"
|
|
await db.commit()
|
|
|
|
@classmethod
|
|
async def mark_sealed(
|
|
cls,
|
|
db: AsyncSession,
|
|
document_id: str,
|
|
seal_info: Dict[str, Any]
|
|
) -> Optional[GeneratedDocument]:
|
|
"""标记已盖章"""
|
|
document = await cls.get_by_id(db, document_id)
|
|
if not document:
|
|
return None
|
|
|
|
document.sealed = True
|
|
document.seal_info = seal_info
|
|
document.status = "sealed"
|
|
await db.commit()
|
|
await db.refresh(document)
|
|
return document
|
|
|
|
|