liulei/jx-callback
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

shan

Browse Source
This commit is contained in:
苏尹岚
2020-10-14 13:47:11 +08:00
parent accb629e14
commit eb950f11bf
41 changed files with 3581 additions and 1809 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
business/partner/purchase/jx/act.go Normal file
View File

@@ -0,0 +1,11 @@
package jx
import (
"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
"git.rosy.net.cn/jx-callback/business/jxutils/tasksch"
"git.rosy.net.cn/jx-callback/business/model"
)
func (c *PurchaseHandler) SyncAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSkuList []*model.ActStoreSku2) (err error) {
return err
}

34
business/partner/purchase/jx/jx.go Normal file
View File

@@ -0,0 +1,34 @@
package jx
import (
"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/business/partner"
"git.rosy.net.cn/jx-callback/globals"
)
type PurchaseHandler struct {
partner.BasePurchasePlatform
}
var (
CurPurchaseHandler *PurchaseHandler
)
func init() {
globals.SugarLogger.Debug("init jx")
if true {
CurPurchaseHandler = new(PurchaseHandler)
// 不能注册京西
// partner.RegisterPurchasePlatform(CurPurchaseHandler)
partner.RegisterPurchaseOrderHandler(CurPurchaseHandler.GetVendorID(), CurPurchaseHandler)
}
}
func (c *PurchaseHandler) GetVendorID() int {
return model.VendorIDJX
}
func (p *PurchaseHandler) UploadImg(ctx *jxcontext.Context, vendorOrgCode, imgURL string, imgData []byte, imgName string, imgType int) (imgHint string, err error) {
return imgHint, err
}

740
business/partner/purchase/jx/localjx/order.go Normal file
View File

