trans

package
v0.0.0-...-41417f0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 18, 2019 License: Apache-2.0 Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types 

type Banner struct {
	ID         uint32 `gorm:"primary_key" json:"id"`
	ReferId    uint32 `json:"referId"`
	LinkUrl    string `json:"linkUrl"`
	PicUrl     string `json:"picUrl"`
	Remark     string `json:"remark"`
	Title      string `json:"title"`
	BannerType int    `json:"bannerType"`
}

func (Banner) TableName 

func (Banner) TableName() string

type FaGoods 

type FaGoods struct {
	Id                 int                            `json:"id"`                   // 商品公共表id
	Title              string                         `json:"title"`                // 商品名称
	Images             mysql.GoodsImagesJson          `json:"images"`               // 商品图片 默认第一个为封面图片
	CategoryIds        mysql.GoodsCategoryIdsJson     `json:"category_ids"`         // 商品分类
	BaseSaleNum        int                            `json:"base_sale_num"`        // 基础销量
	Body               mysql.GoodsBodyJson            `json:"body"`                 // 商品内容
	IsOnSale           int                            `json:"is_on_sale"`           // 是否需上架出售 0 否 1 是
	ImageSpecId        int                            `json:"image_spec_id"`        // 使用图片的规格id
	ImageSpecImages    mysql.GoodsImageSpecImagesJson `json:"image_spec_images"`    // 规格图片集合，废弃
	SkuList            []FaGoodsSku                   `json:"sku_list"`             // sku商品集合，数组
	CreateTime         int64                          `json:"create_time"`          // 创建时间
	Price              float64                        `json:"price"`                // 商品价格
	UpdateTime         int64                          `json:"update_time"`          // 修改时间
	EvaluationGoodStar int                            `json:"evaluation_good_star"` // 好评星级
	EvaluationCount    int                            `json:"evaluation_count"`     // 评价数
	Stock              int                            `json:"stock"`                // goods表库存之和
	SaleNum            int                            `json:"sale_num"`             // 销售量
	GroupSaleNum       int                            `json:"group_sale_num"`       // 拼团销量
	SaleTime           int64                          `json:"sale_time"`            // 开售时间
	DeleteTime         int64                          `json:"delete_time"`          // 软删除时间
	SpecList           mysql.GoodsSpecListJson        `json:"spec_list"`            //
	Img                string                         `json:"img"`                  // 封面图
	PayType            int                            `json:"pay_type"`             // 计算方式：1 按件数 2 按重量
	FreightFee         float64                        `json:"freight_fee"`          // 运费
	FreightId          int                            `json:"freight_id"`           // 运费模板id
}

type FaGoodsSku 

type FaGoodsSku struct {
	Id            int                    `json:"id" gorm:"primary_key"` // 商品id(SKU)
	GoodsId       int                    `json:"goods_id" gorm:"index"` // 商品公共表id
	Spec          mysql.GoodsSkuSpecJson `json:"spec" `                 // 规格json信息
	Price         float64                `json:"price" `                // 商品价格
	Stock         int                    `json:"stock" `                // 商品库存
	Code          string                 `json:"code" `                 // 商品编码
	Img           string                 `json:"img" `                  // 商品主图
	Weight        float64                `json:"weight" `               // 商品重量
	Title         string                 `json:"title" `                // 商品名称（+规格名称）
	SaleNum       int                    `json:"sale_num" `             // 销售数量
	GroupSaleNum  int                    `json:"group_sale_num" `       // 拼团销量
	SpecValueSign string                 `json:"spec_value_sign" `      // 规格值标识
	SpecSign      string                 `json:"spec_sign" `            // 规格标识
}

type FaOrderExtend 

type FaOrderExtend struct {
	Id int `json:"id" gorm:"primary_key"` // 订单索引id

	TrackingTime int64 `json:"tracking_time" ` // 配送时间

	TrackingNo string `json:"tracking_no" ` // 物流单号

	ShipperId int `json:"shipper_id" ` // 商家物流地址id

	ExpressId int `json:"express_id" ` // 物流公司id，默认为0 代表不需要物流

	Message string `json:"message" ` // 买家留言

	VoucherPrice int `json:"voucher_price" ` // 代金券面额

	VoucherId int `json:"voucher_id" ` // 代金券id

	VoucherCode string `json:"voucher_code" ` // 代金券编码

	Remark string `json:"remark" ` // 发货备注

	ReciverName string `json:"reciver_name" ` // 收货人姓名

	ReceiverPhone string `json:"receiver_phone" ` // 收货人电话

	ReciverInfo string `json:"reciver_info" ` // 收货人其它信息 json

	ReciverProvinceId int `json:"reciver_province_id" ` // 收货人省级ID

	ReciverCityId int `json:"reciver_city_id" ` //

	ReciverAreaId int `json:"reciver_area_id" ` //

	InvoiceInfo string `json:"invoice_info" ` // 发票信息 json

	PromotionInfo string `json:"promotion_info" ` // 促销信息备注

	EvaluateTime int64 `json:"evaluate_time" ` // 评价时间

	ServiceRemarks string `json:"service_remarks" ` // 后台客服对此订单做出的备注

	DeliverName string `json:"deliver_name" ` // 配送人名字

	DeliverPhone string `json:"deliver_phone" ` // 配送人电话

	DeliverAddress string `json:"deliver_address" ` // 配送地址

	FreightRule int `json:"freight_rule" ` // 运费规则1按商品累加运费2组合运费

	NeedExpress int `json:"need_express" ` // 是否需要物流1需要0不需要
	IsRefund    int `json:"is_refund"`

	RefundStatus int `json:"refund_status"`
}

type NoticeInfo 

type NoticeInfo struct {
	ID      uint32 `gorm:"primary_key" json:"id"`
	Name    string `json:"name"`
	Content string `json:"content"`
}

func (NoticeInfo) TableName 

func (NoticeInfo) TableName() string

type NoticeList 

type NoticeList struct {
	ID   uint32 `gorm:"primary_key" json:"id"`
	Name string `json:"name"`
}

func (NoticeList) TableName 

func (NoticeList) TableName() string

type Page 

type Page struct {
	Id              int             `json:"id"`               // 自增id
	Name            string          `json:"name"`             // 模板名称
	Description     string          `json:"description"`      // 页面描述
	Body            json.RawMessage `json:"body"`             // 模板json内容
	IsPortal        int             `json:"is_portal"`        // 是否为主页
	IsSystem        int             `json:"is_system"`        // 系统级 默认0自定义 1系统
	BackgroundColor string          `json:"background_color"` // 背景颜色
	Type            string          `json:"type"`             // 模板类型
	CreateTime      int64           `json:"create_time"`      // 创建时间
	UpdateTime      int64           `json:"update_time"`      // 更新时间
	Module          string          `json:"module"`           // 模块名字
	CloneFromId     int             `json:"clone_from_id"`    //
}

type ReqAccessTokenCreate 

type ReqAccessTokenCreate = mysql.AccessToken

ReqAccessTokenCreate 你可以把ReqAccessTokenCreate或mysql.AccessToken嵌套到需要自行修改的结构体中

type ReqAccessTokenDelete 

type ReqAccessTokenDelete struct {
	Jti int `json:"jti"`
}

ReqAccessTokenDelete 你可以把ReqAccessTokenDelete嵌套到需要自行修改的结构体中

type ReqAccessTokenList 

type ReqAccessTokenList struct {
	ReqPage
	mysql.AccessToken
}

ReqAccessTokenList 你可以把ReqAccessTokenList嵌套到需要自行修改的结构体中

type ReqAccessTokenUpdate 

type ReqAccessTokenUpdate = mysql.AccessToken

ReqAccessTokenUpdate 你可以把ReqAccessTokenUpdate或mysql.AccessToken嵌套到需要自行修改的结构体中

type ReqAddressCreate 

type ReqAddressCreate = mysql.Address

ReqAddressCreate 你可以把ReqAddressCreate或mysql.Address嵌套到需要自行修改的结构体中

type ReqAddressCreateInfo 

type ReqAddressCreateInfo struct {
	Address     string `json:"address"`
	Truename    string `json:"truename"`
	MobilePhone string `json:"mobile_phone"`
	Type        string `json:"type"`
	IsDefault   int    `json:"is_default"`
	AreaId      int    `json:"area_id"`
}

type ReqAddressDel 

type ReqAddressDel struct {
	Id int `json:"id"`
}

type ReqAddressDelete 

type ReqAddressDelete struct {
	Id int `json:"id"`
}

ReqAddressDelete 你可以把ReqAddressDelete嵌套到需要自行修改的结构体中

type ReqAddressInfo 

type ReqAddressInfo struct {
	Id int `form:"id"`
}

type ReqAddressList 

type ReqAddressList struct {
	ReqPage
	mysql.Address
}

ReqAddressList 你可以把ReqAddressList嵌套到需要自行修改的结构体中

type ReqAddressSetDefault 

type ReqAddressSetDefault struct {
	Id int `json:"id"`
}

type ReqAddressUpdate 

type ReqAddressUpdate = mysql.Address

ReqAddressUpdate 你可以把ReqAddressUpdate或mysql.Address嵌套到需要自行修改的结构体中

type ReqAddressUpdateInfo 

type ReqAddressUpdateInfo struct {
	Id          int    `json:"id"`
	Address     string `json:"address"`
	Truename    string `json:"truename"`
	MobilePhone string `json:"mobile_phone"`
	Type        string `json:"type"`
	IsDefault   int    `json:"is_default"`
	AreaId      int    `json:"area_id"`
}

type ReqAreaCreate 

type ReqAreaCreate = mysql.Area

ReqAreaCreate 你可以把ReqAreaCreate或mysql.Area嵌套到需要自行修改的结构体中

type ReqAreaDelete 

type ReqAreaDelete struct {
	Id int `json:"id"`
}

ReqAreaDelete 你可以把ReqAreaDelete嵌套到需要自行修改的结构体中

type ReqAreaInfo 

type ReqAreaInfo struct {
	Name string `form:"name"`
}

type ReqAreaList 

type ReqAreaList struct {
	ReqPage
	mysql.Area
}

ReqAreaList 你可以把ReqAreaList嵌套到需要自行修改的结构体中

type ReqAreaListInfo 

type ReqAreaListInfo struct {
	Pid   int `form:"pid"`
	Level int `form:"level"`
}

type ReqAreaUpdate 

type ReqAreaUpdate = mysql.Area

ReqAreaUpdate 你可以把ReqAreaUpdate或mysql.Area嵌套到需要自行修改的结构体中

type ReqArticleCreate 

type ReqArticleCreate = mysql.Article

ReqArticleCreate 你可以把ReqArticleCreate或mysql.Article嵌套到需要自行修改的结构体中

type ReqArticleDelete 

type ReqArticleDelete struct {
	Id int `json:"id"`
}

ReqArticleDelete 你可以把ReqArticleDelete嵌套到需要自行修改的结构体中

type ReqArticleList 

type ReqArticleList struct {
	ReqPage
	mysql.Article
}

ReqArticleList 你可以把ReqArticleList嵌套到需要自行修改的结构体中

type ReqArticleUpdate 

type ReqArticleUpdate = mysql.Article

ReqArticleUpdate 你可以把ReqArticleUpdate或mysql.Article嵌套到需要自行修改的结构体中

type ReqAuthGroupAccessCreate 

type ReqAuthGroupAccessCreate = mysql.AuthGroupAccess

ReqAuthGroupAccessCreate 你可以把ReqAuthGroupAccessCreate或mysql.AuthGroupAccess嵌套到需要自行修改的结构体中

type ReqAuthGroupAccessDelete 

type ReqAuthGroupAccessDelete struct {
	Uid     int `json:"uid"`
	GroupId int `json:"group_id"`
}

