jx-callback/business/jxstore/financial/pay.go

package financial

import (
	"fmt"
	"git.rosy.net.cn/baseapi/platformapi/recharge_phone_bill"
	"git.rosy.net.cn/baseapi/platformapi/tonglianpayapi"
	"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/model/dao"
	"git.rosy.net.cn/jx-callback/business/q_bida"
	"git.rosy.net.cn/jx-callback/globals"
	"git.rosy.net.cn/jx-callback/globals/api"
)

type PayHandler struct {
	PayType       int `json:"-"` //支付方式
	Ctx           *jxcontext.Context
	Order         *model.Order
	VendorPayType string

	WxPayParam *WxPayParam `json:"wxPayParam"`
}

type WxPayParam struct {
	Prepayid  string `json:"prepayid"`
	Noncestr  string `json:"noncestr"`
	Timestamp string `json:"timestamp"`
	Package   string `json:"package"`
	Partnerid string `json:"partnerid"`
	Appid     string `json:"appid"`
	Sign      string `json:"sign"`
}

type PayHandlerInterface interface {
	CreatePay() (err error)
	CreateRefund() (err error)
}

func OnPayFinished(order *model.Order) (err error) {
	var db = dao.GetDB()
	globals.SugarLogger.Debugf("OnPayFinished begin modify account order: %v", utils.Format4Output(order, false))
	txDB, _ := dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db, txDB)
			panic(r)
		}
	}()
	//如果用户没有对应账单信息就给他生成一条
	userBill, err := dao.GetUserBill(db, order.UserID, "")
	if userBill == nil {
		globals.SugarLogger.Debugf("OnPayFinished 未找到该用户的账单 order: %v", utils.Format4Output(order, false))
		return fmt.Errorf("未找到该用户的账单！%v", order.UserID)
	}
	//根据订单类型来操作账户
	switch order.Type {
	case model.OrderTypePay:
		//如果是账户充值（发布任务等）
		//账户收入
		if err = AddIncomeUpdateAccount(txDB, userBill, model.BillTypeInvest, order.PayPrice, 0); err != nil {
			dao.Rollback(db, txDB)
		}
	default:
		globals.SugarLogger.Debugf("OnPayFinished 暂不支持此订单类型 order: %v", utils.Format4Output(order, false))
		return fmt.Errorf("暂不支持此订单类型！")
	}
	dao.Commit(db, txDB)
	globals.SugarLogger.Debugf("OnPayFinished end modify account ...")
	return err
}

func OnCashFinished(order *model.Order) (err error) {
	var (
		db = dao.GetDB()
	)
	globals.SugarLogger.Debugf("OnCashFinished begin modify account order: %v", utils.Format4Output(order, false))
	txDB, _ := dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db, txDB)
			panic(r)
		}
	}()
	//如果用户没有对应账单信息就给他生成一条
	userBill, err := dao.GetUserBill(db, order.UserID, "")
	if userBill == nil {
		globals.SugarLogger.Debugf("OnCashFinished 未找到该用户的账单 order: %v", utils.Format4Output(order, false))
		return fmt.Errorf("未找到该用户的账单！%v", order.UserID)
	}
	//根据订单类型来操作账户
	switch order.Type {
	case model.OrderTypeCash:
		//如果是账户提现
		//账户支出
		if err = AddExpendUpdateAccount(txDB, userBill, model.BillTypeCash, order.PayPrice, 0); err != nil {
			dao.Rollback(db, txDB)
		}
	default:
		globals.SugarLogger.Debugf("OnPayFinished 暂不支持此订单类型 order: %v", utils.Format4Output(order, false))
		return fmt.Errorf("暂不支持此订单类型！")
	}
	dao.Commit(db, txDB)
	globals.SugarLogger.Debugf("OnCashFinished end modify account ...")
	return err
}

