chenlin/migu_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1.增加逻辑，如果订购成功回调通知有订单表之外的数据；则查询流水表，有则加入记录；

Browse Source 
2.10分钟定时任务查询退订数据时，如果连续查询权益接口5次都没返回数据；则默认为拒绝支付数据，计算是否为1小时退订数据；
This commit is contained in:
chenlin 2024-10-21 18:13:56 +08:00
parent cb52858656
commit d372c69e32
5 changed files with 168 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/admin/apis/migumanage/migu_admin.go
View File

@ -315,7 +315,7 @@ func (e MiGuDeployService) OrderList(c *gin.Context) {
}
var orderList []models.MgOrder
err = qs.Order("id desc").Offset(pageNum * req.PageSize).Limit(req.PageSize).Find(&orderList).Error
err = qs.Order("created_at desc").Offset(pageNum * req.PageSize).Limit(req.PageSize).Find(&orderList).Error
if err != nil {
logger.Errorf("OrderList err:%#v", err)
response.Error(c, http.StatusInternalServerError, err, "查询失败")

69
app/admin/apis/migumanage/migu_notice.go
View File

@ -5,7 +5,9 @@ import (
"github.com/gin-gonic/gin"
"github.com/go-admin-team/go-admin-core/logger"
"go-admin/app/admin/models"
"go-admin/tools"
"go-admin/tools/app"
"net/http"
"time"
)
@ -54,26 +56,67 @@ func (e MiGuDeployService) SubscribeNotice(c *gin.Context) {
return
}
// 查询是否有记录
// 查询订单表是否有记录
var orderInfo models.MgOrder
err = e.Orm.Table("mg_order").Where("external_order_id = ?", orderId).First(&orderInfo).Error
if err != nil {
if err != nil && err.Error() != "record not found" {
logger.Errorf("SubscribeNotice query mg_order err:", err.Error())
app.MiGuNoticeOK(c, "failed")
return
}
if orderInfo.State != 1{
err = e.Orm.Table("mg_order").Where("external_order_id = ?", orderId).Updates(map[string]interface{}{
"state": models.SubscribeOK,
"subscribe_time": time.Now(),
"updated_at": time.Now(),
}).Error
if err != nil {
logger.Errorf("SubscribeNotice update mg_order err:", err.Error())
if err.Error() == "record not found" { // 订单表没有记录
if extData == "" { // 没有返回平台订单号
logger.Error("extData is null")
app.MiGuNoticeOK(c, "failed")
return
}
// 查询交易流水表
var logInfo models.MgTransactionLog
err = e.Orm.Table("mg_transaction_log").
Where("out_trade_no = ? and verification_code <> ''", extData).First(&logInfo).Error
if err != nil {
logger.Errorf("SubscribeNotice query mg_transaction_log err:", err.Error())
app.MiGuNoticeOK(c, "failed")
return
}
// 插入订单表
var inOrder models.MgOrder
inOrder.CreatedAt = logInfo.CreatedAt
inOrder.UpdatedAt = logInfo.UpdatedAt
inOrder.ProductID = logInfo.ProductID
inOrder.ChannelCode = logInfo.ChannelCode
inOrder.OrderSerial = logInfo.OutTradeNo
strTime := time.Now()
inOrder.SubscribeTime = &strTime
inOrder.PhoneNumber = logInfo.PhoneNumber
inOrder.SM4PhoneNumber, _ = tools.SM4Encrypt(models.SM4KEy, logInfo.PhoneNumber)
inOrder.ExternalOrderID = logInfo.LinkId
inOrder.ChannelTradeNo = logInfo.ChannelTradeNo
inOrder.State = models.SubscribeOK
err = e.Orm.Create(&inOrder).Error
if err != nil {
logger.Info("Create MgOrder err:", err)
app.MiGuError(c, http.StatusBadRequest, err, err.Error())
return
}
orderInfo.ChannelCode = inOrder.ChannelCode
} else { // 订单表有记录
if orderInfo.State != 1 {
err = e.Orm.Table("mg_order").Where("external_order_id = ?", orderId).Updates(map[string]interface{}{
"state": models.SubscribeOK,
"subscribe_time": time.Now(),
"updated_at": time.Now(),
}).Error
if err != nil {
logger.Errorf("SubscribeNotice update mg_order err:", err.Error())
app.MiGuNoticeOK(c, "failed")
return
}
}
}
// 判断是否为子渠道订购，是的话需要通知子渠道
@ -96,7 +139,7 @@ func (e MiGuDeployService) SubscribeNotice(c *gin.Context) {
}
if resp != "success" {
continue
}else{
} else {
break
}
}
@ -191,13 +234,13 @@ func (e MiGuDeployService) UnsubscribeNotice(c *gin.Context) {
if channelInfo.SubscribeURL != "" {
for i := 0; i < 3; i++ {
resp, err := models.NoticeSubChannel(channelInfo.SubscribeURL, orderInfo.OrderSerial,
orderInfo.ChannelTradeNo,"2")
orderInfo.ChannelTradeNo, "2")
if err != nil {
continue
}
if resp != "success" {
continue
}else{
} else {
break
}
}

108
app/admin/models/migu.go
View File

@ -863,11 +863,11 @@ func CheckOrderState() {
// 查询订单列表中未退订的用户，查询其是否退订；如果退订，则更新退订时间，判断是否为1小时内退订
var orderList []MgOrder
// 获取当天的凌晨 00:50:00
startOfDay := time.Now().Truncate(24 * time.Hour).Add(50 * time.Minute)
// 获取当前时间前2个小时
oneHourAgo := time.Now().Add(-2 * time.Hour)
err := database.Db.Where("is_one_hour_cancel != 1").
Where("created_at > ?", startOfDay).
Where("created_at >= ?", oneHourAgo).
Order("created_at desc").
Find(&orderList).Error
@ -877,11 +877,99 @@ func CheckOrderState() {
}
for i, _ := range orderList {
var req QueryRightsInfoReq
req.AppChannelList = append(req.AppChannelList, ChannelCode)
req.Mobile = orderList[i].PhoneNumber
for j := 0; j < 5; j++ {
var req QueryRightsInfoReq
req.AppChannelList = append(req.AppChannelList, ChannelCode)
req.Mobile = orderList[i].PhoneNumber
resp, err := MiGuQueryRightsInfo(&req)
if err != nil {
fmt.Println("CheckOrderState MiGuQueryRightsInfo err:", err.Error())
logger.Errorf("CheckOrderState MiGuQueryRightsInfo err:", err.Error())
continue
}
// 有退订数据
if len(resp.ResultData) != 0 {
if resp.ResultData[0].IsUnsub == 1 { // 已退订
var cancelFlag int
subscribeTime := orderList[i].CreatedAt
// 检查 subscribeTime 是否为 nil
if IsWithinOneHourCancel(subscribeTime, resp.ResultData[0].UnsubTime) {
cancelFlag = 1
}
err = database.Db.Table("mg_order").Where("order_serial = ?", orderList[i].OrderSerial).Updates(map[string]interface{}{
"state": UnsubscribeOK,
"is_one_hour_cancel": cancelFlag,
"unsubscribe_time": resp.ResultData[0].UnsubTime,
"updated_at": time.Now(),
}).Error
if err != nil {
fmt.Println("CheckOrderState update mg_order err:", err.Error())
logger.Errorf("CheckOrderState update mg_order err:", err.Error())
logger.Errorf("CheckOrderState order_serial:", orderList[i].OrderSerial)
continue
}
break
} else if resp.ResultData[0].IsUnsub == 0 { // 没有退订
break
}
} else {
if j == 4 {
var cancelFlag int
subscribeTime := orderList[i].CreatedAt
unsubTime := time.Now().Format("2006-01-02 15:04:05")
// 检查 subscribeTime 是否为 nil
if IsWithinOneHourCancel(subscribeTime, unsubTime) {
cancelFlag = 1
}
err = database.Db.Table("mg_order").Where("order_serial = ?", orderList[i].OrderSerial).Updates(map[string]interface{}{
"state": UnsubscribeOK,
"is_one_hour_cancel": cancelFlag,
"unsubscribe_time": unsubTime,
"updated_at": time.Now(),
}).Error
if err != nil {
fmt.Println("CheckOrderState update mg_order err:", err.Error())
logger.Errorf("CheckOrderState update mg_order err:", err.Error())
logger.Errorf("CheckOrderState order_serial:", orderList[i].OrderSerial)
continue
}
break
}
continue
}
}
}
}
// CheckAllOrderState 定时任务，检查所有非1小时退订订单
func CheckAllOrderState() {
if database.Db == nil {
log.Println("Database connection is nil")
fmt.Println("Database connection is nil")
return
}
// 查询订单列表中未退订的用户，查询其是否退订；如果退订，则更新退订时间，判断是否为1小时内退订
var orderList []MgOrder
err := database.Db.Where("is_one_hour_cancel != 1").Order("created_at desc").
Find(&orderList).Error
if err != nil {
fmt.Println("query mg_order err:", err.Error())
return
}
for i, _ := range orderList {
for j := 0; j < 3; j++ {
var req QueryRightsInfoReq
req.AppChannelList = append(req.AppChannelList, ChannelCode)
req.Mobile = orderList[i].PhoneNumber
for j:=0; j<3;j++{
resp, err := MiGuQueryRightsInfo(&req)
if err != nil {
fmt.Println("CheckOrderState MiGuQueryRightsInfo err:", err.Error())
@ -913,7 +1001,11 @@ func CheckOrderState() {
}
break
}
}else{
} else {
if j == 2 {
fmt.Println("resp.ResultData is null, phone_number is:", req.Mobile)
logger.Errorf("resp.ResultData is null, phone_number is:", req.Mobile)
}
continue
}
}

12
cmd/api/server.go
View File

@ -92,11 +92,21 @@ func run() error {
// TODO
s := gocron.NewScheduler()
err := s.Every(1).Day().At("01:00").Do(models.CheckOrderState)
//err := s.Every(1).Day().At("18:01").Do(models.CheckOrderState)
//if err != nil {
// fmt.Println("err:", err)
//}
err := s.Every(10).Minute().Do(models.CheckOrderState)
if err != nil {
fmt.Println("err:", err)
}
//err = s.Every(1).Day().At("10:28").Do(models.CheckAllOrderState)
//if err != nil {
// fmt.Println("err:", err)
//}
<-s.Start()
}()

BIN
temp_migu_server
View File

Binary file not shown.