ReqAuthGroupAccessDelete 你可以把ReqAuthGroupAccessDelete嵌套到需要自行修改的结构体中

type ReqAuthGroupAccessList 

type ReqAuthGroupAccessList struct {
	ReqPage
	mysql.AuthGroupAccess
}

ReqAuthGroupAccessList 你可以把ReqAuthGroupAccessList嵌套到需要自行修改的结构体中

type ReqAuthGroupAccessUpdate 

type ReqAuthGroupAccessUpdate = mysql.AuthGroupAccess

ReqAuthGroupAccessUpdate 你可以把ReqAuthGroupAccessUpdate或mysql.AuthGroupAccess嵌套到需要自行修改的结构体中

type ReqAuthGroupCreate 

type ReqAuthGroupCreate = mysql.AuthGroup

ReqAuthGroupCreate 你可以把ReqAuthGroupCreate或mysql.AuthGroup嵌套到需要自行修改的结构体中

type ReqAuthGroupDelete 

type ReqAuthGroupDelete struct {
	Id int `json:"id"`
}

ReqAuthGroupDelete 你可以把ReqAuthGroupDelete嵌套到需要自行修改的结构体中

type ReqAuthGroupList 

type ReqAuthGroupList struct {
	ReqPage
	mysql.AuthGroup
}

ReqAuthGroupList 你可以把ReqAuthGroupList嵌套到需要自行修改的结构体中

type ReqAuthGroupUpdate 

type ReqAuthGroupUpdate = mysql.AuthGroup

ReqAuthGroupUpdate 你可以把ReqAuthGroupUpdate或mysql.AuthGroup嵌套到需要自行修改的结构体中

type ReqAuthRuleCreate 

type ReqAuthRuleCreate = mysql.AuthRule

ReqAuthRuleCreate 你可以把ReqAuthRuleCreate或mysql.AuthRule嵌套到需要自行修改的结构体中

type ReqAuthRuleDelete 

type ReqAuthRuleDelete struct {
	Id int `json:"id"`
}

ReqAuthRuleDelete 你可以把ReqAuthRuleDelete嵌套到需要自行修改的结构体中

type ReqAuthRuleList 

type ReqAuthRuleList struct {
	ReqPage
	mysql.AuthRule
}

ReqAuthRuleList 你可以把ReqAuthRuleList嵌套到需要自行修改的结构体中

type ReqAuthRuleUpdate 

type ReqAuthRuleUpdate = mysql.AuthRule

ReqAuthRuleUpdate 你可以把ReqAuthRuleUpdate或mysql.AuthRule嵌套到需要自行修改的结构体中

type ReqBizCreate 

type ReqBizCreate = mysql.Biz

ReqBizCreate 你可以把ReqBizCreate或mysql.Biz嵌套到需要自行修改的结构体中

type ReqBizDelete 

type ReqBizDelete struct {
	OpenId int `json:"open_id"`
}

ReqBizDelete 你可以把ReqBizDelete嵌套到需要自行修改的结构体中

type ReqBizList 

type ReqBizList struct {
	ReqPage
	mysql.Biz
}

ReqBizList 你可以把ReqBizList嵌套到需要自行修改的结构体中

type ReqBizUpdate 

type ReqBizUpdate = mysql.Biz

ReqBizUpdate 你可以把ReqBizUpdate或mysql.Biz嵌套到需要自行修改的结构体中

type ReqBuyCalculate 

type ReqBuyCalculate struct {
	AddressId int   `json:"address_id"`
	CartIds   []int `json:"cart_ids"`
}

type ReqBuyCreate 

type ReqBuyCreate struct {
	CartIds   []int  `json:"cart_ids"`
	AddressId int    `json:"address_id"`
	Message   string `json:"message"`
}

type ReqBuyPay 

type ReqBuyPay struct {
	OrderType      string `json:"order_type"`
	PaySn          string `json:"pay_sn"`
	PaymentCode    string `json:"payment_code"`
	PaymentChannel string `json:"payment_channel"`
	OpenID         string `json:"open_id"`
}

type ReqCartCheck 

type ReqCartCheck struct {
	GoodsSkuIds []int `json:"goods_sku_ids"`
	IsCheck     int   `json:"is_check"`
}

type ReqCartCreate 

type ReqCartCreate = mysql.Cart

ReqCartCreate 你可以把ReqCartCreate或mysql.Cart嵌套到需要自行修改的结构体中

type ReqCartCreateInfo 

type ReqCartCreateInfo struct {
	GoodsSkuId int `json:"goods_sku_id"`
	Quantity   int `json:"quantity"`
}

type ReqCartDel 

type ReqCartDel struct {
	GoodsSkuIds []int `json:"goods_sku_ids"`
}

type ReqCartDelete 

type ReqCartDelete struct {
	Id int `json:"id"`
}

ReqCartDelete 你可以把ReqCartDelete嵌套到需要自行修改的结构体中

type ReqCartInfo 

type ReqCartInfo struct {
	GoodsSkuId int `form:"goods_sku_id"`
}

type ReqCartList 

type ReqCartList struct {
	ReqPage
	mysql.Cart
}

ReqCartList 你可以把ReqCartList嵌套到需要自行修改的结构体中

type ReqCartUpdate 

type ReqCartUpdate = mysql.Cart

ReqCartUpdate 你可以把ReqCartUpdate或mysql.Cart嵌套到需要自行修改的结构体中

type ReqCartUpdateInfo 

type ReqCartUpdateInfo struct {
	GoodsSkuId int `json:"goods_sku_id"`
	Quantity   int `json:"quantity"`
}

type ReqCollectCreate 

type ReqCollectCreate struct {
	GoodsId int `json:"goods_id"`
}

type ReqCollectDel 

type ReqCollectDel struct {
	GoodsId int `json:"goods_id"`
}

type ReqCouponCreate 

type ReqCouponCreate = mysql.Coupon

ReqCouponCreate 你可以把ReqCouponCreate或mysql.Coupon嵌套到需要自行修改的结构体中

type ReqCouponDelete 

type ReqCouponDelete struct {
	Id int `json:"id"`
}

ReqCouponDelete 你可以把ReqCouponDelete嵌套到需要自行修改的结构体中

type ReqCouponGoodsCreate 

type ReqCouponGoodsCreate = mysql.CouponGoods

ReqCouponGoodsCreate 你可以把ReqCouponGoodsCreate或mysql.CouponGoods嵌套到需要自行修改的结构体中

type ReqCouponGoodsDelete 

type ReqCouponGoodsDelete struct {
	Id int `json:"id"`
}

ReqCouponGoodsDelete 你可以把ReqCouponGoodsDelete嵌套到需要自行修改的结构体中

type ReqCouponGoodsList 

type ReqCouponGoodsList struct {
	ReqPage
	mysql.CouponGoods
}

ReqCouponGoodsList 你可以把ReqCouponGoodsList嵌套到需要自行修改的结构体中

type ReqCouponGoodsUpdate 

type ReqCouponGoodsUpdate = mysql.CouponGoods

ReqCouponGoodsUpdate 你可以把ReqCouponGoodsUpdate或mysql.CouponGoods嵌套到需要自行修改的结构体中

type ReqCouponList 

type ReqCouponList struct {
	ReqPage
	mysql.Coupon
}

ReqCouponList 你可以把ReqCouponList嵌套到需要自行修改的结构体中

type ReqCouponUpdate 

type ReqCouponUpdate = mysql.Coupon

ReqCouponUpdate 你可以把ReqCouponUpdate或mysql.Coupon嵌套到需要自行修改的结构体中

type ReqCronCreate 

type ReqCronCreate = mysql.Cron

ReqCronCreate 你可以把ReqCronCreate或mysql.Cron嵌套到需要自行修改的结构体中

type ReqCronDelete 

type ReqCronDelete struct {
}

ReqCronDelete 你可以把ReqCronDelete嵌套到需要自行修改的结构体中

type ReqCronList 

type ReqCronList struct {
	ReqPage
	mysql.Cron
}

ReqCronList 你可以把ReqCronList嵌套到需要自行修改的结构体中

type ReqCronUpdate 

type ReqCronUpdate = mysql.Cron

ReqCronUpdate 你可以把ReqCronUpdate或mysql.Cron嵌套到需要自行修改的结构体中

type ReqDiscountCreate 

type ReqDiscountCreate = mysql.Discount

ReqDiscountCreate 你可以把ReqDiscountCreate或mysql.Discount嵌套到需要自行修改的结构体中

type ReqDiscountDelete 

type ReqDiscountDelete struct {
	Id int `json:"id"`
}

ReqDiscountDelete 你可以把ReqDiscountDelete嵌套到需要自行修改的结构体中

type ReqDiscountGoodsCreate 

type ReqDiscountGoodsCreate = mysql.DiscountGoods

ReqDiscountGoodsCreate 你可以把ReqDiscountGoodsCreate或mysql.DiscountGoods嵌套到需要自行修改的结构体中

type ReqDiscountGoodsDelete 

type ReqDiscountGoodsDelete struct {
	Id int `json:"id"`
}

ReqDiscountGoodsDelete 你可以把ReqDiscountGoodsDelete嵌套到需要自行修改的结构体中

type ReqDiscountGoodsList 

type ReqDiscountGoodsList struct {
	ReqPage
	mysql.DiscountGoods
}

ReqDiscountGoodsList 你可以把ReqDiscountGoodsList嵌套到需要自行修改的结构体中

type ReqDiscountGoodsUpdate 

type ReqDiscountGoodsUpdate = mysql.DiscountGoods

ReqDiscountGoodsUpdate 你可以把ReqDiscountGoodsUpdate或mysql.DiscountGoods嵌套到需要自行修改的结构体中

type ReqDiscountList 

type ReqDiscountList struct {
	ReqPage
	mysql.Discount
}

ReqDiscountList 你可以把ReqDiscountList嵌套到需要自行修改的结构体中

type ReqDiscountUpdate 

type ReqDiscountUpdate = mysql.Discount

ReqDiscountUpdate 你可以把ReqDiscountUpdate或mysql.Discount嵌套到需要自行修改的结构体中

type ReqDispatchCreate 

type ReqDispatchCreate = mysql.Dispatch

ReqDispatchCreate 你可以把ReqDispatchCreate或mysql.Dispatch嵌套到需要自行修改的结构体中

type ReqDispatchDelete 

type ReqDispatchDelete struct {
	Id int `json:"id"`
}

ReqDispatchDelete 你可以把ReqDispatchDelete嵌套到需要自行修改的结构体中

type ReqDispatchList 

type ReqDispatchList struct {
	ReqPage
	mysql.Dispatch
}

ReqDispatchList 你可以把ReqDispatchList嵌套到需要自行修改的结构体中

type ReqDispatchUpdate 

type ReqDispatchUpdate = mysql.Dispatch

ReqDispatchUpdate 你可以把ReqDispatchUpdate或mysql.Dispatch嵌套到需要自行修改的结构体中

type ReqExpressCreate 

type ReqExpressCreate = mysql.Express

ReqExpressCreate 你可以把ReqExpressCreate或mysql.Express嵌套到需要自行修改的结构体中

type ReqExpressDelete 

type ReqExpressDelete struct {
	Id int `json:"id"`
}

ReqExpressDelete 你可以把ReqExpressDelete嵌套到需要自行修改的结构体中

type ReqExpressList 

type ReqExpressList struct {
	ReqPage
	mysql.Express
}

ReqExpressList 你可以把ReqExpressList嵌套到需要自行修改的结构体中

type ReqExpressUpdate 

type ReqExpressUpdate = mysql.Express

ReqExpressUpdate 你可以把ReqExpressUpdate或mysql.Express嵌套到需要自行修改的结构体中

type ReqExtendCreate 

type ReqExtendCreate = mysql.Extend