@@ -0,0 +1,740 @@
package localjx
import (
"fmt"
"math"
"regexp"
"time"
"git.rosy.net.cn/baseapi/platformapi/jdshopapi"
"git.rosy.net.cn/baseapi/platformapi/wxpayapi"
"git.rosy.net.cn/jx-callback/globals/api"
"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/business/partner"
)
const (
OrderCreateTypePre = 0 // 预创建
OrderCreateTypeNormal = 1 // 正常创建
PayWaitingTime = 10 * time.Minute // 等待支付的最长时间
DingShiDaMinTime = 1 * time.Hour
specialStoreID = 100274
specialFreightPrice = 1500
wxAppID = "wx4b5930c13f8b1170"
autoCancelOrderReason = "支付超时，系统自动取消！"
cancelMatterOrderReason = "失败重发！"
settleDiscountActRefundReason = "守价订单生成补退款"
splitMatterOrderMinWeight = 4500 //物料订单分包最少要4.5kg
jxwxfMatterEclpID = "EMG4418113943423" //京西五香粉物料编码
)
type JxSkuInfo struct {
SkuID int `json:"skuID"`
Count int `json:"count"`
Price int64 `json:"price,omitempty"` // 原价
SalePrice int64 `json:"salePrice,omitempty"` // 售卖价
Name string `json:"name"`
Weight int `json:"weight"`
GroupSign bool `json:"groupSign"`
DefendPrice int64 `json:"defendPrice"` //守价
}
type JxSkuInfo2 struct {
SkuID int `json:"skuID"`
Count int `json:"count"`
Price int64 `json:"price,omitempty"` // 原价
SalePrice int64 `json:"salePrice,omitempty"` // 售卖价
Name string `json:"name"`
Weight int `json:"weight"`
GroupSign bool `json:"groupSign"`
}
type JxSkuInfoList []*JxSkuInfo
func (l JxSkuInfoList) Len() int {
return len(l)
}
func (l JxSkuInfoList) Less(i, j int) bool {
if l[i].SkuID == l[j].SkuID {
return l[i].SalePrice < l[j].SalePrice
}
return l[i].SkuID < l[j].SkuID
}
func (l JxSkuInfoList) Swap(i, j int) {
l[i], l[j] = l[j], l[i]
}
type JxOrderInfo struct {
BuyerComment string `json:"buyerComment"`
StoreID int `json:"storeID"`
Skus []*JxSkuInfo `json:"skus"`
ExpectedDeliveredTimestamp int64 `json:"expectedDeliveredTimestamp"` // 预期送达时间
TotalPrice int64 `json:"totalPrice"` // 单位为分 订单总价
FreightPrice int64 `json:"freightPrice"` // 单位为分 订单配送费
OrderPrice int64 `json:"orderPrice"` // 单位为分 订单商品价格
ActualPayPrice int64 `json:"actualPayPrice"` // 单位为分 顾客实际支付
OrderID int64 `json:"orderID"`
StoreName string `json:"storeName"`
Weight int `json:"weight"`
FromStoreID int `json:"fromStoreID"`
EarningType int `json:"earningType"`
OrderType int `json:"orderType"`
IsBuyNowPrice int `json:"isBuyNowPrice"`
IsPriceDefend int `json:"isPriceDefend"`
OrderID2 string `json:"-"`
UserID string `json:"userID"`
}
type DeliveryTimeItem struct {
ViewTime string `json:"viewTime"`
UnixTime int64 `json:"unixTime"`
ViewShippingFee string `json:"viewShippingFee"`
}
type DeliveryDayTimeInfo struct {
Date string `json:"date"`
TimeList []*DeliveryTimeItem `json:"timeList"`
}
type MatterOrderStatus struct {
Time time.Time `json:"time"`
Status string `json:"status"`
Name string `json:"name"`
Sign int `sign`
}
var (
weekdayMap = map[int]string{
1: "一",
2: "二",
3: "三",
4: "四",
5: "五",
6: "六",
0: "日",
}
dayList = []string{"今天", "明天", "后天"}
bagMap = map[int]int{
6039382: 100,
6039383: 200,
6039384: 200,
6039387: 200,
6039390: 200,
}
regexpCnameAndCmobile = regexp.MustCompile(`配送员，(.*)，手机号，(.*)`)
regexpCnameAndCmobile2 = regexp.MustCompile(`（快递员：(.*)，联系电话：(.*)）`)
bagSkuMap = map[int]int{ //京西物料袋子skuid
6039382: 6039382,
6039383: 6039383,
6039384: 6039384,
6039387: 6039387,
6039390: 6039390,
}
)
func init() {
}
func buildDefendPriceOrder(ctx *jxcontext.Context, jxOrder *JxOrderInfo, addressID int64) (vendorOrderID string) {
var (
issue = 0
db = dao.GetDB()
)
issue = jxutils.GetDefendPriceIssue()
priceDefendOrder := &model.PriceDefendOrder{
VendorOrderID: utils.Int64ToStr(jxutils.GenOrderNo()),
StoreID: jxOrder.StoreID,
SkuID: jxOrder.Skus[0].SkuID,
AddressID: addressID,
Count: jxOrder.Skus[0].Count,
DefendPrice: jxOrder.Skus[0].DefendPrice,
OriginPrice: jxOrder.Skus[0].Price,
IsBuyNowPrice: jxOrder.IsBuyNowPrice,
Issue: issue,
IsSuccess: model.NO, //默认是不成功
IsPay: model.NO,
}
dao.WrapAddIDCULDEntity(priceDefendOrder, ctx.GetUserName())
priceDefendOrder.ActualPayPrice = int64(priceDefendOrder.Count)*jxOrder.Skus[0].Price + jxOrder.FreightPrice
dao.CreateEntity(db, priceDefendOrder)
return priceDefendOrder.VendorOrderID
}
// 买家取消（或申请取消）订单
func BuyerCancelOrder(ctx *jxcontext.Context, orderID int64, reason string) (canceled bool, err error) {
order, err := partner.CurOrderManager.LoadOrder(utils.Int64ToStr(orderID), model.VendorIDJX)
if err == nil {
if order.Status < model.OrderStatusNew {
order.Status = model.OrderStatusCanceled
order.VendorStatus = utils.Int2Str(model.OrderStatusCanceled)
if err = partner.CurOrderManager.UpdateOrderFields(order, []string{model.FieldStatus, "VendorStatus"}); err == nil {
canceled = true
}
} else {
err = fmt.Errorf("暂不支持自行取消订单，请联系商家取消")
// err = changeOrderStatus(utils.Int64ToStr(orderID), model.OrderStatusApplyCancel, fmt.Sprintf("用户%s主动取消", ctx.GetUserName()))
}
}
return canceled, err
}
func Pay4Order(ctx *jxcontext.Context, orderID int64, payType int, vendorPayType string) (orderPay *model.OrderPay, err error) {
order, err := partner.CurOrderManager.LoadOrder(utils.Int64ToStr(orderID), model.VendorIDJX)
if err == nil {
switch payType {
case model.PayTypeWX:
if orderPay, err = pay4OrderByWX(ctx, order, vendorPayType); err == nil {
dao.WrapAddIDCULDEntity(orderPay, ctx.GetUserName())
err = dao.CreateEntity(dao.GetDB(), orderPay)
}
case model.PayTypeTL:
if orderPay, err = pay4OrderByTL(ctx, order, payType, vendorPayType); err == nil && orderPay != nil {
dao.WrapAddIDCULDEntity(orderPay, ctx.GetUserName())
err = dao.CreateEntity(dao.GetDB(), orderPay)
}
default:
err = fmt.Errorf("支付方式:%d当前不支持", payType)
}
} else {
// priceDefendOrders, _ := dao.GetPriceDefendOrder(db, utils.Int64ToStr(orderID), nil, nil, []int{jxutils.GetDefendPriceIssue()}, 0, -1, -1, 0, "", utils.ZeroTimeValue, utils.ZeroTimeValue, false)
// if len(priceDefendOrders) == 0 {
// err = fmt.Errorf("未查询到待支付订单！order_id: %v", orderID)
// }
// order2 := &model.GoodsOrder{
// VendorOrderID: priceDefendOrders[0].VendorOrderID,
// ActualPayPrice: priceDefendOrders[0].ActualPayPrice,
// VendorID: model.VendorIDJX,
// }
// if orderPay, err = pay4OrderByTL(ctx, order2, payType, vendorPayType); err == nil && orderPay != nil {
// dao.WrapAddIDCULDEntity(orderPay, ctx.GetUserName())
// err = dao.CreateEntity(dao.GetDB(), orderPay)
// }
}
return orderPay, err
}
func Pay4User(ctx *jxcontext.Context, thingID, payType int, vendorPayType string) (orderPay *model.OrderPay, err error) {
var (
db = dao.GetDB()
order *model.GoodsOrder
dicountCards []*model.DiscountCard
vendorOrderID string
)
switch payType {
case model.PayTypeTL_DiscountCard:
if configList, err := dao.QueryConfigs(db, "会员折扣卡", model.ConfigTypeDiscountCard, ""); err == nil {
jxutils.Strings2Objs(configList[0].Value, &dicountCards)
if err != nil {
return nil, err
}
discountCard := findDiscountCard(dicountCards, thingID)
// flag, userMemberOrigin, err := checkMember(db, ctx.GetUserID(), discountCard)
if err != nil {
return nil, err
}
vendorOrderID = utils.Int64ToStr(jxutils.GenOrderNo())
order = &model.GoodsOrder{
VendorOrderID: vendorOrderID,
ActualPayPrice: int64(discountCard.Price),
VendorID: model.VendorIDJX,
}
if orderPay, err = pay4OrderByTL(ctx, order, payType, vendorPayType); err == nil && orderPay != nil {
dao.WrapAddIDCULDEntity(orderPay, ctx.GetUserName())
err = dao.CreateEntity(dao.GetDB(), orderPay)
}
// userMember := &model.UserMember{
// VendorOrderID: vendorOrderID,
// UserID: ctx.GetUserID(),
// MemberType: model.MemberTypeDiscountCard,
// EndAt: utils.Str2Time(time.Now().AddDate(0, 1, 0).AddDate(0, 0, -1).Format("2006-01-02") + " 23:59:59"),
// MemberTypeID: thingID,
// IsPay: model.NO,
// }
// dao.WrapAddIDCULDEntity(userMember, ctx.GetUserName())
// if flag == 0 {
// dao.CreateEntity(db, userMember)
// } else if flag == 1 {
// userMemberOrigin.EndAt = userMemberOrigin.EndAt.AddDate(0, 1, 0)
// dao.UpdateEntity(db, userMemberOrigin, "EndAt")
// }
}
default:
err = fmt.Errorf("支付方式:%d当前不支持", payType)
}
return orderPay, err
}
//flag
//0 正常购买
//1 续费
//-1 不能购买
func checkMember(db *dao.DaoDB, userID string, discountCard *model.DiscountCard) (flag int, userMember *model.UserMember, err error) {
// userMembers, err := dao.GetUserMember(db, userID, "", model.MemberTypeDiscountCard, model.YES)
// if len(userMembers) > 0 {
// userMember = userMembers[0]
// if userMember.ID < discountCard.ID {
// return 0, userMember, err
// } else if userMember.ID == discountCard.ID {
// return 1, userMember, err
// } else {
// return -1, userMember, fmt.Errorf("已购买更高档次的会员，无法继续购买！")
// }
// }
return 0, userMember, err
}
func time2ShortTimeStr(t time.Time) string {
return t.Format("15:04")
}
func findDiscountCard(dicountCards []*model.DiscountCard, thingID int) (dicountCard *model.DiscountCard) {
for _, v := range dicountCards {
if v.ID == thingID {
return v
}
}
return dicountCard
}
func OnPayFinished(orderPay *model.OrderPay) (err error) {
order, err := partner.CurOrderManager.LoadOrder(orderPay.VendorOrderID, orderPay.VendorID)
if err == nil {
db := dao.GetDB()
dao.UpdateEntity(db, orderPay)
// if count, err2 := dao.GetJxOrderCount(db, jxutils.GetSaleStoreIDFromOrder(order), order.VendorOrderID, order.OrderCreatedAt); err2 == nil {
// order.OrderSeq = count + 1
// partner.CurOrderManager.UpdateOrderFields(order, []string{"OrderSeq"})
// }
order.Status = model.OrderStatusNew
order.VendorStatus = utils.Int2Str(model.OrderStatusNew)
order.StatusTime = *orderPay.PayFinishedAt
err = callNewOrder(order)
//如果是物料的订单，直接到拣货完成，配送中的状态
if order.OrderType != model.OrderTypeNormal {
// if order.FromStoreID != 0 {
if order.OrderType != model.OrderTypeDefendPrice {
// netprinter.PrintOrderByOrder(jxcontext.AdminCtx, order)
}
// PickupGoods(order, false, "jxadmin")
// }
}
} else {
switch orderPay.PayType {
case model.PayTypeTL_DiscountCard:
// userMembers, _ := dao.GetUserMember(dao.GetDB(), "", orderPay.VendorOrderID, model.MemberTypeDiscountCard, model.NO)
// if len(userMembers) > 0 {
// userMembers[0].IsPay = model.YES
// dao.UpdateEntity(dao.GetDB(), userMembers[0], "IsPay")
// err = nil
// }
default:
}
}
return err
}
func GenPayOrderID(order *model.GoodsOrder) (payOrderID int64) {
return utils.Str2Int64(order.VendorOrderID)
}
func GenRefundID(order *model.GoodsOrder) (refundID int64) {
const suffix = 100000
refundID = utils.Str2Int64(order.VendorOrderID) * suffix
refundID += int64(time.Now().Sub(order.OrderFinishedAt) / time.Minute)
return refundID
}
func formalizeSkus(skus []*JxSkuInfo) (outSkus []*JxSkuInfo) {
skuMap := make(map[int]int)
for _, v := range skus {
skuMap[v.SkuID] += v.Count
}
for skuID, skuCount := range skuMap {
outSkus = append(outSkus, &JxSkuInfo{
SkuID: skuID,
Count: skuCount,
})
}
return outSkus
}
func isTimeInOpTime(openTime1, closeTime1, openTime2, closeTime2 int16, time2Check time.Time) bool {
timeStrList := []string{
jxutils.OperationTime2StrWithSecond(openTime1),
jxutils.OperationTime2StrWithSecond(closeTime1),
}
if openTime1 > 0 {
timeStrList = append(timeStrList,
jxutils.OperationTime2StrWithSecond(openTime2),
jxutils.OperationTime2StrWithSecond(closeTime2),
)
}
checkTimeStr := utils.Time2TimeStr(time2Check)
for i := 0; i < len(timeStrList); i += 2 {
if checkTimeStr >= timeStrList[i] && checkTimeStr <= timeStrList[i+1] {
return true
}
}
return false
}
func jxOrder2GoodsOrder(ctx *jxcontext.Context, jxOrder *JxOrderInfo, deliveryAddress *dao.UserDeliveryAddressEx, userID string, IsDeliverySelf bool) (order *model.GoodsOrder, err error) {
order = &model.GoodsOrder{
VendorOrderID: utils.Int64ToStr(jxOrder.OrderID),
VendorID: model.VendorIDJX,
VendorStoreID: utils.Int2Str(jxOrder.StoreID),
StoreID: jxOrder.StoreID,
StoreName: jxOrder.StoreName,
// UserID: ctx.GetUserID(),
ConsigneeName: deliveryAddress.ConsigneeName,
ConsigneeMobile: deliveryAddress.ConsigneeMobile,
ConsigneeMobile2: deliveryAddress.ConsigneeMobile,
ConsigneeAddress: fmt.Sprintf("%s%s", deliveryAddress.Address, deliveryAddress.DetailAddress),
CoordinateType: model.CoordinateTypeMars,
ConsigneeLng: jxutils.StandardCoordinate2Int(deliveryAddress.Lng),
ConsigneeLat: jxutils.StandardCoordinate2Int(deliveryAddress.Lat),
Status: model.OrderStatusUnknown,
VendorStatus: "realnew",
OrderSeq: 0,
BuyerComment: jxOrder.BuyerComment,
DeliveryType: model.OrderDeliveryTypeStoreSelf,
StatusTime: time.Now(),
EarningType: jxOrder.EarningType,
OrderType: jxOrder.OrderType,
VendorOrderID2: jxOrder.OrderID2,
}
if userID == "" {
order.UserID = ctx.GetUserID()
} else {
order.UserID = userID
}
order.OrderCreatedAt = order.StatusTime
order.VendorUserID = order.UserID
if order.UserID == "" && order.VendorUserID == "" {
if jxOrder.UserID != "" {
order.UserID = jxOrder.UserID
order.VendorUserID = jxOrder.UserID
}
}
if jxOrder.ExpectedDeliveredTimestamp != 0 {
order.ExpectedDeliveredTime = utils.Timestamp2Time(jxOrder.ExpectedDeliveredTimestamp)
order.BusinessType = model.BusinessTypeDingshida
} else {
order.ExpectedDeliveredTime = order.OrderCreatedAt.Add(time.Hour)
order.BusinessType = model.BusinessTypeImmediate
}
for _, sku := range jxOrder.Skus {
order.Skus = append(order.Skus, &model.OrderSku{
Count: sku.Count,
VendorSkuID: utils.Int2Str(sku.SkuID),
SkuID: sku.SkuID,
SkuName: sku.Name,
VendorPrice: sku.Price,
SalePrice: sku.SalePrice,
})
order.TotalShopMoney += int64(sku.Count) * sku.SalePrice
}
order.TotalShopMoney += jxOrder.FreightPrice
order.ActualPayPrice = jxOrder.ActualPayPrice
order.TotalShopMoney = utils.Float64TwoInt64(float64(order.TotalShopMoney) * jdshopapi.JdsPayPercentage)
if jxOrder.FromStoreID != 0 {
order.FromStoreID = jxOrder.FromStoreID
order.DeliveryFlag = model.OrderDeliveryFlagMaskScheduleDisabled
order.Flag = 1
if jxOrder.OrderType == model.OrderTypeMatter {
order.WaybillVendorID = model.VendorIDJDWL
order.ConsigneeAddress = deliveryAddress.Address
}
}
//如果是自提单就设置
if IsDeliverySelf {
order.DeliveryType = model.OrderDeliveryTypeSelfTake
}
return order, err
}
func AcceptOrRefuseOrder(order *model.GoodsOrder, isAcceptIt bool, userName string) (err error) {
var status int
if isAcceptIt {
status = model.OrderStatusAccepted
} else {
status = model.OrderStatusCanceled
}
return changeOrderStatus(order.VendorOrderID, status, "")
}
func AdjustOrder(ctx *jxcontext.Context, order *model.GoodsOrder, removedSkuList []*model.OrderSku, reason string) (err error) {
return err
}
func MarkArrears(db *dao.DaoDB, order *model.GoodsOrder, orderPay *model.OrderPay) {
//退款后，若此订单下单用户有推广人，则需要将分给推广人的金额记录到该推广人的欠款中
// orders, _ := dao.QueryOrders(db, order.VendorOrderID, 0, []int{model.VendorIDJX}, 0, utils.DefaultTimeValue, utils.DefaultTimeValue)
// if len(orders) > 0 {
// user, _ := dao.GetUserByID(db, "user_id", orders[0].UserID)
// if user.ParentMobile != "" {
// user2, _ := dao.GetUserByID(db, "mobile", user.ParentMobile)
// user2.Arrears = user2.Arrears + (orderPay.TotalFee * user2.DividePercentage / 100)
// dao.UpdateEntity(db, user2, "Arrears")
// if user2.ParentMobile != "" {
// user3, _ := dao.GetUserByID(db, "mobile", user2.ParentMobile)
// user3.Arrears = user3.Arrears + ((orderPay.TotalFee - user2.Arrears) * user3.DividePercentage / 100)
// dao.UpdateEntity(db, user3, "Arrears")
// }
// }
// }
}
// todo 消息用异步可能导致丢失，单同步又有重入相关的问题
func callNewOrder(order *model.GoodsOrder) (err error) {
jxutils.CallMsgHandlerAsync(func() {
err = partner.CurOrderManager.OnOrderNew(order, model.Order2Status(order))
}, jxutils.ComposeUniversalOrderID(order.VendorOrderID, model.VendorIDJX))
return err
}
func changeOrderStatus(vendorOrderID string, status int, remark string) (err error) {
orderStatus := &model.OrderStatus{
VendorOrderID: vendorOrderID,
VendorID: model.VendorIDJX,
OrderType: model.OrderTypeOrder,
RefVendorOrderID: vendorOrderID,
RefVendorID: model.VendorIDJX,
VendorStatus: utils.Int2Str(status),
Status: status,
StatusTime: time.Now(),
Remark: remark,
}
jxutils.CallMsgHandlerAsync(func() {
err = partner.CurOrderManager.OnOrderStatusChanged("", orderStatus)
}, jxutils.ComposeUniversalOrderID(vendorOrderID, model.VendorIDJX))
return err
}
func PayForPopluarMan(ctx *jxcontext.Context, vendorOrderID, userID string, price int) (err error) {
db := dao.GetDB()
user, err := dao.GetUserByID(db, "user_id", userID)
if user == nil {
return fmt.Errorf("未找到此用户！用户ID：[%v]\n", userID)
}
auth, err := dao.GetUserBindAuthInfo(db, userID, model.AuthBindTypeAuth, []string{"weixinmini"}, "", "", "wx4b5930c13f8b1170")
if len(auth) == 0 {
return fmt.Errorf("未找到此用户的微信验证方式！用户ID：[%v]\n", userID)
}
// goods, err := dao.QueryOrders(db, vendorOrderID, 0, []int{model.VendorIDJX}, 0, utils.ZeroTimeValue, utils.ZeroTimeValue)
// if len(goods) == 0 {
// return fmt.Errorf("未找到此订单！订单ID：[%v]\n", vendorOrderID)
// }
param := &wxpayapi.TransfersParam{
CheckName: wxpayapi.CheckName,
PartnerTradeNo: vendorOrderID,
Desc: "每日推广人订单分成分到个人",
SpbillCreateIP: ctx.GetRealRemoteIP(),
OpenID: auth[0].AuthID,
Amount: price,
}
_, err = api.WxpayAPI.Transfers(param)
return err
}
//自动打款给市场推广人
func AutoPayForPopluarMan(ctx *jxcontext.Context) (err error) {
// var (
// errMsg string
// // errCode string
// db = dao.GetDB()
// fromDateStr = time.Now().AddDate(0, 0, -1).Format("2006-1-2") + " 00:00:00"
// toDateStr = time.Now().AddDate(0, 0, -1).Format("2006-1-2") + " 23:59:59"
// mapResult = make(map[string]interface{})
// )
// result, err := dao.GetOrdersForJxPay(db, utils.Str2Time(fromDateStr), utils.Str2Time(toDateStr))
// for _, goods := range result {
// var (
// param = &wxpayapi.TransfersParam{
// CheckName: wxpayapi.CheckName,
// Desc: "每日推广人订单分成分到个人",
// SpbillCreateIP: ctx.GetRealRemoteIP(),
// }
// payPrice1 int
// payPrice2 int
// )
// user, err := dao.GetUserByID(db, "user_id", goods.UserID)
// if user.ParentMobile == "" {
// return err
// }
// user2, err := dao.GetUserByID(db, "mobile", user.ParentMobile)
// auths, err := dao.GetUserBindAuthInfo(db, user2.UserID, model.AuthBindTypeAuth, []string{"weixinmini"}, "", "", "wx4b5930c13f8b1170")
// if err != nil {
// return err
// }
// if len(auths) == 0 {
// errMsg += fmt.Sprintf("打款失败！未找到此用户的微信验证方式！订单号：[%v]，用户ID：[%v]\n", goods.VendorOrderID, user2.UserID)
// } else {
// var openID string
// for _, auth := range auths {
// if auth.TypeID == wxAppID {
// openID = auth.AuthID
// }
// }
// payPrice1 = int(goods.ActualPayPrice) * user2.DividePercentage / 100
// //表示这个人之前有欠款，意思是取消订单退款时，这个推广人的分成收不回来，算作欠款，打钱的时候要扣除
// //表示这个人之前有小于3毛钱的款没有打（微信付款api付款最低3毛），记录下来加到以后的款项中
// rPrice := payPrice1 - user2.Arrears + user2.Profit
// err = updateUserAndTransfers(db, param, user2, openID, rPrice)
// if err != nil {
// errMsg += err.Error()
// }
// mapResult["打款人1"] = user2.Name
// mapResult["打款人金额1"] = rPrice
// mapResult["打款人电话1"] = user2.Mobile
// mapResult["打款人1userID"] = user2.UserID
// }
// if user2.ParentMobile != "" {
// user3, err := dao.GetUserByID(db, "mobile", user2.ParentMobile)
// auths, err := dao.GetUserBindAuthInfo(db, user3.UserID, model.AuthBindTypeAuth, []string{"weixinmini"}, "", "", "wx4b5930c13f8b1170")
// if err != nil {
// return err
// }
// if len(auths) == 0 {
// errMsg += fmt.Sprintf("打款失败！未找到此用户的微信验证方式！订单号：[%v]，用户ID：[%v]\n", goods.VendorOrderID, user3.UserID)
// } else {
// var openID string
// for _, auth := range auths {
// if auth.TypeID == wxAppID {
// openID = auth.AuthID
// }
// }
// payPrice2 = (int(goods.ActualPayPrice) - payPrice1) * user3.DividePercentage / 100
// rPrice := payPrice2 - user3.Arrears + user3.Profit
// err = updateUserAndTransfers(db, param, user3, openID, rPrice)
// if err != nil {
// errMsg += err.Error()
// }
// mapResult["打款人2"] = user3.Name
// mapResult["打款人金额2"] = rPrice
// mapResult["打款人电话2"] = user3.Mobile
// mapResult["打款人2userID"] = user3.UserID
// }
// }
// }
// user, _ := dao.GetUserByID(dao.GetDB(), "mobile", "18160030913")
// if user != nil && errMsg != "" {
// ddmsg.SendUserMessage(dingdingapi.MsgTyeText, user.UserID, "每日打款错误", errMsg)
// }
// if err != nil || errMsg != "" {
// errMsg += err.Error()
// errCode = model.ErrCodeGeneralFailed
// } else {
// errCode = model.ErrCodeSuccess
// }
// err = event.AddOperateEvent(ctx, ctx.GetTrackInfo(), cms.BuildDiffData(mapResult), errCode, errMsg, 0, "AutoPayForPopluarMan")
// globals.SugarLogger.Debugf("每日订单打款:[%v]", cms.BuildDiffData(mapResult))
return err
}
func updateUserAndTransfers(db *dao.DaoDB, param *wxpayapi.TransfersParam, user *model.User, authID string, rPrice int) (err error) {
if rPrice >= 30 {
param.OpenID = authID
param.Amount = rPrice
param.PartnerTradeNo = utils.GetUUID()
_, err = api.WxpayAPI.Transfers(param)
user.ProfitSum = user.ProfitSum + rPrice
user.Profit = 0
user.Arrears = 0
} else if rPrice >= 0 && rPrice < 30 {
user.Profit = rPrice
user.Arrears = 0
} else {
user.Profit = 0
user.Arrears = int(utils.Float64TwoInt64(math.Abs(utils.Int2Float64(rPrice))))
}
_, err = dao.UpdateEntity(db, user, "ProfitSum", "Profit", "Arrears")
return err
}
func CancelPayTimeOutOrder(ctx *jxcontext.Context) (err error) {
db := dao.GetDB()
var orders []*model.GoodsOrder
sql := `
SELECT *
FROM goods_order
WHERE order_created_at >= ? AND order_created_at <= NOW()
AND status = ?
AND vendor_id = ?
`
sqlParams := []interface{}{
time.Now().Add(-time.Minute * 30),
model.OrderStatusWait4Pay,
model.VendorIDJX,
}
err = dao.GetRows(db, &orders, sql, sqlParams)
for _, v := range orders {
if v.OrderCreatedAt.Add(PayWaitingTime).Before(time.Now()) {
err2 := changeOrderStatus(v.VendorOrderID, model.OrderStatusCanceled, autoCancelOrderReason)
err = err2
}
}
return err
}
func GetHalfHoursList() (strs []string) {
for k := 0; k < 3; k++ {
for i := 0; i < 10; i++ {
for j := 0; j < 4; j += 3 {
if k == 2 && i > 3 {
break
}
strs = append(strs, utils.Int2Str(k)+utils.Int2Str(i)+":"+utils.Int2Str(j)+"0"+":00")
}
}
}
return strs
}
func GetDiscountActHoursList() (str []string) {
for k := 1; k < 3; k++ {
for i := 0; i < 10; i++ {
for j := 0; j < 6; j++ {
if k == 1 && i == 0 && j == 0 {
continue
}
if k == 2 && i > 2 {
break
}
if k == 2 && i == 2 && j > 0 {
break
}
str = append(str, utils.Int2Str(k)+utils.Int2Str(i)+":"+utils.Int2Str(j)+"0"+":00")
}
}
}
return str
}

