647 lines
21 KiB
Go
647 lines
21 KiB
Go
package controllers
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"server/models"
|
|
|
|
"github.com/beego/beego/v2/client/orm"
|
|
beego "github.com/beego/beego/v2/server/web"
|
|
)
|
|
|
|
// BackendCrmPaybackController CRM 回款管理
|
|
//
|
|
// 回款计划针对于合同创建：
|
|
// - plan_type 回款周期：1月度/2季度/3年度/4进度/5自定义；
|
|
// - 月度/季度/年度：明细为「期数 + 支付金额」；
|
|
// - 进度：明细为「进度名称 + 进度百分比 + 进度金额」；
|
|
// - 自定义：明细为「名称 + 计划日期 + 金额」；
|
|
// - 回款进度：按计划明细逐期登记实收金额/日期。
|
|
type BackendCrmPaybackController struct {
|
|
beego.Controller
|
|
}
|
|
|
|
// paybackItem 计划明细行（items JSON 元素）。
|
|
type paybackItem struct {
|
|
Seq int `json:"seq"`
|
|
Name string `json:"name"`
|
|
Percent float64 `json:"percent"`
|
|
Amount float64 `json:"amount"`
|
|
PlanDate string `json:"plan_date"`
|
|
ReceivedAmount float64 `json:"received_amount"`
|
|
ReceivedDate string `json:"received_date"`
|
|
ReceiptURL string `json:"receipt_url"` // 流水回执地址（选填）
|
|
ReceiptName string `json:"receipt_name"` // 流水回执文件名（选填）
|
|
Status int8 `json:"status"` // 1未回款/2部分回款/3已回款
|
|
}
|
|
|
|
// paybackPayload 创建 / 更新请求体。
|
|
type paybackPayload struct {
|
|
ContractID uint64 `json:"contract_id"`
|
|
ContractNo string `json:"contract_no"`
|
|
ContractName string `json:"contract_name"`
|
|
CustomerID uint64 `json:"customer_id"`
|
|
CustomerName string `json:"customer_name"`
|
|
PlanType int8 `json:"plan_type"`
|
|
PayMethod int8 `json:"pay_method"`
|
|
RemindDays int `json:"remind_days"`
|
|
OwnerUserID string `json:"owner_user_id"`
|
|
OwnerUserName string `json:"owner_user_name"`
|
|
ContractAmount float64 `json:"contract_amount"`
|
|
Items json.RawMessage `json:"items"`
|
|
Remark string `json:"remark"`
|
|
Status int8 `json:"status"`
|
|
ReceiptURL string `json:"receipt_url"` // 流水回执地址（选填）
|
|
ReceiptName string `json:"receipt_name"` // 流水回执文件名（选填）
|
|
}
|
|
|
|
// paybackResp 列表 / 详情响应：items 解析为 JSON 数组透出。
|
|
type paybackResp struct {
|
|
models.TenantCrmPayback
|
|
Items json.RawMessage `json:"items"`
|
|
}
|
|
|
|
// paybackProgress 回款进度行（跨计划摊平的计划明细）。
|
|
type paybackProgress struct {
|
|
PaybackID uint64 `json:"payback_id"`
|
|
ContractID *uint64 `json:"contract_id"`
|
|
ContractNo string `json:"contract_no"`
|
|
ContractName string `json:"contract_name"`
|
|
CustomerName string `json:"customer_name"`
|
|
OwnerUserName string `json:"owner_user_name"`
|
|
PlanType int8 `json:"plan_type"`
|
|
PayMethod int8 `json:"pay_method"`
|
|
Seq int `json:"seq"`
|
|
Name string `json:"name"`
|
|
Percent float64 `json:"percent"`
|
|
Amount float64 `json:"amount"`
|
|
PlanDate string `json:"plan_date"`
|
|
ReceivedAmount float64 `json:"received_amount"`
|
|
ReceivedDate string `json:"received_date"`
|
|
Status int8 `json:"status"`
|
|
}
|
|
|
|
// List GET /backend/crm/payback/list
|
|
func (c *BackendCrmPaybackController) List() {
|
|
claims, err := pipelineClaims(&c.Controller)
|
|
if err != nil {
|
|
pipelineErr(&c.Controller, 401, 401, err.Error())
|
|
return
|
|
}
|
|
page, _ := c.GetInt("page", 1)
|
|
pageSize, _ := c.GetInt("pageSize", 20)
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if pageSize < 1 || pageSize > 100 {
|
|
pageSize = 20
|
|
}
|
|
keyword := strings.TrimSpace(c.GetString("keyword"))
|
|
planType := strings.TrimSpace(c.GetString("plan_type"))
|
|
payMethod := strings.TrimSpace(c.GetString("pay_method"))
|
|
status := strings.TrimSpace(c.GetString("status"))
|
|
contractID := strings.TrimSpace(c.GetString("contract_id"))
|
|
|
|
tenantID := pipelineTenantID(claims)
|
|
cond := orm.NewCondition().And("tenant_id", tenantID).And("delete_time__isnull", true)
|
|
if keyword != "" {
|
|
cond = cond.AndCond(orm.NewCondition().
|
|
Or("contract_name__contains", keyword).
|
|
Or("contract_no__contains", keyword).
|
|
Or("customer_name__contains", keyword).
|
|
Or("owner_user_name__contains", keyword))
|
|
}
|
|
if planType != "" {
|
|
cond = cond.And("plan_type", planType)
|
|
}
|
|
if payMethod != "" {
|
|
cond = cond.And("pay_method", payMethod)
|
|
}
|
|
if status != "" {
|
|
cond = cond.And("status", status)
|
|
}
|
|
if contractID != "" {
|
|
if cid, err := strconv.ParseUint(contractID, 10, 64); err == nil && cid > 0 {
|
|
cond = cond.And("contract_id", cid)
|
|
}
|
|
}
|
|
qs := models.Orm.QueryTable(new(models.TenantCrmPayback)).SetCond(cond)
|
|
|
|
total, _ := qs.Count()
|
|
var list []models.TenantCrmPayback
|
|
if total > 0 {
|
|
_, _ = qs.OrderBy("-id").Offset((page - 1) * pageSize).Limit(pageSize).All(&list)
|
|
}
|
|
items := make([]paybackResp, 0, len(list))
|
|
for i := range list {
|
|
items = append(items, buildPaybackResp(&list[i]))
|
|
}
|
|
|
|
// 汇总（当前筛选条件下全部计划的计划总额 / 已回款 / 待回款），用于列表页统计卡片
|
|
var all []models.TenantCrmPayback
|
|
_, _ = models.Orm.QueryTable(new(models.TenantCrmPayback)).SetCond(cond).All(&all)
|
|
var summaryTotal, summaryReceived float64
|
|
for i := range all {
|
|
summaryTotal = round2(summaryTotal + all[i].TotalAmount)
|
|
summaryReceived = round2(summaryReceived + all[i].ReceivedAmount)
|
|
}
|
|
pipelineOk(&c.Controller, map[string]interface{}{
|
|
"list": items, "total": total, "page": page, "pageSize": pageSize,
|
|
"summary": map[string]interface{}{
|
|
"total_amount": summaryTotal,
|
|
"received_amount": summaryReceived,
|
|
"pending_amount": round2(summaryTotal - summaryReceived),
|
|
},
|
|
})
|
|
}
|
|
|
|
// Detail GET /backend/crm/payback/:id
|
|
func (c *BackendCrmPaybackController) Detail() {
|
|
claims, err := pipelineClaims(&c.Controller)
|
|
if err != nil {
|
|
pipelineErr(&c.Controller, 401, 401, err.Error())
|
|
return
|
|
}
|
|
id, _ := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if id == 0 {
|
|
pipelineErr(&c.Controller, 400, 400, "无效的ID")
|
|
return
|
|
}
|
|
var row models.TenantCrmPayback
|
|
if err := models.Orm.QueryTable(new(models.TenantCrmPayback)).
|
|
Filter("id", id).Filter("tenant_id", pipelineTenantID(claims)).
|
|
Filter("delete_time__isnull", true).One(&row); err != nil {
|
|
pipelineErr(&c.Controller, 404, 404, "回款计划未找到")
|
|
return
|
|
}
|
|
pipelineOk(&c.Controller, buildPaybackResp(&row))
|
|
}
|
|
|
|
// Create POST /backend/crm/payback
|
|
func (c *BackendCrmPaybackController) Create() {
|
|
claims, err := pipelineClaims(&c.Controller)
|
|
if err != nil {
|
|
pipelineErr(&c.Controller, 401, 401, err.Error())
|
|
return
|
|
}
|
|
raw, _ := io.ReadAll(c.Ctx.Request.Body)
|
|
var p paybackPayload
|
|
if err := json.Unmarshal(raw, &p); err != nil {
|
|
pipelineErr(&c.Controller, 400, 400, "参数错误")
|
|
return
|
|
}
|
|
if p.ContractID == 0 {
|
|
pipelineErr(&c.Controller, 400, 400, "请先选择关联合同")
|
|
return
|
|
}
|
|
tenantID := pipelineTenantID(claims)
|
|
|
|
itemsJSON, totalAmount, err := normalizePaybackItems(p.Items)
|
|
if err != nil {
|
|
pipelineErr(&c.Controller, 400, 400, "计划明细格式错误")
|
|
return
|
|
}
|
|
if totalAmount <= 0 {
|
|
pipelineErr(&c.Controller, 400, 400, "计划回款总额不能为 0")
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
row := models.TenantCrmPayback{
|
|
TenantID: tenantID,
|
|
ContractNo: strings.TrimSpace(p.ContractNo),
|
|
ContractName: strings.TrimSpace(p.ContractName),
|
|
CustomerName: strings.TrimSpace(p.CustomerName),
|
|
PlanType: pickInt8(p.PlanType, 1, 5),
|
|
PayMethod: pickInt8(p.PayMethod, 1, 7),
|
|
RemindDays: p.RemindDays,
|
|
OwnerUserID: firstNonEmpty(p.OwnerUserID, pipelineUID(claims)),
|
|
OwnerUserName: firstNonEmpty(p.OwnerUserName, resolveUserName(claims)),
|
|
ContractAmount: round2(p.ContractAmount),
|
|
TotalAmount: totalAmount,
|
|
Status: pickInt8(p.Status, 1, 2),
|
|
Items: itemsJSON,
|
|
Remark: p.Remark,
|
|
ReceiptURL: strings.TrimSpace(p.ReceiptURL),
|
|
ReceiptName: strings.TrimSpace(p.ReceiptName),
|
|
CreateUserID: pipelineUID(claims),
|
|
CreateTime: now,
|
|
UpdateTime: now,
|
|
}
|
|
c.fillFromContract(tenantID, p.ContractID, &row)
|
|
applyPaybackReceived(&row)
|
|
|
|
if _, err := models.Orm.Insert(&row); err != nil {
|
|
pipelineErr(&c.Controller, 500, 500, "创建失败: "+err.Error())
|
|
return
|
|
}
|
|
crmWriteLog(tenantID, 4, row.ID, "create", "创建回款计划："+row.ContractName, claims)
|
|
pipelineOk(&c.Controller, map[string]interface{}{"id": row.ID})
|
|
}
|
|
|
|
// Update PUT /backend/crm/payback/:id
|
|
func (c *BackendCrmPaybackController) Update() {
|
|
claims, err := pipelineClaims(&c.Controller)
|
|
if err != nil {
|
|
pipelineErr(&c.Controller, 401, 401, err.Error())
|
|
return
|
|
}
|
|
id, _ := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if id == 0 {
|
|
pipelineErr(&c.Controller, 400, 400, "无效的ID")
|
|
return
|
|
}
|
|
raw, _ := io.ReadAll(c.Ctx.Request.Body)
|
|
var p paybackPayload
|
|
if err := json.Unmarshal(raw, &p); err != nil {
|
|
pipelineErr(&c.Controller, 400, 400, "参数错误")
|
|
return
|
|
}
|
|
tenantID := pipelineTenantID(claims)
|
|
var row models.TenantCrmPayback
|
|
if err := models.Orm.QueryTable(new(models.TenantCrmPayback)).
|
|
Filter("id", id).Filter("tenant_id", tenantID).
|
|
Filter("delete_time__isnull", true).One(&row); err != nil {
|
|
pipelineErr(&c.Controller, 404, 404, "回款计划未找到")
|
|
return
|
|
}
|
|
|
|
if p.ContractID > 0 {
|
|
row.ContractID = &p.ContractID
|
|
row.ContractNo = strings.TrimSpace(p.ContractNo)
|
|
row.ContractName = strings.TrimSpace(p.ContractName)
|
|
row.CustomerName = strings.TrimSpace(p.CustomerName)
|
|
c.fillFromContract(tenantID, p.ContractID, &row)
|
|
}
|
|
if p.PlanType != 0 {
|
|
row.PlanType = pickInt8(p.PlanType, 1, 5)
|
|
}
|
|
if p.PayMethod != 0 {
|
|
row.PayMethod = pickInt8(p.PayMethod, 1, 7)
|
|
}
|
|
row.RemindDays = p.RemindDays
|
|
if strings.TrimSpace(p.OwnerUserID) != "" {
|
|
row.OwnerUserID = strings.TrimSpace(p.OwnerUserID)
|
|
}
|
|
if strings.TrimSpace(p.OwnerUserName) != "" {
|
|
row.OwnerUserName = strings.TrimSpace(p.OwnerUserName)
|
|
}
|
|
if p.ContractAmount > 0 {
|
|
row.ContractAmount = round2(p.ContractAmount)
|
|
}
|
|
row.Remark = p.Remark
|
|
row.ReceiptURL = strings.TrimSpace(p.ReceiptURL)
|
|
row.ReceiptName = strings.TrimSpace(p.ReceiptName)
|
|
if p.Status != 0 {
|
|
row.Status = pickInt8(p.Status, 1, 2)
|
|
}
|
|
if p.Items != nil {
|
|
itemsJSON, _, err := normalizePaybackItems(p.Items)
|
|
if err != nil {
|
|
pipelineErr(&c.Controller, 400, 400, "计划明细格式错误")
|
|
return
|
|
}
|
|
row.Items = itemsJSON
|
|
}
|
|
applyPaybackReceived(&row)
|
|
row.UpdateTime = time.Now()
|
|
|
|
if _, err := models.Orm.Update(&row); err != nil {
|
|
pipelineErr(&c.Controller, 500, 500, "更新失败: "+err.Error())
|
|
return
|
|
}
|
|
crmWriteLog(tenantID, 4, row.ID, "update", "更新回款计划："+row.ContractName, claims)
|
|
pipelineOk(&c.Controller, map[string]interface{}{"id": row.ID})
|
|
}
|
|
|
|
// Delete DELETE /backend/crm/payback/:id
|
|
func (c *BackendCrmPaybackController) Delete() {
|
|
claims, err := pipelineClaims(&c.Controller)
|
|
if err != nil {
|
|
pipelineErr(&c.Controller, 401, 401, err.Error())
|
|
return
|
|
}
|
|
id, _ := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if id == 0 {
|
|
pipelineErr(&c.Controller, 400, 400, "无效的ID")
|
|
return
|
|
}
|
|
tenantID := pipelineTenantID(claims)
|
|
var row models.TenantCrmPayback
|
|
if err := models.Orm.QueryTable(new(models.TenantCrmPayback)).
|
|
Filter("id", id).Filter("tenant_id", tenantID).
|
|
Filter("delete_time__isnull", true).One(&row); err != nil {
|
|
pipelineErr(&c.Controller, 404, 404, "回款计划未找到")
|
|
return
|
|
}
|
|
if !canDeleteCrmRecord(claims, row.CreateUserID) {
|
|
pipelineErr(&c.Controller, 403, 403, "只有创建人、租户管理员或平台管理员可以删除该回款计划")
|
|
return
|
|
}
|
|
now := time.Now()
|
|
_, err = models.Orm.QueryTable(new(models.TenantCrmPayback)).
|
|
Filter("id", id).Filter("tenant_id", tenantID).
|
|
Update(map[string]interface{}{"delete_time": now, "update_time": now})
|
|
if err != nil {
|
|
pipelineErr(&c.Controller, 500, 500, "删除失败: "+err.Error())
|
|
return
|
|
}
|
|
pipelineOk(&c.Controller, nil)
|
|
}
|
|
|
|
// ProgressList GET /backend/crm/payback/progress/list
|
|
// 回款进度：把全部回款计划的分期明细摊平返回，并汇总计划总额 / 已回款总额。
|
|
func (c *BackendCrmPaybackController) ProgressList() {
|
|
claims, err := pipelineClaims(&c.Controller)
|
|
if err != nil {
|
|
pipelineErr(&c.Controller, 401, 401, err.Error())
|
|
return
|
|
}
|
|
tenantID := pipelineTenantID(claims)
|
|
keyword := strings.TrimSpace(c.GetString("keyword"))
|
|
status := strings.TrimSpace(c.GetString("status"))
|
|
contractID := strings.TrimSpace(c.GetString("contract_id"))
|
|
|
|
cond := orm.NewCondition().And("tenant_id", tenantID).And("delete_time__isnull", true)
|
|
if keyword != "" {
|
|
cond = cond.AndCond(orm.NewCondition().
|
|
Or("contract_name__contains", keyword).
|
|
Or("customer_name__contains", keyword).
|
|
Or("owner_user_name__contains", keyword))
|
|
}
|
|
if contractID != "" {
|
|
if cid, err := strconv.ParseUint(contractID, 10, 64); err == nil && cid > 0 {
|
|
cond = cond.And("contract_id", cid)
|
|
}
|
|
}
|
|
var list []models.TenantCrmPayback
|
|
_, _ = models.Orm.QueryTable(new(models.TenantCrmPayback)).SetCond(cond).OrderBy("-id").All(&list)
|
|
|
|
rows := make([]paybackProgress, 0)
|
|
var totalPlanned, totalReceived float64
|
|
for i := range list {
|
|
p := list[i]
|
|
for _, it := range parsePaybackItems(p.Items) {
|
|
st := it.Status
|
|
if st == 0 {
|
|
st = itemStatus(it.ReceivedAmount, it.Amount)
|
|
}
|
|
if status != "" && fmt.Sprintf("%d", st) != status {
|
|
continue
|
|
}
|
|
totalPlanned = round2(totalPlanned + it.Amount)
|
|
totalReceived = round2(totalReceived + it.ReceivedAmount)
|
|
rows = append(rows, paybackProgress{
|
|
PaybackID: p.ID,
|
|
ContractID: p.ContractID,
|
|
ContractNo: p.ContractNo,
|
|
ContractName: p.ContractName,
|
|
CustomerName: p.CustomerName,
|
|
OwnerUserName: p.OwnerUserName,
|
|
PlanType: p.PlanType,
|
|
PayMethod: p.PayMethod,
|
|
Seq: it.Seq,
|
|
Name: it.Name,
|
|
Percent: it.Percent,
|
|
Amount: it.Amount,
|
|
PlanDate: it.PlanDate,
|
|
ReceivedAmount: it.ReceivedAmount,
|
|
ReceivedDate: it.ReceivedDate,
|
|
Status: st,
|
|
})
|
|
}
|
|
}
|
|
pipelineOk(&c.Controller, map[string]interface{}{
|
|
"list": rows, "total": len(rows),
|
|
"total_planned": totalPlanned, "total_received": totalReceived,
|
|
})
|
|
}
|
|
|
|
// Receive POST /backend/crm/payback/:id/receive
|
|
// 回款进度登记：按明细序号写入实收金额 / 回款日期，并重算计划汇总。
|
|
func (c *BackendCrmPaybackController) Receive() {
|
|
claims, err := pipelineClaims(&c.Controller)
|
|
if err != nil {
|
|
pipelineErr(&c.Controller, 401, 401, err.Error())
|
|
return
|
|
}
|
|
id, _ := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if id == 0 {
|
|
pipelineErr(&c.Controller, 400, 400, "无效的ID")
|
|
return
|
|
}
|
|
raw, _ := io.ReadAll(c.Ctx.Request.Body)
|
|
var p struct {
|
|
Seq int `json:"seq"`
|
|
ReceivedAmount float64 `json:"received_amount"`
|
|
ReceivedDate string `json:"received_date"`
|
|
ReceiptURL string `json:"receipt_url"` // 流水回执地址（选填）
|
|
ReceiptName string `json:"receipt_name"` // 流水回执文件名（选填）
|
|
}
|
|
if err := json.Unmarshal(raw, &p); err != nil {
|
|
pipelineErr(&c.Controller, 400, 400, "参数错误")
|
|
return
|
|
}
|
|
tenantID := pipelineTenantID(claims)
|
|
var row models.TenantCrmPayback
|
|
if err := models.Orm.QueryTable(new(models.TenantCrmPayback)).
|
|
Filter("id", id).Filter("tenant_id", tenantID).
|
|
Filter("delete_time__isnull", true).One(&row); err != nil {
|
|
pipelineErr(&c.Controller, 404, 404, "回款计划未找到")
|
|
return
|
|
}
|
|
items := parsePaybackItems(row.Items)
|
|
matched := false
|
|
for i := range items {
|
|
if items[i].Seq != p.Seq {
|
|
continue
|
|
}
|
|
items[i].ReceivedAmount = round2(p.ReceivedAmount)
|
|
items[i].ReceivedDate = strings.TrimSpace(p.ReceivedDate)
|
|
items[i].ReceiptURL = strings.TrimSpace(p.ReceiptURL)
|
|
items[i].ReceiptName = strings.TrimSpace(p.ReceiptName)
|
|
items[i].Status = itemStatus(items[i].ReceivedAmount, items[i].Amount)
|
|
matched = true
|
|
break
|
|
}
|
|
if !matched {
|
|
pipelineErr(&c.Controller, 404, 404, "计划明细不存在")
|
|
return
|
|
}
|
|
out, err := json.Marshal(items)
|
|
if err != nil {
|
|
pipelineErr(&c.Controller, 500, 500, "保存失败")
|
|
return
|
|
}
|
|
row.Items = string(out)
|
|
applyPaybackReceived(&row)
|
|
row.UpdateTime = time.Now()
|
|
if _, err := models.Orm.Update(&row); err != nil {
|
|
pipelineErr(&c.Controller, 500, 500, "保存失败: "+err.Error())
|
|
return
|
|
}
|
|
crmWriteLog(tenantID, 4, row.ID, "receive", fmt.Sprintf("回款登记：%s 第 %d 期 %s 元", row.ContractName, p.Seq, formatAmount(p.ReceivedAmount)), claims)
|
|
pipelineOk(&c.Controller, buildPaybackResp(&row))
|
|
}
|
|
|
|
// ========================== 内部辅助 ==========================
|
|
|
|
// buildPaybackResp 组装响应：items 透传 JSON 数组。
|
|
func buildPaybackResp(row *models.TenantCrmPayback) paybackResp {
|
|
items := json.RawMessage("[]")
|
|
if strings.TrimSpace(row.Items) != "" {
|
|
items = json.RawMessage(row.Items)
|
|
}
|
|
return paybackResp{TenantCrmPayback: *row, Items: items}
|
|
}
|
|
|
|
// parsePaybackItems 解析明细 JSON（容错：空 / 非法时返回空数组）。
|
|
func parsePaybackItems(raw string) []paybackItem {
|
|
items := make([]paybackItem, 0)
|
|
if strings.TrimSpace(raw) == "" {
|
|
return items
|
|
}
|
|
_ = json.Unmarshal([]byte(raw), &items)
|
|
return items
|
|
}
|
|
|
|
// normalizePaybackItems 校验并规范化明细 JSON：补齐序号、金额取两位小数，返回紧凑 JSON 与计划总额。
|
|
func normalizePaybackItems(raw json.RawMessage) (string, float64, error) {
|
|
if len(raw) == 0 || strings.TrimSpace(string(raw)) == "" || strings.TrimSpace(string(raw)) == "null" {
|
|
return "[]", 0, nil
|
|
}
|
|
var arr []map[string]interface{}
|
|
if err := json.Unmarshal(raw, &arr); err != nil {
|
|
return "", 0, err
|
|
}
|
|
items := make([]paybackItem, 0, len(arr))
|
|
var total float64
|
|
for i, m := range arr {
|
|
it := paybackItem{
|
|
Seq: i + 1,
|
|
Name: strings.TrimSpace(strVal(m["name"])),
|
|
Percent: round2(toFloat64(m["percent"])),
|
|
Amount: round2(toFloat64(m["amount"])),
|
|
PlanDate: strings.TrimSpace(strVal(m["plan_date"])),
|
|
ReceivedAmount: round2(toFloat64(m["received_amount"])),
|
|
ReceivedDate: strings.TrimSpace(strVal(m["received_date"])),
|
|
}
|
|
if v, ok := m["receipt_url"]; ok && v != nil {
|
|
it.ReceiptURL = strings.TrimSpace(fmt.Sprintf("%v", v))
|
|
}
|
|
if v, ok := m["receipt_name"]; ok && v != nil {
|
|
it.ReceiptName = strings.TrimSpace(fmt.Sprintf("%v", v))
|
|
}
|
|
if v, ok := m["seq"]; ok {
|
|
if s := int(toFloat64(v)); s > 0 {
|
|
it.Seq = s
|
|
}
|
|
}
|
|
it.Status = itemStatus(it.ReceivedAmount, it.Amount)
|
|
total = round2(total + it.Amount)
|
|
items = append(items, it)
|
|
}
|
|
out, err := json.Marshal(items)
|
|
if err != nil {
|
|
return "", 0, err
|
|
}
|
|
return string(out), total, nil
|
|
}
|
|
|
|
// itemStatus 由实收金额推导明细状态：0/空=未回款 1、部分回款 2、已回款 3。
|
|
func itemStatus(received, amount float64) int8 {
|
|
if amount > 0 && received >= amount {
|
|
return 3
|
|
}
|
|
if received > 0 {
|
|
return 2
|
|
}
|
|
return 1
|
|
}
|
|
|
|
// strVal 安全取字符串：nil / 非字符串时返回空串，避免写出 "<nil>"。
|
|
func strVal(v interface{}) string {
|
|
if v == nil {
|
|
return ""
|
|
}
|
|
if s, ok := v.(string); ok {
|
|
return s
|
|
}
|
|
return fmt.Sprintf("%v", v)
|
|
}
|
|
|
|
// applyPaybackReceived 按明细重算计划总额、已回款金额与状态。
|
|
func applyPaybackReceived(row *models.TenantCrmPayback) {
|
|
items := parsePaybackItems(row.Items)
|
|
var total, received float64
|
|
allDone := len(items) > 0
|
|
for i := range items {
|
|
if items[i].Status == 0 {
|
|
items[i].Status = itemStatus(items[i].ReceivedAmount, items[i].Amount)
|
|
}
|
|
if items[i].Status != 3 {
|
|
allDone = false
|
|
}
|
|
total = round2(total + items[i].Amount)
|
|
received = round2(received + items[i].ReceivedAmount)
|
|
}
|
|
row.TotalAmount = total
|
|
row.ReceivedAmount = received
|
|
if out, err := json.Marshal(items); err == nil {
|
|
row.Items = string(out)
|
|
}
|
|
// 状态：1进行中 / 2已完成（全部明细回款完成）
|
|
if allDone {
|
|
row.Status = 2
|
|
} else if row.Status == 0 {
|
|
row.Status = 1
|
|
}
|
|
}
|
|
|
|
// fillFromContract 由关联合同补齐合同编号 / 名称 / 客户 / 合同金额（仅在字段为空时填充）。
|
|
func (c *BackendCrmPaybackController) fillFromContract(tenantID string, contractID uint64, row *models.TenantCrmPayback) {
|
|
if contractID == 0 {
|
|
return
|
|
}
|
|
var ct models.TenantCrmContract
|
|
if err := models.Orm.QueryTable(new(models.TenantCrmContract)).
|
|
Filter("id", contractID).Filter("tenant_id", tenantID).
|
|
Filter("delete_time__isnull", true).One(&ct); err != nil {
|
|
return
|
|
}
|
|
row.ContractID = &ct.ID
|
|
if row.ContractNo == "" {
|
|
row.ContractNo = ct.ContractNo
|
|
}
|
|
if row.ContractName == "" {
|
|
row.ContractName = ct.ContractName
|
|
}
|
|
if row.ContractAmount <= 0 {
|
|
row.ContractAmount = ct.TotalAmount
|
|
}
|
|
if row.CustomerName == "" {
|
|
var parties []map[string]interface{}
|
|
_ = json.Unmarshal([]byte(ct.Parties), &parties)
|
|
for _, party := range parties {
|
|
if fmt.Sprintf("%v", party["ref_type"]) != "1" {
|
|
continue
|
|
}
|
|
row.CustomerName = strings.TrimSpace(strVal(party["ref_name"]))
|
|
if cid := uint64(toFloat64(party["ref_id"])); cid > 0 {
|
|
row.CustomerID = &cid
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// formatAmount 金额文案（用于操作日志）。
|
|
func formatAmount(n float64) string {
|
|
return strconv.FormatFloat(round2(n), 'f', 2, 64)
|
|
}
|