ReqExtendCreate 你可以把ReqExtendCreate或mysql.Extend嵌套到需要自行修改的结构体中

type ReqExtendDelete 

type ReqExtendDelete struct {
	Id int `json:"id"`
}

ReqExtendDelete 你可以把ReqExtendDelete嵌套到需要自行修改的结构体中

type ReqExtendList 

type ReqExtendList struct {
	ReqPage
	mysql.Extend
}

ReqExtendList 你可以把ReqExtendList嵌套到需要自行修改的结构体中

type ReqExtendUpdate 

type ReqExtendUpdate = mysql.Extend

ReqExtendUpdate 你可以把ReqExtendUpdate或mysql.Extend嵌套到需要自行修改的结构体中

type ReqFdCreate 

type ReqFdCreate = mysql.Fd

ReqFdCreate 你可以把ReqFdCreate或mysql.Fd嵌套到需要自行修改的结构体中

type ReqFdDelete 

type ReqFdDelete struct {
	Id int `json:"id"`
}

ReqFdDelete 你可以把ReqFdDelete嵌套到需要自行修改的结构体中

type ReqFdList 

type ReqFdList struct {
	ReqPage
	mysql.Fd
}

ReqFdList 你可以把ReqFdList嵌套到需要自行修改的结构体中

type ReqFdUpdate 

type ReqFdUpdate = mysql.Fd

ReqFdUpdate 你可以把ReqFdUpdate或mysql.Fd嵌套到需要自行修改的结构体中

type ReqFreightCreate 

type ReqFreightCreate = mysql.Freight

ReqFreightCreate 你可以把ReqFreightCreate或mysql.Freight嵌套到需要自行修改的结构体中

type ReqFreightDelete 

type ReqFreightDelete struct {
	Id int `json:"id"`
}

ReqFreightDelete 你可以把ReqFreightDelete嵌套到需要自行修改的结构体中

type ReqFreightList 

type ReqFreightList struct {
	ReqPage
	mysql.Freight
}

ReqFreightList 你可以把ReqFreightList嵌套到需要自行修改的结构体中

type ReqFreightUpdate 

type ReqFreightUpdate = mysql.Freight

ReqFreightUpdate 你可以把ReqFreightUpdate或mysql.Freight嵌套到需要自行修改的结构体中

type ReqFullcutCreate 

type ReqFullcutCreate = mysql.Fullcut

ReqFullcutCreate 你可以把ReqFullcutCreate或mysql.Fullcut嵌套到需要自行修改的结构体中

type ReqFullcutDelete 

type ReqFullcutDelete struct {
	Id int `json:"id"`
}

ReqFullcutDelete 你可以把ReqFullcutDelete嵌套到需要自行修改的结构体中

type ReqFullcutGoodsCreate 

type ReqFullcutGoodsCreate = mysql.FullcutGoods

ReqFullcutGoodsCreate 你可以把ReqFullcutGoodsCreate或mysql.FullcutGoods嵌套到需要自行修改的结构体中

type ReqFullcutGoodsDelete 

type ReqFullcutGoodsDelete struct {
	Id int `json:"id"`
}

ReqFullcutGoodsDelete 你可以把ReqFullcutGoodsDelete嵌套到需要自行修改的结构体中

type ReqFullcutGoodsList 

type ReqFullcutGoodsList struct {
	ReqPage
	mysql.FullcutGoods
}

ReqFullcutGoodsList 你可以把ReqFullcutGoodsList嵌套到需要自行修改的结构体中

type ReqFullcutGoodsUpdate 

type ReqFullcutGoodsUpdate = mysql.FullcutGoods

ReqFullcutGoodsUpdate 你可以把ReqFullcutGoodsUpdate或mysql.FullcutGoods嵌套到需要自行修改的结构体中

type ReqFullcutList 

type ReqFullcutList struct {
	ReqPage
	mysql.Fullcut
}

ReqFullcutList 你可以把ReqFullcutList嵌套到需要自行修改的结构体中

type ReqFullcutUpdate 

type ReqFullcutUpdate = mysql.Fullcut

ReqFullcutUpdate 你可以把ReqFullcutUpdate或mysql.Fullcut嵌套到需要自行修改的结构体中

type ReqGoodsCartCreate 

type ReqGoodsCartCreate = mysql.GoodsCart

ReqGoodsCartCreate 你可以把ReqGoodsCartCreate或mysql.GoodsCart嵌套到需要自行修改的结构体中

type ReqGoodsCartDelete 

type ReqGoodsCartDelete struct {
	Id int `json:"id"`
}

ReqGoodsCartDelete 你可以把ReqGoodsCartDelete嵌套到需要自行修改的结构体中

type ReqGoodsCartList 

type ReqGoodsCartList struct {
	ReqPage
	mysql.GoodsCart
}

ReqGoodsCartList 你可以把ReqGoodsCartList嵌套到需要自行修改的结构体中

type ReqGoodsCartUpdate 

type ReqGoodsCartUpdate = mysql.GoodsCart

ReqGoodsCartUpdate 你可以把ReqGoodsCartUpdate或mysql.GoodsCart嵌套到需要自行修改的结构体中

type ReqGoodsCategoryCreate 

type ReqGoodsCategoryCreate = mysql.GoodsCategory

ReqGoodsCategoryCreate 你可以把ReqGoodsCategoryCreate或mysql.GoodsCategory嵌套到需要自行修改的结构体中

type ReqGoodsCategoryDelete 

type ReqGoodsCategoryDelete struct {
	Id int `json:"id"`
}

ReqGoodsCategoryDelete 你可以把ReqGoodsCategoryDelete嵌套到需要自行修改的结构体中

type ReqGoodsCategoryIdsCreate 

type ReqGoodsCategoryIdsCreate = mysql.GoodsCategoryIds

ReqGoodsCategoryIdsCreate 你可以把ReqGoodsCategoryIdsCreate或mysql.GoodsCategoryIds嵌套到需要自行修改的结构体中

type ReqGoodsCategoryIdsDelete 

type ReqGoodsCategoryIdsDelete struct {
	Id int `json:"id"`
}

ReqGoodsCategoryIdsDelete 你可以把ReqGoodsCategoryIdsDelete嵌套到需要自行修改的结构体中

type ReqGoodsCategoryIdsList 

type ReqGoodsCategoryIdsList struct {
	ReqPage
	mysql.GoodsCategoryIds
}

ReqGoodsCategoryIdsList 你可以把ReqGoodsCategoryIdsList嵌套到需要自行修改的结构体中

type ReqGoodsCategoryIdsUpdate 

type ReqGoodsCategoryIdsUpdate = mysql.GoodsCategoryIds

ReqGoodsCategoryIdsUpdate 你可以把ReqGoodsCategoryIdsUpdate或mysql.GoodsCategoryIds嵌套到需要自行修改的结构体中

type ReqGoodsCategoryList 

type ReqGoodsCategoryList struct {
	ReqPage
	mysql.GoodsCategory
}

ReqGoodsCategoryList 你可以把ReqGoodsCategoryList嵌套到需要自行修改的结构体中

type ReqGoodsCategoryUpdate 

type ReqGoodsCategoryUpdate = mysql.GoodsCategory

ReqGoodsCategoryUpdate 你可以把ReqGoodsCategoryUpdate或mysql.GoodsCategory嵌套到需要自行修改的结构体中

type ReqGoodsCollectCreate 

type ReqGoodsCollectCreate = mysql.GoodsCollect

ReqGoodsCollectCreate 你可以把ReqGoodsCollectCreate或mysql.GoodsCollect嵌套到需要自行修改的结构体中

type ReqGoodsCollectDelete 

type ReqGoodsCollectDelete struct {
	Id int `json:"id"`
}

ReqGoodsCollectDelete 你可以把ReqGoodsCollectDelete嵌套到需要自行修改的结构体中

type ReqGoodsCollectList 

type ReqGoodsCollectList struct {
	ReqPage
	mysql.GoodsCollect
}

ReqGoodsCollectList 你可以把ReqGoodsCollectList嵌套到需要自行修改的结构体中

type ReqGoodsCollectUpdate 

type ReqGoodsCollectUpdate = mysql.GoodsCollect

ReqGoodsCollectUpdate 你可以把ReqGoodsCollectUpdate或mysql.GoodsCollect嵌套到需要自行修改的结构体中

type ReqGoodsCreate 

type ReqGoodsCreate = mysql.Goods

ReqGoodsCreate 你可以把ReqGoodsCreate或mysql.Goods嵌套到需要自行修改的结构体中

type ReqGoodsDelete 

type ReqGoodsDelete struct {
	Id int `json:"id"`
}

ReqGoodsDelete 你可以把ReqGoodsDelete嵌套到需要自行修改的结构体中

type ReqGoodsEvaluateCreate 

type ReqGoodsEvaluateCreate = mysql.GoodsEvaluate

ReqGoodsEvaluateCreate 你可以把ReqGoodsEvaluateCreate或mysql.GoodsEvaluate嵌套到需要自行修改的结构体中

type ReqGoodsEvaluateDelete 

type ReqGoodsEvaluateDelete struct {
	Id int `json:"id"`
}

ReqGoodsEvaluateDelete 你可以把ReqGoodsEvaluateDelete嵌套到需要自行修改的结构体中

type ReqGoodsEvaluateList 

type ReqGoodsEvaluateList struct {
	ReqPage
	mysql.GoodsEvaluate
}

ReqGoodsEvaluateList 你可以把ReqGoodsEvaluateList嵌套到需要自行修改的结构体中

type ReqGoodsEvaluateUpdate 

type ReqGoodsEvaluateUpdate = mysql.GoodsEvaluate

ReqGoodsEvaluateUpdate 你可以把ReqGoodsEvaluateUpdate或mysql.GoodsEvaluate嵌套到需要自行修改的结构体中

type ReqGoodsImageCreate 

type ReqGoodsImageCreate = mysql.GoodsImage

ReqGoodsImageCreate 你可以把ReqGoodsImageCreate或mysql.GoodsImage嵌套到需要自行修改的结构体中

type ReqGoodsImageDelete 

type ReqGoodsImageDelete struct {
	Id int `json:"id"`
}

ReqGoodsImageDelete 你可以把ReqGoodsImageDelete嵌套到需要自行修改的结构体中

type ReqGoodsImageList 

type ReqGoodsImageList struct {
	ReqPage
	mysql.GoodsImage
}

ReqGoodsImageList 你可以把ReqGoodsImageList嵌套到需要自行修改的结构体中

type ReqGoodsImageUpdate 

type ReqGoodsImageUpdate = mysql.GoodsImage

ReqGoodsImageUpdate 你可以把ReqGoodsImageUpdate或mysql.GoodsImage嵌套到需要自行修改的结构体中

type ReqGoodsInfo 

type ReqGoodsInfo struct {
	Id int `form:"id"`
}

type ReqGoodsList 

type ReqGoodsList struct {
	ReqPage
	mysql.Goods
}

ReqGoodsList 你可以把ReqGoodsList嵌套到需要自行修改的结构体中

type ReqGoodsListCustom 

type ReqGoodsListCustom struct {
	CategoryIds []int `json:"category_ids"`
	Page        int   `json:"page"`
	Rows        int   `json:"rows"`
}

type ReqGoodsOnSale 

type ReqGoodsOnSale struct {
	Ids []int `json:"ids"`
}

type ReqGoodsSkuCreate 

type ReqGoodsSkuCreate = mysql.GoodsSku

ReqGoodsSkuCreate 你可以把ReqGoodsSkuCreate或mysql.GoodsSku嵌套到需要自行修改的结构体中

type ReqGoodsSkuDelete 

type ReqGoodsSkuDelete struct {
	Id int `json:"id"`
}

ReqGoodsSkuDelete 你可以把ReqGoodsSkuDelete嵌套到需要自行修改的结构体中