182
business/partner/purchase/jx/localjx/tonglianpay.go Normal file
View File

@@ -0,0 +1,182 @@
package localjx
import (
"encoding/json"
"strings"
"time"
"git.rosy.net.cn/jx-callback/globals"
"git.rosy.net.cn/baseapi/platformapi/tonglianpayapi"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/auth2/authprovider/weixin"
"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/api"
)
func pay4OrderByTL(ctx *jxcontext.Context, order *model.GoodsOrder, payType int, vendorPayType string) (orderPay *model.OrderPay, err error) {
// if order.FromStoreID != 0 {
// result, _ := orderman.GetMatterStoreOrderCount(nil, order.FromStoreID)
// if !result.Flag {
// return nil, fmt.Errorf("该门店[%v]已在一周内申请过物料，请勿重复申请！", order.FromStoreID)
// }
// }
payCreatedAt := time.Now()
param := &tonglianpayapi.CreateUnitorderOrderParam{
Trxamt: int(order.ActualPayPrice),
NotifyUrl: globals.TLPayNotifyURL,
Reqsn: order.VendorOrderID,
PayType: vendorPayType,
}
//暂时做兼容处理
if vendorPayType == "JSAPI" {
param.PayType = tonglianpayapi.PayTypeWxXcx
}
if vendorPayType == tonglianpayapi.PayTypeWxXcx {
if authInfo, err := ctx.GetV2AuthInfo(); err == nil && authInfo.GetAuthType() == weixin.AuthTypeMini {
param.Acct = authInfo.GetAuthID()
}
}
if vendorPayType == tonglianpayapi.PayTypeH5 {
param2 := &tonglianpayapi.CreateH5UnitorderOrderParam{
Trxamt: int(order.ActualPayPrice),
NotifyUrl: globals.TLPayNotifyURL,
Body: "京西菜市",
Charset: "UTF-8",
}
err = api.TLpayAPI.CreateH5UnitorderOrder(param2)
} else {
result, err := api.TLpayAPI.CreateUnitorderOrder(param)
if err == nil {
var result2 tonglianpayapi.PayInfo
json.Unmarshal([]byte(result.PayInfo), &result2)
prePayID := result2.Package[strings.LastIndex(result2.Package, "=")+1 : len(result2.Package)]
orderPay = &model.OrderPay{
PayOrderID: param.Reqsn,
PayType: payType,
VendorPayType: vendorPayType,
TransactionID: result.TrxID,
VendorOrderID: order.VendorOrderID,
VendorID: order.VendorID,
Status: 0,
PayCreatedAt: payCreatedAt,
PrepayID: prePayID,
CodeURL: utils.LimitUTF8StringLen(result.PayInfo, 3200),
TotalFee: int(order.ActualPayPrice),
}
}
}
return orderPay, err
}
func OnTLPayCallback(call *tonglianpayapi.CallBackResult) (err error) {
globals.SugarLogger.Debugf("OnTLPayCallback msg:%s", utils.Format4Output(call, true))
switch call.TrxCode {
case tonglianpayapi.MsgTypePay:
err = onTLpayFinished(call)
case tonglianpayapi.MsgTypeRefund:
err = onTLpayRefund(call)
}
return err
}
func onTLpayFinished(call *tonglianpayapi.CallBackResult) (err error) {
orderPay := &model.OrderPay{
PayOrderID: call.CusorderID,
// PayType: model.PayTypeTL,
}
orderPay.DeletedAt = utils.DefaultTimeValue
db := dao.GetDB()
if err = dao.GetEntity(db, orderPay, "PayOrderID", "DeletedAt"); err == nil {
if orderPay.Status != 0 {
globals.SugarLogger.Debugf("already pay msg:%s, err:%v", utils.Format4Output(call, true), err)
return err
}
loc, _ := time.LoadLocation("Local")
t1, _ := time.ParseInLocation("20060102150405", call.PayTime, loc)
orderPay.PayFinishedAt = utils.Time2Pointer(t1)
// orderPay.TransactionID = call.ChnlTrxID
orderPay.OriginalData = utils.Format4Output(call, true)
if call.TrxStatus == tonglianpayapi.TrxStatusSuccess {
orderPay.Status = model.PayStatusYes
} else {
orderPay.Status = model.PayStatusFailed
}
dao.UpdateEntity(db, orderPay)
if call.TrxStatus == tonglianpayapi.TrxStatusSuccess {
err = OnPayFinished(orderPay)
}
} else {
globals.SugarLogger.Debugf("onTLpayFinished msg:%s, err:%v", utils.Format4Output(call, true), err)
}
return err
}
func onTLpayRefund(call *tonglianpayapi.CallBackResult) (err error) {
orderPayRefund := &model.OrderPayRefund{
RefundID: call.CusorderID,
}
db := dao.GetDB()
if err = dao.GetEntity(db, orderPayRefund, "RefundID"); err == nil {
if call.TrxStatus == tonglianpayapi.TrxStatusSuccess {
orderPayRefund.Status = model.RefundStatusYes
} else {
orderPayRefund.Status = model.RefundStatusFailed
}
orderPayRefund.OriginalData = utils.Format4Output(call, true)
dao.UpdateEntity(db, orderPayRefund)
} else if dao.IsNoRowsError(err) {
globals.SugarLogger.Warnf("收到异常的退款事件, call:%s", utils.Format4Output(call, true))
}
orderPay := &model.OrderPay{
VendorOrderID: orderPayRefund.VendorOrderID,
VendorID: jxutils.GetPossibleVendorIDFromVendorOrderID(orderPayRefund.VendorOrderID),
PayType: model.PayTypeWX,
Status: model.PayStatusYes,
}
orderPay.DeletedAt = utils.DefaultTimeValue
if err = dao.GetEntity(db, orderPay, "VendorOrderID", "VendorID", "PayType", "Status", "DeletedAt"); err == nil {
orderPay.Status = model.PayStatusRefund
dao.UpdateEntity(db, orderPay)
}
return err
}
func RefundOrderByTL(ctx *jxcontext.Context, orderPay *model.OrderPay, 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.VendorOrderID,
VendorID: orderPay.VendorID,
Status: model.RefundStatusNo,
TransactionID: orderPay.TransactionID,
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)
dao.CreateEntity(db, orderPayRefund)
orderPay.Status = model.PayStatusRefund
dao.UpdateEntity(db, orderPay)
}
return orderPayRefund, err
}

