package _type

import (
	"fmt"
	"reflect"
	"strings"
	"unicode/utf8"
)

// ErrResponse 错误响应
type ErrResponse struct {
	Code int         `json:"code"`
	Msg  string      `json:"msg"`
	Data interface{} `json:"data"`
}

// 品牌捡漏信息-生产信息
type ExpireInfoBrand struct {
	Num  int32  `json:"num"`  // 保质期（必需），范围：1-9999
	Unit string `json:"unit"` // 单位（必需），枚举值：天、月、年
}

// 品牌捡漏信息-有效期信息
type ProductionInfoBrand struct {
	Date string `json:"date"` // 食品生产日期（必需），长度限制：1-20个字符
}

// 品牌捡漏信息-新图片信息
type ImageInfo struct {
	Src    string `json:"src"`    // 图片地址（必需）
	Width  int32  `json:"width"`  // 图片宽度（必需）
	Height int32  `json:"height"` // 图片高度（必需）
}

// CategoryListRequest 商品分类列表请求结构体
type CategoryListRequest struct {
	ItemBizType   int `json:"item_biz_type"`             // 商品类型（必需）
	SpBizType     int `json:"sp_biz_type,omitempty"`     // 行业类型（可选）
	FlashSaleType int `json:"flash_sale_type,omitempty"` // 闲鱼特卖类型（可选）
}

// CategoryListResponse 商品分类列表响应结构体
type CategoryListResponse struct {
	Code int          `json:"code"`
	Msg  string       `json:"msg"`
	Data CategoryData `json:"data"`
}

// CategoryData 分类数据
type CategoryData struct {
	List []CategoryItem `json:"list"`
}

// CategoryItem 分类项
type CategoryItem struct {
	SpBizType      int    `json:"sp_biz_type"`      // 行业类型
	SpBizName      string `json:"sp_biz_name"`      // 行业名称
	ChannelCatId   string `json:"channel_cat_id"`   // 渠道类目ID
	ChannelCatName string `json:"channel_cat_name"` // 渠道类目名称
}

// 咸鱼特卖-生产信息
type ExpireInfoAdvent struct {
	Num  int32  `json:"num"`  // 保质期（必需），范围：1-9999
	Unit string `json:"unit"` // 单位（必需），枚举值：天、月、年
}

// 咸鱼特卖-有效期信息
type ProductionInfoAdvent struct {
	Date string `json:"date"` // 食品生产日期（必需），长度限制：1-20个字符
}

// 食品生产信息-食品生产地信息
type AddressInfo struct {
	Detail   string `json:"detail"`   // 详细地址（必需），长度限制：1-60个字符
	Province int32  `json:"province"` // 生产地省份ID（必需）
	City     int32  `json:"city"`     // 生产地城市ID（必需）
	District int32  `json:"district"` // 生产地地区ID（必需）
}

// 食品信息-食品有效期信息
type ExpireInfoFood struct {
	Num  int32  `json:"num"`  // 保质期（必需），范围：1-9999
	Unit string `json:"unit"` // 单位（必需），枚举值：天、月、年
}

// 食品信息-食品生产信息
type ProductionInfoFood struct {
	Date    string      `json:"date"`    // 食品生产日期（必需），长度限制：1-20个字符
	Address AddressInfo `json:"address"` // 食品生产地信息（必需）
}

// 严选3c-质检报告项
type ReportItem struct {
	AnswerID     int32  `json:"answer_id"`     // 选项ID（必需）
	AnswerName   string `json:"answer_name"`   // 选项名称（必需）
	AnswerType   int32  `json:"answer_type"`   // 选项类型（必需）
	AnswerDesc   string `json:"answer_desc"`   // 选项描述（必需）
	QuestionName string `json:"question_name"` // 问题名称（必需）
	CategoryName string `json:"category_name"` // 分类名称（必需）
	GroupName    string `json:"group_name"`    // 分组名称（必需）
}

// 验货报告-美妆信息
type BeautyMakeup struct {
	Brand   string   `json:"brand"`    // 品牌（必需）
	Spec    string   `json:"spec"`     // 规格（必需）
	Level   string   `json:"level"`    // 成色（必需）
	OrgID   int32    `json:"org_id"`   // 检测机构ID（必需）
	OrgName string   `json:"org_name"` // 检测机构名称（必需）
	Images  []string `json:"images"`   // 图片信息（必需），1-30个项
}

// 验货报告-文玩信息
type Curio struct {
	Size     string   `json:"size"`     // 尺寸（必需）
	Material string   `json:"material"` // 材料（必需）
	OrgID    int32    `json:"org_id"`   // 检测机构ID（必需）
	OrgName  string   `json:"org_name"` // 检测机构名称（必需）
	QcNo     string   `json:"qc_no"`    // 验货编码（必需）
	Images   []string `json:"images"`   // 图片信息（必需），1-30个项
}

// 验货报告-珠宝信息
type Jewelry struct {
	Shape   string   `json:"shape"`    // 形状（必需）
	Color   string   `json:"color"`    // 颜色（必需）
	Weight  string   `json:"weight"`   // 重量（必需）
	OrgName string   `json:"org_name"` // 检测机构名称（必需）
	QcNo    string   `json:"qc_no"`    // 验货编码（必需）
	QcDesc  string   `json:"qc_desc"`  // 验货描述（必需）
	Images  []string `json:"images"`   // 图片信息（必需），1-30个项
}

// 验货报告-游戏信息
type Game struct {
	Title    string   `json:"title"`    // 报告标题（必需）
	Platform string   `json:"platform"` // 游戏平台（必需）
	QcNo     string   `json:"qc_no"`    // 验货编码（必需）
	QcDesc   string   `json:"qc_desc"`  // 验货描述（必需）
	Images   []string `json:"images"`   // 图片信息（必需），1-30个项
}

// 验货报告-OpenProductReportUsedCar
type UsedCar struct {
	ReportURL              string `json:"report_url,omitempty"`                // 验货报告链接（可选）
	DrivingLicenseInfo     string `json:"driving_license_info,omitempty"`      // 行驶证主页图片（可选）
	DrivingLicenseCarPhoto string `json:"driving_license_car_photo,omitempty"` // 行驶证车辆页图片（可选）
	BusinessLicenseFront   string `json:"business_license_front,omitempty"`    // 营业执照图片（可选）
	CarFunction            string `json:"car_function,omitempty"`              // 使用性质（可选）
	CarVin                 string `json:"car_vin,omitempty"`                   // 车辆识别代码VIN码（可选）
}