type ReqGoodsSkuList 

type ReqGoodsSkuList struct {
	ReqPage
	mysql.GoodsSku
}

ReqGoodsSkuList 你可以把ReqGoodsSkuList嵌套到需要自行修改的结构体中

type ReqGoodsSkuUpdate 

type ReqGoodsSkuUpdate = mysql.GoodsSku

ReqGoodsSkuUpdate 你可以把ReqGoodsSkuUpdate或mysql.GoodsSku嵌套到需要自行修改的结构体中

type ReqGoodsSpecCreate 

type ReqGoodsSpecCreate = mysql.GoodsSpec

ReqGoodsSpecCreate 你可以把ReqGoodsSpecCreate或mysql.GoodsSpec嵌套到需要自行修改的结构体中

type ReqGoodsSpecDelete 

type ReqGoodsSpecDelete struct {
	Id int `json:"id"`
}

ReqGoodsSpecDelete 你可以把ReqGoodsSpecDelete嵌套到需要自行修改的结构体中

type ReqGoodsSpecList 

type ReqGoodsSpecList struct {
	ReqPage
	mysql.GoodsSpec
}

ReqGoodsSpecList 你可以把ReqGoodsSpecList嵌套到需要自行修改的结构体中

type ReqGoodsSpecUpdate 

type ReqGoodsSpecUpdate = mysql.GoodsSpec

ReqGoodsSpecUpdate 你可以把ReqGoodsSpecUpdate或mysql.GoodsSpec嵌套到需要自行修改的结构体中

type ReqGoodsSpecValueCreate 

type ReqGoodsSpecValueCreate = mysql.GoodsSpecValue

ReqGoodsSpecValueCreate 你可以把ReqGoodsSpecValueCreate或mysql.GoodsSpecValue嵌套到需要自行修改的结构体中

type ReqGoodsSpecValueDelete 

type ReqGoodsSpecValueDelete struct {
	Id int `json:"id"`
}

ReqGoodsSpecValueDelete 你可以把ReqGoodsSpecValueDelete嵌套到需要自行修改的结构体中

type ReqGoodsSpecValueList 

type ReqGoodsSpecValueList struct {
	ReqPage
	mysql.GoodsSpecValue
}

ReqGoodsSpecValueList 你可以把ReqGoodsSpecValueList嵌套到需要自行修改的结构体中

type ReqGoodsSpecValueUpdate 

type ReqGoodsSpecValueUpdate = mysql.GoodsSpecValue

ReqGoodsSpecValueUpdate 你可以把ReqGoodsSpecValueUpdate或mysql.GoodsSpecValue嵌套到需要自行修改的结构体中

type ReqGoodsUpdate 

type ReqGoodsUpdate = mysql.Goods

ReqGoodsUpdate 你可以把ReqGoodsUpdate或mysql.Goods嵌套到需要自行修改的结构体中

type ReqGoodscategoryCreate 

type ReqGoodscategoryCreate struct {
	Icon string `json:"icon"`
	Name string `json:"name"`
	Pid  int    `json:"pid"`
}

type ReqGoodscategoryInfo 

type ReqGoodscategoryInfo struct {
	Id int `form:"id"`
}

type ReqGoodscategoryUpdate 

type ReqGoodscategoryUpdate struct {
	Id   int    `json:"id"`
	Icon string `json:"icon"`
	Name string `json:"name"`
	Pid  int    `json:"pid"`
}

type ReqGoodsspecCreate 

type ReqGoodsspecCreate struct {
	Name string `json:"name"`
}

type ReqGoodsspecvalueCreate 

type ReqGoodsspecvalueCreate struct {
	SpecId int    `json:"spec_id"`
	Name   string `json:"name"`
}

type ReqGroupConfigCreate 

type ReqGroupConfigCreate = mysql.GroupConfig

ReqGroupConfigCreate 你可以把ReqGroupConfigCreate或mysql.GroupConfig嵌套到需要自行修改的结构体中

type ReqGroupConfigDelete 

type ReqGroupConfigDelete struct {
}

ReqGroupConfigDelete 你可以把ReqGroupConfigDelete嵌套到需要自行修改的结构体中

type ReqGroupConfigList 

type ReqGroupConfigList struct {
	ReqPage
	mysql.GroupConfig
}

ReqGroupConfigList 你可以把ReqGroupConfigList嵌套到需要自行修改的结构体中

type ReqGroupConfigUpdate 

type ReqGroupConfigUpdate = mysql.GroupConfig

ReqGroupConfigUpdate 你可以把ReqGroupConfigUpdate或mysql.GroupConfig嵌套到需要自行修改的结构体中

type ReqGroupCreate 

type ReqGroupCreate = mysql.Group

ReqGroupCreate 你可以把ReqGroupCreate或mysql.Group嵌套到需要自行修改的结构体中

type ReqGroupDelete 

type ReqGroupDelete struct {
	Id int `json:"id"`
}

ReqGroupDelete 你可以把ReqGroupDelete嵌套到需要自行修改的结构体中

type ReqGroupGoodsCreate 

type ReqGroupGoodsCreate = mysql.GroupGoods

ReqGroupGoodsCreate 你可以把ReqGroupGoodsCreate或mysql.GroupGoods嵌套到需要自行修改的结构体中

type ReqGroupGoodsDelete 

type ReqGroupGoodsDelete struct {
	Id int `json:"id"`
}

ReqGroupGoodsDelete 你可以把ReqGroupGoodsDelete嵌套到需要自行修改的结构体中

type ReqGroupGoodsList 

type ReqGroupGoodsList struct {
	ReqPage
	mysql.GroupGoods
}

ReqGroupGoodsList 你可以把ReqGroupGoodsList嵌套到需要自行修改的结构体中

type ReqGroupGoodsUpdate 

type ReqGroupGoodsUpdate = mysql.GroupGoods

ReqGroupGoodsUpdate 你可以把ReqGroupGoodsUpdate或mysql.GroupGoods嵌套到需要自行修改的结构体中

type ReqGroupList 

type ReqGroupList struct {
	ReqPage
	mysql.Group
}

ReqGroupList 你可以把ReqGroupList嵌套到需要自行修改的结构体中

type ReqGroupUpdate 

type ReqGroupUpdate = mysql.Group

ReqGroupUpdate 你可以把ReqGroupUpdate或mysql.Group嵌套到需要自行修改的结构体中

type ReqImageCreate 

type ReqImageCreate = mysql.Image

ReqImageCreate 你可以把ReqImageCreate或mysql.Image嵌套到需要自行修改的结构体中

type ReqImageDelete 

type ReqImageDelete struct {
	Id int `json:"id"`
}

ReqImageDelete 你可以把ReqImageDelete嵌套到需要自行修改的结构体中

type ReqImageList 

type ReqImageList struct {
	ReqPage
	mysql.Image
}

ReqImageList 你可以把ReqImageList嵌套到需要自行修改的结构体中

type ReqImageUpdate 

type ReqImageUpdate = mysql.Image

ReqImageUpdate 你可以把ReqImageUpdate或mysql.Image嵌套到需要自行修改的结构体中

type ReqInfo 

type ReqInfo struct {
	Id int `form:"id"`
}

type ReqInfoCategoryCreate 

type ReqInfoCategoryCreate = mysql.InfoCategory

ReqInfoCategoryCreate 你可以把ReqInfoCategoryCreate或mysql.InfoCategory嵌套到需要自行修改的结构体中

type ReqInfoCategoryDelete 

type ReqInfoCategoryDelete struct {
	Id int `json:"id"`
}

ReqInfoCategoryDelete 你可以把ReqInfoCategoryDelete嵌套到需要自行修改的结构体中

type ReqInfoCategoryList 

type ReqInfoCategoryList struct {
	ReqPage
	mysql.InfoCategory
}

ReqInfoCategoryList 你可以把ReqInfoCategoryList嵌套到需要自行修改的结构体中

type ReqInfoCategoryUpdate 

type ReqInfoCategoryUpdate = mysql.InfoCategory

ReqInfoCategoryUpdate 你可以把ReqInfoCategoryUpdate或mysql.InfoCategory嵌套到需要自行修改的结构体中

type ReqInvoiceCreate 

type ReqInvoiceCreate = mysql.Invoice

ReqInvoiceCreate 你可以把ReqInvoiceCreate或mysql.Invoice嵌套到需要自行修改的结构体中

type ReqInvoiceDelete 

type ReqInvoiceDelete struct {
	Id int `json:"id"`
}

ReqInvoiceDelete 你可以把ReqInvoiceDelete嵌套到需要自行修改的结构体中

type ReqInvoiceList 

type ReqInvoiceList struct {
	ReqPage
	mysql.Invoice
}

ReqInvoiceList 你可以把ReqInvoiceList嵌套到需要自行修改的结构体中

type ReqInvoiceUpdate 

type ReqInvoiceUpdate = mysql.Invoice

ReqInvoiceUpdate 你可以把ReqInvoiceUpdate或mysql.Invoice嵌套到需要自行修改的结构体中

type ReqList 

type ReqList struct {
	Page int    `form:"page"`
	Rows int    `form:"rows"`
	Sort string `form:"sort"`
}

type ReqMaterialCreate 

type ReqMaterialCreate = mysql.Material

ReqMaterialCreate 你可以把ReqMaterialCreate或mysql.Material嵌套到需要自行修改的结构体中

type ReqMaterialDelete 

type ReqMaterialDelete struct {
	Id int `json:"id"`
}

ReqMaterialDelete 你可以把ReqMaterialDelete嵌套到需要自行修改的结构体中

type ReqMaterialList 

type ReqMaterialList struct {
	ReqPage
	mysql.Material
}

ReqMaterialList 你可以把ReqMaterialList嵌套到需要自行修改的结构体中

type ReqMaterialUpdate 

type ReqMaterialUpdate = mysql.Material

ReqMaterialUpdate 你可以把ReqMaterialUpdate或mysql.Material嵌套到需要自行修改的结构体中

type ReqMessageCreate 

type ReqMessageCreate = mysql.Message

ReqMessageCreate 你可以把ReqMessageCreate或mysql.Message嵌套到需要自行修改的结构体中

type ReqMessageDelete 

type ReqMessageDelete struct {
	Id int `json:"id"`
}

ReqMessageDelete 你可以把ReqMessageDelete嵌套到需要自行修改的结构体中

type ReqMessageList 

type ReqMessageList struct {
	ReqPage
	mysql.Message
}

ReqMessageList 你可以把ReqMessageList嵌套到需要自行修改的结构体中

type ReqMessageStateCreate 

type ReqMessageStateCreate = mysql.MessageState

ReqMessageStateCreate 你可以把ReqMessageStateCreate或mysql.MessageState嵌套到需要自行修改的结构体中

type ReqMessageStateDelete 

type ReqMessageStateDelete struct {
	Id int `json:"id"`
}

ReqMessageStateDelete 你可以把ReqMessageStateDelete嵌套到需要自行修改的结构体中

type ReqMessageStateList 

type ReqMessageStateList struct {
	ReqPage
	mysql.MessageState
}

ReqMessageStateList 你可以把ReqMessageStateList嵌套到需要自行修改的结构体中

type ReqMessageStateUpdate 

type ReqMessageStateUpdate = mysql.MessageState

ReqMessageStateUpdate 你可以把ReqMessageStateUpdate或mysql.MessageState嵌套到需要自行修改的结构体中

type ReqMessageTypeCreate 

type ReqMessageTypeCreate = mysql.MessageType

ReqMessageTypeCreate 你可以把ReqMessageTypeCreate或mysql.MessageType嵌套到需要自行修改的结构体中

type ReqMessageTypeDelete 

type ReqMessageTypeDelete struct {
	Id int `json:"id"`
}