152
business/partner/purchase/jx/localjx/wxpay.go Normal file
View File

@@ -0,0 +1,152 @@
package localjx
import (
"fmt"
"time"
"git.rosy.net.cn/baseapi/platformapi/wxpayapi"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/auth2/authprovider/weixin"
"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"
)
func vendorPayType2WxpayType(vendorPayType string) string {
return vendorPayType
}
func getOrderBrief(order *model.GoodsOrder) string {
return fmt.Sprintf("%s等共%d件商品", order.Skus[0].SkuName, order.GoodsCount)
}
func pay4OrderByWX(ctx *jxcontext.Context, order *model.GoodsOrder, vendorPayType string) (orderPay *model.OrderPay, err error) {
payCreatedAt := time.Now()
param := &wxpayapi.CreateOrderParam{
OutTradeNo: utils.Int64ToStr(GenPayOrderID(order)),
Body: getOrderBrief(order),
NotifyURL: globals.WxpayNotifyURL,
SpbillCreateIP: ctx.GetRealRemoteIP(),
TradeType: vendorPayType2WxpayType(vendorPayType),
TotalFee: int(order.ActualPayPrice),
TimeStart: wxpayapi.Time2PayTime(payCreatedAt),
// TimeExpire: wxpayapi.Time2PayTime(payCreatedAt.Add(PayWaitingTime)),
ProfitSharing: wxpayapi.OptYes,
}
if authInfo, err := ctx.GetV2AuthInfo(); err == nil && authInfo.GetAuthType() == weixin.AuthTypeMini {
param.OpenID = authInfo.GetAuthID()
}
result, err := api.WxpayAPI.CreateUnifiedOrder(param)
if err == nil {
orderPay = &model.OrderPay{
PayOrderID: param.OutTradeNo,
PayType: model.PayTypeWX,
VendorPayType: vendorPayType,
VendorOrderID: order.VendorOrderID,
VendorID: order.VendorID,
Status: 0,
PayCreatedAt: payCreatedAt,
PrepayID: result.PrepayID,
CodeURL: result.CodeURL,
TotalFee: int(order.ActualPayPrice),
}
}
return orderPay, err
}
func OnWxPayCallback(msg *wxpayapi.CallbackMsg) (err error) {
globals.SugarLogger.Debugf("OnWxPayCallback msg:%s", utils.Format4Output(msg, true))
switch msg.MsgType {
case wxpayapi.MsgTypePay:
err = onWxpayFinished(msg.Data.(*wxpayapi.PayResultMsg))
case wxpayapi.MsgTypeRefund:
err = onWxpayRefund(msg.Data.(*wxpayapi.RefundResultMsg))
}
return err
}
func onWxpayFinished(msg *wxpayapi.PayResultMsg) (err error) {
orderPay := &model.OrderPay{
PayOrderID: msg.OutTradeNo,
PayType: model.PayTypeWX,
}
orderPay.DeletedAt = utils.DefaultTimeValue
db := dao.GetDB()
if err = dao.GetEntity(db, orderPay, "PayOrderID", "PayType", "DeletedAt"); err == nil {
orderPay.PayFinishedAt = utils.Time2Pointer(wxpayapi.PayTime2Time(msg.TimeEnd))
orderPay.TransactionID = msg.TransactionID
orderPay.OriginalData = utils.Format4Output(msg, true)
if msg.ResultCode == wxpayapi.ResponseCodeSuccess {
orderPay.Status = model.PayStatusYes
} else {
orderPay.Status = model.PayStatusFailed
}
dao.UpdateEntity(db, orderPay)
if msg.ResultCode == wxpayapi.ResponseCodeSuccess {
err = OnPayFinished(orderPay)
}
} else {
globals.SugarLogger.Debugf("onWxpayFinished msg:%s, err:%v", utils.Format4Output(msg, true), err)
}
return err
}
func onWxpayRefund(msg *wxpayapi.RefundResultMsg) (err error) {
orderPayRefund := &model.OrderPayRefund{
RefundID: msg.ReqInfoObj.OutRefundNo,
}
db := dao.GetDB()
if err = dao.GetEntity(db, orderPayRefund, "RefundID"); err == nil {
if msg.ResultCode == wxpayapi.ResponseCodeSuccess {
orderPayRefund.Status = model.RefundStatusYes
} else {
orderPayRefund.Status = model.RefundStatusFailed
}
orderPayRefund.OriginalData = utils.Format4Output(msg, true)
dao.UpdateEntity(db, orderPayRefund)
} else if dao.IsNoRowsError(err) {
globals.SugarLogger.Warnf("收到异常的退款事件, msg:%s", utils.Format4Output(msg, true))
}
orderPay := &model.OrderPay{
VendorOrderID: orderPayRefund.VendorOrderID,
VendorID: jxutils.GetPossibleVendorIDFromVendorOrderID(orderPayRefund.VendorOrderID),
PayType: model.PayTypeWX,
Status: model.PayStatusYes,
}
orderPay.DeletedAt = utils.DefaultTimeValue
if err = dao.GetEntity(db, orderPay, "VendorOrderID", "VendorID", "PayType", "Status", "DeletedAt"); err == nil {
orderPay.Status = model.PayStatusRefund
dao.UpdateEntity(db, orderPay)
}
return err
}
func refundOrderByWX(ctx *jxcontext.Context, orderPay *model.OrderPay, refundID string, refundFee int, refundDesc string) (orderPayRefund *model.OrderPayRefund, err error) {
result, err := api.WxpayAPI.PayRefund(&wxpayapi.PayRefundParam{
OutTradeNo: orderPay.VendorOrderID,
NotifyURL: globals.WxpayNotifyURL,
OutRefundNo: refundID,
TotalFee: orderPay.TotalFee,
RefundFee: refundFee,
RefundDesc: wxpayapi.CData(refundDesc),
})
if err == nil {
orderPayRefund = &model.OrderPayRefund{
RefundID: refundID,
VendorRefundID: result.RefundID,
VendorOrderID: orderPay.VendorOrderID,
VendorID: orderPay.VendorID,
Status: model.RefundStatusNo,
TransactionID: orderPay.TransactionID,
RefundFee: orderPay.TotalFee,
RefundCreatedAt: time.Now(),
}
}
return orderPayRefund, err
}

