1117 lines
38 KiB
Go
1117 lines
38 KiB
Go
package logic
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"math/rand"
|
||
"strconv"
|
||
"strings"
|
||
|
||
"github.com/gogf/gf/v2/database/gdb"
|
||
"github.com/gogf/gf/v2/errors/gerror"
|
||
"github.com/gogf/gf/v2/frame/g"
|
||
"github.com/gogf/gf/v2/os/gfile"
|
||
"github.com/gogf/gf/v2/os/gtime"
|
||
|
||
adminv1 "tool-api/api/admin/v1"
|
||
userv1 "tool-api/api/user/v1"
|
||
"tool-api/internal/consts"
|
||
)
|
||
|
||
// ============================================================================
|
||
// 开发项目（迭代-2026-09-30 三期）
|
||
//
|
||
// 后台建单（生成绑定令牌）→ 管理端生成小程序码（wxacode.getUnlimited，
|
||
// scene = "p"+项目id+令牌，落 pkg-service/project-bind）→ 用户扫码绑定；
|
||
// 后台维护阶段 / 小节点 / 交付物（原型、UI 设计稿等图片），用户端只读查看。
|
||
//
|
||
// 关键约定：
|
||
// - 绑定令牌 10 位大写字母数字（去掉易混字符），scene 只含 id+token，不落个人信息；
|
||
// - 项目软删，阶段/节点/交付物跟随项目硬删（管理端内容，无独立保留价值）；
|
||
// - 阶段状态变更 / 交付物上传 / 绑定成功 / 已交付 → 站内信通知绑定用户；
|
||
// - TZ-01：datetime 写库一律 gdb.Raw("NOW()")。
|
||
// ============================================================================
|
||
|
||
// projectBindPage 绑定页（扫码后进入的分包页面），与年会查座码图同一套落盘/静态路由。
|
||
const projectBindPage = "pkg-service/project-bind"
|
||
|
||
// bindTokenChars 去掉易混字符（0/O、1/I/L）的大写字母数字表
|
||
const bindTokenChars = "ABCDEFGHJKMNPQRSTUVWXYZ23456789"
|
||
|
||
func genBindToken() string {
|
||
b := make([]byte, 10)
|
||
for i := range b {
|
||
b[i] = bindTokenChars[rand.Intn(len(bindTokenChars))]
|
||
}
|
||
return string(b)
|
||
}
|
||
|
||
// parseBindScene 小程序码 scene（"p"+id+token）→ token。非法返回空。
|
||
func parseBindScene(scene string) string {
|
||
s := strings.TrimSpace(scene)
|
||
if !strings.HasPrefix(s, "p") {
|
||
return ""
|
||
}
|
||
s = s[1:]
|
||
i := 0
|
||
for i < len(s) && s[i] >= '0' && s[i] <= '9' {
|
||
i++
|
||
}
|
||
token := strings.TrimSpace(s[i:])
|
||
if len(token) < 6 || len(token) > 16 {
|
||
return ""
|
||
}
|
||
return token
|
||
}
|
||
|
||
// projectStageAgg 统计项目可见阶段的总数/已完成数
|
||
func projectStageAgg(ctx context.Context, projectId int64) (total, done int) {
|
||
total, _ = g.Model(consts.TableProjectStages).
|
||
Where("project_id", projectId).Where("is_enabled", 1).Count()
|
||
done, _ = g.Model(consts.TableProjectStages).
|
||
Where("project_id", projectId).Where("is_enabled", 1).Where("status", consts.StageStatusDone).Count()
|
||
return
|
||
}
|
||
|
||
// pushProjectUpdate 项目站内信（尽力而为；userId<=0 即未绑定，不推）
|
||
func pushProjectUpdate(ctx context.Context, userId int64, projectId int64, title, content string) {
|
||
if userId <= 0 {
|
||
return
|
||
}
|
||
PushMessage(ctx, userId, consts.MsgTypeProjectUpdate, title, content,
|
||
fmt.Sprintf("/pkg-service/project-detail?id=%d", projectId))
|
||
}
|
||
|
||
// ============================================================================
|
||
// C 端
|
||
// ============================================================================
|
||
|
||
// ProjectItemOf 列表行 → C 端输出（附阶段进度）
|
||
func projectItemOf(p gdb.Record) userv1.ProjectItem {
|
||
return userv1.ProjectItem{
|
||
Id: p["id"].Int64(),
|
||
Title: p["title"].String(),
|
||
Description: p["description"].String(),
|
||
PriceCents: p["price_cents"].Int64(),
|
||
PriceNote: p["price_note"].String(),
|
||
DueNote: p["due_note"].String(),
|
||
Status: p["status"].Int(),
|
||
StatusText: consts.ProjectStatusNameOf(p["status"].Int()),
|
||
UpdatedAt: timeStr(p["updated_at"].GTime()),
|
||
}
|
||
}
|
||
|
||
// ProjectMine 我的项目（当前用户绑定的，按更新时间倒序）
|
||
func ProjectMine(ctx context.Context) (*userv1.ProjectMineRes, error) {
|
||
records, err := g.Model(consts.TableServiceProjects).
|
||
Where("user_id", CtxUserId(ctx)).
|
||
OrderDesc("id").
|
||
All()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
// 入口图：每个项目取排序最靠前的交付物图片（阶段 sort → 文件 sort）
|
||
ids := make([]int64, 0, len(records))
|
||
for _, p := range records {
|
||
ids = append(ids, p["id"].Int64())
|
||
}
|
||
covers := projectCoverMap(ctx, ids)
|
||
list := make([]userv1.ProjectItem, 0, len(records))
|
||
for _, p := range records {
|
||
item := projectItemOf(p)
|
||
item.StageTotal, item.StageDone = projectStageAgg(ctx, p["id"].Int64())
|
||
item.CoverUrl = covers[p["id"].Int64()]
|
||
list = append(list, item)
|
||
}
|
||
return &userv1.ProjectMineRes{List: list}, nil
|
||
}
|
||
|
||
// projectCoverMap 项目 → 第一张交付物图（按阶段 sort、文件 sort 取最前）。
|
||
func projectCoverMap(ctx context.Context, ids []int64) map[int64]string {
|
||
out := map[int64]string{}
|
||
if len(ids) == 0 {
|
||
return out
|
||
}
|
||
files, err := g.Model(consts.TableProjectFiles+" f").
|
||
LeftJoin(consts.TableProjectStages+" s", "s.id=f.stage_id").
|
||
WhereIn("f.project_id", ids).
|
||
Fields("f.project_id, f.file_path").
|
||
Order("s.sort asc, s.id asc, f.sort asc, f.id asc").
|
||
All()
|
||
if err != nil {
|
||
return out
|
||
}
|
||
for _, f := range files {
|
||
pid := f["project_id"].Int64()
|
||
if _, ok := out[pid]; !ok && f["file_path"].String() != "" {
|
||
out[pid] = absoluteURL(ctx, f["file_path"].String())
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
// ProjectDetail 项目详情（仅绑定用户可见；含阶段/节点/交付物全量）。
|
||
func ProjectDetail(ctx context.Context, id int64) (*userv1.ProjectDetailRes, error) {
|
||
p, err := g.Model(consts.TableServiceProjects).Where("id", id).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if p.IsEmpty() || p["user_id"].Int64() != CtxUserId(ctx) {
|
||
return nil, gerror.New("项目不存在或未绑定到当前账号")
|
||
}
|
||
stages, err := projectStagesOut(ctx, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
pays, err := projectPaysOut(ctx, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
maintain, err := projectMaintainOut(ctx, p)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
res := &userv1.ProjectDetailRes{
|
||
ProjectItem: projectItemOf(p),
|
||
Stages: stages,
|
||
Pays: pays,
|
||
Maintain: maintain,
|
||
}
|
||
res.StageTotal, res.StageDone = projectStageAgg(ctx, id)
|
||
if p["status"].Int() == consts.ProjectStatusDone && p["accepted"].Int() == 0 {
|
||
res.CanAccept = 1
|
||
}
|
||
return res, nil
|
||
}
|
||
|
||
// projectPaysOut 分期列表（按期号升序）
|
||
func projectPaysOut(ctx context.Context, projectId int64) ([]userv1.ProjectPayItem, error) {
|
||
records, err := g.Model(consts.TableProjectPays).
|
||
Where("project_id", projectId).Order("seq asc, id asc").All()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
list := make([]userv1.ProjectPayItem, 0, len(records))
|
||
for _, r := range records {
|
||
list = append(list, userv1.ProjectPayItem{
|
||
Id: r["id"].Int64(),
|
||
Seq: r["seq"].Int(),
|
||
Percent: r["percent"].Int(),
|
||
AmountCents: r["amount_cents"].Int64(),
|
||
Trigger: r["trigger"].String(),
|
||
TriggerText: consts.PayTriggerNameOf(r["trigger"].String()),
|
||
Status: r["status"].Int(),
|
||
PaidAt: timeStr(r["paid_at"].GTime()),
|
||
})
|
||
}
|
||
return list, nil
|
||
}
|
||
|
||
// projectMaintainOut 维护期信息（未选模板 / 仅源码仍有展示，便于用户理解售后范围）
|
||
func projectMaintainOut(ctx context.Context, p gdb.Record) (*userv1.ProjectMaintainOut, error) {
|
||
planId := p["maintain_plan_id"].Int64()
|
||
if planId <= 0 {
|
||
return nil, nil
|
||
}
|
||
plan, err := g.Model(consts.TableMaintainPlans).Where("id", planId).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if plan.IsEmpty() {
|
||
return nil, nil
|
||
}
|
||
return &userv1.ProjectMaintainOut{
|
||
PlanName: plan["name"].String(),
|
||
FreeYears: plan["free_years"].Int(),
|
||
YearlyFeeCents: plan["yearly_fee_cents"].Int64(),
|
||
SourceOnly: plan["source_only"].Int(),
|
||
Accepted: p["accepted"].Int(),
|
||
AcceptedAt: timeStr(p["accepted_at"].GTime()),
|
||
StartAt: timeStr(p["maintain_start_at"].GTime()),
|
||
PaidUntil: timeStr(p["maintain_paid_until"].GTime()),
|
||
}, nil
|
||
}
|
||
|
||
// ProjectAccept 用户确认验收：进入维护期（起点=验收当天；后台可调整起算日）。
|
||
// 维护费已缴至 = 起算日 + 免费年数（按年收费模板 free_years=0 → 验收后即进入首年缴费提醒窗口）。
|
||
func ProjectAccept(ctx context.Context, id int64) (*userv1.ProjectAcceptRes, error) {
|
||
p, err := g.Model(consts.TableServiceProjects).Where("id", id).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if p.IsEmpty() || p["user_id"].Int64() != CtxUserId(ctx) {
|
||
return nil, gerror.New("项目不存在或未绑定到当前账号")
|
||
}
|
||
if p["status"].Int() != consts.ProjectStatusDone {
|
||
return nil, gerror.New("项目尚未交付，暂不能验收")
|
||
}
|
||
if p["accepted"].Int() == 1 {
|
||
return nil, gerror.New("该项目已验收过")
|
||
}
|
||
planId := p["maintain_plan_id"].Int64()
|
||
freeYears := 0
|
||
sourceOnly := 0
|
||
if planId > 0 {
|
||
plan, err := g.Model(consts.TableMaintainPlans).Where("id", planId).One()
|
||
if err == nil && !plan.IsEmpty() {
|
||
freeYears = plan["free_years"].Int()
|
||
sourceOnly = plan["source_only"].Int()
|
||
}
|
||
}
|
||
now := gtime.Now()
|
||
var paidUntil *gtime.Time
|
||
if sourceOnly != 1 {
|
||
paidUntil = now.AddDate(freeYears, 0, 0)
|
||
}
|
||
if _, err = g.Model(consts.TableServiceProjects).Where("id", id).Data(g.Map{
|
||
"accepted": 1,
|
||
"accepted_at": now,
|
||
"maintain_start_at": now,
|
||
"maintain_paid_until": paidUntil,
|
||
"updated_at": gdb.Raw("NOW()"),
|
||
}).Update(); err != nil {
|
||
return nil, err
|
||
}
|
||
if sourceOnly == 1 {
|
||
pushProjectUpdate(ctx, p["user_id"].Int64(), id,
|
||
"验收成功",
|
||
"项目「"+p["title"].String()+"」已验收，源码交付完成。感谢信任！")
|
||
} else {
|
||
tail := "免费维护期至 " + paidUntil.Format("Y-m-d")
|
||
if freeYears <= 0 {
|
||
tail = "按年收费维护已开始，请留意年度维护费缴纳提醒"
|
||
}
|
||
pushProjectUpdate(ctx, p["user_id"].Int64(), id,
|
||
"验收成功，进入维护期",
|
||
"项目「"+p["title"].String()+"」验收通过，"+tail)
|
||
}
|
||
WriteAudit(ctx, AuditEntry{
|
||
Action: "service.project.accept",
|
||
TargetType: "service_project",
|
||
TargetId: auditId(id),
|
||
After: g.Map{"accepted": 1, "maintain_paid_until": paidUntil},
|
||
Result: consts.AuditResultSuccess,
|
||
})
|
||
res := &userv1.ProjectAcceptRes{MaintainStartAt: now.Format("Y-m-d")}
|
||
if paidUntil != nil {
|
||
res.PaidUntil = paidUntil.Format("Y-m-d")
|
||
}
|
||
return res, nil
|
||
}
|
||
|
||
// projectStagesOut 组装阶段树（节点 + 交付物，图片绝对 URL）
|
||
func projectStagesOut(ctx context.Context, projectId int64) ([]userv1.ProjectStageItem, error) {
|
||
stages, err := g.Model(consts.TableProjectStages).
|
||
Where("project_id", projectId).
|
||
Where("is_enabled", 1).
|
||
Order("sort asc, id asc").All()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
nodes, err := g.Model(consts.TableProjectNodes).
|
||
Where("project_id", projectId).
|
||
Order("sort asc, id asc").All()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
files, err := g.Model(consts.TableProjectFiles).
|
||
Where("project_id", projectId).
|
||
Order("sort asc, id asc").All()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
out := make([]userv1.ProjectStageItem, 0, len(stages))
|
||
for _, s := range stages {
|
||
stageId := s["id"].Int64()
|
||
stage := userv1.ProjectStageItem{
|
||
Id: stageId,
|
||
Title: s["title"].String(),
|
||
Status: s["status"].Int(),
|
||
StatusText: consts.StageStatusNameOf(s["status"].Int()),
|
||
}
|
||
for _, n := range nodes {
|
||
if n["stage_id"].Int64() != stageId {
|
||
continue
|
||
}
|
||
stage.Nodes = append(stage.Nodes, userv1.ProjectNodeItem{
|
||
Id: n["id"].Int64(),
|
||
Title: n["title"].String(),
|
||
IsDone: n["is_done"].Int(),
|
||
DoneAt: timeStr(n["done_at"].GTime()),
|
||
})
|
||
}
|
||
for _, f := range files {
|
||
if f["stage_id"].Int64() != stageId {
|
||
continue
|
||
}
|
||
stage.Files = append(stage.Files, userv1.ProjectFileItem{
|
||
Id: f["id"].Int64(),
|
||
FileName: f["file_name"].String(),
|
||
FileUrl: absoluteURL(ctx, f["file_path"].String()),
|
||
})
|
||
}
|
||
if stage.Nodes == nil {
|
||
stage.Nodes = []userv1.ProjectNodeItem{}
|
||
}
|
||
if stage.Files == nil {
|
||
stage.Files = []userv1.ProjectFileItem{}
|
||
}
|
||
out = append(out, stage)
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
// ProjectBind 扫码绑定：令牌来自小程序码 scene。已绑本人幂等；已被他人绑定报错。
|
||
func ProjectBind(ctx context.Context, token string) (*userv1.ProjectBindRes, error) {
|
||
token = strings.ToUpper(strings.TrimSpace(token))
|
||
if token == "" {
|
||
return nil, gerror.New("缺少绑定令牌")
|
||
}
|
||
p, err := g.Model(consts.TableServiceProjects).Where("bind_token", token).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if p.IsEmpty() {
|
||
return nil, gerror.New("绑定码无效，请联系开发者确认")
|
||
}
|
||
userId := CtxUserId(ctx)
|
||
owner := p["user_id"].Int64()
|
||
if owner != 0 && owner != userId {
|
||
return nil, gerror.New("该项目已绑定到其他账号")
|
||
}
|
||
if owner != userId {
|
||
if _, err = g.Model(consts.TableServiceProjects).Where("id", p["id"].Int64()).Data(g.Map{
|
||
"user_id": userId,
|
||
"updated_at": gdb.Raw("NOW()"),
|
||
}).Update(); err != nil {
|
||
return nil, err
|
||
}
|
||
pushProjectUpdate(ctx, userId, p["id"].Int64(),
|
||
"项目绑定成功",
|
||
"你的项目「"+p["title"].String()+"」已绑定到当前账号，进度与交付物会在这里同步。")
|
||
}
|
||
return &userv1.ProjectBindRes{ProjectId: p["id"].Int64()}, nil
|
||
}
|
||
|
||
// ============================================================================
|
||
// 管理端
|
||
// ============================================================================
|
||
|
||
// AdminProjectList 项目列表（含未绑定；带客户昵称与阶段进度）
|
||
func AdminProjectList(ctx context.Context, req *adminv1.AdminProjectListReq) (*adminv1.AdminProjectListRes, error) {
|
||
page, pageSize := normalizePage(req.Page, req.PageSize, 20)
|
||
m := g.Model(consts.TableServiceProjects)
|
||
if kw := strings.TrimSpace(req.Keyword); kw != "" {
|
||
m = m.Where("title LIKE ?", "%"+kw+"%")
|
||
}
|
||
if req.Status != nil {
|
||
m = m.Where("status", *req.Status)
|
||
}
|
||
total, err := m.Count()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
records, err := m.Page(page, pageSize).OrderDesc("id").All()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
// 客户昵称 / 模板名映射
|
||
nicknames := map[int64]string{}
|
||
maintainNames := map[int64]string{}
|
||
payNames := map[int64]string{}
|
||
userIds := make([]int64, 0, len(records))
|
||
maintainIds := make([]int64, 0, len(records))
|
||
payIds := make([]int64, 0, len(records))
|
||
for _, r := range records {
|
||
if uid := r["user_id"].Int64(); uid > 0 {
|
||
userIds = append(userIds, uid)
|
||
}
|
||
if mid := r["maintain_plan_id"].Int64(); mid > 0 {
|
||
maintainIds = append(maintainIds, mid)
|
||
}
|
||
if pid := r["pay_plan_id"].Int64(); pid > 0 {
|
||
payIds = append(payIds, pid)
|
||
}
|
||
}
|
||
if len(userIds) > 0 {
|
||
rows, err := g.Model(consts.TableUsers).WhereIn("id", userIds).All()
|
||
if err == nil {
|
||
for _, u := range rows {
|
||
nicknames[u["id"].Int64()] = u["nickname"].String()
|
||
}
|
||
}
|
||
}
|
||
if len(maintainIds) > 0 {
|
||
rows, err := g.Model(consts.TableMaintainPlans).WhereIn("id", maintainIds).All()
|
||
if err == nil {
|
||
for _, m := range rows {
|
||
maintainNames[m["id"].Int64()] = m["name"].String()
|
||
}
|
||
}
|
||
}
|
||
if len(payIds) > 0 {
|
||
rows, err := g.Model(consts.TablePayPlans).WhereIn("id", payIds).All()
|
||
if err == nil {
|
||
for _, p := range rows {
|
||
payNames[p["id"].Int64()] = p["name"].String()
|
||
}
|
||
}
|
||
}
|
||
list := make([]adminv1.AdminProjectItem, 0, len(records))
|
||
for _, r := range records {
|
||
uid := r["user_id"].Int64()
|
||
item := adminv1.AdminProjectItem{
|
||
Id: r["id"].Int64(),
|
||
UserId: uid,
|
||
UserNickname: nicknames[uid],
|
||
Title: r["title"].String(),
|
||
Description: r["description"].String(),
|
||
PriceCents: r["price_cents"].Int64(),
|
||
PriceNote: r["price_note"].String(),
|
||
DueNote: r["due_note"].String(),
|
||
Status: r["status"].Int(),
|
||
StatusText: consts.ProjectStatusNameOf(r["status"].Int()),
|
||
BindToken: r["bind_token"].String(),
|
||
CodeUrl: r["code_url"].String(),
|
||
CreatedAt: timeStr(r["created_at"].GTime()),
|
||
UpdatedAt: timeStr(r["updated_at"].GTime()),
|
||
}
|
||
item.StageTotal, item.StageDone = projectStageAgg(ctx, item.Id)
|
||
item.MaintainPlanId = r["maintain_plan_id"].Int64()
|
||
item.PayPlanId = r["pay_plan_id"].Int64()
|
||
item.MaintainPlanName = maintainNames[item.MaintainPlanId]
|
||
item.PayPlanName = payNames[item.PayPlanId]
|
||
item.Accepted = r["accepted"].Int()
|
||
item.MaintainPaidUntil = timeStr(r["maintain_paid_until"].GTime())
|
||
item.MaintainDaysLeft = projectDaysLeft(r)
|
||
list = append(list, item)
|
||
}
|
||
return &adminv1.AdminProjectListRes{List: list, Total: total}, nil
|
||
}
|
||
|
||
// projectDaysLeft 距维护费到期天数；未启用维护期（未验收/仅源码/未设缴至）返回 -1。
|
||
// list 查询未 join 模板表，仅源码模板（yearly_fee=0）的项目会在已缴至为空时自然返回 -1。
|
||
func projectDaysLeft(p gdb.Record) int {
|
||
if p["accepted"].Int() != 1 {
|
||
return -1
|
||
}
|
||
paidUntil := p["maintain_paid_until"].GTime()
|
||
if paidUntil == nil {
|
||
return -1
|
||
}
|
||
return maintainDaysLeft(gtime.Now(), paidUntil)
|
||
}
|
||
|
||
// AdminProjectSave 新增/编辑项目。新建生成绑定令牌；userId 变更即时改绑；
|
||
// 状态切到「已交付」时推站内信。
|
||
func AdminProjectSave(ctx context.Context, req *adminv1.AdminProjectSaveReq) (*adminv1.AdminProjectSaveRes, error) {
|
||
title := strings.TrimSpace(req.Title)
|
||
if title == "" {
|
||
return nil, gerror.New("请填写项目名称")
|
||
}
|
||
// 模板校验（新建必选；编辑允许沿用原值）
|
||
if req.MaintainPlanId > 0 {
|
||
if cnt, _ := g.Model(consts.TableMaintainPlans).Where("id", req.MaintainPlanId).Where("is_enabled", 1).Count(); cnt == 0 {
|
||
return nil, gerror.New("维护模板不存在或已停用")
|
||
}
|
||
}
|
||
if req.PayPlanId > 0 {
|
||
if cnt, _ := g.Model(consts.TablePayPlans).Where("id", req.PayPlanId).Where("is_enabled", 1).Count(); cnt == 0 {
|
||
return nil, gerror.New("付款分期模板不存在或已停用")
|
||
}
|
||
}
|
||
|
||
data := g.Map{
|
||
"title": title,
|
||
"description": strings.TrimSpace(req.Description),
|
||
"price_cents": req.PriceCents,
|
||
"price_note": strings.TrimSpace(req.PriceNote),
|
||
"due_note": strings.TrimSpace(req.DueNote),
|
||
"status": req.Status,
|
||
"user_id": req.UserId,
|
||
}
|
||
if req.Id > 0 {
|
||
exist, err := g.Model(consts.TableServiceProjects).Where("id", req.Id).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if exist.IsEmpty() {
|
||
return nil, gerror.New("项目不存在")
|
||
}
|
||
if req.MaintainPlanId > 0 {
|
||
data["maintain_plan_id"] = req.MaintainPlanId
|
||
}
|
||
if req.PayPlanId > 0 {
|
||
data["pay_plan_id"] = req.PayPlanId
|
||
}
|
||
data["updated_at"] = gdb.Raw("NOW()")
|
||
if _, err = g.Model(consts.TableServiceProjects).Where("id", req.Id).Data(data).Update(); err != nil {
|
||
return nil, err
|
||
}
|
||
// 分期计划再生成：换了付款模板 → 必须没有已到账分期；金额变了 → 只重算未到账期数
|
||
if req.PayPlanId > 0 || req.PriceCents != exist["price_cents"].Int64() {
|
||
if err = projectRegeneratePays(ctx, req.Id, req.PriceCents); err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
// 改绑 / 交付 的站内信
|
||
if req.UserId > 0 && req.UserId != exist["user_id"].Int64() {
|
||
pushProjectUpdate(ctx, req.UserId, req.Id,
|
||
"项目绑定成功",
|
||
"你的项目「"+title+"」已绑定到当前账号，进度与交付物会在这里同步。")
|
||
}
|
||
if req.Status == consts.ProjectStatusDone && exist["status"].Int() != consts.ProjectStatusDone {
|
||
pushProjectUpdate(ctx, req.UserId, req.Id,
|
||
"项目已交付",
|
||
"项目「"+title+"」已标记交付，感谢信任，售后随时找我们。")
|
||
}
|
||
WriteAudit(ctx, AuditEntry{
|
||
Action: "service.project.save",
|
||
TargetType: "service_project",
|
||
TargetId: auditId(req.Id),
|
||
Before: g.Map{"title": exist["title"].String(), "status": exist["status"].Int()},
|
||
After: g.Map{"title": title, "status": req.Status},
|
||
Result: consts.AuditResultSuccess,
|
||
})
|
||
return &adminv1.AdminProjectSaveRes{Id: req.Id, BindToken: exist["bind_token"].String()}, nil
|
||
}
|
||
|
||
token := genBindToken()
|
||
// 令牌唯一键兜底：极小概率撞表，重试一次
|
||
if cnt, _ := g.Model(consts.TableServiceProjects).Where("bind_token", token).Count(); cnt > 0 {
|
||
token = genBindToken()
|
||
}
|
||
if req.MaintainPlanId <= 0 || req.PayPlanId <= 0 {
|
||
return nil, gerror.New("请选择维护模板与付款分期模板")
|
||
}
|
||
data["maintain_plan_id"] = req.MaintainPlanId
|
||
data["pay_plan_id"] = req.PayPlanId
|
||
data["bind_token"] = token
|
||
data["created_at"] = gdb.Raw("NOW()")
|
||
data["updated_at"] = gdb.Raw("NOW()")
|
||
res, err := g.Model(consts.TableServiceProjects).Data(data).Insert()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
id, _ := res.LastInsertId()
|
||
if err = projectRegeneratePays(ctx, id, req.PriceCents); err != nil {
|
||
return nil, err
|
||
}
|
||
if req.UserId > 0 {
|
||
pushProjectUpdate(ctx, req.UserId, id,
|
||
"项目绑定成功",
|
||
"你的项目「"+title+"」已绑定到当前账号，进度与交付物会在这里同步。")
|
||
}
|
||
WriteAudit(ctx, AuditEntry{
|
||
Action: "service.project.save",
|
||
TargetType: "service_project",
|
||
TargetId: auditId(id),
|
||
After: g.Map{"title": title, "status": req.Status},
|
||
Result: consts.AuditResultSuccess,
|
||
})
|
||
return &adminv1.AdminProjectSaveRes{Id: id, BindToken: token}, nil
|
||
}
|
||
|
||
// projectRegeneratePays 按项目当前付款模板 × 金额生成分期计划。
|
||
// - 无已到账分期：整表重建（换模板 / 首次生成）；
|
||
// - 已有到账分期：仅重算未到账期数的金额（最后一期吸收取整余额），不动已到账记录。
|
||
func projectRegeneratePays(ctx context.Context, projectId, priceCents int64) error {
|
||
p, err := g.Model(consts.TableServiceProjects).Where("id", projectId).One()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if p.IsEmpty() || p["pay_plan_id"].Int64() <= 0 {
|
||
return nil
|
||
}
|
||
plan, err := g.Model(consts.TablePayPlans).Where("id", p["pay_plan_id"].Int64()).One()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if plan.IsEmpty() {
|
||
return nil
|
||
}
|
||
steps, err := parsePaySchedule(plan["schedule"].String())
|
||
if err != nil {
|
||
return err
|
||
}
|
||
paidCnt, err := g.Model(consts.TableProjectPays).
|
||
Where("project_id", projectId).Where("status", consts.PayStatusPaid).Count()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if paidCnt > 0 {
|
||
// 只重算金额：所有期按各自比例算，取整差额（正负均可）归到最后一个未到账期。
|
||
// ⚠️ 差额 = 项目金额 − 全部期按比例之和（含已到账期），绝不能把已到账期漏掉，
|
||
// 否则最后一期会被错误地写成「项目金额 − 已到账合计」（线上踩过一次）。
|
||
all, err := g.Model(consts.TableProjectPays).
|
||
Where("project_id", projectId).Order("seq asc").All()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
percentSum := int64(0)
|
||
for _, r := range all {
|
||
percentSum += priceCents * r["percent"].Int64() / 100
|
||
}
|
||
remainder := priceCents - percentSum
|
||
var lastUnpaid int64
|
||
for i := len(all) - 1; i >= 0; i-- {
|
||
if all[i]["status"].Int() == consts.PayStatusPending {
|
||
lastUnpaid = all[i]["id"].Int64()
|
||
break
|
||
}
|
||
}
|
||
for _, r := range all {
|
||
if r["status"].Int() != consts.PayStatusPending {
|
||
continue
|
||
}
|
||
amount := priceCents * r["percent"].Int64() / 100
|
||
if r["id"].Int64() == lastUnpaid {
|
||
amount += remainder
|
||
}
|
||
if _, err = g.Model(consts.TableProjectPays).Where("id", r["id"].Int64()).Data(g.Map{
|
||
"amount_cents": amount,
|
||
"updated_at": gdb.Raw("NOW()"),
|
||
}).Update(); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
// 整表重建
|
||
if _, err = g.Model(consts.TableProjectPays).Where("project_id", projectId).Delete(); err != nil {
|
||
return err
|
||
}
|
||
allocated := int64(0)
|
||
for i, st := range steps {
|
||
amount := priceCents * st.Percent / 100
|
||
if i == len(steps)-1 {
|
||
amount = priceCents - allocated
|
||
}
|
||
allocated += amount
|
||
if _, err = g.Model(consts.TableProjectPays).Data(g.Map{
|
||
"project_id": projectId,
|
||
"seq": st.Seq,
|
||
"percent": st.Percent,
|
||
"amount_cents": amount,
|
||
"trigger": st.Trigger,
|
||
"status": consts.PayStatusPending,
|
||
"created_at": gdb.Raw("NOW()"),
|
||
"updated_at": gdb.Raw("NOW()"),
|
||
}).Insert(); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// payStep 分期计划单步
|
||
type payStep struct {
|
||
Seq int
|
||
Percent int64
|
||
Trigger string
|
||
}
|
||
|
||
// parsePaySchedule 解析分期模板 schedule JSON（[{seq,percent,trigger}]），校验比例合计 100。
|
||
func parsePaySchedule(raw string) ([]payStep, error) {
|
||
var steps []payStep
|
||
if err := json.Unmarshal([]byte(raw), &steps); err != nil {
|
||
return nil, gerror.New("分期计划 JSON 不合法")
|
||
}
|
||
if len(steps) == 0 {
|
||
return nil, gerror.New("分期计划不能为空")
|
||
}
|
||
total := int64(0)
|
||
for _, st := range steps {
|
||
switch st.Trigger {
|
||
case consts.PayTriggerStart, consts.PayTriggerMidDemo,
|
||
consts.PayTriggerOnlineBefore, consts.PayTriggerOnlineAfter:
|
||
default:
|
||
return nil, gerror.New("分期触发节点不合法（start / mid_demo / online_before / online_after）")
|
||
}
|
||
if st.Percent <= 0 || st.Percent > 100 {
|
||
return nil, gerror.New("分期比例需在 1-100 之间")
|
||
}
|
||
total += st.Percent
|
||
}
|
||
if total != 100 {
|
||
return nil, gerror.New("分期比例合计必须为 100%")
|
||
}
|
||
return steps, nil
|
||
}
|
||
|
||
// AdminProjectDelete 删除项目（软删）及其阶段/节点/交付物（硬删）。
|
||
func AdminProjectDelete(ctx context.Context, id int64) (*adminv1.AdminProjectDeleteRes, error) {
|
||
exist, err := g.Model(consts.TableServiceProjects).Where("id", id).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if exist.IsEmpty() {
|
||
return nil, gerror.New("项目不存在")
|
||
}
|
||
if _, err = g.Model(consts.TableServiceProjects).Where("id", id).Data(g.Map{
|
||
"deleted_at": gdb.Raw("NOW()"),
|
||
"updated_at": gdb.Raw("NOW()"),
|
||
}).Update(); err != nil {
|
||
return nil, err
|
||
}
|
||
for _, table := range []string{consts.TableProjectStages, consts.TableProjectNodes, consts.TableProjectFiles} {
|
||
if _, err = g.Model(table).Where("project_id", id).Delete(); err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
WriteAudit(ctx, AuditEntry{
|
||
Action: "service.project.delete",
|
||
TargetType: "service_project",
|
||
TargetId: auditId(id),
|
||
Before: g.Map{"title": exist["title"].String()},
|
||
Result: consts.AuditResultSuccess,
|
||
})
|
||
return &adminv1.AdminProjectDeleteRes{}, nil
|
||
}
|
||
|
||
// AdminProjectDetail 管理态详情（含全部阶段/节点/交付物，含停用阶段）
|
||
func AdminProjectDetail(ctx context.Context, id int64) (*adminv1.AdminProjectDetailRes, error) {
|
||
p, err := g.Model(consts.TableServiceProjects).Where("id", id).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if p.IsEmpty() {
|
||
return nil, gerror.New("项目不存在")
|
||
}
|
||
item := adminv1.AdminProjectItem{
|
||
Id: p["id"].Int64(),
|
||
UserId: p["user_id"].Int64(),
|
||
Title: p["title"].String(),
|
||
Description: p["description"].String(),
|
||
PriceCents: p["price_cents"].Int64(),
|
||
PriceNote: p["price_note"].String(),
|
||
DueNote: p["due_note"].String(),
|
||
Status: p["status"].Int(),
|
||
StatusText: consts.ProjectStatusNameOf(p["status"].Int()),
|
||
BindToken: p["bind_token"].String(),
|
||
CodeUrl: p["code_url"].String(),
|
||
CreatedAt: timeStr(p["created_at"].GTime()),
|
||
UpdatedAt: timeStr(p["updated_at"].GTime()),
|
||
}
|
||
if item.UserId > 0 {
|
||
if u, err := g.Model(consts.TableUsers).Where("id", item.UserId).One(); err == nil && !u.IsEmpty() {
|
||
item.UserNickname = u["nickname"].String()
|
||
}
|
||
}
|
||
item.StageTotal, item.StageDone = projectStageAgg(ctx, id)
|
||
item.MaintainPlanId = p["maintain_plan_id"].Int64()
|
||
item.PayPlanId = p["pay_plan_id"].Int64()
|
||
item.Accepted = p["accepted"].Int()
|
||
item.AcceptedAt = timeStr(p["accepted_at"].GTime())
|
||
item.MaintainStartAt = timeStr(p["maintain_start_at"].GTime())
|
||
item.MaintainPaidUntil = timeStr(p["maintain_paid_until"].GTime())
|
||
item.MaintainDaysLeft = projectDaysLeft(p)
|
||
if item.MaintainPlanId > 0 {
|
||
if mp, err := g.Model(consts.TableMaintainPlans).Where("id", item.MaintainPlanId).One(); err == nil && !mp.IsEmpty() {
|
||
item.MaintainPlanName = mp["name"].String()
|
||
}
|
||
}
|
||
if item.PayPlanId > 0 {
|
||
if pp, err := g.Model(consts.TablePayPlans).Where("id", item.PayPlanId).One(); err == nil && !pp.IsEmpty() {
|
||
item.PayPlanName = pp["name"].String()
|
||
}
|
||
}
|
||
if pays, err := projectPaysOut(ctx, id); err == nil {
|
||
for _, py := range pays {
|
||
item.Pays = append(item.Pays, adminv1.AdminProjectPayItem{
|
||
Id: py.Id, Seq: py.Seq, Percent: py.Percent, AmountCents: py.AmountCents,
|
||
Trigger: py.Trigger, TriggerText: py.TriggerText, Status: py.Status,
|
||
PaidAt: py.PaidAt,
|
||
})
|
||
}
|
||
}
|
||
|
||
stages, err := g.Model(consts.TableProjectStages).
|
||
Where("project_id", id).Order("sort asc, id asc").All()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
nodes, err := g.Model(consts.TableProjectNodes).
|
||
Where("project_id", id).Order("sort asc, id asc").All()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
files, err := g.Model(consts.TableProjectFiles).
|
||
Where("project_id", id).Order("sort asc, id asc").All()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
for _, s := range stages {
|
||
stageId := s["id"].Int64()
|
||
stage := adminv1.AdminProjectStageItem{
|
||
Id: stageId,
|
||
Title: s["title"].String(),
|
||
Status: s["status"].Int(),
|
||
StatusText: consts.StageStatusNameOf(s["status"].Int()),
|
||
Sort: s["sort"].Int(),
|
||
IsEnabled: s["is_enabled"].Int(),
|
||
Nodes: []adminv1.AdminProjectNodeItem{},
|
||
Files: []adminv1.AdminProjectFileItem{},
|
||
}
|
||
for _, n := range nodes {
|
||
if n["stage_id"].Int64() != stageId {
|
||
continue
|
||
}
|
||
stage.Nodes = append(stage.Nodes, adminv1.AdminProjectNodeItem{
|
||
Id: n["id"].Int64(),
|
||
Title: n["title"].String(),
|
||
IsDone: n["is_done"].Int(),
|
||
Sort: n["sort"].Int(),
|
||
})
|
||
}
|
||
for _, f := range files {
|
||
if f["stage_id"].Int64() != stageId {
|
||
continue
|
||
}
|
||
stage.Files = append(stage.Files, adminv1.AdminProjectFileItem{
|
||
Id: f["id"].Int64(),
|
||
FileName: f["file_name"].String(),
|
||
FileUrl: absoluteURL(ctx, f["file_path"].String()),
|
||
})
|
||
}
|
||
item.Stages = append(item.Stages, stage)
|
||
}
|
||
return &adminv1.AdminProjectDetailRes{AdminProjectItem: item}, nil
|
||
}
|
||
|
||
// AdminProjectQrcode 生成/刷新绑定小程序码（wxacode.getUnlimited，scene=p<id><token>）。
|
||
// 复用年会域的 access_token 复用与码图落盘设施（QrCodeDir + /qrcode 静态路由）。
|
||
func AdminProjectQrcode(ctx context.Context, id int64) (*adminv1.AdminProjectQrcodeRes, error) {
|
||
p, err := g.Model(consts.TableServiceProjects).Where("id", id).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if p.IsEmpty() {
|
||
return nil, gerror.New("项目不存在")
|
||
}
|
||
cfg := xpayConfig(ctx)
|
||
if cfg.AppId == "" || cfg.Secret == "" {
|
||
return nil, gerror.New("未配置 wx.appId / wx.appSecret，无法生成小程序码；也可把绑定码 " + p["bind_token"].String() + " 直接发给用户，在绑定页手动输入")
|
||
}
|
||
token, err := wxAccessToken(ctx)
|
||
if err != nil {
|
||
return nil, gerror.New("获取微信 access_token 失败，请稍后重试或检查 wx.appId / wx.appSecret 配置；也可把绑定码 " + p["bind_token"].String() + " 直接发给用户，在绑定页手动输入")
|
||
}
|
||
scene := "p" + strconv.FormatInt(p["id"].Int64(), 10) + p["bind_token"].String()
|
||
body := g.Map{
|
||
"scene": scene,
|
||
"page": projectBindPage,
|
||
"check_path": false, // 联调期页面可能未发布，避免路径校验失败
|
||
"env_version": "release",
|
||
}
|
||
resp, err := g.Client().ContentJson().Post(ctx, xpayAPIBase+"/wxa/getwxacodeunlimit?access_token="+token, body)
|
||
if err != nil {
|
||
return nil, gerror.Newf("调用 wxacode.getUnlimited 失败: %v", err)
|
||
}
|
||
defer resp.Close()
|
||
data := resp.ReadAll()
|
||
if len(data) == 0 {
|
||
return nil, gerror.New("生成小程序码失败：微信返回空响应")
|
||
}
|
||
if isJsonBytes(data) {
|
||
var we struct {
|
||
ErrCode int `json:"errcode"`
|
||
ErrMsg string `json:"errmsg"`
|
||
}
|
||
_ = json.Unmarshal(data, &we)
|
||
return nil, gerror.Newf("生成小程序码失败：%d %s（页面未发布时请改用正式环境或令牌绑定）", we.ErrCode, we.ErrMsg)
|
||
}
|
||
if err = gfile.Mkdir(QrCodeDir); err != nil {
|
||
return nil, gerror.Newf("创建码图目录失败: %v", err)
|
||
}
|
||
fileName := "project_" + strconv.FormatInt(p["id"].Int64(), 10) + "_" + gtime.Now().Format("YmdHis") + ".png"
|
||
path := gfile.Join(QrCodeDir, fileName)
|
||
if err = gfile.PutBytes(path, data); err != nil {
|
||
return nil, gerror.Newf("写入码图失败: %v", err)
|
||
}
|
||
codeUrl := "/qrcode/" + fileName
|
||
if _, err = g.Model(consts.TableServiceProjects).Where("id", id).Data(g.Map{
|
||
"code_url": codeUrl,
|
||
"updated_at": gdb.Raw("NOW()"),
|
||
}).Update(); err != nil {
|
||
return nil, err
|
||
}
|
||
return &adminv1.AdminProjectQrcodeRes{CodeUrl: codeUrl}, nil
|
||
}
|
||
|
||
// AdminProjectStageSave 新增/编辑阶段；状态变更推站内信。
|
||
func AdminProjectStageSave(ctx context.Context, req *adminv1.AdminProjectStageSaveReq) (*adminv1.AdminProjectStageSaveRes, error) {
|
||
title := strings.TrimSpace(req.Title)
|
||
if title == "" {
|
||
return nil, gerror.New("请填写阶段名称")
|
||
}
|
||
p, err := g.Model(consts.TableServiceProjects).Where("id", req.ProjectId).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if p.IsEmpty() {
|
||
return nil, gerror.New("项目不存在")
|
||
}
|
||
data := g.Map{
|
||
"project_id": req.ProjectId,
|
||
"title": title,
|
||
"status": req.Status,
|
||
"sort": req.Sort,
|
||
"is_enabled": req.IsEnabled,
|
||
}
|
||
if req.Id > 0 {
|
||
exist, err := g.Model(consts.TableProjectStages).Where("id", req.Id).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if exist.IsEmpty() || exist["project_id"].Int64() != req.ProjectId {
|
||
return nil, gerror.New("阶段不存在")
|
||
}
|
||
data["updated_at"] = gdb.Raw("NOW()")
|
||
if _, err = g.Model(consts.TableProjectStages).Where("id", req.Id).Data(data).Update(); err != nil {
|
||
return nil, err
|
||
}
|
||
if req.Status != exist["status"].Int() {
|
||
pushProjectUpdate(ctx, p["user_id"].Int64(), req.ProjectId,
|
||
"阶段进度更新",
|
||
"项目「"+p["title"].String()+"」的阶段「"+title+"」已"+consts.StageStatusNameOf(req.Status)+"。")
|
||
}
|
||
return &adminv1.AdminProjectStageSaveRes{Id: req.Id}, nil
|
||
}
|
||
data["created_at"] = gdb.Raw("NOW()")
|
||
data["updated_at"] = gdb.Raw("NOW()")
|
||
res, err := g.Model(consts.TableProjectStages).Data(data).Insert()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
id, _ := res.LastInsertId()
|
||
return &adminv1.AdminProjectStageSaveRes{Id: id}, nil
|
||
}
|
||
|
||
// AdminProjectStageDelete 删除阶段（节点与交付物一并删除）。
|
||
func AdminProjectStageDelete(ctx context.Context, id int64) (*adminv1.AdminProjectStageDeleteRes, error) {
|
||
exist, err := g.Model(consts.TableProjectStages).Where("id", id).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if exist.IsEmpty() {
|
||
return nil, gerror.New("阶段不存在")
|
||
}
|
||
if _, err = g.Model(consts.TableProjectStages).Where("id", id).Delete(); err != nil {
|
||
return nil, err
|
||
}
|
||
if _, err = g.Model(consts.TableProjectNodes).Where("stage_id", id).Delete(); err != nil {
|
||
return nil, err
|
||
}
|
||
if _, err = g.Model(consts.TableProjectFiles).Where("stage_id", id).Delete(); err != nil {
|
||
return nil, err
|
||
}
|
||
return &adminv1.AdminProjectStageDeleteRes{}, nil
|
||
}
|
||
|
||
// AdminProjectNodeSave 新增/编辑小节点（isDone 变更落完成时间）。
|
||
func AdminProjectNodeSave(ctx context.Context, req *adminv1.AdminProjectNodeSaveReq) (*adminv1.AdminProjectNodeSaveRes, error) {
|
||
title := strings.TrimSpace(req.Title)
|
||
if title == "" {
|
||
return nil, gerror.New("请填写节点内容")
|
||
}
|
||
stage, err := g.Model(consts.TableProjectStages).Where("id", req.StageId).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if stage.IsEmpty() {
|
||
return nil, gerror.New("阶段不存在")
|
||
}
|
||
data := g.Map{
|
||
"project_id": stage["project_id"].Int64(),
|
||
"stage_id": req.StageId,
|
||
"title": title,
|
||
"is_done": req.IsDone,
|
||
"sort": req.Sort,
|
||
}
|
||
if req.Id > 0 {
|
||
exist, err := g.Model(consts.TableProjectNodes).Where("id", req.Id).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if exist.IsEmpty() || exist["stage_id"].Int64() != req.StageId {
|
||
return nil, gerror.New("节点不存在")
|
||
}
|
||
if req.IsDone == 1 && exist["is_done"].Int() != 1 {
|
||
data["done_at"] = gdb.Raw("NOW()")
|
||
} else if req.IsDone != 1 {
|
||
data["done_at"] = nil
|
||
}
|
||
data["updated_at"] = gdb.Raw("NOW()")
|
||
if _, err = g.Model(consts.TableProjectNodes).Where("id", req.Id).Data(data).Update(); err != nil {
|
||
return nil, err
|
||
}
|
||
return &adminv1.AdminProjectNodeSaveRes{Id: req.Id}, nil
|
||
}
|
||
if req.IsDone == 1 {
|
||
data["done_at"] = gdb.Raw("NOW()")
|
||
}
|
||
data["created_at"] = gdb.Raw("NOW()")
|
||
data["updated_at"] = gdb.Raw("NOW()")
|
||
res, err := g.Model(consts.TableProjectNodes).Data(data).Insert()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
id, _ := res.LastInsertId()
|
||
return &adminv1.AdminProjectNodeSaveRes{Id: id}, nil
|
||
}
|
||
|
||
// AdminProjectNodeDelete 删除小节点。
|
||
func AdminProjectNodeDelete(ctx context.Context, id int64) (*adminv1.AdminProjectNodeDeleteRes, error) {
|
||
if _, err := g.Model(consts.TableProjectNodes).Where("id", id).Delete(); err != nil {
|
||
return nil, err
|
||
}
|
||
return &adminv1.AdminProjectNodeDeleteRes{}, nil
|
||
}
|
||
|
||
// AdminProjectFileAdd 登记交付物（文件本体已由 /admin/upload 落盘）并推站内信。
|
||
func AdminProjectFileAdd(ctx context.Context, req *adminv1.AdminProjectFileAddReq) (*adminv1.AdminProjectFileAddRes, error) {
|
||
p, err := g.Model(consts.TableServiceProjects).Where("id", req.ProjectId).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if p.IsEmpty() {
|
||
return nil, gerror.New("项目不存在")
|
||
}
|
||
stageTitle := "项目"
|
||
if req.StageId > 0 {
|
||
s, err := g.Model(consts.TableProjectStages).Where("id", req.StageId).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if s.IsEmpty() || s["project_id"].Int64() != req.ProjectId {
|
||
return nil, gerror.New("阶段不存在")
|
||
}
|
||
stageTitle = s["title"].String()
|
||
}
|
||
res, err := g.Model(consts.TableProjectFiles).Data(g.Map{
|
||
"project_id": req.ProjectId,
|
||
"stage_id": req.StageId,
|
||
"file_name": strings.TrimSpace(req.FileName),
|
||
"file_path": normalizeToRelativePath(req.FilePath),
|
||
"created_at": gdb.Raw("NOW()"),
|
||
}).Insert()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
id, _ := res.LastInsertId()
|
||
pushProjectUpdate(ctx, p["user_id"].Int64(), req.ProjectId,
|
||
"新交付物上传",
|
||
"项目「"+p["title"].String()+"」的「"+stageTitle+"」上传了新交付物："+strings.TrimSpace(req.FileName))
|
||
return &adminv1.AdminProjectFileAddRes{Id: id}, nil
|
||
}
|
||
|
||
// AdminProjectFileDelete 删除交付物登记（不动附件本体，附件管理页统一治理）。
|
||
func AdminProjectFileDelete(ctx context.Context, id int64) (*adminv1.AdminProjectFileDeleteRes, error) {
|
||
if _, err := g.Model(consts.TableProjectFiles).Where("id", id).Delete(); err != nil {
|
||
return nil, err
|
||
}
|
||
return &adminv1.AdminProjectFileDeleteRes{}, nil
|
||
}
|