// 验货报告-奢品信息
type Valuable struct {
	OrgID   int32    `json:"org_id"`   // 检测机构ID（必需）
	OrgName string   `json:"org_name"` // 检测机构名称（必需）
	QcNo    string   `json:"qc_no"`    // 验货编码（必需）
	QcDesc  string   `json:"qc_desc"`  // 验货描述（必需）
	Images  []string `json:"images"`   // 图片信息（必需），1-30个项
}

// 验货报告-严选3c信息
type Yx3c struct {
	ClassID     int32      `json:"class_id"`     // 品类ID（必需）
	SubclassID  int32      `json:"subclass_id"`  // 子类ID（必需）
	BrandID     int32      `json:"brand_id"`     // 品牌ID（必需）
	BrandName   string     `json:"brand_name"`   // 品牌名称（必需）
	ModelID     int32      `json:"model_id"`     // 机型ID（必需）
	ModelName   string     `json:"model_name"`   // 机型名称（必需）
	ModelSn     string     `json:"model_sn"`     // IMEI/序列号（必需）
	ReportUser  string     `json:"report_user"`  // 质检人（必需）
	ReportTime  string     `json:"report_time"`  // 质检时间（必需）
	ReportItems ReportItem `json:"report_items"` // 质检报告项（必需）
	AnswerIDs   []int32    `json:"answer_ids"`   // 质检选项ID（必需），内部存储
}

// 商品属性（可选）
type ChannelPv struct {
	PropertyID   string `json:"property_id"`   // 属性ID（必需）示例值: 83b8f62c43df34e6
	PropertyName string `json:"property_name"` // 属性名称（必需）示例值: 品牌
	ValueID      string `json:"value_id"`      // 属性值ID（必需）示例值: 76f78d92eeb4f5f6eccf7d4fabef47b6
	ValueName    string `json:"value_name"`    // 属性值名称（必需）示例值: Apple/苹果
}

// 发布店铺（必需）
type PublishShop struct {
	UserName       string   `json:"user_name"`       // 闲鱼会员名（必需）
	Province       int32    `json:"province"`        // 商品发货省份（必需）
	City           int32    `json:"city"`            // 商品发货城市（必需）
	District       int32    `json:"district"`        // 商品发货地区（必需）
	Title          string   `json:"title"`           // 商品标题（必需），注意：一个中文按2个字符算，长度限制：1-60个字符
	Content        string   `json:"content"`         // 商品描述（必需），注意：一个中文按2个字符算，不支持HTML代码，可使用\n换行，长度限制：5-5000字符
	Images         []string `json:"images"`          // 图片信息（必需），数量限制：1-30张
	WhiteImages    string   `json:"white_images"`    // 商品白底图URL（可选），注意：1.如果传入会在闲鱼商品详情显示且无法删除只能修改 2.当商品类型是特卖类型(item_biz_type=24)时为必填
	ServiceSupport string   `json:"service_support"` // 商品服务项（可选），多个时用英文逗号拼接。枚举值：SDR(七天无理由退货)、NFR(描述不符包邮退)、VNR(描述不符全额退-虚拟类)、FD_10MS(10分钟极速发货-虚拟类)、FD_24HS(24小时极速发货)、FD_48HS(48小时极速发货)、FD_GPA(正品保障)
}

// 拍卖信息（可选）
type BidData struct {
	BidStartTime     string `json:"bid_start_time"`     // 拍卖开始时间（必需），示例值：2023-07-21 00:00:00
	BidEndTime       string `json:"bid_end_time"`       // 拍卖结束时间（必需），示例值：2023-07-21 00:00:00
	BidReservePrice  int64  `json:"bid_reserve_price"`  // 拍卖起拍价（分）（必需），范围：100-9999999900
	BidIncreasePrice int64  `json:"bid_increase_price"` // 拍卖加拍价（分）（必需），范围：100-10000
	BidDeposit       int64  `json:"bid_deposit"`        // 拍卖保证金（分）（必需），范围：100-9999999900
}

// 多规格信息（可选）
type SkuItems struct {
	Price   int64  `json:"price"`    // 商品售价（必需），单位：分，范围：1-9999999900
	Stock   int32  `json:"stock"`    // SKU库存（必需），范围：0-9999
	SkuText string `json:"sku_text"` // SKU规格（必需），格式：规格:属性，多个时使用";"拼接，如：颜色:白色;容量:128G
	OuterId string `json:"outer_id"` // SKU商品编码（可选），长度限制：0-64个字符（一个中文按2个字符算）
}

// 图书信息（可选）
type BookData struct {
	ISBN      string `json:"isbn"`      // 图书ISBN码（必需），格式校验：/^((?:[0-9]{9}X|[0-9]{10})|(?:(?:97(?:8|9))[0-9]{10}))$/
	Title     string `json:"title"`     // 图书标题（必需）
	Author    string `json:"author"`    // 图书作者（可选），长度限制：1-30个字符
	Publisher string `json:"publisher"` // 图书出版社（可选），长度限制：1-30个字符
}

// 食品信息（可选）
type FoodInfo struct {
	Brand      string             `json:"brand"`      // 食品品牌（必需），长度限制：1-30个字符
	Spec       string             `json:"spec"`       // 食品规格（必需），长度限制：1-30个字符
	Pack       string             `json:"pack"`       // 食品包装（必需），长度限制：1-10个字符
	Expire     ExpireInfoFood     `json:"expire"`     // 食品有效期信息（必需）
	Production ProductionInfoFood `json:"production"` // 食品生产信息（必需）
}

// 验货报告信息
type ReportData struct {
	BeautyMakeup BeautyMakeup `json:"beauty_makeup,omitempty"` // 美妆信息（可选）
	Curio        Curio        `json:"curio,omitempty"`         // 文玩信息（可选）
	Jewelry      Jewelry      `json:"jewelry,omitempty"`       // 珠宝信息（可选）
	Game         Game         `json:"game,omitempty"`          // 游戏信息（可选）
	UsedCar      UsedCar      `json:"used_car,omitempty"`      // 二手车信息（可选）
	Valuable     Valuable     `json:"valuable,omitempty"`      // 奢品信息（可选）
	Yx3c         Yx3c         `json:"yx_3c,omitempty"`         // 严选3c信息（可选）
}