134
business/partner/purchase/jx/order.go Normal file
View File

@@ -0,0 +1,134 @@
package jx
import (
"time"
"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
"git.rosy.net.cn/jx-callback/business/jxutils/tasksch"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/business/partner"
"git.rosy.net.cn/jx-callback/business/partner/purchase/jx/localjx"
"git.rosy.net.cn/jx-callback/business/partner/purchase/jx/phpjx"
)
func (c *PurchaseHandler) Map2Order(orderData map[string]interface{}) (order *model.GoodsOrder) {
return order
}
func (c *PurchaseHandler) GetOrder(vendorOrgCode, orderID string) (order *model.GoodsOrder, err error) {
order, err = partner.CurOrderManager.LoadOrder(orderID, model.VendorIDJX)
return order, err
}
func (p *PurchaseHandler) GetOrderStatus(vendorOrgCode, vendorOrderID string) (status int, err error) {
order, err := partner.CurOrderManager.LoadOrder(vendorOrderID, model.VendorIDJX)
if err == nil {
status = order.Status
}
return status, err
}
func (c *PurchaseHandler) AcceptOrRefuseOrder(order *model.GoodsOrder, isAcceptIt bool, userName string) (err error) {
var status int
if isAcceptIt {
status = model.OrderStatusAccepted
} else {
status = model.OrderStatusCanceled
}
if model.IsOrderJXTemp(order) {
err = phpjx.NotifyOrderStatusChanged(order, status)
} else {
err = localjx.AcceptOrRefuseOrder(order, isAcceptIt, userName)
}
return err
}
func (c *PurchaseHandler) PickupGoods(order *model.GoodsOrder, isSelfDelivery bool, userName string) (err error) {
if model.IsOrderJXTemp(order) {
err = phpjx.NotifyOrderStatusChanged(order, model.OrderStatusFinishedPickup)
} else {
err = localjx.PickupGoods(order, isSelfDelivery, userName)
}
return err
}
func (p *PurchaseHandler) AcceptOrRefuseFailedGetOrder(ctx *jxcontext.Context, order *model.GoodsOrder, isAcceptIt bool) (err error) {
return err
}
func (p *PurchaseHandler) CallCourier(ctx *jxcontext.Context, order *model.GoodsOrder) (err error) { // 拣货失败后再次招唤平台配送
return err
}
func (p *PurchaseHandler) ConfirmReceiveGoods(ctx *jxcontext.Context, order *model.GoodsOrder) (err error) { // 投递失败后确认收到退货
return err
}
func (c *PurchaseHandler) Swtich2SelfDeliver(order *model.GoodsOrder, userName string) (err error) {
return err
}
func (c *PurchaseHandler) Swtich2SelfDelivered(order *model.GoodsOrder, userName string) (err error) {
return err
}
func (c *PurchaseHandler) SelfDeliverDelivering(order *model.GoodsOrder, userName string) (err error) {
if model.IsOrderJXTemp(order) {
err = phpjx.NotifyOrderStatusChanged(order, model.OrderStatusDelivering)
} else {
err = localjx.SelfDeliverDelivering(order, userName)
}
return err
}
func (c *PurchaseHandler) SelfDeliverDelivered(order *model.GoodsOrder, userName string) (err error) {
if model.IsOrderJXTemp(order) {
err = phpjx.NotifyOrderStatusChanged(order, model.OrderStatusFinished)
} else {
err = localjx.SelfDeliverDelivered(order, userName)
}
return err
}
func (c *PurchaseHandler) GetOrderRealMobile(ctx *jxcontext.Context, order *model.GoodsOrder) (mobile string, err error) {
return mobile, err
}
func (c *PurchaseHandler) AgreeOrRefuseCancel(ctx *jxcontext.Context, order *model.GoodsOrder, isAgree bool, reason string) (err error) {
if model.IsOrderJXTemp(order) {
} else {
err = localjx.AgreeOrRefuseCancel(ctx, order, isAgree, reason)
}
return err
}
func (c *PurchaseHandler) CancelOrder(ctx *jxcontext.Context, order *model.GoodsOrder, reason string) (err error) {
if model.IsOrderJXTemp(order) {
err = phpjx.NotifyOrderStatusChanged(order, model.OrderStatusCanceled)
} else {
err = localjx.CancelOrder(ctx, order, reason)
}
return err
}
func (c *PurchaseHandler) AdjustOrder(ctx *jxcontext.Context, order *model.GoodsOrder, removedSkuList []*model.OrderSku, reason string) (err error) {
if model.IsOrderJXTemp(order) {
} else {
err = localjx.AdjustOrder(ctx, order, removedSkuList, reason)
}
return err
}
func (c *PurchaseHandler) ListOrders(ctx *jxcontext.Context, vendorOrgCode string, parentTask tasksch.ITask, queryDate time.Time, vendorStoreID string) (vendorOrderIDs []string, err error) {
return vendorOrderIDs, err
}
func (c *PurchaseHandler) ConfirmSelfTake(ctx *jxcontext.Context, vendorOrderID, selfTakeCode string) (err error) {
order, err := partner.CurOrderManager.LoadOrder(vendorOrderID, model.VendorIDJX)
if err == nil {
if model.IsOrderJXTemp(order) {
err = phpjx.NotifyOrderStatusChanged(order, model.OrderStatusFinished)
}
}
return err
}

170
business/partner/purchase/jx/order_afs.go Normal file
View File

