639 lines
21 KiB
Go
639 lines
21 KiB
Go
package q_bida
|
||
|
||
import (
|
||
"errors"
|
||
"fmt"
|
||
bida "git.rosy.net.cn/baseapi/platformapi/q_bida"
|
||
"git.rosy.net.cn/baseapi/platformapi/tonglianpayapi"
|
||
"git.rosy.net.cn/baseapi/utils"
|
||
"git.rosy.net.cn/jx-callback/business/jxutils"
|
||
"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
|
||
"git.rosy.net.cn/jx-callback/business/model"
|
||
"git.rosy.net.cn/jx-callback/business/model/dao"
|
||
"git.rosy.net.cn/jx-callback/globals"
|
||
"git.rosy.net.cn/jx-callback/globals/api"
|
||
"time"
|
||
)
|
||
|
||
// ExpressCompany 快递公司
|
||
var ExpressCompany = []int{
|
||
bida.JDExpressInt,
|
||
bida.DBExpressInt,
|
||
bida.STExpressInt,
|
||
bida.YTExpressInt,
|
||
bida.DBAirCraftExpressInt,
|
||
bida.SFExpressInt,
|
||
bida.JDDWExpressInt,
|
||
bida.JDStoreExpressInt,
|
||
bida.ZTExpressInt,
|
||
bida.JSTExpressInt,
|
||
bida.YDExpressInt,
|
||
}
|
||
|
||
// LogisticsCompany 物流
|
||
var LogisticsCompany = []int{
|
||
bida.SXJDExpressInt,
|
||
bida.SFKYExpressInt,
|
||
bida.ZTKYExpressInt,
|
||
bida.KYExpressInt,
|
||
bida.JDLogisticsExpressInt,
|
||
bida.DBLogisticsExpressInt,
|
||
}
|
||
|
||
const MarkupAmount = 50 // 每公斤加价五毛
|
||
|
||
// QueryExpressPrice 查询配送价格,获取所有快递价格
|
||
func QueryExpressPrice(param *bida.GetExpressPriceReq) (map[string]*bida.GetExpressPriceRes, error) {
|
||
if param.Weight <= 0 {
|
||
return nil, errors.New("物品重量必须大于0")
|
||
}
|
||
|
||
// 给快递默认值
|
||
result := make(map[string]*bida.GetExpressPriceRes, 0)
|
||
if param.Type == 0 {
|
||
// 渠道费每公斤加价五毛
|
||
switch param.ChannelType {
|
||
case 1: // 快递
|
||
for i := 0; i < len(ExpressCompany); i++ {
|
||
param.Type = ExpressCompany[i]
|
||
fee, err := api.QBiDaAPI.GetExpressPrice(param)
|
||
if err != nil {
|
||
continue
|
||
}
|
||
if fee.Code != 0 {
|
||
result[fmt.Sprintf("%d", ExpressCompany[i])] = fee
|
||
continue
|
||
}
|
||
if fee.Data.ChannelFee != 0 {
|
||
addFee := int(fee.Data.ChannelFee*100) + param.Weight*MarkupAmount
|
||
fee.Data.ChannelFee = utils.Int2Float64(addFee) / float64(100)
|
||
result[fmt.Sprintf("%d", ExpressCompany[i])] = fee
|
||
}
|
||
}
|
||
case 2: // 物流
|
||
for i := 0; i < len(LogisticsCompany); i++ {
|
||
param.Type = LogisticsCompany[i]
|
||
fee, err := api.QBiDaAPI.GetExpressPrice(param)
|
||
if err != nil {
|
||
continue
|
||
}
|
||
if fee.Code != 0 {
|
||
result[fmt.Sprintf("%d", LogisticsCompany[i])] = fee
|
||
continue
|
||
}
|
||
if fee.Data.ChannelFee != 0 {
|
||
addFee := int(fee.Data.ChannelFee*100) + param.Weight*MarkupAmount
|
||
fee.Data.ChannelFee = utils.Int2Float64(addFee) / float64(100)
|
||
result[fmt.Sprintf("%d", LogisticsCompany[i])] = fee
|
||
}
|
||
}
|
||
}
|
||
|
||
} else {
|
||
fee, err := api.QBiDaAPI.GetExpressPrice(param)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if fee.Code != 0 {
|
||
return nil, errors.New(fee.Msg)
|
||
}
|
||
|
||
if fee.Data.ChannelFee != 0 {
|
||
addFee := int(fee.Data.ChannelFee*100) + param.Weight*MarkupAmount
|
||
fee.Data.ChannelFee = utils.Int2Float64(addFee) / float64(100)
|
||
result[fmt.Sprintf("%d", param.Type)] = fee
|
||
}
|
||
}
|
||
|
||
return result, nil
|
||
}
|
||
|
||
// CreateWayOrder 创建快递订单
|
||
func CreateWayOrder(ctx *jxcontext.Context, param *model.MakeOrderParamReq, userId string) (*model.UserVendorOrder, error) {
|
||
// 检查价格
|
||
reallyCannelleFee := param.ChannelFee
|
||
if err := checkWayFeeIsTrue(param); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 第三方数据创建成功，则创建本地数据
|
||
random := RandomString(5)
|
||
vendorOrder := &model.UserVendorOrder{
|
||
UserId: userId,
|
||
LocalWayBill: utils.Int64ToStr(time.Now().Unix()) + userId[:4] + random, // 当前时间秒数加用户ID前四位
|
||
OtherWayBill: utils.Int64ToStr(time.Now().Unix()) + userId[:4] + random,
|
||
PromiseTimeType: param.PromiseTimeType,
|
||
DeliveryType: param.DeliveryType,
|
||
Goods: param.Goods,
|
||
GuaranteeValueAmount: param.GuaranteeValueAmount,
|
||
Weight: param.Weight,
|
||
Length: param.Length,
|
||
Height: param.Height,
|
||
Width: param.Width,
|
||
OrderSendTime: param.OrderSendTime,
|
||
PackageNum: param.PackageNum,
|
||
ReceiveAddressID: param.ReceiveAddressId,
|
||
Remark: param.Remark,
|
||
SenderAddressID: param.SenderAddressId,
|
||
ThirdPlatform: param.ThirdPlatform,
|
||
Type: param.Type,
|
||
ReallyChannelFee: reallyCannelleFee,
|
||
ChannelFee: param.ChannelFee,
|
||
ServiceCharge: param.ServiceCharge,
|
||
GuarantFee: param.GuarantFee,
|
||
OriginalFee: param.OriginalFee,
|
||
Bulk: param.Bulk,
|
||
Increment: param.Increment,
|
||
ChannelType: param.ChannelType,
|
||
OrderStatus: model.OrderStatusWaitPay, // 创建待支付
|
||
Img: param.Images,
|
||
IsForward: model.YES, //
|
||
}
|
||
|
||
// 事务创建待支付运单，和待支付order
|
||
db := dao.GetDB()
|
||
tdb, _ := dao.Begin(db)
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
dao.Rollback(db, tdb)
|
||
panic(r)
|
||
}
|
||
}()
|
||
|
||
// 添加运单表
|
||
dao.WrapAddIDCULDEntity(vendorOrder, ctx.GetUserName())
|
||
if err := dao.CreateEntityTx(tdb, vendorOrder); err != nil {
|
||
dao.Rollback(db, tdb)
|
||
return nil, err
|
||
}
|
||
// 添加待支付订单表
|
||
orderPayStatus := &model.Order{
|
||
OrderID: vendorOrder.LocalWayBill,
|
||
UserID: vendorOrder.UserId,
|
||
Type: model.OrderTypePay,
|
||
OrderType: model.PayType4Express,
|
||
Way: "",
|
||
Status: model.OrderStatusWaitPay, // 待支付状态
|
||
PayPrice: int(vendorOrder.ChannelFee * 100),
|
||
TransactionID: "",
|
||
PayFinishedAt: time.Time{},
|
||
PrepayID: "",
|
||
OriginalData: "",
|
||
Comment: "",
|
||
Lng: 0,
|
||
Lat: 0,
|
||
CityCode: 0,
|
||
DistrictCode: 0,
|
||
Address: "",
|
||
PayMethod: 0,
|
||
}
|
||
if err := dao.CreateEntityTx(tdb, orderPayStatus); err != nil {
|
||
dao.Rollback(db, tdb)
|
||
return nil, err
|
||
}
|
||
dao.Commit(db, tdb)
|
||
|
||
return vendorOrder, nil
|
||
}
|
||
|
||
// CancelWayOrder 取消运单 todo
|
||
func CancelWayOrder(ctx *jxcontext.Context, userId string, param *bida.CancelOrderReq) error {
|
||
// 查询订单
|
||
order := &model.UserVendorOrder{UserId: userId, LocalWayBill: param.OrderNo}
|
||
if err := dao.GetEntity(dao.GetDB(), order, "UserId", "LocalWayBill"); err != nil {
|
||
return err
|
||
}
|
||
|
||
if time.Now().Unix()-order.CreatedAt.Unix() <= 30 {
|
||
return errors.New("支付成功后，超过30s才能取消")
|
||
}
|
||
|
||
// 待支付或者支付失败
|
||
switch order.OrderStatus {
|
||
case model.OrderStatusFailPay, model.OrderStatusWaitPay: // 待支付订单，或者支付失败订单，不需要退款，取消本地订单以及order记录表
|
||
db := dao.GetDB()
|
||
tx, _ := dao.Begin(db)
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
panic(r)
|
||
}
|
||
}()
|
||
|
||
order.OrderStatus = model.OrderStatusCancel
|
||
if _, err := dao.UpdateEntityTx(tx, order, "OrderStatus"); err != nil {
|
||
tx.Rollback()
|
||
return err
|
||
}
|
||
if _, err := dao.UpdateEntityTx(tx, &model.Order{OrderID: param.OrderNo, UserID: userId, Status: model.OrderStatusCancel}, "Status"); err != nil {
|
||
tx.Rollback()
|
||
return err
|
||
}
|
||
tx.Commit()
|
||
case model.OrderStatusSuccessPay, model.OrderStatusWaitPickup: // 支付成功，取消三方订单，本地转取消状态，，原路退款
|
||
// 发起QBiDa取消，过去取消通过，则取消本地！不通过，则不予取消!
|
||
cancelParma := &bida.CancelOrderReq{
|
||
Genre: param.Genre,
|
||
OrderNo: order.OtherWayBill,
|
||
Type: param.Type,
|
||
}
|
||
if err := api.QBiDaAPI.CancelOrder(cancelParma); err != nil {
|
||
return err
|
||
}
|
||
// 暂时考虑余额支付渠道，加载order表判断支付渠道方式
|
||
orderWay := &model.Order{OrderID: param.OrderNo, UserID: userId}
|
||
if err := dao.GetEntity(dao.GetDB(), orderWay, "OrderID", "UserID"); err != nil {
|
||
|
||
return err
|
||
}
|
||
|
||
if orderWay.PayMethod == 1 { // 余额支付
|
||
// 支付方式为余额支付，则需要修改order/userVendorOrder，修改订单状态，给用户账户价钱，生成一个价钱数据
|
||
} else if orderWay.PayMethod == 2 { // 微信支付
|
||
// 微信支付原路退款，发起退款申请
|
||
_, err := RefundOrderByTL(ctx, orderWay, order, order.OtherWayBill, int(order.ChannelFee*100), "申请退款")
|
||
return err
|
||
}
|
||
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// QueryOrderDetail 获取订单详细信息
|
||
func QueryOrderDetail(typeCode int, orderNo string) (*bida.OrderDetail, error) {
|
||
detail, err := api.QBiDaAPI.GetOrderDetail(&bida.GetOrderDetailReq{
|
||
Type: typeCode,
|
||
OrderNo: orderNo,
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 本地查询获取真是支付快递费用
|
||
sql := `SELECT * FROM user_vendor_order a WHERE a.other_way_bill = ? and a.type = ? `
|
||
data := &model.UserVendorOrder{}
|
||
param := []interface{}{orderNo, typeCode}
|
||
if err := dao.GetRow(dao.GetDB(), data, sql, param); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
addFee := int(detail.PayFee*100) + detail.Weight*MarkupAmount
|
||
detail.PayFee = utils.Int2Float64(addFee) / float64(100)
|
||
detail.Images = data.Img
|
||
return detail, nil
|
||
}
|
||
|
||
// QueryUserOrderList 查询用户订单列表
|
||
func QueryUserOrderList(userId string, expressType, orderStatus int, pageNum, pageSize int, orderNo string) ([]*model.UserOrderList, int, error) {
|
||
sql := `
|
||
SELECT SQL_CALC_FOUND_ROWS a.type,a.other_way_bill,a.local_way_bill,a.user_id,a.receive_address_id,a.sender_address_id,
|
||
a.created_at,a.order_status,a.channel_fee,add1.consignee_name send_user_name,add2.consignee_name receive_user_name,
|
||
district.name sender_address,city.name receive_address
|
||
FROM user_vendor_order a
|
||
LEFT JOIN user_delivery_address add1 ON a.sender_address_id = add1.id
|
||
LEFT JOIN user_delivery_address add2 ON a.receive_address_id = add2.id
|
||
LEFT JOIN place district ON district.code = add1.city_code
|
||
LEFT JOIN place city ON city.code = add2.city_code
|
||
WHERE a.deleted_at = ? AND a.user_id = ?
|
||
`
|
||
param := make([]interface{}, 0, 0)
|
||
param = append(param, utils.DefaultTimeValue)
|
||
param = append(param, userId)
|
||
if orderNo != "" {
|
||
sql = sql + `AND a.other_way_bill = ? OR a.local_way_bill = ? `
|
||
param = append(param, orderNo, orderNo)
|
||
}
|
||
if expressType != 0 {
|
||
sql = sql + ` AND a.type = ? `
|
||
param = append(param, expressType)
|
||
}
|
||
if orderStatus != 0 {
|
||
sql = sql + ` AND a.order_status = ? `
|
||
param = append(param, orderStatus)
|
||
}
|
||
|
||
// 获取数据条数
|
||
sql = sql + ` ORDER BY a.created_at DESC LIMIT ? OFFSET ? `
|
||
pageSize = jxutils.FormalizePageSize(pageSize)
|
||
param = append(param, pageSize, (pageNum-1)*pageSize)
|
||
|
||
// 获取数据
|
||
var result []*model.UserOrderList
|
||
db := dao.GetDB()
|
||
tx, _ := dao.Begin(db)
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
panic(r)
|
||
}
|
||
}()
|
||
|
||
if err := dao.GetRowsTx(tx, &result, sql, param...); err != nil {
|
||
dao.Rollback(db, tx)
|
||
return nil, 0, err
|
||
}
|
||
count := dao.GetLastTotalRowCountTx(tx)
|
||
dao.Commit(db, tx)
|
||
|
||
return result, count, nil
|
||
}
|
||
|
||
// CreateOrder2QBiDa 订单回调成功，且为运费支付时使用该接口
|
||
func CreateOrder2QBiDa(order *model.UserVendorOrder, orderId string) error {
|
||
//// 加载订单
|
||
//order := &model.UserVendorOrder{}
|
||
//sql := `SELECT * FROM user_vendor_order WHERE local_way_bill = ? `
|
||
//if err := dao.GetRow(dao.GetDB(), order, sql, []interface{}{orderId}...); err != nil {
|
||
// return err
|
||
//}
|
||
//
|
||
//if order.OrderStatus != model.OrderStatusSuccessPay {
|
||
// globals.SugarLogger.Debug("Callback Success But Order Status Update Fail ....")
|
||
// return errors.New("Callback Success But Order Status Update Fail ")
|
||
//}
|
||
globals.SugarLogger.Debug("order==================", order)
|
||
globals.SugarLogger.Debug("order==================", order.LocalWayBill)
|
||
|
||
// 创建QBIDA订单
|
||
makeOrder := &bida.MakeOrderReq{
|
||
PromiseTimeType: order.PromiseTimeType,
|
||
DeliveryType: order.DeliveryType,
|
||
Goods: order.Goods,
|
||
GuaranteeValueAmount: order.GuaranteeValueAmount,
|
||
Weight: order.Weight,
|
||
Length: order.Length,
|
||
Height: order.Height,
|
||
Width: order.Width,
|
||
OrderSendTime: order.OrderSendTime,
|
||
PackageNum: order.PackageNum,
|
||
Remark: order.Remark,
|
||
ThirdPlatform: order.ThirdPlatform,
|
||
Type: order.Type,
|
||
Img: order.Img,
|
||
}
|
||
// 获取发货地址以及送货地址
|
||
// GetAddressDetail 获取配送地址详情
|
||
sendAddress, err := dao.GetAddressDetail(int(order.SenderAddressID))
|
||
if err != nil {
|
||
return err
|
||
}
|
||
makeOrder.SenderAddress = sendAddress.AutoAddress
|
||
makeOrder.SenderName = sendAddress.ConsigneeName
|
||
makeOrder.SenderPhone = sendAddress.ConsigneeMobile
|
||
receiveAddress, err := dao.GetAddressDetail(int(order.ReceiveAddressID))
|
||
if err != nil {
|
||
return err
|
||
}
|
||
makeOrder.ReceiveAddress = receiveAddress.AutoAddress
|
||
makeOrder.ReceiveName = receiveAddress.ConsigneeName
|
||
makeOrder.ReceivePhone = receiveAddress.ConsigneeMobile
|
||
otherId, err := createOtherOrder(makeOrder)
|
||
if err != nil {
|
||
order.ErrorMsg = err.Error()
|
||
globals.SugarLogger.Debug("err==========", err)
|
||
}
|
||
globals.SugarLogger.Debug("otherId==========", otherId)
|
||
order.OtherWayBill = otherId
|
||
order.OrderStatus = model.OrderStatusWaitPickup
|
||
order.UpdatedAt = time.Now()
|
||
if _, err = dao.UpdateEntity(dao.GetDB(), order, "OtherWayBill", "OrderStatus", "UpdatedAt", "ErrorMsg"); err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// RefundOrderByTL 发起取消订单
|
||
func RefundOrderByTL(ctx *jxcontext.Context, orderPay *model.Order, order *model.UserVendorOrder, refundID string, refundFee int, refundDesc string) (orderPayRefund *model.OrderPayRefund, err error) {
|
||
result, err := api.TLpayAPI.PayRefund(&tonglianpayapi.PayRefundParam{
|
||
Trxamt: refundFee,
|
||
Reqsn: utils.GetUUID(),
|
||
Remark: refundDesc,
|
||
OldTrxID: orderPay.TransactionID,
|
||
})
|
||
if err == nil {
|
||
orderPayRefund = &model.OrderPayRefund{
|
||
RefundID: refundID,
|
||
VendorRefundID: result.TrxID,
|
||
VendorOrderID: orderPay.OrderID, //本地生成Id
|
||
Status: model.RefundStatusNo,
|
||
TransactionID: orderPay.TransactionID, // 支付事务id
|
||
RefundFee: refundFee,
|
||
RefundCreatedAt: time.Now(),
|
||
}
|
||
dao.WrapAddIDCULDEntity(orderPayRefund, ctx.GetUserName())
|
||
db := dao.GetDB()
|
||
if result.TrxStatus == tonglianpayapi.TrxStatusSuccess {
|
||
orderPayRefund.Status = model.RefundStatusYes
|
||
} else {
|
||
orderPayRefund.Status = model.RefundStatusFailed
|
||
}
|
||
orderPayRefund.OriginalData = utils.Format4Output(result, true)
|
||
|
||
tx, _ := dao.Begin(db)
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
panic(r)
|
||
}
|
||
}()
|
||
|
||
if err := dao.CreateEntityTx(tx, orderPayRefund); err != nil {
|
||
dao.Rollback(db, tx)
|
||
return nil, err
|
||
}
|
||
|
||
order.OrderStatus = model.OrderStatusCancel
|
||
if _, err := dao.UpdateEntityTx(tx, order); err != nil {
|
||
dao.Rollback(db, tx)
|
||
return nil, err
|
||
}
|
||
dao.Commit(db, tx)
|
||
|
||
}
|
||
return orderPayRefund, err
|
||
}
|
||
|
||
// ManagerGetOrderList 管理系统查询订单列表
|
||
func ManagerGetOrderList(param *model.OrderListReq) ([]*model.UserVendorOrder, int, error) {
|
||
sql := `SELECT SQL_CALC_FOUND_ROWS * FROM user_vendor_order uo WHERE uo.deleted_at = ? `
|
||
paramSql := make([]interface{}, 0, 0)
|
||
paramSql = append(paramSql, utils.DefaultTimeValue)
|
||
result := make([]*model.UserVendorOrder, 0, 0)
|
||
if param.OrderNo != "" {
|
||
sql += ` AND (uo.local_way_bill = ? OR uo.other_way_bill = ? )`
|
||
paramSql = append(paramSql, param.OrderNo, param.OrderNo)
|
||
if err := dao.GetRows(dao.GetDB(), &result, sql, paramSql...); err != nil {
|
||
return nil, 0, err
|
||
}
|
||
return result, 0, nil
|
||
}
|
||
|
||
if param.StartTime.IsZero() && param.EndTime.IsZero() {
|
||
sql += ` AND uo.created_at >= ? AND ou.created_at <= ? `
|
||
paramSql = append(paramSql, param.StartTime, param.EndTime)
|
||
}
|
||
if param.ExpressType != 0 {
|
||
sql += ` AND uo.type = ? `
|
||
paramSql = append(paramSql, param.ExpressType)
|
||
}
|
||
if param.OrderStatus != 0 {
|
||
sql += ` AND uo.order_status = ? `
|
||
paramSql = append(paramSql, param.OrderStatus)
|
||
}
|
||
if param.PageNum == 0 {
|
||
param.PageNum = 1
|
||
}
|
||
if param.PageSize == 0 {
|
||
param.PageSize = 10
|
||
}
|
||
sql += ` ORDER BY uo.created_at DESC LIMIT ? OFFSET ? `
|
||
paramSql = append(paramSql, param.PageSize, (param.PageNum-1)*param.PageSize)
|
||
|
||
db := dao.GetDB()
|
||
txdb, _ := dao.Begin(db)
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
panic(r)
|
||
}
|
||
}()
|
||
|
||
if err := dao.GetRowsTx(txdb, &result, sql, paramSql...); err != nil {
|
||
dao.Rollback(db, txdb)
|
||
return nil, 0, err
|
||
}
|
||
count := dao.GetLastTotalRowCountTx(txdb)
|
||
dao.Commit(db, txdb)
|
||
return result, count, nil
|
||
}
|
||
|
||
// DeleteOrderByLocalId 删除订单
|
||
func DeleteOrderByLocalId(userId, localId string) (int64, error) {
|
||
sql := `SELECT * FROM user_vendor_order a WHERE 1=1 AND a.user_id = ? AND a.local_way_bill = ? `
|
||
paramSql := make([]interface{}, 0, 0)
|
||
paramSql = append(paramSql, userId, localId)
|
||
|
||
data := model.UserVendorOrder{}
|
||
if err := dao.GetRow(dao.GetDB(), &data, sql, paramSql...); err != nil {
|
||
return 0, err
|
||
}
|
||
if data.ID <= 0 {
|
||
return 0, errors.New("用户数据不存在")
|
||
}
|
||
// 待支付,支付失败,取消，可以删除
|
||
data.DeletedAt = time.Now()
|
||
if data.OrderStatus == 2 || data.OrderStatus == 3 || data.OrderStatus == 150 {
|
||
return dao.UpdateEntity(dao.GetDB(), &data, "DeletedAt")
|
||
}
|
||
|
||
// 支付成功保留15天，可以删除
|
||
if !data.CreatedAt.IsZero() && data.CreatedAt.AddDate(0, 0, 15).Unix() > time.Now().Unix() {
|
||
return dao.UpdateEntity(dao.GetDB(), &data, "DeletedAt")
|
||
}
|
||
return 0, errors.New("订单完成后保存15天，才可以删除")
|
||
}
|
||
|
||
// UpdateOrderStatus 查询所有支付成功的订单
|
||
func UpdateOrderStatus() {
|
||
globals.SugarLogger.Debug("每十分钟更新一下订单，定时任务")
|
||
// 查询状态值为【4-支付成功,10预下单11待取件12运输中17终止揽收】//2,3 15已签收16取消订单 完成订单
|
||
db := dao.GetDB()
|
||
sql := `SELECT * FROM user_vendor_order WHERE order_status IN (4,10,11,12,17) AND deleted_at = ?`
|
||
param := []interface{}{utils.DefaultTimeValue}
|
||
var data []*model.UserVendorOrder
|
||
if err := dao.GetRows(db, &data, sql, param...); err != nil {
|
||
globals.SugarLogger.Debug("Scheduled task Err = ", err)
|
||
return
|
||
}
|
||
|
||
for _, v := range data {
|
||
if v.LocalWayBill == v.OtherWayBill && v.OrderStatus == model.OrderStatusSuccessPay {
|
||
globals.SugarLogger.Debug("ERROR ", "第三方订单Id写入错误，")
|
||
continue
|
||
}
|
||
if v.OrderStatus == 2 || v.OrderStatus == 3 || v.OrderStatus == 15 || v.OrderStatus == 16 || v.OrderStatus == 115 {
|
||
continue
|
||
}
|
||
otherOrder, err := QueryOrderDetail(v.Type, v.OtherWayBill)
|
||
if err != nil {
|
||
globals.SugarLogger.Debug("Get Order Fail To QBiDa:", err)
|
||
continue
|
||
}
|
||
param := model.UserVendorOrder{ModelIDCULD: model.ModelIDCULD{ID: v.ModelIDCULD.ID}}
|
||
param.OrderStatus = otherOrder.Status + 10
|
||
if _, err := dao.UpdateEntity(db, ¶m, "OrderStatus"); err != nil {
|
||
globals.SugarLogger.Debug("Update Order Status Fail ", err)
|
||
continue
|
||
}
|
||
}
|
||
}
|
||
|
||
// TryAgainOrder 再来一单
|
||
func TryAgainOrder(ctx *jxcontext.Context, oldNo string) (*model.UserVendorOrder, error) {
|
||
sql := `SELECT * FROM user_vendor_order WHERE local_way_bill = ?`
|
||
var oldOrder *model.UserVendorOrder
|
||
if err := dao.GetRow(dao.GetDB(), &oldOrder, sql, []interface{}{oldNo}...); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 获取用户发货地址信息
|
||
sendAddress, countSend, err := dao.QueryUserDeliveryAddress(dao.GetDB(), oldOrder.SenderAddressID, nil, 0, 0, 10)
|
||
if err != nil || countSend != model.YES {
|
||
return nil, errors.New("查询错误/送货地址信息不正确")
|
||
}
|
||
// 获取用户收货
|
||
receiveAddress, receiveSend, err := dao.QueryUserDeliveryAddress(dao.GetDB(), oldOrder.ReceiveAddressID, nil, 0, 0, 10)
|
||
if err != nil || receiveSend != model.YES {
|
||
return nil, errors.New("查询错误/收货地址信息不正确")
|
||
}
|
||
|
||
// 查询配送费选择最低的
|
||
fee, err := QueryExpressPrice(&bida.GetExpressPriceReq{
|
||
Type: oldOrder.Type,
|
||
PromiseTimeType: oldOrder.PromiseTimeType,
|
||
DeliveryType: oldOrder.DeliveryType,
|
||
GoodsValue: oldOrder.GuarantFee,
|
||
ReceiveAddress: receiveAddress[0].AutoAddress,
|
||
SendAddress: sendAddress[0].AutoAddress,
|
||
Weight: oldOrder.Weight,
|
||
Length: oldOrder.Length,
|
||
Height: oldOrder.Height,
|
||
Width: oldOrder.Width,
|
||
SendPhone: sendAddress[0].ConsigneeMobile,
|
||
ChannelType: oldOrder.ChannelType,
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
param := &model.MakeOrderParamReq{
|
||
PromiseTimeType: oldOrder.PromiseTimeType,
|
||
DeliveryType: oldOrder.DeliveryType,
|
||
Goods: oldOrder.Goods,
|
||
GuaranteeValueAmount: oldOrder.GuaranteeValueAmount,
|
||
Weight: oldOrder.Weight,
|
||
Length: oldOrder.Length,
|
||
Height: oldOrder.Height,
|
||
Width: oldOrder.Width,
|
||
OrderSendTime: oldOrder.OrderSendTime,
|
||
PackageNum: oldOrder.PackageNum,
|
||
ReceiveAddressId: oldOrder.ReceiveAddressID,
|
||
ReceiveAddress: receiveAddress[0].AutoAddress,
|
||
ReceiveName: receiveAddress[0].ConsigneeName,
|
||
ReceivePhone: receiveAddress[0].ConsigneeMobile,
|
||
Remark: oldOrder.Remark,
|
||
SenderAddressId: oldOrder.SenderAddressID,
|
||
SenderAddress: sendAddress[0].AutoAddress,
|
||
SenderName: sendAddress[0].ConsigneeName,
|
||
SenderPhone: sendAddress[0].ConsigneeMobile,
|
||
ThirdPlatform: oldOrder.ThirdPlatform,
|
||
Type: oldOrder.Type,
|
||
ChannelType: oldOrder.ChannelType,
|
||
Images: oldOrder.Img,
|
||
ChannelFee: fee[fmt.Sprintf("%d", oldOrder.Type)].Data.ChannelFee,
|
||
Bulk: utils.Int2Float64(fee[fmt.Sprintf("%d", oldOrder.Type)].Data.Bulk),
|
||
ServiceCharge: fee[fmt.Sprintf("%d", oldOrder.Type)].Data.ServiceCharge,
|
||
GuarantFee: fee[fmt.Sprintf("%d", oldOrder.Type)].Data.GuarantFee,
|
||
OriginalFee: utils.Int2Float64(fee[fmt.Sprintf("%d", oldOrder.Type)].Data.OriginalFee),
|
||
Increment: fee[fmt.Sprintf("%d", oldOrder.Type)].Data.IncrementFee,
|
||
}
|
||
return CreateWayOrder(ctx, param, oldOrder.UserId)
|
||
}
|