liulei/baseapi
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加国美api,删除老版本蜂鸟API，添加抖音授权api、

Browse Source
This commit is contained in:
邹宗楠
2022-05-13 16:03:37 +08:00
parent 56ef57fae5
commit ff5b116ce5
35 changed files with 2346 additions and 1191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
platformapi/gome_live_show/callback.go Normal file
View File

@@ -0,0 +1,54 @@
package gome_live_show
import (
"net/url"
"git.rosy.net.cn/jx-callback/globals"
"git.rosy.net.cn/baseapi/utils"
)
type CallBackInfo struct {
AppID string `json:"app_id"`
Data string `json:"data"`
Salt int `json:"salt"`
Signature string `json:"signature"`
}
type WayBillInfo struct {
PartnerOrderCode string `json:"partner_order_code"`
OrderStatus int `json:"order_status"`
PushTime int64 `json:"push_time"`
CarrierDriverName string `json:"carrier_driver_name"`
CarrierDriverPhone string `json:"carrier_driver_phone"`
OpenOrderCode int64 `json:"open_order_code"`
PlatformCode string `json:"platform_code"`
ErrorScene string `json:"error_scene"`
Description string `json:"description"`
ErrorCode string `json:"error_code"`
DetailDescription string `json:"detail_description"`
}
func (a *API) GetOrderCallbackMsg(data []byte) (orderMsg *WayBillInfo) {
callbackInfo := &CallBackInfo{}
err := utils.UnmarshalUseNumber(data, callbackInfo)
if err != nil {
globals.SugarLogger.Debugf("fn msg faild %v, err : %v", string(data), err)
return nil
}
if err == nil {
if str, err := url.QueryUnescape(callbackInfo.Data); err == nil {
orderMsg = &WayBillInfo{}
if err := utils.UnmarshalUseNumber([]byte(str), orderMsg); err == nil {
return orderMsg
} else {
globals.SugarLogger.Debugf("fn msg faild3 %v", err)
return nil
}
} else {
globals.SugarLogger.Debugf("fn msg faild2 %v", err)
return nil
}
}
return orderMsg
}

195
platformapi/gome_live_show/goods.go Normal file
View File

@@ -0,0 +1,195 @@
package gome_live_show
import (
"encoding/json"
"errors"
"git.rosy.net.cn/baseapi/utils"
"net/http"
)
// 获取商品品类信息查询
func (a *API) GetGoodsCategoryList() (goodsCategory *GoodsCategoryListRes, err error) {
goodsCategoryMap, err := a.AccessAPI(gomeUrl, GoodsCategoryApi, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(nil)))
if err != nil {
return nil, err
}
result := &GoodsCategoryListRes{}
if err := utils.Map2StructByJson(goodsCategoryMap, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
//
//// 查询所有的商品规格
//func (a *API) QueryGoodsSizeListAll(param *QueryGoodsSpecSizeReq) {
// param.PageNumber = 1
// param.PageSize = 50
// result, err := a.QueryGoodsSizeList(param)
// if err != nil {
// return nil, err
// }
//
// for ; pageNo <= result.Data.Total/pageSize+1; pageNo++ {
// result2, err := getAPI(string(model.VendorGoMei)).QueryGoodsListById(&gomei.QueryGoodsListForStoreReq{
// Page: gomei.Page{
// PageNumber: pageNo,
// PageSize: pageSize,
// },
// })
// if err != nil {
// return nil, err
// }
//
// for _, v := range result2.Data.Records {
// if skuName := vendorSku2Jx2(v); skuName != nil {
// skuNameList = append(skuNameList, skuName)
// }
// }
// }
//
// return skuNameList, err
// reslut, err := a.QueryGoodsSizeList(param)
//
//}
//jsonMarshal,err := json.Marshal(gomeResult)
//if err != nil {
//return nil, err
//}
//if err := json.Unmarshal(jsonMarshal,data);err != nil {
//return nil, err
//}
// 查询商品规格
func (a *API) QueryGoodsSizeList(param *QueryGoodsSpecSizeReq) (result *QueryGoodsSpecSizeRes, err error) {
reqByte, err := json.Marshal(param)
if err != nil {
return
}
gomeResult, err := a.AccessAPI(gomeUrl, GoodsSpecListApi, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(reqByte)))
if err != nil {
return nil, err
}
data := &QueryGoodsSpecSizeRes{}
if err := utils.Map2StructByJson(gomeResult, data, false); err != nil {
return nil, err
}
jsonMarshal, err := json.Marshal(gomeResult)
if err != nil {
return nil, err
}
if err := json.Unmarshal(jsonMarshal, data); err != nil {
return nil, err
}
if data.Code != 200 {
return nil, errors.New(result.Message)
}
return data, err
}
// 查询商品规格详情
func (a *API) QueryGoodsDetails(specCode string) (result *QueryGoodsSpecDetailRes, err error) {
byteParam, err := json.Marshal(map[string]string{"specCode": specCode})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, GoodsSpecDetailApi, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteParam)))
if err != nil {
return nil, err
}
detail := &QueryGoodsSpecDetailRes{}
if err := utils.Map2StructByJson(gomeResult, detail, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return detail, err
}
// 新增商品规格
func (a *API) CreateGoodsSpceList(param *CreateSpecDetailParam) (result *SystemParameterRes, err error) {
paramByte, err := json.Marshal(param)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, GoodsSpecCreateApi, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(paramByte)))
resultData := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, resultData, true); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return resultData, nil
}
// 修改商品规格
func (a *API) UpdateGoodsSize(param *UpdateGoodsSizeReq) (*SystemParameterRes, error) {
paramByte, err := json.Marshal(param)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, GoodsSpecUpdateApi, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(paramByte)))
resultData := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, resultData, true); err != nil {
return nil, err
}
if resultData.Code != 200 {
return nil, errors.New(resultData.Message)
}
return resultData, nil
}
// 删除商品规格
func (a *API) DeleteGoodsSize(specCode string) (*SystemParameterRes, error) {
byteParam, err := json.Marshal(map[string]string{"specCode": specCode})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, GoodsSpecDeleteApi, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam([]byte(byteParam))))
if err != nil {
return nil, err
}
resultData := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, resultData, true); err != nil {
return nil, err
}
if resultData.Code != 200 {
return nil, errors.New(resultData.Message)
}
return resultData, nil
}
// 获取不同商品的类型
func (a *API) GetGoodsTypeList(cat3Code string) (*QueryGoodsTypeListRes, error) {
byteParam, err := json.Marshal(map[string]string{"cat3Code": cat3Code})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, GoodsSpecTypeApi, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam([]byte(byteParam))))
if err != nil {
return nil, err
}
resultData := &QueryGoodsTypeListRes{}
if err := utils.Map2StructByJson(gomeResult, resultData, true); err != nil {
return nil, err
}
if resultData.Code != 200 {
return nil, errors.New(resultData.Message)
}
return resultData, nil
}

136
platformapi/gome_live_show/goods_model.go Normal file
View File

