905 lines
42 KiB
Python
905 lines
42 KiB
Python
"""项目主档:列表、详情、创建、成员、阶段、删除与恢复。
|
||
|
||
列表一律先过数据权限再分页,计数也用同一个条件,否则会出现"总数 500 但只列得出来 3 条"。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
from datetime import date, datetime
|
||
from typing import Any
|
||
|
||
from fastapi import APIRouter, Query, Request
|
||
from pydantic import BaseModel, Field
|
||
from sqlalchemy import func, or_, select
|
||
|
||
from .. import dicts as dict_store
|
||
from ..deps import DbSession, Principal, PrincipalOf, assert_project_visible
|
||
from ..envelope import conflict, forbidden, not_found, ok, page
|
||
from ..models import (
|
||
Account,
|
||
ApprovalInstance,
|
||
ApprovalRecord,
|
||
Attachment,
|
||
BudgetFundMonth,
|
||
BudgetIncomeLine,
|
||
BudgetIncomePlanLine,
|
||
BudgetManageLine,
|
||
BudgetOtherCostLine,
|
||
BudgetPayPlanLine,
|
||
BudgetPurchaseLine,
|
||
CalcSnapshot,
|
||
EstimateCostLine,
|
||
EstimateIncomeLine,
|
||
EstimateOtherLine,
|
||
InstanceStatus,
|
||
Project,
|
||
ProjectMember,
|
||
ProjectMemberRole,
|
||
ProjectSource,
|
||
ProjectStage,
|
||
ProjectStageLog,
|
||
SaleStage,
|
||
ProjectVisibleRole,
|
||
Revision,
|
||
RevisionModule,
|
||
RevisionStatus,
|
||
to_decimal,
|
||
)
|
||
from ..service import audit, biz
|
||
from ..service.calc.money import money_str
|
||
|
||
router = APIRouter(prefix="/projects", tags=["projects"])
|
||
|
||
|
||
class ProjectBody(BaseModel):
|
||
name: str = Field(min_length=1, max_length=1000)
|
||
otherName: str = ""
|
||
type: int = 0
|
||
projectNo: str = ""
|
||
customer: str = ""
|
||
terminalCustomer: str = ""
|
||
planStart: str = ""
|
||
planEnd: str = ""
|
||
contractTime: str = ""
|
||
bidsTime: str = ""
|
||
underwrittenMode: int | None = None
|
||
cooperateType: int | None = None
|
||
collaborator: str = ""
|
||
certainty: int | None = None
|
||
isSecond: int | None = None
|
||
isHuizhiBid: int | None = None
|
||
saleStage: int | None = None
|
||
stage: int | None = None
|
||
signType: int | None = None
|
||
resolvePlan: int | None = None
|
||
industryScene: int = 0
|
||
industrySceneDesc: str = ""
|
||
principalId: int | None = None
|
||
mainContractCollectionTerms: str = ""
|
||
mainContractResolvePlan: str = ""
|
||
calculationCollection: str = ""
|
||
valueRisk: str = ""
|
||
advanceInterestRate: str = ""
|
||
stageRemark: str = ""
|
||
nextPlan: str = ""
|
||
memberIds: list[int] = Field(default_factory=list)
|
||
# 立项表上可以直接录入的金额。录了测算明细之后,这几个数改由计算投影覆盖
|
||
# (见 biz.apply_projection:有明细行才投影),手填值只在没明细时生效。
|
||
contractAmount: str = ""
|
||
grossProfit: str = ""
|
||
grossProfitRate: str = ""
|
||
huizhiAmount: str = ""
|
||
huazhiAmount: str = ""
|
||
h3cAmount: str = ""
|
||
otherProductAmount: str = ""
|
||
|
||
|
||
class MemberBody(BaseModel):
|
||
accountIds: list[int] = Field(default_factory=list)
|
||
memberRole: str = ProjectMemberRole.PARTICIPANT
|
||
|
||
|
||
@router.get("")
|
||
def list_projects(
|
||
db: DbSession,
|
||
current: PrincipalOf,
|
||
keyword: str = "",
|
||
type: int | None = None,
|
||
stage: int | None = None,
|
||
orgUnitId: int | None = None,
|
||
underwrittenMode: int | None = None,
|
||
initiationStatus: str = "",
|
||
onlyMine: bool = False,
|
||
deletedOnly: bool = False,
|
||
pageNo: int = Query(1, ge=1),
|
||
pageSize: int = Query(20, ge=1, le=200),
|
||
orderBy: str = "-updated_at",
|
||
) -> dict[str, Any]:
|
||
if not current.permission.can_any(("project:project:view", "project:project:edit")):
|
||
raise forbidden("缺少权限:project:project:view")
|
||
|
||
from ..service.data_scope import descendant_unit_ids, evaluate
|
||
|
||
# deletedOnly 是回收站:同一个数据权限条件,只把"有效/已删除"这一维翻过来,
|
||
# 不能因为换了个视图就让人看到别人删掉的项目。
|
||
statement = select(Project).where(
|
||
Project.is_deleted.is_(True) if deletedOnly else Project.is_deleted.is_(False)
|
||
)
|
||
decision = evaluate(db, "project", current.scope)
|
||
statement = decision.apply_to(statement)
|
||
|
||
if keyword:
|
||
like = f"%{keyword}%"
|
||
statement = statement.where(or_(Project.name.like(like), Project.project_no.like(like),
|
||
Project.customer.like(like), Project.other_name.like(like)))
|
||
if type is not None:
|
||
statement = statement.where(Project.type == type)
|
||
if stage is not None:
|
||
statement = statement.where(Project.stage == stage)
|
||
if orgUnitId:
|
||
statement = statement.where(Project.org_unit_id.in_(descendant_unit_ids(db, [orgUnitId])))
|
||
if underwrittenMode is not None:
|
||
statement = statement.where(Project.underwritten_mode == underwrittenMode)
|
||
if onlyMine:
|
||
statement = statement.where(or_(
|
||
Project.creator_id == current.account.id,
|
||
Project.principal_id == current.account.id,
|
||
Project.id.in_(select(ProjectMember.project_id).where(
|
||
ProjectMember.account_id == current.account.id)),
|
||
))
|
||
if initiationStatus:
|
||
# 两个模块列表共用这一条查询:立项列表看全部,预算列表看 approved。
|
||
# "none" 是还没建过立项版本的项目——老系统迁过来的八百多个项目就是这么一大片,
|
||
# 新系统里它们算"还没立项",得能在界面上筛出来。
|
||
wanted = [item.strip() for item in initiationStatus.split(",") if item.strip()]
|
||
if "none" in wanted:
|
||
statement = statement.where(Project.id.notin_(
|
||
select(Revision.project_id).where(Revision.module == RevisionModule.ESTIMATE,
|
||
Revision.is_deleted.is_(False))))
|
||
else:
|
||
statement = statement.where(Project.id.in_(
|
||
select(Revision.project_id).where(
|
||
Revision.module == RevisionModule.ESTIMATE,
|
||
Revision.is_deleted.is_(False),
|
||
Revision.status.in_([item for item in wanted if item != "none"]))))
|
||
|
||
total = db.execute(select(func.count()).select_from(statement.subquery())).scalar() or 0
|
||
order_column = _order_column(orderBy)
|
||
rows = db.execute(statement.order_by(order_column).offset((pageNo - 1) * pageSize).limit(pageSize)
|
||
).scalars().all()
|
||
states = _initiation_states(db, [row.id for row in rows])
|
||
result = page([_project_view(db, row, states.get(row.id)) for row in rows], total, pageNo, pageSize)
|
||
# 把"你看到的是哪个范围"一起返回,用户不用猜为什么少了几条
|
||
result["data"]["scope"] = decision.to_dict()
|
||
return result
|
||
|
||
|
||
def _order_column(order_by: str):
|
||
mapping = {
|
||
"updated_at": Project.updated_at, "created_at": Project.created_at,
|
||
"contract_amount": Project.contract_amount, "project_no": Project.project_no,
|
||
"contribution_profit_rate": Project.contribution_profit_rate,
|
||
}
|
||
descending = order_by.startswith("-")
|
||
column = mapping.get(order_by.lstrip("-"), Project.updated_at)
|
||
return column.desc() if descending else column.asc()
|
||
|
||
|
||
def _s(value: Any) -> str:
|
||
return money_str(value)
|
||
|
||
|
||
def _t(value: datetime | None) -> str:
|
||
return value.isoformat(sep=" ", timespec="seconds") if value else ""
|
||
|
||
|
||
def _initiation_states(db, project_ids: list[int]) -> dict[int, dict[str, Any]]:
|
||
"""一次把这一页项目的立项状态捞回来。
|
||
|
||
逐行走 :func:`biz.initiation_state` 会变成每行两条 SQL,一页 20 行就是 40 条查询;
|
||
这里改成一条:把这一页项目的立项版本全捞出来,在内存里挑"最近一版"与"最近通过版"。
|
||
"""
|
||
if not project_ids:
|
||
return {}
|
||
rows = db.execute(
|
||
select(Revision.project_id, Revision.id, Revision.version, Revision.status,
|
||
Revision.decided_at)
|
||
.where(Revision.project_id.in_(project_ids), Revision.module == RevisionModule.ESTIMATE,
|
||
Revision.is_deleted.is_(False))
|
||
.order_by(Revision.version.desc())
|
||
).all()
|
||
latest: dict[int, tuple] = {}
|
||
approved: dict[int, tuple] = {}
|
||
for row in rows:
|
||
latest.setdefault(row.project_id, row)
|
||
if row.status == RevisionStatus.APPROVED:
|
||
approved.setdefault(row.project_id, row)
|
||
out: dict[int, dict[str, Any]] = {}
|
||
for project_id in project_ids:
|
||
head, passed = latest.get(project_id), approved.get(project_id)
|
||
out[project_id] = {
|
||
"status": head.status if head else "",
|
||
"statusLabel": dict_store.label(db, "revisionStatus", head.status, head.status) if head else "未立项",
|
||
"version": head.version if head else 0,
|
||
"revisionId": head.id if head else None,
|
||
"approvedVersion": passed.version if passed else 0,
|
||
"approvedRevisionId": passed.id if passed else None,
|
||
"approvedAt": _t(passed.decided_at) if passed else "",
|
||
"budgetReady": passed is not None,
|
||
}
|
||
return out
|
||
|
||
|
||
def _project_view(db, row: Project, initiation: dict[str, Any] | None = None) -> dict[str, Any]:
|
||
return {
|
||
"id": row.id, "projectNo": row.project_no, "name": row.name, "otherName": row.other_name,
|
||
"type": row.type, "stage": row.stage, "stageLabel": row.stage_label,
|
||
"customer": row.customer, "terminalCustomer": row.terminal_customer,
|
||
"orgUnitId": row.org_unit_id, "orgUnitName": row.org_unit_name,
|
||
"creatorId": row.creator_id, "creatorName": row.creator_name,
|
||
"principal": row.principal, "principalId": row.principal_id,
|
||
"underwrittenMode": row.underwritten_mode,
|
||
"contractAmount": _s(row.contract_amount),
|
||
"grossProfitA": _s(row.gross_profit_a), "grossProfitARate": _s(row.gross_profit_a_rate),
|
||
"grossProfit": _s(row.gross_profit), "grossProfitRate": _s(row.gross_profit_rate),
|
||
"contributionProfit": _s(row.contribution_profit),
|
||
"contributionProfitRate": _s(row.contribution_profit_rate),
|
||
"advancePeakAmount": _s(row.advance_peak_value),
|
||
"advancePeakMonth": row.advance_peak_month,
|
||
"advanceInterestAmount": _s(row.advance_interest_amount),
|
||
"calcVersion": row.calc_version,
|
||
"source": row.source,
|
||
"sourceLabel": ProjectSource.LABELS.get(row.source, row.source),
|
||
"saleStage": row.sale_stage,
|
||
"saleStageLabel": dict_store.label(db, "saleStage", row.sale_stage, "未填写"),
|
||
"isHuizhiBid": row.is_huizhi_bid,
|
||
"certainty": row.certainty,
|
||
"certaintyLabel": dict_store.label(db, "certainty", row.certainty, ""),
|
||
"industrySceneLabel": dict_store.label(db, "industryScene", row.industry_scene, ""),
|
||
"initiation": initiation or {},
|
||
"createdAt": _t(row.created_at), "updatedAt": _t(row.updated_at),
|
||
"deletedAt": _t(row.deleted_at), "deletedByName": row.deleted_by_name,
|
||
"deleteReason": row.delete_reason,
|
||
}
|
||
|
||
|
||
def _project_detail(db, row: Project, initiation: dict[str, Any] | None = None) -> dict[str, Any]:
|
||
data = _project_view(db, row, initiation)
|
||
data.update({
|
||
"planStart": row.plan_start.isoformat() if row.plan_start else "",
|
||
"planEnd": row.plan_end.isoformat() if row.plan_end else "",
|
||
"contractTime": _t(row.contract_time), "bidsTime": _t(row.bids_time),
|
||
"cooperateType": row.cooperate_type, "collaborator": row.collaborator,
|
||
"collaboratorAttachment": row.collaborator_attachment,
|
||
"certainty": row.certainty, "isSecond": row.is_second, "signType": row.sign_type,
|
||
"isHuizhiBid": row.is_huizhi_bid,
|
||
"saleStage": row.sale_stage,
|
||
"saleStageLabel": dict_store.label(db, "saleStage", row.sale_stage, "未填写"),
|
||
"certaintyLabel": dict_store.label(db, "certainty", row.certainty, ""),
|
||
"isSecondLabel": dict_store.label(db, "yesNo", row.is_second, ""),
|
||
"isHuizhiBidLabel": dict_store.label(db, "yesNo", row.is_huizhi_bid, ""),
|
||
"industrySceneLabel": dict_store.label(db, "industryScene", row.industry_scene, ""),
|
||
"grossProfit": _s(row.gross_profit), "grossProfitRate": _s(row.gross_profit_rate),
|
||
"resolvePlan": row.resolve_plan, "industryScene": row.industry_scene,
|
||
"industrySceneDesc": row.industry_scene_desc,
|
||
"mainContractCollectionTerms": row.main_contract_collection_terms,
|
||
"mainContractResolvePlan": row.main_contract_resolve_plan,
|
||
"calculationCollection": row.calculation_collection, "valueRisk": row.value_risk,
|
||
"stageRemark": row.stage_remark, "nextPlan": row.next_plan,
|
||
"advanceInterestRate": _s(row.advance_interest_rate),
|
||
"advancePlanTotal": _s(row.advance_plan_total),
|
||
"huazhiAmount": _s(row.huazhi_amount), "huizhiAmount": _s(row.huizhi_amount),
|
||
"h3cAmount": _s(row.h3c_amount), "otherProductAmount": _s(row.other_product_amount),
|
||
"calcSnapshotId": row.calc_snapshot_id, "calcAt": _t(row.calc_at),
|
||
})
|
||
return data
|
||
|
||
|
||
@router.get("/options")
|
||
def project_options(db: DbSession, current: PrincipalOf) -> dict[str, Any]:
|
||
"""项目类型/阶段/垫资模式这些枚举统一从数据字典取,前后端都不再自己抄一份。"""
|
||
return ok({
|
||
"types": dict_store.options(db, "projectType"),
|
||
"stages": dict_store.options(db, "projectStage"),
|
||
"underwrittenModes": dict_store.options(db, "underwrittenMode"),
|
||
"memberRoles": dict_store.options(db, "projectMemberRole"),
|
||
"certainties": dict_store.options(db, "certainty"),
|
||
"industryScenes": dict_store.options(db, "industryScene"),
|
||
"saleStages": dict_store.options(db, "saleStage"),
|
||
"yesNo": dict_store.options(db, "yesNo"),
|
||
})
|
||
|
||
|
||
@router.post("")
|
||
def create_project(body: ProjectBody, request: Request, db: DbSession,
|
||
current: PrincipalOf) -> dict[str, Any]:
|
||
if not current.permission.can("project:project:create"):
|
||
raise forbidden("缺少权限:project:project:create")
|
||
account = current.account
|
||
unit = account.org_unit
|
||
project = Project(
|
||
name=body.name, other_name=body.otherName, type=body.type or 0,
|
||
project_no=body.projectNo.strip() or next_project_no(db),
|
||
creator_id=account.id, creator_name=account.display_name or account.account,
|
||
org_unit_id=account.org_unit_id, org_unit_name=unit.name if unit else "",
|
||
stage=body.stage if body.stage in ProjectStage.LABELS else ProjectStage.S0_INITIATION,
|
||
customer=body.customer, terminal_customer=body.terminalCustomer,
|
||
plan_start=_date(body.planStart), plan_end=_date(body.planEnd),
|
||
contract_time=_datetime(body.contractTime), bids_time=_datetime(body.bidsTime),
|
||
underwritten_mode=body.underwrittenMode, cooperate_type=body.cooperateType,
|
||
collaborator=body.collaborator, certainty=body.certainty, is_second=body.isSecond,
|
||
is_huizhi_bid=body.isHuizhiBid, sale_stage=body.saleStage
|
||
if body.saleStage is not None else SaleStage.UNSET,
|
||
sign_type=body.signType, resolve_plan=body.resolvePlan,
|
||
industry_scene=body.industryScene or 0, industry_scene_desc=body.industrySceneDesc,
|
||
principal_id=body.principalId or account.id,
|
||
main_contract_collection_terms=body.mainContractCollectionTerms,
|
||
main_contract_resolve_plan=body.mainContractResolvePlan,
|
||
calculation_collection=body.calculationCollection, value_risk=body.valueRisk,
|
||
advance_interest_rate=to_decimal(body.advanceInterestRate),
|
||
stage_remark=body.stageRemark, next_plan=body.nextPlan,
|
||
source=ProjectSource.LOCAL,
|
||
)
|
||
_apply_manual_amounts(project, body)
|
||
# 负责人没点名就是创建人:姓名与账号一起落,别只留 principal_id。
|
||
# 只留 id 会让主档上那一列一直是空串,立项表的"项目负责人"必填就永远卡着,
|
||
# 列表页那列也是空的。
|
||
if not project.principal and project.principal_id:
|
||
owner = account if project.principal_id == account.id else db.get(Account, project.principal_id)
|
||
project.principal = (owner.display_name or owner.account) if owner else ""
|
||
db.add(project)
|
||
db.flush()
|
||
# 负责人没点名就是创建人:姓名与账号一起落,别只留 principal_id——
|
||
# 主档那列空着,立项表的"项目负责人"必填就永远卡着,列表页这一列也是空的。
|
||
if project.principal_id and not project.principal:
|
||
owner = account if project.principal_id == account.id else db.get(Account, project.principal_id)
|
||
if owner is not None:
|
||
project.principal = owner.display_name or owner.account
|
||
|
||
# 负责人先落成员表(sync_owner_member 内部会去重),创建人只有在不是负责人时才另记一条,
|
||
# 否则同一个人会被插两次,撞上 uk_project_member 唯一键。
|
||
biz.sync_owner_member(db, project)
|
||
member_ids = {account.id} | set(body.memberIds or [])
|
||
if project.principal_id:
|
||
member_ids.add(project.principal_id)
|
||
existing_members = {project.principal_id} if project.principal_id else set()
|
||
for account_id in member_ids:
|
||
if account_id in existing_members:
|
||
continue
|
||
target = account if account_id == account.id else db.get(Account, account_id)
|
||
if target is None or target.is_deleted:
|
||
continue
|
||
db.add(ProjectMember(project_id=project.id, account_id=account_id,
|
||
account_name=target.display_name or target.account,
|
||
member_role=ProjectMemberRole.PARTICIPANT))
|
||
existing_members.add(account_id)
|
||
db.add(ProjectStageLog(project_id=project.id, stage=project.stage, stage_label=project.stage_label,
|
||
account_id=account.id, account_name=account.display_name or account.account,
|
||
remark="创建项目"))
|
||
db.commit()
|
||
audit.enrich(request, object_name=project.name, projectNo=project.project_no)
|
||
return ok({"id": project.id})
|
||
|
||
|
||
def next_project_no(db) -> str:
|
||
"""生成项目编号:``前缀 + 年份 + 当年四位流水``(例:FS26-0007)。
|
||
|
||
立项表上这一栏写的是"保存后默认提供",所以编号得在保存那一刻就有,不能指望
|
||
事后再补。取当年已有最大流水 +1,不锁表:两个人同时建项目撞上同一个号的概率
|
||
极低,真撞了 ``uk_project_no``……库里并没有这个唯一键,所以这里只做一次存在性
|
||
重试,比加表锁合适。
|
||
"""
|
||
from ..models import SystemConfig
|
||
|
||
prefix = (db.execute(select(SystemConfig.value).where(
|
||
SystemConfig.code == "project.no_prefix")).scalars().first() or "FS").strip() or "FS"
|
||
year = datetime.now().year
|
||
head = f"{prefix}{year % 100:02d}-"
|
||
like = f"{head}%"
|
||
numbers = [int(no[len(head):]) for (no,) in db.execute(
|
||
select(Project.project_no).where(Project.project_no.like(like))
|
||
) if no[len(head):].isdigit()]
|
||
candidate_index = (max(numbers) + 1) if numbers else 1
|
||
existing = {row[0] for row in db.execute(
|
||
select(Project.project_no).where(Project.project_no.like(like))).all()}
|
||
while f"{head}{candidate_index:04d}" in existing:
|
||
candidate_index += 1
|
||
return f"{head}{candidate_index:04d}"
|
||
|
||
|
||
def _apply_manual_amounts(project: Project, body: "ProjectBody") -> None:
|
||
"""立项表上手填的那几个金额。空串表示"这一栏没动",不是"清零"。"""
|
||
pairs = (
|
||
(body.contractAmount, "contract_amount"), (body.grossProfit, "gross_profit"),
|
||
(body.grossProfitRate, "gross_profit_rate"), (body.huizhiAmount, "huizhi_amount"),
|
||
(body.huazhiAmount, "huazhi_amount"), (body.h3cAmount, "h3c_amount"),
|
||
(body.otherProductAmount, "other_product_amount"),
|
||
)
|
||
for text, column in pairs:
|
||
if text not in (None, ""):
|
||
setattr(project, column, to_decimal(text))
|
||
|
||
|
||
def _date(value: str | None) -> date | None:
|
||
if not value:
|
||
return None
|
||
try:
|
||
text = value.strip()
|
||
if len(text) == 7: # 日期选择器可能只给到月(YYYY-MM),补成当月 1 号
|
||
text += "-01"
|
||
return date.fromisoformat(text[:10])
|
||
except ValueError:
|
||
return None
|
||
|
||
|
||
def _datetime(value: str | None) -> datetime | None:
|
||
if not value:
|
||
return None
|
||
try:
|
||
return datetime.fromisoformat(value.strip().replace("Z", ""))
|
||
except ValueError:
|
||
return None
|
||
|
||
|
||
@router.get("/{project_id}")
|
||
def get_project(project_id: int, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
|
||
project = assert_project_visible(db, current, project_id)
|
||
members = db.execute(select(ProjectMember).where(ProjectMember.project_id == project_id)
|
||
.order_by(ProjectMember.id)).scalars().all()
|
||
stage_logs = db.execute(select(ProjectStageLog).where(ProjectStageLog.project_id == project_id)
|
||
.order_by(ProjectStageLog.id.desc())).scalars().all()
|
||
data = _project_detail(db, project, biz.initiation_state(db, project_id))
|
||
data["members"] = [{"id": row.id, "accountId": row.account_id, "accountName": row.account_name,
|
||
"memberRole": row.member_role,
|
||
"memberRoleLabel": dict_store.label(
|
||
db, "projectMemberRole", row.member_role, row.member_role)}
|
||
for row in members]
|
||
data["stageLogs"] = [{"id": row.id, "stage": row.stage, "stageLabel": row.stage_label,
|
||
"accountName": row.account_name, "remark": row.remark,
|
||
"createdAt": _t(row.created_at)} for row in stage_logs]
|
||
return ok(data)
|
||
|
||
|
||
@router.put("/{project_id}")
|
||
def update_project(project_id: int, body: ProjectBody, request: Request, db: DbSession,
|
||
current: PrincipalOf) -> dict[str, Any]:
|
||
project = assert_project_visible(db, current, project_id)
|
||
if not current.permission.can("project:project:edit"):
|
||
raise forbidden("缺少权限:project:project:edit")
|
||
_assert_project_owner(current, project, "修改项目信息")
|
||
|
||
project.name = body.name
|
||
project.other_name = body.otherName
|
||
project.type = body.type or project.type
|
||
project.project_no = body.projectNo
|
||
project.customer = body.customer
|
||
project.terminal_customer = body.terminalCustomer
|
||
project.plan_start = _date(body.planStart)
|
||
project.plan_end = _date(body.planEnd)
|
||
project.contract_time = _datetime(body.contractTime)
|
||
project.bids_time = _datetime(body.bidsTime)
|
||
project.underwritten_mode = body.underwrittenMode
|
||
project.cooperate_type = body.cooperateType
|
||
project.collaborator = body.collaborator
|
||
project.certainty = body.certainty
|
||
project.is_second = body.isSecond
|
||
project.is_huizhi_bid = body.isHuizhiBid
|
||
if body.saleStage is not None:
|
||
project.sale_stage = body.saleStage
|
||
if body.stage in ProjectStage.LABELS:
|
||
project.stage = body.stage
|
||
project.sign_type = body.signType
|
||
project.resolve_plan = body.resolvePlan
|
||
project.industry_scene = body.industryScene or 0
|
||
project.industry_scene_desc = body.industrySceneDesc
|
||
project.main_contract_collection_terms = body.mainContractCollectionTerms
|
||
project.main_contract_resolve_plan = body.mainContractResolvePlan
|
||
project.calculation_collection = body.calculationCollection
|
||
project.value_risk = body.valueRisk
|
||
project.advance_interest_rate = to_decimal(body.advanceInterestRate)
|
||
project.stage_remark = body.stageRemark
|
||
project.next_plan = body.nextPlan
|
||
_apply_manual_amounts(project, body)
|
||
if body.principalId:
|
||
project.principal_id = body.principalId
|
||
owner = db.get(Account, body.principalId)
|
||
project.principal = (owner.display_name or owner.account) if owner else project.principal
|
||
biz.sync_owner_member(db, project)
|
||
db.commit()
|
||
audit.enrich(request, object_name=project.name, projectNo=project.project_no)
|
||
return ok({"id": project.id})
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 删除与恢复:软删除,回收站走同一条数据权限
|
||
# ---------------------------------------------------------------------------
|
||
|
||
#: 合同期及其之后的阶段。删掉这一档的项目要额外提醒一句——合同、结算都挂在上面,
|
||
#: 而"项目丢失"(S9) 虽然编号更靠后,恰恰是最该允许清掉的那类,所以不在这个名单里。
|
||
LATE_STAGES = (ProjectStage.S5_CONTRACT, ProjectStage.S6_DELIVERY,
|
||
ProjectStage.S7_SETTLEMENT, ProjectStage.S8_FINAL)
|
||
|
||
|
||
class DeleteBody(BaseModel):
|
||
reason: str = Field(default="", max_length=500)
|
||
|
||
|
||
def _assert_project_owner(current: Principal, project: Project, action: str) -> None:
|
||
"""主档级改动(改、删、恢复)的归属判定:系统管理员,或创建人、项目负责人。
|
||
|
||
数据权限管"看得见",这条管"动得了"——财务能看全公司项目,不等于能把别人的项目删掉。
|
||
"""
|
||
if not (current.permission.is_system_admin or project.creator_id == current.account.id
|
||
or project.principal_id == current.account.id):
|
||
raise forbidden(f"只有创建人或项目负责人可以{action}")
|
||
|
||
|
||
def _count(db, statement) -> int:
|
||
return db.execute(statement).scalar() or 0
|
||
|
||
|
||
def _delete_report(db, project: Project) -> dict[str, Any]:
|
||
"""删除前的影响面清单。
|
||
|
||
只有**审批还在流转**这一条真挡删除:实例活着、待办挂在别人名下,项目一消失,
|
||
那些人手里就剩一条点不开的待办。已通过的版本、附件、历史审批都只是"连带藏起来",
|
||
恢复即全部回来,所以只列出来让人看清楚,不拦。
|
||
"""
|
||
revision_statuses = db.execute(
|
||
select(Revision.status).where(Revision.project_id == project.id,
|
||
Revision.is_deleted.is_(False))
|
||
).scalars().all()
|
||
approved = sum(1 for status in revision_statuses if status == RevisionStatus.APPROVED)
|
||
reviewing = _count(db, select(func.count(ApprovalInstance.id)).where(
|
||
ApprovalInstance.project_id == project.id,
|
||
ApprovalInstance.status == InstanceStatus.REVIEWING))
|
||
instances = _count(db, select(func.count(ApprovalInstance.id)).where(
|
||
ApprovalInstance.project_id == project.id))
|
||
attachments = _count(db, select(func.count(Attachment.id)).where(
|
||
Attachment.object_id == project.id, Attachment.is_deleted.is_(False)))
|
||
members = _count(db, select(func.count(ProjectMember.id)).where(
|
||
ProjectMember.project_id == project.id))
|
||
|
||
blockers: list[dict[str, str]] = []
|
||
warnings: list[dict[str, str]] = []
|
||
if reviewing:
|
||
blockers.append({
|
||
"code": "approval_in_progress",
|
||
"message": f"有 {reviewing} 个审批正在流转,请先撤回送审或等审批出结果",
|
||
})
|
||
if approved:
|
||
warnings.append({
|
||
"code": "has_approved_revision",
|
||
"message": f"已有 {approved} 个审批通过的版本,删除后这些口径在列表里查不到",
|
||
})
|
||
if project.stage in LATE_STAGES:
|
||
warnings.append({
|
||
"code": "late_stage",
|
||
"message": f"项目已进入「{project.stage_label}」,删除前请确认合同与结算已经了结",
|
||
})
|
||
if attachments:
|
||
warnings.append({"code": "has_attachment",
|
||
"message": f"项目还挂着 {attachments} 个附件"})
|
||
if instances and not reviewing:
|
||
warnings.append({"code": "has_approval_history",
|
||
"message": f"有 {instances} 条历史审批记录"})
|
||
|
||
return {
|
||
"projectName": project.name, "projectNo": project.project_no,
|
||
"stage": project.stage, "stageLabel": project.stage_label,
|
||
"deletable": not blockers, "blockers": blockers, "warnings": warnings,
|
||
"stats": {
|
||
"members": members, "attachments": attachments,
|
||
"revisions": len(revision_statuses), "approvedRevisions": approved,
|
||
"approvalInstances": instances, "reviewingInstances": reviewing,
|
||
},
|
||
}
|
||
|
||
|
||
@router.get("/{project_id}/delete-check")
|
||
def check_project_deletion(project_id: int, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
|
||
"""删除确认框要显示的东西:能不能删、牵连多少。前端不自己猜规则。"""
|
||
project = assert_project_visible(db, current, project_id)
|
||
_assert_project_owner(current, project, "删除项目")
|
||
return ok(_delete_report(db, project))
|
||
|
||
|
||
@router.delete("/{project_id}")
|
||
def delete_project(project_id: int, request: Request, db: DbSession, current: PrincipalOf,
|
||
body: DeleteBody | None = None) -> dict[str, Any]:
|
||
"""软删除。项目连同概算、预算、成员、附件一起从业务视图里消失,数据一行不少。"""
|
||
project = assert_project_visible(db, current, project_id)
|
||
if not current.permission.can("project:project:delete"):
|
||
raise forbidden("缺少权限:project:project:delete")
|
||
_assert_project_owner(current, project, "删除项目")
|
||
report = _delete_report(db, project)
|
||
if report["blockers"]:
|
||
first = report["blockers"][0]
|
||
raise conflict(first["code"], first["message"])
|
||
|
||
reason = (body.reason.strip() if body else "")[:500]
|
||
project.is_deleted = True
|
||
project.deleted_at = datetime.now()
|
||
project.deleted_by_id = current.account.id
|
||
project.deleted_by_name = current.account.display_name or current.account.account
|
||
project.delete_reason = reason
|
||
# 审计行由中间件统一写;这里只补"为什么删"和业务口径,不另开一条。
|
||
audit.enrich(request, action="delete", object_name=project.name, reason=reason,
|
||
stage=project.stage, stageLabel=project.stage_label,
|
||
projectNo=project.project_no, stats=report["stats"])
|
||
db.commit()
|
||
return ok({"deleted": True, "id": project.id, "deletedAt": _t(project.deleted_at)})
|
||
|
||
|
||
@router.post("/{project_id}/restore")
|
||
def restore_project(project_id: int, request: Request, db: DbSession,
|
||
current: PrincipalOf) -> dict[str, Any]:
|
||
"""回收站里捞回来。删除留痕一并清掉,别拿上一次的原因冒充这一次的。"""
|
||
project = assert_project_visible(db, current, project_id, allow_deleted=True)
|
||
if not project.is_deleted:
|
||
raise conflict("not_deleted", "这个项目没有被删除")
|
||
if not current.permission.can("project:project:delete"):
|
||
raise forbidden("缺少权限:project:project:delete")
|
||
_assert_project_owner(current, project, "恢复项目")
|
||
|
||
previous_reason = project.delete_reason
|
||
project.is_deleted = False
|
||
project.deleted_at = None
|
||
project.deleted_by_id = None
|
||
project.deleted_by_name = ""
|
||
project.delete_reason = ""
|
||
audit.enrich(request, action="restore", object_name=project.name,
|
||
previousDeleteReason=previous_reason)
|
||
db.commit()
|
||
return ok({"restored": True, "id": project.id})
|
||
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 彻底删除:把回收站里的项目连同业务数据一起销毁,不可恢复
|
||
# ---------------------------------------------------------------------------
|
||
|
||
#: 销毁顺序(叶子在前)与界面上的说法。不依赖 MySQL 的外键级联:级联是这台库的配置,
|
||
#: 不是这套代码的约束,写清楚每张表既能在任何后端删干净,也能把"删了多少"讲明白。
|
||
PURGE_PLAN: tuple[tuple[str, tuple[type, ...]], ...] = (
|
||
("概算明细", (EstimateIncomeLine, EstimateCostLine, EstimateOtherLine)),
|
||
("预算明细", (BudgetIncomeLine, BudgetIncomePlanLine, BudgetPurchaseLine,
|
||
BudgetPayPlanLine, BudgetManageLine, BudgetOtherCostLine, BudgetFundMonth)),
|
||
("计算快照", (CalcSnapshot,)),
|
||
("概算/预算版本", (Revision,)),
|
||
("项目成员", (ProjectMember,)),
|
||
("可见角色授权", (ProjectVisibleRole,)),
|
||
("阶段流水", (ProjectStageLog,)),
|
||
)
|
||
|
||
#: 附件是按 (object_type, object_id) 挂的多态表,只认项目这一族的挂法;
|
||
#: 回收站/项目页能列出来的附件,和这里要销毁的附件,必须是同一批。
|
||
PROJECT_ATTACHMENT_TYPES = ("project", "estimate", "budget", "settlement", "final")
|
||
|
||
|
||
class PurgeBody(BaseModel):
|
||
confirmName: str = Field(default="", max_length=1000)
|
||
|
||
|
||
def _purge_counts(db, project: Project) -> dict[str, int]:
|
||
"""数一遍销毁会带走多少行;附件按项目的挂点算。"""
|
||
counts = {label: 0 for label, _ in PURGE_PLAN}
|
||
for label, models in PURGE_PLAN:
|
||
for model in models:
|
||
counts[label] += _count(db, select(func.count(model.id)).where(
|
||
model.project_id == project.id))
|
||
counts["审批记录"] = _count(db, select(func.count(ApprovalRecord.id)).where(
|
||
ApprovalRecord.project_id == project.id))
|
||
counts["附件"] = _count(db, select(func.count(Attachment.id)).where(
|
||
Attachment.object_id == project.id,
|
||
Attachment.object_type.in_(PROJECT_ATTACHMENT_TYPES)))
|
||
return counts
|
||
|
||
|
||
def _purge_blockers(db, project: Project) -> list[dict[str, str]]:
|
||
blockers: list[dict[str, str]] = []
|
||
if not project.is_deleted:
|
||
blockers.append({
|
||
"code": "not_in_bin",
|
||
"message": "只能销毁回收站里的项目,请先删除再彻底删除",
|
||
})
|
||
instances = _count(db, select(func.count(ApprovalInstance.id)).where(
|
||
ApprovalInstance.project_id == project.id))
|
||
records = _count(db, select(func.count(ApprovalRecord.id)).where(
|
||
ApprovalRecord.project_id == project.id))
|
||
if instances or records:
|
||
# 审批留痕是合规资产:谁批的、什么时候批的、按什么数批的。项目可以作废,
|
||
# 这条链不能跟着销毁,否则审计就断在"曾经有个项目批过 800 万但查不到了"。
|
||
blockers.append({
|
||
"code": "has_approval_history",
|
||
"message": f"项目留有审批痕迹({instances} 个实例 / {records} 条记录),"
|
||
"按审计要求不能物理销毁,请保留在回收站",
|
||
})
|
||
return blockers
|
||
|
||
|
||
def _assert_project_purgable(db, current: Principal, project: Project) -> list[dict[str, str]]:
|
||
if not current.permission.can("project:project:purge"):
|
||
raise forbidden("缺少权限:project:project:purge")
|
||
_assert_project_owner(current, project, "彻底删除项目")
|
||
blockers = _purge_blockers(db, project)
|
||
if blockers:
|
||
first = blockers[0]
|
||
raise conflict(first["code"], first["message"])
|
||
return blockers
|
||
|
||
|
||
@router.get("/{project_id}/purge-check")
|
||
def check_project_purge(project_id: int, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
|
||
"""彻底删除前把"会毁掉什么"和要回敲的确认词一起给出去。"""
|
||
project = assert_project_visible(db, current, project_id, allow_deleted=True)
|
||
if not current.permission.can("project:project:purge"):
|
||
raise forbidden("缺少权限:project:project:purge")
|
||
_assert_project_owner(current, project, "彻底删除项目")
|
||
blockers = _purge_blockers(db, project)
|
||
return ok({
|
||
"projectName": project.name, "projectNo": project.project_no,
|
||
"deletedAt": _t(project.deleted_at), "deletedByName": project.deleted_by_name,
|
||
"deletable": not blockers, "blockers": blockers,
|
||
"confirmName": project.project_no or project.name,
|
||
"counts": _purge_counts(db, project),
|
||
})
|
||
|
||
|
||
@router.delete("/{project_id}/purge")
|
||
def purge_project(project_id: int, request: Request, db: DbSession, current: PrincipalOf,
|
||
body: PurgeBody | None = None) -> dict[str, Any]:
|
||
"""物理销毁。执行完只剩审计行,业务数据一行不剩,没有回头路。"""
|
||
project = assert_project_visible(db, current, project_id, allow_deleted=True)
|
||
_assert_project_purgable(db, current, project)
|
||
wanted = (project.project_no or project.name).strip()
|
||
if (body.confirmName if body else "").strip() != wanted:
|
||
raise conflict("confirm_mismatch", f"请输入项目编号「{wanted}」确认销毁")
|
||
|
||
# 销毁之前先把现场留进审计:这条日志是这件事在这个世界上剩下的唯一痕迹。
|
||
counts = _purge_counts(db, project)
|
||
snapshot = {
|
||
"projectNo": project.project_no, "name": project.name, "stage": project.stage,
|
||
"stageLabel": project.stage_label, "creatorName": project.creator_name,
|
||
"orgUnitName": project.org_unit_name, "principal": project.principal,
|
||
"contractAmount": money_str(project.contract_amount),
|
||
"deletedAt": _t(project.deleted_at), "deletedByName": project.deleted_by_name,
|
||
"deleteReason": project.delete_reason, "destroyed": counts,
|
||
}
|
||
|
||
for _, models in PURGE_PLAN:
|
||
for model in models:
|
||
db.query(model).filter(model.project_id == project.id).delete(
|
||
synchronize_session=False)
|
||
db.query(Attachment).filter(
|
||
Attachment.object_id == project.id,
|
||
Attachment.object_type.in_(PROJECT_ATTACHMENT_TYPES)).delete(synchronize_session=False)
|
||
db.query(Project).filter(Project.id == project.id).delete(synchronize_session=False)
|
||
audit.enrich(request, action="purge", object_name=snapshot["name"], **snapshot)
|
||
db.commit()
|
||
return ok({"purged": True, "id": project_id, "destroyed": counts})
|
||
|
||
class StageBody(BaseModel):
|
||
stage: int
|
||
remark: str = ""
|
||
|
||
|
||
@router.post("/{project_id}/stage")
|
||
def change_stage(project_id: int, body: StageBody, request: Request, *, db: DbSession,
|
||
current: PrincipalOf) -> dict[str, Any]:
|
||
stage = body.stage
|
||
project = assert_project_visible(db, current, project_id)
|
||
if not current.permission.can("project:project:edit"):
|
||
raise forbidden("缺少权限:project:project:edit")
|
||
if stage not in ProjectStage.LABELS:
|
||
raise conflict("unknown_stage", f"未知的项目阶段:{stage}")
|
||
biz.set_project_stage(db, project, stage, current.account, body.remark)
|
||
audit.enrich(request, object_name=project.name, stage=stage,
|
||
stageLabel=project.stage_label, remark=body.remark)
|
||
db.commit()
|
||
return ok({"stage": stage,
|
||
"stageLabel": dict_store.label(db, "projectStage", stage,
|
||
ProjectStage.LABELS[stage])})
|
||
|
||
|
||
@router.get("/{project_id}/members")
|
||
def list_members(project_id: int, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
|
||
assert_project_visible(db, current, project_id)
|
||
rows = db.execute(select(ProjectMember).where(ProjectMember.project_id == project_id)
|
||
.order_by(ProjectMember.id)).scalars().all()
|
||
return ok([{"id": row.id, "accountId": row.account_id, "accountName": row.account_name,
|
||
"memberRole": row.member_role,
|
||
"memberRoleLabel": dict_store.label(
|
||
db, "projectMemberRole", row.member_role, row.member_role)}
|
||
for row in rows])
|
||
|
||
|
||
@router.post("/{project_id}/members")
|
||
def add_members(project_id: int, body: MemberBody, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
|
||
assert_project_visible(db, current, project_id)
|
||
if not current.permission.can("project:project:edit"):
|
||
raise forbidden("缺少权限:project:project:edit")
|
||
existing = set(db.execute(select(ProjectMember.account_id).where(
|
||
ProjectMember.project_id == project_id)).scalars().all())
|
||
added = 0
|
||
for account_id in body.accountIds or []:
|
||
if account_id in existing:
|
||
continue
|
||
target = db.get(Account, account_id)
|
||
if target is None or target.is_deleted:
|
||
continue
|
||
db.add(ProjectMember(project_id=project_id, account_id=account_id,
|
||
account_name=target.display_name or target.account,
|
||
member_role=body.memberRole))
|
||
added += 1
|
||
db.commit()
|
||
return ok({"added": added, "projectId": project_id})
|
||
|
||
|
||
@router.delete("/{project_id}/members/{account_id}")
|
||
def remove_member(project_id: int, account_id: int, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
|
||
assert_project_visible(db, current, project_id)
|
||
if not current.permission.can("project:project:edit"):
|
||
raise forbidden("缺少权限:project:project:edit")
|
||
row = db.execute(select(ProjectMember).where(
|
||
ProjectMember.project_id == project_id, ProjectMember.account_id == account_id
|
||
)).scalars().first()
|
||
if row is None:
|
||
raise not_found("该成员不在项目里")
|
||
if row.member_role == ProjectMemberRole.OWNER:
|
||
raise conflict("owner_protected", "项目负责人不能移除,请先移交项目负责人")
|
||
db.delete(row)
|
||
db.commit()
|
||
return ok({"deleted": True})
|
||
|
||
|
||
@router.get("/{project_id}/visible-roles")
|
||
def list_visible_roles(project_id: int, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
|
||
assert_project_visible(db, current, project_id)
|
||
from ..models import PermRole
|
||
|
||
rows = db.execute(select(ProjectVisibleRole).where(
|
||
ProjectVisibleRole.project_id == project_id)).scalars().all()
|
||
roles = dict(db.execute(select(PermRole.id, PermRole.name)).all())
|
||
return ok([{"id": row.id, "roleId": row.role_id, "roleName": roles.get(row.role_id, "")} for row in rows])
|
||
|
||
|
||
class VisibleRoleBody(BaseModel):
|
||
roleIds: list[int] = Field(default_factory=list)
|
||
|
||
|
||
@router.put("/{project_id}/visible-roles")
|
||
def set_visible_roles(project_id: int, body: VisibleRoleBody, db: DbSession,
|
||
current: PrincipalOf) -> dict[str, Any]:
|
||
"""逐项目的"哪些角色能看这个项目",兼容老 project_visible 的 type=1。"""
|
||
assert_project_visible(db, current, project_id)
|
||
if not current.permission.can("project:project:edit"):
|
||
raise forbidden("缺少权限:project:project:edit")
|
||
existing = set(db.execute(select(ProjectVisibleRole.role_id).where(
|
||
ProjectVisibleRole.project_id == project_id)).scalars().all())
|
||
wanted = set(body.roleIds or [])
|
||
for role_id in existing - wanted:
|
||
for row in db.execute(select(ProjectVisibleRole).where(
|
||
ProjectVisibleRole.project_id == project_id,
|
||
ProjectVisibleRole.role_id == role_id)).scalars():
|
||
db.delete(row)
|
||
for role_id in wanted - existing:
|
||
db.add(ProjectVisibleRole(project_id=project_id, role_id=role_id))
|
||
db.commit()
|
||
return ok({"count": len(wanted)})
|
||
|
||
|
||
@router.get("/{project_id}/attachments")
|
||
def list_attachments(project_id: int, db: DbSession, current: PrincipalOf,
|
||
objectType: str = "") -> dict[str, Any]:
|
||
assert_project_visible(db, current, project_id)
|
||
statement = select(Attachment).where(Attachment.object_id == project_id,
|
||
Attachment.is_deleted.is_(False))
|
||
if objectType:
|
||
statement = statement.where(Attachment.object_type == objectType)
|
||
rows = db.execute(statement.order_by(Attachment.id.desc())).scalars().all()
|
||
return ok([{"id": row.id, "objectType": row.object_type, "objectId": row.object_id,
|
||
"field": row.field, "fileName": row.file_name, "url": row.url, "size": row.size,
|
||
"ext": row.ext, "uploaderName": row.uploader_name,
|
||
"createdAt": _t(row.created_at)} for row in rows])
|