// 闲鱼特卖信息
type AdventData struct {
	Expire     ExpireInfoAdvent     `json:"expire"`     // 有效期信息 （必需）
	Production ProductionInfoAdvent `json:"production"` // 生产信息 （必需）
}

// 验货宝信息
type InspectData struct {
	TradeRule  string `json:"trade_rule"`  //交易规则（必需）
	AssumeRule string `json:"assume_rule"` //验货费规则 （必需）
}

// 品牌捡漏信息
type BrandData struct {
	Expire     ExpireInfoBrand     `json:"expire"`     // 有效期信息 （可选）
	Production ProductionInfoBrand `json:"production"` // 生产信息 （可选）
	Supplier   string              `json:"supplier"`   // 供应商名称（可选）
	Images     ImageInfo           `json:"images"`     // 新图片信息（可选）
}

// 新图片信息
type DetailImage struct {
	Src    string `json:"src"`    // 图片地址（必需）
	Width  int32  `json:"width"`  // 图片宽度（必需）
	Height int32  `json:"height"` // 图片高度（必需）
}

// 规格图片信息
type SkuImages struct {
	Src     string `json:"src"`      // 图片地址（必需）
	Width   int32  `json:"width"`    // 图片宽度（必需）
	Height  int32  `json:"height"`   // 图片高度（必需）
	SkuText string `json:"sku_text"` // 规格属性（必需）
}

// BashCreat 咸鱼批量创建商品 Body参数
type BashCreat struct {
	ItemKey       string        `json:"item_key"`        // 批次商品KEY（必需），原样返回，用于匹配商家自己的商品
	ItemBizType   int32         `json:"item_biz_type"`   // 商品类型（必需），枚举值：2-普通商品,0-已验货,10-验货宝,16-品牌授权,19-闲鱼严选,24-闲鱼特卖,26-品牌捡漏
	SpBizType     int32         `json:"sp_biz_type"`     // 行业类型（必需），枚举值：1-手机,2-潮品,3-家电,8-乐器,9-3C数码,16-奢品,17-母婴,18-美妆个护,19-文玩/珠宝,20-游戏电玩,21-家居,22-虚拟游戏,23-租号,24-图书,25-卡券,27-食品,28-潮玩,29-二手车,30-宠植,31-工艺礼品,33-汽车服务,99-其他
	ChannelCatId  string        `json:"channel_cat_id"`  // 商品类目ID（必需），通过查询商品类目接口获取类目参数
	ChannelPv     []ChannelPv   `json:"channel_pv"`      // 商品属性（可选）
	Price         int64         `json:"price"`           // 商品售价（必需），范围：1-9999999900，单位：分
	OriginalPrice int64         `json:"original_price"`  // 商品原价（可选），范围：0-9999999900，单位：分
	ExpressFee    int64         `json:"express_fee"`     // 运费（可选），单位：分
	Stock         int32         `json:"stock"`           // 商品库存（必需），注意：多规格商品，必须是SKU库存的合计，范围：1-399960
	OuterId       string        `json:"outer_id"`        // 商家编码（可选），长度限制：1-64个字符
	StuffStatus   int32         `json:"stuff_status"`    // 商品成色（可选），枚举值：0-无成色,100-全新,-1-准新,99-99新,95-95新,90-9新,80-8新,70-7新,60-6新,50-5新,40-未使用·中度瑕疵,30-未使用·轻微瑕疵,20-未使用·仅拆封,10-未使用·准新,100-全新未使用
	PublishShop   []PublishShop `json:"publish_shop"`    // 发布店铺（必需）
	BidData       []BidData     `json:"bid_data"`        // 拍卖信息（可选）
	SkuItems      []SkuItems    `json:"sku_items"`       // 商品多规格信息（可选）
	BookData      BookData      `json:"book_data"`       // 图书信息（可选）
	FoodData      []FoodInfo    `json:"food_data"`       // 食品信息（可选）
	ReportData    []ReportData  `json:"report_data"`     // 验货报告信息（可选）
	FlashSaleType int32         `json:"flash_sale_type"` // 闲鱼特卖类型（可选），枚举值：1-临期,2-孤品,3-断码,4-微瑕,5-尾货,6-官翻,7-全新,8-福袋,99-其他,2601-微瑕,2602-临期,2603-清仓,2604-官翻
	AdventData    []AdventData  `json:"advent_data"`     // 闲鱼特卖信息（可选）
	InspectData   []InspectData `json:"inspect_data"`    // 验货宝信息（可选）
	BrandData     []BrandData   `json:"brand_data"`      // 品牌捡漏信息（可选）
	DetailImages  []DetailImage `json:"detail_images"`   // 新图片信息（可选）
	SkuImages     []SkuImages   `json:"sku_images"`      // 规格图片（可选）
}

// BashCreat 咸鱼批量创建商品 Body参数
type BashCreatNew struct {
	ItemKey       string        `json:"item_key"`       // 批次商品KEY（必需），原样返回，用于匹配商家自己的商品
	ItemBizType   int32         `json:"item_biz_type"`  // 商品类型（必需），枚举值：2-普通商品,0-已验货,10-验货宝,16-品牌授权,19-闲鱼严选,24-闲鱼特卖,26-品牌捡漏
	SpBizType     int32         `json:"sp_biz_type"`    // 行业类型（必需），枚举值：1-手机,2-潮品,3-家电,8-乐器,9-3C数码,16-奢品,17-母婴,18-美妆个护,19-文玩/珠宝,20-游戏电玩,21-家居,22-虚拟游戏,23-租号,24-图书,25-卡券,27-食品,28-潮玩,29-二手车,30-宠植,31-工艺礼品,33-汽车服务,99-其他
	ChannelCatId  string        `json:"channel_cat_id"` // 商品类目ID（必需），通过查询商品类目接口获取类目参数
	ChannelPv     []ChannelPv   `json:"channel_pv"`     // 商品属性（可选）
	Price         int64         `json:"price"`          // 商品售价（必需），范围：1-9999999900，单位：分
	OriginalPrice int64         `json:"original_price"` // 商品原价（可选），范围：0-9999999900，单位：分
	ExpressFee    int64         `json:"express_fee"`    // 运费（可选），单位：分
	Stock         int32         `json:"stock"`          // 商品库存（必需），注意：多规格商品，必须是SKU库存的合计，范围：1-399960
	OuterId       string        `json:"outer_id"`       // 商家编码（可选），长度限制：1-64个字符
	StuffStatus   int32         `json:"stuff_status"`   // 商品成色（可选），枚举值：0-无成色,100-全新,-1-准新,99-99新,95-95新,90-9新,80-8新,70-7新,60-6新,50-5新,40-未使用·中度瑕疵,30-未使用·轻微瑕疵,20-未使用·仅拆封,10-未使用·准新,100-全新未使用
	PublishShop   []PublishShop `json:"publish_shop"`   // 发布店铺（必需）
	BidData       []BidData     `json:"bid_data"`       // 拍卖信息（可选）
	SkuItems      []SkuItems    `json:"sku_items"`      // 商品多规格信息（可选）
	// BookData      BookData      `json:"book_data"`       // 图书信息（可选）
	FoodData      []FoodInfo    `json:"food_data"`       // 食品信息（可选）
	ReportData    []ReportData  `json:"report_data"`     // 验货报告信息（可选）
	FlashSaleType int32         `json:"flash_sale_type"` // 闲鱼特卖类型（可选），枚举值：1-临期,2-孤品,3-断码,4-微瑕,5-尾货,6-官翻,7-全新,8-福袋,99-其他,2601-微瑕,2602-临期,2603-清仓,2604-官翻
	AdventData    []AdventData  `json:"advent_data"`     // 闲鱼特卖信息（可选）
	InspectData   []InspectData `json:"inspect_data"`    // 验货宝信息（可选）
	BrandData     []BrandData   `json:"brand_data"`      // 品牌捡漏信息（可选）
	DetailImages  []DetailImage `json:"detail_images"`   // 新图片信息（可选）
	SkuImages     []SkuImages   `json:"sku_images"`      // 规格图片（可选）
}