@@ -0,0 +1,170 @@
package jx
import (
"fmt"
"strings"
"time"
"git.rosy.net.cn/jx-callback/business/jxutils"
"git.rosy.net.cn/jx-callback/globals"
"git.rosy.net.cn/jx-callback/business/model/dao"
"git.rosy.net.cn/jx-callback/globals/api"
"git.rosy.net.cn/jx-callback/business/partner/purchase/jx/localjx"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/business/partner"
)
// 审核售后单申请
func (c *PurchaseHandler) AgreeOrRefuseRefund(ctx *jxcontext.Context, order *model.AfsOrder, approveType int, reason string) (err error) {
var status int
if approveType == partner.AfsApproveTypeRefused {
status = model.AfsOrderStatusFailed
} else {
status = model.AfsOrderStatusFinished
}
orderStatus := &model.OrderStatus{
VendorOrderID: order.AfsOrderID, // 是售后单ID，不是订单ID，订单ID在RefVendorOrderID中
VendorID: order.VendorID,
OrderType: model.OrderTypeAfsOrder,
RefVendorOrderID: order.VendorOrderID,
RefVendorID: order.VendorID,
VendorStatus: utils.Int2Str(status),
Status: status,
StatusTime: time.Now(),
Remark: reason,
}
if status == model.AfsOrderStatusFinished {
orderPays, err := dao.GetOrderPayList(dao.GetDB(), order.VendorOrderID, order.VendorID)
if err == nil {
_, err = localjx.RefundOrderByTL(ctx, orderPays[0], order.VendorOrderID, int(order.SkuUserMoney), reason)
if err != nil {
return err
} else {
partner.CurOrderManager.OnAfsOrderStatusChanged(orderStatus)
}
}
} else {
partner.CurOrderManager.OnAfsOrderStatusChanged(orderStatus)
}
return err
}
// 确认收到退货
func (c *PurchaseHandler) ConfirmReceivedReturnGoods(ctx *jxcontext.Context, order *model.AfsOrder) (err error) {
err = fmt.Errorf("京西商城当前不支持ConfirmReceivedReturnGoods")
return err
}
// 发起全款退款
func (c *PurchaseHandler) RefundOrder(ctx *jxcontext.Context, order *model.GoodsOrder, reason string) (err error) {
err = c.PartRefundOrder(ctx, order, order.Skus, reason)
return err
}
// 发起部分退款
func (c *PurchaseHandler) PartRefundOrder(ctx *jxcontext.Context, order *model.GoodsOrder, refundSkuList []*model.OrderSku, reason string) (err error) {
globals.SugarLogger.Debugf("PartRefundOrder jx, orderID :%v", order.VendorOrderID)
var (
skuMap = make(map[int]*model.OrderSku)
appID = ""
salePrice int64
db = dao.GetDB()
)
if time.Now().Sub(order.OrderCreatedAt) > 24*time.Hour {
return fmt.Errorf("已超过售后申请时间，如有疑问请联系门店！")
}
referer := ctx.GetRequest().Referer()
index := strings.Index(referer, "//")
if index > 0 {
list := strings.Split(referer[index+2:], "/")
if len(list) >= 2 {
appID = list[1]
}
}
for _, sku := range order.Skus {
skuMap[sku.SkuID] = sku
}
orderStatus := buildOrderStatus(ctx, order, reason, isJxShop(appID))
afsOrder := &model.AfsOrder{
VendorID: order.VendorID,
AfsOrderID: orderStatus.VendorOrderID,
VendorOrderID: orderStatus.RefVendorOrderID,
VendorStoreID: order.VendorStoreID,
StoreID: order.StoreID,
AfsCreatedAt: time.Now(),
VendorAppealType: "",
AppealType: model.AfsAppealTypeRefund,
VendorReasonType: utils.Int2Str(model.AfsReasonNotOthers),
ReasonType: model.AfsReasonNotOthers,
ReasonDesc: utils.LimitUTF8StringLen(reason, 1024),
ReasonImgList: "",
RefundType: model.AfsTypePartRefund,
VendorOrgCode: "",
}
for _, sku := range refundSkuList {
orderSku := &model.OrderSkuFinancial{
Count: sku.Count,
VendorSkuID: utils.Int2Str(sku.SkuID),
SkuID: sku.SkuID,
}
if skuMap[sku.SkuID] != nil {
orderSku.Name = skuMap[sku.SkuID].SkuName
orderSku.UserMoney = skuMap[sku.SkuID].SalePrice * int64(sku.Count)
salePrice += skuMap[sku.SkuID].SalePrice * int64(sku.Count)
}
afsOrder.SkuUserMoney += orderSku.UserMoney
afsOrder.Skus = append(afsOrder.Skus, orderSku)
}
if !isJxShop(appID) {
orderPays, err := dao.GetOrderPayList(db, order.VendorOrderID, order.VendorID)
if err == nil {
_, err = localjx.RefundOrderByTL(ctx, orderPays[0], order.VendorOrderID, int(salePrice), reason)
if err != nil {
return err
} else {
if afsOrder != nil {
err = partner.CurOrderManager.OnAfsOrderNew(afsOrder, orderStatus)
}
}
}
} else {
err = partner.CurOrderManager.OnAfsOrderNew(afsOrder, orderStatus)
}
return err
}
func buildOrderStatus(ctx *jxcontext.Context, order *model.GoodsOrder, reason string, isJxShop bool) (orderStatus *model.OrderStatus) {
orderStatus = &model.OrderStatus{
VendorOrderID: utils.Int64ToStr(jxutils.GenAfsOrderNo()), // 是售后单ID，不是订单ID，订单ID在RefVendorOrderID中
VendorID: order.VendorID,
OrderType: model.OrderTypeAfsOrder,
RefVendorOrderID: order.VendorOrderID,
RefVendorID: order.VendorID,
VendorStatus: utils.Int2Str(model.AfsOrderStatusWait4Approve),
// Status: model.AfsOrderStatusWait4Approve,
StatusTime: time.Now(),
Remark: reason,
}
if isJxShop {
orderStatus.Status = model.AfsOrderStatusWait4Approve
} else {
orderStatus.Status = model.AfsOrderStatusFinished
}
return orderStatus
}
func isJxShop(appID string) bool {
if appID == api.WeixinMiniAppID2 {
return true
}
return false
}

10
business/partner/purchase/jx/order_comment.go Normal file
View File

@@ -0,0 +1,10 @@
package jx
import (
"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
"git.rosy.net.cn/jx-callback/business/model"
)
func (c *PurchaseHandler) ReplyOrderComment(ctx *jxcontext.Context, vendorOrgCode string, orderComment *model.OrderComment, replyComment string) (err error) {
return err
}

55
business/partner/purchase/jx/phpjx/callback.go Normal file
View File

@@ -0,0 +1,55 @@
package phpjx
import (
"fmt"
"time"
"git.rosy.net.cn/baseapi/utils"
)
const (
appKey = "4A86853D-E4B6-454E-940A-B68ECDA2B73E"
MsgTypeOrder = "order"
MsgTypeAfsOrder = "afsOrder"
)
type CallbackResponse struct {
Code int `json:"code"`
Data string `json:"data"`
}
type CallbackMsg struct {
AppKey string `json:"appKey"`
MsgType string `json:"msgType"`
SubMsgType string `json:"subMsgType"`
ThingID string `json:"thingID"`
ThingID2 string `json:"thingID2"`
Data string `json:"data"`
Timestamp int64 `json:"timestamp"`
}
func OnCallbackMsg(msg *CallbackMsg) (retVal, errCode string, err error) {
if msg.AppKey != appKey {
return retVal, errCode, fmt.Errorf("无效的AppKey:%s", msg.AppKey)
}
if msg.MsgType == MsgTypeOrder {
retVal, errCode, err = OnOrderMsg(msg)
} else if msg.MsgType == MsgTypeAfsOrder {
err = OnAfsOrderMsg(msg)
}
return retVal, errCode, err
}
func postFakeMsg(orderNo string, status int) {
msg := &CallbackMsg{
AppKey: appKey,
MsgType: MsgTypeOrder,
SubMsgType: utils.Int2Str(status),
ThingID: orderNo,
Timestamp: time.Now().Unix(),
}
utils.CallFuncAsync(func() {
OnCallbackMsg(msg)
})
}

52
business/partner/purchase/jx/phpjx/callback_test.go Normal file
View File

@@ -0,0 +1,52 @@
package phpjx
import (
"testing"
_ "git.rosy.net.cn/jx-callback/business/jxcallback/orderman"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/business/partner"
"git.rosy.net.cn/jx-callback/globals/testinit"
)
func init() {
testinit.Init()
}
func TestBuildNewJxOrder(t *testing.T) {
order, err := partner.CurOrderManager.LoadOrder("920931913000041", model.VendorIDJD)
if err != nil {
t.Fatal(err)
}
order.VendorID = model.VendorIDJX
order.VendorStoreID = utils.Int2Str(order.StoreID)
for _, sku := range order.Skus {
sku.VendorID = model.VendorIDJX
sku.VendorSkuID = utils.Int2Str(sku.SkuID)
}
order2 := &Data4Neworder{
GoodsOrder: *order,
Skus: order.Skus,
}
msg := &CallbackMsg{
AppKey: appKey,
MsgType: MsgTypeOrder,
SubMsgType: utils.Int2Str(model.OrderStatusNew),
ThingID: order.VendorOrderID,
Data: utils.Format4Output(order2, true),
}
t.Logf("\n%s", msg.AppKey)
t.Logf("\n%s", msg.MsgType)
t.Logf("\n%s", msg.SubMsgType)
t.Logf("\n%s", msg.ThingID)
t.Logf("\n%s", msg.Data)
var order3 *model.GoodsOrder
err = utils.UnmarshalUseNumber([]byte(msg.Data), &order3)
if err != nil {
t.Fatal(err)
}
t.Log(order3.OrderCreatedAt)
}

99
business/partner/purchase/jx/phpjx/jxapi.go Normal file
View File

