323 lines
11 KiB
Go
323 lines
11 KiB
Go
package logic
|
||
|
||
import (
|
||
"errors"
|
||
"fmt"
|
||
"micro-bundle/internal/dao"
|
||
"micro-bundle/internal/model"
|
||
"micro-bundle/pb/bundle"
|
||
"micro-bundle/pkg/app"
|
||
"micro-bundle/pkg/utils"
|
||
"strconv"
|
||
|
||
uuid "github.com/satori/go.uuid"
|
||
|
||
"github.com/jinzhu/copier"
|
||
)
|
||
|
||
func CreateOrderRecord(req *bundle.OrderCreateRecord) (res *bundle.CommonResponse, err error) {
|
||
res = new(bundle.CommonResponse)
|
||
// 下单前置校验
|
||
orderKind := model.OrderKindBundle
|
||
if req.OrderType == model.OrderTypeValueAdd {
|
||
orderKind = model.OrderKindValueAdd
|
||
}
|
||
if eligibility, e := CheckOrderEligibility(&bundle.CheckOrderEligibilityRequest{
|
||
CustomerID: req.CustomerID,
|
||
OrderKind: orderKind,
|
||
OrderMode: req.OrderMode,
|
||
}); e != nil {
|
||
return nil, e
|
||
} else if !eligibility.Allow {
|
||
res.Msg = eligibility.Msg
|
||
return res, errors.New(eligibility.Msg)
|
||
}
|
||
//orderUUID := app.ModuleClients.SfNode.Generate().Base64()
|
||
uuidV4, err := uuid.NewV4()
|
||
if err != nil {
|
||
fmt.Println("生成错误", err)
|
||
return nil, errors.New("生成uuid失败")
|
||
}
|
||
orderUUID := uuidV4.String()
|
||
orderNo := utils.GetOrderNo()
|
||
if req.OrderNo != "" {
|
||
orderNo = req.OrderNo
|
||
}
|
||
var addRecords []model.BundleOrderValueAdd
|
||
for _, i := range req.AddRecords {
|
||
addOrderMode := i.OrderMode
|
||
if addOrderMode == 0 {
|
||
addOrderMode = model.OrderModePayLater // 增值订单默认先用后付
|
||
}
|
||
addPayLaterStatus := i.PayLaterStatus
|
||
if addOrderMode == model.OrderModePayLater && addPayLaterStatus == 0 && i.PaymentStatus != 2 {
|
||
addPayLaterStatus = model.PayLaterStatusPending
|
||
}
|
||
addRecords = append(addRecords, model.BundleOrderValueAdd{
|
||
UUID: app.ModuleClients.SfNode.Generate().Base64(),
|
||
OrderNo: orderNo,
|
||
OrderUUID: orderUUID,
|
||
CustomerID: req.CustomerID,
|
||
CustomerNum: req.CustomerNum,
|
||
CustomerName: req.CustomerName,
|
||
ServiceType: i.ServiceType,
|
||
CurrencyType: i.CurrencyType,
|
||
Amount: float64(i.Amount),
|
||
Num: i.Num,
|
||
Unit: i.Unit,
|
||
ValueAddUUID: i.ValueUid,
|
||
Source: int(i.Source),
|
||
PaymentStatus: int(i.PaymentStatus),
|
||
SignContract: req.SignContract,
|
||
Signature: req.Signature,
|
||
SignedTime: req.SignedTime,
|
||
Snapshot: req.Snapshot,
|
||
HandlingFee: i.HandlingFee,
|
||
EquityType: i.EquityType,
|
||
QuotaType: i.QuotaType,
|
||
QuotaValue: i.QuotaValue,
|
||
IsExpired: i.IsExpired,
|
||
})
|
||
}
|
||
orderMode := req.OrderMode
|
||
if orderMode == 0 {
|
||
return res, errors.New("订单模式错误")
|
||
}
|
||
payLaterStatus := req.PayLaterStatus
|
||
if orderMode == model.OrderModePayLater && payLaterStatus == 0 && req.Status != model.BundleStatusPaid {
|
||
payLaterStatus = model.PayLaterStatusPending
|
||
}
|
||
// OrderType 从请求中获取，不写死
|
||
orderType := req.OrderType
|
||
if orderType == 0 {
|
||
return res, errors.New("订单类型错误")
|
||
}
|
||
orderRecord := &model.BundleOrderRecords{
|
||
UUID: orderUUID,
|
||
OrderNo: orderNo,
|
||
BundleUUID: req.BundleUuid,
|
||
BundleName: req.BundleName,
|
||
CustomerID: req.CustomerID,
|
||
CustomerNum: req.CustomerNum,
|
||
CustomerName: req.CustomerName,
|
||
Amount: req.Amount,
|
||
AmountType: req.AmountType,
|
||
TotalAmount: req.TotalAmount,
|
||
SignContract: req.SignContract,
|
||
Signature: req.Signature,
|
||
SignedTime: req.SignedTime,
|
||
PayType: int64(req.PayType),
|
||
PayTime: req.PayTime,
|
||
Status: req.Status,
|
||
ContractNo: req.ContractNo,
|
||
BundleCommonUid: req.BundleCommonUid,
|
||
FinancialConfirmation: model.ConfirmationNotConfirmed,
|
||
ExpirationTime: req.ExpirationTime,
|
||
Language: req.Language,
|
||
BundleOrderValueAdd: addRecords,
|
||
PlatformIds: req.PlatformIds,
|
||
InviterID: req.InviterId,
|
||
PurchaseType: req.PurchaseType,
|
||
RenewalOrderUUID: req.RenewalOrderUUID,
|
||
OrderMode: orderMode,
|
||
DueTime: req.DueTime,
|
||
PayLaterStatus: payLaterStatus,
|
||
ContractTplType: req.ContractTplType,
|
||
OrderType: orderType,
|
||
}
|
||
res, err = dao.CreateOrderRecord(orderRecord)
|
||
return
|
||
}
|
||
|
||
func UpdateOrderRecord(req *bundle.OrderRecord) (res *bundle.CommonResponse, err error) {
|
||
res = new(bundle.CommonResponse)
|
||
orderRecord := new(model.BundleOrderRecords)
|
||
_ = copier.CopyWithOption(&orderRecord, req, copier.Option{DeepCopy: true})
|
||
orderRecord.UUID = req.Uuid
|
||
orderRecord.BundleUUID = req.BundleUuid
|
||
res, err = dao.UpdateOrderRecord(orderRecord)
|
||
return
|
||
}
|
||
|
||
func UpdateOrderRecordByOrderNo(req *bundle.OrderRecord) (res *bundle.CommonResponse, err error) {
|
||
res = new(bundle.CommonResponse)
|
||
orderRecord := new(model.BundleOrderRecords)
|
||
_ = copier.CopyWithOption(&orderRecord, req, copier.Option{DeepCopy: true})
|
||
orderRecord.UUID = req.Uuid
|
||
orderRecord.BundleUUID = req.BundleUuid
|
||
orderRecord.Status = req.Status
|
||
fmt.Println("UpdateOrderRecordByOrderNo Status:", req.Status)
|
||
res, err = dao.UpdateOrderRecordByOrderNO(orderRecord)
|
||
return
|
||
}
|
||
|
||
func OrderRecordsList(req *bundle.OrderRecordsRequest) (res *bundle.OrderRecordsResponse, err error) {
|
||
res = new(bundle.OrderRecordsResponse)
|
||
res, err = dao.OrderRecordsList(req)
|
||
return
|
||
}
|
||
|
||
func OrderRecordsDetail(req *bundle.OrderRecordsDetailRequest) (res *bundle.OrderRecordsDetailResponse, err error) {
|
||
res = new(bundle.OrderRecordsDetailResponse)
|
||
res.OrderRecord = new(bundle.OrderRecord)
|
||
res.OrderRecord, err = dao.OrderRecordDetail(req)
|
||
if err != nil {
|
||
res.Msg = err.Error()
|
||
}
|
||
return
|
||
}
|
||
func GetInEffectOrderRecord(req *bundle.GetInEffectOrderRecordRequest) (res *bundle.OrderRecord, err error) {
|
||
res = new(bundle.OrderRecord)
|
||
orderReq := &bundle.OrderRecordsDetailRequest{
|
||
CustomerID: strconv.FormatUint(req.UserID, 10),
|
||
Status: 2,
|
||
}
|
||
res, err = dao.OrderRecordDetail(orderReq)
|
||
if err != nil {
|
||
return nil, errors.New("未找到有效订单")
|
||
}
|
||
return
|
||
}
|
||
|
||
func UpdateFinancialConfirmationStatus(req *bundle.FinancialConfirmationRequest) (res *bundle.CommonResponse, err error) {
|
||
res = new(bundle.CommonResponse)
|
||
err = app.ModuleClients.BundleDB.Model(&model.BundleOrderRecords{}).Where("order_no = ?", req.OrderNo).Update("financial_confirmation", model.ConfirmationConfirmed).Error
|
||
if err != nil {
|
||
res.Msg = "更新财务确认状态失败"
|
||
return res, err
|
||
}
|
||
res.Msg = "更新财务确认状态成功"
|
||
return
|
||
}
|
||
func PackagePriceAndTime(req *bundle.OrderRecord) (res *bundle.PackagePriceAndTimeResponse, err error) {
|
||
res = new(bundle.PackagePriceAndTimeResponse)
|
||
res, err = dao.PackagePriceAndTime(req)
|
||
return
|
||
|
||
}
|
||
func CreateOrderAddRecord(req *bundle.OrderAddRecord) (res *bundle.CommonResponse, err error) {
|
||
res = new(bundle.CommonResponse)
|
||
// 增值订单下单前置校验（规则5：增值订单不受套餐过期限制，可无限续杯）
|
||
if eligibility, e := CheckOrderEligibility(&bundle.CheckOrderEligibilityRequest{
|
||
CustomerID: req.CustomerID,
|
||
OrderKind: model.OrderKindValueAdd,
|
||
OrderMode: req.OrderMode,
|
||
}); e != nil {
|
||
return nil, e
|
||
} else if !eligibility.Allow {
|
||
res.Msg = eligibility.Msg
|
||
return res, errors.New(eligibility.Reason)
|
||
}
|
||
res, err = dao.CreateOrderAddRecord(req)
|
||
return
|
||
}
|
||
func OrderRecordsListV2(req *bundle.OrderRecordsRequestV2) (res *bundle.OrderRecordsResponseV2, err error) {
|
||
res = new(bundle.OrderRecordsResponseV2)
|
||
res, err = dao.OrderRecordsListV2(req)
|
||
return
|
||
}
|
||
func OrderListByOrderNo(req *bundle.OrderInfoByOrderNoRequest) (res *bundle.OrderInfoByOrderNoResp, err error) {
|
||
res = new(bundle.OrderInfoByOrderNoResp)
|
||
res, err = dao.OrderListByOrderNo(req)
|
||
return
|
||
}
|
||
func GetReconciliationList(req *bundle.GetReconciliationListReq) (res *bundle.GetReconciliationListResp, err error) {
|
||
res = new(bundle.GetReconciliationListResp)
|
||
res, err = dao.GetReconciliationList(req)
|
||
return
|
||
}
|
||
func CreateReconciliation(req *bundle.ReconciliationInfo) (res *bundle.CommonResponse, err error) {
|
||
res = new(bundle.CommonResponse)
|
||
res, err = dao.CreateReconciliation(req)
|
||
return
|
||
}
|
||
func UpdateReconciliation(req *bundle.ReconciliationInfo) (res *bundle.CommonResponse, err error) {
|
||
res = new(bundle.CommonResponse)
|
||
res, err = dao.UpdateReconciliation(req)
|
||
return
|
||
}
|
||
func OnlyAddValueListByOrderNo(req *bundle.OnlyAddValueListByOrderNoRequest) (res *bundle.OnlyAddValueListByOrderNoResp, err error) {
|
||
res = new(bundle.OnlyAddValueListByOrderNoResp)
|
||
res, err = dao.OnlyAddValueListByOrderNo(req)
|
||
return
|
||
}
|
||
func UpdateReconciliationStatusBySerialNumber(req *bundle.UpdateStatusAndPayTimeBySerialNumber) (res *bundle.CommonResponse, err error) {
|
||
res = new(bundle.CommonResponse)
|
||
res, err = dao.UpdateReconciliationStatusBySerialNumber(req)
|
||
return
|
||
}
|
||
func DeleteValueAddService(req *bundle.DeleteValueAddServiceRequest) (res *bundle.CommonResponse, err error) {
|
||
res = new(bundle.CommonResponse)
|
||
res, err = dao.DeleteValueAddService(req)
|
||
return
|
||
}
|
||
|
||
func ListUnfinishedInfos(req *bundle.AutoCreateUserAndOrderRequest) (res *bundle.UnfinishedInfos, err error) {
|
||
res = new(bundle.UnfinishedInfos)
|
||
res, err = dao.ListUnfinishedInfos(req)
|
||
return
|
||
}
|
||
|
||
func SoftDeleteUnfinishedInfo(req *bundle.SoftDeleteUnfinishedInfoRequest) (res *bundle.CommonResponse, err error) {
|
||
res = new(bundle.CommonResponse)
|
||
res, err = dao.SoftDeleteUnfinishedInfo(req)
|
||
return
|
||
}
|
||
func ReSignTheContract(req *bundle.ReSignTheContractRequest) (res *bundle.CommonResponse, err error) {
|
||
res = new(bundle.CommonResponse)
|
||
res, err = dao.ReSignTheContract(req)
|
||
return
|
||
}
|
||
|
||
func UpdateOrderRecordByOrderUuid(req *bundle.OrderRecord) (res *bundle.CommonResponse, err error) {
|
||
res = new(bundle.CommonResponse)
|
||
orderRecord := new(model.BundleOrderRecords)
|
||
_ = copier.CopyWithOption(&orderRecord, req, copier.Option{DeepCopy: true})
|
||
orderRecord.UUID = req.Uuid
|
||
orderRecord.BundleUUID = req.BundleUuid
|
||
orderRecord.Status = req.Status
|
||
fmt.Println("UpdateOrderRecordByOrderUuid Status:", req.Status)
|
||
res, err = dao.UpdateOrderRecordByOrderUuid(orderRecord)
|
||
return
|
||
}
|
||
func OrderListByOrderUuid(req *bundle.OrderInfoByOrderUuidRequest) (res *bundle.OrderInfoByOrderNoResp, err error) {
|
||
res = new(bundle.OrderInfoByOrderNoResp)
|
||
res, err = dao.OrderListByOrderUuid(req)
|
||
return
|
||
}
|
||
|
||
// GetUserOrderListWithDetails 根据用户ID获取订单列表（包含子表）
|
||
// 支持30+筛选条件和分页
|
||
func GetUserOrderListWithDetails(req *bundle.GetUserOrderListRequest) (*bundle.GetUserOrderListResponse, error) {
|
||
return dao.GetUserOrderListWithDetails(req)
|
||
}
|
||
|
||
// UpdateOrderExpiration 更新订单过期时间定时任务
|
||
// 根据 BundleBalance.ExpiredAt 更新 BundleOrderRecords.ExpirationTime
|
||
// 只更新 ExpirationTime 为空的记录
|
||
func UpdateOrderExpiration(req *bundle.UpdateOrderExpirationRequest) (*bundle.UpdateOrderExpirationResponse, error) {
|
||
res := &bundle.UpdateOrderExpirationResponse{}
|
||
updated, err := dao.UpdateOrderExpiration()
|
||
if err != nil {
|
||
res.Msg = fmt.Sprintf("更新失败: %v", err)
|
||
return res, err
|
||
}
|
||
res.Updated = updated
|
||
res.Msg = fmt.Sprintf("成功更新 %d 条订单记录", updated)
|
||
return res, nil
|
||
}
|
||
|
||
// CompleteExpiredOrders 完成已过期订单定时任务
|
||
// 将已支付且已过期的订单状态更新为已完成(status=4)
|
||
func CompleteExpiredOrders(req *bundle.CompleteExpiredOrdersRequest) (*bundle.CompleteExpiredOrdersResponse, error) {
|
||
res := &bundle.CompleteExpiredOrdersResponse{}
|
||
completed, err := dao.CompleteExpiredOrders()
|
||
if err != nil {
|
||
res.Msg = fmt.Sprintf("更新失败: %v", err)
|
||
return res, err
|
||
}
|
||
res.Completed = completed
|
||
res.Msg = fmt.Sprintf("成功完成 %d 条订单", completed)
|
||
return res, nil
|
||
}
|