type BookDataInput struct {
	ISBN        string  `json:"isbn"`        // 图书ISBN码（必需），格式校验：/^((?:[0-9]{9}X|[0-9]{10})|(?:(?:97(?:8|9))[0-9]{10}))$/
	Title       string  `json:"title"`       // 图书标题（必需）
	Author      string  `json:"author"`      // 图书作者（可选），长度限制：1-30个字符
	Publisher   string  `json:"publisher"`   // 图书出版社（可选），长度限制：1-30个字符
	Prices      []int64 `json:"prices"`      // 价格数组[商品原价，商品售价，...]
	Stock       int32   `json:"stock"`       // 库存
	ItemBizType int32   `json:"itemBizType"` // 咸鱼_商品类型（必需），枚举值：2-普通商品,0-已验货,10-验货宝,16-品牌授权,19-闲鱼严选,24-闲鱼特卖,26-品牌捡漏
	SpBizType   int32   `json:"spBizType"`   // 咸鱼_行业类型（必需），枚举值：1-手机,2-潮品,3-家电,8-乐器,9-3C数码,16-奢品,17-母婴,18-美妆个护,19-文玩/珠宝,20-游戏电玩,21-家居,22-虚拟游戏,23-租号,24-图书,25-卡券,27-食品,28-潮玩,29-二手车,30-宠植,31-工艺礼品,33-汽车服务,99-其他
	CatIds      string  `json:"catIds"`
}

type BookDataInputNew struct {
	ISBN      string `json:"isbn"`      // 图书ISBN码（必需），格式校验：/^((?:[0-9]{9}X|[0-9]{10})|(?:(?:97(?:8|9))[0-9]{10}))$/
	Title     string `json:"title"`     // 图书标题（必需）
	Author    string `json:"author"`    // 图书作者（可选），长度限制：1-30个字符
	Publisher string `json:"publisher"` // 图书出版社（可选），长度限制：1-30个字符
}

type SkuMsg struct {
	Key         string   `json:"key"`         // 必填
	Value       string   `json:"value"`       // 必填
	Title       string   `json:"title"`       // 必填
	CatIds      string   `json:"cat_ids"`     // 必填
	MainImgs    []string `json:"mainImgs"`    // 主图, 数组形式
	ContentImgs []string `json:"contentImgs"` // 内容图，数组形式
	Content     string   `json:"content"`     // 商品描述
	UserName    string   `json:"userName"`    // 用户名
}

type Shop struct {
	UserName    string   `json:"userName"` // 用户名
	Province    int32    `json:"province"`
	City        int32    `json:"city"`
	District    int32    `json:"district"`
	Title       string   `json:"title"`       // 必填
	Content     string   `json:"content"`     // 商品描述
	MainImgs    []string `json:"mainImgs"`    // 主图, 数组形式
	ContentImgs []string `json:"contentImgs"` // 内容图，数组形式
}

type Body struct {
	AppId        int             `json:"appId"`
	AppSecret    string          `json:"appSecret"`
	OuterId      string          `json:"outerId"`
	Token        string          `json:"token"`
	ApiShopId    int             `json:"apiShopId"`
	TypePlatform int             `json:"typePlatform"`
	ShopId       int             `json:"shopId"`
	ShopToken    string          `json:"shopToken"`
	ShopName     string          `json:"shopName"`
	Province     int32           `json:"province"`
	City         int32           `json:"city"`
	District     int32           `json:"district"`
	TypeClass    string          `json:"typeClass"`
	TypeGoods    string          `json:"typeGoods"`
	CatIds       string          `json:"catIds"`
	SkuMsgs      []SkuMsg        `json:"skuMsgs"`
	StuffStatus  int             `json:"stuffStatus"`
	ItemKey      string          `json:"itemKey"`
	BookData     []BookDataInput `json:"bookData"`
	Shop         []Shop          `json:"shop"`
}

type BodyNew struct {
	AppId         int                `json:"appId"`
	AppSecret     string             `json:"appSecret"`
	OuterId       string             `json:"outerId"`
	Token         string             `json:"token"`
	ApiShopId     int                `json:"apiShopId"`
	TypePlatform  int                `json:"typePlatform"`
	ShopId        int                `json:"shopId"`
	ShopToken     string             `json:"shopToken"`
	ShopName      string             `json:"shopName"`
	Province      int32              `json:"province"`
	City          int32              `json:"city"`
	District      int32              `json:"district"`
	TypeClass     string             `json:"typeClass"`
	TypeGoods     string             `json:"typeGoods"`
	CatIds        string             `json:"catIds"`
	SkuMsgs       []SkuMsg           `json:"skuMsgs"`
	StuffStatus   int                `json:"stuffStatus"`
	ItemKey       string             `json:"itemKey"`
	BookData      []BookDataInputNew `json:"bookData"`
	Shop          []Shop             `json:"shop"`
	Price         int64              `json:"price"`
	OriginalPrice int64              `json:"original_price"`
	Stock         int32              `json:"stock"`
	ItemBizType   int32              `json:"itemBizType"`
	SpBizType     int32              `json:"spBizType"`
}