@@ -0,0 +1,99 @@
package phpjx
import (
"fmt"
"net/http"
"strings"
"git.rosy.net.cn/baseapi"
"git.rosy.net.cn/baseapi/platformapi"
"git.rosy.net.cn/baseapi/utils"
)
type API struct {
token string
appKey string
appSecret string
client *http.Client
config *platformapi.APIConfig
}
const (
ResponseCodeSuccess = 200
)
const (
prodURL = "https://www.jingxicaishi.com/index.php/Weimendian/index"
)
var (
exceedLimitCodes = map[int]int{}
canRetryCodes = map[int]int{}
)
var (
jxAPI *API
)
func NewAPI(token, appKey, appSecret string, config ...*platformapi.APIConfig) *API {
curConfig := platformapi.DefAPIConfig
if len(config) > 0 {
curConfig = *config[0]
}
return &API{
token: token,
appKey: appKey,
appSecret: appSecret,
client: &http.Client{Timeout: curConfig.ClientTimeout},
config: &curConfig,
}
}
func init() {
jxAPI = NewAPI("", "", "")
}
func (a *API) AccessAPI(apiStr string, jxParams map[string]interface{}, traceInfo string) (retVal map[string]interface{}, err error) {
err = platformapi.AccessPlatformAPIWithRetry(a.client,
func() *http.Request {
params := utils.MergeMaps(jxParams, map[string]interface{}{
"timestamp": utils.GetCurTimeStr(),
})
var request *http.Request
if false {
} else {
fullURL := prodURL + "/" + apiStr
// baseapi.SugarLogger.Debug(utils.Map2URLValues(params).Encode())
request, _ = http.NewRequest(http.MethodPost, fullURL, strings.NewReader(utils.Map2URLValues(params).Encode()))
request.Header.Set("charset", "UTF-8")
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
}
if traceInfo != "" {
request.Header.Set(platformapi.KeyTrackInfo, traceInfo)
}
// request.Close = true //todo 为了性能考虑还是不要关闭
return request
},
a.config,
func(response *http.Response, bodyStr string, jsonResult1 map[string]interface{}) (errLevel string, err error) {
if jsonResult1 == nil {
return platformapi.ErrLevelRecoverableErr, fmt.Errorf("mapData is nil")
}
code := int(utils.Interface2Int64WithDefault(jsonResult1["code"], 0))
if code == ResponseCodeSuccess {
retVal = jsonResult1
return platformapi.ErrLevelSuccess, nil
}
newErr := utils.NewErrorIntCode(jsonResult1["msg"].(string), code)
if _, ok := exceedLimitCodes[code]; ok {
return platformapi.ErrLevelExceedLimit, newErr
} else if _, ok := canRetryCodes[code]; ok {
return platformapi.ErrLevelRecoverableErr, newErr
} else {
baseapi.SugarLogger.Debugf("jx AccessAPI failed, jsonResult1:%s", utils.Format4Output(jsonResult1, true))
return platformapi.ErrLevelCodeIsNotOK, newErr
}
})
return retVal, err
}

45
business/partner/purchase/jx/phpjx/jxapi_order.go Normal file
View File

@@ -0,0 +1,45 @@
package phpjx
import (
"git.rosy.net.cn/jx-callback/business/model"
)
var (
orderStatusMap = map[int]int{
model.OrderStatusFinishedPickup: 7,
model.OrderStatusDelivering: 8,
// 4,
model.OrderStatusFinished: 3,
model.OrderStatusCanceled: 3,
}
)
func translateOrderStatus(status int) (outStatus int) {
return status //orderStatusMap[status]
}
func (a *API) NotifyOrderStatusChanged(order *model.GoodsOrder) (err error) {
status := translateOrderStatus(order.Status)
if status > 0 {
_, err = a.AccessAPI("orderChangeStatus", map[string]interface{}{
"orderid": order.VendorOrderID,
"status": status,
"data": "", //string(utils.MustMarshal(order)),
}, "")
}
return err
}
func (a *API) NotifyAfsOrderStatusChanged(afsOrder *model.AfsOrder) (err error) {
status := translateOrderStatus(afsOrder.Status)
if status > 0 {
_, err = a.AccessAPI("afsOrderChangeStatus", map[string]interface{}{
"orderid": afsOrder.VendorOrderID,
"afsOrderID": afsOrder.AfsOrderID,
"status": status,
"data": "", //string(utils.MustMarshal(order)),
}, "")
}
return err
}

21
business/partner/purchase/jx/phpjx/jxapi_order_test.go Normal file
View File

@@ -0,0 +1,21 @@
package phpjx
import (
"testing"
_ "git.rosy.net.cn/jx-callback/business/jxcallback/orderman"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/business/partner"
)
func TestNotifyOrderStatusChanged(t *testing.T) {
order, err := partner.CurOrderManager.LoadOrder("920931913000041", model.VendorIDJX)
if err != nil {
t.Fatal(err)
}
err = jxAPI.NotifyOrderStatusChanged(order)
if err != nil {
t.Fatal(err)
}
}

84
business/partner/purchase/jx/phpjx/order.go Normal file
View File

@@ -0,0 +1,84 @@
package phpjx
import (
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/jxutils"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/business/partner"
"git.rosy.net.cn/jx-callback/globals"
)
func NotifyOrderStatusChanged(order *model.GoodsOrder, status int) (err error) {
orderMsg := *order
orderMsg.Status = status
if err = jxAPI.NotifyOrderStatusChanged(&orderMsg); err == nil {
postFakeMsg(orderMsg.VendorOrderID, orderMsg.Status)
}
return err
}
type Data4Neworder struct {
model.GoodsOrder
Skus []*model.OrderSku `json:"skus"`
}
func OnOrderMsg(msg *CallbackMsg) (retVal, errCode string, err error) {
jxutils.CallMsgHandler(func() {
retVal, errCode, err = onOrderMsg(msg)
}, jxutils.ComposeUniversalOrderID(msg.ThingID, model.VendorIDJX))
return retVal, errCode, err
}
func onOrderMsg(msg *CallbackMsg) (retVal, errCode string, err error) {
subMsgType := int(utils.Str2Int64WithDefault(msg.SubMsgType, 0))
if subMsgType == model.OrderStatusNew || subMsgType == model.OrderStatusAdjust {
var order *Data4Neworder
if err = utils.UnmarshalUseNumber([]byte(msg.Data), &order); err == nil {
if order.VendorStatus == "" {
order.VendorStatus = utils.Int2Str(order.Status)
}
retVal, errCode, err = onOrderNew(msg, subMsgType, order)
}
} else {
status := callbackMsg2Status(msg)
err = partner.CurOrderManager.OnOrderStatusChanged("", status)
}
return retVal, errCode, err
}
func callbackMsg2Status(msg *CallbackMsg) *model.OrderStatus {
orderStatus := &model.OrderStatus{
VendorOrderID: msg.ThingID,
VendorID: model.VendorIDJX,
OrderType: model.OrderTypeOrder,
RefVendorOrderID: msg.ThingID,
RefVendorID: model.VendorIDJX,
VendorStatus: msg.SubMsgType,
Status: int(utils.Str2Int64WithDefault(msg.SubMsgType, 0)),
StatusTime: utils.Timestamp2Time(msg.Timestamp),
Remark: "",
}
return orderStatus
}
func onOrderNew(msg *CallbackMsg, subMsgType int, order *Data4Neworder) (retVal, errCode string, err error) {
globals.SugarLogger.Debugf("onOrderNew orderID:%s", msg.ThingID)
order.StoreID = int(utils.Str2Int64WithDefault(order.VendorStoreID, 0))
if order.DeliveryType == "" {
order.DeliveryType = model.OrderDeliveryTypeStoreSelf
}
order.GoodsOrder.Skus = order.Skus
order.VendorID = model.VendorIDJX
order.Flag = model.OrderFlagMaskTempJX
for _, v := range order.GoodsOrder.Skus {
v.SkuID = int(utils.Str2Int64WithDefault(v.VendorSkuID, 0))
}
jxutils.RefreshOrderSkuRelated(&order.GoodsOrder)
orderStatus := model.Order2Status(&order.GoodsOrder)
if subMsgType == model.OrderStatusNew {
err = partner.CurOrderManager.OnOrderNew(&order.GoodsOrder, orderStatus)
} else if subMsgType == model.OrderStatusAdjust {
err = partner.CurOrderManager.OnOrderAdjust(&order.GoodsOrder, orderStatus)
}
return retVal, errCode, err
}

130
business/partner/purchase/jx/phpjx/order_afs.go Normal file
View File

