1046 lines
32 KiB
Go
1046 lines
32 KiB
Go
package lakala
|
||
|
||
import (
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"git.rosy.net.cn/baseapi/platformapi/lakala"
|
||
"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/partner"
|
||
"git.rosy.net.cn/jx-callback/globals"
|
||
"git.rosy.net.cn/jx-callback/globals/api"
|
||
"strings"
|
||
"time"
|
||
)
|
||
|
||
//#region 进件相关API
|
||
|
||
// LaKaLaApplyContract 拉卡拉申请签约合同
|
||
func LaKaLaApplyContract(ctx *jxcontext.Context, apply *lakala.ApplyContractParam, storeID int) (*lakala.ApplyContract, error) {
|
||
apply.OrderNo = lakala.GetOrderNumber(10)
|
||
apply.RetUrl = lakala.ApplyContractCallback
|
||
contractObj, err := api.LaKaLaApi.ApplyElectronicContract(apply)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
if contractObj.RespData != nil {
|
||
db := dao.GetDB()
|
||
incomingObj := &model.LakalaContract{
|
||
StoreId: storeID,
|
||
ContractId: contractObj.RespData.OrderNo,
|
||
ContractApplyId: utils.Int64ToStr(contractObj.RespData.EcApplyId),
|
||
ContractStatus: "WAIT_AUDIT ",
|
||
ApplyType: apply.EcTypeCode,
|
||
}
|
||
dao.WrapAddIDCULEntity(incomingObj, ctx.GetUserName())
|
||
if err = dao.CreateEntity(db, incomingObj); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
}
|
||
return contractObj, nil
|
||
}
|
||
|
||
// LaKaLaApplyContractByPeople 生气人工审核 ApplyElectronicContractByPeople
|
||
func LaKaLaApplyContractByPeople(storeId int, apply *lakala.ApplyContractByPeople) (string, error) {
|
||
apply.OrderNo = lakala.GetOrderNumber(8)
|
||
apply.RetUrl = lakala.ApplyContractByPeopleCallback
|
||
err := api.LaKaLaApi.ApplyElectronicContractByPeople(apply)
|
||
if err != nil {
|
||
return "", fmt.Errorf("申请人工审核失败:%v", err)
|
||
}
|
||
|
||
contract, err := dao.GetStoreContract(dao.GetDB(), storeId, "", utils.Int64ToStr(apply.EcApplyId))
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
contract.ContractStatus = "people"
|
||
dao.UpdateEntity(dao.GetDB(), contract, "ContractStatus")
|
||
return "", nil
|
||
}
|
||
|
||
// QueryElectronicContract 拉卡拉签约合同查询
|
||
func QueryElectronicContract(orderNo string, orgId int, ecApplyId string, storeID int) (*lakala.ElectronicContractStatus, error) {
|
||
db := dao.GetDB()
|
||
merchantInfo, err := dao.GetStoreContract(db, storeID, orderNo, "")
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
contractObj, err := api.LaKaLaApi.QueryElectronicContract(orderNo, orgId, ecApplyId)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
merchantInfo.ContractStatus = contractObj.AuditStatus
|
||
dao.UpdateEntity(db, merchantInfo, "ContractStatus")
|
||
|
||
return contractObj, nil
|
||
}
|
||
|
||
// LaKaLaInComing 商户进件
|
||
func LaKaLaInComing(ctx *jxcontext.Context, incoming *lakala.MerchantIncomingReq, storeId int) (string, error) {
|
||
merchantNo, status, err := api.LaKaLaApi.MerchantIncoming(incoming)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
incomingObj := &model.LakalaIncoming{
|
||
StoreId: storeId,
|
||
MerchantNo: merchantNo,
|
||
MerchantStatus: status,
|
||
}
|
||
dao.WrapAddIDCULEntity(incomingObj, ctx.GetUserName())
|
||
|
||
if err = dao.CreateEntity(dao.GetDB(), incomingObj); err != nil {
|
||
return "", err
|
||
}
|
||
|
||
return status, nil
|
||
}
|
||
|
||
// GetMerchantInfo 获取门店商户详情
|
||
func GetMerchantInfo(merchantNo string) (*lakala.MerchantObj, error) {
|
||
result, err := api.LaKaLaApi.GetMerchantInfo(merchantNo)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
db := dao.GetDB()
|
||
merchantInfo, err := dao.GetStoreInfoByMerchantID(db, merchantNo, 0, "", "")
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
if merchantInfo.TermNo == "" {
|
||
merchantInfo.TermNo = result.Customer.TermNo
|
||
}
|
||
merchantInfo.MerchantStatus = result.Customer.CustomerStatus
|
||
if merchantInfo.MerchantNo2 == "" {
|
||
merchantInfo.MerchantNo2 = result.Customer.ExternalCustomerNo
|
||
}
|
||
dao.UpdateEntity(db, merchantInfo, "TermNo", "MerchantStatus", "MerchantNo2")
|
||
|
||
return result, err
|
||
}
|
||
|
||
// GetPosTerimeInfo 获取门店商户详情
|
||
func GetPosTerimeInfo(posSn string) (*lakala.TerminalInfo, error) {
|
||
result, err := api.LaKaLaApi.GetTerminalInfo(posSn)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return result, err
|
||
}
|
||
|
||
// QueryCityCode 获取拉卡拉code列表
|
||
func QueryCityCode(parentCode string) ([]*lakala.OrganizationList, error) {
|
||
return api.LaKaLaApi.GetOrganizationCode(parentCode)
|
||
}
|
||
|
||
// QueryBankList 获取地方银行列表
|
||
func QueryBankList(areaCode, bankName string) ([]*lakala.BankListResult, error) {
|
||
if areaCode == "" {
|
||
return nil, fmt.Errorf("地区编码不能为空")
|
||
}
|
||
return api.LaKaLaApi.GetBankList(areaCode, bankName)
|
||
}
|
||
|
||
// GetCustomerCategory 获取门店类别
|
||
func GetCustomerCategory(businessScene, parentCode string) ([]*lakala.BusinessResult, error) {
|
||
return api.LaKaLaApi.GetMerchantMcc(businessScene, parentCode)
|
||
}
|
||
|
||
// MerchantFeeQuery 商户费率查询
|
||
func MerchantFeeQuery(customerNo, productCode string) (*lakala.MerchantFeeResp, error) {
|
||
return api.LaKaLaApi.MerchantFeeQuery(customerNo, productCode)
|
||
}
|
||
|
||
// MerchantFeeChange 商户费率信息变更
|
||
func MerchantFeeChange(param *lakala.FeeChangeReq, customerNo string) (int64, string, error) {
|
||
changeId, status, err := api.LaKaLaApi.MerchantFeeChange(param, customerNo)
|
||
if err != nil {
|
||
return 0, "", err
|
||
}
|
||
|
||
if changeId != model.NO {
|
||
db := dao.GetDB()
|
||
merchant, err := dao.GetStoreInfoByMerchantID(db, customerNo, 0, "", "")
|
||
if err != nil {
|
||
return 0, "", err
|
||
}
|
||
merchant.FeeId = utils.Int64ToStr(changeId)
|
||
merchant.FeeStatus = status
|
||
dao.UpdateEntity(db, merchant, "FeeId", "FeeStatus")
|
||
}
|
||
|
||
return changeId, status, err
|
||
}
|
||
|
||
// UpdateSettleInfo 查询/修改结算信息
|
||
func UpdateSettleInfo(customerNo string, param *lakala.UpdateSettleInfoReq) (*lakala.UpdateSettleInfoReq, string, error) {
|
||
updateResult, queryResult, err := api.LaKaLaApi.UpdateSettleInfo(customerNo, param)
|
||
if err != nil {
|
||
return nil, "", err
|
||
}
|
||
|
||
db := dao.GetDB()
|
||
merchant, err := dao.GetStoreInfoByMerchantID(db, customerNo, 0, "", "")
|
||
if err != nil {
|
||
return nil, "", err
|
||
}
|
||
if param == nil {
|
||
return queryResult, "", err
|
||
}
|
||
|
||
merchant.SettleId = utils.Int64ToStr(updateResult.ReviewRelatedId)
|
||
merchant.SettleStatus = updateResult.Message
|
||
dao.UpdateEntity(db, merchant, "SettleID", "SettleStatus")
|
||
return nil, updateResult.Message, nil
|
||
}
|
||
|
||
// MerchantUpdateBaseInfo 基本信息变更
|
||
func MerchantUpdateBaseInfo(customerNo string, param *lakala.UpdateBaseInfoReq) (string, error) {
|
||
basic, err := api.LaKaLaApi.UpdateBaseInfo(customerNo, param)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
if basic.ReviewRelatedId != model.NO {
|
||
db := dao.GetDB()
|
||
merchant, err := dao.GetStoreInfoByMerchantID(db, customerNo, 0, "", "")
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
merchant.BasicId = utils.Int64ToStr(basic.ReviewRelatedId)
|
||
merchant.BasicStatus = basic.Message
|
||
dao.UpdateEntity(db, merchant, "BasicId", "BasicStatus")
|
||
return merchant.BasicId, nil
|
||
}
|
||
|
||
return "", fmt.Errorf("UpdateBaseInfo 修改异常,联系管理员")
|
||
}
|
||
|
||
// QueryExamine 查询门店变更审核状态
|
||
func QueryExamine(merchantId, reviewRelatedId string) (map[string]string, error) {
|
||
reviewPass, reviewResult, err := api.LaKaLaApi.QueryMerchantReviewStatus(reviewRelatedId)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
db := dao.GetDB()
|
||
merchant, err := dao.GetStoreInfoByMerchantID(db, merchantId, 0, "", "")
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
updateField := make([]string, 0, 0)
|
||
switch reviewRelatedId {
|
||
case merchant.FeeId:
|
||
merchant.FeeStatus = reviewPass
|
||
updateField = append(updateField, "FeeStatus")
|
||
case merchant.SettleId:
|
||
merchant.SettleStatus = reviewPass
|
||
updateField = append(updateField, "SettleStatus")
|
||
case merchant.BasicId:
|
||
merchant.BasicStatus = reviewPass
|
||
updateField = append(updateField, "BasicStatus")
|
||
case merchant.LicenseId:
|
||
merchant.LicenseStatus = reviewPass
|
||
updateField = append(updateField, "LicenseStatus")
|
||
}
|
||
if len(updateField) != 0 {
|
||
dao.UpdateEntity(db, merchant, updateField...)
|
||
}
|
||
|
||
return map[string]string{"status": reviewPass, "desc": reviewResult}, err
|
||
}
|
||
|
||
// CheckIsUploadPhoto 查看门店是否需要补充照片
|
||
func CheckIsUploadPhoto(customerNo string) (*lakala.OpenCustomerExtImgVo, error) {
|
||
return api.LaKaLaApi.CheckImgIsSupplement(customerNo)
|
||
}
|
||
|
||
// ImgSupplement 补充照片
|
||
func ImgSupplement(param *lakala.ImgSupplementReq) error {
|
||
if param.ExtCustomerNo == "" {
|
||
return fmt.Errorf("商户号不能为空")
|
||
}
|
||
return api.LaKaLaApi.ImgSupplement(param)
|
||
}
|
||
|
||
// GetMerchantReportStatus 查看银联报备状态
|
||
func GetMerchantReportStatus(orgCode, agentNo, customerNo string) (*lakala.OpenUnionpayMerchantVo, error) {
|
||
return api.LaKaLaApi.GetMerchantReportStatus(orgCode, agentNo, customerNo)
|
||
}
|
||
|
||
// GetMerchantTerminal 获取终端报备信息
|
||
func GetMerchantTerminal(orgCode, agentNo, externalCustomerNo, posSn string) (*lakala.OpenUnionpayTermVo, error) {
|
||
return api.LaKaLaApi.GetMerchantTerminal(orgCode, agentNo, externalCustomerNo, posSn)
|
||
}
|
||
|
||
// SupplementBusinessLicense 变更营业执照
|
||
func SupplementBusinessLicense(param *lakala.BusinessLicenseReq) (string, error) {
|
||
licenseId, status, err := api.LaKaLaApi.SupplementBusinessLicense(param)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
db := dao.GetDB()
|
||
merchant, err := dao.GetStoreInfoByMerchantID(db, param.ExternalCustomerNo, 0, "", "")
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
merchant.LicenseId = licenseId
|
||
merchant.LicenseStatus = status
|
||
if _, err = dao.UpdateEntity(db, merchant, "LicenseId", "LicenseStatus"); err != nil {
|
||
return "", err
|
||
}
|
||
|
||
return status, nil
|
||
}
|
||
|
||
// UnionPayMerInfo 联防机制查询(失信人名单)
|
||
func UnionPayMerInfo(larName, larIdCard string) (*lakala.DishonestPerson, error) {
|
||
return api.LaKaLaApi.UnionPayMerInfo(larName, larIdCard)
|
||
}
|
||
|
||
//#endregion
|
||
|
||
//#region 分账相关
|
||
|
||
// CreateSeparate 创建分账门店
|
||
func CreateSeparate(req *lakala.CreateSeparateReq) (string, error) {
|
||
req.OrderNo = lakala.GetOrderNumber(8)
|
||
req.RetUrl = lakala.CallbackLaKaLaShopUrl
|
||
applyID, err := api.LaKaLaApi.CreateSeparate(req)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
db := dao.GetDB()
|
||
merchant, err := dao.GetStoreInfoByMerchantID(db, req.MerInnerNo, 0, "", "")
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
merchant.OrderID = req.OrderNo
|
||
merchant.ApplyID = applyID
|
||
merchant.ThingType = model.ThingTypeSeparate
|
||
merchant.Operate = model.OperateTypeCreate
|
||
merchant.OperateStatus = model.OperateStatusReview
|
||
merchant.Remark = fmt.Sprintf("创建分账:%s", req.OrderNo)
|
||
if _, err = dao.UpdateEntity(db, merchant, "OrderID", "ApplyID", "ThingType", "Operate", "OperateStatus", "Remark"); err != nil {
|
||
return "", err
|
||
}
|
||
|
||
return applyID, nil
|
||
}
|
||
|
||
// SeparateModify 变更分账门店
|
||
func SeparateModify(param *lakala.SeparateModifyReq) (string, error) {
|
||
db := dao.GetDB()
|
||
merchant, err := dao.GetStoreInfoByMerchantID(db, param.MerInnerNo, 0, "", "")
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
if merchant.OperateStatus == model.OperateStatusReview {
|
||
return "", fmt.Errorf("有待审核项目,请审核完成后再变更")
|
||
}
|
||
|
||
param.OrderNo = lakala.GetOrderNumber(8)
|
||
param.RetUrl = lakala.CallbackLaKaLaShopUrl
|
||
applyID, err := api.LaKaLaApi.SeparateModify(param)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
merchant.OrderID = param.OrderNo
|
||
merchant.ApplyID = applyID
|
||
merchant.ThingType = model.ThingTypeSeparate
|
||
merchant.Operate = model.OperateTypeUpdate
|
||
merchant.OperateStatus = model.OperateStatusReview
|
||
merchant.Remark = fmt.Sprintf("修改分账:%s", param.OrderNo)
|
||
if _, err = dao.UpdateEntity(db, merchant, "OrderID", "ApplyID", "ThingType", "Operate", "OperateStatus"); err != nil {
|
||
return "", err
|
||
}
|
||
|
||
return applyID, nil
|
||
}
|
||
|
||
// SeparateQuery 分账信息查询
|
||
func SeparateQuery(merInnerNo, orgCode string) (*lakala.SeparateQueryResp, error) {
|
||
param := &lakala.SeparateQueryReq{
|
||
Version: lakala.Version2,
|
||
OrderNo: lakala.GetOrderNumber(8),
|
||
OrgCode: orgCode,
|
||
MerCupNo: merInnerNo,
|
||
}
|
||
return api.LaKaLaApi.SeparateQuery(param)
|
||
}
|
||
|
||
// CreateSeparateRecipient 创建分账接收方
|
||
func CreateSeparateRecipient(ctx *jxcontext.Context, param *lakala.CreateSeparateRecipientReq) (string, error) {
|
||
param.OrderNo = lakala.GetOrderNumber(8)
|
||
receiverNo, err := api.LaKaLaApi.CreateSeparateRecipient(param)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
receiver := &model.LakalaRecipient{}
|
||
dao.WrapAddIDCULEntity(receiver, ctx.GetUserName())
|
||
receiver.ReceiverNo = receiverNo
|
||
receiver.ReceiverName = param.ReceiverName
|
||
receiver.OrgCode = param.OrgCode
|
||
receiver.Status = model.ReceiverStatusValid
|
||
receiver.Remark = fmt.Sprintf("创建分账接收方:%s", param.OrderNo)
|
||
|
||
if err = dao.CreateEntity(dao.GetDB(), receiver); err != nil {
|
||
return "", err
|
||
}
|
||
return receiverNo, err
|
||
}
|
||
|
||
// UpdateSeparateRecipient 修改分账接收方
|
||
func UpdateSeparateRecipient(param *lakala.UpdateSeparateRecipientReq) (string, error) {
|
||
param.OrderNo = lakala.GetOrderNumber(8)
|
||
orderNo, err := api.LaKaLaApi.UpdateSeparateRecipient(param)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
db := dao.GetDB()
|
||
recipient, err := dao.GetRecipientByMerchantID(db, param.ReceiverNo)
|
||
recipient.ReceiverName = param.ReceiverName
|
||
recipient.Status = param.Status
|
||
recipient.Remark = fmt.Sprintf("修改分账接收方:%s", param.OrderNo)
|
||
|
||
_, err = dao.UpdateEntity(db, recipient, "ReceiverName", "Status", "Remark")
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
return orderNo, nil
|
||
}
|
||
|
||
// QuerySeparateRecipient 分账方详细信息查询
|
||
func QuerySeparateRecipient(orderNo, receiverNo string) (*lakala.QuerySeparateRecipientResp, error) {
|
||
return api.LaKaLaApi.QuerySeparateRecipient(orderNo, receiverNo)
|
||
}
|
||
|
||
// ApplyBind 申请绑定分账关系
|
||
func ApplyBind(param *lakala.SeparateApplyBindReq) (*lakala.SeparateApplyBindResp, error) {
|
||
param.OrderNo = lakala.GetOrderNumber(8)
|
||
param.RetUrl = lakala.CallbackLaKaLaSeparateBindUrl
|
||
applyInfo, err := api.LaKaLaApi.ApplyBind(param)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
db := dao.GetDB()
|
||
merchant, err := dao.GetStoreInfoByMerchantID(db, param.MerInnerNo, 0, "", "")
|
||
if err != nil {
|
||
return applyInfo, err
|
||
}
|
||
bind := map[string]*model.BindAccountObj{param.ReceiverNo: &model.BindAccountObj{
|
||
ApplyId: utils.Int64ToStr(applyInfo.RespData.ApplyId),
|
||
Status: "0",
|
||
Remark: "新增绑定",
|
||
}}
|
||
bodyBind, _ := json.Marshal(bind)
|
||
merchant.BindAccount = string(bodyBind)
|
||
_, err = dao.UpdateEntity(db, merchant, "BindAccount")
|
||
if err != nil {
|
||
return applyInfo, err
|
||
}
|
||
return applyInfo, nil
|
||
}
|
||
|
||
// SeparateUnBind 申请解除绑定
|
||
func SeparateUnBind(param *lakala.SeparateUnBindReq) error {
|
||
param.OrderNo = lakala.GetOrderNumber(8)
|
||
param.RetUrl = lakala.CallbackLaKaLaSeparateBindUrl
|
||
applyId, err := api.LaKaLaApi.SeparateUnBind(param)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
db := dao.GetDB()
|
||
merchant, err := dao.GetStoreInfoByMerchantID(db, param.MerInnerNo, 0, "", "")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
unBind := make(map[string]*model.BindAccountObj, 0)
|
||
if err = json.Unmarshal([]byte(merchant.BindAccount), &unBind); err != nil {
|
||
return err
|
||
}
|
||
|
||
unBind[param.ReceiverNo] = &model.BindAccountObj{
|
||
ApplyId: applyId,
|
||
Status: "0",
|
||
Remark: "解除绑定",
|
||
}
|
||
|
||
bodyBind, _ := json.Marshal(unBind)
|
||
merchant.BindAccount = string(bodyBind)
|
||
if _, err = dao.UpdateEntity(db, merchant, "BindAccount"); err != nil {
|
||
return err
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// SeparateQueryAmt 可分账金额查询
|
||
func SeparateQueryAmt(ctx *jxcontext.Context, merchantNo, logDate, logNo, vendorOrderId string) (*lakala.SeparateQueryAmtResp, error) {
|
||
result, err := api.LaKaLaApi.SeparateQueryAmt(merchantNo, logNo, logDate)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
separate, err := dao.GetSeparateAmtByOrderID(vendorOrderId, "", logNo)
|
||
if separate != nil {
|
||
separate.TotalAmt = result.TotalSeparateAmt
|
||
separate.CanAmt = result.CanSeparateAmt
|
||
dao.UpdateEntity(dao.GetDB(), separate, "TotalAmt", "ActualSeparateAmt")
|
||
} else {
|
||
order, _ := partner.CurOrderManager.LoadOrder(vendorOrderId, model.VendorIDJX)
|
||
separate = &model.LakalaSeparateAmt{
|
||
MerchantNo: merchantNo,
|
||
VendorOrderID: vendorOrderId,
|
||
StoreId: order.JxStoreID,
|
||
CmdType: lakala.SeparateType_SEPATRATE,
|
||
Status: "1",
|
||
LogNo: logNo,
|
||
LogDate: time.Now(),
|
||
SeparateNo: "",
|
||
OutSeparateNo: "",
|
||
CalType: "",
|
||
FinishDate: "",
|
||
TotalAmt: result.TotalSeparateAmt,
|
||
CanAmt: result.CanSeparateAmt,
|
||
TotalFeeAmt: "",
|
||
FinalStatus: "",
|
||
DetailData: "",
|
||
Remark: "",
|
||
}
|
||
dao.WrapAddIDCULEntity(separate, ctx.GetUserName())
|
||
err = dao.CreateEntity(dao.GetDB(), separate)
|
||
}
|
||
|
||
return result, err
|
||
}
|
||
|
||
// Separate 分账
|
||
func Separate(ctx *jxcontext.Context, param *lakala.OrderSeparateReq, vendorOrderId string) (*lakala.OrderSeparateResp, error) {
|
||
separateObj, err := dao.GetSeparateAmtByOrderID(vendorOrderId, "", param.LogNo)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
param.NotifyUrl = lakala.CallbackLaKaLaSeparateUrl
|
||
globals.SugarLogger.Debugf("------Separate param--:%s", utils.Format4Output(param, false))
|
||
resp, err := api.LaKaLaApi.Separate(param)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
globals.SugarLogger.Debugf("------Separate resp--:%s", utils.Format4Output(resp, false))
|
||
recv, _ := json.Marshal(param.RecvDatas)
|
||
separateObj.OutSeparateNo = param.OutSeparateNo
|
||
separateObj.SeparateNo = resp.RespData.SeparateNo
|
||
separateObj.CalType = param.CalType
|
||
separateObj.Status = resp.RespData.Status
|
||
separateObj.Remark += `->分账`
|
||
separateObj.DetailData = string(recv)
|
||
separateObj.CmdType = lakala.SeparateType_SEPATRATE
|
||
t, err := time.Parse("20060102", param.LogDate)
|
||
if err != nil {
|
||
t = time.Now()
|
||
}
|
||
separateObj.LogDate = t
|
||
globals.SugarLogger.Debugf("------Separate separateObj--:%s", utils.Format4Output(separateObj, false))
|
||
_, err = dao.UpdateEntity(dao.GetDB(), separateObj)
|
||
globals.SugarLogger.Debugf("------Separate err--:%v", err)
|
||
|
||
return resp, err
|
||
}
|
||
|
||
// SeparateResultQuery 分账结果查询
|
||
func SeparateResultQuery(merchantNo, separateNo string) (*lakala.SeparateResultQueryResp, error) {
|
||
result, err := api.LaKaLaApi.SeparateResultQuery(merchantNo, separateNo)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
db := dao.GetDB()
|
||
recordsObj, err := dao.GetSeparateRecords(db, merchantNo, separateNo, result.CmdType)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
recordsObj.UpdatedAt = time.Now()
|
||
recordsObj.ActualSeparateAmt = result.ActualSeparateAmt
|
||
recordsObj.TotalFeeAmt = result.TotalFeeAmt
|
||
recordsObj.Status = result.Status
|
||
recordsObj.SeparateNo = result.SeparateNo
|
||
recordsObj.OutSeparateNo = result.OutSeparateNo
|
||
recordsObj.TotalAmt = result.TotalAmt
|
||
recv := make([]*lakala.RecvDatasParam, 0, 0)
|
||
for _, v := range result.DetailDatas {
|
||
recv = append(recv, &lakala.RecvDatasParam{
|
||
RecvNo: v.RecvNo,
|
||
SeparateValue: utils.Int64ToStr(v.Amt),
|
||
})
|
||
}
|
||
recvObj, _ := json.Marshal(recv)
|
||
recordsObj.DetailData = string(recvObj)
|
||
if _, err = dao.UpdateEntity(db, recordsObj, "DetailData", "Status", "TotalFeeAmt", "UpdatedAt", "TotalAmt", "ActualSeparateAmt", "DetailData"); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return result, nil
|
||
}
|
||
|
||
// SeparateCancel 订单分账撤销
|
||
func SeparateCancel(merchantNo, separateNo string) (*lakala.SeparateCancelResp, error) {
|
||
db := dao.GetDB()
|
||
separateAmt, err := dao.GetSeparateRecords(db, merchantNo, separateNo, "")
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
result, err := api.LaKaLaApi.SeparateCancel(&lakala.SeparateCancelReq{
|
||
MerchantNo: merchantNo,
|
||
OriginSeparateNo: separateNo,
|
||
OriginOutSeparateNo: "",
|
||
OutSeparateNo: lakala.GetOrderNumber(8),
|
||
TotalAmt: separateAmt.TotalAmt,
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
separateAmt.CmdType = lakala.SeparateType_CANCEL
|
||
separateAmt.Status = result.RespData.Status
|
||
//separateAmt.SeparateNo = result.RespData.SeparateNo
|
||
separateAmt.Remark += "->分账撤销"
|
||
|
||
if _, err = dao.UpdateEntity(db, separateAmt, "CmdType", "Status", "Remark"); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return result, err
|
||
}
|
||
|
||
// SeparateFallBack 分账退回
|
||
func SeparateFallBack(merchantNo, separateNo, reason string) (*lakala.SeparateFallResp, error) {
|
||
db := dao.GetDB()
|
||
separateAmt, err := dao.GetSeparateRecords(db, merchantNo, separateNo, "")
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
recv := make([]*lakala.RecvDatasParam, 0, 0)
|
||
if err = json.Unmarshal([]byte(separateAmt.DetailData), &recv); err != nil {
|
||
return nil, err
|
||
}
|
||
if len(recv) == 0 {
|
||
return nil, fmt.Errorf("数据异常[%s],未获取到分账详细", separateNo)
|
||
}
|
||
|
||
isBack := false
|
||
for _, v := range recv {
|
||
if strings.Contains(v.RecvNo, "SR") {
|
||
isBack = true
|
||
}
|
||
}
|
||
//先了解分账回退这个功能是怎么用的，多次跟咱们同步。分账回退这个接口，用的场景是订单发生退款时，
|
||
//把已经分给接收方（SR开头）的资金回退给商户，用作资金平账的。因为退款是从商户收款账户资金里退的
|
||
//822开头的就是商家自己不需要回退
|
||
if !isBack {
|
||
return nil, nil
|
||
}
|
||
|
||
param := &lakala.SeparateFallReq{
|
||
MerchantNo: merchantNo,
|
||
OriginSeparateNo: separateNo,
|
||
OutSeparateNo: lakala.GetOrderNumber(8),
|
||
FallbackReason: reason,
|
||
TotalAmt: separateAmt.TotalAmt,
|
||
OriginRecvDatas: nil,
|
||
}
|
||
originRecvDatas := make([]*lakala.OriginRecvDatas, 0, len(recv))
|
||
for _, v := range recv {
|
||
originRecvDatas = append(originRecvDatas, &lakala.OriginRecvDatas{
|
||
RecvNo: v.RecvNo,
|
||
Amt: v.SeparateValue,
|
||
})
|
||
}
|
||
param.OriginRecvDatas = originRecvDatas
|
||
|
||
result, err := api.LaKaLaApi.SeparateFallBack(param)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
separateAmt.CmdType = lakala.Separate_FALLBACK
|
||
separateAmt.Status = result.RespData.Status
|
||
separateAmt.Remark += "->分账退回"
|
||
dao.UpdateEntity(db, separateAmt, "CmdType", "Status", "Remark")
|
||
|
||
return result, nil
|
||
}
|
||
|
||
func GetCardBin(orgCode, cardNo string) (*lakala.BinInfo, error) {
|
||
result, err := api.LaKaLaApi.QueryCarBin(lakala.GetOrderNumber(8), orgCode, cardNo)
|
||
return result, err
|
||
}
|
||
|
||
// SaveAuthentication 支付宝/微信认证
|
||
func SaveAuthentication(param *lakala.AuthenticationInfo, authType string) error {
|
||
return api.LaKaLaApi.SaveAuthentication(param, authType)
|
||
}
|
||
|
||
// UpdateAuthentication 修改认证
|
||
func UpdateAuthentication(param *lakala.UpdateAuthentication, authType string) error {
|
||
return api.LaKaLaApi.UpdateAuthentication(param, authType)
|
||
}
|
||
|
||
// QueryAuthentication 认证查询
|
||
func QueryAuthentication(param *lakala.QueryAuthentication, authType string) (*lakala.QueryAuthenticationResp, error) {
|
||
return api.LaKaLaApi.QueryAuthentication(param, authType)
|
||
}
|
||
|
||
// AccountStatusQuery 开户状态查询
|
||
func AccountStatusQuery(tradeMode, subMerchantId, merchantNo string) (map[string]interface{}, error) {
|
||
return api.LaKaLaApi.AccountStatusQuery(tradeMode, subMerchantId, merchantNo)
|
||
}
|
||
|
||
// SubMerchantInfoQuery 报备查询
|
||
func SubMerchantInfoQuery(merInnerNo, merCupNo string) ([]*lakala.SubMerchantInfoQueryResp, error) {
|
||
if merInnerNo == "" && merCupNo == "" {
|
||
return nil, errors.New("内部商户号和银联号必须填写一个")
|
||
}
|
||
param := &lakala.SubMerchantInfoQueryReq{
|
||
Version: "1.0",
|
||
OrderNo: lakala.GetOrderNumber(8),
|
||
OrgCode: lakala.OrgCode,
|
||
MerInnerNo: "",
|
||
MerCupNo: "",
|
||
}
|
||
if merInnerNo != "" {
|
||
param.MerInnerNo = merInnerNo
|
||
} else {
|
||
param.MerCupNo = merCupNo
|
||
}
|
||
return api.LaKaLaApi.SubMerchantInfoQuery(param)
|
||
}
|
||
|
||
//#endregion
|
||
|
||
//#region 订单相关
|
||
|
||
// CreateOrder 创建拉卡拉交易订单
|
||
func CreateOrder(ctx *jxcontext.Context, vendorOrderID, merchantNo string, vendorId int) (*lakala.CreateOrderResp, error) {
|
||
order, err := partner.CurOrderManager.LoadOrder(vendorOrderID, vendorId)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
param := &lakala.CreateOrderReq{
|
||
OutOrderNo: order.VendorOrderID,
|
||
MerchantNo: merchantNo,
|
||
TotalAmount: order.ActualPayPrice,
|
||
OrderEfficientTime: time.Now().Add(1 * time.Hour).Format("20060102150405"),
|
||
OrderInfo: fmt.Sprintf("门店扫码订单:%d", order.OrderSeq),
|
||
NotifyUrl: lakala.OrderStatusCallback,
|
||
SupportRepeatPay: 1,
|
||
}
|
||
|
||
result, err := api.LaKaLaApi.CreateOrder(param)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
orderPay := &model.OrderPay{
|
||
PayOrderID: result.PayOrderNo,
|
||
PayType: model.PayTypeLaKaLa,
|
||
VendorPayType: lakala.PayWayAPP,
|
||
TransactionID: "",
|
||
VendorOrderID: order.VendorOrderID,
|
||
VendorID: order.VendorID,
|
||
Status: 0,
|
||
PayCreatedAt: time.Now(),
|
||
PrepayID: result.PayOrderNo,
|
||
CodeURL: "",
|
||
TotalFee: int(order.ActualPayPrice),
|
||
}
|
||
dao.WrapAddIDCULDEntity(orderPay, ctx.GetUserName())
|
||
err = dao.CreateEntity(dao.GetDB(), orderPay)
|
||
|
||
separate := &model.LakalaSeparateAmt{
|
||
MerchantNo: merchantNo,
|
||
VendorOrderID: order.VendorOrderID,
|
||
StoreId: order.JxStoreID,
|
||
CmdType: lakala.SeparateType_SEPATRATE,
|
||
Status: "1",
|
||
LogNo: "",
|
||
LogDate: time.Now(),
|
||
SeparateNo: "",
|
||
OutSeparateNo: "",
|
||
CalType: "",
|
||
FinishDate: "",
|
||
TotalAmt: "",
|
||
ActualSeparateAmt: "",
|
||
TotalFeeAmt: "",
|
||
FinalStatus: "",
|
||
DetailData: "",
|
||
Remark: "",
|
||
}
|
||
dao.WrapAddIDCULEntity(separate, ctx.GetUserName())
|
||
err = dao.CreateEntity(dao.GetDB(), separate)
|
||
|
||
return result, nil
|
||
}
|
||
|
||
// CloseOrder 关闭待支付订单
|
||
func CloseOrder(merchantId, vendorOrderId string, vendorId int) (string, error) {
|
||
param := &lakala.CloseOrderReq{
|
||
MerchantNo: merchantId,
|
||
OutOrderNo: vendorOrderId,
|
||
PayOrderNo: "",
|
||
ChannelId: "",
|
||
}
|
||
result, err := api.LaKaLaApi.CloseOrder(param)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
order, err := partner.CurOrderManager.LoadOrder(vendorOrderId, vendorId)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
switch result {
|
||
case lakala.OrderCloseStatusPayFail, lakala.OrderCloseStatusExpire, lakala.OrderCloseStatusCancel, lakala.OrderCloseStatusRefund, lakala.OrderCloseStatusClose:
|
||
order.Status = model.OrderStatusCanceled
|
||
order.VendorStatus = result
|
||
dao.UpdateEntity(dao.GetDB(), order, "Status", "VendorStatus")
|
||
}
|
||
|
||
return result, err
|
||
}
|
||
|
||
// QueryOrder 收银台订单查询
|
||
func QueryOrder(vendorOrderId, merchantId string, vendorId int) (*lakala.QueryOrderResp, error) {
|
||
result, err := api.LaKaLaApi.QueryOrder(vendorOrderId, merchantId)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
order, err := partner.CurOrderManager.LoadOrder(vendorOrderId, vendorId)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
switch result.OrderStatus {
|
||
case lakala.OrderCloseStatusPayFail, lakala.OrderCloseStatusExpire, lakala.OrderCloseStatusCancel, lakala.OrderCloseStatusRefund, lakala.OrderCloseStatusClose:
|
||
order.Status = model.OrderStatusCanceled
|
||
order.VendorStatus = result.OrderStatus
|
||
case lakala.OrderCloseStatusPaySuccess:
|
||
order.Status = model.OrderStatusFinished
|
||
order.VendorStatus = result.OrderStatus
|
||
order.OrderFinishedAt = time.Now()
|
||
}
|
||
dao.UpdateEntity(dao.GetDB(), order, "Status", "VendorStatus", "OrderFinishedAt")
|
||
|
||
return result, nil
|
||
}
|
||
|
||
// CloseOrderByMini 聚合支付关单,关单重新拉起支付
|
||
func CloseOrderByMini(merchantNo, termNo, orderNo, ip string) error {
|
||
param := &lakala.ClosePayMiniOrder{
|
||
MerchantNo: merchantNo,
|
||
TermNo: termNo,
|
||
OriginOutTradeNo: orderNo,
|
||
OriginTradeNo: "",
|
||
LocationInfo: struct {
|
||
RequestIp string `json:"request_ip"`
|
||
BaseStation string `json:"base_station"`
|
||
Location string `json:"location"`
|
||
}{
|
||
RequestIp: ip,
|
||
},
|
||
}
|
||
return api.LaKaLaApi.ClosePay(param)
|
||
}
|
||
|
||
//#endregion
|
||
|
||
//#region 账户相关
|
||
|
||
// QueryBillBalance 查询账户余额
|
||
func QueryBillBalance(orgNo, merchantNo, payType string) (*lakala.QueryBillBalanceResp, error) {
|
||
result, err := api.LaKaLaApi.QueryBillBalance(&lakala.QueryBillBalanceReq{
|
||
OrgNo: orgNo,
|
||
MerchantNo: merchantNo,
|
||
PayType: payType,
|
||
})
|
||
|
||
return result, err
|
||
}
|
||
|
||
// EwalletWithdrawD1 申请提现
|
||
func EwalletWithdrawD1(ctx *jxcontext.Context, orgNo, merchantNo, payType, drawAmt string) error {
|
||
param := &lakala.EwalletWithdrawD1Req{
|
||
OrgNo: orgNo,
|
||
MerchantNo: merchantNo,
|
||
DrawAmt: drawAmt,
|
||
NotifyUrl: lakala.BillProdCallbackUrl,
|
||
MerOrderNo: lakala.GetOrderNumber(8),
|
||
PayNo: "",
|
||
PayType: payType,
|
||
Remark: "",
|
||
Summary: "",
|
||
BankId: "",
|
||
}
|
||
drawJnl, _, err := api.LaKaLaApi.EwalletWithdrawD1(param)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
withdrawal := &model.LakalaWithdrawal{
|
||
CreatedTime: time.Now(),
|
||
MercId: merchantNo,
|
||
DrawJnl: drawJnl,
|
||
ReqDate: "",
|
||
DrawAmt: drawAmt,
|
||
DrawFee: "",
|
||
BatchAutoSettle: "01",
|
||
DrawState: "DRAW.ACCEPTED",
|
||
DrawMode: "",
|
||
Memo: "",
|
||
}
|
||
dao.WrapAddIDCULEntity(withdrawal, ctx.GetUserName())
|
||
if err = dao.CreateEntity(dao.GetDB(), withdrawal); err != nil {
|
||
return err
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// EwalletWithdrawQuery 提现结果查询
|
||
func EwalletWithdrawQuery(ctx *jxcontext.Context, orgNo, merchantNo, drawJnl string) (*lakala.EwalletWithdrawQueryResp, error) {
|
||
resp, err := api.LaKaLaApi.EwalletWithdrawQuery(&lakala.EwalletWithdrawQueryReq{
|
||
OrgNo: orgNo,
|
||
MerchantNo: merchantNo,
|
||
DrawJnl: drawJnl,
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
db := dao.GetDB()
|
||
withDraw, err := dao.GetEwalletWithDraw(db, merchantNo, drawJnl)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
withDraw.UpdatedAt = time.Now()
|
||
withDraw.LastOperator = ctx.GetUserName()
|
||
withDraw.CreatedTime = utils.Str2Time(resp.CreatedTime)
|
||
withDraw.CompleteTime = utils.Str2Time(resp.CompleteTime)
|
||
withDraw.ReqDate = resp.ReqDate
|
||
withDraw.DrawFee = resp.DrawFee
|
||
withDraw.DrawAmt = resp.DrawAmt
|
||
withDraw.BatchAutoSettle = resp.BatchAutoSettle
|
||
withDraw.DrawState = resp.DrawState
|
||
withDraw.DrawMode = resp.DrawMode
|
||
withDraw.Memo = resp.Memo
|
||
|
||
if _, err = dao.UpdateEntity(db, withDraw); err != nil {
|
||
return nil, err
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
// SettleDrawPattern 提款模式设置
|
||
func SettleDrawPattern(param *lakala.SettleDrawPatternReq) error {
|
||
param.NotifyUrl = lakala.BillProdCallbackUrl
|
||
return api.LaKaLaApi.SettleDrawPattern(param)
|
||
}
|
||
|
||
// EwalletSettleQuery 提款模式查询
|
||
func EwalletSettleQuery(orgCode, merchantId string) (*lakala.EwalletSettleQueryResp, error) {
|
||
return api.LaKaLaApi.EwalletSettleQuery(orgCode, merchantId)
|
||
}
|
||
|
||
//#endregion
|
||
|
||
//#region 图片上传
|
||
|
||
func UploadImg(filePath, imgType, sourcechnl, isOcr string) (*lakala.UploadImgResp, error) {
|
||
return api.LaKaLaApi.FileUpload(filePath, imgType, sourcechnl, isOcr)
|
||
}
|
||
|
||
// UploadAttachmentImg 分账附件上传
|
||
func UploadAttachmentImg(orgCode, attType, attExtName, attContext string) (*lakala.AttachmentImgResp, error) {
|
||
parameter := &lakala.AttachmentImg{
|
||
Version: "1.0",
|
||
OrderNo: lakala.GetOrderNumber(8),
|
||
OrgCode: orgCode,
|
||
AttType: attType,
|
||
AttExtName: attExtName,
|
||
AttContext: attContext,
|
||
}
|
||
//base64DecryData, _ := base64.StdEncoding.DecodeString(attContext)
|
||
|
||
return api.LaKaLaApi.AttachmentUpload(parameter)
|
||
}
|
||
|
||
//#endregion
|
||
|
||
//#region京西数据查询
|
||
|
||
// GetIncomingList 进件查询
|
||
func GetIncomingList(merchantNo string, storeId, pageSize, offset int) (*model.PagedInfo, error) {
|
||
return dao.GetIncoming(storeId, merchantNo, offset, pageSize)
|
||
}
|
||
|
||
// GetRecipientList 获取分账商户
|
||
func GetRecipientList(orgCode, receiverNo, receiverName string, offset, pageSize int) (pagedInfo *model.PagedInfo, err error) {
|
||
return dao.GetRecipientList(orgCode, receiverNo, receiverName, offset, pageSize)
|
||
}
|
||
|
||
// GetSeparateAmt 分账流水查询
|
||
func GetSeparateAmt(merchantNo, cmdType, status, separateNo, separateTimeStart, separateTimeEnd, vendorOrderID string, storeId int, offset, pageSize int) (pagedInfo *model.PagedInfo, err error) {
|
||
var (
|
||
start time.Time
|
||
end time.Time
|
||
)
|
||
if separateTimeStart != "" {
|
||
start = utils.Str2Time(separateTimeStart)
|
||
}
|
||
if separateTimeEnd != "" {
|
||
end = utils.Str2Time(separateTimeEnd)
|
||
}
|
||
return dao.GetSeparateAmt(merchantNo, cmdType, status, separateNo, vendorOrderID, storeId, start, end, offset, pageSize)
|
||
}
|
||
|
||
// WithdrawalList 提现流水查询
|
||
func WithdrawalList(merchantNo, drawJnl, acctName, startTime, endTime string, pageSize, offset int) (pagedInfo *model.PagedInfo, err error) {
|
||
var (
|
||
start time.Time
|
||
end time.Time
|
||
)
|
||
if startTime != "" {
|
||
start = utils.Str2Time(startTime)
|
||
}
|
||
if endTime != "" {
|
||
end = utils.Str2Time(endTime)
|
||
}
|
||
return dao.WithdrawalList(merchantNo, drawJnl, acctName, start, end, pageSize, offset)
|
||
}
|
||
|
||
// QueryApplyContractList 门店合同申请记录
|
||
func QueryApplyContractList(orderNo string, storeID, pageSize, offset int) (pagedInfo *model.PagedInfo, err error) {
|
||
return dao.QueryApplyContractList(orderNo, storeID, pageSize, offset)
|
||
}
|
||
|
||
//#endregion
|