loser/dongfeng-pay
1
1
Fork 0
mirror of https://github.com/kongyuebin1/dongfeng-pay.git synced 2025-10-17 10:38:00 +08:00
Code Issues Projects Releases Wiki Activity

由gopath形式改为module形式

Browse Source
This commit is contained in:
kongyuebin
2021-04-27 15:36:40 +08:00
parent 77d895e83a
commit 5ee1450a21
734 changed files with 1822 additions and 310623 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
boss/supplier/alipay.go
View File

@@ -10,7 +10,7 @@
package controller
import (
"dongfeng-pay/service/models"
"boss/models"
)
type AlipayImpl struct {

14
boss/supplier/gateway_solve.go
View File

@@ -10,9 +10,9 @@
package controller
import (
"github.com/astaxie/beego/logs"
"github.com/astaxie/beego/orm"
"dongfeng-pay/service/models"
"boss/models"
"github.com/beego/beego/v2/adapter/orm"
"github.com/beego/beego/v2/core/logs"
)
/*
@@ -20,22 +20,22 @@ import (
*/
func InsertOrderAndOrderProfit(orderInfo models.OrderInfo, orderProfitInfo models.OrderProfitInfo) bool {
o := orm.NewOrm()
o.Begin()
_ = o.Begin()
defer func(interface{}) {
if err := recover(); err != nil {
o.Rollback()
_ = o.Rollback()
}
}(o)
if _, err := o.Insert(&orderInfo); err != nil {
logs.Error("insert orderInfo fail: ", err)
o.Rollback()
_ = o.Rollback()
return false
}
if _, err := o.Insert(&orderProfitInfo); err != nil {
logs.Error("insert orderProfit fail: ", err)
o.Rollback()
_ = o.Rollback()
return false
}

4
boss/supplier/init.go
View File

@@ -10,8 +10,8 @@
package controller
import (
"dongfeng-pay/service/common"
"github.com/astaxie/beego/logs"
"boss/common"
"github.com/beego/beego/v2/core/logs"
)
var registerSupplier = make(map[string]PayInterface)

14
boss/supplier/kuaifu.go
View File

@@ -10,15 +10,15 @@
package controller
import (
"boss/common"
"boss/gojson"
"boss/models"
"boss/utils"
"fmt"
"github.com/astaxie/beego"
"github.com/astaxie/beego/httplib"
"github.com/astaxie/beego/logs"
"github.com/beego/beego/v2/adapter/httplib"
"github.com/beego/beego/v2/core/logs"
beego "github.com/beego/beego/v2/server/web"
"github.com/rs/xid"
"github.com/widuu/gojson"
"dongfeng-pay/service/common"
"dongfeng-pay/service/models"
"dongfeng-pay/service/utils"
"strconv"
"strings"
)

223
boss/supplier/order_settle.go
View File

@@ -10,12 +10,14 @@
package controller
import (
"boss/common"
"boss/models"
"boss/utils"
"context"
"errors"
"fmt"
"github.com/astaxie/beego/logs"
"github.com/astaxie/beego/orm"
"dongfeng-pay/service/common"
"dongfeng-pay/service/models"
"dongfeng-pay/service/utils"
"github.com/beego/beego/v2/client/orm"
"github.com/beego/beego/v2/core/logs"
"time"
)
@@ -38,81 +40,79 @@ func OrderSettle() {
func settle(orderSettle models.OrderSettleInfo, orderProfit models.OrderProfitInfo) bool {
o := orm.NewOrm()
o.Begin()
defer func(interface{}) {
if err := recover(); err != nil {
logs.Error(fmt.Sprintf("结算信息出了panic，错误信息：%s", err))
o.Rollback()
return
if err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
tmpSettle := new(models.OrderSettleInfo)
if err := txOrm.Raw("select * from order_settle_info where bank_order_id=? for update", orderSettle.BankOrderId).QueryRow(tmpSettle); err != nil || tmpSettle == nil {
logs.Error("获取tmpSettle失败，bankOrderId=%s", orderSettle.BankOrderId)
return err
}
}(o)
tmpSettle := new(models.OrderSettleInfo)
if err := o.Raw("select * from order_settle_info where bank_order_id=? for update", orderSettle.BankOrderId).QueryRow(tmpSettle); err != nil || tmpSettle == nil {
logs.Error("获取tmpSettle失败，bankOrderId=%s", orderSettle.BankOrderId)
o.Rollback()
return false
}
tmpSettle.UpdateTime = utils.GetBasicDateTime()
tmpSettle.IsCompleteSettle = common.YES
if _, err := o.Update(tmpSettle); err != nil {
logs.Error("更新tmpSettle失败，错误：", err)
o.Rollback()
return false
}
tmpSettle.UpdateTime = utils.GetBasicDateTime()
tmpSettle.IsCompleteSettle = common.YES
accountInfo := new(models.AccountInfo)
if err := o.Raw("select * from account_info where account_uid=? for update", orderSettle.MerchantUid).QueryRow(accountInfo); err != nil || accountInfo == nil {
logs.Error("结算select account info失败，错误信息：", err)
o.Rollback()
return false
}
accountInfo.UpdateTime = utils.GetBasicDateTime()
accountInfo.SettleAmount += orderProfit.FactAmount
if _, err := o.Update(accountInfo); err != nil {
logs.Error("结算update account 失败，错误信息：", err)
o.Rollback()
return false
}
if _, err := txOrm.Update(tmpSettle); err != nil {
logs.Error("更新tmpSettle失败，错误：", err)
return err
}
merchantDeployInfo := models.GetMerchantDeployByUidAndPayType(accountInfo.AccountUid, orderSettle.PayTypeCode)
if merchantDeployInfo.IsLoan == common.YES {
loadAmount := merchantDeployInfo.LoanRate * 0.01 * orderProfit.FactAmount
date := utils.GetDate()
params := make(map[string]string)
params["merchant_uid"] = tmpSettle.MerchantUid
params["road_uid"] = tmpSettle.RoadUid
params["load_date"] = date
if !models.IsExistMerchantLoadByParams(params) {
tmp := models.MerchantLoadInfo{Status: common.NO, MerchantUid: orderSettle.MerchantUid, RoadUid: orderSettle.RoadUid,
LoadDate: date, LoadAmount: loadAmount, UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := o.Insert(tmp); err != nil {
logs.Error("結算插入merchantLoad失敗，失败信息：", err)
o.Rollback()
return false
accountInfo := new(models.AccountInfo)
if err := txOrm.Raw("select * from account_info where account_uid=? for update", orderSettle.MerchantUid).QueryRow(accountInfo); err != nil || accountInfo == nil {
logs.Error("结算select account info失败，错误信息：", err)
return err
}
accountInfo.UpdateTime = utils.GetBasicDateTime()
accountInfo.SettleAmount += orderProfit.FactAmount
if _, err := txOrm.Update(accountInfo); err != nil {
logs.Error("结算update account 失败，错误信息：", err)
return err
}
merchantDeployInfo := models.GetMerchantDeployByUidAndPayType(accountInfo.AccountUid, orderSettle.PayTypeCode)
if merchantDeployInfo.IsLoan == common.YES {
loadAmount := merchantDeployInfo.LoanRate * 0.01 * orderProfit.FactAmount
date := utils.GetDate()
params := make(map[string]string)
params["merchant_uid"] = tmpSettle.MerchantUid
params["road_uid"] = tmpSettle.RoadUid
params["load_date"] = date
if !models.IsExistMerchantLoadByParams(params) {
tmp := models.MerchantLoadInfo{Status: common.NO, MerchantUid: orderSettle.MerchantUid, RoadUid: orderSettle.RoadUid,
LoadDate: date, LoadAmount: loadAmount, UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := txOrm.Insert(tmp); err != nil {
logs.Error("結算插入merchantLoad失敗，失败信息：", err)
return err
} else {
logs.Info("结算插入新的merchantLoad信息成功")
}
} else {
logs.Info("结算插入新的merchantLoad信息成功")
}
} else {
merchantLoad := new(models.MerchantLoadInfo)
if err := o.Raw("select * from merchant_load_info where merchant_uid=? and road_uid=? and load_date=? for update").
QueryRow(merchantLoad); err != nil || merchantLoad == nil {
logs.Error(fmt.Sprintf("结算过程，select merchant load info失败，错误信息：%s", err))
o.Rollback()
return false
} else {
merchantLoad.UpdateTime = utils.GetBasicDateTime()
merchantLoad.LoadAmount += loadAmount
if _, err := o.Update(merchantLoad); err != nil {
logs.Error(fmt.Sprintf("结算过程，update merchant load info失败，失败信息：%s", err))
o.Rollback()
return false
merchantLoad := new(models.MerchantLoadInfo)
if err := txOrm.Raw("select * from merchant_load_info where merchant_uid=? and road_uid=? and load_date=? for update").
QueryRow(merchantLoad); err != nil || merchantLoad == nil {
logs.Error(fmt.Sprintf("结算过程，select merchant load info失败，错误信息：%s", err))
return err
} else {
merchantLoad.UpdateTime = utils.GetBasicDateTime()
merchantLoad.LoadAmount = merchantLoad.LoadAmount + loadAmount
if _, err := txOrm.Update(merchantLoad); err != nil {
logs.Error(fmt.Sprintf("结算过程，update merchant load info失败，失败信息：%s", err))
return err
}
}
}
} else {
logs.Info(fmt.Sprintf("结算过程中，该商户不需要押款，全款结算"))
}
} else {
logs.Info(fmt.Sprintf("结算过程中，该商户不需要押款，全款结算"))
return nil
}); err != nil {
return false
}
return true
}
@@ -148,56 +148,45 @@ func MerchantLoadSolve() {
*/
func MerchantAbleAmount(merchantLoad models.MerchantLoadInfo) bool {
o := orm.NewOrm()
o.Begin()
defer func(interface{}) {
if err := recover(); err != nil {
logs.Error(fmt.Sprintf("解款操作出现了painc，错误信息：%s", err))
o.Rollback()
return
if err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
tmpLoad := new(models.MerchantLoadInfo)
if err := txOrm.Raw("select * from merchant_load_info where merchant_uid=? and road_uid=? and load_date=? for update",
merchantLoad.MerchantUid, merchantLoad.RoadUid, merchantLoad.LoadDate).QueryRow(tmpLoad); err != nil || tmpLoad == nil {
logs.Error(fmt.Sprintf("解款操作获取商户押款信息失败，fail： %s", err))
return err
}
if tmpLoad.Status != common.NO {
logs.Error(fmt.Sprintf("押款信息merchantuid=%s，通道uid=%s， 押款日期=%s,已经解款过，不需要再进行处理了", tmpLoad.MerchantUid, tmpLoad.RoadUid, tmpLoad.LoadDate))
return errors.New("已经解款过，不需要再进行处理了")
}
}(o)
tmpLoad := new(models.MerchantLoadInfo)
if err := o.Raw("select * from merchant_load_info where merchant_uid=? and road_uid=? and load_date=? for update",
merchantLoad.MerchantUid, merchantLoad.RoadUid, merchantLoad.LoadDate).QueryRow(tmpLoad); err != nil || tmpLoad == nil {
logs.Error(fmt.Sprintf("解款操作获取商户押款信息失败，fail： %s", err))
o.Rollback()
tmpLoad.UpdateTime = utils.GetBasicDateTime()
tmpLoad.Status = common.YES
if _, err := txOrm.Update(tmpLoad); err != nil {
logs.Error(fmt.Sprintf("解款操作更新merchant load info 失败：%s", err))
return err
}
accountInfo := new(models.AccountInfo)
accountInfo.UpdateTime = utils.GetBasicDateTime()
if accountInfo.LoanAmount >= tmpLoad.LoadAmount {
accountInfo.LoanAmount -= tmpLoad.LoadAmount
} else {
accountInfo.LoanAmount = common.ZERO
}
if _, err := txOrm.Update(accountInfo); err != nil {
logs.Error(fmt.Sprintf("解款操作更新account info 失败：%s，账户uid=%s", err, accountInfo.AccountUid))
return err
}
return nil
}); err != nil {
return false
}
if tmpLoad.Status != common.NO {
logs.Error(fmt.Sprintf("押款信息merchantuid=%s，通道uid=%s， 押款日期=%s,已经解款过，不需要再进行处理了", tmpLoad.MerchantUid, tmpLoad.RoadUid, tmpLoad.LoadDate))
o.Rollback()
return false
}
tmpLoad.UpdateTime = utils.GetBasicDateTime()
tmpLoad.Status = common.YES
if _, err := o.Update(tmpLoad); err != nil {
logs.Error(fmt.Sprintf("解款操作更新merchant load info 失败：%s", err))
o.Rollback()
return false
}
accountInfo := new(models.AccountInfo)
accountInfo.UpdateTime = utils.GetBasicDateTime()
if accountInfo.LoanAmount >= tmpLoad.LoadAmount {
accountInfo.LoanAmount -= tmpLoad.LoadAmount
} else {
accountInfo.LoanAmount = common.ZERO
}
if _, err := o.Update(accountInfo); err != nil {
logs.Error(fmt.Sprintf("解款操作更新account info 失败：%s，账户uid=%s", err, accountInfo.AccountUid))
o.Rollback()
return false
}
if err := o.Commit(); err != nil {
logs.Error(fmt.Sprintf("解款操作commint事务失败，账号uid=%s，错误信息=%s", accountInfo.AccountUid, err))
} else {
logs.Info(fmt.Sprintf("账户uid=%s，通道uid=%s，押款日期=%s，解款操作成功", accountInfo.AccountUid, tmpLoad.RoadUid, tmpLoad.LoadDate))
}
return true
}

704
boss/supplier/pay_solve.go
View File

@@ -10,13 +10,15 @@
package controller
import (
"boss/common"
"boss/message_queue"
"boss/models"
"boss/utils"
"context"
"errors"
"fmt"
"github.com/astaxie/beego/logs"
"github.com/astaxie/beego/orm"
"dongfeng-pay/service/common"
"dongfeng-pay/service/message_queue"
"dongfeng-pay/service/models"
"dongfeng-pay/service/utils"
"github.com/beego/beego/v2/client/orm"
"github.com/beego/beego/v2/core/logs"
url2 "net/url"
"strconv"
)
@@ -26,452 +28,400 @@ type PaySolveController struct {
//处理支付成功的加款等各项操作
func (c *PaySolveController) SolvePaySuccess(bankOrderId string, factAmount float64, trxNo string) bool {
o := orm.NewOrm()
o.Begin()
defer func(interface{}) {
if r := recover(); r != nil {
o.Rollback()
logs.Error("SolvePaySuccess fail， call rollback")
err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
var orderInfo models.OrderInfo
if err := txOrm.Raw("select * from order_info where bank_order_id = ? for update", bankOrderId).QueryRow(&orderInfo); err != nil || orderInfo.BankOrderId == "" {
logs.Error("不存在该订单，或者select for update出错")
return err
}
}(o)
var orderInfo models.OrderInfo
if err := o.Raw("select * from order_info where bank_order_id = ? for update", bankOrderId).QueryRow(&orderInfo); err != nil || orderInfo.BankOrderId == "" {
o.Rollback()
logs.Error("不存在该订单，或者select for update出错")
return false
}
if orderInfo.Status != "wait" {
logs.Error("该订单已经处理，订单号=", bankOrderId)
return errors.New(fmt.Sprintf("该订单已经处理，订单号= %s", bankOrderId))
}
if orderInfo.Status != "wait" {
o.Rollback()
logs.Error("该订单已经处理，订单号=", bankOrderId)
return false
}
if factAmount <= common.ZERO {
factAmount = orderInfo.OrderAmount
}
if factAmount <= common.ZERO {
factAmount = orderInfo.OrderAmount
}
var orderProfitInfo models.OrderProfitInfo
if err := txOrm.Raw("select * from order_profit_info where bank_order_id = ? for update", bankOrderId).QueryRow(&orderProfitInfo); err != nil || orderProfitInfo.BankOrderId == "" {
logs.Error("select order_profit_info for update fail: ", err)
return err
}
var orderProfitInfo models.OrderProfitInfo
if err := o.Raw("select * from order_profit_info where bank_order_id = ? for update", bankOrderId).QueryRow(&orderProfitInfo); err != nil || orderProfitInfo.BankOrderId == "" {
logs.Error("select order_profit_info for update fail: ", err)
o.Rollback()
return false
}
if orderProfitInfo.BankOrderId == "" {
logs.Error("solve pay success, get orderProfit fail, bankOrderId = ", bankOrderId)
return errors.New(fmt.Sprintf("solve pay success, get orderProfit fail, bankOrderId = %s", bankOrderId))
}
if orderProfitInfo.BankOrderId == "" {
logs.Error("solve pay success, get orderProfit fail, bankOrderId = ", bankOrderId)
o.Rollback()
return false
}
comp := c.CompareOrderAndFactAmount(factAmount, orderInfo)
//如果实际支付金额比订单金额大或者小，那么重新按照实际金额金额利润计算
if comp != 0 {
orderProfitInfo.FactAmount = factAmount
orderProfitInfo.SupplierProfit = orderInfo.FactAmount * orderProfitInfo.SupplierRate
orderProfitInfo.PlatformProfit = orderInfo.FactAmount * orderProfitInfo.PlatformRate
orderProfitInfo.AgentProfit = orderInfo.FactAmount * orderProfitInfo.AgentRate
orderProfitInfo.AllProfit = orderProfitInfo.SupplierProfit + orderProfitInfo.PlatformProfit + orderProfitInfo.AgentProfit
orderProfitInfo.UserInAmount = orderProfitInfo.FactAmount - orderProfitInfo.AllProfit
orderProfitInfo.UpdateTime = utils.GetBasicDateTime()
comp := c.CompareOrderAndFactAmount(factAmount, orderInfo)
//如果实际支付金额比订单金额大或者小，那么重新按照实际金额金额利润计算
if comp != 0 {
orderProfitInfo.FactAmount = factAmount
orderProfitInfo.SupplierProfit = orderInfo.FactAmount * orderProfitInfo.SupplierRate
orderProfitInfo.PlatformProfit = orderInfo.FactAmount * orderProfitInfo.PlatformRate
orderProfitInfo.AgentProfit = orderInfo.FactAmount * orderProfitInfo.AgentRate
orderProfitInfo.AllProfit = orderProfitInfo.SupplierProfit + orderProfitInfo.PlatformProfit + orderProfitInfo.AgentProfit
orderProfitInfo.UserInAmount = orderProfitInfo.FactAmount - orderProfitInfo.AllProfit
orderInfo.FactAmount = factAmount
//如果实际支付金额跟订单金额有出入，那么需要重新更新利润记录
if _, err := txOrm.Update(orderProfitInfo); err != nil {
logs.Info("solve pay success fail：", err)
return err
}
}
orderInfo.Status = common.SUCCESS
orderInfo.BankTransId = trxNo
orderInfo.UpdateTime = utils.GetBasicDateTime()
if _, err := txOrm.Update(&orderInfo); err != nil || orderInfo.BankOrderId == "" {
logs.Error(fmt.Sprintf("solve pay success, update order info fail: %s, bankOrderId = %s", err, bankOrderId))
return err
}
//插入一条待结算记录
settAmount := orderProfitInfo.FactAmount - orderProfitInfo.SupplierProfit - orderProfitInfo.PlatformProfit - orderProfitInfo.AgentProfit
if settAmount <= 0.00 {
logs.Error(fmt.Sprintf("订单id=%s，计算利润存在异常", bankOrderId))
return errors.New(fmt.Sprintf("订单id=%s，计算利润存在异常", bankOrderId))
}
orderSettleInfo := models.OrderSettleInfo{PayTypeCode: orderInfo.PayTypeCode, PayProductCode: orderInfo.PayProductCode, RoadUid: orderInfo.RoadUid,
PayProductName: orderInfo.PayProductName, PayTypeName: orderInfo.PayTypeName, MerchantUid: orderInfo.MerchantUid, MerchantOrderId: orderInfo.MerchantOrderId,
MerchantName: orderInfo.MerchantName, BankOrderId: bankOrderId, SettleAmount: settAmount, IsAllowSettle: common.YES,
IsCompleteSettle: common.NO, UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := txOrm.Insert(&orderSettleInfo); err != nil {
logs.Error(fmt.Sprintf("solve pay success，insert order settle info fail: %s, bankOrderId = %s", err, bankOrderId))
return err
}
//做账户的加款操作，最重要的一部
var accountInfo models.AccountInfo
if err := txOrm.Raw("select * from account_info where account_uid = ? for update", orderInfo.MerchantUid).QueryRow(&accountInfo); err != nil || accountInfo.AccountUid == "" {
logs.Error(fmt.Sprintf("solve pay success, raw account info fail: %s, bankOrderId = %s", err, bankOrderId))
return err
}
if _, err := txOrm.QueryTable(models.ACCOUNT_INFO).Filter("account_uid", orderInfo.MerchantUid).
Update((orm.Params{"balance": accountInfo.Balance + settAmount, "wait_amount": accountInfo.WaitAmount + settAmount})); err != nil {
logs.Error(fmt.Sprintf("solve pay success, update account info fail: %s, bankOrderId = %s", err, bankOrderId))
return err
}
//添加一条动账记录
accountHistory := models.AccountHistoryInfo{AccountUid: orderInfo.MerchantUid, AccountName: orderInfo.MerchantName,
Type: common.PLUS_AMOUNT, Amount: settAmount, Balance: accountInfo.Balance + settAmount,
UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := txOrm.Insert(&accountHistory); err != nil {
logs.Error(fmt.Sprintf("solve pay success，insert account history fail：%s, bankOrderId = %s", err, bankOrderId))
return err
}
//更新通道信息
roadInfo := models.GetRoadInfoByRoadUid(orderInfo.RoadUid)
roadInfo.UpdateTime = utils.GetBasicDateTime()
roadInfo.RequestSuccess += 1
roadInfo.TotalIncome += orderInfo.FactAmount
roadInfo.TodayIncome += orderInfo.FactAmount
roadInfo.TodayProfit += orderProfitInfo.PlatformProfit + orderProfitInfo.AgentProfit
roadInfo.TotalProfit += orderProfitInfo.PlatformProfit + orderProfitInfo.AgentProfit
roadInfo.UpdateTime = utils.GetBasicDateTime()
if _, err := txOrm.Update(&roadInfo); err != nil {
logs.Error(fmt.Sprintf("solve pay success, update road info fail: %s, bankOrderId = %s", err, bankOrderId))
return err
}
//更新订单利润表
orderProfitInfo.Status = common.SUCCESS
orderProfitInfo.UpdateTime = utils.GetBasicDateTime()
orderInfo.FactAmount = factAmount
//如果实际支付金额跟订单金额有出入，那么需要重新更新利润记录
if _, err := o.Update(orderProfitInfo); err != nil {
logs.Info("solve pay success fail：", err)
if _, err := txOrm.Update(&orderProfitInfo); err != nil {
logs.Error(fmt.Sprintf("solve pay success, update order profit info fail: %s, bankOrderId = %s", err, bankOrderId))
return err
}
}
orderInfo.Status = common.SUCCESS
orderInfo.BankTransId = trxNo
orderInfo.UpdateTime = utils.GetBasicDateTime()
if _, err := o.Update(&orderInfo); err != nil || orderInfo.BankOrderId == "" {
logs.Error(fmt.Sprintf("solve pay success, update order info fail: %s, bankOrderId = %s", err, bankOrderId))
o.Rollback()
return false
}
//插入一条待结算记录
settAmount := orderProfitInfo.FactAmount - orderProfitInfo.SupplierProfit - orderProfitInfo.PlatformProfit - orderProfitInfo.AgentProfit
if settAmount <= 0.00 {
logs.Error(fmt.Sprintf("订单id=%s，计算利润存在异常", bankOrderId))
o.Rollback()
return false
}
orderSettleInfo := models.OrderSettleInfo{PayTypeCode: orderInfo.PayTypeCode, PayProductCode: orderInfo.PayProductCode, RoadUid: orderInfo.RoadUid,
PayProductName: orderInfo.PayProductName, PayTypeName: orderInfo.PayTypeName, MerchantUid: orderInfo.MerchantUid, MerchantOrderId: orderInfo.MerchantOrderId,
MerchantName: orderInfo.MerchantName, BankOrderId: bankOrderId, SettleAmount: settAmount, IsAllowSettle: common.YES,
IsCompleteSettle: common.NO, UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := o.Insert(&orderSettleInfo); err != nil {
logs.Error(fmt.Sprintf("solve pay success，insert order settle info fail: %s, bankOrderId = %s", err, bankOrderId))
o.Rollback()
return false
}
//做账户的加款操作，最重要的一部
var accountInfo models.AccountInfo
if err := o.Raw("select * from account_info where account_uid = ? for update", orderInfo.MerchantUid).QueryRow(&accountInfo); err != nil || accountInfo.AccountUid == "" {
logs.Error(fmt.Sprintf("solve pay success, raw account info fail: %s, bankOrderId = %s", err, bankOrderId))
o.Rollback()
return false
}
if _, err := o.QueryTable(models.ACCOUNT_INFO).Filter("account_uid", orderInfo.MerchantUid).
Update(orm.Params{"balance": accountInfo.Balance + settAmount, "wait_amount": accountInfo.WaitAmount + settAmount}); err != nil {
logs.Error(fmt.Sprintf("solve pay success, update account info fail: %s, bankOrderId = %s", err, bankOrderId))
o.Rollback()
return false
}
//添加一条动账记录
accountHistory := models.AccountHistoryInfo{AccountUid: orderInfo.MerchantUid, AccountName: orderInfo.MerchantName,
Type: common.PLUS_AMOUNT, Amount: settAmount, Balance: accountInfo.Balance + settAmount,
UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := o.Insert(&accountHistory); err != nil {
logs.Error(fmt.Sprintf("solve pay success，insert account history fail：%s, bankOrderId = %s", err, bankOrderId))
o.Rollback()
return false
}
//更新通道信息
roadInfo := models.GetRoadInfoByRoadUid(orderInfo.RoadUid)
roadInfo.UpdateTime = utils.GetBasicDateTime()
roadInfo.RequestSuccess += 1
roadInfo.TotalIncome += orderInfo.FactAmount
roadInfo.TodayIncome += orderInfo.FactAmount
roadInfo.TodayProfit += orderProfitInfo.PlatformProfit + orderProfitInfo.AgentProfit
roadInfo.TotalProfit += orderProfitInfo.PlatformProfit + orderProfitInfo.AgentProfit
roadInfo.UpdateTime = utils.GetBasicDateTime()
if _, err := o.Update(&roadInfo); err != nil {
logs.Error(fmt.Sprintf("solve pay success, update road info fail: %s, bankOrderId = %s", err, bankOrderId))
o.Rollback()
return false
}
//更新订单利润表
orderProfitInfo.Status = common.SUCCESS
orderProfitInfo.UpdateTime = utils.GetBasicDateTime()
if _, err := o.Update(&orderProfitInfo); err != nil {
logs.Error(fmt.Sprintf("solve pay success, update order profit info fail: %s, bankOrderId = %s", err, bankOrderId))
o.Rollback()
return false
}
if err := o.Commit(); err != nil {
logs.Error(fmt.Sprintf("订单bankOrderId = %s，加款失败！", bankOrderId))
logs.Error("失败原因：", err)
return false
} else {
logs.Info("账户加款成功，并记录了账户历史！")
//如果处理成功，发送到消息队列，进行商户的回调操作
// 给下游发送回调通知
go c.CreateOrderNotifyInfo(orderInfo, common.SUCCESS)
return nil
})
if err != nil {
logs.Error("SolvePaySuccess失败：", err)
return false
}
logs.Info("SolvePaySuccess处理成功")
return true
}
//处理支付失败
func (c *PaySolveController) SolvePayFail(orderInfo models.OrderInfo, str string) bool {
o := orm.NewOrm()
o.Begin()
err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
defer func(interface{}) {
if r := recover(); r != nil {
o.Rollback()
logs.Error("SolvePaySuccess fail， call rollback")
var orderTmp models.OrderInfo
bankOrderId := orderInfo.BankOrderId
if err := txOrm.Raw("select * from order_info where bank_order_id = ?", bankOrderId).QueryRow(&orderTmp); err != nil || orderTmp.BankOrderId == "" {
return err
}
}(o)
var orderTmp models.OrderInfo
bankOrderId := orderInfo.BankOrderId
if err := o.Raw("select * from order_info where bank_order_id = ?", bankOrderId).QueryRow(&orderTmp); err != nil || orderTmp.BankOrderId == "" {
o.Rollback()
return false
}
if orderTmp.Status != "wait" {
return errors.New("订单已经处理，不要重复加款")
}
if _, err := txOrm.QueryTable(models.ORDER_INFO).Filter("bank_order_id", bankOrderId).Update(orm.Params{"status": str, "bank_trans_id": orderInfo.BankTransId}); err != nil {
logs.Error("更改订单状态失败：", err)
return err
}
if _, err := txOrm.QueryTable(models.ORDER_PROFIT_INFO).Filter("bank_order_id", bankOrderId).Update(orm.Params{"status": str, "bank_trans_id": orderInfo.BankTransId}); err != nil {
logs.Error("更改订单状态失败：", err)
return err
}
if orderTmp.Status != "wait" {
o.Rollback()
return false
}
_, err1 := o.QueryTable(models.ORDER_INFO).Filter("bank_order_id", bankOrderId).Update(orm.Params{"status": str, "bank_trans_id": orderInfo.BankTransId})
_, err2 := o.QueryTable(models.ORDER_PROFIT_INFO).Filter("bank_order_id", bankOrderId).Update(orm.Params{"status": str, "bank_trans_id": orderInfo.BankTransId})
if err1 != nil || err2 != nil {
logs.Error("SolvePayFail fail: ", err1, err2)
o.Rollback()
return false
} else {
o.Commit()
go c.CreateOrderNotifyInfo(orderInfo, common.FAIL)
return true
return nil
})
if err != nil {
logs.Error("SolvePayFail：", err)
return false
}
logs.Info("SolvePayFail成功")
return true
}
//处理订单冻结
func (c *PaySolveController) SolveOrderFreeze(bankOrderId string) bool {
o := orm.NewOrm()
o.Begin()
defer func(interface{}) {
if err := recover(); err != nil {
o.Rollback()
return
err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
var orderInfo models.OrderInfo
if err := txOrm.Raw("select * from order_info where bank_order_id = ? for update", bankOrderId).QueryRow(&orderInfo); err != nil || orderInfo.BankOrderId == "" {
logs.Error("solve order freeze 不存在这样的订单记录，bankOrderId = ", bankOrderId)
return err
}
}(o)
var orderInfo models.OrderInfo
if err := o.Raw("select * from order_info where bank_order_id = ? for update", bankOrderId).QueryRow(&orderInfo); err != nil || orderInfo.BankOrderId == "" {
logs.Error("solve order freeze 不存在这样的订单记录，bankOrderId = ", bankOrderId)
o.Rollback()
if orderInfo.Status != common.SUCCESS {
logs.Error("非成功订单不能进行冻结")
return errors.New("非成功订单不能进行冻结")
}
orderInfo.Freeze = common.YES
orderInfo.FreezeTime = utils.GetBasicDateTime()
orderInfo.UpdateTime = utils.GetBasicDateTime()
if _, err := txOrm.Update(&orderInfo); err != nil {
logs.Error("solve order freeze fail: ", err)
return err
}
//账户的冻结金额里面加入相应的金额
orderProfitInfo := models.GetOrderProfitByBankOrderId(bankOrderId)
var accountInfo models.AccountInfo
if err := txOrm.Raw("select * from account_info where account_uid = ? for update", orderInfo.MerchantUid).QueryRow(&accountInfo); err != nil || accountInfo.AccountUid == "" {
logs.Error(fmt.Sprintf("solve pay fail select acount fail：%s", err))
return err
}
accountInfo.UpdateTime = utils.GetBasicDateTime()
accountInfo.FreezeAmount = accountInfo.FreezeAmount + orderProfitInfo.UserInAmount
if _, err := txOrm.Update(&accountInfo); err != nil {
logs.Error("solve order freeze fail: ", err)
return err
}
//插入一条动账记录
accountHistoryInfo := models.AccountHistoryInfo{AccountName: accountInfo.AccountName, AccountUid: accountInfo.AccountUid,
Type: common.FREEZE_AMOUNT, Amount: orderProfitInfo.UserInAmount, Balance: accountInfo.Balance, UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := txOrm.Insert(&accountHistoryInfo); err != nil {
logs.Error("solve order freeze fail: ", err)
return err
}
return nil
})
if err != nil {
logs.Error("SolveOrderFreeze：", err)
return false
}
if orderInfo.Status != common.SUCCESS {
o.Rollback()
return false
}
logs.Info("SolveOrderFreeze")
orderInfo.Freeze = common.YES
orderInfo.FreezeTime = utils.GetBasicDateTime()
orderInfo.UpdateTime = utils.GetBasicDateTime()
if _, err := o.Update(&orderInfo); err != nil {
logs.Error("solve order freeze fail: ", err)
o.Rollback()
return false
}
//账户的冻结金额里面加入相应的金额
orderProfitInfo := models.GetOrderProfitByBankOrderId(bankOrderId)
var accountInfo models.AccountInfo
if err := o.Raw("select * from account_info where account_uid = ? for update", orderInfo.MerchantUid).QueryRow(&accountInfo); err != nil || accountInfo.AccountUid == "" {
logs.Error(fmt.Sprintf("solve pay fail select acount fail：%s", err))
o.Rollback()
return false
}
accountInfo.UpdateTime = utils.GetBasicDateTime()
accountInfo.FreezeAmount = accountInfo.FreezeAmount + orderProfitInfo.UserInAmount
if _, err := o.Update(&accountInfo); err != nil {
logs.Error("solve order freeze fail: ", err)
o.Rollback()
return false
}
//插入一条动账记录
accountHistoryInfo := models.AccountHistoryInfo{AccountName: accountInfo.AccountName, AccountUid: accountInfo.AccountUid,
Type: common.FREEZE_AMOUNT, Amount: orderProfitInfo.UserInAmount, Balance: accountInfo.Balance, UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := o.Insert(&accountHistoryInfo); err != nil {
logs.Error("solve order freeze fail: ", err)
o.Rollback()
return false
}
if err := o.Commit(); err != nil {
logs.Error("SolveOrderFreeze fail")
} else {
logs.Info("冻结处理成功")
}
return true
}
//订单解冻
func (c *PaySolveController) SolveOrderUnfreeze(bankOrderId string) bool {
o := orm.NewOrm()
o.Begin()
defer func(interface{}) {
if err := recover(); err != nil {
o.Rollback()
return
if err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
orderInfo := new(models.OrderInfo)
if err := txOrm.Raw("select * from order_info where bank_order_id = ? for update", bankOrderId).QueryRow(orderInfo); err != nil || orderInfo.BankOrderId == "" {
logs.Error("solve order unfreeze 不存在这样的订单记录，bankOrderId = ", bankOrderId)
return err
}
}(o)
orderInfo := new(models.OrderInfo)
if err := o.Raw("select * from order_info where bank_order_id = ? for update", bankOrderId).QueryRow(orderInfo); err != nil || orderInfo.BankOrderId == "" {
logs.Error("solve order unfreeze 不存在这样的订单记录，bankOrderId = ", bankOrderId)
orderInfo.Freeze = ""
orderInfo.Unfreeze = common.YES
orderInfo.UnfreezeTime = utils.GetBasicDateTime()
orderInfo.UpdateTime = utils.GetBasicDateTime()
if _, err := txOrm.Update(orderInfo); err != nil {
logs.Error("solve order unfreeze fail: ", err)
return err
}
orderProfitInfo := models.GetOrderProfitByBankOrderId(bankOrderId)
accountInfo := new(models.AccountInfo)
if err := txOrm.Raw("select * from account_info where account_uid = ? for update", orderInfo.MerchantUid).QueryRow(accountInfo); err != nil || accountInfo.AccountUid == "" {
logs.Error(fmt.Sprintf("unfreeze select account fail: %s", err))
return err
}
accountInfo.UpdateTime = utils.GetBasicDateTime()
accountInfo.FreezeAmount = accountInfo.FreezeAmount - orderProfitInfo.UserInAmount
if _, err := txOrm.Update(accountInfo); err != nil {
logs.Error("solve order unfreeze fail: ", err)
return err
}
accountHistoryInfo := models.AccountHistoryInfo{AccountUid: accountInfo.AccountUid, AccountName: accountInfo.AccountName, Type: common.UNFREEZE_AMOUNT,
Amount: orderProfitInfo.UserInAmount, Balance: accountInfo.Balance, UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := txOrm.Insert(&accountHistoryInfo); err != nil {
return err
}
return nil
}); err != nil {
logs.Error("SolveOrderUnfreeze失败：", err)
return false
}
orderInfo.Freeze = ""
orderInfo.Unfreeze = common.YES
orderInfo.UnfreezeTime = utils.GetBasicDateTime()
orderInfo.UpdateTime = utils.GetBasicDateTime()
if _, err := o.Update(orderInfo); err != nil {
logs.Error("solve order unfreeze fail: ", err)
o.Rollback()
return false
}
orderProfitInfo := models.GetOrderProfitByBankOrderId(bankOrderId)
accountInfo := new(models.AccountInfo)
if err := o.Raw("select * from account_info where account_uid = ? for update", orderInfo.MerchantUid).QueryRow(accountInfo); err != nil || accountInfo.AccountUid == "" {
logs.Error(fmt.Sprintf("unfreeze select account fail: %s", err))
o.Rollback()
return false
}
accountInfo.UpdateTime = utils.GetBasicDateTime()
accountInfo.FreezeAmount = accountInfo.FreezeAmount - orderProfitInfo.UserInAmount
if _, err := o.Update(accountInfo); err != nil {
logs.Error("solve order unfreeze fail: ", err)
o.Rollback()
return false
}
accountHistoryInfo := models.AccountHistoryInfo{AccountUid: accountInfo.AccountUid, AccountName: accountInfo.AccountName, Type: common.UNFREEZE_AMOUNT,
Amount: orderProfitInfo.UserInAmount, Balance: accountInfo.Balance, UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := o.Insert(&accountHistoryInfo); err != nil {
logs.Error("solve order unfreeze fail: ", err)
o.Rollback()
return false
}
if err := o.Commit(); err != nil {
logs.Error(fmt.Sprintf("unfreeze commit fail: %s", err))
return false
} else {
logs.Info("解冻成功")
}
return true
}
func (c *PaySolveController) SolveRefund(bankOrderId string) bool {
o := orm.NewOrm()
o.Begin()
if err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
defer func(interface{}) {
if err := recover(); err != nil {
o.Rollback()
return
orderInfo := new(models.OrderInfo)
if err := txOrm.Raw("select * from order_info where bank_order_id = ? for update", bankOrderId).QueryRow(orderInfo); err != nil || orderInfo.BankOrderId == "" {
logs.Error("solve refund 不存在这样的订单，bankOrderId = " + bankOrderId)
return err
}
}(o)
orderInfo := new(models.OrderInfo)
if err := o.Raw("select * from order_info where bank_order_id = ? for update", bankOrderId).QueryRow(orderInfo); err != nil || orderInfo.BankOrderId == "" {
logs.Error("solve refund 不存在这样的订单，bankOrderId = " + bankOrderId)
return false
}
orderInfo.UpdateTime = utils.GetBasicDateTime()
orderInfo.Refund = common.YES
orderInfo.RefundTime = utils.GetBasicDateTime()
orderInfo.UpdateTime = utils.GetBasicDateTime()
orderInfo.Refund = common.YES
orderInfo.RefundTime = utils.GetBasicDateTime()
orderProfitInfo := models.GetOrderProfitByBankOrderId(bankOrderId)
account := new(models.AccountInfo)
if err := o.Raw("select * from account_info where account_uid = ? for update", orderInfo.MerchantUid).QueryRow(account); err != nil || account.AccountUid == "" {
o.Rollback()
return false
}
account.UpdateTime = utils.GetBasicDateTime()
account.SettleAmount = account.SettleAmount - orderProfitInfo.UserInAmount
account.Balance = account.Balance - orderProfitInfo.UserInAmount
if orderInfo.Freeze == common.YES {
account.FreezeAmount = account.FreezeAmount - orderProfitInfo.UserInAmount
if account.FreezeAmount < 0 {
account.FreezeAmount = common.ZERO
orderProfitInfo := models.GetOrderProfitByBankOrderId(bankOrderId)
account := new(models.AccountInfo)
if err := txOrm.Raw("select * from account_info where account_uid = ? for update", orderInfo.MerchantUid).QueryRow(account); err != nil || account.AccountUid == "" {
return err
}
orderInfo.Freeze = ""
}
if _, err := o.Update(orderInfo); err != nil {
logs.Error("solve order refund update order info fail: ", err)
o.Rollback()
account.UpdateTime = utils.GetBasicDateTime()
account.SettleAmount = account.SettleAmount - orderProfitInfo.UserInAmount
account.Balance = account.Balance - orderProfitInfo.UserInAmount
if orderInfo.Freeze == common.YES {
account.FreezeAmount = account.FreezeAmount - orderProfitInfo.UserInAmount
if account.FreezeAmount < 0 {
account.FreezeAmount = common.ZERO
}
orderInfo.Freeze = ""
}
if _, err := txOrm.Update(orderInfo); err != nil {
logs.Error("solve order refund update order info fail: ", err)
return err
}
if _, err := txOrm.Update(account); err != nil {
logs.Error("solve order refund update account fail: ", err)
return err
}
accountHistoryInfo := models.AccountHistoryInfo{AccountName: account.AccountName, AccountUid: account.AccountUid,
Type: common.REFUND, Amount: orderProfitInfo.UserInAmount, Balance: account.Balance,
UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := txOrm.Insert(&accountHistoryInfo); err != nil {
logs.Error("solve order refund insert account history fail: ", err)
return err
}
return nil
}); err != nil {
logs.Error("SolveRefund 成功：", err)
return false
}
if _, err := o.Update(account); err != nil {
logs.Error("solve order refund update account fail: ", err)
o.Rollback()
return false
}
accountHistoryInfo := models.AccountHistoryInfo{AccountName: account.AccountName, AccountUid: account.AccountUid,
Type: common.REFUND, Amount: orderProfitInfo.UserInAmount, Balance: account.Balance,
UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := o.Insert(&accountHistoryInfo); err != nil {
logs.Error("solve order refund insert account history fail: ", err)
o.Rollback()
return false
}
if err := o.Commit(); err != nil {
logs.Error("退款处理失败，fail： ", err)
} else {
logs.Info("退款处理成功")
}
return true
}
func (c *PaySolveController) SolveOrderRoll(bankOrderId string) bool {
o := orm.NewOrm()
o.Begin()
if err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
defer func(interface{}) {
if err := recover(); err != nil {
o.Rollback()
return
orderInfo := new(models.OrderInfo)
if err := txOrm.Raw("select * from order_info where bank_order_id = ? for update", bankOrderId).QueryRow(orderInfo); err != nil {
logs.Error("solve order roll fail： ", err)
return err
}
}(o)
orderInfo := new(models.OrderInfo)
if orderInfo.Status != common.SUCCESS {
logs.Error("solve order roll 订单不存在或者订单状态不是success, bankOrderId=", bankOrderId)
return errors.New("solve order roll failed")
}
orderInfo.UpdateTime = utils.GetBasicDateTime()
if err := o.Raw("select * from order_info where bank_order_id = ? for update", bankOrderId).QueryRow(orderInfo); err != nil {
logs.Error("solve order roll fail： ", err)
o.Rollback()
orderProfitInfo := models.GetOrderProfitByBankOrderId(bankOrderId)
account := new(models.AccountInfo)
if err := txOrm.Raw("select * from account_info where account_uid = ? for update", orderInfo.MerchantUid).QueryRow(account); err != nil || account.AccountUid == "" {
return err
}
account.UpdateTime = utils.GetBasicDateTime()
if orderInfo.Refund == common.YES {
account.Balance = account.Balance + orderProfitInfo.UserInAmount
account.SettleAmount = account.SettleAmount + orderProfitInfo.UserInAmount
orderInfo.Refund = common.NO
}
if _, err := txOrm.Update(orderInfo); err != nil {
logs.Error("solve order roll fail update order info fail: ", err)
return err
}
if _, err := txOrm.Update(account); err != nil {
logs.Error("solve order roll update account fail: ", err)
return err
}
accountHistoryInfo := models.AccountHistoryInfo{AccountUid: account.AccountUid, AccountName: account.AccountName,
Type: common.PLUS_AMOUNT, Amount: orderProfitInfo.UserInAmount, Balance: account.Balance,
UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := txOrm.Insert(&accountHistoryInfo); err != nil {
logs.Error("solve order roll insert account history fail: ", err)
return err
}
return nil
}); err != nil {
logs.Error("SolveOrderRoll处理失败：", err)
return false
}
if orderInfo.Status != common.SUCCESS {
logs.Error("solve order roll 订单不存在或者订单状态不是success, bankOrderId=", bankOrderId)
o.Rollback()
return false
}
orderInfo.UpdateTime = utils.GetBasicDateTime()
orderProfitInfo := models.GetOrderProfitByBankOrderId(bankOrderId)
account := new(models.AccountInfo)
if err := o.Raw("select * from account_info where account_uid = ? for update", orderInfo.MerchantUid).QueryRow(account); err != nil || account.AccountUid == "" {
logs.Error("solve order roll get account is nil, accountUid = ", orderInfo.MerchantUid)
o.Rollback()
return false
}
account.UpdateTime = utils.GetBasicDateTime()
if orderInfo.Refund == common.YES {
account.Balance = account.Balance + orderProfitInfo.UserInAmount
account.SettleAmount = account.SettleAmount + orderProfitInfo.UserInAmount
orderInfo.Refund = common.NO
}
if _, err := o.Update(orderInfo); err != nil {
logs.Error("solve order roll fail update order info fail: ", err)
o.Rollback()
return false
}
if _, err := o.Update(account); err != nil {
logs.Error("solve order roll update account fail: ", err)
o.Rollback()
return false
}
accountHistoryInfo := models.AccountHistoryInfo{AccountUid: account.AccountUid, AccountName: account.AccountName,
Type: common.PLUS_AMOUNT, Amount: orderProfitInfo.UserInAmount, Balance: account.Balance,
UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := o.Insert(&accountHistoryInfo); err != nil {
logs.Error("solve order roll insert account history fail: ", err)
o.Rollback()
return false
}
if err := o.Commit(); err != nil {
logs.Error("处理订单回滚失败,fail: ", err)
} else {
logs.Info("处理订单回滚成功")
}
return true
}

417
boss/supplier/payfor_solve.go
View File

@@ -10,153 +10,127 @@
package controller
import (
"boss/common"
"boss/message_queue"
"boss/models"
"boss/utils"
"context"
"errors"
"fmt"
"github.com/astaxie/beego/logs"
"github.com/astaxie/beego/orm"
"dongfeng-pay/service/common"
"dongfeng-pay/service/message_queue"
"dongfeng-pay/service/models"
"dongfeng-pay/service/utils"
"github.com/beego/beego/v2/client/orm"
"github.com/beego/beego/v2/core/logs"
"strings"
)
func PayForFail(payFor models.PayforInfo) bool {
o := orm.NewOrm()
o.Begin()
if err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
defer func(interface{}) {
if err := recover(); err != nil {
logs.Error("pay for fail,rollback....")
o.Rollback()
var tmpForPay models.PayforInfo
if err := txOrm.Raw("select * from payfor_info where bank_order_id = ? for update", payFor.BankOrderId).QueryRow(&tmpForPay); err != nil || tmpForPay.PayforUid == "" {
logs.Error("solve pay fail select fail：", err)
return err
}
return
}(o)
var tmpForPay models.PayforInfo
if err := o.Raw("select * from payfor_info where bank_order_id = ? for update", payFor.BankOrderId).QueryRow(&tmpForPay); err != nil || tmpForPay.PayforUid == "" {
logs.Error("solve pay fail select fail：", err)
o.Rollback()
if tmpForPay.Status == common.PAYFOR_FAIL || tmpForPay.Status == common.PAYFOR_SUCCESS {
logs.Error(fmt.Sprintf("该代付订单uid=%s，状态已经是最终结果", payFor.PayforUid))
return errors.New("状态已经是最终结果")
}
//更新payfor记录的状态
tmpForPay.Status = common.PAYFOR_FAIL
tmpForPay.UpdateTime = utils.GetBasicDateTime()
if _, err := txOrm.Update(&tmpForPay); err != nil {
logs.Error("PayForFail update payfor_info fail: ", err)
return err
}
var account models.AccountInfo
if err := txOrm.Raw("select * from account_info where account_uid = ? for update", payFor.MerchantUid).QueryRow(&account); err != nil || account.AccountUid == "" {
logs.Error("payfor select account fail：", err)
return err
}
account.UpdateTime = utils.GetBasicDateTime()
if account.PayforAmount < (payFor.PayforAmount + payFor.PayforFee) {
logs.Error(fmt.Sprintf("商户uid=%s，账户中待代付金额小于代付记录的金额", payFor.MerchantUid))
return errors.New("账户中待代付金额小于代付记录的金额")
}
//将正在打款中的金额减去
account.PayforAmount = account.PayforAmount - payFor.PayforAmount - payFor.PayforFee
if _, err := txOrm.Update(&account); err != nil {
logs.Error("PayForFail update account fail: ", err)
return err
}
return nil
}); err != nil {
return false
}
if tmpForPay.Status == common.PAYFOR_FAIL || tmpForPay.Status == common.PAYFOR_SUCCESS {
logs.Error(fmt.Sprintf("该代付订单uid=%s，状态已经是最终结果", payFor.PayforUid))
o.Rollback()
return false
}
//更新payfor记录的状态
tmpForPay.Status = common.PAYFOR_FAIL
tmpForPay.UpdateTime = utils.GetBasicDateTime()
if _, err := o.Update(&tmpForPay); err != nil {
logs.Error("PayForFail update payfor_info fail: ", err)
o.Rollback()
return false
}
var account models.AccountInfo
if err := o.Raw("select * from account_info where account_uid = ? for update", payFor.MerchantUid).QueryRow(&account); err != nil || account.AccountUid == "" {
logs.Error("payfor select account fail：", err)
o.Rollback()
return false
}
account.UpdateTime = utils.GetBasicDateTime()
if account.PayforAmount < (payFor.PayforAmount + payFor.PayforFee) {
logs.Error(fmt.Sprintf("商户uid=%s，账户中待代付金额小于代付记录的金额", payFor.MerchantUid))
o.Rollback()
return false
}
//将正在打款中的金额减去
account.PayforAmount = account.PayforAmount - payFor.PayforAmount - payFor.PayforFee
if _, err := o.Update(&account); err != nil {
logs.Error("PayForFail update account fail: ", err)
o.Rollback()
return false
}
if err := o.Commit(); err != nil {
logs.Error("代付失败处理出错，fail：", err)
} else {
logs.Info("代付处理成功")
}
return true
}
func PayForSuccess(payFor models.PayforInfo) bool {
o := orm.NewOrm()
o.Begin()
defer func(interface{}) {
if err := recover(); err != nil {
logs.Error("pay for success,rollback....")
o.Rollback()
if err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
var tmpPayFor models.PayforInfo
if err := txOrm.Raw("select * from payfor_info where bank_order_id = ? for update", payFor.BankOrderId).QueryRow(&tmpPayFor); err != nil || tmpPayFor.PayforUid == "" {
logs.Error("payfor success select payfor fail：", err)
return err
}
if tmpPayFor.Status == common.PAYFOR_FAIL || tmpPayFor.Status == common.PAYFOR_SUCCESS {
logs.Error(fmt.Sprintf("该代付订单uid=%s，已经是最终结果，不需要处理", payFor.PayforUid))
return errors.New("已经是最终结果，不需要处理")
}
tmpPayFor.UpdateTime = utils.GetBasicDateTime()
tmpPayFor.Status = common.PAYFOR_SUCCESS
_, err := txOrm.Update(&tmpPayFor)
if err != nil {
logs.Error("PayForSuccess update payfor fail: ", err)
return err
}
return
}(o)
var tmpPayFor models.PayforInfo
if err := o.Raw("select * from payfor_info where bank_order_id = ? for update", payFor.BankOrderId).QueryRow(&tmpPayFor); err != nil || tmpPayFor.PayforUid == "" {
logs.Error("payfor success select payfor fail：", err)
o.Rollback()
return false
}
if tmpPayFor.Status == common.PAYFOR_FAIL || tmpPayFor.Status == common.PAYFOR_SUCCESS {
logs.Error(fmt.Sprintf("该代付订单uid=%s，已经是最终结果，不需要处理", payFor.PayforUid))
o.Rollback()
return false
}
tmpPayFor.UpdateTime = utils.GetBasicDateTime()
tmpPayFor.Status = common.PAYFOR_SUCCESS
_, err := o.Update(&tmpPayFor)
if err != nil {
logs.Error("PayForSuccess update payfor fail: ", err)
o.Rollback()
return false
}
var account models.AccountInfo
if err := txOrm.Raw("select * from account_info where account_uid = ? for update", payFor.MerchantUid).QueryRow(&account); err != nil || account.AccountUid == "" {
logs.Error("payfor success select account fail：", err)
return err
}
var account models.AccountInfo
if err := o.Raw("select * from account_info where account_uid = ? for update", payFor.MerchantUid).QueryRow(&account); err != nil || account.AccountUid == "" {
logs.Error("payfor success select account fail：", err)
o.Rollback()
account.UpdateTime = utils.GetBasicDateTime()
if account.PayforAmount < (payFor.PayforAmount + payFor.PayforFee) {
logs.Error(fmt.Sprintf("商户uid=%s，账户中待代付金额小于代付记录的金额", payFor.MerchantUid))
return errors.New("账户中待代付金额小于代付记录的金额")
}
//代付打款中的金额减去
account.PayforAmount = account.PayforAmount - payFor.PayforAmount - payFor.PayforFee
//减去余额，减去可用金额
account.Balance = account.Balance - payFor.PayforAmount - payFor.PayforFee
//已结算金额减去
account.SettleAmount = account.SettleAmount - payFor.PayforAmount - payFor.PayforFee
if _, err := txOrm.Update(&account); err != nil {
logs.Error("PayForSuccess udpate account fail：", err)
return err
}
//添加一条动账记录
accountHistory := models.AccountHistoryInfo{AccountUid: payFor.MerchantUid, AccountName: payFor.MerchantName,
Type: common.SUB_AMOUNT, Amount: payFor.PayforAmount + payFor.PayforFee, Balance: account.Balance,
UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := txOrm.Insert(&accountHistory); err != nil {
logs.Error("PayForSuccess insert account history fail: ", err)
return err
}
return nil
}); err != nil {
return false
}
account.UpdateTime = utils.GetBasicDateTime()
if account.PayforAmount < (payFor.PayforAmount + payFor.PayforFee) {
logs.Error(fmt.Sprintf("商户uid=%s，账户中待代付金额小于代付记录的金额", payFor.MerchantUid))
o.Rollback()
return false
}
//代付打款中的金额减去
account.PayforAmount = account.PayforAmount - payFor.PayforAmount - payFor.PayforFee
//减去余额，减去可用金额
account.Balance = account.Balance - payFor.PayforAmount - payFor.PayforFee
//已结算金额减去
account.SettleAmount = account.SettleAmount - payFor.PayforAmount - payFor.PayforFee
if _, err := o.Update(&account); err != nil {
logs.Error("PayForSuccess udpate account fail：", err)
return false
}
//添加一条动账记录
accountHistory := models.AccountHistoryInfo{AccountUid: payFor.MerchantUid, AccountName: payFor.MerchantName,
Type: common.SUB_AMOUNT, Amount: payFor.PayforAmount + payFor.PayforFee, Balance: account.Balance,
UpdateTime: utils.GetBasicDateTime(), CreateTime: utils.GetBasicDateTime()}
if _, err := o.Insert(&accountHistory); err != nil {
logs.Error("PayForSuccess insert account history fail: ", err)
o.Rollback()
return false
}
if err := o.Commit(); err != nil {
logs.Error("代付成功处理失败，fail：", err)
} else {
logs.Info("代付处理成功")
}
return true
}
@@ -189,8 +163,6 @@ func SolvePayForConfirm() {
}
func findPayForRoad(payFor models.PayforInfo, merchant models.MerchantInfo) bool {
o := orm.NewOrm()
//检查是否单独填写了每笔代付的手续费
if merchant.PayforFee > common.ZERO {
logs.Info(fmt.Sprintf("商户uid=%s，有单独的代付手续费。", merchant.MerchantUid))
@@ -218,39 +190,33 @@ func findPayForRoad(payFor models.PayforInfo, merchant models.MerchantInfo) bool
payFor.RoadName = roadInfoList[0].RoadName
}
o.Begin()
defer func(interface{}) {
if err := recover(); err != nil {
o.Rollback()
return
o := orm.NewOrm()
// 开启事务
if err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
var tmpPayFor models.PayforInfo
if err := txOrm.Raw("select * from payfor_info where payfor_uid = ? for update", payFor.PayforUid).QueryRow(&tmpPayFor); err != nil || tmpPayFor.PayforUid == "" {
logs.Error("find payfor road select payfor fail：", err)
return err
}
}(o)
var tmpPayFor models.PayforInfo
if err := o.Raw("select * from payfor_info where payfor_uid = ? for update", payFor.PayforUid).QueryRow(&tmpPayFor); err != nil || tmpPayFor.PayforUid == "" {
logs.Error("find payfor road select payfor fail：", err)
o.Rollback()
if tmpPayFor.Status != common.PAYFOR_COMFRIM {
logs.Notice(fmt.Sprintf("该代付记录uid=%s，已经被审核", payFor.PayforUid))
return errors.New("已经被审核")
}
tmpPayFor.UpdateTime = utils.GetBasicDateTime()
tmpPayFor.Status = common.PAYFOR_SOLVING
tmpPayFor.GiveType = common.PAYFOR_ROAD
if _, err := txOrm.Update(&tmpPayFor); err != nil {
logs.Error(fmt.Sprintf("该代付记录uid=%s，从审核更新为正在处理出错: %s", payFor.PayforUid, err))
return err
}
return nil
}); err != nil {
return false
}
if tmpPayFor.Status != common.PAYFOR_COMFRIM {
logs.Notice(fmt.Sprintf("该代付记录uid=%s，已经被审核", payFor.PayforUid))
return false
}
tmpPayFor.UpdateTime = utils.GetBasicDateTime()
tmpPayFor.Status = common.PAYFOR_SOLVING
tmpPayFor.GiveType = common.PAYFOR_ROAD
if _, err := o.Update(&tmpPayFor); err != nil {
logs.Error(fmt.Sprintf("该代付记录uid=%s，从审核更新为正在处理出错: %s", payFor.PayforUid, err))
o.Rollback()
return false
}
if err := o.Commit(); err != nil {
logs.Error("挑选代付通道失败，fail：", err)
} else {
logs.Info("挑选代付通道成功")
}
return true
}
@@ -279,102 +245,93 @@ func SolvePayFor() {
}
}
func solveSelf(payFor models.PayforInfo) {
func solveSelf(payFor models.PayforInfo) bool {
o := orm.NewOrm()
o.Begin()
defer func(interface{}) {
if err := recover(); err != nil {
o.Rollback()
if err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
var tmpPayFor models.PayforInfo
if err := txOrm.Raw("select * from payfor_info where payfor_uid = ? for update", payFor.PayforUid).QueryRow(&tmpPayFor); err != nil || tmpPayFor.PayforUid == "" {
logs.Error("solve self payfor fail：", err)
return errors.New("solve self payfor fail")
}
}(o)
var tmpPayFor models.PayforInfo
if err := o.Raw("select * from payfor_info where payfor_uid = ? for update", payFor.PayforUid).QueryRow(&tmpPayFor); err != nil || tmpPayFor.PayforUid == "" {
logs.Error("solve self payfor fail：", err)
o.Rollback()
return
}
if tmpPayFor.IsSend == common.YES {
return errors.New("代付已经发送")
}
if tmpPayFor.IsSend == common.YES {
o.Rollback()
return
}
tmpPayFor.UpdateTime = utils.GetBasicDateTime()
if payFor.RoadUid == "" {
tmpPayFor.Status = common.PAYFOR_FAIL
} else {
tmpPayFor.Status = common.PAYFOR_BANKING
tmpPayFor.RequestTime = utils.GetBasicDateTime()
tmpPayFor.IsSend = common.YES
}
if _, err := txOrm.Update(&tmpPayFor); err != nil {
return err
}
tmpPayFor.UpdateTime = utils.GetBasicDateTime()
if payFor.RoadUid == "" {
tmpPayFor.Status = common.PAYFOR_FAIL
} else {
tmpPayFor.Status = common.PAYFOR_BANKING
tmpPayFor.RequestTime = utils.GetBasicDateTime()
tmpPayFor.IsSend = common.YES
}
_, err := o.Update(&tmpPayFor)
if err != nil {
o.Rollback()
} else {
o.Commit()
RequestPayFor(payFor)
return nil
}); err != nil {
return false
}
return true
}
func SendPayFor(payFor models.PayforInfo) bool {
o := orm.NewOrm()
o.Begin()
defer func(interface{}) {
if err := recover(); err != nil {
o.Rollback()
return
if err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
var tmpPayFor models.PayforInfo
if err := txOrm.Raw("select * from payfor_info where payfor_uid = ? for update", payFor.PayforUid).QueryRow(&tmpPayFor); err != nil || tmpPayFor.PayforUid == "" {
logs.Error("send payfor select payfor fail: ", err)
return err
}
}(o)
var tmpPayFor models.PayforInfo
if err := o.Raw("select * from payfor_info where payfor_uid = ? for update", payFor.PayforUid).QueryRow(&tmpPayFor); err != nil || tmpPayFor.PayforUid == "" {
logs.Error("send payfor select payfor fail: ", err)
o.Rollback()
return false
}
var account models.AccountInfo
if err := txOrm.Raw("select * from account_info where account_uid = ? for update", payFor.MerchantUid).QueryRow(&account); err != nil || account.AccountUid == "" {
logs.Error("send payfor select account fail：", err)
return err
}
var account models.AccountInfo
if err := o.Raw("select * from account_info where account_uid = ? for update", payFor.MerchantUid).QueryRow(&account); err != nil || account.AccountUid == "" {
logs.Error("send payfor select account fail：", err)
o.Rollback()
return false
}
//支付金额不足，将直接判定为失败，不往下面邹逻辑了
if account.SettleAmount-account.PayforAmount < tmpPayFor.PayforAmount+tmpPayFor.PayforFee {
tmpPayFor.Status = common.PAYFOR_FAIL
tmpPayFor.UpdateTime = utils.GetBasicDateTime()
//支付金额不足，将直接判定为失败，不往下面邹逻辑了
if account.SettleAmount-account.PayforAmount < tmpPayFor.PayforAmount+tmpPayFor.PayforFee {
tmpPayFor.Status = common.PAYFOR_FAIL
if _, err := txOrm.Update(&tmpPayFor); err != nil {
return err
} else {
return nil
}
}
account.UpdateTime = utils.GetBasicDateTime()
account.PayforAmount = account.PayforAmount + payFor.PayforAmount + payFor.PayforFee
if _, err := txOrm.Update(&account); err != nil {
logs.Error(fmt.Sprintf("商户uid=%s，在发送代付给上游的处理中，更新账户表出错, err: %s", payFor.MerchantUid, err))
return err
}
tmpPayFor.IsSend = common.YES
tmpPayFor.Status = common.PAYFOR_BANKING //变为银行处理中
tmpPayFor.RequestTime = utils.GetBasicDateTime()
tmpPayFor.UpdateTime = utils.GetBasicDateTime()
o.Update(&tmpPayFor)
o.Commit()
return false
}
account.UpdateTime = utils.GetBasicDateTime()
account.PayforAmount = account.PayforAmount + payFor.PayforAmount + payFor.PayforFee
if _, err := txOrm.Update(&tmpPayFor); err != nil {
logs.Error(fmt.Sprintf("商户uid=%s，在发送代付给上游的处理中，更代付列表出错， err：%s", payFor.MerchantUid, err))
return err
}
_, err := o.Update(&account)
if err != nil {
logs.Error(fmt.Sprintf("商户uid=%s，在发送代付给上游的处理中，更新账户表出错, err: %s", payFor.MerchantUid, err))
o.Rollback()
return false
}
tmpPayFor.IsSend = common.YES
tmpPayFor.Status = common.PAYFOR_BANKING //变为银行处理中
tmpPayFor.RequestTime = utils.GetBasicDateTime()
tmpPayFor.UpdateTime = utils.GetBasicDateTime()
_, err = o.Update(&tmpPayFor)
if err != nil {
logs.Error(fmt.Sprintf("商户uid=%s，在发送代付给上游的处理中，更代付列表出错， err：%s", payFor.MerchantUid, err))
o.Rollback()
return false
} else {
o.Commit()
RequestPayFor(payFor)
return nil
}); err != nil {
return false
}
return true
}

2
boss/supplier/supplier_interface.go
View File

@@ -10,7 +10,7 @@
package controller
import (
"dongfeng-pay/service/models"
"boss/models"
)
//定义扫码支付的返回值

2
boss/supplier/weixin.go
View File

@@ -10,7 +10,7 @@
package controller
import (
"dongfeng-pay/service/models"
"boss/models"
)
type WeiXinImpl struct {