@@ -0,0 +1,136 @@
package gome_live_show
//#region 获取商品品类信息
type GoodsCategoryListRes struct {
Code int64 `json:"code"` // 响应码
Timestamp int64 `json:"timestamp"` // 时间戳（秒）
Message string `json:"message"` // 响应描述
RequestId string `json:"requestId"` // 请求id
Data []*GoodsCategoryListRecordRes
}
// 商品品类查询 品类查询，创建商品规格和商品时需要维护品类信息。
type GoodsCategoryListRecordRes struct {
CatCode string `json:"catCode"` // 品类 id
CatLevel int `json:"catLevel"` // 品类级别 三级品类:1 一级品类2 二级品类3三级品类
CatName string `json:"catName"` // 品类名称
ChildCat []*GoodsCategoryListRecordRes `json:"childCat"` // 子类目信息
}
//#endregion
//#region 获取商铺尺寸列表
// 查询商品规格列表 创建商品时，可选择不同规格的组合商品进行售卖，,
//包含规格属性唯一标识(specCode)、规格属性名(specName) 、
//规格属性值唯一标识(specValueCode)、规格属性值(specValueName)等信息。
type QueryGoodsSpecSizeReq struct {
Cat3Code string `json:"cat3Code"` // 根据3级品类code查询,长度50
SpecName string `json:"specName"` // 规格属性名
Page
}
// 返回值
type QueryGoodsSpecSizeRes struct {
SystemParameterRes
Data *GoodsSpecSizeList
}
type GoodsSpecSizeList struct {
Records []*QueryGoodsSpecSizeRecords
SystemRecordDataDetailRes
}
type QueryGoodsSpecSizeRecords struct {
SpecCode string `json:"specCode"` // 规格属性名唯一标识
SpecName string `json:"specName"` // 规格属性名
FullCatName string `json:"fullCatName"` // 所属品类
Cat3Code string `json:"cat3Code"` // 三级品类Code
Remark string `json:"remark"` // 备注
}
//#endregion
//#region 查询商品规格详情
type QueryGoodsSpecDetailRes struct {
SystemParameterRes
Data *QueryGoodsSpecDetailRecordRes
}
type QueryGoodsSpecDetailRecordRes struct {
QueryGoodsSpecDetailDataRes
SystemRecordDataDetailRes
}
type QueryGoodsSpecDetailDataRes struct {
SpecCode string `json:"specCode"` // 规格属性名 id
SpecName string `json:"specName"` // 规格属性名
SpecValues []*SpecValuesList `json:"specValues"` // 规格属性值集合
FullCatName string `json:"fullCatName"` // 所属品类
Cat1Code string `json:"cat1Code"` // 一级品类code
Cat1Name string `json:"cat1Name"` // 一级品类名
Cat2Code string `json:"cat2Code"` // 二级品类code
Cat2Name string `json:"cat2Name"` // 二级品类名
Cat3Code string `json:"cat3Code"` // 三级品类 code
Cat3Name string `json:"cat3Name"` // 三级品类名
Remark string `json:"remark"` // 备注
}
type SpecValuesList struct {
SpecValueCode string `json:"specValueCode"` // 规格属性值唯一标示
SpecValueName string `json:"specValueName"` // 规格属性值名称
}
//#endregion
//#region 新增商品尺寸规格
type CreateSpecDetailParam struct {
SpecName string `json:"specName"` // 规格属性名[必填]
SpecValues []*SpecValueName `json:"specValues"` // 规格属性值[必填]
Cat3Code string `json:"cat3Code"` // 规格属性名[必填]
Remark string `json:"remark"` // 规格属性名
}
type SpecValueName struct {
SpecValueName string `json:"specValueName"` // 规格属性名必填
}
//#endregion
//#region 编辑商品规格
type UpdateGoodsSizeReq struct {
SpecCode string `json:"specCode"` // 规格属性名唯一标识[必填]
SpecName string `json:"specName"` // 规格属性名[必填]
SpecValues []*UpdateGoodsSpecValue `json:"specValues"` // 规格属性值[必填]
Cat3Code string `json:"cat3Code"` // 三级品类code[必填]
Remark string `json:"remark"` // 备注
}
type UpdateGoodsSpecValue struct {
SpecValueName string `json:"specValueName"` // 规格属性名
SpecValueCode string `json:"specValueCode"` // 规格属性名
}
//#endregion
//#region 删除商品规格
//#endregion
//#region 获取不同商品类型
type QueryGoodsTypeListRes struct {
SystemParameterRes
Data *QueryGoodsTypeListDataRes
}
type QueryGoodsTypeListDataRes struct {
SystemRecordDataDetailRes
Record []*struct {
GoodsType string `json:"goodsType"` // 商品类型
GoodsTypeName string `json:"goodsTypeName"` // 商品名称
}
}
//#endregion

42
platformapi/gome_live_show/goods_test.go Normal file
View File

@@ -0,0 +1,42 @@
package gome_live_show
import (
"fmt"
"testing"
)
// 获取商品尺寸列表
func TestQueryGoodsList(t *testing.T) {
paramter := &QueryGoodsSpecSizeReq{
Cat3Code: "",
SpecName: "",
Page: Page{
PageNumber: PageNumber,
PageSize: PageSize,
},
}
data, err := api.QueryGoodsSizeList(paramter)
fmt.Println("err=", err)
fmt.Println("err=", data)
// fmt.Println("data", data.Records[0].Cat3Code)
}
// 获取尺寸详情
func TestQuerSpecListDetail(t *testing.T) {
api.QueryGoodsDetails("11111")
}
// 新增商品规格
func TestAddGoods(t *testing.T) {
data, err := api.CreateGoodsSpceList(&CreateSpecDetailParam{
SpecName: "测试分类",
SpecValues: []*SpecValueName{
{SpecValueName: "1111"},
{SpecValueName: "2222"},
},
Cat3Code: "100001",
Remark: "测试用力添加",
})
fmt.Println(data)
fmt.Println(err)
}

108
platformapi/gome_live_show/guomei_const_emu.go Normal file
View File

