MiFaZhan
633 lines
21 KiB
Go
633 lines
21 KiB
Go
package renewchange
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gogf/gf/v2/database/gdb"
|
|
"github.com/gogf/gf/v2/encoding/gjson"
|
|
"github.com/gogf/gf/v2/errors/gerror"
|
|
"github.com/gogf/gf/v2/frame/g"
|
|
"github.com/gogf/gf/v2/os/gtime"
|
|
|
|
"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/consts"
|
|
rc "git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/repository/renewchange"
|
|
)
|
|
|
|
const (
|
|
renewFinanceAccountStatusNormal = 0
|
|
renewFinanceIncomeExpenseExpense = 1
|
|
)
|
|
|
|
type renewPaymentAccountRow struct {
|
|
ID int64 `orm:"id"`
|
|
Balance float64 `orm:"balance"`
|
|
Status int `orm:"status"`
|
|
}
|
|
|
|
func (r *RenewExecutor) ensureRenewExecutionContract(
|
|
ctx context.Context,
|
|
tx gdb.TX,
|
|
main *rc.BatchMainRow,
|
|
details []*rc.BatchDetailRow,
|
|
cards map[string]*rc.SimCardInfo,
|
|
binds map[string]*rc.SimCardBindPkg,
|
|
futureBinds map[string][]*rc.SimCardBindPkg,
|
|
now time.Time,
|
|
) (*ExecutionContract, error) {
|
|
if contract, err := ParseExecutionContract(main); err == nil {
|
|
if err = r.validateRenewRuntimePermissions(ctx, tx, main, contract); err != nil {
|
|
return nil, err
|
|
}
|
|
return contract, nil
|
|
}
|
|
|
|
info := main.BatchInfo
|
|
if info == nil || info.IsNil() {
|
|
return nil, gerror.New("续费批次缺少导入参数")
|
|
}
|
|
durationValue := firstInt(info, "durationValue", "durationYears")
|
|
if durationValue <= 0 {
|
|
durationValue = normalizeLegacyRenewDurationValue(firstInt(info, "durationMonths"))
|
|
}
|
|
if durationValue <= 0 {
|
|
return nil, gerror.New("续费时长不能为空")
|
|
}
|
|
giftDurationMonths := firstInt(info, "giftDurationMonths")
|
|
if giftDurationMonths < 0 {
|
|
return nil, gerror.New("赠送时长不能小于0")
|
|
}
|
|
|
|
iccids, err := strictIccidsFromDetails(details)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
customerID, packageCode, beginDates, err := runtimeRenewFacts(main, details, cards, binds, futureBinds, now)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pkg, err := r.repo.Tables().LoadRenewPackage(ctx, tx, main.TenantId, packageCode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if pkg.Enabled != 1 {
|
|
return nil, gerror.New("当前套餐未启用")
|
|
}
|
|
durationUnit := renewDurationUnitForPackage(pkg)
|
|
actualDurationMonths := consts.DurationValueToMonths(durationUnit, durationValue)
|
|
actualGiftDurationMonths := consts.DurationValueToMonths(durationUnit, giftDurationMonths)
|
|
options, err := validateRuntimeRenewDuration(pkg, durationValue)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
customerDept, err := loadRenewDeptTx(ctx, tx, main.TenantId, customerID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
priceSnap, err := loadRuntimeRenewPriceSnapshot(ctx, tx, main.TenantId, pkg, customerDept, options, beginDates)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
amount := roundAmount(priceSnap.RenewUnitPrice * float64(durationValue) * float64(len(iccids)))
|
|
|
|
mode := strings.TrimSpace(firstString(info, "paymentMode", "paymentSnapshot.paymentMode"))
|
|
payment, err := r.buildRuntimeRenewPayment(ctx, tx, main, mode, customerID, amount, now)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
addition := map[string]any{
|
|
"customerAgentId": customerID,
|
|
"customerName": strings.TrimSpace(customerDept.DeptName),
|
|
"packageCode": priceSnap.PackageCode,
|
|
"packageName": priceSnap.PackageName,
|
|
"priceSource": priceSnap.PriceSource,
|
|
"priceOwnerDeptId": priceSnap.PriceOwnerDeptId,
|
|
"agentDefaultPriceId": priceSnap.AgentDefaultPriceId,
|
|
"targetPriceId": priceSnap.TargetPriceId,
|
|
"renewUnitPrice": priceSnap.RenewUnitPrice,
|
|
"renewableDurationOptions": priceSnap.RenewableDurationOptions,
|
|
"renewablePackageCodes": priceSnap.RenewablePackageCodes,
|
|
"renewablePackages": priceSnap.RenewablePackages,
|
|
"billingMethod": priceSnap.BillingMethod,
|
|
"renewDurationUnit": priceSnap.RenewDurationUnit,
|
|
"renewDurationUnitText": priceSnap.RenewDurationUnitText,
|
|
"renewBeginDate": priceSnap.RenewBeginDate,
|
|
"renewBeginDateMin": priceSnap.RenewBeginDateMin,
|
|
"renewBeginDateMax": priceSnap.RenewBeginDateMax,
|
|
"sameRenewBeginDate": priceSnap.SameRenewBeginDate,
|
|
"priceSnapshot": priceSnap,
|
|
"quantity": len(iccids),
|
|
"durationValue": durationValue,
|
|
"durationMonths": actualDurationMonths,
|
|
"actualDurationMonths": actualDurationMonths,
|
|
"giftDurationMonths": giftDurationMonths,
|
|
"actualGiftDurationMonths": actualGiftDurationMonths,
|
|
"amount": amount,
|
|
}
|
|
for key, value := range payment {
|
|
addition[key] = value
|
|
}
|
|
merged := mergeBatchInfo(main.BatchInfo, addition)
|
|
main.BatchInfo = gjson.New(merged)
|
|
|
|
contract, err := ParseExecutionContract(main)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err = r.validateRenewRuntimePermissions(ctx, tx, main, contract); err != nil {
|
|
return nil, err
|
|
}
|
|
return contract, nil
|
|
}
|
|
|
|
func runtimeRenewFacts(
|
|
main *rc.BatchMainRow,
|
|
details []*rc.BatchDetailRow,
|
|
cards map[string]*rc.SimCardInfo,
|
|
binds map[string]*rc.SimCardBindPkg,
|
|
futureBinds map[string][]*rc.SimCardBindPkg,
|
|
now time.Time,
|
|
) (int64, string, []string, error) {
|
|
customerIDs := map[int64]struct{}{}
|
|
packageCodes := map[string]struct{}{}
|
|
beginDates := make([]string, 0, len(details))
|
|
periodRows := make([]*RenewRow, 0, len(details))
|
|
sourceBatchNo := executionSourceBatchNo(main, main.BatchInfo)
|
|
|
|
for _, detail := range details {
|
|
if detail == nil {
|
|
return 0, "", nil, gerror.New("续费明细为空")
|
|
}
|
|
iccid := strings.TrimSpace(detail.ItemId)
|
|
card := cards[iccid]
|
|
bind := binds[iccid]
|
|
if card == nil {
|
|
return 0, "", nil, gerror.Newf("ICCID不存在：%s", iccid)
|
|
}
|
|
if bind == nil {
|
|
return 0, "", nil, gerror.Newf("ICCID没有订购记录：%s", iccid)
|
|
}
|
|
expectedMSISDN, expectedIMSI := snapshotIdentity(detail.Snapshot)
|
|
if err := validateCurrentSubscription(card, bind, subscriptionValidation{
|
|
ICCID: iccid,
|
|
MSISDN: expectedMSISDN,
|
|
IMSI: expectedIMSI,
|
|
TenantID: main.TenantId,
|
|
CustomerDeptID: card.DeptId,
|
|
PackageCode: card.CurrentPackageCode,
|
|
SourceBatchNo: sourceBatchNo,
|
|
}); err != nil {
|
|
return 0, "", nil, gerror.Wrapf(err, "校验续费卡失败，ICCID:%s", iccid)
|
|
}
|
|
base := renewBaseSubscriptionForCard(card, bind, futureBinds[iccid])
|
|
if err := validateRenewBaseWindow(base, now, iccid); err != nil {
|
|
return 0, "", nil, err
|
|
}
|
|
customerIDs[card.DeptId] = struct{}{}
|
|
packageCodes[strings.TrimSpace(card.CurrentPackageCode)] = struct{}{}
|
|
periodRows = append(periodRows, &RenewRow{
|
|
RowNo: detail.RowNo,
|
|
ICCID: iccid,
|
|
OldEffTime: base.EffectiveTime,
|
|
OldExpireTime: base.ExpectedExpireTime,
|
|
})
|
|
beginAt := renewBeginDateFromExpire(base.ExpectedExpireTime)
|
|
if beginAt != nil {
|
|
beginDates = append(beginDates, beginAt.Format("Y-m-d"))
|
|
}
|
|
}
|
|
if err := validateRenewSameCurrentPeriod(periodRows, nil); err != nil {
|
|
return 0, "", nil, err
|
|
}
|
|
if len(customerIDs) != 1 {
|
|
return 0, "", nil, gerror.New("当前批次下存在多个客户，不能统一续费")
|
|
}
|
|
if len(packageCodes) != 1 {
|
|
return 0, "", nil, gerror.New("当前批次下存在多个套餐，不能统一续费")
|
|
}
|
|
var customerID int64
|
|
for id := range customerIDs {
|
|
customerID = id
|
|
}
|
|
var packageCode string
|
|
for code := range packageCodes {
|
|
packageCode = code
|
|
}
|
|
return customerID, packageCode, beginDates, nil
|
|
}
|
|
|
|
func normalizeLegacyRenewDurationValue(raw int) int {
|
|
if raw <= 0 {
|
|
return 0
|
|
}
|
|
if raw >= 12 && raw%12 == 0 {
|
|
return raw / 12
|
|
}
|
|
return raw
|
|
}
|
|
|
|
func validateRuntimeRenewDuration(pkg *rc.FlowPackageInfo, durationValue int) ([]int, error) {
|
|
if pkg == nil {
|
|
return nil, gerror.New("续费套餐不存在")
|
|
}
|
|
options, err := renewableYearOptions(pkg.RenewableDurationConfig)
|
|
if err != nil || len(options) == 0 {
|
|
return nil, gerror.Newf("当前套餐%s未配置可续费时长", runtimeRenewPackageLabel(pkg))
|
|
}
|
|
if !rc.ContainsInt(options, durationValue) {
|
|
return nil, gerror.Newf(
|
|
"续费时长%d%s不在当前套餐%s可续费范围内，可选：%s",
|
|
durationValue,
|
|
consts.RenewDurationUnitText(renewDurationUnitForPackage(pkg)),
|
|
runtimeRenewPackageLabel(pkg),
|
|
formatRuntimeRenewDurationOptions(options, renewDurationUnitForPackage(pkg)),
|
|
)
|
|
}
|
|
return options, nil
|
|
}
|
|
|
|
func runtimeRenewPackageLabel(pkg *rc.FlowPackageInfo) string {
|
|
if pkg == nil {
|
|
return ""
|
|
}
|
|
name := strings.TrimSpace(pkg.PackageName)
|
|
code := strings.TrimSpace(pkg.PackageCode)
|
|
switch {
|
|
case name != "" && code != "":
|
|
return name + "(" + code + ")"
|
|
case name != "":
|
|
return name
|
|
default:
|
|
return code
|
|
}
|
|
}
|
|
|
|
func formatRuntimeRenewDurationOptions(options []int, unit string) string {
|
|
if len(options) == 0 {
|
|
return ""
|
|
}
|
|
parts := make([]string, 0, len(options))
|
|
for _, option := range options {
|
|
parts = append(parts, fmt.Sprintf("%d%s", option, consts.RenewDurationUnitText(unit)))
|
|
}
|
|
return strings.Join(parts, "、")
|
|
}
|
|
|
|
func snapshotIdentity(snapshot *gjson.Json) (string, string) {
|
|
if snapshot == nil {
|
|
return "", ""
|
|
}
|
|
msisdn := strings.TrimSpace(snapshot.Get("msisdn").String())
|
|
if msisdn == "" {
|
|
msisdn = strings.TrimSpace(snapshot.Get("MSISDN").String())
|
|
}
|
|
imsi := strings.TrimSpace(snapshot.Get("imsi").String())
|
|
if imsi == "" {
|
|
imsi = strings.TrimSpace(snapshot.Get("IMSI").String())
|
|
}
|
|
return msisdn, imsi
|
|
}
|
|
|
|
func loadRuntimeRenewPriceSnapshot(
|
|
ctx context.Context,
|
|
tx gdb.TX,
|
|
tenantID string,
|
|
pkg *rc.FlowPackageInfo,
|
|
customerDept *rc.SysDeptRow,
|
|
options []int,
|
|
beginDates []string,
|
|
) (*RenewPriceSnapshot, error) {
|
|
if pkg == nil || customerDept == nil {
|
|
return nil, gerror.New("续费套餐或客户信息缺失")
|
|
}
|
|
priceOwnerDeptID := renewPriceOwnerDeptID(customerDept)
|
|
salePrice, err := resolveRenewEffectiveSalePrice(ctx, renewTxEffectivePriceStore{tx: tx}, tenantID, priceOwnerDeptID, customerDept.DeptId, pkg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sameDate, minDate, maxDate, same := summarizeRenewBeginDates(beginDates)
|
|
durationUnit := renewDurationUnitForPackage(pkg)
|
|
renewableCodes, renewablePackages, err := runtimeRenewablePackageOptions(ctx, tx, tenantID, customerDept.DeptId, priceOwnerDeptID, pkg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &RenewPriceSnapshot{
|
|
CustomerAgentId: customerDept.DeptId,
|
|
PriceOwnerDeptId: priceOwnerDeptID,
|
|
PackageCode: pkg.PackageCode,
|
|
PackageName: pkg.PackageName,
|
|
BillingMethod: pkg.BillingMethod,
|
|
RenewDurationUnit: durationUnit,
|
|
RenewDurationUnitText: consts.RenewDurationUnitText(durationUnit),
|
|
PriceSource: salePrice.Rule.PriceSource,
|
|
AgentDefaultPriceId: salePrice.Rule.AgentDefaultPriceId,
|
|
TargetPriceId: salePrice.Rule.TargetPriceId,
|
|
RenewUnitPrice: salePrice.AgentShipmentPrice,
|
|
RenewableDurationOptions: options,
|
|
RenewablePackageCodes: renewableCodes,
|
|
RenewablePackages: renewablePackages,
|
|
RenewBeginDate: sameDate,
|
|
RenewBeginDateMin: minDate,
|
|
RenewBeginDateMax: maxDate,
|
|
SameRenewBeginDate: same,
|
|
}, nil
|
|
}
|
|
|
|
func runtimeRenewablePackageOptions(ctx context.Context, tx gdb.TX, tenantID string, customerDeptID, priceOwnerDeptID int64, currentPkg *rc.FlowPackageInfo) ([]string, []RenewPackageOption, error) {
|
|
if currentPkg == nil {
|
|
return nil, nil, gerror.New("当前套餐不存在或未启用")
|
|
}
|
|
codes := renewPackageCodesFromJSON(currentPkg.RenewablePackageCodes)
|
|
if len(codes) == 0 {
|
|
return nil, nil, gerror.New("当前套餐未配置可续费套餐")
|
|
}
|
|
validCodes := make([]string, 0, len(codes))
|
|
options := make([]RenewPackageOption, 0, len(codes))
|
|
for _, code := range codes {
|
|
pkg, err := loadRenewPackageOptionTx(ctx, tx, tenantID, code)
|
|
if err != nil || pkg == nil || pkg.Enabled != 1 {
|
|
continue
|
|
}
|
|
unitPrice, err := runtimeRenewPackageUnitPrice(ctx, tx, tenantID, customerDeptID, priceOwnerDeptID, pkg)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
durations, err := renewableYearOptions(pkg.RenewableDurationConfig)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
validCodes = append(validCodes, pkg.PackageCode)
|
|
options = append(options, RenewPackageOption{
|
|
PackageCode: pkg.PackageCode,
|
|
PackageName: pkg.PackageName,
|
|
RenewUnitPrice: unitPrice,
|
|
RenewableDurationOptions: durations,
|
|
})
|
|
}
|
|
if len(options) == 0 {
|
|
return nil, nil, gerror.New("当前套餐未配置可用的可续费套餐")
|
|
}
|
|
return validCodes, options, nil
|
|
}
|
|
|
|
func loadRenewPackageOptionTx(ctx context.Context, tx gdb.TX, tenantID, packageCode string) (*rc.FlowPackageInfo, error) {
|
|
var pkg rc.FlowPackageInfo
|
|
err := tx.Ctx(ctx).Model(rc.TableSimFlowPackageInfo).
|
|
Where("tenant_id", strings.TrimSpace(tenantID)).
|
|
Where("package_code", strings.TrimSpace(packageCode)).
|
|
LockShared().
|
|
Scan(&pkg)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, nil
|
|
}
|
|
return nil, gerror.Wrap(err, "查询可续费套餐失败")
|
|
}
|
|
if pkg.Id == 0 {
|
|
return nil, nil
|
|
}
|
|
return &pkg, nil
|
|
}
|
|
|
|
func runtimeRenewPackageUnitPrice(ctx context.Context, tx gdb.TX, tenantID string, customerDeptID, priceOwnerDeptID int64, pkg *rc.FlowPackageInfo) (float64, error) {
|
|
if pkg == nil {
|
|
return 0, gerror.New("续费套餐不存在")
|
|
}
|
|
salePrice, err := resolveRenewEffectiveSalePrice(ctx, renewTxEffectivePriceStore{tx: tx}, tenantID, priceOwnerDeptID, customerDeptID, pkg)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return salePrice.AgentShipmentPrice, nil
|
|
}
|
|
|
|
func (r *RenewExecutor) buildRuntimeRenewPayment(ctx context.Context, tx gdb.TX, main *rc.BatchMainRow, requestedMode string, payerDeptID int64, amount float64, now time.Time) (map[string]any, error) {
|
|
isTop, operatorDeptID, err := isRenewTopDeptTx(ctx, tx, main)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if payerDeptID <= 0 {
|
|
payerDeptID = operatorDeptID
|
|
}
|
|
mode := strings.TrimSpace(requestedMode)
|
|
if mode == "" {
|
|
if isTop {
|
|
mode = "offline"
|
|
} else {
|
|
mode = "balance"
|
|
}
|
|
}
|
|
switch mode {
|
|
case "offline":
|
|
if !isTop {
|
|
return nil, gerror.New("当前组织续费必须使用余额支付")
|
|
}
|
|
if main.BatchInfo != nil && !main.BatchInfo.Get("offlineContractCompleted").Bool() {
|
|
return nil, gerror.New("请确认线下业务已完成")
|
|
}
|
|
return runtimePaymentSnapshot(mode, consts.PayTypeOffline, amount, 0, amount, 0, 0, "", payerDeptID, main.CreatedBy, isTop, now), nil
|
|
case "balance":
|
|
before, after, serialNo, err := deductRuntimeRenewBalance(ctx, tx, main, payerDeptID, amount, now)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return runtimePaymentSnapshot(mode, consts.PayTypeBalance, amount, amount, 0, before, after, serialNo, payerDeptID, main.CreatedBy, isTop, now), nil
|
|
default:
|
|
return nil, gerror.New("续费付款方式不正确")
|
|
}
|
|
}
|
|
|
|
func runtimePaymentSnapshot(mode string, payType int, payAmount, balanceAmount, offlineAmount, before, after float64, serialNo string, payerDeptID, payerUserID int64, isTop bool, now time.Time) map[string]any {
|
|
paymentTime := now.Format("2006-01-02 15:04:05")
|
|
snapshot := map[string]any{
|
|
"paymentMode": mode,
|
|
"payType": payType,
|
|
"payStatus": consts.PayStatusPaid,
|
|
"payAmount": payAmount,
|
|
"balanceAmount": balanceAmount,
|
|
"offlinePaidAmount": offlineAmount,
|
|
"balanceBefore": before,
|
|
"balanceAfter": after,
|
|
"balanceDetailSerialNo": strings.TrimSpace(serialNo),
|
|
"paymentTime": paymentTime,
|
|
"payerDeptId": payerDeptID,
|
|
"payerUserId": payerUserID,
|
|
"isTopDept": isTop,
|
|
}
|
|
return map[string]any{
|
|
"paymentMode": mode,
|
|
"payType": payType,
|
|
"payStatus": consts.PayStatusPaid,
|
|
"payAmount": payAmount,
|
|
"balanceAmount": balanceAmount,
|
|
"offlinePaidAmount": offlineAmount,
|
|
"balanceBefore": before,
|
|
"balanceAfter": after,
|
|
"balanceDetailSerialNo": strings.TrimSpace(serialNo),
|
|
"paymentTime": paymentTime,
|
|
"payerDeptId": payerDeptID,
|
|
"payerUserId": payerUserID,
|
|
"isTopDept": isTop,
|
|
"paymentSnapshot": snapshot,
|
|
}
|
|
}
|
|
|
|
func deductRuntimeRenewBalance(ctx context.Context, tx gdb.TX, main *rc.BatchMainRow, payerDeptID int64, amount float64, now time.Time) (float64, float64, string, error) {
|
|
amount = roundAmount(amount)
|
|
if amount <= 0 {
|
|
return 0, 0, "", nil
|
|
}
|
|
serialNo := "RENPAY" + strings.TrimSpace(main.BatchNo)
|
|
if serialNo == "RENPAY" {
|
|
return 0, 0, "", gerror.New("续费余额流水号生成失败")
|
|
}
|
|
existingModel := tx.Ctx(ctx).Model(rc.TableBalanceDetail).
|
|
Where("tenant_id", main.TenantId).
|
|
Where("serial_no", serialNo)
|
|
existing, err := runtimeRenewLockForUpdate(existingModel).One()
|
|
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
|
return 0, 0, "", gerror.Wrap(err, "查询续费余额流水失败")
|
|
}
|
|
if existing != nil && !existing.IsEmpty() {
|
|
return 0, 0, "", gerror.New("当前续费批次已扣款，请勿重复提交")
|
|
}
|
|
|
|
var account renewPaymentAccountRow
|
|
recordModel := tx.Ctx(ctx).Model(rc.TableAgentBalance).
|
|
Where("dept_id", payerDeptID).
|
|
Where("tenant_id", main.TenantId)
|
|
record, err := runtimeRenewLockForUpdate(recordModel).One()
|
|
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
|
return 0, 0, "", gerror.Wrap(err, "查询账户余额失败")
|
|
}
|
|
if record != nil && !record.IsEmpty() {
|
|
if err := record.Struct(&account); err != nil {
|
|
return 0, 0, "", gerror.Wrap(err, "解析账户余额失败")
|
|
}
|
|
}
|
|
if account.ID == 0 {
|
|
return 0, 0, "", gerror.New("账户余额不存在，请先充值")
|
|
}
|
|
if account.Status != renewFinanceAccountStatusNormal {
|
|
return 0, 0, "", gerror.New("账户余额状态异常，不能续费")
|
|
}
|
|
before := roundAmount(account.Balance)
|
|
if before+0.0001 < amount {
|
|
return 0, 0, "", gerror.Newf("账户余额不足，需支付%.2f元，当前余额%.2f元", amount, before)
|
|
}
|
|
after := roundAmount(before - amount)
|
|
nowTime := gtime.NewFromTime(now)
|
|
if _, err := tx.Ctx(ctx).Model(rc.TableAgentBalance).Where("id", account.ID).Data(g.Map{
|
|
"balance": after,
|
|
"updated_by": main.CreatedBy,
|
|
"updated_at": nowTime,
|
|
}).Update(); err != nil {
|
|
return 0, 0, "", gerror.Wrap(err, "扣减账户余额失败")
|
|
}
|
|
if _, err := tx.Ctx(ctx).Model(rc.TableBalanceDetail).Data(g.Map{
|
|
"dept_id": payerDeptID,
|
|
"serial_no": serialNo,
|
|
"transaction_time": nowTime,
|
|
"income_expense_type": renewFinanceIncomeExpenseExpense,
|
|
"transaction_type": renewFinanceTransactionTypeConsume,
|
|
"transaction_channel": renewFinanceTransactionChannelBalance,
|
|
"transaction_status": renewFinanceTransactionStatusPaid,
|
|
"amount": amount,
|
|
"before_balance": before,
|
|
"balance_after": after,
|
|
"order_sn": main.BatchNo,
|
|
"remark": fmt.Sprintf("SIM卡续费余额支付，批次号：%s", main.BatchNo),
|
|
"tenant_id": main.TenantId,
|
|
"created_dept": payerDeptID,
|
|
"created_by": main.CreatedBy,
|
|
"created_at": nowTime,
|
|
}).Insert(); err != nil {
|
|
return 0, 0, "", gerror.Wrap(err, "写入续费余额流水失败")
|
|
}
|
|
return before, after, serialNo, nil
|
|
}
|
|
|
|
func runtimeRenewLockForUpdate(model *gdb.Model) *gdb.Model {
|
|
if g.DB().GetConfig().Type == "sqlite" {
|
|
return model
|
|
}
|
|
return model.LockUpdate()
|
|
}
|
|
|
|
func (r *RenewExecutor) validateRenewRuntimePermissions(ctx context.Context, tx gdb.TX, main *rc.BatchMainRow, contract *ExecutionContract) error {
|
|
if contract == nil {
|
|
return gerror.New("续费执行合同不能为空")
|
|
}
|
|
isTop, _, err := isRenewTopDeptTx(ctx, tx, main)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if contract.PaymentMode == "offline" && !isTop {
|
|
return gerror.New("当前组织续费必须使用余额支付")
|
|
}
|
|
if contract.PackageBeginTime != nil && !isTop {
|
|
return gerror.New("当前组织不能修改续费日期")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func isRenewTopDeptTx(ctx context.Context, tx gdb.TX, main *rc.BatchMainRow) (bool, int64, error) {
|
|
deptID := main.CreatedDept
|
|
if deptID <= 0 {
|
|
deptID = main.DeptId
|
|
}
|
|
if deptID <= 0 {
|
|
return false, 0, gerror.New("当前批次缺少操作组织")
|
|
}
|
|
dept, err := loadRenewDeptTx(ctx, tx, main.TenantId, deptID)
|
|
if err != nil {
|
|
return false, 0, err
|
|
}
|
|
return dept.ParentId == 0, deptID, nil
|
|
}
|
|
|
|
func loadRenewDeptTx(ctx context.Context, tx gdb.TX, tenantID string, deptID int64) (*rc.SysDeptRow, error) {
|
|
var row rc.SysDeptRow
|
|
err := tx.Ctx(ctx).Model(rc.TableSysDept).
|
|
Where("tenant_id", tenantID).
|
|
Where("dept_id", deptID).
|
|
WhereNull("deleted_at").
|
|
LockShared().
|
|
Scan(&row)
|
|
if err != nil {
|
|
return nil, gerror.Wrap(err, "查询客户部门失败")
|
|
}
|
|
if row.DeptId == 0 {
|
|
return nil, gerror.New("客户部门不存在")
|
|
}
|
|
return &row, nil
|
|
}
|
|
|
|
func loadRenewPriceOverrideTx(ctx context.Context, tx gdb.TX, tenantID string, deptID, targetAgentID int64, scopeType int, packageCode string) (*rc.FlowPackagePrice, error) {
|
|
var row rc.FlowPackagePrice
|
|
err := tx.Ctx(ctx).Model(rc.TableSimFlowPackagePrice).
|
|
Where("tenant_id", tenantID).
|
|
Where("dept_id", deptID).
|
|
Where("agent_scope_type", scopeType).
|
|
Where("target_agent_id", targetAgentID).
|
|
Where("package_code", strings.TrimSpace(packageCode)).
|
|
Where("enabled", 1).
|
|
LockShared().
|
|
Scan(&row)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, nil
|
|
}
|
|
return nil, gerror.Wrap(err, "查询代理续费定价失败")
|
|
}
|
|
if row.Id == 0 {
|
|
return nil, nil
|
|
}
|
|
return &row, nil
|
|
}
|