671 lines
26 KiB
Go
671 lines
26 KiB
Go
package tiktok_store
|
||
|
||
import (
|
||
"errors"
|
||
"fmt"
|
||
address_create_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/address_create/request"
|
||
address_list_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/address_list/request"
|
||
address_list_response "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/address_list/response"
|
||
freightTemplate_create_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/freightTemplate_create/request"
|
||
shop_batchCreateStore_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_batchCreateStore/request"
|
||
shop_bindStoreFreight_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_bindStoreFreight/request"
|
||
shop_bindStoreSaleLimit_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_bindStoreSaleLimit/request"
|
||
shop_editStore_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_editStore/request"
|
||
shop_getStoreDetail_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_getStoreDetail/request"
|
||
shop_storeSuspend_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_storeSuspend/request"
|
||
shop_unsuspendStore_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/shop_unsuspendStore/request"
|
||
trade_createTradeLimitTemplate_request "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/sdk-golang/api/trade_createTradeLimitTemplate/request"
|
||
"git.rosy.net.cn/baseapi/platformapi/tiktok_shop/tiktok_api"
|
||
"git.rosy.net.cn/baseapi/utils"
|
||
"git.rosy.net.cn/baseapi/utils/errlist"
|
||
"git.rosy.net.cn/jx-callback/business/jxcallback/scheduler"
|
||
"git.rosy.net.cn/jx-callback/business/jxstore/event"
|
||
"git.rosy.net.cn/jx-callback/business/jxutils"
|
||
"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/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"
|
||
)
|
||
|
||
func SplicingTimeToDoudian(openTime1, closeTime1, openTime2, closeTime2 int16) (timeList string) {
|
||
//700 1200 -> 07:00-12:00
|
||
var (
|
||
s1 = ""
|
||
ts1 = ""
|
||
s2 = ""
|
||
ts2 = ""
|
||
s3 = ""
|
||
ts3 = ""
|
||
s4 = ""
|
||
ts4 = ""
|
||
timeStr = ""
|
||
)
|
||
if openTime1 != 0 && closeTime1 != 0 {
|
||
tOpenTime1 := utils.Int64ToStr(int64(openTime1))
|
||
len1 := len(tOpenTime1) - 2
|
||
if utils.Str2Int(tOpenTime1[:len1]) <= 9 {
|
||
ts1 = "0"
|
||
}
|
||
s1 = ts1 + tOpenTime1[:len1] + ":" + tOpenTime1[len1+1:] + "0"
|
||
tCloseTime1 := utils.Int64ToStr(int64(closeTime1))
|
||
len2 := len(tCloseTime1) - 2
|
||
if utils.Str2Int(tCloseTime1[:len2]) <= 9 {
|
||
ts2 = "0"
|
||
}
|
||
s2 = ts2 + tCloseTime1[:len2] + ":" + tCloseTime1[len2+1:] + "0"
|
||
timeStr += s1 + "-" + s2
|
||
if openTime2 != 0 && closeTime2 != 0 {
|
||
tOpenTime2 := utils.Int64ToStr(int64(openTime2))
|
||
len3 := len(tOpenTime2) - 2
|
||
if utils.Str2Int(tOpenTime2[:len3]) <= 9 {
|
||
ts3 = "0"
|
||
}
|
||
s3 = ts3 + tOpenTime2[:len3] + ":" + tOpenTime2[len3+1:] + "0"
|
||
tCloseTime2 := utils.Int64ToStr(int64(closeTime2))
|
||
len4 := len(tCloseTime2) - 2
|
||
if utils.Str2Int(tCloseTime2[:len4]) <= 9 {
|
||
ts4 = "0"
|
||
}
|
||
s4 = ts4 + tCloseTime2[:len4] + ":" + tCloseTime2[len4+1:] + "0"
|
||
timeStr += "," + s3 + "-" + s4
|
||
}
|
||
}
|
||
return timeStr
|
||
}
|
||
|
||
// shop/batchCreateStore 批量创建门店
|
||
func (P *PurchaseHandler) CreateStore2(db *dao.DaoDB, storeID int, userName string, params map[string]interface{}, storeDetail *dao.StoreDetail) (vendorStoreID string, err error) {
|
||
var (
|
||
storeIDs string
|
||
tempStoreID []int64
|
||
fences []string
|
||
lists []shop_batchCreateStore_request.StoreListItem
|
||
ShopBatchCreateStoreParam *shop_batchCreateStore_request.ShopBatchCreateStoreParam
|
||
FreightTemplate *model.FreightTemplate
|
||
)
|
||
errList := errlist.New()
|
||
//a:=getAPI(storeDetail.VendorOrgCode, storeID, storeDetail.VendorStoreID)
|
||
timeStr := ""
|
||
if storeDetail.OpenTime1 == 0 || storeDetail.CloseTime1 == 0 {
|
||
return "", fmt.Errorf("营业时间必填")
|
||
} else {
|
||
globals.SugarLogger.Debug("storeDetail.OpenTime1, storeDetail.CloseTime1======", storeDetail.OpenTime1, storeDetail.CloseTime1)
|
||
timeStr = SplicingTimeToDoudian(storeDetail.OpenTime1, storeDetail.CloseTime1, storeDetail.OpenTime2, storeDetail.CloseTime2)
|
||
}
|
||
m := make(map[int64]string)
|
||
for j := 1; j <= 7; j++ {
|
||
m[int64(j)] = timeStr
|
||
}
|
||
list := shop_batchCreateStore_request.StoreListItem{
|
||
RowId: 1,
|
||
Name: storeDetail.Name,
|
||
StoreCode: utils.Int2Str(storeDetail.Store.ID),
|
||
Longitude: utils.Float64ToStr(jxutils.IntCoordinate2Standard(storeDetail.Lng)),
|
||
Latitude: utils.Float64ToStr(jxutils.IntCoordinate2Standard(storeDetail.Lat)),
|
||
Province: storeDetail.ProvinceName,
|
||
City: storeDetail.CityName,
|
||
District: storeDetail.DistrictName,
|
||
Address: storeDetail.Address,
|
||
Contact: storeDetail.Tel1,
|
||
OpenTime: &shop_batchCreateStore_request.OpenTime{
|
||
DayMap: m,
|
||
},
|
||
}
|
||
lists = append(lists, list)
|
||
ShopBatchCreateStoreParam = &shop_batchCreateStore_request.ShopBatchCreateStoreParam{
|
||
StoreList: lists,
|
||
}
|
||
if resp, err := getAPI(storeDetail.VendorOrgCode, storeID, storeDetail.VendorStoreID).BatchCreateStore(ShopBatchCreateStoreParam); err != nil {
|
||
return "", err
|
||
} else {
|
||
if len(resp.ResultList) == 0 {
|
||
return "", err
|
||
}
|
||
for k, v := range resp.ResultList {
|
||
if k != len(resp.ResultList) {
|
||
storeIDs = utils.Int64ToStr(v.Store.StoreId) + ","
|
||
}
|
||
storeIDs = utils.Int64ToStr(v.Store.StoreId)
|
||
|
||
}
|
||
globals.SugarLogger.Debug("Success createStore and return storeID=====", resp.ResultList[0].Store.StoreId, utils.Str2Int(storeIDs))
|
||
if utils.Str2Int(storeIDs) == 0 {
|
||
errList.AddErr(fmt.Errorf("storeIDs=0 %v", err))
|
||
//return "", errors.New(fmt.Sprintf("创建店铺失败原因storeIDs = 0:%v,%v", err, resp.ResultList[0].Msg))
|
||
}
|
||
//创建并绑定运费模板
|
||
globals.SugarLogger.Debug("storeDetail.Store.ID==============", storeDetail.Store.ID)
|
||
freightTemplateID, err := CreateFreightTemplate(storeDetail.Store.ID)
|
||
if err != nil {
|
||
errList.AddErr(fmt.Errorf("创建运费模板失败原因：%v", err))
|
||
} else {
|
||
if freightTemplateID == 0 {
|
||
globals.SugarLogger.Debug("freightTemplateID=========", freightTemplateID)
|
||
errList.AddErr(fmt.Errorf(" ", int64(storeDetail.Store.ID), freightTemplateID, err))
|
||
}
|
||
err = P.ShopBindStoreFreight(int64(storeDetail.Store.ID), freightTemplateID)
|
||
if err != nil {
|
||
errList.AddErr(fmt.Errorf("门店：%d 绑定运费模板:%d 失败原因：%v", int64(storeDetail.Store.ID), freightTemplateID, err))
|
||
} else {
|
||
FreightTemplate.TemplateID = freightTemplateID
|
||
_, err := dao.UpdateEntity(db, FreightTemplate, "TemplateID")
|
||
if err != nil {
|
||
errList.AddErr(fmt.Errorf("运费模板ID存入数据库失败原因：%v", err))
|
||
}
|
||
}
|
||
}
|
||
//创建并绑定仓库
|
||
warehouse, err := P.CreateWarehouse(utils.Int2Str(storeDetail.Store.ID), storeDetail.VendorOrgCode)
|
||
if err != nil {
|
||
errList.AddErr(fmt.Errorf("创建仓库失败原因：%v", err))
|
||
} else {
|
||
tempStoreID = append(tempStoreID, int64(storeDetail.Store.ID))
|
||
err = P.BindStoreWarehouse(tempStoreID, utils.Int2Str(storeDetail.Store.ID), utils.Int64ToStr(warehouse))
|
||
if err != nil {
|
||
errList.AddErr(fmt.Errorf("门店：%d 绑定仓库:%d 失败原因：%v", int64(storeDetail.Store.ID), warehouse, err))
|
||
} else {
|
||
FreightTemplate.WarehouseID = warehouse
|
||
_, err := dao.UpdateEntity(db, FreightTemplate, "WarehouseID")
|
||
if err != nil {
|
||
errList.AddErr(fmt.Errorf("仓库ID存入数据库失败原因：%v", err))
|
||
}
|
||
}
|
||
}
|
||
//创建并绑定电子围栏
|
||
if fenceID, err := CreateFenceByStore(int(resp.ResultList[0].Store.StoreId)); err != nil {
|
||
errList.AddErr(fmt.Errorf("创建电子围栏失败原因：%v", err))
|
||
} else {
|
||
fences = append(fences, fenceID)
|
||
if err := BindFenceByStore(resp.ResultList[0].Store.StoreId, fences); err != nil {
|
||
errList.AddErr(fmt.Errorf("门店：%d 绑定电子围栏:%d 失败原因：%v", int64(storeDetail.Store.ID), warehouse, err))
|
||
} else {
|
||
FreightTemplate.FenceID = fenceID
|
||
_, err := dao.UpdateEntity(db, FreightTemplate, "FenceID")
|
||
if err != nil {
|
||
errList.AddErr(fmt.Errorf("电子围栏ID存入数据库失败原因：%v", err))
|
||
}
|
||
}
|
||
}
|
||
//storeIDs =
|
||
globals.SugarLogger.Debug("CreateStore2 return storeIDs, storeDetail.Store.ID==========", storeIDs, storeDetail.Store.ID)
|
||
FreightTemplate.StoreID = storeDetail.Store.ID
|
||
FreightTemplate.VendorStoreID = storeIDs
|
||
_, err = dao.UpdateEntity(db, FreightTemplate, "StoreID", "VendorStoreID")
|
||
if err != nil {
|
||
errList.AddErr(fmt.Errorf("db update storeID,vendorStoreID defeat on :%v", err))
|
||
}
|
||
globals.SugarLogger.Debug("CreateStore last step success..................")
|
||
return storeIDs, errors.New(fmt.Sprintf("%v", errList))
|
||
}
|
||
}
|
||
|
||
// shop/editStore 编辑门店信息 正向推送平台
|
||
func (P *PurchaseHandler) UpdateStore(db *dao.DaoDB, storeID int, userName string) (err error) {
|
||
globals.SugarLogger.Debugf("doudian Update storeID:%d, userName:%s", storeID, userName)
|
||
var (
|
||
storeInfo *dao.StoreDetail
|
||
name string
|
||
)
|
||
if db == nil {
|
||
db = dao.GetDB()
|
||
}
|
||
storeInfo, err = dao.GetStoreDetail(db, storeID, model.VendorIDDD, "")
|
||
errList := errlist.New()
|
||
timeStr := ""
|
||
m := make(map[int64]string)
|
||
if storeInfo.OpenTime1 != 0 && storeInfo.CloseTime1 != 0 {
|
||
timeStr = SplicingTimeToDoudian(storeInfo.OpenTime1, storeInfo.CloseTime1, storeInfo.OpenTime2, storeInfo.CloseTime2)
|
||
for j := 1; j <= 7; j++ {
|
||
m[int64(j)] = timeStr
|
||
}
|
||
}
|
||
vendorStoreID := &shop_getStoreDetail_request.ShopGetStoreDetailParam{
|
||
StoreId: utils.Str2Int64(storeInfo.VendorStoreID),
|
||
}
|
||
api := getAPI(storeInfo.VendorOrgCode, storeID, utils.Int64ToStr(vendorStoreID.StoreId))
|
||
if globals.EnableDdStoreWrite {
|
||
remoteStoreInfo, err2 := api.GetStoreDetail(vendorStoreID)
|
||
if err2 != nil {
|
||
return err2
|
||
}
|
||
if remoteStoreInfo.StoreDetail.Store.StoreId == 0 {
|
||
return fmt.Errorf("ID:%d 的门店不存在,请先创建", utils.Str2Int64(storeInfo.VendorStoreID))
|
||
}
|
||
mergedStoreStatus := jxutils.MergeStoreStatus(storeInfo.Status, storeInfo.VendorStatus)
|
||
name = remoteStoreInfo.StoreDetail.Store.Name
|
||
if storeInfo.SyncStatus&(model.SyncFlagNewMask|model.SyncFlagStoreName) != 0 {
|
||
if storeInfo.VendorStoreName != "" {
|
||
name = storeInfo.VendorStoreName
|
||
}
|
||
}
|
||
store := fmt.Sprintf("门店id:%d,门店名称:%s,第三方门店状态:%d,本地修改前门店状态%d,本地门店修改后状态:%d,第三方平台Id(抖店):%s", storeID, remoteStoreInfo.StoreDetail.Store.Name, remoteStoreInfo.StoreDetail.Store.State, storeInfo.Status, mergedStoreStatus, storeInfo.VendorOrgCode)
|
||
event.AddOperateEvent(jxcontext.AdminCtx, jxcontext.AdminCtx.GetTrackInfo(), store, "", "", 10, "UpdateStore")
|
||
params := &shop_editStore_request.ShopEditStoreParam{
|
||
StoreId: remoteStoreInfo.StoreDetail.Store.StoreId, //平台id不可修改
|
||
Name: name,
|
||
StoreCode: utils.Int2Str(storeInfo.ID), //自用编码即很本地storeID
|
||
Latitude: utils.Int2Str(storeInfo.Lat),
|
||
Longitude: utils.Int2Str(storeInfo.Lng),
|
||
Province: storeInfo.ProvinceName,
|
||
City: storeInfo.CityName,
|
||
District: storeInfo.DistrictName,
|
||
Address: storeInfo.Address,
|
||
Contact: storeInfo.Tel1,
|
||
OpenTime: &shop_editStore_request.OpenTime{
|
||
DayMap: m,
|
||
},
|
||
}
|
||
//修改店铺状态
|
||
if storeInfo.SyncStatus&(model.SyncFlagNewMask|model.SyncFlagStoreStatus) != 0 {
|
||
globals.SugarLogger.Debug("================1", 1)
|
||
globals.SugarLogger.Debug("================mergedStoreStatus", mergedStoreStatus)
|
||
errList.AddErr(P.UpdateStoreStatus(jxcontext.AdminCtx, storeInfo.VendorOrgCode, storeID, storeInfo.VendorStoreID, mergedStoreStatus))
|
||
}
|
||
//TODO 需增加 更新运费模板、电子围栏
|
||
_, err3 := api.EditStore(params)
|
||
if err3 != nil {
|
||
errList.AddErr(err3)
|
||
}
|
||
}
|
||
return err
|
||
}
|
||
|
||
// UpdateStoreStatus shop/unsuspendStore 门店恢复营业
|
||
func (p *PurchaseHandler) UpdateStoreStatus(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, status int) (err error) {
|
||
globals.SugarLogger.Debug("================2", 1)
|
||
isOnline := bizStatusJX2DouDian(status)
|
||
globals.SugarLogger.Debug("================2", isOnline)
|
||
api := getAPI(vendorOrgCode, storeID, vendorStoreID)
|
||
if globals.EnableDdStoreWrite {
|
||
if isOnline != tiktok_api.StoreStatusOnline { //暂停营业状态
|
||
unsuspendStoreID := &shop_unsuspendStore_request.ShopUnsuspendStoreParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
}
|
||
_, err = api.UnsuspendStore(unsuspendStoreID)
|
||
} else { //恢复营业
|
||
suspendStoreID := &shop_storeSuspend_request.ShopStoreSuspendParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
}
|
||
getStoreID := &shop_getStoreDetail_request.ShopGetStoreDetailParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
}
|
||
//平台上店铺状态
|
||
remoteStoreInfo, err2 := api.GetStoreDetail(getStoreID)
|
||
if err2 != nil {
|
||
return err2
|
||
}
|
||
if remoteStoreInfo.StoreDetail.Store.SuspendType == tiktok_api.SuspendTypePlatformPenalty {
|
||
err = errors.New("门店因平台处罚暂停营业，不可主动修改营业状态")
|
||
} else {
|
||
_, err = api.StoreSuspend(suspendStoreID)
|
||
}
|
||
}
|
||
}
|
||
return err
|
||
}
|
||
|
||
//默认 运费模板只创建 固定运费模板
|
||
func CreateFreightTemplate(storeCode int) (int64, error) {
|
||
var (
|
||
columns []freightTemplate_create_request.ColumnsItem
|
||
childrenItems []freightTemplate_create_request.ChildrenItem
|
||
children5s []freightTemplate_create_request.ChildrenItem_5
|
||
provinceInfos []freightTemplate_create_request.ProvinceInfosItem
|
||
children4s []freightTemplate_create_request.ChildrenItem_4
|
||
)
|
||
//获取本地门店信息
|
||
storeDetail, err := dao.GetStoreDetail(dao.GetDB(), storeCode, model.VendorIDDD, "")
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
childrenItem := freightTemplate_create_request.ChildrenItem{
|
||
Id: 0, //获取不到街道id
|
||
}
|
||
childrenItems = append(childrenItems, childrenItem)
|
||
children5 := freightTemplate_create_request.ChildrenItem_5{
|
||
Id: int64(storeDetail.DistrictCode),
|
||
Children: childrenItems,
|
||
}
|
||
children5s = append(children5s, children5)
|
||
children4 := freightTemplate_create_request.ChildrenItem_4{
|
||
Id: int64(storeDetail.CityCode),
|
||
Children: children5s,
|
||
}
|
||
children4s = append(children4s, children4)
|
||
provinceInfo := freightTemplate_create_request.ProvinceInfosItem{
|
||
Id: int64(storeDetail.ProvinceCode),
|
||
Children: children4s,
|
||
}
|
||
provinceInfos = append(provinceInfos, provinceInfo)
|
||
column := freightTemplate_create_request.ColumnsItem{
|
||
FirstNum: 1,
|
||
FirstNumPrice: 0.01,
|
||
AddNum: 1,
|
||
AddNumPrice: 0.01,
|
||
IsOverFree: true, //是否包邮
|
||
OverAmount: int64(storeDetail.DeliveryFeeDeductionSill), //此字段在vendor_id=14时 存储满x包邮金额
|
||
ProvinceInfos: provinceInfos,
|
||
}
|
||
columns = append(columns, column)
|
||
param := &freightTemplate_create_request.FreightTemplateCreateParam{
|
||
Template: &freightTemplate_create_request.Template{
|
||
TemplateName: "门店编码：" + utils.Int2Str(storeCode) + "的运费模板",
|
||
ProductProvince: int64(storeDetail.ProvinceCode),
|
||
ProductCity: int64(storeDetail.CityCode),
|
||
CalculateType: 2, //模板类型为1-固定运费、2-卖家包邮、3-货到付款 时，计价类型传 2-按数量
|
||
TransferType: 1,
|
||
RuleType: 2, //卖家包邮
|
||
},
|
||
Columns: columns,
|
||
}
|
||
resp, err := getAPI(storeDetail.VendorOrgCode, storeCode, storeDetail.VendorStoreID).FreightTemplateCreate(param)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return resp.TemplateId, nil
|
||
}
|
||
|
||
// /freightTemplate/create 创建运费模板
|
||
func (P *PurchaseHandler) CreateFreightTemplateDirectly(templateInfo freightTemplate_create_request.FreightTemplateCreateParam, storeID, vendorStoreID int64) error {
|
||
var (
|
||
db *dao.DaoDB
|
||
)
|
||
if templateInfo.Template.RuleType > 0 {
|
||
templateInfo.Template.CalculateType = tiktok_api.CalculateTypeNum
|
||
}
|
||
info := &freightTemplate_create_request.FreightTemplateCreateParam{
|
||
Template: templateInfo.Template,
|
||
Columns: templateInfo.Columns,
|
||
}
|
||
api := getAPI("", int(storeID), utils.Int64ToStr(vendorStoreID))
|
||
resp, err := api.FreightTemplateCreate(info)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
//创建成功后进行绑定
|
||
bindInfo := &shop_bindStoreFreight_request.ShopBindStoreFreightParam{
|
||
StoreId: vendorStoreID,
|
||
FreightId: resp.TemplateId,
|
||
}
|
||
err = api.BindFreightTemplate(bindInfo)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
//并写入数据库
|
||
freightInfo := model.FreightTemplate{
|
||
StoreID: int(storeID),
|
||
VendorStoreID: utils.Int64ToStr(vendorStoreID),
|
||
TemplateID: resp.TemplateId,
|
||
}
|
||
if err = dao.CreateEntity(db, freightInfo); err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// /shop/bindStoreFreight 门店绑定运费模版
|
||
//门店绑定运费模版，运费模版必须属于门店关联的抖店，且门店与运费模版是一对一关系
|
||
func (P *PurchaseHandler) ShopBindStoreFreight(storeID, freightID int64) error {
|
||
param := &shop_bindStoreFreight_request.ShopBindStoreFreightParam{
|
||
StoreId: storeID,
|
||
FreightId: freightID,
|
||
}
|
||
api := getAPI("", int(storeID), "")
|
||
err := api.BindFreightTemplate(param)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// /address/create 创建店铺地址库（新建即绑定）
|
||
func (P *PurchaseHandler) CreateAddress(addressInfo address_create_request.AddressCreateParam) (addressID int64, err error) {
|
||
info := &address_create_request.AddressCreateParam{
|
||
Address: addressInfo.Address,
|
||
StoreId: addressInfo.StoreId,
|
||
}
|
||
api := getAPI("", 0, utils.Int64ToStr(info.StoreId))
|
||
resp, err := api.AddressCreate(info)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
//添加进数据库page_shop
|
||
//获取门店信息
|
||
//storeID := &shop_getStoreDetail_request.ShopGetStoreDetailParam{
|
||
// StoreId: addressInfo.StoreId,
|
||
//}
|
||
//storeInfo, err1 := api.DouDianApi.GetStoreDetail(storeID)
|
||
//if err1 != nil {
|
||
// return 0, err1
|
||
//}
|
||
//createAddress := &model.PageShop{ //此表暂存门店售后地址库
|
||
// Name: storeInfo.StoreDetail.Store.Name,
|
||
// VendorID: model.VendorIDDouDian,
|
||
// VendorStoreID: utils.Int64ToStr(storeInfo.StoreDetail.Store.StoreId), //抖店平台ID
|
||
// OrgCode: storeInfo.StoreDetail.Store.StoreCode, //暂时用来存放京西平台门店ID
|
||
// VendorStatus: utils.Int64ToStr(storeInfo.StoreDetail.Store.State),
|
||
// Status: 0,
|
||
// CityCode: utils.Str2Int(storeInfo.StoreDetail.Store.CityCode),
|
||
// DistrictCode: utils.Str2Int(storeInfo.StoreDetail.Store.DistrictCode),
|
||
// Address: storeInfo.StoreDetail.Store.Address,
|
||
// Lng: utils.Str2Float64(storeInfo.StoreDetail.Store.Longitude),
|
||
// Lat: utils.Str2Float64(storeInfo.StoreDetail.Store.Latitude),
|
||
// Tel1: storeInfo.StoreDetail.Store.Contact,
|
||
//}
|
||
//if err = dao.CreateEntity(dao.GetDB(), createAddress); err != nil {
|
||
// return 0, err
|
||
//}
|
||
return resp.AddressId, nil
|
||
}
|
||
|
||
// /address/list 获取售后地址列表接口
|
||
//分页获取商家地址列表
|
||
func (P *PurchaseHandler) GetAddressList(param *address_list_request.AddressListParam) (*address_list_response.AddressListData, error) {
|
||
//不传入ID则是获取所有门店售后地址列表
|
||
info := &address_list_request.AddressListParam{
|
||
PageSize: 10,
|
||
PageNo: 1,
|
||
OrderBy: param.OrderBy,
|
||
OrderField: param.OrderField,
|
||
}
|
||
if param.StoreId != 0 {
|
||
info.StoreId = param.StoreId
|
||
}
|
||
listInfo, err := getAPI("", 0, utils.Int64ToStr(info.StoreId)).GetAddressList(info)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return listInfo, nil
|
||
}
|
||
|
||
// /trade/createTradeLimitTemplate 创建限售模板
|
||
func (P *PurchaseHandler) CreateTradeLimitTemplate(template trade_createTradeLimitTemplate_request.TradeCreateTradeLimitTemplateParam) (tradeLimitID int64, err error) {
|
||
info := &trade_createTradeLimitTemplate_request.TradeCreateTradeLimitTemplateParam{
|
||
StoreId: template.StoreId,
|
||
TradeLimitRuleRequestList: template.TradeLimitRuleRequestList,
|
||
}
|
||
resp, err := getAPI("", 0, utils.Int64ToStr(info.StoreId)).CreateTradeLimitTemplate(info)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return resp.TradeLimitId, nil
|
||
}
|
||
|
||
// /shop/bindStoreSaleLimit 门店绑定限售模板
|
||
func (P *PurchaseHandler) BindStoreSaleLimit(storeID, saleLimitTemplateID int64) error {
|
||
info := &shop_bindStoreSaleLimit_request.ShopBindStoreSaleLimitParam{
|
||
StoreId: storeID,
|
||
SaleLimitId: saleLimitTemplateID,
|
||
}
|
||
if err := getAPI("", 0, utils.Int64ToStr(info.StoreId)).BindStoreSaleLimit(info); err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (P *PurchaseHandler) UpdateStoreOpTime(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, opTimeList []int16) (err error) {
|
||
t1 := opTimeList[0]
|
||
t2 := opTimeList[1]
|
||
t3 := opTimeList[2]
|
||
t4 := opTimeList[4]
|
||
timeStr := SplicingTimeToDoudian(t1, t2, t3, t4)
|
||
m := make(map[int64]string)
|
||
for j := 1; j <= 7; j++ {
|
||
m[int64(j)] = timeStr
|
||
}
|
||
params := &shop_editStore_request.ShopEditStoreParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
OpenTime: &shop_editStore_request.OpenTime{
|
||
DayMap: m,
|
||
},
|
||
}
|
||
if globals.EnableDdStoreWrite {
|
||
_, err = getAPI(vendorOrgCode, storeID, vendorStoreID).EditStore(params)
|
||
}
|
||
return err
|
||
}
|
||
|
||
//获取门店状态
|
||
func (P *PurchaseHandler) GetStoreStatus(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string) (storeStatus int, err error) {
|
||
params := &shop_getStoreDetail_request.ShopGetStoreDetailParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
}
|
||
result, err := getAPI(vendorOrgCode, storeID, vendorStoreID).GetStoreDetail(params)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
status := bizStatusJX2DouDian(int(result.StoreDetail.Store.State))
|
||
return status, nil
|
||
}
|
||
|
||
func (P *PurchaseHandler) EnableAutoAcceptOrder(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, isSetEnable bool) (err error) {
|
||
return err
|
||
}
|
||
|
||
// 获取店铺所有平台ID
|
||
func (P *PurchaseHandler) GetAllStoresVendorID(ctx *jxcontext.Context, vendorOrgCode string) (vendorStoreIDs []string, err error) {
|
||
//param := &shop_getStoreList_request.ShopGetStoreListParam{
|
||
// Page: 0,
|
||
// PageSize: 10,
|
||
//}
|
||
//storeList, err := api.DouDianApi.GetStoreList(param)
|
||
//if err != nil {
|
||
// return nil, err
|
||
//}
|
||
//if len(storeList.StoreDetailList) > 0 {
|
||
// vendorStoreIDs = make([]string, len(storeList.StoreDetailList))
|
||
// for k, v := range storeList.StoreDetailList {
|
||
// vendorStoreIDs[k] = utils.Int64ToStr(v.Store.StoreId)
|
||
// }
|
||
//}
|
||
//return vendorStoreIDs, err
|
||
return nil, err
|
||
}
|
||
|
||
func (P *PurchaseHandler) UpdateStoreLineStatus(ctx *jxcontext.Context, vendorOrgCode string, storeID int, vendorStoreID string, lineStatus int) (err error) {
|
||
api := getAPI(vendorOrgCode, storeID, vendorStoreID)
|
||
if lineStatus == model.StoreStatusOpened {
|
||
param := &shop_storeSuspend_request.ShopStoreSuspendParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
}
|
||
_, err = api.StoreSuspend(param)
|
||
} else {
|
||
param := &shop_unsuspendStore_request.ShopUnsuspendStoreParam{
|
||
StoreId: utils.Str2Int64(vendorStoreID),
|
||
}
|
||
_, err = api.UnsuspendStore(param)
|
||
}
|
||
return err
|
||
}
|
||
func (P *PurchaseHandler) ReadStore(ctx *jxcontext.Context, vendorOrgCode, vendorStoreID, vendorStoreName string) (store *dao.StoreDetail, err error) {
|
||
vendorStore, err := getAPI(vendorOrgCode, 0, "").GetStoreDetail(&shop_getStoreDetail_request.ShopGetStoreDetailParam{StoreId: utils.Str2Int64(vendorStoreID)})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
globals.SugarLogger.Debugf("AddAuthBind user================:%s", utils.Format4Output(vendorStore, true))
|
||
// globals.SugarLogger.Debug(utils.Format4Output(result, false))
|
||
retVal := &dao.StoreDetail{
|
||
Store: model.Store{
|
||
Address: vendorStore.StoreDetail.Store.Address,
|
||
Tel1: vendorStore.StoreDetail.Store.Contact,
|
||
},
|
||
}
|
||
retVal.OriginalName = vendorStore.StoreDetail.Store.Name
|
||
_, retVal.Name = jxutils.SplitStoreName(retVal.OriginalName, partner.StoreNameSeparator, globals.StoreNameTiktok)
|
||
|
||
retVal.SetTiktokOpenTime(vendorStore.StoreDetail.Store.OpenTime.DayMap[1])
|
||
retVal.Status = bizStatusTiktok2JX(vendorStore.StoreDetail.Store.State)
|
||
|
||
//tel2 := result.StandbyTel
|
||
//if tel2 != "" && tel2 != retVal.Tel1 {
|
||
// retVal.Tel2 = tel2
|
||
//}
|
||
|
||
retVal.Lng = int(utils.Str2Float64(vendorStore.StoreDetail.Store.Longitude) * 1000000)
|
||
retVal.Lat = int(utils.Str2Float64(vendorStore.StoreDetail.Store.Latitude) * 1000000)
|
||
|
||
lng := jxutils.IntCoordinate2Standard(retVal.Lng)
|
||
lat := jxutils.IntCoordinate2Standard(retVal.Lat)
|
||
db := dao.GetDB()
|
||
retVal.DistrictCode = api.AutonaviAPI.GetCoordinateDistrictCode(lng, lat)
|
||
city, err := dao.GetPlaceByCode(db, utils.Str2Int(vendorStore.StoreDetail.Store.CityCode))
|
||
retVal.CityName = city.Name
|
||
retVal.CityCode = utils.Str2Int(vendorStore.StoreDetail.Store.CityCode)
|
||
|
||
poiCode := vendorStore.StoreDetail.Store.StoreCode
|
||
retVal.VendorStoreID = vendorStoreID
|
||
retVal.ID = utils.Str2Int(poiCode)
|
||
retVal.DeliveryRangeType = model.DeliveryRangeTypeRadius
|
||
retVal.DeliveryRange = "3000"
|
||
retVal.DeliveryType = scheduler.StoreDeliveryTypeByStore
|
||
//retVal.DeliveryRangeType = model.DeliveryRangeTypePolygon
|
||
//var deliveryRangeInfo []map[string]interface{}
|
||
//deliveryRangeInfo, err = getAPIWithoutToken(vendorOrgCode).ShippingFetch(poiCode)
|
||
//if err != nil {
|
||
// deliveryRangeInfo, err = getAPIWithoutToken(vendorOrgCode).ShippingList(poiCode)
|
||
//}
|
||
//if err == nil {
|
||
// if len(deliveryRangeInfo) > 0 {
|
||
// retVal.DeliveryRange = rangeMtwm2JX(deliveryRangeInfo[0]["area"].(string))
|
||
// logisticsCode := utils.Interface2String(deliveryRangeInfo[0]["logistics_code"])
|
||
// if logisticsCode == "" || logisticsCode == mtwmapi.PeiSongTypeSelf {
|
||
// retVal.DeliveryType = scheduler.StoreDeliveryTypeByStore
|
||
// } else {
|
||
// retVal.DeliveryType = scheduler.StoreDeliveryTypeByPlatform
|
||
// }
|
||
// }
|
||
//}
|
||
return retVal, nil
|
||
}
|
||
|
||
func (P *PurchaseHandler) RefreshAllStoresID(ctx *jxcontext.Context, parentTask tasksch.ITask, isAsync bool) (hint string, err error) {
|
||
return "", errors.New("抖店暂不支持此操作")
|
||
}
|
||
|
||
func bizStatusJX2DouDian(status int) (onLine int) {
|
||
if status == model.StoreStatusDisabled || status == model.StoreStatusClosed || status == model.StoreStatusHaveRest {
|
||
return tiktok_api.StoreStatusOffline
|
||
}
|
||
return tiktok_api.StoreStatusOnline
|
||
}
|
||
|
||
func (P *PurchaseHandler) DeleteStore(db *dao.DaoDB, storeID int, userName string) (err error) {
|
||
return errors.New("抖店暂不支持此操作")
|
||
}
|
||
|
||
func (P *PurchaseHandler) UpdateStoreCustomID(ctx *jxcontext.Context, vendorOrgCode, vendorStoreID string, storeID int64) (err error) {
|
||
return err
|
||
}
|
||
|
||
func (P *PurchaseHandler) GetOrderStatus(vendorOrgCode, vendorOrderID string) (status int, err error) {
|
||
return 0, errors.New("抖店暂不支持此操作")
|
||
}
|
||
|
||
// /address/getProvince 获取四级地址全量省份信息
|
||
//func (P *PurchaseHandler) GetProvince()([]) {
|
||
//
|
||
//}
|