@@ -0,0 +1,130 @@
package phpjx
import (
"time"
"git.rosy.net.cn/baseapi/platformapi/jdapi"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/jxutils"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/business/partner"
)
type Data4AfsOrderSku struct {
VendorSkuID string `orm:"column(vendor_sku_id);size(48)" json:"vendorSkuID"` // 平台skuid
PromotionType int `json:"promotionType"` // 商品级别促销类型 (1、无优惠;2、秒杀(已经下线);3、单品直降;4、限时抢购;1202、加价购;1203、满赠(标识商品);6、买赠(买A送B，标识B);9999、表示一个普通商品参与捆绑促销，设置的捆绑类型;9998、表示一个商品参与了捆绑促销，并且还参与了其他促销类型;9997、表示一个商品参与了捆绑促销，但是金额拆分不尽,9996:组合购,8001:轻松购会员价,8:第二件N折,9:拼团促销)
Name string `orm:"size(255)" json:"name"` // 商品名
SalePrice int64 `json:"salePrice"` // 售卖价
Count int `json:"count"` // 订单下单数量
}
type Data4AfsOrder struct {
VendorOrderID string `orm:"column(vendor_order_id);size(48)" json:"vendorOrderID"` // 关联原始订单ID
AfsOrderID string `orm:"column(afs_order_id);size(48)" json:"afsOrderID"` // 售后订单ID
AfsCreatedAt time.Time `orm:"type(datetime);null;index" json:"afsCreatedAt"` // 售后单生成时间
VendorStoreID string `orm:"column(vendor_store_id);size(48)" json:"vendorStoreID"` // 外部系统里记录的storeid
VendorStatus string `orm:"size(255)" json:"vendorStatus"`
VendorReasonType string `orm:"size(255)" json:"vendorReasonType"` // 原始售后原因
ReasonDesc string `orm:"size(1024)" json:"reasonDesc"` // 售后原因描述
ReasonImgList string `orm:"size(1024)" json:"reasonImgList"` // 售后描述图片
VendorAppealType string `orm:"size(255)" json:"vendorAppealType"` // 原始售后方式
Skus []*Data4AfsOrderSku
}
func OnAfsOrderMsg(msg *CallbackMsg) (err error) {
jxutils.CallMsgHandlerAsync(func() {
err = onAfsOrderMsg(msg)
}, jxutils.ComposeUniversalOrderID(msg.ThingID, model.VendorIDJX))
return err
}
func buildAfsOrder(msg *CallbackMsg) (outAfsOrder *model.AfsOrder, err error) {
var afsOrder *Data4AfsOrder
if err = utils.UnmarshalUseNumber([]byte(msg.Data), &afsOrder); err == nil {
outAfsOrder = &model.AfsOrder{
VendorID: model.VendorIDJX,
AfsOrderID: afsOrder.AfsOrderID,
VendorOrderID: afsOrder.VendorOrderID,
VendorStoreID: afsOrder.VendorStoreID,
StoreID: int(utils.Str2Int64WithDefault(afsOrder.VendorStoreID, 0)),
AfsCreatedAt: afsOrder.AfsCreatedAt,
VendorStatus: afsOrder.VendorStatus,
VendorReasonType: afsOrder.VendorReasonType,
ReasonType: int8(utils.Str2Int64WithDefault(afsOrder.VendorReasonType, 0)),
ReasonDesc: utils.LimitUTF8StringLen(afsOrder.ReasonDesc, 1024),
ReasonImgList: afsOrder.ReasonImgList,
VendorAppealType: afsOrder.VendorAppealType,
AppealType: int8(utils.Str2Int64WithDefault(afsOrder.VendorAppealType, 0)),
Flag: model.OrderFlagMaskTempJX,
}
outAfsOrder.Status = int(utils.Str2Int64WithDefault(afsOrder.VendorStatus, 0))
for _, x := range afsOrder.Skus {
orderSku := &model.OrderSkuFinancial{
Count: x.Count,
VendorSkuID: x.VendorSkuID,
SkuID: int(utils.Str2Int64WithDefault(x.VendorSkuID, 0)),
Name: x.Name,
}
if x.PromotionType != 0 && x.PromotionType != jdapi.PromotionTypeNormal {
orderSku.StoreSubName = utils.Int2Str(x.PromotionType)
}
outAfsOrder.Skus = append(outAfsOrder.Skus, orderSku)
}
}
return outAfsOrder, err
}
func callbackAfsMsg2Status(msg *CallbackMsg) *model.OrderStatus {
orderStatus := &model.OrderStatus{
VendorOrderID: msg.ThingID2, // 是售后单ID，不是订单ID，订单ID在RefVendorOrderID中
VendorID: model.VendorIDJX,
OrderType: model.OrderTypeAfsOrder,
RefVendorOrderID: msg.ThingID,
RefVendorID: model.VendorIDJX,
VendorStatus: msg.SubMsgType,
Status: int(utils.Str2Int64WithDefault(msg.SubMsgType, 0)),
StatusTime: utils.Timestamp2Time(msg.Timestamp),
Remark: "",
}
return orderStatus
}
func onAfsOrderMsg(msg *CallbackMsg) (err error) {
subMsgType := int(utils.Str2Int64WithDefault(msg.SubMsgType, 0))
status := callbackAfsMsg2Status(msg)
if subMsgType == model.AfsOrderStatusWait4Approve || subMsgType == model.AfsOrderStatusNew {
afsOrder, err2 := buildAfsOrder(msg)
if err = err2; err == nil {
err = partner.CurOrderManager.OnAfsOrderNew(afsOrder, status)
}
} else {
err = partner.CurOrderManager.OnOrderStatusChanged("", status)
}
return err
}
func postFakeAfsMsg(orderNo, afsOrderID string, status int) {
msg := &CallbackMsg{
AppKey: appKey,
MsgType: MsgTypeAfsOrder,
SubMsgType: utils.Int2Str(status),
ThingID: orderNo,
ThingID2: afsOrderID,
Timestamp: time.Now().Unix(),
}
utils.CallFuncAsync(func() {
OnCallbackMsg(msg)
})
}
func NotifyAfsOrderStatusChanged(order *model.AfsOrder, status int) (err error) {
orderMsg := *order
orderMsg.Status = status
if err = jxAPI.NotifyAfsOrderStatusChanged(&orderMsg); err == nil {
postFakeAfsMsg(orderMsg.VendorOrderID, orderMsg.AfsOrderID, orderMsg.Status)
}
return err
}

82
business/partner/purchase/jx/sku.go Normal file
View File

@@ -0,0 +1,82 @@
package jx
// 这里函数取得的信息，除了与自身实体相关的ID（比如PARENT ID），都已经转换成了本地ID了
import (
"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/business/partner"
)
// func (p *PurchaseHandler) CreateCategory(db *dao.DaoDB, cat *model.SkuCategory, userName string) (err error) {
// return err
// }
func (p *PurchaseHandler) GetAllCategories(ctx *jxcontext.Context, vendorOrgCode string) (cats []*partner.BareCategoryInfo, err error) {
return cats, err
}
// func (p *PurchaseHandler) UpdateCategory(db *dao.DaoDB, cat *model.SkuCategory, userName string) error {
// return nil
// }
// func (p *PurchaseHandler) DeleteCategory(db *dao.DaoDB, cat *model.SkuCategory, userName string) error {
// return nil
// }
// func (p *PurchaseHandler) ReorderCategories(db *dao.DaoDB, parentCatID int, userName string) (err error) {
// return err
// }
func (p *PurchaseHandler) CreateCategory2(ctx *jxcontext.Context, cat *dao.SkuStoreCatInfo) (err error) {
return err
}
func (p *PurchaseHandler) UpdateCategory2(ctx *jxcontext.Context, cat *dao.SkuStoreCatInfo) (err error) {
return err
}
func (p *PurchaseHandler) DeleteCategory2(ctx *jxcontext.Context, vendorOrgCode, vendorCatID string) (err error) {
return err
}
func (p *PurchaseHandler) ReorderCategories2(ctx *jxcontext.Context, vendorOrgCode, vendorParentCatID string, vendorCatIDList []string) (err error) {
return err
}
// func (p *PurchaseHandler) CreateSku(db *dao.DaoDB, sku *model.Sku, userName string) (err error) {
// return err
// }
// func (p *PurchaseHandler) ReadSku(ctx *jxcontext.Context, vendorOrgCode, vendorSkuID string) (skuNameExt *model.SkuNameExt, err error) {
// return skuNameExt, err
// }
// func (p *PurchaseHandler) UpdateSku(db *dao.DaoDB, sku *model.Sku, userName string) (err error) {
// return err
// }
// func (p *PurchaseHandler) DeleteSku(db *dao.DaoDB, sku *model.Sku, userName string) (err error) {
// return err
// }
func (p *PurchaseHandler) CreateSku2(ctx *jxcontext.Context, sku *dao.StoreSkuSyncInfo) (err error) {
return err
}
func (p *PurchaseHandler) UpdateSku2(ctx *jxcontext.Context, sku *dao.StoreSkuSyncInfo) (err error) {
return err
}
func (p *PurchaseHandler) DeleteSku2(ctx *jxcontext.Context, vendorOrgCode string, sku *partner.StoreSkuInfo) (err error) {
return err
}
func (p *PurchaseHandler) GetVendorCategories(ctx *jxcontext.Context) (vendorCats []*model.SkuVendorCategory, err error) {
return vendorCats, err
}
func (p *PurchaseHandler) GetSkus(ctx *jxcontext.Context, vendorOrgCode string, skuID int, vendorSkuID string) (skuNameList []*partner.SkuNameInfo, err error) {
return skuNameList, err
}

44
business/partner/purchase/jx/store.go Normal file
View File

@@ -0,0 +1,44 @@
package jx
import (
"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
"git.rosy.net.cn/jx-callback/business/jxutils/tasksch"
"git.rosy.net.cn/jx-callback/business/model/dao"
)
func (p *PurchaseHandler) ReadStore(ctx *jxcontext.Context, vendorOrgCode, vendorStoreID string) (storeDetail *dao.StoreDetail, err error) {
return storeDetail, err
}
// stoerIDs为nil表示所有
func (p *PurchaseHandler) UpdateStore(db *dao.DaoDB, storeID int, userName string) (err error) {
return err
}
func (p *PurchaseHandler) RefreshAllStoresID(ctx *jxcontext.Context, parentTask tasksch.ITask, isAsync bool) (hint string, err error) {
return hint, err
}
func (p *PurchaseHandler) GetStoreStatus(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string) (storeStatus int, err error) {
return storeStatus, err
}
func (p *PurchaseHandler) EnableAutoAcceptOrder(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, isSetEnable bool) (err error) {
return err
}
func (c *PurchaseHandler) UpdateStoreStatus(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, status int) (err error) {
return err
}
func (c *PurchaseHandler) UpdateStoreOpTime(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, opTimeList []int16) (err error) {
return err
}
func (c *PurchaseHandler) GetAllStoresVendorID(ctx *jxcontext.Context, vendorOrgCode string) (vendorStoreIDs []string, err error) {
return vendorStoreIDs, err
}
func (c *PurchaseHandler) UpdateStoreCustomID(ctx *jxcontext.Context, vendorOrgCode, vendorStoreID string, storeID int64) (err error) {
return err
}

36
business/partner/purchase/jx/store_sku2.go Normal file
View File

@@ -0,0 +1,36 @@
package jx
import (
"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
"git.rosy.net.cn/jx-callback/business/jxutils/tasksch"
"git.rosy.net.cn/jx-callback/business/partner"
)
func (p *PurchaseHandler) GetStoreSkusBatchSize(funcID int) (batchSize int) {
batchSize = 1
return batchSize
}
func (p *PurchaseHandler) GetStoreSkusBareInfo(ctx *jxcontext.Context, vendorOrgCode string, parentTask tasksch.ITask, storeID int, vendorStoreID string, inStoreSkuList []*partner.StoreSkuInfo) (outStoreSkuList []*partner.StoreSkuInfo, err error) {
return outStoreSkuList, err
}
func (p *PurchaseHandler) UpdateStoreSkusStatus(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, storeSkuList []*partner.StoreSkuInfo, status int) (successList []*partner.StoreSkuInfo, err error) {
return successList, err
}
func (p *PurchaseHandler) UpdateStoreSkusPrice(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, storeSkuList []*partner.StoreSkuInfo) (successList []*partner.StoreSkuInfo, err error) {
return successList, err
}
func (p *PurchaseHandler) UpdateStoreSkusStock(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, storeSkuList []*partner.StoreSkuInfo) (successList []*partner.StoreSkuInfo, err error) {
return successList, err
}
func (p *PurchaseHandler) CreateStoreSkusAct(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, storeSkuList []*partner.StoreSkuInfo) (failedList []*partner.StoreSkuInfoWithErr, err error) {
return failedList, err
}
func (p *PurchaseHandler) CancelActs(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, storeSkuList []*partner.StoreSkuInfo) (failedList []*partner.StoreSkuInfoWithErr, err error) {
return failedList, err
}