type ListedProducts struct {
	ProductId          int      `json:"product_id"`           //管家商品ID
	UserName           []string `json:"user_name"`            //闲鱼会员名
	SpecifyPublishTime string   `json:"specify_publish_time"` //定时上架时间
	NotifyUrl          string   `json:"notify_url"`           //上架回调地址
	AppId              int      `json:"appId"`
	AppSecret          string   `json:"appSecret"`
}

type DownAndFlash struct {
	ProductId int64  `json:"product_id"`
	AppId     int    `json:"appId"`
	AppSecret string `json:"appSecret"`
}

type EditPrices struct {
	ProductId     int64  `json:"product_id"`
	Price         int64  `json:"price"`
	OriginalPrice int64  `json:"original_price"`
	AppId         int    `json:"appId"`
	AppSecret     string `json:"appSecret"`
}

type EditStock struct {
	ProductId int64  `json:"product_id"`
	Stock     int32  `json:"stock"`
	AppId     int    `json:"appId"`
	AppSecret string `json:"appSecret"`
}

type SelectGoodsListWithTime struct {
	OfflineTime   []int64 `json:"offline_time"`
	ProductStatus int32   `json:"product_status"`
	AppId         int     `json:"appId"`
	AppSecret     string  `json:"appSecret"`
	PageNo        int32   `json:"page_no"`
	PageSize      int32   `json:"page_size"`
}

type SelectGoodsListWithoutTime struct {
	ProductStatus int32  `json:"product_status"`
	AppId         int    `json:"appId"`
	AppSecret     string `json:"appSecret"`
	PageNo        int32  `json:"page_no"`
	PageSize      int32  `json:"page_size"`
}

type GetShopList struct {
	AppId     int    `json:"appId"`
	AppSecret string `json:"appSecret"`
}

type GetOrderShip struct {
	AppId          int    `json:"appId"`
	AppSecret      string `json:"appSecret"`
	OrderNo        string `json:"order_no"`
	ShipName       string `json:"ship_name"`
	ShipMobile     string `json:"ship_mobile"`
	ShipDistrictID int    `json:"ship_district_id"`
	ShipProvName   string `json:"ship_prov_name"`
	ShipCityName   string `json:"ship_city_name"`
	ShipAreaName   string `json:"ship_area_name"`
	ShipAddress    string `json:"ship_address"`
	WaybillNo      string `json:"waybill_no"`
	ExpressName    string `json:"express_name"`
	ExpressCode    string `json:"express_code"`
}

type GetGoosDetail struct {
	ProductId int64  `json:"product_id"`
	AppId     int    `json:"appId"`
	AppSecret string `json:"appSecret"`
}

// ================校验相关函数===============

// ValidationError 校验错误类型
type ValidationError struct {
	Errors []string
}

func (v *ValidationError) Error() string {
	return strings.Join(v.Errors, "; ")
}

func (v *ValidationError) Add(field, message string) {
	v.Errors = append(v.Errors, fmt.Sprintf("%s: %s", field, message))
}

// 计算中文字符长度（一个中文算2个字符）
func chineseAwareLength(s string) int {
	runeCount := utf8.RuneCountInString(s)
	byteCount := len(s)
	// 估算：每个中文字符大约占3字节，英文字符占1字节
	// 简单估算：长度 ≈ (字节数 + 字符数) / 2
	return (byteCount + runeCount) / 2
}

/**
 * 各个内部结构体的校验方法
 */