ReqMessageTypeDelete 你可以把ReqMessageTypeDelete嵌套到需要自行修改的结构体中

type ReqMessageTypeList 

type ReqMessageTypeList struct {
	ReqPage
	mysql.MessageType
}

ReqMessageTypeList 你可以把ReqMessageTypeList嵌套到需要自行修改的结构体中

type ReqMessageTypeUpdate 

type ReqMessageTypeUpdate = mysql.MessageType

ReqMessageTypeUpdate 你可以把ReqMessageTypeUpdate或mysql.MessageType嵌套到需要自行修改的结构体中

type ReqMessageUpdate 

type ReqMessageUpdate = mysql.Message

ReqMessageUpdate 你可以把ReqMessageUpdate或mysql.Message嵌套到需要自行修改的结构体中

type ReqOffpayAreaCreate 

type ReqOffpayAreaCreate = mysql.OffpayArea

ReqOffpayAreaCreate 你可以把ReqOffpayAreaCreate或mysql.OffpayArea嵌套到需要自行修改的结构体中

type ReqOffpayAreaDelete 

type ReqOffpayAreaDelete struct {
}

ReqOffpayAreaDelete 你可以把ReqOffpayAreaDelete嵌套到需要自行修改的结构体中

type ReqOffpayAreaList 

type ReqOffpayAreaList struct {
	ReqPage
	mysql.OffpayArea
}

ReqOffpayAreaList 你可以把ReqOffpayAreaList嵌套到需要自行修改的结构体中

type ReqOffpayAreaUpdate 

type ReqOffpayAreaUpdate = mysql.OffpayArea

ReqOffpayAreaUpdate 你可以把ReqOffpayAreaUpdate或mysql.OffpayArea嵌套到需要自行修改的结构体中

type ReqOrderCancel 

type ReqOrderCancel struct {
	Id          int `json:"id"`
	StateRemark int `json:"state_remark"`
}

type ReqOrderConfirmReceipt 

type ReqOrderConfirmReceipt struct {
	Id          int    `json:"id"`
	StateRemark string `json:"state_remark"`
}

type ReqOrderCreate 

type ReqOrderCreate = mysql.Order

ReqOrderCreate 你可以把ReqOrderCreate或mysql.Order嵌套到需要自行修改的结构体中

type ReqOrderDelete 

type ReqOrderDelete struct {
	Id int `json:"id"`
}

ReqOrderDelete 你可以把ReqOrderDelete嵌套到需要自行修改的结构体中

type ReqOrderExtendCreate 

type ReqOrderExtendCreate = mysql.OrderExtend

ReqOrderExtendCreate 你可以把ReqOrderExtendCreate或mysql.OrderExtend嵌套到需要自行修改的结构体中

type ReqOrderExtendDelete 

type ReqOrderExtendDelete struct {
	Id int `json:"id"`
}

ReqOrderExtendDelete 你可以把ReqOrderExtendDelete嵌套到需要自行修改的结构体中

type ReqOrderExtendList 

type ReqOrderExtendList struct {
	ReqPage
	mysql.OrderExtend
}

ReqOrderExtendList 你可以把ReqOrderExtendList嵌套到需要自行修改的结构体中

type ReqOrderExtendUpdate 

type ReqOrderExtendUpdate = mysql.OrderExtend

ReqOrderExtendUpdate 你可以把ReqOrderExtendUpdate或mysql.OrderExtend嵌套到需要自行修改的结构体中

type ReqOrderGoodsCreate 

type ReqOrderGoodsCreate = mysql.OrderGoods

ReqOrderGoodsCreate 你可以把ReqOrderGoodsCreate或mysql.OrderGoods嵌套到需要自行修改的结构体中

type ReqOrderGoodsDelete 

type ReqOrderGoodsDelete struct {
	Id int `json:"id"`
}

ReqOrderGoodsDelete 你可以把ReqOrderGoodsDelete嵌套到需要自行修改的结构体中

type ReqOrderGoodsInfo 

type ReqOrderGoodsInfo struct {
	Id int `json:"id"`
}

type ReqOrderGoodsList 

type ReqOrderGoodsList struct {
	ReqPage
	mysql.OrderGoods
}

ReqOrderGoodsList 你可以把ReqOrderGoodsList嵌套到需要自行修改的结构体中

type ReqOrderGoodsUpdate 

type ReqOrderGoodsUpdate = mysql.OrderGoods

ReqOrderGoodsUpdate 你可以把ReqOrderGoodsUpdate或mysql.OrderGoods嵌套到需要自行修改的结构体中

type ReqOrderInfo 

type ReqOrderInfo struct {
	Id int `form:"id"`
}

type ReqOrderList 

type ReqOrderList struct {
	ReqPage
	mysql.Order
}

ReqOrderList 你可以把ReqOrderList嵌套到需要自行修改的结构体中

type ReqOrderListInfo 

type ReqOrderListInfo struct {
	Page      int    `form:"page"`
	Rows      int    `form:"rows"`
	StateType string `form:"state_type"`
}

type ReqOrderLogCreate 

type ReqOrderLogCreate = mysql.OrderLog

ReqOrderLogCreate 你可以把ReqOrderLogCreate或mysql.OrderLog嵌套到需要自行修改的结构体中

type ReqOrderLogDelete 

type ReqOrderLogDelete struct {
	Id int `json:"id"`
}

ReqOrderLogDelete 你可以把ReqOrderLogDelete嵌套到需要自行修改的结构体中

type ReqOrderLogList 

type ReqOrderLogList struct {
	ReqPage
	mysql.OrderLog
}

ReqOrderLogList 你可以把ReqOrderLogList嵌套到需要自行修改的结构体中

type ReqOrderLogUpdate 

type ReqOrderLogUpdate = mysql.OrderLog

ReqOrderLogUpdate 你可以把ReqOrderLogUpdate或mysql.OrderLog嵌套到需要自行修改的结构体中

type ReqOrderLogistics 

type ReqOrderLogistics struct {
	Id int `json:"id"`
}

type ReqOrderPayCreate 

type ReqOrderPayCreate = mysql.OrderPay

ReqOrderPayCreate 你可以把ReqOrderPayCreate或mysql.OrderPay嵌套到需要自行修改的结构体中

type ReqOrderPayDelete 

type ReqOrderPayDelete struct {
	Id int `json:"id"`
}

ReqOrderPayDelete 你可以把ReqOrderPayDelete嵌套到需要自行修改的结构体中

type ReqOrderPayList 

type ReqOrderPayList struct {
	ReqPage
	mysql.OrderPay
}

ReqOrderPayList 你可以把ReqOrderPayList嵌套到需要自行修改的结构体中

type ReqOrderPayUpdate 

type ReqOrderPayUpdate = mysql.OrderPay

ReqOrderPayUpdate 你可以把ReqOrderPayUpdate或mysql.OrderPay嵌套到需要自行修改的结构体中

type ReqOrderRefundCreate 

type ReqOrderRefundCreate = mysql.OrderRefund

ReqOrderRefundCreate 你可以把ReqOrderRefundCreate或mysql.OrderRefund嵌套到需要自行修改的结构体中

type ReqOrderRefundDelete 

type ReqOrderRefundDelete struct {
	Id int `json:"id"`
}

ReqOrderRefundDelete 你可以把ReqOrderRefundDelete嵌套到需要自行修改的结构体中

type ReqOrderRefundList 

type ReqOrderRefundList struct {
	ReqPage
	mysql.OrderRefund
}

ReqOrderRefundList 你可以把ReqOrderRefundList嵌套到需要自行修改的结构体中

type ReqOrderRefundLogCreate 

type ReqOrderRefundLogCreate = mysql.OrderRefundLog

ReqOrderRefundLogCreate 你可以把ReqOrderRefundLogCreate或mysql.OrderRefundLog嵌套到需要自行修改的结构体中

type ReqOrderRefundLogDelete 

type ReqOrderRefundLogDelete struct {
	Id int `json:"id"`
}

ReqOrderRefundLogDelete 你可以把ReqOrderRefundLogDelete嵌套到需要自行修改的结构体中

type ReqOrderRefundLogList 

type ReqOrderRefundLogList struct {
	ReqPage
	mysql.OrderRefundLog
}

ReqOrderRefundLogList 你可以把ReqOrderRefundLogList嵌套到需要自行修改的结构体中

type ReqOrderRefundLogUpdate 

type ReqOrderRefundLogUpdate = mysql.OrderRefundLog

ReqOrderRefundLogUpdate 你可以把ReqOrderRefundLogUpdate或mysql.OrderRefundLog嵌套到需要自行修改的结构体中

type ReqOrderRefundReasonCreate 

type ReqOrderRefundReasonCreate = mysql.OrderRefundReason

ReqOrderRefundReasonCreate 你可以把ReqOrderRefundReasonCreate或mysql.OrderRefundReason嵌套到需要自行修改的结构体中

type ReqOrderRefundReasonDelete 

type ReqOrderRefundReasonDelete struct {
	Id int `json:"id"`
}

ReqOrderRefundReasonDelete 你可以把ReqOrderRefundReasonDelete嵌套到需要自行修改的结构体中

type ReqOrderRefundReasonList 

type ReqOrderRefundReasonList struct {
	ReqPage
	mysql.OrderRefundReason
}

ReqOrderRefundReasonList 你可以把ReqOrderRefundReasonList嵌套到需要自行修改的结构体中

type ReqOrderRefundReasonUpdate 

type ReqOrderRefundReasonUpdate = mysql.OrderRefundReason

ReqOrderRefundReasonUpdate 你可以把ReqOrderRefundReasonUpdate或mysql.OrderRefundReason嵌套到需要自行修改的结构体中

type ReqOrderRefundUpdate 

type ReqOrderRefundUpdate = mysql.OrderRefund

ReqOrderRefundUpdate 你可以把ReqOrderRefundUpdate或mysql.OrderRefund嵌套到需要自行修改的结构体中

type ReqOrderStatisCreate 

type ReqOrderStatisCreate = mysql.OrderStatis

ReqOrderStatisCreate 你可以把ReqOrderStatisCreate或mysql.OrderStatis嵌套到需要自行修改的结构体中

type ReqOrderStatisDelete 

type ReqOrderStatisDelete struct {
	Id int64 `json:"id"`
}

ReqOrderStatisDelete 你可以把ReqOrderStatisDelete嵌套到需要自行修改的结构体中

type ReqOrderStatisList 

type ReqOrderStatisList struct {
	ReqPage
	mysql.OrderStatis
}

ReqOrderStatisList 你可以把ReqOrderStatisList嵌套到需要自行修改的结构体中

type ReqOrderStatisUpdate 

type ReqOrderStatisUpdate = mysql.OrderStatis

ReqOrderStatisUpdate 你可以把ReqOrderStatisUpdate或mysql.OrderStatis嵌套到需要自行修改的结构体中

type ReqOrderUpdate 

type ReqOrderUpdate = mysql.Order

ReqOrderUpdate 你可以把ReqOrderUpdate或mysql.Order嵌套到需要自行修改的结构体中

type ReqPage 

type ReqPage struct {
	Current  int    `json:"current" form:"current"`
	PageSize int    `json:"pageSize" form:"pageSize"`
	Sort     string `json:"sort" form:"sort"`
}

type ReqPageCreate 

type ReqPageCreate = mysql.Page

ReqPageCreate 你可以把ReqPageCreate或mysql.Page嵌套到需要自行修改的结构体中

type ReqPageDelete 

type ReqPageDelete struct {
	Id int `json:"id"`
}

ReqPageDelete 你可以把ReqPageDelete嵌套到需要自行修改的结构体中

type ReqPageList 

type ReqPageList struct {
	ReqPage
	mysql.Page
}

ReqPageList 你可以把ReqPageList嵌套到需要自行修改的结构体中