@@ -0,0 +1,108 @@
package gome_live_show
// api/url
const (
gomeUrl = "http://openapi-uat-external.lohashow.com" // 基础url
GetTokenApi = "login/auth/getToken" // 获取token
// 门店
GetStoreListApi = "V2/store/list" // 获取门店列表
// 商户商品
GetMerchantGoodsList = "V2/goods/merchant/list" // 商户商品列表
GetMerchantGoodsDetailList = "V2/goods/merchant/detail" // 商户商品商品详情列表
CreateMerchantGoodsToStore = "V2/goods/merchant/create" // 商户商品新增
UpdateMerchantGoodsToStore = "V2/goods/merchant/update" // 商户商品修改
DeleteMerchantGoodsToStore = "V2/goods/merchant/delete" // 商户商品删除
// 门店分类
GetStoreCategoryListApi = "V2/category/storeGoods/list" // 获取店铺商品分类列表(素菜,水果,牛肉)
AddStoreCategoryApi = "V2/category/storeGoods/create" // 店铺商品分类新增
ModifyStoreCategoryApi = "V2/category/storeGoods/update" // 店铺商品分类修改
DeleteStoreCategoryApi = "V2/category/storeGoods/delete" // 店铺商品分类删除
// 门店商品规格
GoodsCategoryApi = "V2/goodsCategory/list" // 商品品类查询(超市/超市/(洋酒/鲜花/面包))
GoodsSpecListApi = "V2/spec/list" // 查询商品规格列表
GoodsSpecDetailApi = "V2/spec/detail" // 查询商品规格详情
GoodsSpecCreateApi = "V2/spec/create" // 创建商品规格
GoodsSpecUpdateApi = "V2/spec/update" // 修改商品规格
GoodsSpecDeleteApi = "V2/spec/delete" // 删除商品规格
GoodsSpecTypeApi = "V2/goodsType/list" // 获取不同商品类型
// 门店商品维护
QueryGoodsListByStoreId = "V2/goods/store/list" // 根据店铺编码查询店铺商品列表
QueryOneGoodsByStoreId = "V2/goods/store/detail" // 根据 storeCode+skuCode 查询店铺商品详情
GoodsOnOffLineByStore = "V2/goods/store/onOffline" // 门店商品上下架状态
UpdatePriceToOneGoodsByStore = "V2/goods/store/priceUpdate" // 单商品维护售价
UpdateGoodsStockForStore = "V2/goods/store/stockUpdate" // 商品库存更新接口
AddGoodsForStore = "V2/goods/store/create" // 新增店铺商品
// 订单
QueryOrderList = "V2/order/list" // 根据创建时间查询订单的列表信息
QueryOrderDetail = "V2/order/detail" // 查询订单详情接口
CancelOrder = "V2/order/cancel" // 取消订单
ConfirmOrder = "V2/order/confirm" // 此接口主要用于商户接单场景
DeliveryOrder = "V2/order/delivery" // 发货
CheckOutOrder = "V2/order/checkout" // 用户自提商家核销
CancelAgreeOrRefuseAfterApply = "V2/order/cancle/agreeOrRefuseAfterApply" // 用户自提商家核销
// 售后订单
QueryAfterSaleList = "V2/afterSale/list" // 批量查询售后单接口
CreateAfterSaleOrder = "V2/afterSale/create" // 创建售后单接口
QueryAfterSaleOrderDetail = "V2/afterSale/get" // 售后单详情接口
AgreeOrRefuseAfterApplyOrder = "V2/afterSale/agreeOrRefuseAfterApply" // 商家审核订单
MerchantAgreeOkAfterApplyOrder = "V2/afterSale/confirm/goods" // 售后单商户收货确认
UploadImg = "V2/material/upload" // 主要用于为合作方上传图片提供服务，将合作方素材转化为乐活秀平台所需素材链接。
)
// 国美枚举说明
const (
// 上下架枚举值
PutOnTheShelf = "SHELVE" // 上架
DownOnTheShelf = "READY" // 下架
// 订单状态枚举值
GoodsToBePrepared = "STOCKUP_PENDING" // 待备货
PayingAndCancel = "PAID_CANCEL" // 支付后取消
Consignment = "DELIVERY_PENDING" // 待发货
CancelAfterStock = "STOCKUP_CANCEL" // 备货后取消
GoodsToBeReceived = "RECEIVING" // 待收货
Completed = "COMPLETE" // 已完成
//售后单状态枚举值
SubmitAfterSalesApplication = iota // 提交售后申请 0
AfterSalesAuditPassed // 售后审核通过 1
MerchantFailedToPass // 上架审核未通过 2
CustomerShipped // 客户已发货 3
MerchantHasReceivedTheGoods // 商家已收货 4
AfterSalesCompletion // 售后完成 5
UserCancel // 用户取消（完成） 6
TimeoutShutdown // 超时关闭（完成） 7
PlatformInterventionConsent // 平台介入同意 9
PlatformInterventionNo // 平台介入拒绝 10
PlatformInterventionApply // 申请平台介入 11
PlatformInterventionAgainApply // 拒绝后再次申请 12
// 门店营业状态
GoMeiStoreStatusToBeOpen = 1 // 待开业
GoMeiStoreStatusOpen = 2 // 开业
GoMeiStoreStatusTemporaryClose = 3 // 临时关闭
GoMeiStoreStatusClose = 4 // 关闭
)
// 常量
const (
PageNumber = 1
PageSize = 50
ConstNumberOne = 0
GoMeiMaxStock = 99999999 // 最大库存量
)
func GoMeiStoreSkuStatus(status int) string {
if status == 1 {
return PutOnTheShelf
}
return DownOnTheShelf
}

158
platformapi/gome_live_show/guomei_token.go Normal file
View File

@@ -0,0 +1,158 @@
package gome_live_show
import (
"crypto/md5"
"encoding/json"
"fmt"
"git.rosy.net.cn/baseapi"
"git.rosy.net.cn/baseapi/platformapi"
"git.rosy.net.cn/baseapi/utils"
"net/http"
"sort"
"strings"
"sync"
"time"
)
var api *API
func init() {
appKey := "N0R033L2QQFR53"
secretKey := "686ffc3e31c24594838baed045563790"
api = New(appKey, secretKey, "")
api.GetAccessToken()
// api.GetAccessToken()
}
func (a *API) SetToken(token string) {
a.locker.Lock()
defer a.locker.Unlock()
a.sessionToken = token
}
func (a *API) GetAppKey() string {
a.locker.Lock()
defer a.locker.Unlock()
return a.appKey
}
func New(appKey, appSecret, code string, config ...*platformapi.APIConfig) *API {
curConfig := platformapi.DefAPIConfig
if len(config) > 0 {
curConfig = *config[0]
}
return &API{
code: code,
appKey: appKey,
sign: "",
appSecret: appSecret,
refreshToken: "",
sessionToken: "",
expiration: "",
version: "2",
locker: sync.RWMutex{},
client: &http.Client{Timeout: curConfig.ClientTimeout},
config: &curConfig,
}
}
// 签名
func (a *API) signParam(params map[string]interface{}) (sig string) {
var valueList []string
for k, v := range params {
if k != "sign" {
if str := fmt.Sprint(v); str != "" {
valueList = append(valueList, fmt.Sprintf("%s%s", k, str))
}
}
}
sort.Sort(sort.StringSlice(valueList))
sig = strings.Join(valueList, "")
sig = sig + "_" + a.appSecret
data := []byte(sig)
return strings.ToUpper(fmt.Sprintf("%x", md5.Sum(data)))
}
// 获取access_token
func (a *API) GetAccessToken() (tokenInfo *gomeToken, err error) {
parameter := make(map[string]interface{}, 3)
parameter["appKey"] = a.appKey
parameter["timestamp"] = utils.Int64ToStr(time.Now().Unix())
parameter["sign"] = a.signParam(parameter)
// 获取token
result, err := a.AccessAPI(gomeUrl, GetTokenApi, http.MethodPost, parameter)
if err != nil {
return nil, err
}
if err := utils.Map2StructByJson(result, &tokenInfo, false); err != nil {
return nil, err
}
a.refreshToken = tokenInfo.Data.RefreshToken
a.expiration = tokenInfo.Data.Expiration
a.sessionToken = tokenInfo.Data.SessionToken
return tokenInfo, err
}
func (a *API) AccessAPI(baseUrl, actionApi, method string, bizParams map[string]interface{}) (retVal map[string]interface{}, err error) {
// 序列化
data, err := json.Marshal(bizParams)
if err != nil {
return nil, err
}
// 全路径请求参数
fullURL := utils.GenerateGetURL(baseUrl, actionApi, nil)
// 发送请求
sendUrl := func() *http.Request {
var request *http.Request
if http.MethodPost == method {
request, _ = http.NewRequest(http.MethodPost, fullURL, strings.NewReader(string(data)))
} else {
request, _ = http.NewRequest(http.MethodGet, utils.GenerateGetURL(baseUrl, actionApi, bizParams), nil)
}
request.Header.Set("Content-Type", "application/json")
return request
}
// 数据解析
dataMarshal := 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")
}
if err != nil {
return "", err
}
if utils.MustInterface2Int64(jsonResult1["code"]) != 200 {
errLevel = platformapi.ErrLevelGeneralFail
err = utils.NewErrorCode(jsonResult1["message"].(string), utils.Int64ToStr(utils.MustInterface2Int64(jsonResult1["code"])))
baseapi.SugarLogger.Debugf("gome AccessAPI failed, jsonResult1:%s", utils.Format4Output(jsonResult1, true))
}
retVal = jsonResult1
return errLevel, err
}
err = platformapi.AccessPlatformAPIWithRetry(a.client, sendUrl, a.config, dataMarshal)
return retVal, err
}
// 组装访问参数
func (a *API) MakeRequestParam(storeByte []byte) *SystemParameterReq {
param := &SystemParameterReq{
AuthToken: a.sessionToken,
Timestamp: time.Now().Unix(),
Version: a.version,
Sign: "",
}
param.Biz = "{}"
if storeByte != nil || len(storeByte) > 0 {
param.Biz = string(storeByte)
}
mapParametersReq := utils.Struct2FlatMap(param)
param.Sign = a.signParam(mapParametersReq)
return param
}

