682 lines
19 KiB
Go
682 lines
19 KiB
Go
package bundle
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"fonchain-fiee/api/accountFiee"
|
|
"fonchain-fiee/api/bundle"
|
|
"fonchain-fiee/api/order"
|
|
"fonchain-fiee/pkg/model/login"
|
|
"fonchain-fiee/pkg/service"
|
|
"fonchain-fiee/pkg/service/bundle/common"
|
|
"fonchain-fiee/pkg/service/bundle/logic"
|
|
bundleModel "fonchain-fiee/pkg/service/bundle/model"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/gin-gonic/gin/binding"
|
|
)
|
|
|
|
func CreateBundleOrderAddSignature(c *gin.Context) {
|
|
var req bundle.OrderAddRecord
|
|
|
|
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
if req.Language == "" {
|
|
service.Error(c, errors.New(common.MissLanguageTypes))
|
|
return
|
|
}
|
|
if req.BundleUuid == "" {
|
|
service.Error(c, errors.New(common.MissOrderNo))
|
|
return
|
|
}
|
|
// 获取用户信息
|
|
userInfo := login.GetUserInfoFromC(c)
|
|
if msg, exists := map[int32]string{
|
|
1: common.Unnamed,
|
|
2: common.UnderReview,
|
|
3: common.ReviewFailed,
|
|
}[userInfo.Status]; userInfo.Status != 4 {
|
|
if exists {
|
|
service.Error(c, errors.New(msg))
|
|
} else {
|
|
service.Error(c, errors.New(common.UnknownStatus))
|
|
}
|
|
return
|
|
}
|
|
|
|
// 校验套餐是否已购买
|
|
orderRecordReq := bundle.OrderRecordsDetailRequest{
|
|
BundleUUID: req.BundleUuid,
|
|
CustomerID: strconv.FormatUint(userInfo.ID, 10),
|
|
}
|
|
orderRecordResp, err := service.BundleProvider.OrderRecordsDetail(context.Background(), &orderRecordReq)
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
if orderRecordResp.OrderRecord.ExpirationTime == "" || orderRecordResp.OrderRecord.ExpirationTime < time.Now().Format("2006-01-02") {
|
|
service.Error(c, errors.New(common.ThePackageHasExpired))
|
|
return
|
|
}
|
|
// 获取套餐详情（待替换逻辑）
|
|
bundleDetail, err := service.BundleProvider.BundleDetail(context.Background(), &bundle.BundleDetailRequest{
|
|
Uuid: req.BundleUuid,
|
|
})
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
// todo 需要判断购买的增值服务是否为可用时长 如果为可以用时长 合同截止日期为购买时长时间 否则合同截止日期为主套餐截止日期
|
|
// 处理多个增值服务
|
|
type ValueAddServiceInfo struct {
|
|
Service *bundle.ValueAddServiceLang
|
|
Options *bundle.ValueAddPriceOptions
|
|
ID int32
|
|
}
|
|
// 计算总金额和确定截止日期
|
|
var expirationDate string
|
|
var addPriceList []*bundle.AddPriceOptionsInfo
|
|
var totalAmount float32
|
|
for _, svc := range req.AddPriceOptionsList {
|
|
valueAddInfo, err := service.BundleProvider.ValueAddServiceLangByUuidAndLanguage(context.Background(), &bundle.ValueAddServiceDetailRequest{
|
|
Uuid: svc.ValueUid,
|
|
Language: req.Language,
|
|
})
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
valuePrice, err := service.BundleProvider.CalculatePrice(context.Background(), &bundle.CalculatePriceRequest{
|
|
Uuid: svc.ValueUid,
|
|
Num: svc.Num,
|
|
Language: req.Language,
|
|
})
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
totalAmount += valuePrice.Price
|
|
addPriceList = append(addPriceList, &bundle.AddPriceOptionsInfo{
|
|
ValueUid: valueAddInfo.Uuid,
|
|
ServiceType: valueAddInfo.ServiceType,
|
|
CurrencyType: valueAddInfo.PriceType,
|
|
Amount: valuePrice.Price,
|
|
Num: svc.Num,
|
|
Unit: valueAddInfo.Unit,
|
|
})
|
|
// 如果是可用时长服务，计算新的截止日期
|
|
if valueAddInfo.ServiceType == 5 {
|
|
endDate := orderRecordResp.OrderRecord.ExpirationTime
|
|
if endDate == "9999-12-31" {
|
|
service.Error(c, errors.New(common.ErrorPermanentPackage))
|
|
return
|
|
}
|
|
t, err := time.Parse("2006-01-02", endDate)
|
|
if err != nil {
|
|
fmt.Println("解析时间出错:", err)
|
|
return
|
|
}
|
|
newDeadline := calculateExpirationDate(t, svc.Num, valueAddInfo.Unit)
|
|
expirationDate = newDeadline
|
|
//}
|
|
}
|
|
}
|
|
// 如果没有可用时长服务，使用主套餐截止日期
|
|
if expirationDate == "" {
|
|
expirationDate = orderRecordResp.OrderRecord.ExpirationTime
|
|
}
|
|
req.CustomerNum = userInfo.SubNum
|
|
req.CustomerName = userInfo.Name
|
|
req.CustomerID = strconv.FormatUint(userInfo.ID, 10)
|
|
req.Source = 2
|
|
req.SignedTime = common.GetBeijingTime()
|
|
req.ExpirationDate = expirationDate
|
|
req.AddPriceOptionsList = addPriceList
|
|
req.OrderUUID = orderRecordResp.OrderRecord.Uuid
|
|
// 当前 未将 签名 写入合同中
|
|
signContract, signContractErr := logic.SignContractV2(req.CustomerNum, bundleDetail.Bundle.Contract, totalAmount, expirationDate)
|
|
if signContractErr != nil {
|
|
service.Error(c, signContractErr)
|
|
return
|
|
}
|
|
req.SignContract = signContract
|
|
// 创建增值服务订单记录
|
|
res, err := service.BundleProvider.CreateOrderAddRecord(context.Background(), &req)
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
service.Success(c, res)
|
|
}
|
|
|
|
// 计算截止日期辅助函数
|
|
func calculateExpirationDate(startDate time.Time, num int32, unit string) string {
|
|
//now := time.Now()
|
|
switch unit {
|
|
case "天":
|
|
return startDate.AddDate(0, 0, int(num)).Format("2006-01-02")
|
|
case "月":
|
|
return startDate.AddDate(0, int(num), 0).Format("2006-01-02")
|
|
case "年":
|
|
return startDate.AddDate(int(num), 0, 0).Format("2006-01-02")
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
func CreateBundleOrderSignature(c *gin.Context) {
|
|
var req bundle.OrderCreateRecord
|
|
|
|
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
if req.BundleUuid == "" {
|
|
service.Error(c, errors.New(common.MissBundleUUID))
|
|
return
|
|
}
|
|
if req.Language == "" {
|
|
service.Error(c, errors.New(common.MissLanguageTypes))
|
|
return
|
|
}
|
|
// 不去校验 签名
|
|
/*if req.Signature == "" {
|
|
service.Error(c, errors.New(common.MissOrderSignature))
|
|
return
|
|
}*/
|
|
statusMessages := map[int32]string{
|
|
1: common.Unnamed,
|
|
2: common.UnderReview,
|
|
3: common.ReviewFailed,
|
|
}
|
|
// 获取 用户信息
|
|
userInfo := login.GetUserInfoFromC(c)
|
|
if userInfo.Status != 4 {
|
|
if msg, exists := statusMessages[userInfo.Status]; exists {
|
|
service.Error(c, errors.New(msg))
|
|
return
|
|
} else {
|
|
service.Error(c, errors.New(common.UnknownStatus))
|
|
return
|
|
}
|
|
}
|
|
// 校验 当前用户只能买一次套餐
|
|
orderRecordsListReq := bundle.OrderRecordsRequest{
|
|
CustomerID: strconv.FormatUint(userInfo.ID, 10),
|
|
}
|
|
orderRecordsList, orderRecordsListErr := service.BundleProvider.OrderRecordsList(context.Background(), &orderRecordsListReq)
|
|
if orderRecordsListErr != nil {
|
|
service.Error(c, orderRecordsListErr)
|
|
return
|
|
}
|
|
//有套餐并且套餐未过期
|
|
if orderRecordsList.OrderRecords != nil {
|
|
for _, orderInfo := range orderRecordsList.OrderRecords {
|
|
if orderInfo.CustomerID == strconv.FormatUint(userInfo.ID, 10) && orderInfo.ExpirationTime > time.Now().Format("2006-01-02") {
|
|
service.Error(c, errors.New(common.HadOrder))
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// 获取 最后一次的 合同编号
|
|
lastOrderRecord, lastOrderRecordErr := service.BundleProvider.OrderRecordsList(context.Background(), &bundle.OrderRecordsRequest{
|
|
PageSize: 1,
|
|
Page: 1,
|
|
})
|
|
|
|
if lastOrderRecordErr != nil {
|
|
service.Error(c, lastOrderRecordErr)
|
|
return
|
|
}
|
|
lastContractNo := ""
|
|
if lastOrderRecord.OrderRecords != nil {
|
|
for _, lastOrder := range lastOrderRecord.OrderRecords {
|
|
lastContractNo = lastOrder.ContractNo
|
|
}
|
|
}
|
|
// 获取 套餐信息
|
|
bundleDetailReq := &bundle.BundleDetailRequest{
|
|
Uuid: req.BundleUuid,
|
|
}
|
|
bundleDetail, detailErr := service.BundleProvider.BundleDetail(context.Background(), bundleDetailReq)
|
|
if detailErr != nil {
|
|
service.Error(c, detailErr)
|
|
return
|
|
}
|
|
//获取过期时间和增值服务金额
|
|
var addRecords []*bundle.OrderCreateAddRecord
|
|
var addTotalPrice float32
|
|
var expirationDay string
|
|
for _, i := range req.AddRecords {
|
|
price, err := service.BundleProvider.CalculatePrice(context.Background(), &bundle.CalculatePriceRequest{
|
|
Uuid: i.ValueUid,
|
|
Num: i.Num,
|
|
Language: req.Language,
|
|
})
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
addTotalPrice += price.Price
|
|
addService, err := service.BundleProvider.ValueAddServiceLangByUuidAndLanguage(context.Background(), &bundle.ValueAddServiceDetailRequest{
|
|
Uuid: i.ValueUid,
|
|
Language: req.Language,
|
|
})
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
addRecords = append(addRecords, &bundle.OrderCreateAddRecord{
|
|
ServiceType: addService.ServiceType,
|
|
ValueUid: i.ValueUid,
|
|
CurrencyType: addService.PriceType,
|
|
Amount: price.Price,
|
|
Num: i.Num,
|
|
Unit: addService.Unit,
|
|
Source: 1,
|
|
PaymentStatus: 1,
|
|
})
|
|
//服务类型为时长 计算
|
|
if addService.ServiceType == 5 {
|
|
expirationDay = calculateExpirationDate(time.Now(), i.Num, addService.Unit)
|
|
} else {
|
|
expirationDay = time.Now().AddDate(0, 0, 7).Format("2006-01-02")
|
|
}
|
|
}
|
|
// 当前 未将 签名 写入合同中 todo 金额和有效时间待修改
|
|
signContract, signContractErr := logic.SignContractV2(req.CustomerNum, bundleDetail.Bundle.Contract, addTotalPrice, expirationDay)
|
|
if signContractErr != nil {
|
|
service.Error(c, signContractErr)
|
|
return
|
|
}
|
|
req.CustomerNum = userInfo.SubNum
|
|
req.CustomerName = userInfo.Name
|
|
req.CustomerID = strconv.FormatUint(userInfo.ID, 10)
|
|
req.BundleName = bundleDetail.Bundle.Name
|
|
req.Amount = bundleDetail.Bundle.Price
|
|
req.AmountType = bundleDetail.Bundle.PriceType
|
|
req.BundleCommonUid = bundleDetail.Bundle.BundleCommonUid
|
|
req.TotalAmount = bundleDetail.Bundle.Price + addTotalPrice
|
|
req.ContractNo = common.GenerateContractNo(lastContractNo)
|
|
req.SignContract = signContract
|
|
req.SignedTime = common.GetBeijingTime()
|
|
req.Status = bundleModel.OrderSigned
|
|
req.AddRecords = addRecords
|
|
req.ExpirationTime = expirationDay
|
|
req.PayType = 1
|
|
|
|
res, err := service.BundleProvider.CreateOrderRecord(context.Background(), &req)
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
service.Success(c, res)
|
|
}
|
|
|
|
func UpdateBundleOrderStatusPaid(c *gin.Context) {
|
|
var req bundle.OrderRecord
|
|
|
|
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
// 获取 用户信息
|
|
userInfo := login.GetUserInfoFromC(c)
|
|
|
|
if req.Uuid == "" {
|
|
service.Error(c, errors.New(common.MissOrderUUID))
|
|
return
|
|
}
|
|
|
|
detail, detailErr := service.BundleProvider.OrderRecordsDetail(context.Background(), &bundle.OrderRecordsDetailRequest{
|
|
Uuid: req.Uuid,
|
|
})
|
|
|
|
if detailErr != nil {
|
|
service.Error(c, detailErr)
|
|
return
|
|
}
|
|
|
|
// 判断 是否是 本人操作
|
|
if strconv.FormatUint(userInfo.ID, 10) != detail.OrderRecord.CustomerID {
|
|
service.Error(c, errors.New(common.NotMatchOrderInfo))
|
|
return
|
|
}
|
|
|
|
// 如果 当前订单 是 已签未支付 且 存在 checkoutSessionId 需要 查询 支付结果
|
|
if detail.OrderRecord.Status == bundleModel.OrderSigned && detail.OrderRecord.CheckoutSessionId != "" && detail.OrderRecord.PayTime == "" {
|
|
// 查询支付结果
|
|
stripeInfosRes, stripeInfosErr := service.OrderProvider.QueryStripeInfoByCheckSessionIds(context.Background(), &order.QueryStripeInfoRequest{
|
|
CheckoutSessionIds: []string{detail.OrderRecord.CheckoutSessionId},
|
|
})
|
|
|
|
if stripeInfosErr != nil {
|
|
service.Error(c, errors.New(common.ErrorQueryStripeInfo))
|
|
return
|
|
}
|
|
|
|
totalStripe := 0
|
|
|
|
if stripeInfosRes != nil && len(stripeInfosRes.StripeInfos) > 0 {
|
|
totalStripe = len(stripeInfosRes.StripeInfos)
|
|
for _, stripeInfo := range stripeInfosRes.StripeInfos {
|
|
if stripeInfo.OutTradeNo == detail.OrderRecord.OrderNo && stripeInfo.PaymentIntentStatus == "paid" {
|
|
_, updateOrderRecordErr := service.BundleProvider.UpdateOrderRecord(context.Background(), &bundle.OrderRecord{
|
|
Uuid: detail.OrderRecord.Uuid,
|
|
Status: bundleModel.OrderPaid,
|
|
PayTime: common.GetBeijingTime(),
|
|
})
|
|
if updateOrderRecordErr != nil {
|
|
service.Error(c, detailErr)
|
|
return
|
|
}
|
|
totalStripe--
|
|
}
|
|
}
|
|
}
|
|
|
|
if totalStripe != 0 && totalStripe == len(stripeInfosRes.StripeInfos) {
|
|
_, updateOrderRecordErr := service.BundleProvider.UpdateOrderRecord(context.Background(), &bundle.OrderRecord{
|
|
Uuid: detail.OrderRecord.Uuid,
|
|
CheckoutSessionId: "",
|
|
CheckoutSessionUrl: "",
|
|
})
|
|
if updateOrderRecordErr != nil {
|
|
service.Error(c, detailErr)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
service.Success(c, nil)
|
|
}
|
|
func OrderRecordsListV2(c *gin.Context) {
|
|
var req bundle.OrderRecordsRequestV2
|
|
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
res := &bundle.OrderRecordsResponseV2{}
|
|
|
|
// Step 1: 如果有姓名/电话筛选，先查用户列表
|
|
if req.CustomerName != "" {
|
|
userListResp, err := service.AccountFieeProvider.UserList(context.Background(), &accountFiee.UserListRequest{
|
|
BlurNameTel: req.CustomerName,
|
|
Domain: "app",
|
|
})
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
if len(userListResp.UserList) == 0 {
|
|
// 没查到用户，直接返回空结果
|
|
res.Page = req.Page
|
|
res.PageSize = req.PageSize
|
|
res.Total = 0
|
|
service.Success(c, res)
|
|
return
|
|
}
|
|
|
|
// 提取用户ID列表
|
|
for _, u := range userListResp.UserList {
|
|
req.UserIds = append(req.UserIds, int64(u.Id))
|
|
}
|
|
}
|
|
|
|
// Step 2: 查询订单列表
|
|
orderList, err := service.BundleProvider.OrderRecordsListV2(context.Background(), &req)
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
// Step 3: 如果订单不为空，查一次用户信息填充（只查一次）
|
|
if len(orderList.BundleInfo) > 0 {
|
|
// 收集订单里的所有用户ID
|
|
userIdSet := make(map[int64]struct{})
|
|
for _, i := range orderList.BundleInfo {
|
|
userIdSet[i.CustomerId] = struct{}{}
|
|
}
|
|
|
|
var userIds []int64
|
|
for id := range userIdSet {
|
|
userIds = append(userIds, id)
|
|
}
|
|
|
|
userListResp, err := service.AccountFieeProvider.UserList(context.Background(), &accountFiee.UserListRequest{
|
|
Ids: userIds,
|
|
Domain: "app",
|
|
})
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
// 建立用户ID -> 用户信息映射
|
|
userMap := make(map[int64]*accountFiee.UserListInfo, len(userListResp.UserList))
|
|
for _, u := range userListResp.UserList {
|
|
userMap[int64(u.Id)] = u
|
|
}
|
|
|
|
// 填充订单中的用户信息
|
|
for _, item := range orderList.BundleInfo {
|
|
if u, ok := userMap[item.CustomerId]; ok {
|
|
item.CustomerName = u.Name
|
|
item.TelNum = u.TelNum
|
|
}
|
|
}
|
|
}
|
|
|
|
service.Success(c, orderList)
|
|
}
|
|
func OrderRecordsList(c *gin.Context) {
|
|
var req bundle.OrderRecordsRequest
|
|
|
|
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
// 获取 用户信息
|
|
//userInfo := login.GetUserInfoFromC(c)
|
|
|
|
//req.CustomerID = strconv.FormatUint(userInfo.ID, 10)
|
|
|
|
res, err := service.BundleProvider.OrderRecordsList(context.Background(), &req)
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
for _, orderRecord := range res.OrderRecords {
|
|
if orderRecord.CustomerID != "" {
|
|
var userID uint64
|
|
userID, err = strconv.ParseUint(orderRecord.CustomerID, 10, 64)
|
|
if err != nil {
|
|
err = nil
|
|
continue
|
|
}
|
|
|
|
userInfo, _ := service.AccountFieeProvider.Info(context.Background(), &accountFiee.InfoRequest{
|
|
Domain: "app",
|
|
ID: userID,
|
|
})
|
|
if userInfo != nil {
|
|
orderRecord.Sex = userInfo.Sex
|
|
orderRecord.Nationality = userInfo.Nationality
|
|
orderRecord.CertificatePicture = userInfo.CertificatePicture
|
|
orderRecord.PlaceOfResidence = userInfo.PlaceOfResidence
|
|
orderRecord.GroupPhoto = userInfo.GroupPhoto
|
|
orderRecord.TelNum = userInfo.TelNum
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
service.Success(c, res)
|
|
}
|
|
|
|
func OrderRecordsDetail(c *gin.Context) {
|
|
var req bundle.OrderRecordsDetailRequest
|
|
|
|
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
/*// 获取 用户信息
|
|
userInfo := login.GetUserInfoFromC(c)
|
|
|
|
req.CustomerID = strconv.FormatUint(userInfo.ID, 10)*/
|
|
|
|
res, err := service.BundleProvider.OrderRecordsDetail(context.Background(), &req)
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
service.Success(c, res)
|
|
}
|
|
|
|
// web
|
|
func UpdateFinancialConfirmationStatus(c *gin.Context) {
|
|
var req bundle.FinancialConfirmationRequest
|
|
|
|
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
// 不限制 支付状态 未支付 也可确认
|
|
//detail, err := service.BundleProvider.OrderRecordsDetail(context.Background(), &bundle.OrderRecordsDetailRequest{
|
|
// OrderNo: req.OrderNo,
|
|
//})
|
|
//if err != nil {
|
|
// service.Error(c, err)
|
|
// return
|
|
//}
|
|
//if detail.OrderRecord.Status != bundleModel.OrderPaid {
|
|
// service.Error(c, errors.New("订单未支付,不可确认"))
|
|
// return
|
|
//}
|
|
|
|
res, err := service.BundleProvider.UpdateFinancialConfirmationStatus(context.Background(), &req)
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
service.Success(c, res)
|
|
}
|
|
|
|
func ExportOrderInfo(c *gin.Context) {
|
|
var req bundle.OrderRecordsRequest
|
|
|
|
if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
res, err := service.BundleProvider.OrderRecordsList(context.Background(), &req)
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
rows := make([][]interface{}, 0)
|
|
|
|
for _, orderRecord := range res.OrderRecords {
|
|
if orderRecord.CustomerID != "" {
|
|
var userID uint64
|
|
userID, err = strconv.ParseUint(orderRecord.CustomerID, 10, 64)
|
|
if err != nil {
|
|
err = nil
|
|
continue
|
|
}
|
|
|
|
userInfo, _ := service.AccountFieeProvider.Info(context.Background(), &accountFiee.InfoRequest{
|
|
Domain: "app",
|
|
ID: userID,
|
|
})
|
|
if userInfo != nil {
|
|
orderRecord.Sex = userInfo.Sex
|
|
orderRecord.Nationality = userInfo.Nationality
|
|
orderRecord.TelNum = userInfo.TelNum
|
|
}
|
|
}
|
|
|
|
status := ""
|
|
if orderRecord.Status == bundleModel.OrderSigned {
|
|
status = "未支付"
|
|
} else if orderRecord.Status == bundleModel.OrderPaid {
|
|
status = "已支付"
|
|
}
|
|
financialConfirmation := ""
|
|
if orderRecord.FinancialConfirmation == bundleModel.UnConfirm {
|
|
financialConfirmation = "未确认"
|
|
} else if orderRecord.FinancialConfirmation == bundleModel.Confirmed {
|
|
financialConfirmation = "已确认"
|
|
}
|
|
|
|
rows = append(rows, []interface{}{
|
|
orderRecord.OrderNo,
|
|
orderRecord.CustomerNum,
|
|
orderRecord.CustomerName,
|
|
orderRecord.Sex,
|
|
orderRecord.TelNum,
|
|
orderRecord.Nationality,
|
|
orderRecord.BundleName,
|
|
orderRecord.SignedTime,
|
|
orderRecord.Amount,
|
|
orderRecord.Num,
|
|
orderRecord.ValueAddBundleAmount,
|
|
orderRecord.TotalAmount,
|
|
status,
|
|
orderRecord.PayTime,
|
|
financialConfirmation,
|
|
})
|
|
}
|
|
|
|
dirPath := "./runtime"
|
|
|
|
filePath, err := logic.WriteToExcel(dirPath, rows)
|
|
if err != nil {
|
|
service.Error(c, err)
|
|
return
|
|
}
|
|
|
|
var httpType string = "http" // Default to http
|
|
|
|
// Safely check if Origin exists in c.Keys
|
|
if origin, exists := c.Keys["Origin"]; exists && origin != nil {
|
|
originStr, ok := origin.(string)
|
|
if ok && originStr != "" {
|
|
fmt.Printf("c.Request.Origin %+v\n", originStr)
|
|
parts := strings.Split(originStr, ":")
|
|
if len(parts) > 0 {
|
|
httpType = parts[0]
|
|
}
|
|
}
|
|
} else {
|
|
// Fallback: Check if the request was made over TLS
|
|
if c.Request.TLS != nil || c.Request.Header.Get("X-Forwarded-Proto") == "https" {
|
|
httpType = "https"
|
|
}
|
|
}
|
|
|
|
var exportUrl = strings.Replace(strings.Replace(filePath, ".", fmt.Sprintf("%s://%s", httpType, c.Request.Host), 1), "runtime", "api/static", 1)
|
|
//var exportUrl = fmt.Sprintf("%s%s/%s", httpType, c.Request.Host, dirPath + path)
|
|
fmt.Println("exportUrl : ", exportUrl)
|
|
service.Success(c, &bundleModel.ExportResponse{ExportUrl: exportUrl})
|
|
}
|