type ReqPageUpdate 

type ReqPageUpdate = mysql.Page

ReqPageUpdate 你可以把ReqPageUpdate或mysql.Page嵌套到需要自行修改的结构体中

type ReqPayLogCreate 

type ReqPayLogCreate = mysql.PayLog

ReqPayLogCreate 你可以把ReqPayLogCreate或mysql.PayLog嵌套到需要自行修改的结构体中

type ReqPayLogDelete 

type ReqPayLogDelete struct {
	LogId int `json:"log_id"`
}

ReqPayLogDelete 你可以把ReqPayLogDelete嵌套到需要自行修改的结构体中

type ReqPayLogList 

type ReqPayLogList struct {
	ReqPage
	mysql.PayLog
}

ReqPayLogList 你可以把ReqPayLogList嵌套到需要自行修改的结构体中

type ReqPayLogUpdate 

type ReqPayLogUpdate = mysql.PayLog

ReqPayLogUpdate 你可以把ReqPayLogUpdate或mysql.PayLog嵌套到需要自行修改的结构体中

type ReqPdCashCreate 

type ReqPdCashCreate = mysql.PdCash

ReqPdCashCreate 你可以把ReqPdCashCreate或mysql.PdCash嵌套到需要自行修改的结构体中

type ReqPdCashDelete 

type ReqPdCashDelete struct {
	Id int `json:"id"`
}

ReqPdCashDelete 你可以把ReqPdCashDelete嵌套到需要自行修改的结构体中

type ReqPdCashList 

type ReqPdCashList struct {
	ReqPage
	mysql.PdCash
}

ReqPdCashList 你可以把ReqPdCashList嵌套到需要自行修改的结构体中

type ReqPdCashUpdate 

type ReqPdCashUpdate = mysql.PdCash

ReqPdCashUpdate 你可以把ReqPdCashUpdate或mysql.PdCash嵌套到需要自行修改的结构体中

type ReqPdLogCreate 

type ReqPdLogCreate = mysql.PdLog

ReqPdLogCreate 你可以把ReqPdLogCreate或mysql.PdLog嵌套到需要自行修改的结构体中

type ReqPdLogDelete 

type ReqPdLogDelete struct {
	Id int `json:"id"`
}

ReqPdLogDelete 你可以把ReqPdLogDelete嵌套到需要自行修改的结构体中

type ReqPdLogList 

type ReqPdLogList struct {
	ReqPage
	mysql.PdLog
}

ReqPdLogList 你可以把ReqPdLogList嵌套到需要自行修改的结构体中

type ReqPdLogUpdate 

type ReqPdLogUpdate = mysql.PdLog

ReqPdLogUpdate 你可以把ReqPdLogUpdate或mysql.PdLog嵌套到需要自行修改的结构体中

type ReqPdRechargeCreate 

type ReqPdRechargeCreate = mysql.PdRecharge

ReqPdRechargeCreate 你可以把ReqPdRechargeCreate或mysql.PdRecharge嵌套到需要自行修改的结构体中

type ReqPdRechargeDelete 

type ReqPdRechargeDelete struct {
	Id int `json:"id"`
}

ReqPdRechargeDelete 你可以把ReqPdRechargeDelete嵌套到需要自行修改的结构体中

type ReqPdRechargeList 

type ReqPdRechargeList struct {
	ReqPage
	mysql.PdRecharge
}

ReqPdRechargeList 你可以把ReqPdRechargeList嵌套到需要自行修改的结构体中

type ReqPdRechargeUpdate 

type ReqPdRechargeUpdate = mysql.PdRecharge

ReqPdRechargeUpdate 你可以把ReqPdRechargeUpdate或mysql.PdRecharge嵌套到需要自行修改的结构体中

type ReqPluginCreate 

type ReqPluginCreate = mysql.Plugin

ReqPluginCreate 你可以把ReqPluginCreate或mysql.Plugin嵌套到需要自行修改的结构体中

type ReqPluginDelete 

type ReqPluginDelete struct {
}

ReqPluginDelete 你可以把ReqPluginDelete嵌套到需要自行修改的结构体中

type ReqPluginList 

type ReqPluginList struct {
	ReqPage
	mysql.Plugin
}

ReqPluginList 你可以把ReqPluginList嵌套到需要自行修改的结构体中

type ReqPluginUpdate 

type ReqPluginUpdate = mysql.Plugin

ReqPluginUpdate 你可以把ReqPluginUpdate或mysql.Plugin嵌套到需要自行修改的结构体中

type ReqQueueCreate 

type ReqQueueCreate = mysql.Queue

ReqQueueCreate 你可以把ReqQueueCreate或mysql.Queue嵌套到需要自行修改的结构体中

type ReqQueueDelete 

type ReqQueueDelete struct {
	Id int `json:"id"`
}

ReqQueueDelete 你可以把ReqQueueDelete嵌套到需要自行修改的结构体中

type ReqQueueList 

type ReqQueueList struct {
	ReqPage
	mysql.Queue
}

ReqQueueList 你可以把ReqQueueList嵌套到需要自行修改的结构体中

type ReqQueueUpdate 

type ReqQueueUpdate = mysql.Queue

ReqQueueUpdate 你可以把ReqQueueUpdate或mysql.Queue嵌套到需要自行修改的结构体中

type ReqSaleNumCreate 

type ReqSaleNumCreate = mysql.SaleNum

ReqSaleNumCreate 你可以把ReqSaleNumCreate或mysql.SaleNum嵌套到需要自行修改的结构体中

type ReqSaleNumDelete 

type ReqSaleNumDelete struct {
}

ReqSaleNumDelete 你可以把ReqSaleNumDelete嵌套到需要自行修改的结构体中

type ReqSaleNumList 

type ReqSaleNumList struct {
	ReqPage
	mysql.SaleNum
}

ReqSaleNumList 你可以把ReqSaleNumList嵌套到需要自行修改的结构体中

type ReqSaleNumUpdate 

type ReqSaleNumUpdate = mysql.SaleNum

ReqSaleNumUpdate 你可以把ReqSaleNumUpdate或mysql.SaleNum嵌套到需要自行修改的结构体中

type ReqSendAreaCreate 

type ReqSendAreaCreate = mysql.SendArea

ReqSendAreaCreate 你可以把ReqSendAreaCreate或mysql.SendArea嵌套到需要自行修改的结构体中

type ReqSendAreaDelete 

type ReqSendAreaDelete struct {
	Id int `json:"id"`
}

ReqSendAreaDelete 你可以把ReqSendAreaDelete嵌套到需要自行修改的结构体中

type ReqSendAreaList 

type ReqSendAreaList struct {
	ReqPage
	mysql.SendArea
}

ReqSendAreaList 你可以把ReqSendAreaList嵌套到需要自行修改的结构体中

type ReqSendAreaUpdate 

type ReqSendAreaUpdate = mysql.SendArea

ReqSendAreaUpdate 你可以把ReqSendAreaUpdate或mysql.SendArea嵌套到需要自行修改的结构体中

type ReqSettingCreate 

type ReqSettingCreate = mysql.Setting

ReqSettingCreate 你可以把ReqSettingCreate或mysql.Setting嵌套到需要自行修改的结构体中

type ReqSettingDelete 

type ReqSettingDelete struct {
	Key string `json:"key"`
}

ReqSettingDelete 你可以把ReqSettingDelete嵌套到需要自行修改的结构体中

type ReqSettingList 

type ReqSettingList struct {
	ReqPage
	mysql.Setting
}

ReqSettingList 你可以把ReqSettingList嵌套到需要自行修改的结构体中

type ReqSettingUpdate 

type ReqSettingUpdate = mysql.Setting

ReqSettingUpdate 你可以把ReqSettingUpdate或mysql.Setting嵌套到需要自行修改的结构体中

type ReqShipperCreate 

type ReqShipperCreate = mysql.Shipper

ReqShipperCreate 你可以把ReqShipperCreate或mysql.Shipper嵌套到需要自行修改的结构体中

type ReqShipperDelete 

type ReqShipperDelete struct {
	Id int `json:"id"`
}

ReqShipperDelete 你可以把ReqShipperDelete嵌套到需要自行修改的结构体中

type ReqShipperList 

type ReqShipperList struct {
	ReqPage
	mysql.Shipper
}

ReqShipperList 你可以把ReqShipperList嵌套到需要自行修改的结构体中

type ReqShipperUpdate 

type ReqShipperUpdate = mysql.Shipper

ReqShipperUpdate 你可以把ReqShipperUpdate或mysql.Shipper嵌套到需要自行修改的结构体中

type ReqShopCreate 

type ReqShopCreate = mysql.Shop

ReqShopCreate 你可以把ReqShopCreate或mysql.Shop嵌套到需要自行修改的结构体中

type ReqShopDelete 

type ReqShopDelete struct {
	OpenId int `json:"open_id"`
}

ReqShopDelete 你可以把ReqShopDelete嵌套到需要自行修改的结构体中

type ReqShopGoodInfo 

type ReqShopGoodInfo struct {
	Id int `form:"id" binding:"required"`
}

type ReqShopGoodList 

type ReqShopGoodList struct {
	Cid      int    `form:"cid"`
	Name     string `form:"name"`
	Page     int    `form:"page" binding:"required"`
	PageSize int    `form:"pageSize" binding:"required"`
}

type ReqShopList 

type ReqShopList struct {
	ReqPage
	mysql.Shop
}

ReqShopList 你可以把ReqShopList嵌套到需要自行修改的结构体中

type ReqShopOrder 

type ReqShopOrder struct {
	Token     string                  `json:"token" binding:"required"`
	GoodsJson []ReqShopOrderGoodsJson `json:"goodsJson"  binding:"required"`
	Remark    string                  `json:"remark"`
}

token:2af1a72e-2fe9-40f0-8ad7-b26d7a2473ed goodsJson:[{"goodsId":100804,"number":1,"propertyChildIds":"","logisticsType":0, "inviter_id":0}] remark: calculate:true

type ReqShopOrderCancel 

type ReqShopOrderCancel struct {
	Token   string `json:"token" binding:"required"`
	OrderNo string `json:"orderNo" binding:"required"`
}

type ReqShopOrderGoodsJson 

type ReqShopOrderGoodsJson struct {
	GoodsId          uint32 `json:"goodsId"`
	Number           uint32 `json:"number"`
	PropertyChildIds string `json:"propertyChildIds"`
	LogisticsType    uint32 `json:"logisticsType"`
	InviterId        uint32 `json:"inviterId"`
}

type ReqShopOrderList 

type ReqShopOrderList struct {
	Token  string `form:"token" binding:"required"`
	Status int    `form:"status" binding:"required"`
}

type ReqShopUpdate 

type ReqShopUpdate = mysql.Shop

ReqShopUpdate 你可以把ReqShopUpdate或mysql.Shop嵌套到需要自行修改的结构体中

type ReqSmsCreate 

type ReqSmsCreate = mysql.Sms

ReqSmsCreate 你可以把ReqSmsCreate或mysql.Sms嵌套到需要自行修改的结构体中

type ReqSmsDelete 

type ReqSmsDelete struct {
	Id int `json:"id"`
}

ReqSmsDelete 你可以把ReqSmsDelete嵌套到需要自行修改的结构体中

type ReqSmsList 

type ReqSmsList struct {
	ReqPage
	mysql.Sms
}

ReqSmsList 你可以把ReqSmsList嵌套到需要自行修改的结构体中

type ReqSmsProviderCreate 

type ReqSmsProviderCreate = mysql.SmsProvider

ReqSmsProviderCreate 你可以把ReqSmsProviderCreate或mysql.SmsProvider嵌套到需要自行修改的结构体中

type ReqSmsProviderDelete 

type ReqSmsProviderDelete struct {
	Type string `json:"type"`
}