167
platformapi/gome_live_show/order.go Normal file
View File

@@ -0,0 +1,167 @@
package gome_live_show
import (
"encoding/json"
"errors"
"git.rosy.net.cn/baseapi/utils"
"net/http"
)
// 根据创建时间查询订单的列表信息
// 为了防止访问及返回的压力过大，可支持的时间区间查询范围，
// 不允许超过 30 分钟，每页显示 10 条；正常频率查询：增量查询，建议1~3 分钟查询一次，
// 查询开始时间为上次查询结束时间，查询结束时间为当前 1~3 分钟之前；补充频率查询：为了防止数据遗漏，
// 建议10分钟查询一次。例如当前时间为 10:50，查询区间为10:10~10:30，具体细节有调用方把握，减少数据遗漏的可能性
func (a *API) QueryOrderListByTime(req *QueryOrderListForTimeReq) (*QueryOrderListForTimeRes, error) {
byteReq, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, QueryOrderList, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &QueryOrderListForTimeRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 查询订单详情接口
// 此接口主要用于订单下单后获取订单详细信息，包括订单基础信息、商品信息、配送信息、物流信息等
func (a *API) QueryOrderDetail(orderNo string) (*QueryOrderDetailRes, error) {
byteReq, err := json.Marshal(map[string]string{"orderNo": orderNo})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, QueryOrderDetail, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &QueryOrderDetailRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 商家取消订单 ，订单处于待备货或待发货的情况下，商家可主动操作取消订单，取消成功后订单变成支付后取消状态
func (a *API) CancelOrder(orderNo string) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(map[string]string{"orderNo": orderNo})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, CancelOrder, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 接单
func (a *API) ConfirmOrder(orderNo string) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(map[string]string{"orderNo": orderNo})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, ConfirmOrder, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 发货接口 此接口主要用于商户基于订单发货场景，第三方平台调用成功后，订单状态将变为待收货
func (a *API) DeliveryOrder(param *DeliveryOrderReq) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(param)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, DeliveryOrder, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 核销接口此接口主要用于 C 端用户下单自提，商家核销场景，核销成功订单状态变成已完成(订单号/核销码)
func (a *API) CheckOrder(orderNo, deliverCheckCode string) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(map[string]string{"orderNo": orderNo, "deliverCheckCode": deliverCheckCode})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, CheckOutOrder, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 此接口主要用于，售中（待发货状态）订单，用户发起全单取消，申请后进行商家审核场景，商家审核通过订单将变成备货后取消状态，商家拒绝订单则进行走正向流程
func (a *API) OrderAgreeOrRefuseAfterApply(req *AgreeOrRefuseCheck) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, CancelAgreeOrRefuseAfterApply, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}

141
platformapi/gome_live_show/order_after_sale.go Normal file
View File

@@ -0,0 +1,141 @@
package gome_live_show
import (
"encoding/json"
"errors"
"git.rosy.net.cn/baseapi/utils"
"net/http"
)
// 查询售后单
func (a *API) QueryAfterSaleList(req *QueryAfterSaleListReq) (*QueryAfterSaleListRes, error) {
byteReq, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, QueryAfterSaleList, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &QueryAfterSaleListRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 创建售后单 此接口主要基于售后场景，订单处于待收货或已完成，商户在后台针对订单的单商品主动发起售后
func (a *API) CreateAfterSaleOrderApi(req *CreateOrderAfterSaleReq) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, CreateAfterSaleOrder, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 售后单详情接口
func (a *API) QueryAfterSaleOrderDetail(afterSaleNo string) (*QueryAfterSaleListRes, error) {
byteReq, err := json.Marshal(map[string]string{"afterSaleNo": afterSaleNo})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, QueryAfterSaleOrderDetail, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &QueryAfterSaleListRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 此接口主当售中（待收货、已完成）用户发起单sku的售后申请，申请后进行商家审核场景，
//商家审核通过售后单进退退款流程，商家拒绝售后单关闭，用户可进行重新申请或申请平台介入
func (a *API) AgreeOrRefuseAfterApplyOrder(req *CheckOutAfterOrderReq) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, AgreeOrRefuseAfterApplyOrder, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 售后单商户收货确认
func (a *API) MerchantConfirmOrder(afterSaleNo string) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(map[string]string{"afterSaleNo": afterSaleNo})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, MerchantAgreeOkAfterApplyOrder, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 合作方图片上传 materialType(枚举值1 图片2视频)
func (a *API) UploadPicture(data string, materialType int, materialName string) (*GomeiUploadImgRes, error) {
byteReq, err := json.Marshal(map[string]interface{}{"data": data, "materialType": materialType, "materialName": materialName})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, UploadImg, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &GomeiUploadImgRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}

68
platformapi/gome_live_show/order_after_sale_model.go Normal file
View File

@@ -0,0 +1,68 @@
package gome_live_show
//#region 查询平台售后单列表
// 查询平台售后单列表。
type QueryAfterSaleListReq struct {
Page
AfterSaleStatus int `json:"afterSaleStatus"` // 售后状态
OrderNo string `json:"orderNo"` // 按照订单号查询
AfterSaleNo string `json:"afterSaleNo"` // 按照售后单号查询
Mobile string `json:"mobile"` // 售后状态
StoreCode int `json:"storeCode"` // 平台店铺编码
}
type QueryAfterSaleListRes struct {
SystemParameterRes
Data *QueryAfterSaleListData
}
type QueryAfterSaleListData struct {
SystemRecordDataDetailRes
Record []*QueryAfterSaleListRecord
}
type QueryAfterSaleListRecord struct {
AfterSaleNo string `json:"afterSaleNo"` // 售后单单号
OrderNo string `json:"orderNo"` // 订单号
AfterSaleType int `json:"afterSaleType"` // 售后类型 0：仅退款，1：退货退款
StoreName string `json:"storeName"` // 平台店铺名称
StoreCode string `json:"storeCode"` // 平台店铺编码
SkuCode string `json:"skuCode"` // 平台 sku 编码
GoodsName string `json:"goodsName"` // 商品名称
AfterSaleNumber int `json:"afterSaleNumber"` // 申请售后 sku 数
AfterSaleStatus int `json:"afterSaleStatus"` // 售后单状态 0 待商家确认，1 待退货，2退款中，3 商家已拒绝，4 平台介入中，5已关闭，6 已取消，7 售后完成，8退款失败
CreateTime string `json:"createTime"` // 创建时间
}
//#endregion
//#region 商户主动创建售后单,此接口主要基于售后场景，订单处于待收货或已完成，商户在后台针对订单的单商品主动发起售后
type CreateOrderAfterSaleReq struct {
// 必填
StoreCode string `json:"storeCode"` // 平台店铺编码
OrderNo string `json:"orderNo"` // 订单号
AfterSaleType int `json:"afterSaleType"` // 售后类型 0：仅退款，1：退货退款
SkuCode string `json:"skuCode"` // 平台 sku 编码
AfterSaleNumber int `json:"afterSaleNumber"` // 申请售后 sku 数
// 非必填
CargoState int `json:"cargoState"` // 售后申请- 货物状态
IssueDesc int `json:"issueDesc"` // 售后申请- 补充描述
RefundReasonCode int `json:"refundReasonCode"` // 退款原因编码
RefundReasonStr int `json:"refundReasonStr"` // 退款原因
PicUrl int `json:"picUrl"` // 退款原因凭证图片
}
//#endregion
type CheckOutAfterOrderReq struct {
// 必填
AfterSaleNo string `json:"afterSaleNo"` // 售后单单号
AfterSaleApplyResult string `json:"afterSaleApplyResult"` // 商户审核结果1 同意2拒绝
// 非必填
afterSaleApplyRejectReason string `json:"afterSaleApplyRejectReason"` // 拒绝原因
}
//#region

203
platformapi/gome_live_show/order_model.go Normal file
View File

@@ -0,0 +1,203 @@
package gome_live_show
import "time"
//#region 根据创建时间查询订单的列表信息
// 查询半小时内的订单,
type QueryOrderListForTimeReq struct {
StartTime time.Time `json:"startTime"` // 订单创建起始时间，默认只查询当天订单
EndTime time.Time `json:"endTime"` // 订单创建时间截止，默认只查询当天订单
StoreCode string `json:"storeCode"` // 过滤店铺信息，不传递是所有
OrderNo string `json:"orderNo"` // 过滤订单号
Status string `json:"status"` // 订单状态枚举值，不传递是所有
Page
}
// 返回参数
type QueryOrderListForTimeRes struct {
SystemParameterRes
Data *QueryOrderListForTimeData
}
type QueryOrderListForTimeData struct {
Record []*QueryOrderListForTimeRecord
SystemRecordDataDetailRes
}
type QueryOrderListForTimeRecord struct {
StoreCode string `json:"storeCode"`
StoreName string `json:"storeName"`
OrderNo string `json:"orderNo"`
UserName string `json:"userName"` // 下单用户名
Mobile string `json:"mobile"` // 下单用户电话
Items []*Items `json:"items"` // 商品
TotalAmount float64 `json:"totalAmount"` // 订单总价
RealAmount float64 `json:"realAmount"` // 用户实付金额
CreateTime string `json:"createTime"` // 下单时间
Status string `json:"status"` // 订单状态
UserCancelState string `json:"userCancelState"` // 订单取消审核 NONE-未申请ON-申请中PASS-申请通过REJECT-申请被拒绝
}
type Items struct {
SpuCode string `json:"spuCode"` // 平台 spu 编码
SkuCode string `json:"skuCode"` // 平台 sku 编码
ThirdSkuCode string `json:"thirdSkuCode"` // 外部 sku 编码
GoodsName string `json:"goodsName"` // 商品名称
Quantity int `json:"quantity"` // 购买商品数量
Amount float64 `json:"amount"` // 商品总价
}
//#endregion
//#region 查询订单详情接口
type QueryOrderDetailRes struct {
SystemParameterRes
Data *QueryOrderListForTimeData
}
type QueryOrderDetailResData struct {
Record *QueryOrderDetailRecordReq
SystemRecordDataDetailRes
}
type QueryOrderDetailRecordReq struct {
StoreCode string `json:"storeCode"` // 店铺码
OrderNo string `json:"orderNo"` // 订单号
OrderType string `json:"orderType"` // 订单类型
OrderPayType string `json:"orderPayType"` // 订单付款方式
Mobile string `json:"mobile"` // 用户手机号码
UserName string `json:"userName"` // 用户名
Items []*GoodsItems `json:"items"` // 商品列表
TotalAmount float64 `json:"totalAmount"` // 商品订单总价
RealAmount float64 `json:"realAmount"` // 商品实付金额
Quantity int `json:"quantity"` // 订单下单数量
CreateTime string `json:"createTime"` // 下单时间
Status string `json:"status"` // 订单状态
Comment string `json:"comment"` // 用户下单备注
CancelInfo *CancelInfo `json:"cancelInfo"` // 订单取消信息集
DeliveryInfo *DeliveryInfo `json:"deliveryInfo"` // 配送信息集
ExpressInfo *ExpressInfo `json:"expressInfo"` // 物流信息集
}
type GoodsItems struct {
SkuCode string `json:"skuCode"` // 平台 sku 编码
SpuCode string `json:"spuCode"` // 平台 spu 编码
ThirdSkuCode string `json:"thirdSkuCode"` // 外部 sku 编码
MainPictureURL string `json:"mainPictureUrl"` // 商品主图
FullSpecName string `json:"fullSpecName"` // 商品规格名称
FullCatName string `json:"fullCatName"` // 商品所属品类
Quantity int `json:"quantity"` // 购买商品数量
SalePrice float64 `json:"salePrice"` // 商品售价
SkuRealAmount float64 `json:"skuRealAmount"` // 商品项实付金额
FinishAfterNumber int `json:"finishAfterNumber"` // 已申请售后数量
AftersaleEndTime string `json:"aftersaleEndTime"` // 售后截止时间
GoodsName string `json:"goodsName"` // 商品名称
Cat1Code string `json:"cat1Code"`
Cat2Code string `json:"cat2Code"`
Cat3Code string `json:"cat3Code"`
SpuName string `json:"spuName"`
OrderItemNo string `json:"orderItemNo"`
SkuName string `json:"skuName"`
}
type CancelInfo struct {
UserCancelApplyTime string `json:"userCancelApplyTime"` // 用户申请取消时间
UserCancelReasonStr string `json:"userCancelReasonStr"` // 用户申请取消原因
UserCancelState string `json:"userCancelState"` // 订单取消审核状态
MerchantCancelReason string `json:"merchantCancelReason"` // 商家取消原因Id
MerchantCancelReasonStr string `json:"merchantCancelReasonStr"` // 商家取消原因
}
type DeliveryInfo struct {
DeliveryOrderNo string `json:"deliveryOrderNo"` // 配送单号
ReceiverName string `json:"receiverName"` // 收货人姓名
ReceiverMobile string `json:"receiverMobile"` // 收货人手机号
ReceiverAddress string `json:"receiverAddress"` // 地址包含省市
ProvinceCode string `json:"provinceCode"` // 省编码
ProvinceName string `json:"provinceName"` // 省名称
CityCode string `json:"cityCode"` // 市编码
CityName string `json:"cityName"` // 市名称
DistrictCode string `json:"districtCode"` // 区编码
DistrictName string `json:"districtName"` // 区名称
DeliveryAdress string `json:"deliveryAdress"` // 详细地址
DeliveryAmount float64 `json:"deliveryAmount"` // 运费金额
}
type ExpressInfo struct {
ExpressName string `json:"expressName"` // 物流单号
ExpressNo string `json:"expressNo"` // 物流公司名称
ExpressCode string `json:"expressCode"` // 物流公司标准编码
}
//#endregion
//#region 此接口主要用于商户基于订单发货场景，第三方平台调用成功后，订单状态将变为待收货
type DeliveryOrderReq struct {
OrderNo string `json:"orderNo"` // 订单号[必填]
storeCode string `json:"storeCode"` // 平台店铺编码[必填]
ExpressList []*struct { // 订单发货物流集合[必填]
ExpressNo string `json:"expressNo"` // 物流单号[必填]
ExpressCode string `json:"expressCode"` // 物流公司编码[必填]
ExpressName string `json:"expressName"` // 物流公司物流公司[必填]
}
}
//#endregion
//#region 商户审核用户取消订单申请
type AgreeOrRefuseCheck struct {
OrderNo string `json:"orderNo"` // 订单号[必填]
StoreCode string `json:"storeCode"` // 店铺码[必填]
CancelApplyResult int `json:"cancelApplyResult"` // 审核结果 商户审核结果1 同意2拒绝[必填]
CancelApplyRejectReason string `json:"cancelApplyRejectReason"` // 商户审核用户取消拒绝原因
}
//#endregion
//#region 获取售后单详情
type QueryAfterSaleOrderDetailRes struct {
SystemParameterRes
Data *QueryAfterSaleOrderDetailDataRes
}
type QueryAfterSaleOrderDetailDataRes struct {
SystemRecordDataDetailRes
Records *QueryAfterSaleOrderDetailRecordsRes
}
type QueryAfterSaleOrderDetailRecordsRes struct {
AfterSaleNo string `json:"afterSaleNo"` // 售后单单号
StoreCode string `json:"storeCode"` // 平台店铺编码
StoreName string `json:"storeName"` // 平台店铺名称
OrderNo string `json:"orderNo"` // 订单号
AfterSaleType int `json:"afterSaleType"` // 售后类型
RefundReasonCode string `json:"refundReasonCode"` // 退款原因id
RefundReasonStr string `json:"refundReasonStr"` // 退款原因描述
CargoState int `json:"cargoState"` // 货物 状态
IssueDesc string `json:"issueDesc"` // 补充描述和凭证
SkuCode string `json:"skuCode"` // 平台 sku 编码
GoodsName string `json:"goodsName"` // 平台 sku 名称
AfterSaleNumber int `json:"afterSaleNumber"` // 申请售后 sku 数量
AfterSaleStatus int `json:"afterSaleStatus"` // 售后单状态
CreateTime time.Time `json:"createTime"` // 创建时间
ApproveDeadline time.Time `json:"approveDeadline"` // 商家审核截至时建间
AgreeApplyTime time.Time `json:"agreeApplyTime"` // 商家同意时间
AfterSaleRejectReason string `json:"afterSaleRejectReason"` // 商家拒绝理由
DeliverGoodsDeadline time.Time `json:"deliverGoodsDeadline"` // 用户发货截至时间
ConfirmGoodsDeadline time.Time `json:"confirmGoodsDeadline"` // 商家收货截至时 间
ExpectRefundAmount float64 `json:"expectRefundAmount"` // 预计退款金额
ReturnLogisticsNo string `json:"returnLogisticsNo"` // 用户退货快递单号
ReturnLogistics string `json:"returnLogistics"` // 用户退货快递公司
ReturnTime time.Time `json:"returnTime"` // 用户退货退货时间
}
//#endregion
//#region 上传图片
type GomeiUploadImgRes struct {
Code int64 `json:"code"` // 响应码
Timestamp int64 `json:"timestamp"` // 时间戳（秒）
Message string `json:"message"` // 响应描述
RequestId string `json:"requestId"` // 请求id
Data *struct {
Url string `json:"url"`
}
}
//#endregion

1
platformapi/gome_live_show/order_test.go Normal file
View File

@@ -0,0 +1 @@
package gome_live_show

121
platformapi/gome_live_show/store_category.go Normal file
View File

@@ -0,0 +1,121 @@
package gome_live_show
import (
"encoding/json"
"errors"
"git.rosy.net.cn/baseapi/utils"
"net/http"
)
// 查询店铺列表
func (a *API) QueryStoreList(storeList *GetStoreListReq) (result *GetStoreListRes, err error) {
if storeList.PageSize == ConstNumberOne {
storeList.PageSize = PageSize
}
if storeList.PageNumber == ConstNumberOne {
storeList.PageNumber = PageNumber
}
storeByte, err := json.Marshal(storeList)
if err != nil {
return nil, err
}
gomeStoreList, err := a.AccessAPI(gomeUrl, GetStoreListApi, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(storeByte)))
if err != nil {
return nil, err
}
resultData := &GetStoreListRes{}
if err := utils.Map2StructByJson(gomeStoreList, resultData, false); err != nil {
return nil, err
}
if resultData.Code != 200 {
return nil, errors.New(resultData.Message)
}
return resultData, nil
}
// 店铺商品分类列表查询
func (a *API) QueryStoreCategoryList(param *QueryStoreGoodsCategoryListReq) (*QueryStoreGoodsCategoryListRes, error) {
byteParam, err := json.Marshal(param)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, GetStoreCategoryListApi, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteParam)))
if err != nil {
return nil, err
}
result := &QueryStoreGoodsCategoryListRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
return result, nil
}
// 店铺商品分类新增
func (a *API) AddStoreCategory(req *StoreAddGoodsCategory) (*SystemParameterRes, error) {
byteParam, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, AddStoreCategoryApi, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteParam)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 店铺商品分类编辑
func (a *API) ModifyStoreGoodsCategory(req *StoreModifyGoodsCategory) (*SystemParameterRes, error) {
byteParam, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, ModifyStoreCategoryApi, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteParam)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 店铺商品分类删除
func (a *API) DeleteStoreGoodsCategory(storeCode, categoryCode string) (*SystemParameterRes, error) {
byteParam, err := json.Marshal(map[string]string{"storeCode": storeCode, "categoryCode": categoryCode})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, DeleteStoreCategoryApi, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteParam)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}

