Files
yunzerwebsiteallinone/go/controllers/backend_crm_payback.go
T
2026-11-16 17:22:50 +08:00

1039 lines
32 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package controllers
import (
"encoding/json"
"fmt"
"io"
"strconv"
"strings"
"time"
"server/models"
"server/pkg/identity"
"server/services"
"github.com/beego/beego/v2/client/orm"
beego "github.com/beego/beego/v2/server/web"
)
type BackendCrmPaybackController struct {
beego.Controller
}
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"`
}
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"`
}
type paybackResp struct {
models.TenantCrmPayback
Items json.RawMessage `json:"items"`
Children []models.TenantCrmPaybackRecord `json:"children"`
}
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"`
}
func (c *BackendCrmPaybackController) List() {
claims, err := pipelineClaims(&c.Controller)
if err != nil {
code := identity.Status(err)
pipelineErr(&c.Controller, code, code, 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)
cond = crmApplyOwnerScope(cond, claims)
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("status", "-id").Offset((page - 1) * pageSize).Limit(pageSize).All(&list)
}
planIDs := make([]uint64, 0, len(list))
for i := range list {
planIDs = append(planIDs, list[i].ID)
}
recordsByPlan := make(map[uint64][]models.TenantCrmPaybackRecord, len(list))
if len(planIDs) > 0 {
var recs []models.TenantCrmPaybackRecord
_, _ = models.Orm.QueryTable(new(models.TenantCrmPaybackRecord)).
Filter("tenant_id", tenantID).
Filter("payback_id__in", planIDs).
Filter("delete_time__isnull", true).
OrderBy("-received_date", "-id").All(&recs)
for _, r := range recs {
recordsByPlan[r.PaybackID] = append(recordsByPlan[r.PaybackID], r)
}
}
items := make([]paybackResp, 0, len(list))
for i := range list {
resp := buildPaybackResp(&list[i])
if recs := recordsByPlan[list[i].ID]; len(recs) > 0 {
resp.Children = recs
} else {
resp.Children = []models.TenantCrmPaybackRecord{}
}
items = append(items, resp)
}
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),
},
})
}
func (c *BackendCrmPaybackController) Detail() {
claims, err := pipelineClaims(&c.Controller)
if err != nil {
code := identity.Status(err)
pipelineErr(&c.Controller, code, code, 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))
}
func (c *BackendCrmPaybackController) Create() {
claims, err := pipelineClaims(&c.Controller)
if err != nil {
code := identity.Status(err)
pipelineErr(&c.Controller, code, code, 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)
if paybackContractPaidOff(tenantID, p.ContractID) {
pipelineErr(&c.Controller, 400, 400, "回款已全部完成(进度 100%),不可再新建回款计划")
return
}
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)
if row.ContractID != nil {
services.SyncPaybackOverdueForContract(tenantID, *row.ContractID)
}
pipelineOk(&c.Controller, map[string]interface{}{"id": row.ID})
}
func (c *BackendCrmPaybackController) Update() {
claims, err := pipelineClaims(&c.Controller)
if err != nil {
code := identity.Status(err)
pipelineErr(&c.Controller, code, code, 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 !canAccessCrmRecord(claims, row.OwnerUserID, row.CreateUserID) {
pipelineErr(&c.Controller, 403, 403, "无权操作该回款计划数据")
return
}
if row.Status == 2 {
pipelineErr(&c.Controller, 400, 400, "该回款计划已完成(回款已收齐),不允许编辑")
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
if strings.TrimSpace(p.ReceiptURL) != "" {
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, total, err := normalizePaybackItems(p.Items)
if err != nil {
pipelineErr(&c.Controller, 400, 400, "计划明细格式错误")
return
}
row.Items = itemsJSON
row.TotalAmount = total
}
row.UpdateTime = time.Now()
if _, err := models.Orm.Update(&row); err != nil {
pipelineErr(&c.Controller, 500, 500, "更新失败: "+err.Error())
return
}
refreshPlanReceived(tenantID, row.ID)
if row.ContractID != nil {
services.SyncPaybackOverdueForContract(tenantID, *row.ContractID)
}
crmWriteLog(tenantID, 4, row.ID, "update", "更新回款计划:"+row.ContractName, claims)
pipelineOk(&c.Controller, map[string]interface{}{"id": row.ID})
}
func (c *BackendCrmPaybackController) Delete() {
claims, err := pipelineClaims(&c.Controller)
if err != nil {
code := identity.Status(err)
pipelineErr(&c.Controller, code, code, 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 !canAccessCrmRecord(claims, row.OwnerUserID, row.CreateUserID) {
pipelineErr(&c.Controller, 403, 403, "无权操作该回款计划数据")
return
}
if !canDeleteCrmRecord(claims, row.CreateUserID) {
pipelineErr(&c.Controller, 403, 403, "只有创建人、租户管理员或平台管理员可以删除该回款计划")
return
}
if row.Status == 2 {
pipelineErr(&c.Controller, 400, 400, "该回款计划已完成(回款已收齐),不允许删除")
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)
}
func (c *BackendCrmPaybackController) ProgressList() {
claims, err := pipelineClaims(&c.Controller)
if err != nil {
code := identity.Status(err)
pipelineErr(&c.Controller, code, code, 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)
cond = crmApplyOwnerScope(cond, claims)
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,
})
}
func (c *BackendCrmPaybackController) Receive() {
claims, err := pipelineClaims(&c.Controller)
if err != nil {
code := identity.Status(err)
pipelineErr(&c.Controller, code, code, 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
}
if !canAccessCrmRecord(claims, row.OwnerUserID, row.CreateUserID) {
pipelineErr(&c.Controller, 403, 403, "无权操作该回款计划数据")
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)
if row.ContractID != nil {
services.SyncPaybackOverdueForContract(tenantID, *row.ContractID)
}
pipelineOk(&c.Controller, buildPaybackResp(&row))
}
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}
}
func parsePaybackItems(raw string) []paybackItem {
items := make([]paybackItem, 0)
if strings.TrimSpace(raw) == "" {
return items
}
_ = json.Unmarshal([]byte(raw), &items)
return items
}
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
}
func itemStatus(received, amount float64) int8 {
if amount > 0 && received >= amount {
return 3
}
if received > 0 {
return 2
}
return 1
}
func strVal(v interface{}) string {
if v == nil {
return ""
}
if s, ok := v.(string); ok {
return s
}
return fmt.Sprintf("%v", v)
}
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)
}
if allDone {
row.Status = 2
} else if row.Status == 0 {
row.Status = 1
}
}
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
}
}
}
func formatAmount(n float64) string {
return strconv.FormatFloat(round2(n), 'f', 2, 64)
}
func (c *BackendCrmPaybackController) RecordList() {
claims, err := pipelineClaims(&c.Controller)
if err != nil {
code := identity.Status(err)
pipelineErr(&c.Controller, code, code, err.Error())
return
}
tenantID := pipelineTenantID(claims)
contractID, _ := c.GetUint64("contract_id")
paybackID, _ := c.GetUint64("payback_id")
cond := orm.NewCondition().And("tenant_id", tenantID).And("delete_time__isnull", true)
cond = crmApplyOwnerScope(cond, claims)
if contractID > 0 {
cond = cond.And("contract_id", contractID)
}
if paybackID > 0 {
cond = cond.And("payback_id", paybackID)
}
list := make([]models.TenantCrmPaybackRecord, 0)
_, _ = models.Orm.QueryTable(new(models.TenantCrmPaybackRecord)).
SetCond(cond).OrderBy("-received_date", "-id").All(&list)
var totalPlanned, totalReceived float64
planCond := orm.NewCondition().And("tenant_id", tenantID).And("delete_time__isnull", true)
planCond = crmApplyOwnerScope(planCond, claims)
if contractID > 0 {
planCond = planCond.And("contract_id", contractID)
}
var plans []models.TenantCrmPayback
_, _ = models.Orm.QueryTable(new(models.TenantCrmPayback)).SetCond(planCond).All(&plans)
for _, p := range plans {
totalPlanned = round2(totalPlanned + p.TotalAmount)
totalReceived = round2(totalReceived + p.ReceivedAmount)
}
pipelineOk(&c.Controller, map[string]interface{}{
"list": list, "total": len(list),
"total_planned": totalPlanned, "total_received": totalReceived,
})
}
func (c *BackendCrmPaybackController) CreateRecord() {
claims, err := pipelineClaims(&c.Controller)
if err != nil {
code := identity.Status(err)
pipelineErr(&c.Controller, code, code, err.Error())
return
}
raw, _ := io.ReadAll(c.Ctx.Request.Body)
var p struct {
PaybackID uint64 `json:"payback_id"`
ItemSeq int `json:"item_seq"`
Amount float64 `json:"amount"`
ReceivedDate string `json:"received_date"`
PayMethod int8 `json:"pay_method"`
ReceiptURL string `json:"receipt_url"`
ReceiptName string `json:"receipt_name"`
Remark string `json:"remark"`
}
if err := json.Unmarshal(raw, &p); err != nil {
pipelineErr(&c.Controller, 400, 400, "参数错误")
return
}
if p.PaybackID == 0 {
pipelineErr(&c.Controller, 400, 400, "请先选择回款计划")
return
}
if round2(p.Amount) <= 0 {
pipelineErr(&c.Controller, 400, 400, "请填写本次回款金额")
return
}
tenantID := pipelineTenantID(claims)
var plan models.TenantCrmPayback
if err := models.Orm.QueryTable(new(models.TenantCrmPayback)).
Filter("id", p.PaybackID).Filter("tenant_id", tenantID).
Filter("delete_time__isnull", true).One(&plan); err != nil {
pipelineErr(&c.Controller, 404, 404, "回款计划不存在")
return
}
if plan.Status == 2 {
pipelineErr(&c.Controller, 400, 400, "该回款计划已完成(回款已收齐),不可再新建回款记录")
return
}
payMethod := p.PayMethod
if payMethod <= 0 {
payMethod = plan.PayMethod
}
itemSeq := 0
itemName := ""
if p.ItemSeq > 0 {
for _, it := range parsePaybackItems(plan.Items) {
if it.Seq == p.ItemSeq {
itemSeq = it.Seq
itemName = it.Name
break
}
}
if itemSeq == 0 {
pipelineErr(&c.Controller, 400, 400, "计划明细节点不存在")
return
}
}
var contractID *uint64
if plan.ContractID != nil {
cid := *plan.ContractID
contractID = &cid
}
now := time.Now()
row := models.TenantCrmPaybackRecord{
TenantID: tenantID,
ContractID: contractID,
PaybackID: plan.ID,
ItemSeq: itemSeq,
ItemName: itemName,
Amount: round2(p.Amount),
ReceivedDate: strings.TrimSpace(p.ReceivedDate),
PayMethod: payMethod,
ReceiptURL: strings.TrimSpace(p.ReceiptURL),
ReceiptName: strings.TrimSpace(p.ReceiptName),
Remark: strings.TrimSpace(p.Remark),
OwnerUserID: plan.OwnerUserID,
OwnerUserName: plan.OwnerUserName,
CreateUserID: pipelineUID(claims),
CreateTime: now,
UpdateTime: now,
}
id, ierr := models.Orm.Insert(&row)
if ierr != nil {
pipelineErr(&c.Controller, 500, 500, "保存失败: "+ierr.Error())
return
}
refreshPlanReceived(tenantID, plan.ID)
if contractID != nil {
crmWriteLog(tenantID, 6, *contractID, "payback",
fmt.Sprintf("新建回款:%s 元(%s)", formatAmount(row.Amount), row.ReceivedDate), claims)
}
pipelineOk(&c.Controller, map[string]interface{}{"id": id})
}
func (c *BackendCrmPaybackController) DeleteRecord() {
claims, err := pipelineClaims(&c.Controller)
if err != nil {
code := identity.Status(err)
pipelineErr(&c.Controller, code, code, 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.TenantCrmPaybackRecord
if err := models.Orm.QueryTable(new(models.TenantCrmPaybackRecord)).
Filter("id", id).Filter("tenant_id", tenantID).
Filter("delete_time__isnull", true).One(&row); err != nil {
pipelineErr(&c.Controller, 404, 404, "回款记录不存在")
return
}
var plan models.TenantCrmPayback
if err := models.Orm.QueryTable(new(models.TenantCrmPayback)).
Filter("id", row.PaybackID).Filter("tenant_id", tenantID).
Filter("delete_time__isnull", true).One(&plan); err == nil && plan.Status == 2 {
pipelineErr(&c.Controller, 400, 400, "所属回款计划已完成(回款已收齐),不允许删除回款记录")
return
}
now := time.Now()
if _, err := models.Orm.QueryTable(new(models.TenantCrmPaybackRecord)).
Filter("id", id).Filter("tenant_id", tenantID).
Update(orm.Params{"delete_time": now, "update_time": now}); err != nil {
pipelineErr(&c.Controller, 500, 500, "删除失败: "+err.Error())
return
}
refreshPlanReceived(tenantID, row.PaybackID)
if row.ContractID != nil {
services.SyncPaybackOverdueForContract(tenantID, *row.ContractID)
}
pipelineOk(&c.Controller, map[string]interface{}{"id": id})
}
func (c *BackendCrmPaybackController) UpdateRecord() {
claims, err := pipelineClaims(&c.Controller)
if err != nil {
code := identity.Status(err)
pipelineErr(&c.Controller, code, code, 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 {
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.TenantCrmPaybackRecord
if err := models.Orm.QueryTable(new(models.TenantCrmPaybackRecord)).
Filter("id", id).Filter("tenant_id", tenantID).
Filter("delete_time__isnull", true).One(&row); err != nil {
pipelineErr(&c.Controller, 404, 404, "回款记录不存在")
return
}
now := time.Now()
if _, uerr := models.Orm.QueryTable(new(models.TenantCrmPaybackRecord)).
Filter("id", id).Filter("tenant_id", tenantID).
Update(orm.Params{
"receipt_url": strings.TrimSpace(p.ReceiptURL),
"receipt_name": strings.TrimSpace(p.ReceiptName),
"update_time": now,
}); uerr != nil {
pipelineErr(&c.Controller, 500, 500, "更新失败: "+uerr.Error())
return
}
pipelineOk(&c.Controller, map[string]interface{}{
"id": id,
"receipt_url": strings.TrimSpace(p.ReceiptURL),
"receipt_name": strings.TrimSpace(p.ReceiptName),
})
}
func paybackOverdueDateByContracts(tenantID string, contractIDs []uint64) map[uint64]string {
out := make(map[uint64]string)
if models.Orm == nil || tenantID == "" || len(contractIDs) == 0 {
return out
}
today := time.Now().Format("2006-01-02")
var plans []models.TenantCrmPayback
if _, err := models.Orm.QueryTable(new(models.TenantCrmPayback)).
Filter("tenant_id", tenantID).
Filter("contract_id__in", contractIDs).
Filter("delete_time__isnull", true).
Filter("status__ne", 2).
All(&plans, "id", "contract_id", "items"); err != nil {
return out
}
if len(plans) == 0 {
return out
}
planIDs := make([]uint64, 0, len(plans))
for i := range plans {
planIDs = append(planIDs, plans[i].ID)
}
var recs []models.TenantCrmPaybackRecord
_, _ = models.Orm.QueryTable(new(models.TenantCrmPaybackRecord)).
Filter("payback_id__in", planIDs).
Filter("delete_time__isnull", true).
All(&recs, "payback_id", "item_seq", "amount")
receivedByPlan := make(map[uint64]map[int]float64, len(plans))
for _, r := range recs {
if r.ItemSeq <= 0 {
continue
}
m := receivedByPlan[r.PaybackID]
if m == nil {
m = make(map[int]float64)
receivedByPlan[r.PaybackID] = m
}
m[r.ItemSeq] += r.Amount
}
for i := range plans {
plan := plans[i]
if plan.ContractID == nil || *plan.ContractID == 0 {
continue
}
date := paybackPlanEarliestOverdueDate(plan, receivedByPlan[plan.ID], today)
if date == "" {
continue
}
cid := *plan.ContractID
if cur, ok := out[cid]; !ok || date < cur {
out[cid] = date
}
}
return out
}
func paybackPlanEarliestOverdueDate(plan models.TenantCrmPayback, receivedBySeq map[int]float64, today string) string {
items := parsePaybackItems(plan.Items)
if len(items) == 0 {
return ""
}
earliest := ""
for _, it := range items {
received := receivedBySeq[it.Seq]
if it.ReceivedAmount > received {
received = it.ReceivedAmount
}
if it.Amount > 0 && received >= it.Amount {
continue
}
planDate := strings.TrimSpace(it.PlanDate)
if len(planDate) > 10 {
planDate = planDate[:10]
}
if planDate == "" || planDate >= today {
continue
}
if earliest == "" || planDate < earliest {
earliest = planDate
}
}
return earliest
}
func paybackContractPaidOff(tenantID string, contractID uint64) bool {
if contractID == 0 {
return false
}
var plans []models.TenantCrmPayback
_, _ = models.Orm.QueryTable(new(models.TenantCrmPayback)).
Filter("tenant_id", tenantID).
Filter("contract_id", contractID).
Filter("delete_time__isnull", true).All(&plans)
var planned, received float64
for _, p := range plans {
planned = round2(planned + p.TotalAmount)
received = round2(received + p.ReceivedAmount)
}
return planned > 0 && received+0.005 >= planned
}
func refreshPlanReceived(tenantID string, paybackID uint64) {
if paybackID == 0 {
return
}
var rows []orm.Params
sql := "SELECT IFNULL(SUM(amount),0) AS received FROM " +
new(models.TenantCrmPaybackRecord).TableName() +
" WHERE tenant_id = ? AND payback_id = ? AND delete_time IS NULL"
if _, err := models.Orm.Raw(sql, tenantID, paybackID).Values(&rows); err != nil || len(rows) == 0 {
return
}
received := round2(toFloat64(rows[0]["received"]))
var plan models.TenantCrmPayback
if err := models.Orm.QueryTable(new(models.TenantCrmPayback)).
Filter("id", paybackID).Filter("tenant_id", tenantID).
Filter("delete_time__isnull", true).One(&plan); err != nil {
return
}
status := int8(1)
if plan.TotalAmount > 0 && received+0.005 >= plan.TotalAmount {
status = 2
}
_, _ = models.Orm.QueryTable(new(models.TenantCrmPayback)).
Filter("id", paybackID).Filter("tenant_id", tenantID).
Update(orm.Params{"received_amount": received, "status": status, "update_time": time.Now()})
}