ReqSmsProviderDelete 你可以把ReqSmsProviderDelete嵌套到需要自行修改的结构体中

type ReqSmsProviderList 

type ReqSmsProviderList struct {
	ReqPage
	mysql.SmsProvider
}

ReqSmsProviderList 你可以把ReqSmsProviderList嵌套到需要自行修改的结构体中

type ReqSmsProviderUpdate 

type ReqSmsProviderUpdate = mysql.SmsProvider

ReqSmsProviderUpdate 你可以把ReqSmsProviderUpdate或mysql.SmsProvider嵌套到需要自行修改的结构体中

type ReqSmsSceneCreate 

type ReqSmsSceneCreate = mysql.SmsScene

ReqSmsSceneCreate 你可以把ReqSmsSceneCreate或mysql.SmsScene嵌套到需要自行修改的结构体中

type ReqSmsSceneDelete 

type ReqSmsSceneDelete struct {
	Id int `json:"id"`
}

ReqSmsSceneDelete 你可以把ReqSmsSceneDelete嵌套到需要自行修改的结构体中

type ReqSmsSceneList 

type ReqSmsSceneList struct {
	ReqPage
	mysql.SmsScene
}

ReqSmsSceneList 你可以把ReqSmsSceneList嵌套到需要自行修改的结构体中

type ReqSmsSceneUpdate 

type ReqSmsSceneUpdate = mysql.SmsScene

ReqSmsSceneUpdate 你可以把ReqSmsSceneUpdate或mysql.SmsScene嵌套到需要自行修改的结构体中

type ReqSmsUpdate 

type ReqSmsUpdate = mysql.Sms

ReqSmsUpdate 你可以把ReqSmsUpdate或mysql.Sms嵌套到需要自行修改的结构体中

type ReqSystemCreate 

type ReqSystemCreate = mysql.System

ReqSystemCreate 你可以把ReqSystemCreate或mysql.System嵌套到需要自行修改的结构体中

type ReqSystemDelete 

type ReqSystemDelete struct {
	Name string `json:"name"`
}

ReqSystemDelete 你可以把ReqSystemDelete嵌套到需要自行修改的结构体中

type ReqSystemList 

type ReqSystemList struct {
	ReqPage
	mysql.System
}

ReqSystemList 你可以把ReqSystemList嵌套到需要自行修改的结构体中

type ReqSystemUpdate 

type ReqSystemUpdate = mysql.System

ReqSystemUpdate 你可以把ReqSystemUpdate或mysql.System嵌套到需要自行修改的结构体中

type ReqTransportCreate 

type ReqTransportCreate = mysql.Transport

ReqTransportCreate 你可以把ReqTransportCreate或mysql.Transport嵌套到需要自行修改的结构体中

type ReqTransportDelete 

type ReqTransportDelete struct {
	Id int `json:"id"`
}

ReqTransportDelete 你可以把ReqTransportDelete嵌套到需要自行修改的结构体中

type ReqTransportExtendCreate 

type ReqTransportExtendCreate = mysql.TransportExtend

ReqTransportExtendCreate 你可以把ReqTransportExtendCreate或mysql.TransportExtend嵌套到需要自行修改的结构体中

type ReqTransportExtendDelete 

type ReqTransportExtendDelete struct {
	Id int `json:"id"`
}

ReqTransportExtendDelete 你可以把ReqTransportExtendDelete嵌套到需要自行修改的结构体中

type ReqTransportExtendList 

type ReqTransportExtendList struct {
	ReqPage
	mysql.TransportExtend
}

ReqTransportExtendList 你可以把ReqTransportExtendList嵌套到需要自行修改的结构体中

type ReqTransportExtendUpdate 

type ReqTransportExtendUpdate = mysql.TransportExtend

ReqTransportExtendUpdate 你可以把ReqTransportExtendUpdate或mysql.TransportExtend嵌套到需要自行修改的结构体中

type ReqTransportList 

type ReqTransportList struct {
	ReqPage
	mysql.Transport
}

ReqTransportList 你可以把ReqTransportList嵌套到需要自行修改的结构体中

type ReqTransportUpdate 

type ReqTransportUpdate = mysql.Transport

ReqTransportUpdate 你可以把ReqTransportUpdate或mysql.Transport嵌套到需要自行修改的结构体中

type ReqUploadCreate 

type ReqUploadCreate = mysql.Upload

ReqUploadCreate 你可以把ReqUploadCreate或mysql.Upload嵌套到需要自行修改的结构体中

type ReqUploadDelete 

type ReqUploadDelete struct {
	Id int `json:"id"`
}

ReqUploadDelete 你可以把ReqUploadDelete嵌套到需要自行修改的结构体中

type ReqUploadList 

type ReqUploadList struct {
	ReqPage
	mysql.Upload
}

ReqUploadList 你可以把ReqUploadList嵌套到需要自行修改的结构体中

type ReqUploadUpdate 

type ReqUploadUpdate = mysql.Upload

ReqUploadUpdate 你可以把ReqUploadUpdate或mysql.Upload嵌套到需要自行修改的结构体中

type ReqUserAccountCreate 

type ReqUserAccountCreate = mysql.UserAccount

ReqUserAccountCreate 你可以把ReqUserAccountCreate或mysql.UserAccount嵌套到需要自行修改的结构体中

type ReqUserAccountDelete 

type ReqUserAccountDelete struct {
	Uid int `json:"uid"`
}

ReqUserAccountDelete 你可以把ReqUserAccountDelete嵌套到需要自行修改的结构体中

type ReqUserAccountList 

type ReqUserAccountList struct {
	ReqPage
	mysql.UserAccount
}

ReqUserAccountList 你可以把ReqUserAccountList嵌套到需要自行修改的结构体中

type ReqUserAccountUpdate 

type ReqUserAccountUpdate = mysql.UserAccount

ReqUserAccountUpdate 你可以把ReqUserAccountUpdate或mysql.UserAccount嵌套到需要自行修改的结构体中

type ReqUserAddressCreate 

type ReqUserAddressCreate struct {
	Token      string `json:"token"  binding:"required"`
	ProvinceId uint32 `json:"provinceId"  binding:"required"`
	CityId     uint32 `json:"cityId"  binding:"required"`
	DistrictId uint32 `json:"districtId"`
	LinkMan    string `json:"linkMan"`
	Address    string `json:"address"`
	Mobile     string `json:"mobile"`
	Code       string `json:"code"`
	IsDefault  uint32 `json:"isDefault"`
}

type ReqUserAddressDefault 

type ReqUserAddressDefault struct {
	Token string `form:"token"  binding:"required"`
}

type ReqUserAddressList 

type ReqUserAddressList struct {
	Token string `form:"token"  binding:"required"`
}

type ReqUserAliasCreate 

type ReqUserAliasCreate = mysql.UserAlias

ReqUserAliasCreate 你可以把ReqUserAliasCreate或mysql.UserAlias嵌套到需要自行修改的结构体中

type ReqUserAliasDelete 

type ReqUserAliasDelete struct {
	Id int `json:"id"`
}

ReqUserAliasDelete 你可以把ReqUserAliasDelete嵌套到需要自行修改的结构体中

type ReqUserAliasList 

type ReqUserAliasList struct {
	ReqPage
	mysql.UserAlias
}

ReqUserAliasList 你可以把ReqUserAliasList嵌套到需要自行修改的结构体中

type ReqUserAliasUpdate 

type ReqUserAliasUpdate = mysql.UserAlias

ReqUserAliasUpdate 你可以把ReqUserAliasUpdate或mysql.UserAlias嵌套到需要自行修改的结构体中

type ReqUserAssetsCreate 

type ReqUserAssetsCreate = mysql.UserAssets

ReqUserAssetsCreate 你可以把ReqUserAssetsCreate或mysql.UserAssets嵌套到需要自行修改的结构体中

type ReqUserAssetsDelete 

type ReqUserAssetsDelete struct {
	Id int `json:"id"`
}

ReqUserAssetsDelete 你可以把ReqUserAssetsDelete嵌套到需要自行修改的结构体中

type ReqUserAssetsList 

type ReqUserAssetsList struct {
	ReqPage
	mysql.UserAssets
}

ReqUserAssetsList 你可以把ReqUserAssetsList嵌套到需要自行修改的结构体中

type ReqUserAssetsUpdate 

type ReqUserAssetsUpdate = mysql.UserAssets

ReqUserAssetsUpdate 你可以把ReqUserAssetsUpdate或mysql.UserAssets嵌套到需要自行修改的结构体中

type ReqUserLevelCreate 

type ReqUserLevelCreate = mysql.UserLevel

ReqUserLevelCreate 你可以把ReqUserLevelCreate或mysql.UserLevel嵌套到需要自行修改的结构体中

type ReqUserLevelDelete 

type ReqUserLevelDelete struct {
	Id int `json:"id"`
}

ReqUserLevelDelete 你可以把ReqUserLevelDelete嵌套到需要自行修改的结构体中

type ReqUserLevelList 

type ReqUserLevelList struct {
	ReqPage
	mysql.UserLevel
}

ReqUserLevelList 你可以把ReqUserLevelList嵌套到需要自行修改的结构体中

type ReqUserLevelUpdate 

type ReqUserLevelUpdate = mysql.UserLevel

ReqUserLevelUpdate 你可以把ReqUserLevelUpdate或mysql.UserLevel嵌套到需要自行修改的结构体中

type ReqUserLogin 

type ReqUserLogin struct {
	WechatMiniCode string `json:"wechat_mini_code"`
}

type ReqUserOpenCreate 

type ReqUserOpenCreate = mysql.UserOpen

ReqUserOpenCreate 你可以把ReqUserOpenCreate或mysql.UserOpen嵌套到需要自行修改的结构体中

type ReqUserOpenDelete 

type ReqUserOpenDelete struct {
	Uid int `json:"uid"`
}

ReqUserOpenDelete 你可以把ReqUserOpenDelete嵌套到需要自行修改的结构体中

type ReqUserOpenList 

type ReqUserOpenList struct {
	ReqPage
	mysql.UserOpen
}

ReqUserOpenList 你可以把ReqUserOpenList嵌套到需要自行修改的结构体中

type ReqUserOpenUpdate 

type ReqUserOpenUpdate = mysql.UserOpen

ReqUserOpenUpdate 你可以把ReqUserOpenUpdate或mysql.UserOpen嵌套到需要自行修改的结构体中

type ReqUserPointsLogCreate 

type ReqUserPointsLogCreate = mysql.UserPointsLog

ReqUserPointsLogCreate 你可以把ReqUserPointsLogCreate或mysql.UserPointsLog嵌套到需要自行修改的结构体中

type ReqUserPointsLogDelete 

type ReqUserPointsLogDelete struct {
	Id int `json:"id"`
}

ReqUserPointsLogDelete 你可以把ReqUserPointsLogDelete嵌套到需要自行修改的结构体中

type ReqUserPointsLogList 

type ReqUserPointsLogList struct {
	ReqPage
	mysql.UserPointsLog
}

ReqUserPointsLogList 你可以把ReqUserPointsLogList嵌套到需要自行修改的结构体中

type ReqUserPointsLogUpdate 

type ReqUserPointsLogUpdate = mysql.UserPointsLog

ReqUserPointsLogUpdate 你可以把ReqUserPointsLogUpdate或mysql.UserPointsLog嵌套到需要自行修改的结构体中

type ReqUserProfileCreate 

type ReqUserProfileCreate = mysql.UserProfile

ReqUserProfileCreate 你可以把ReqUserProfileCreate或mysql.UserProfile嵌套到需要自行修改的结构体中

type ReqUserProfileDelete 

type ReqUserProfileDelete struct {
	Id int `json:"id"`
}