259
platformapi/gome_live_show/store_goods.go Normal file
View File

@@ -0,0 +1,259 @@
package gome_live_show
import (
"encoding/json"
"errors"
"git.rosy.net.cn/baseapi/utils"
"net/http"
)
// 商户商品列表查询
func (a *API) GetMerchantStoreGoodsList(req *QueryStoreGoodsListReq) (*QueryStoreGoodsListRes, error) {
if req.PageNumber == 0 {
req.PageNumber = 1
}
if req.PageSize == 0 {
req.PageSize = 50
}
byteParam, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, GetMerchantGoodsList, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteParam)))
if err != nil {
return nil, err
}
result := &QueryStoreGoodsListRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 商品详情查询，包含商品基本信息名称、图片、品类，规格
func (a *API) QueryMerchantStoreGoodsDetail(spuCode string) (*QueryStoreGoodsDetailsRes, error) {
byteSpuCode, err := json.Marshal(map[string]string{"spuCode": spuCode})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, GetMerchantGoodsDetailList, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteSpuCode)))
if err != nil {
return nil, err
}
result := &QueryStoreGoodsDetailsRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 商户创建新的商品
func (a *API) CreateMerchantGoodsOnStore(req *CreateGoodsListToStore) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, CreateMerchantGoodsToStore, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 修改商户商品，商品一旦创建，不可修改商品的品类和类型，只能修改商品的基础信息，如果规格信息有修改，需要同时入参specProperty 和 skuSaleList
func (a *API) UpdateMerchantGoodsOnStore(req *CreateGoodsListToStore) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, UpdateMerchantGoodsToStore, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 不在使用的商户商品可删除
func (a *API) DeleteGoodsOnStore(spuCode string) (*SystemParameterRes, error) {
param, err := json.Marshal(map[string]string{"spuCode": spuCode})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, DeleteMerchantGoodsToStore, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(param)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 根据店铺编码查询店铺商品列表。
func (a *API) QueryGoodsListById(req *QueryGoodsListForStoreReq) (*QueryGoodsListForStoreRes, error) {
byteReq, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, QueryGoodsListByStoreId, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &QueryGoodsListForStoreRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 查询单商品接口
func (a *API) QueryOneGoodsForStore(storeCode, skuCode string) (*QueryStoreOneGoodsRes, error) {
if storeCode == "" || skuCode == "" {
return nil, errors.New("参数不能为空")
}
byteReq, err := json.Marshal(map[string]string{"storeCode": storeCode, "skuCode": skuCode})
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, QueryOneGoodsByStoreId, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &QueryStoreOneGoodsRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 商品上下架操作 功能描述： 商品上下架,支持单商品或多商品；如果商品在审核中或驳回情况下，
//将禁止商户的上架操作,最多支持10 个sku，此接口不会立刻响应成功或失败，需要调用查询接口确定
func (a *API) OnOffLineGoodsOnStore(req *ShelfGoodsForStoreReq) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, GoodsOnOffLineByStore, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 单商品维护售价
func (a *API) UpdateOnGoodsPriceForStore(req *StoreGoodsPriceUpdateReq) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, UpdatePriceToOneGoodsByStore, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 商品库存更新接口
func (a *API) UpdateStockForStore(req *StoreGoodsStockUpdateReq) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, UpdateGoodsStockForStore, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}
// 新增店铺商品
func (a *API) CreateGoodsForStore(req *CreateGoodsForStoreReq) (*SystemParameterRes, error) {
byteReq, err := json.Marshal(req)
if err != nil {
return nil, err
}
gomeResult, err := a.AccessAPI(gomeUrl, AddGoodsForStore, http.MethodPost, utils.Struct2FlatMap(a.MakeRequestParam(byteReq)))
if err != nil {
return nil, err
}
result := &SystemParameterRes{}
if err := utils.Map2StructByJson(gomeResult, result, false); err != nil {
return nil, err
}
if result.Code != 200 {
return nil, errors.New(result.Message)
}
return result, nil
}

327
platformapi/gome_live_show/store_model.go Normal file
View File

@@ -0,0 +1,327 @@
package gome_live_show
import "time"
//#region 获取商铺详情
// 查询商铺列表
type GetStoreListReq struct {
Page
StoreName string `json:"storeName"`
}
// 查询商品列表返回值
type GetStoreListRes struct {
SystemParameterRes
Data *StoreListRecords
}
type StoreListRecords struct {
Records []*RecordsList `json:"records"`
SystemRecordDataDetailRes
}
type RecordsList struct {
StoreName string `json:"storeName"` // 店铺名称
StoreAlias string `json:"storeAlias"` // 店铺别名
StoreStatus int `json:"storeStatus"` // 店铺营业状态 1 待开店；2 已开店；3 临时闭店；4已闭店
StoreCode string `json:"storeCode"` // 平台店铺编码
}
//#endregion
//#region 店铺商品分类列表查询
// 请求参数
type QueryStoreGoodsCategoryListReq struct {
Page
StoreCode string `json:"storeCode"` // 平台店铺编码
}
// 返回参数
type QueryStoreGoodsCategoryListRes struct {
SystemParameterRes
Data *QueryStoreGoodsCategoryListRecord
}
type QueryStoreGoodsCategoryListRecord struct {
SystemRecordDataDetailRes
Records []*StoreGoodsCategoryListRecord
}
type StoreGoodsCategoryListRecord struct {
CategoryCode string `json:"categoryCode"` // 店铺分类编码
CategoryName string `json:"categoryName"` // 店铺分类名称
Rank int `json:"rank"` // 排序
}
//#endregion
//#region 店铺分类新增
// 店铺商品分类新增
type StoreAddGoodsCategory struct {
StoreCode string `json:"storeCode"` // 平台店铺编码[必填]
CategoryName string `json:"categoryName"` // 分类名称[必填]
Rank int `json:"rank"` // 排序
}
// 店铺商品分类修改
type StoreModifyGoodsCategory struct {
StoreCode string `json:"storeCode"` // 平台店铺编码[必填]
CategoryCode string `json:"categoryCode"` // 店铺商品分类编码[必填]
CategoryName string `json:"categoryName"` // 分类名称[必填]
Rank int `json:"rank"` // 排序[必填]
}
//#endregion
//#region 商户商品列表
// 商户商品列表查询参数
type QueryStoreGoodsListReq struct {
GoodsName string `json:"goodsName"` // 商品名称[非必填]
Cat3Code string `json:"cat3Code"` // 三级品类[非必填]
Page
}
// 返回结构体
type QueryStoreGoodsListRes struct {
SystemParameterRes
Data *QueryStoreGoodsListRecord
}
type QueryStoreGoodsListRecord struct {
SystemRecordDataDetailRes
Records []*struct {
SpuCode string `json:"spuCode"` // 三级品类
GoodsName string `json:"goodsName"` // 商品名称
MainPictureUrl string `json:"mainPictureUrl"` // 商品主图
FullCatName string `json:"fullCatName"` // 商品所属品类 零售/美妆护肤/面部护肤
CreateTime string `json:"createTime"` // 创建时间
}
}
type QueryStoreGoodsListData struct {
SpuCode string `json:"spuCode"` // 三级品类
GoodsName string `json:"goodsName"` // 商品名称
MainPictureUrl string `json:"mainPictureUrl"` // 商品主图
FullCatName string `json:"fullCatName"` // 商品所属品类
CreateTime string `json:"createTime"` // 创建时间
}
//#endregion
//#region 商户商品详情
// 商品详情请求参数
type QueryStoreGoodsDetailsRes struct {
SystemParameterRes
Data *QueryStoreGoodsDetailsData
}
type QueryStoreGoodsDetailsData struct {
SystemRecordDataDetailRes
Records *QueryStoreGoodsDetailsRecords
}
type QueryStoreGoodsDetailsRecords struct {
GoodsName string `json:"goodsName"` // 商品名称
MainPictureUrl string `json:"mainPictureUrl"` // 商品主图
OtherPictureUrl string `json:"otherPictureUrl"` // 商品其他图
VideoUrl string `json:"videoUrl"` // 商品视频
Detail string `json:"detail"` // 商品详情
Cat1Code string `json:"cat1Code"` // 一级目录id
Cat2Code string `json:"cat2Code"` // 二级目录id
Cat3Code string `json:"cat3Code"` // 三级目录id
Cat1Name string `json:"cat1Name"` // 一级目录名称
Cat2Name string `json:"cat2Name"` // 二级目录名称
Cat3Name string `json:"cat3Name"` // 三级目录名称
SpecProperty []*SpecPropertyList `json:"specProperty"` // 商品支持的规格，最多支持5个。
SkuSaleList []*SkuSaleList `json:"skuSaleList"` // 不同规格组合是一个sku，示例：颜色：红
}
// 商品规格
type SpecPropertyList struct {
SpecCode string `json:"specCode"` // 规格id
SpecName string `json:"specName"` // 规格名称(颜色)
SpecValues []*SpecValues
}
// sku
type SkuSaleList struct {
SkuCode string `json:"skuCode"` // 颜色名称(红色)
Specification string `json:"specification"` // 颜色名称(红色)
MarketPrice float64 `json:"marketPrice"` // 颜色名称(红色)
ThirdSkuCode string `json:"thirdSkuCode"` // 颜色名称(红色)
}
//#endregion
//#region 商户创建商品
type CreateGoodsListToStore struct {
GoodsName string `json:"goodsName"` // 商品名称[必填]
MainPictureURL string `json:"mainPictureUrl"` // 商品主图[必填] 格式：png，jpeg大小：3 兆以下，宽高强制比例3：4 像素750px
Detail string `json:"detail"` // 详情[必填]
Cat3Code string `json:"cat3Code"` // 三级类目[必填]
SpecProperty []*SpecProperty `json:"specProperty"` // 规格集合[必填]
SkuSaleList []*SkuSaleListData `json:"skuSaleList"` // sku 售卖组[必填]
GoodsType string `json:"goodsType"` // 商品类型[必填]
OtherPictureURL []string `json:"otherPictureUrl"` // 商品其他图【最多四张】
VideoURL string `json:"videoUrl"` // 格式mp4, 大小：20兆以下，时长30秒以下。
SpecCode string `json:"specCode"` // 规格
SpecName string `json:"specName"` // 规格名称
SpecValues string `json:"specValues"` // 规格值集合
SpecValueCode string `json:"specValueCode"` // 规格值 ID
SpecValueName string `json:"specValueName"` // 规格值
Specification string `json:"specification"` // 规格id集合逗号间隔
MarketPrice float64 `json:"marketPrice"` // 参考价
ThirdSkuCode string `json:"thirdSkuCode"` // 第三方业务编码
}
type SpecValues struct {
SpecValueCode string `json:"specValueCode"` // 规格code
SpecValueName string `json:"specValueName"` // 规格值
}
type SpecProperty struct {
SpecCode string `json:"specCode"` // 规格
SpecName string `json:"specName"` // 规格名称
SpecValues []*SpecValues `json:"specValues"` // 规格值集合
}
type SkuSaleListData struct {
Specification string `json:"specification"` // 规格id集合, 逗号间隔
MarketPrice float64 `json:"marketPrice"` // 参考价
ThirdSkuCode string `json:"thirdSkuCode"` // 第三方业务
}
//#endregion
//#region 批量查询门店商品
// 批量查询门店商品请求参数
type QueryGoodsListForStoreReq struct {
storeCode string `json:"storeCode"` // 平台店铺编码 [必填]
Page
shelveStatus string `json:"shelveStatus"` // 可过滤商品上架状态枚举值；不传递返回全部
Cat1Code string `json:"cat1Code"` // 一级目录id
Cat2Code string `json:"cat2Code"` // 二级目录id
Cat3Code string `json:"cat3Code"` // 三级目录id
}
// 批量查询门店商品请求参数 返回参数
type QueryGoodsListForStoreRes struct {
SystemParameterRes
Data *QueryGoodsListForStoreDataRes
}
type QueryGoodsListForStoreDataRes struct {
SystemRecordDataDetailRes
Records []*QueryGoodsListForStoreRecordRes
}
type QueryGoodsListForStoreRecordRes struct {
SkuCode string `json:"skuCode"`
SpuCode string `json:"spuCode"`
ThirdSkuCode string `json:"thirdSkuCode"`
GoodsName string `json:"goodsName"`
Alias string `json:"alias"`
SalePrice float64 `json:"salePrice"`
MarketPrice float64 `json:"marketPrice"`
GoodsType string `json:"goodsType"`
ShelveStatus string `json:"shelveStatus"`
ShelveDate string `json:"shelveDate"`
UnshelveDate string `json:"unshelveDate"`
StockNum int `json:"stockNum"`
}
//#endregion
//#region 查询单个门店
type QueryStoreOneGoodsRes struct {
SystemParameterRes
Data *QueryStoreOneGoodsDataRes
}
type QueryStoreOneGoodsDataRes struct {
SystemRecordDataDetailRes
Records *QueryStoreOneGoodsRecordRes
}
type QueryStoreOneGoodsRecordRes struct {
SkuCode string `json:"skuCode"` // 平台 sku 编码
SpuCode string `json:"spuCode"` // 平台 spu 编码，乐活秀
ThirdSkuCode string `json:"thirdSkuCode"` // 第三方平台sku 编码
GoodsName string `json:"goodsName"` // 商品名称
Alias string `json:"alias"` // 商品别名或简称
SalePrice float64 `json:"salePrice"` // 商品售价
MarketPrice float64 `json:"marketPrice"` // 参考价
GoodsType string `json:"goodsType"` // 商品类型
FullCatName string `json:"fullCatName"` // 商品所属分类
ShelveDate time.Time `json:"shelveDate"` // 上架时间
UnshelveDate time.Time `json:"unshelveDate"` // 下架时间
StockNum int `json:"stockNum"` // 库存数量
ShelveStatus string `json:"shelveStatus"` // 商品上下架状态
Isshow int `json:"isshow"` // c端隐藏或显示
DeliverType string `json:"deliverType"` // 配送方式
DeliverTemplateCode string `json:"deliverTemplateCode"` // 运费模板
CategoryCodes string `json:"categoryCodes"` // 分类id
CategoryNames string `json:"categoryNames"` // 分类名称
MainPictureURL string `json:"mainPictureUrl"` // 商品主图
OtherPictureURL []string `json:"otherPictureUrl"` // 商品其他图
Specification []string `json:"specification"` // 商品规格属性
FullSpecName string `json:"fullSpecName"` // 商品规格名称
VideoUrls string `json:"videoUrls"` // 商品视频
Detail string `json:"detail"` // 商品详情
}
//#endregion
//#region 平台商品上下架
type ShelfGoodsForStoreReq struct {
StoreCode string `json:"storeCode"` // 平台店铺编码[必填]
SkuCode []string `json:"SkuCode"` // 平台 sku编码[必填]
ShelveStatus string `json:"SkuCode"` // 商品上架状态[必填]
}
//#endregion
//#region 平台商品价格修改
type StoreGoodsPriceUpdateReq struct {
StoreCode string `json:"storeCode"` // 平台店铺编码[必填]
SkuCode string `json:"SkuCode"` // 平台 sku编码[必填]
SalePrice float64 `json:"salePrice"` // 品商上品架售状价，枚两举位值小数,示例：2.51元[必填]
}
//#endregion
//#region 平台商品库存修改
type StoreGoodsStockUpdateReq struct {
StoreCode string `json:"storeCode"` // 平台店铺编码[必填]
ItemStocks []*StoreSkuNum
}
type StoreSkuNum struct {
SkuCode string `json:"skuCode"` // 平台店铺编码
StockNum int64 `json:"stockNum"` // 库存数量
}
//#endregion
//#region 新增平台商品
type CreateGoodsForStoreReq struct {
StoreCode string `json:"storeCode"` // 平台店铺编码[必填]
SkuCode string `json:"SkuCode"` // 平台 sku编码[必填]
SalePrice float64 `json:"salePrice"` // 品商上品架售状价，枚两举位值小数,示例：2.51元[必填]
DeliverType string `json:"deliverType"` // 配送方式[必填]
DeliverTemplateCode string `json:"deliverTemplateCode"` // 运费模板 运费模板信息id，调用查询接口
}
//#endregion

192
platformapi/gome_live_show/store_test.go Normal file
View File

File diff suppressed because one or more lines are too long

32
platformapi/gome_live_show/system_model.go Normal file
View File

@@ -0,0 +1,32 @@
package gome_live_show
// 系统参数,所有接口都需要携带的参数
type SystemParameterReq struct {
AuthToken string `json:"authToken"` // 访问令牌，需要定时刷新获取
Timestamp int64 `json:"timestamp"` // 时间戳（秒）默认有效时间为10分钟
Version string `json:"version"` // 版本号
Sign string `json:"sign"` // 签名
Biz string `json:"biz"` // 业务参数json字符串，为空时请传{}
}
// 系统参数返回值
type SystemParameterRes struct {
Code int64 `json:"code"` // 响应码
Timestamp int64 `json:"timestamp"` // 时间戳（秒）
Message string `json:"message"` // 响应描述
RequestId string `json:"requestId"` // 请求id
}
type Page struct {
PageNumber int `json:"pageNumber"` // 查询页码
PageSize int `json:"pageSize"` // 展示条数默认显示10条最高50条
}
// 系统参数,返回列表数据详情
type SystemRecordDataDetailRes struct {
Page
StartRow int `json:"startRow"` // 开始行
EndRow int `json:"endRow"` // 结束行
Total int `json:"total"` // 列表总数
PageTotal int `json:"pageTotal"` // 总页数
}

39
platformapi/gome_live_show/token_model.go Normal file
View File

@@ -0,0 +1,39 @@
package gome_live_show
import (
"git.rosy.net.cn/baseapi/platformapi"
"net/http"
"sync"
)
// 注册请求api
type API struct {
code string `json:"code"` // 商户码
appKey string `json:"appKey"` // appkey
sign string `json:"sign"` // 签名
timestamp string `json:"timestamp"` // 请求时间戳
appSecret string `json:"app_secret"` // 私钥
refreshToken string `json:"refresh_token"` // 刷新token
expiration string `json:"expiration"` // 刷新token过期时间
sessionToken string `json:"session_token"` // token
version string `json:"version"` // 版本
locker sync.RWMutex
client *http.Client
config *platformapi.APIConfig
}
// 国美token
type gomeToken struct {
Code int64 `json:"code"`
Timestamp int64 `json:"timestamp"`
Data *TokenInfo `json:"data"`
RequestId string `json:"request_id"`
}
// 获取token
type TokenInfo struct {
SessionToken string `json:"sessionToken"` // 商家令牌 sessionToken String
Expiration string `json:"expiration"` // 授权到期时间
RefreshToken string `json:"refreshToken"` // 刷新令牌
AppKey string `json:"appKey"` // 应用 code
}