//微信支付充值会员
func OnWXPayFinished(order *model.Order) (err error) {
	var (
		db      = dao.GetDB()
		ctx     *jxcontext.Context
		txDB, _ = dao.Begin(db)
	)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db, txDB)
			panic(r)
		}
	}()

	//判断是新会员充值还是老会员续费
	userMembers, err := dao.GetUserMember(db, order.UserID, model.MemberTypeNormal)
	if err != nil {
		return err
	}
	//根据订单类型来操作账户
	if order.Type == model.OrderTypePay {
		//为新会员生成会员信息并充值
		if len(userMembers) > 0 {
			if _, err := WXInvestMember(ctx, order.OrderType, order.UserID); err != nil {
				return err
			}
		} else {
			if _, err := WXInvestMemberNew(ctx, order.OrderType, order.UserID); err != nil {
				return err
			}
		}
		order.Status = model.OrderStatusFinished
		//更新order状态
		if _, err := dao.UpdateEntityTx(txDB, &order, "Status"); err != nil {
			dao.Rollback(db, txDB)
			return err
		}
	} else {
		return fmt.Errorf("暂不支持此订单类型！")
	}
	return err
}

// OnWxPayTelephone 微信充值话费
func OnWxPayTelephone(order *model.Order) error {
	orderNumber, err := api.TelephoneAPI.RechargePhoneBill(&recharge_phone_bill.RechargePhoneBillBase{
		FlowCode:    order.FlowCode,
		Mobile:      order.Mobile,
		OrderNumber: order.OrderID,
		CallbackURL: "http://callback.rsm.jxc4.com/recharge/msg",
		ChargeType:  "1",
	})
	if err != nil {
		order.Comment = err.Error()
		order.RechargeStatus = -1 // 充值失败
	}
	order.RechargeStatus = 1 // 充值中
	order.Comment = orderNumber
	//更新order状态
	order.Status = model.OrderStatusFinished
	if _, err := dao.UpdateEntity(dao.GetDB(), &order, "Status", "RechargeStatus", "Comment"); err != nil {
		return err
	}
	return nil
}

// OnWxPaySendPage 发快递支付方
func OnWxPaySendPage(db *dao.DaoDB, order *model.Order, call *tonglianpayapi.CallBackResult, payStatus int) (err error) {
	txdb, _ := dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			panic(r)
		}
	}()
	order.TransactionID = call.TrxID
	order.Status = 110 //支付成功状态
	if _, err := dao.UpdateEntityTx(txdb, order, "TransactionID", "Status"); err != nil {
		dao.Rollback(db, txdb)
		return err
	}
	userOrder := model.UserVendorOrder{LocalWayBill: order.OrderID}
	if err := dao.GetEntity(db, &userOrder, "LocalWayBill"); err != nil {
		dao.Rollback(db, txdb)
		return err
	}
	userOrder.OrderStatus = payStatus
	if _, err := dao.UpdateEntityTx(txdb, &userOrder, "OrderStatus"); err != nil {
		dao.Rollback(db, txdb)
		return err
	}
	//1-余额,2-微信,5-混合
	if order.PayMethod == model.OrderPayMethodMix {
		userBill, err := dao.GetUserBill(db, order.UserID, "")
		if err != nil {
			return err
		}
		//创建混合支付账单
		totalPrice := order.PayPrice + userBill.AccountBalance
		if err := AddMixPay(txdb, order.OrderID, userBill.AccountBalance, totalPrice, 1); err != nil {
			dao.Rollback(db, txdb)
			return err
		}
		//余额清空
		if err := dao.UpdateUserBill(order.UserID, 0); err != nil {
			dao.Rollback(db, txdb)
			return err
		}
	}
	dao.Commit(db, txdb)
	if call.TrxStatus == tonglianpayapi.TrxStatusSuccess {
		switch order.OrderType {
		case model.PayType4Express:
			err = q_bida.CreateOrder2QBiDa(&userOrder, order.OrderID)
		}
	}
	return err
}