ReqUserProfileDelete 你可以把ReqUserProfileDelete嵌套到需要自行修改的结构体中

type ReqUserProfileList 

type ReqUserProfileList struct {
	ReqPage
	mysql.UserProfile
}

ReqUserProfileList 你可以把ReqUserProfileList嵌套到需要自行修改的结构体中

type ReqUserProfileUpdate 

type ReqUserProfileUpdate = mysql.UserProfile

ReqUserProfileUpdate 你可以把ReqUserProfileUpdate或mysql.UserProfile嵌套到需要自行修改的结构体中

type ReqUserReigster 

type ReqUserReigster struct {
	RegisterType    string `json:"register_type"`
	WechatMiniParam struct {
		Code          string `json:"code"`
		RawData       string `json:"raw_data"`
		EncryptedData string `json:"encrypted_data"`
		Signature     string `json:"signature"`
		Iv            string `json:"iv"`
	} `json:"wechat_mini_param"`
}

type ReqUserTempCreate 

type ReqUserTempCreate = mysql.UserTemp

ReqUserTempCreate 你可以把ReqUserTempCreate或mysql.UserTemp嵌套到需要自行修改的结构体中

type ReqUserTempDelete 

type ReqUserTempDelete struct {
	UserId int `json:"user_id"`
}

ReqUserTempDelete 你可以把ReqUserTempDelete嵌套到需要自行修改的结构体中

type ReqUserTempList 

type ReqUserTempList struct {
	ReqPage
	mysql.UserTemp
}

ReqUserTempList 你可以把ReqUserTempList嵌套到需要自行修改的结构体中

type ReqUserTempUpdate 

type ReqUserTempUpdate = mysql.UserTemp

ReqUserTempUpdate 你可以把ReqUserTempUpdate或mysql.UserTemp嵌套到需要自行修改的结构体中

type ReqUserVisitCreate 

type ReqUserVisitCreate = mysql.UserVisit

ReqUserVisitCreate 你可以把ReqUserVisitCreate或mysql.UserVisit嵌套到需要自行修改的结构体中

type ReqUserVisitDelete 

type ReqUserVisitDelete struct {
}

ReqUserVisitDelete 你可以把ReqUserVisitDelete嵌套到需要自行修改的结构体中

type ReqUserVisitList 

type ReqUserVisitList struct {
	ReqPage
	mysql.UserVisit
}

ReqUserVisitList 你可以把ReqUserVisitList嵌套到需要自行修改的结构体中

type ReqUserVisitUpdate 

type ReqUserVisitUpdate = mysql.UserVisit

ReqUserVisitUpdate 你可以把ReqUserVisitUpdate或mysql.UserVisit嵌套到需要自行修改的结构体中

type ReqUserWechatCreate 

type ReqUserWechatCreate = mysql.UserWechat

ReqUserWechatCreate 你可以把ReqUserWechatCreate或mysql.UserWechat嵌套到需要自行修改的结构体中

type ReqUserWechatDelete 

type ReqUserWechatDelete struct {
	UserId int `json:"user_id"`
}

ReqUserWechatDelete 你可以把ReqUserWechatDelete嵌套到需要自行修改的结构体中

type ReqUserWechatList 

type ReqUserWechatList struct {
	ReqPage
	mysql.UserWechat
}

ReqUserWechatList 你可以把ReqUserWechatList嵌套到需要自行修改的结构体中

type ReqUserWechatUpdate 

type ReqUserWechatUpdate = mysql.UserWechat

ReqUserWechatUpdate 你可以把ReqUserWechatUpdate或mysql.UserWechat嵌套到需要自行修改的结构体中

type ReqVerifyCodeCreate 

type ReqVerifyCodeCreate = mysql.VerifyCode

ReqVerifyCodeCreate 你可以把ReqVerifyCodeCreate或mysql.VerifyCode嵌套到需要自行修改的结构体中

type ReqVerifyCodeDelete 

type ReqVerifyCodeDelete struct {
	Id int `json:"id"`
}

ReqVerifyCodeDelete 你可以把ReqVerifyCodeDelete嵌套到需要自行修改的结构体中

type ReqVerifyCodeList 

type ReqVerifyCodeList struct {
	ReqPage
	mysql.VerifyCode
}

ReqVerifyCodeList 你可以把ReqVerifyCodeList嵌套到需要自行修改的结构体中

type ReqVerifyCodeUpdate 

type ReqVerifyCodeUpdate = mysql.VerifyCode

ReqVerifyCodeUpdate 你可以把ReqVerifyCodeUpdate或mysql.VerifyCode嵌套到需要自行修改的结构体中

type ReqVersionCreate 

type ReqVersionCreate = mysql.Version

ReqVersionCreate 你可以把ReqVersionCreate或mysql.Version嵌套到需要自行修改的结构体中

type ReqVersionDelete 

type ReqVersionDelete struct {
	Id int `json:"id"`
}

ReqVersionDelete 你可以把ReqVersionDelete嵌套到需要自行修改的结构体中

type ReqVersionList 

type ReqVersionList struct {
	ReqPage
	mysql.Version
}

ReqVersionList 你可以把ReqVersionList嵌套到需要自行修改的结构体中

type ReqVersionUpdate 

type ReqVersionUpdate = mysql.Version

ReqVersionUpdate 你可以把ReqVersionUpdate或mysql.Version嵌套到需要自行修改的结构体中

type ReqVisitCreate 

type ReqVisitCreate = mysql.Visit

ReqVisitCreate 你可以把ReqVisitCreate或mysql.Visit嵌套到需要自行修改的结构体中

type ReqVisitDelete 

type ReqVisitDelete struct {
	Id int `json:"id"`
}

ReqVisitDelete 你可以把ReqVisitDelete嵌套到需要自行修改的结构体中

type ReqVisitList 

type ReqVisitList struct {
	ReqPage
	mysql.Visit
}

ReqVisitList 你可以把ReqVisitList嵌套到需要自行修改的结构体中

type ReqVisitUpdate 

type ReqVisitUpdate = mysql.Visit

ReqVisitUpdate 你可以把ReqVisitUpdate或mysql.Visit嵌套到需要自行修改的结构体中

type ReqWechatAutoReplyCreate 

type ReqWechatAutoReplyCreate = mysql.WechatAutoReply

ReqWechatAutoReplyCreate 你可以把ReqWechatAutoReplyCreate或mysql.WechatAutoReply嵌套到需要自行修改的结构体中

type ReqWechatAutoReplyDelete 

type ReqWechatAutoReplyDelete struct {
	Id int `json:"id"`
}

ReqWechatAutoReplyDelete 你可以把ReqWechatAutoReplyDelete嵌套到需要自行修改的结构体中

type ReqWechatAutoReplyKeywordsCreate 

type ReqWechatAutoReplyKeywordsCreate = mysql.WechatAutoReplyKeywords

ReqWechatAutoReplyKeywordsCreate 你可以把ReqWechatAutoReplyKeywordsCreate或mysql.WechatAutoReplyKeywords嵌套到需要自行修改的结构体中

type ReqWechatAutoReplyKeywordsDelete 

type ReqWechatAutoReplyKeywordsDelete struct {
}

ReqWechatAutoReplyKeywordsDelete 你可以把ReqWechatAutoReplyKeywordsDelete嵌套到需要自行修改的结构体中

type ReqWechatAutoReplyKeywordsList 

type ReqWechatAutoReplyKeywordsList struct {
	ReqPage
	mysql.WechatAutoReplyKeywords
}

ReqWechatAutoReplyKeywordsList 你可以把ReqWechatAutoReplyKeywordsList嵌套到需要自行修改的结构体中

type ReqWechatAutoReplyKeywordsUpdate 

type ReqWechatAutoReplyKeywordsUpdate = mysql.WechatAutoReplyKeywords

ReqWechatAutoReplyKeywordsUpdate 你可以把ReqWechatAutoReplyKeywordsUpdate或mysql.WechatAutoReplyKeywords嵌套到需要自行修改的结构体中

type ReqWechatAutoReplyList 

type ReqWechatAutoReplyList struct {
	ReqPage
	mysql.WechatAutoReply
}

ReqWechatAutoReplyList 你可以把ReqWechatAutoReplyList嵌套到需要自行修改的结构体中

type ReqWechatAutoReplyUpdate 

type ReqWechatAutoReplyUpdate = mysql.WechatAutoReply

ReqWechatAutoReplyUpdate 你可以把ReqWechatAutoReplyUpdate或mysql.WechatAutoReply嵌套到需要自行修改的结构体中

type ReqWechatBroadcastCreate 

type ReqWechatBroadcastCreate = mysql.WechatBroadcast

ReqWechatBroadcastCreate 你可以把ReqWechatBroadcastCreate或mysql.WechatBroadcast嵌套到需要自行修改的结构体中

type ReqWechatBroadcastDelete 

type ReqWechatBroadcastDelete struct {
	Id int `json:"id"`
}

ReqWechatBroadcastDelete 你可以把ReqWechatBroadcastDelete嵌套到需要自行修改的结构体中

type ReqWechatBroadcastList 

type ReqWechatBroadcastList struct {
	ReqPage
	mysql.WechatBroadcast
}

ReqWechatBroadcastList 你可以把ReqWechatBroadcastList嵌套到需要自行修改的结构体中

type ReqWechatBroadcastUpdate 

type ReqWechatBroadcastUpdate = mysql.WechatBroadcast

ReqWechatBroadcastUpdate 你可以把ReqWechatBroadcastUpdate或mysql.WechatBroadcast嵌套到需要自行修改的结构体中

type ReqWechatCreate 

type ReqWechatCreate = mysql.Wechat

ReqWechatCreate 你可以把ReqWechatCreate或mysql.Wechat嵌套到需要自行修改的结构体中

type ReqWechatDelete 

type ReqWechatDelete struct {
	Id int `json:"id"`
}

ReqWechatDelete 你可以把ReqWechatDelete嵌套到需要自行修改的结构体中

type ReqWechatList 

type ReqWechatList struct {
	ReqPage
	mysql.Wechat
}

ReqWechatList 你可以把ReqWechatList嵌套到需要自行修改的结构体中

type ReqWechatUpdate 

type ReqWechatUpdate = mysql.Wechat

ReqWechatUpdate 你可以把ReqWechatUpdate或mysql.Wechat嵌套到需要自行修改的结构体中

type ReqWechatUserCreate 

type ReqWechatUserCreate = mysql.WechatUser

ReqWechatUserCreate 你可以把ReqWechatUserCreate或mysql.WechatUser嵌套到需要自行修改的结构体中

type ReqWechatUserDelete 

type ReqWechatUserDelete struct {
	Id int `json:"id"`
}

ReqWechatUserDelete 你可以把ReqWechatUserDelete嵌套到需要自行修改的结构体中

type ReqWechatUserList 

type ReqWechatUserList struct {
	ReqPage
	mysql.WechatUser
}

ReqWechatUserList 你可以把ReqWechatUserList嵌套到需要自行修改的结构体中

type ReqWechatUserUpdate 

type ReqWechatUserUpdate = mysql.WechatUser

ReqWechatUserUpdate 你可以把ReqWechatUserUpdate或mysql.WechatUser嵌套到需要自行修改的结构体中

type RespCartList 

type RespCartList struct {
}

type RespList 

type RespList struct {
	List        interface{} `json:"list"`
	TotalNumber int         `json:"total_number"`
}

type RespOrderInfo 

type RespOrderInfo struct {
	Info              mysql.Order         `json:"info"`
	OrderCondition    view.OrderCondition `json:"order_condition"`
	OrderLog          []mysql.OrderLog    `json:"order_log"`
	ExtendOrderExtend mysql.OrderExtend   `json:"extend_order_extend"`
	ExtendOrderGoods  []FaOrderExtend     `json:"extend_order_goods"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.