func (e ExpireInfoBrand) Validate() error {
	var errs ValidationError
	if e.Num < 1 || e.Num > 9999 {
		errs.Add("Num", "must be between 1 and 9999")
	}
	if e.Unit != "天" && e.Unit != "月" && e.Unit != "年" {
		errs.Add("Unit", "must be one of: 天, 月, 年")
	}
	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

func (p ProductionInfoBrand) Validate() error {
	var errs ValidationError
	if p.Date == "" {
		errs.Add("Date", "is required")
	} else if chineseAwareLength(p.Date) < 1 || chineseAwareLength(p.Date) > 20 {
		errs.Add("Date", "must be between 1 and 20 characters")
	}
	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

func (i ImageInfo) Validate() error {
	var errs ValidationError
	if i.Src == "" {
		errs.Add("Src", "is required")
	}
	if i.Width <= 0 {
		errs.Add("Width", "must be positive")
	}
	if i.Height <= 0 {
		errs.Add("Height", "must be positive")
	}
	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

func (e ExpireInfoAdvent) Validate() error {
	var errs ValidationError
	if e.Num < 1 || e.Num > 9999 {
		errs.Add("Num", "must be between 1 and 9999")
	}
	if e.Unit != "天" && e.Unit != "月" && e.Unit != "年" {
		errs.Add("Unit", "must be one of: 天, 月, 年")
	}
	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

func (p ProductionInfoAdvent) Validate() error {
	var errs ValidationError
	if p.Date == "" {
		errs.Add("Date", "is required")
	} else if chineseAwareLength(p.Date) < 1 || chineseAwareLength(p.Date) > 20 {
		errs.Add("Date", "must be between 1 and 20 characters")
	}
	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

func (a AddressInfo) Validate() error {
	var errs ValidationError
	if a.Detail == "" {
		errs.Add("Detail", "is required")
	} else if chineseAwareLength(a.Detail) < 1 || chineseAwareLength(a.Detail) > 60 {
		errs.Add("Detail", "must be between 1 and 60 characters")
	}
	if a.Province <= 0 {
		errs.Add("Province", "is required and must be positive")
	}
	if a.City <= 0 {
		errs.Add("City", "is required and must be positive")
	}
	if a.District <= 0 {
		errs.Add("District", "is required and must be positive")
	}
	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

func (e ExpireInfoFood) Validate() error {
	var errs ValidationError
	if e.Num < 1 || e.Num > 9999 {
		errs.Add("Num", "must be between 1 and 9999")
	}
	if e.Unit != "天" && e.Unit != "月" && e.Unit != "年" {
		errs.Add("Unit", "must be one of: 天, 月, 年")
	}
	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

func (p ProductionInfoFood) Validate() error {
	var errs ValidationError
	if p.Date == "" {
		errs.Add("Date", "is required")
	} else if chineseAwareLength(p.Date) < 1 || chineseAwareLength(p.Date) > 20 {
		errs.Add("Date", "must be between 1 and 20 characters")
	}
	if err := p.Address.Validate(); err != nil {
		if verr, ok := err.(*ValidationError); ok {
			for _, e := range verr.Errors {
				errs.Add("Address."+e, "")
			}
		}
	}
	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

func (p PublishShop) Validate() error {
	var errs ValidationError
	if p.UserName == "" {
		errs.Add("UserName", "is required")
	}
	if p.Province <= 0 {
		errs.Add("Province", "is required")
	}
	if p.City <= 0 {
		errs.Add("City", "is required")
	}
	if p.District <= 0 {
		errs.Add("District", "is required")
	}
	if p.Title == "" {
		errs.Add("Title", "is required")
	} else if length := chineseAwareLength(p.Title); length < 1 || length > 60 {
		errs.Add("Title", fmt.Sprintf("must be between 1 and 60 characters, got %d", length))
	}
	if p.Content == "" {
		errs.Add("Content", "is required")
	} else if length := chineseAwareLength(p.Content); length < 5 || length > 5000 {
		errs.Add("Content", fmt.Sprintf("must be between 5 and 5000 characters, got %d", length))
	}
	if len(p.Images) == 0 || len(p.Images) > 30 {
		errs.Add("Images", "must have between 1 and 30 items")
	}
	if p.ServiceSupport != "" {
		validServices := map[string]bool{
			"SDR": true, "NFR": true, "VNR": true, "FD_10MS": true,
			"FD_24HS": true, "FD_48HS": true, "FD_GPA": true,
		}
		services := strings.Split(p.ServiceSupport, ",")
		for _, s := range services {
			if !validServices[s] {
				errs.Add("ServiceSupport", fmt.Sprintf("invalid service: %s", s))
			}
		}
	}
	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// beautyMakeup 校验方法
func (b BeautyMakeup) Validate() error {
	var errs ValidationError

	if b.Brand == "" {
		errs.Add("Brand", "is required")
	}

	if b.Spec == "" {
		errs.Add("Spec", "is required")
	}

	if b.Level == "" {
		errs.Add("Level", "is required")
	}

	if b.OrgID <= 0 {
		errs.Add("OrgID", "is required")
	}

	if b.OrgName == "" {
		errs.Add("OrgName", "is required")
	}

	if len(b.Images) == 0 || len(b.Images) > 30 {
		errs.Add("Images", "must have between 1 and 30 items")
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// curio 校验方法
func (c Curio) Validate() error {
	var errs ValidationError

	if c.Size == "" {
		errs.Add("Size", "is required")
	}

	if c.Material == "" {
		errs.Add("Material", "is required")
	}

	if c.OrgID <= 0 {
		errs.Add("OrgID", "is required")
	}

	if c.OrgName == "" {
		errs.Add("OrgName", "is required")
	}

	if c.QcNo == "" {
		errs.Add("QcNo", "is required")
	}

	if len(c.Images) == 0 || len(c.Images) > 30 {
		errs.Add("Images", "must have between 1 and 30 items")
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// jewelry 校验方法
func (j Jewelry) Validate() error {
	var errs ValidationError

	if j.Shape == "" {
		errs.Add("Shape", "is required")
	}

	if j.Color == "" {
		errs.Add("Color", "is required")
	}

	if j.Weight == "" {
		errs.Add("Weight", "is required")
	}

	if j.OrgName == "" {
		errs.Add("OrgName", "is required")
	}

	if j.QcNo == "" {
		errs.Add("QcNo", "is required")
	}

	if j.QcDesc == "" {
		errs.Add("QcDesc", "is required")
	}

	if len(j.Images) == 0 || len(j.Images) > 30 {
		errs.Add("Images", "must have between 1 and 30 items")
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// game 校验方法
func (g Game) Validate() error {
	var errs ValidationError

	if g.Title == "" {
		errs.Add("Title", "is required")
	}

	if g.Platform == "" {
		errs.Add("Platform", "is required")
	}

	if g.QcNo == "" {
		errs.Add("QcNo", "is required")
	}

	if g.QcDesc == "" {
		errs.Add("QcDesc", "is required")
	}

	if len(g.Images) == 0 || len(g.Images) > 30 {
		errs.Add("Images", "must have between 1 and 30 items")
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// usedCar 校验方法
func (u UsedCar) Validate() error {
	var errs ValidationError

	// usedCar 所有字段都是可选的，不需要必需校验
	// 这里可以添加一些格式校验，比如URL格式等

	if u.ReportURL != "" {
		// 可以添加URL格式校验
		if !strings.HasPrefix(u.ReportURL, "http") {
			errs.Add("ReportURL", "must be a valid URL")
		}
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// valuable 校验方法
func (v Valuable) Validate() error {
	var errs ValidationError

	if v.OrgID <= 0 {
		errs.Add("OrgID", "is required")
	}

	if v.OrgName == "" {
		errs.Add("OrgName", "is required")
	}

	if v.QcNo == "" {
		errs.Add("QcNo", "is required")
	}

	if v.QcDesc == "" {
		errs.Add("QcDesc", "is required")
	}

	if len(v.Images) == 0 || len(v.Images) > 30 {
		errs.Add("Images", "must have between 1 and 30 items")
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// yx3c 校验方法
func (y Yx3c) Validate() error {
	var errs ValidationError

	if y.ClassID <= 0 {
		errs.Add("ClassID", "is required")
	}

	if y.SubclassID <= 0 {
		errs.Add("SubclassID", "is required")
	}

	if y.BrandID <= 0 {
		errs.Add("BrandID", "is required")
	}

	if y.BrandName == "" {
		errs.Add("BrandName", "is required")
	}

	if y.ModelID <= 0 {
		errs.Add("ModelID", "is required")
	}

	if y.ModelName == "" {
		errs.Add("ModelName", "is required")
	}

	if y.ModelSn == "" {
		errs.Add("ModelSn", "is required")
	}

	if y.ReportUser == "" {
		errs.Add("ReportUser", "is required")
	}

	if y.ReportTime == "" {
		errs.Add("ReportTime", "is required")
	}

	// 校验质检报告项
	if err := y.ReportItems.Validate(); err != nil {
		if verr, ok := err.(*ValidationError); ok {
			for _, e := range verr.Errors {
				errs.Add("ReportItems."+e, "")
			}
		}
	}

	if len(y.AnswerIDs) == 0 {
		errs.Add("AnswerIDs", "is required")
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// reportItem 校验方法
func (r ReportItem) Validate() error {
	var errs ValidationError

	if r.AnswerID <= 0 {
		errs.Add("AnswerID", "is required")
	}

	if r.AnswerName == "" {
		errs.Add("AnswerName", "is required")
	}

	if r.AnswerType <= 0 {
		errs.Add("AnswerType", "is required")
	}

	if r.AnswerDesc == "" {
		errs.Add("AnswerDesc", "is required")
	}

	if r.QuestionName == "" {
		errs.Add("QuestionName", "is required")
	}

	if r.CategoryName == "" {
		errs.Add("CategoryName", "is required")
	}

	if r.GroupName == "" {
		errs.Add("GroupName", "is required")
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// bidData 的校验方法
func (b BidData) Validate() error {
	var errs ValidationError
	if b.BidStartTime == "" {
		errs.Add("BidStartTime", "is required")
	}
	if b.BidEndTime == "" {
		errs.Add("BidEndTime", "is required")
	}
	if b.BidReservePrice < 100 || b.BidReservePrice > 9999999900 {
		errs.Add("BidReservePrice", "must be between 100 and 9999999900")
	}
	if b.BidIncreasePrice < 100 || b.BidIncreasePrice > 10000 {
		errs.Add("BidIncreasePrice", "must be between 100 and 10000")
	}
	if b.BidDeposit < 100 || b.BidDeposit > 9999999900 {
		errs.Add("BidDeposit", "must be between 100 and 9999999900")
	}
	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// skuItems 的校验方法
func (s SkuItems) Validate() error {
	var errs ValidationError
	if s.Price < 1 || s.Price > 9999999900 {
		errs.Add("Price", "must be between 1 and 9999999900")
	}
	if s.Stock < 0 || s.Stock > 9999 {
		errs.Add("Stock", "must be between 0 and 9999")
	}
	if s.SkuText == "" {
		errs.Add("SkuText", "is required")
	}
	if s.OuterId != "" && len(s.OuterId) > 64 {
		errs.Add("OuterId", "must be at most 64 characters")
	}
	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// bookData 的校验方法
func (b BookData) Validate() error {
	var errs ValidationError
	if b.Title == "" {
		errs.Add("标题", "必须输入")
	}
	if b.Author != "" && len(b.Author) > 30 {
		errs.Add("作者", "最多30字符")
	}
	if b.Publisher != "" && len(b.Publisher) > 30 {
		errs.Add("出版社", "最多30字符")
	}
	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// FoodInfo 的校验方法
func (f FoodInfo) Validate() error {
	var errs ValidationError

	if f.Brand == "" {
		errs.Add("Brand", "is required")
	} else if chineseAwareLength(f.Brand) > 30 {
		errs.Add("Brand", "must be at most 30 characters")
	}

	if f.Spec == "" {
		errs.Add("Spec", "is required")
	} else if chineseAwareLength(f.Spec) > 30 {
		errs.Add("Spec", "must be at most 30 characters")
	}

	if f.Pack == "" {
		errs.Add("Pack", "is required")
	} else if chineseAwareLength(f.Pack) > 10 {
		errs.Add("Pack", "must be at most 10 characters")
	}

	// 校验嵌套结构体
	if err := f.Expire.Validate(); err != nil {
		if verr, ok := err.(*ValidationError); ok {
			for _, e := range verr.Errors {
				errs.Add("Expire."+e, "")
			}
		}
	}

	if err := f.Production.Validate(); err != nil {
		if verr, ok := err.(*ValidationError); ok {
			for _, e := range verr.Errors {
				errs.Add("Production."+e, "")
			}
		}
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// ReportData 的校验方法
func (r ReportData) Validate() error {
	var errs ValidationError

	// 美妆信息校验
	if !reflect.DeepEqual(r.BeautyMakeup, BeautyMakeup{}) {
		if err := r.BeautyMakeup.Validate(); err != nil {
			if verr, ok := err.(*ValidationError); ok {
				for _, e := range verr.Errors {
					errs.Add("BeautyMakeup."+e, "")
				}
			}
		}
	}
	// 文玩信息校验
	if !reflect.DeepEqual(r.Curio, Curio{}) {
		if err := r.Curio.Validate(); err != nil {
			if verr, ok := err.(*ValidationError); ok {
				for _, e := range verr.Errors {
					errs.Add("Curio."+e, "")
				}
			}
		}
	}
	// 珠宝信息校验
	if !reflect.DeepEqual(r.Jewelry, Jewelry{}) {
		if err := r.Jewelry.Validate(); err != nil {
			if verr, ok := err.(*ValidationError); ok {
				for _, e := range verr.Errors {
					errs.Add("Jewelry."+e, "")
				}
			}
		}
	}
	// 游戏信息校验
	if !reflect.DeepEqual(r.Game, Game{}) {
		if err := r.Game.Validate(); err != nil {
			if verr, ok := err.(*ValidationError); ok {
				for _, e := range verr.Errors {
					errs.Add("Game."+e, "")
				}
			}
		}
	}
	// 二手车信息校验
	if !reflect.DeepEqual(r.UsedCar, UsedCar{}) {
		if err := r.UsedCar.Validate(); err != nil {
			if verr, ok := err.(*ValidationError); ok {
				for _, e := range verr.Errors {
					errs.Add("UsedCar."+e, "")
				}
			}
		}
	}

	// 奢品信息校验
	if !reflect.DeepEqual(r.Valuable, Valuable{}) {
		if err := r.Valuable.Validate(); err != nil {
			if verr, ok := err.(*ValidationError); ok {
				for _, e := range verr.Errors {
					errs.Add("Valuable."+e, "")
				}
			}
		}
	}

	// 严选3c信息校验
	if !reflect.DeepEqual(r.Yx3c, Yx3c{}) {
		if err := r.Yx3c.Validate(); err != nil {
			if verr, ok := err.(*ValidationError); ok {
				for _, e := range verr.Errors {
					errs.Add("Yx3c."+e, "")
				}
			}
		}
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// AdventData 的校验方法
func (a AdventData) Validate() error {
	var errs ValidationError

	// 校验有效期信息
	if err := a.Expire.Validate(); err != nil {
		if verr, ok := err.(*ValidationError); ok {
			for _, e := range verr.Errors {
				errs.Add("Expire."+e, "")
			}
		}
	}

	// 校验生产信息
	if err := a.Production.Validate(); err != nil {
		if verr, ok := err.(*ValidationError); ok {
			for _, e := range verr.Errors {
				errs.Add("Production."+e, "")
			}
		}
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// InspectData 的校验方法
func (i InspectData) Validate() error {
	var errs ValidationError

	if i.TradeRule == "" {
		errs.Add("TradeRule", "is required")
	}

	if i.AssumeRule == "" {
		errs.Add("AssumeRule", "is required")
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

func (b BrandData) Validate() error {
	var errs ValidationError

	// 有效期信息（可选）
	if !reflect.DeepEqual(b.Expire, ExpireInfoBrand{}) {
		if err := b.Expire.Validate(); err != nil {
			if verr, ok := err.(*ValidationError); ok {
				for _, e := range verr.Errors {
					errs.Add("Expire."+e, "")
				}
			}
		}
	}

	// 生产信息（可选）
	if !reflect.DeepEqual(b.Production, ProductionInfoBrand{}) {
		if err := b.Production.Validate(); err != nil {
			if verr, ok := err.(*ValidationError); ok {
				for _, e := range verr.Errors {
					errs.Add("Production."+e, "")
				}
			}
		}
	}

	// 供应商名称（可选）
	if b.Supplier != "" && chineseAwareLength(b.Supplier) > 100 {
		errs.Add("Supplier", "must be at most 100 characters")
	}

	// 新图片信息（可选）
	if !reflect.DeepEqual(b.Images, ImageInfo{}) {
		if err := b.Images.Validate(); err != nil {
			if verr, ok := err.(*ValidationError); ok {
				for _, e := range verr.Errors {
					errs.Add("Images."+e, "")
				}
			}
		}
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

func (d DetailImage) Validate() error {
	var errs ValidationError

	if d.Src == "" {
		errs.Add("Src", "is required")
	}

	if d.Width <= 0 {
		errs.Add("Width", "must be positive")
	}

	if d.Height <= 0 {
		errs.Add("Height", "must be positive")
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

func (s SkuImages) Validate() error {
	var errs ValidationError

	if s.Src == "" {
		errs.Add("Src", "is required")
	}

	if s.Width <= 0 {
		errs.Add("Width", "must be positive")
	}

	if s.Height <= 0 {
		errs.Add("Height", "must be positive")
	}

	if s.SkuText == "" {
		errs.Add("SkuText", "is required")
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

// 为其他可空结构体实现类似的 Validate() 方法...
// brandData, detailImage, skuImages

/**
 * Validate BashCreat校验
 */
func (b BashCreat) Validate() error {
	var errs ValidationError

	// SkuItems 切片验证
	if len(b.SkuItems) > 0 {
		for i, skuItem := range b.SkuItems {
			if err := skuItem.Validate(); err != nil {
				if verr, ok := err.(*ValidationError); ok {
					for _, e := range verr.Errors {
						errs.Add(fmt.Sprintf("SkuItems[%d].%s", i, e), "")
					}
				} else {
					errs.Add(fmt.Sprintf("SkuItems[%d]", i), err.Error())
				}
			}
		}
	}

	// BookData 切片验证
	if b.BookData.ISBN != "" || b.BookData.Title != "" {
		if err := b.BookData.Validate(); err != nil {
			if verr, ok := err.(*ValidationError); ok {
				for _, e := range verr.Errors {
					errs.Add(fmt.Sprintf("BookData.%s", e), "") // 移除索引
				}
			} else {
				errs.Add("BookData", err.Error()) // 移除索引
			}
		}
	}

	// DetailImages 切片验证
	if len(b.DetailImages) > 0 {
		for i, detailImage := range b.DetailImages {
			if err := detailImage.Validate(); err != nil {
				if verr, ok := err.(*ValidationError); ok {
					for _, e := range verr.Errors {
						errs.Add(fmt.Sprintf("DetailImages[%d].%s", i, e), "")
					}
				} else {
					errs.Add(fmt.Sprintf("DetailImages[%d]", i), err.Error())
				}
			}
		}
	}

	// SkuImages 切片验证
	if len(b.SkuImages) > 0 {
		for i, skuImage := range b.SkuImages {
			if err := skuImage.Validate(); err != nil {
				if verr, ok := err.(*ValidationError); ok {
					for _, e := range verr.Errors {
						errs.Add(fmt.Sprintf("SkuImages[%d].%s", i, e), "")
					}
				} else {
					errs.Add(fmt.Sprintf("SkuImages[%d]", i), err.Error())
				}
			}
		}
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}

/**
 * ValidateNew BashCreat校验
 */
func (b BashCreatNew) ValidateNew() error {
	var errs ValidationError

	// SkuItems 切片验证
	if len(b.SkuItems) > 0 {
		for i, skuItem := range b.SkuItems {
			if err := skuItem.Validate(); err != nil {
				if verr, ok := err.(*ValidationError); ok {
					for _, e := range verr.Errors {
						errs.Add(fmt.Sprintf("SkuItems[%d].%s", i, e), "")
					}
				} else {
					errs.Add(fmt.Sprintf("SkuItems[%d]", i), err.Error())
				}
			}
		}
	}

	// DetailImages 切片验证
	if len(b.DetailImages) > 0 {
		for i, detailImage := range b.DetailImages {
			if err := detailImage.Validate(); err != nil {
				if verr, ok := err.(*ValidationError); ok {
					for _, e := range verr.Errors {
						errs.Add(fmt.Sprintf("DetailImages[%d].%s", i, e), "")
					}
				} else {
					errs.Add(fmt.Sprintf("DetailImages[%d]", i), err.Error())
				}
			}
		}
	}

	// SkuImages 切片验证
	if len(b.SkuImages) > 0 {
		for i, skuImage := range b.SkuImages {
			if err := skuImage.Validate(); err != nil {
				if verr, ok := err.(*ValidationError); ok {
					for _, e := range verr.Errors {
						errs.Add(fmt.Sprintf("SkuImages[%d].%s", i, e), "")
					}
				} else {
					errs.Add(fmt.Sprintf("SkuImages[%d]", i), err.Error())
				}
			}
		}
	}

	if len(errs.Errors) > 0 {
		return &errs
	}
	return nil
}
