baseapi/platformapi/ebaiapi/shop_sku.go

package ebaiapi

import (
	"git.rosy.net.cn/baseapi/utils"
)

const (
	SkuStatusOnline  = 1
	SkuStatusOffline = 0
)

const (
	UPCTypeStandard = 1
	UPCTypePrivate  = 0
)
const (
	MaxLeftNum = 9999
)

type CategoryInfo struct {
	CategoryID   int64           `json:"category_id"`
	ShopCustomID string          `json:"shop_custom_id"`
	Name         string          `json:"name"`
	Rank         int             `json:"rank"` // 店内分类独有
	Children     []*CategoryInfo `json:"children"`
	Level        int             `json:"level"`
}

type PageDataInfo struct {
	Total int
	Page  int
	Pages int
	List  []map[string]interface{}
}

// category相关的函数，shop_custom_id可重

func (a *API) ShopCategoryCreate(shopID string, parentID int64, name string, rank int, shopCustomID string) (catID int64, err error) {
	result, err := a.AccessAPI("sku.shop.category.create", map[string]interface{}{
		KeyShopID:            shopID,
		"parent_category_id": parentID,
		"name":               name,
		"rank":               rank,
		"shop_custom_id":     shopCustomID,
	})
	if err == nil {
		return utils.Str2Int64(utils.Interface2String(result.Data.(map[string]interface{})["category_id"])), nil
	}
	return 0, err
}

func (a *API) ShopCategoryGet(shopID string) (cats []*CategoryInfo, err error) {
	result, err := a.AccessAPI("sku.shop.category.get", utils.Params2Map(KeyShopID, shopID))
	if err == nil {
		if inMap, ok := result.Data.(map[string]interface{}); ok { // fuck it
			cats := interface2CatList(inMap["categorys"], 1)
			return cats, nil
		}
	}
	return nil, err
}

func (a *API) ShopCategoryUpdate(shopID string, categoryID int64, name string, rank int, shopCustomID string) (err error) {
	_, err = a.AccessAPI("sku.shop.category.update", map[string]interface{}{
		KeyShopID:        shopID,
		"category_id":    categoryID,
		"name":           name,
		"rank":           rank,
		"shop_custom_id": shopCustomID,
	})
	if errWithCode, ok := err.(*utils.ErrorWithCode); ok {
		if errWithCode.Level() == 0 && errWithCode.IntCode() == 1 { //忽略同名错误
			err = nil
		}
	}
	return err
}

func (a *API) ShopCategoryDelete(shopID string, categoryID int64) (err error) {
	_, err = a.AccessAPI("sku.shop.category.delete", map[string]interface{}{
		KeyShopID:     shopID,
		"category_id": categoryID,
	})
	return err
}

func (a *API) SkuGetItemsByCategoryId(shopID string, categoryID int64) (skus []map[string]interface{}, err error) {
	result, err := a.AccessAPI("sku.getItemsByCategoryId", map[string]interface{}{
		KeyShopID:     shopID,
		"category_id": categoryID,
	})
	if err == nil {
		return utils.Slice2MapSlice(result.Data.([]interface{})), nil
	}
	return nil, err
}

func (a *API) SkuList(shopID string, params map[string]interface{}) (skuInfo *PageDataInfo, err error) {
	defParams := map[string]interface{}{
		KeyShopID: shopID,
	}
	result, err := a.AccessAPI("sku.list", utils.MergeMaps(params, defParams))
	if err == nil {
		data := result.Data.(map[string]interface{})
		return &PageDataInfo{
			Total: int(utils.MustInterface2Int64(data["total"])),
			Page:  int(utils.MustInterface2Int64(data["page"])),
			Pages: int(utils.MustInterface2Int64(data["pages"])),
			List:  utils.Slice2MapSlice(data["list"].([]interface{})),
		}, nil
	}
	return nil, err
}

func (a *API) SkuCreate(shopID string, customSkuID int, params map[string]interface{}) (skuID int64, err error) {
	defParams := map[string]interface{}{
		KeyShopID:       shopID,
		"custom_sku_id": customSkuID,
		"upc_type":      UPCTypePrivate,
		"brand_name":    "无", // 很狗血的是，你还必须填个无才行。。。
	}
	if params["upc"] == nil {
		defParams["upc"] = "upc-" + utils.Int2Str(customSkuID)
	}
	if params["brand_id"] == nil {
		defParams["brand_id"] = 0
	}
	result, err := a.AccessAPI("sku.create", utils.MergeMaps(params, defParams))
	if err == nil {
		return utils.Str2Int64(utils.Interface2String(result.Data.(map[string]interface{})["sku_id"])), nil
	}
	return 0, err
}

func (a *API) SkuUpdate(shopID string, ebaiSkuID int64, params map[string]interface{}) (skuID int64, err error) {
	defParams := map[string]interface{}{
		KeyShopID: shopID,
		"sku_id":  ebaiSkuID,
	}
	result, err := a.AccessAPI("sku.update", utils.MergeMaps(params, defParams))
	if err == nil {
		return utils.Str2Int64(utils.Interface2String(result.Data.(map[string]interface{})["sku_id"])), nil
	}
	return 0, err
}

func (a *API) SkuDelete(shopID, skuIDsStr string) (err error) {
	params := map[string]interface{}{
		KeyShopID: shopID,
		"sku_id":  skuIDsStr,
	}
	_, err = a.AccessAPI("sku.delete", params)
	if err == nil {
		return nil
	}
	return err
}

func (a *API) SkuOnline(shopID, skuIDsStr string) (err error) {
	params := map[string]interface{}{
		KeyShopID: shopID,
		"sku_id":  skuIDsStr,
	}
	_, err = a.AccessAPI("sku.online", params)
	if err == nil {
		return nil
	}
	return err
}

func (a *API) SkuOffline(shopID, skuIDsStr string) (err error) {
	params := map[string]interface{}{
		KeyShopID: shopID,
		"sku_id":  skuIDsStr,
	}
	_, err = a.AccessAPI("sku.offline", params)
	if err == nil {
		return nil
	}
	return err
}

func (a *API) SkuShopCategoryMap(shopID string, skuID int64, categoryIDsStr string) (err error) {
	params := map[string]interface{}{
		KeyShopID:     shopID,
		"sku_id":      skuID,
		"category_id": categoryIDsStr,
	}
	_, err = a.AccessAPI("sku.shop.category.map", params)
	if err == nil {
		return nil
	}
	return err
}

//
func interface2CatList(data interface{}, level int) (cats []*CategoryInfo) {
	maps, ok := data.([]interface{})
	if ok {
		cats = make([]*CategoryInfo, len(maps))
		for index, v := range maps {
			cats[index] = interface2Cat(v, level)
		}
	}
	return cats
}

func interface2Cat(data interface{}, level int) (cat *CategoryInfo) {
	catMap := data.(map[string]interface{})
	cat = &CategoryInfo{
		CategoryID:   utils.MustInterface2Int64(catMap["category_id"]),
		ShopCustomID: utils.Interface2String(catMap["shop_custom_id"]),
		Name:         utils.Interface2String(catMap["name"]),
		Rank:         int(utils.MustInterface2Int64(catMap["rank"])),
		Children:     interface2CatList(catMap["children"], level+1),
		Level:        level,
	}
	return cat
}