diff --git a/controller/recycle_card.go b/controller/recycle_card.go new file mode 100644 index 0000000..e7415dd --- /dev/null +++ b/controller/recycle_card.go @@ -0,0 +1,294 @@ +package controller + +import ( + "github.com/codinl/go-logger" + "github.com/gin-gonic/gin" + "mh-server/lib/auth" + "mh-server/lib/status" + "mh-server/lib/xianmai" + "mh-server/model" +) + +func GameCassetteList(c *gin.Context) { + req := struct { + Keyword string `json:"keyword"` + PageNum int `json:"page_num"` + PageSize int `json:"page_size"` + }{} + if c.ShouldBindJSON(&req) != nil { + logger.Error("ShouldBindJSON err") + RespJson(c, status.BadRequest, nil) + return + } + cassettes, count, err := xianmai.GameCassetteList(req.Keyword, req.PageNum, req.PageSize) + if err != nil { + logger.Error("game cassette err", err) + RespJson(c, status.InternalServerError, nil) + return + } + + ret := map[string]interface{}{ + "count": count, + "list": cassettes, + "pageIndex": req.PageNum, + "total_page": req.PageSize, + } + + RespOK(c, ret) + return +} + +func GameCheckGoods(c *gin.Context) { + req := xianmai.GameCheckGoodsReq{} + if c.ShouldBindJSON(&req) != nil { + logger.Error("ShouldBindJSON err") + RespJson(c, status.BadRequest, nil) + return + } + resp, err := req.Get() + if err != nil { + logger.Error("game cassette err", err) + RespJson(c, status.InternalServerError, nil) + return + } + + RespOK(c, resp) + return +} + +func GameEvaluation(c *gin.Context) { + req := xianmai.GameEvaluationReq{} + if c.ShouldBindJSON(&req) != nil { + logger.Error("ShouldBindJSON err") + RespJson(c, status.BadRequest, nil) + return + } + price, err := req.Evaluation() + if err != nil { + logger.Error("game cassette err", err) + RespJson(c, status.InternalServerError, nil) + return + } + + ret := map[string]interface{}{ + "price": price, + } + RespOK(c, ret) + return +} + +func RecycleCardCreateOrder(c *gin.Context) { + req := xianmai.GameEvaluationReq{} + if c.ShouldBindJSON(&req) != nil { + logger.Error("ShouldBindJSON err") + RespJson(c, status.BadRequest, nil) + return + } + uc := auth.GetCurrentUser(c) + if uc == nil { + logger.Error("uc is nil") + RespJson(c, status.Unauthorized, nil) + return + } + //uc = &auth.UserClaims{Uid: 8588420} + order, err := model.RecycleCardOrderCreate(uc.Uid, req) + if err != nil { + logger.Error("game cassette err", err) + RespJson(c, status.InternalServerError, nil) + return + } + + RespOK(c, order) + return +} + +func RecycleCardOrderList(c *gin.Context) { + req := model.RecycleCardOrderListReq{} + if c.ShouldBindJSON(&req) != nil { + logger.Error("ShouldBindJSON err") + RespJson(c, status.BadRequest, nil) + return + } + uc := auth.GetCurrentUser(c) + if uc == nil { + logger.Error("uc is nil") + RespJson(c, status.Unauthorized, nil) + return + } + //uc = &auth.UserClaims{Uid: 8588420} + req.Uid = uc.Uid + orders, totalPage, err := req.List() + if err != nil { + logger.Error("game cassette err", err) + RespJson(c, status.InternalServerError, nil) + return + } + + ret := map[string]interface{}{ + "list": orders, + "cur_page": req.PageIdx, + "total_page": totalPage, + } + + RespOK(c, ret) + return +} + +func RecycleCardOrderDetail(c *gin.Context) { + req := struct { + OrderId uint32 `json:"order_id" binding:"required"` + }{} + if c.ShouldBindJSON(&req) != nil { + logger.Error("ShouldBindJSON err") + RespJson(c, status.BadRequest, nil) + return + } + uc := auth.GetCurrentUser(c) + if uc == nil { + logger.Error("uc is nil") + RespJson(c, status.Unauthorized, nil) + return + } + //uc = &auth.UserClaims{Uid: 8588420} + user := model.GetUserByUid(uc.Uid) + var order model.RecycleCardOrder + err := model.NewRecycleCardOrderQuerySet(model.DB).IDEq(req.OrderId).One(&order) + if err != nil { + logger.Error("game cassette err", err) + RespJson(c, status.InternalServerError, nil) + return + } + order.User = user + + RespOK(c, order) + return +} + +func RecycleCardOrderCancel(c *gin.Context) { + req := struct { + OrderId uint32 `json:"order_id" binding:"required"` + }{} + if c.ShouldBindJSON(&req) != nil { + logger.Error("ShouldBindJSON err") + RespJson(c, status.BadRequest, nil) + return + } + + var order model.RecycleCardOrder + err := model.NewRecycleCardOrderQuerySet(model.DB).IDEq(req.OrderId).One(&order) + if err != nil { + logger.Error("game cassette err:", err) + RespJson(c, status.InternalServerError, nil) + return + } + if order.State != 1 { + logger.Error("order state err") + RespJson(c, status.StateNotCancel, nil) + return + } + err = model.NewRecycleCardOrderQuerySet(model.DB).IDEq(req.OrderId).GetUpdater(). + SetState(4).Update() + if err != nil { + logger.Error("game cassette err", err) + RespJson(c, status.InternalServerError, nil) + return + } + order.State = 4 + RespOK(c, order) + return +} + +func RecycleCardOrderImageUpdate(c *gin.Context) { + req := struct { + OrderId uint32 `json:"order_id" binding:"required"` + Images string `json:"images" binding:"required"` + }{} + if c.ShouldBindJSON(&req) != nil { + logger.Error("ShouldBindJSON err") + RespJson(c, status.BadRequest, nil) + return + } + + uc := auth.GetCurrentUser(c) + if uc == nil { + logger.Error("uc is nil") + RespJson(c, status.Unauthorized, nil) + return + } + + //uc = &auth.UserClaims{Uid: 8588420} + assistant := model.GetUserByUid(uc.Uid) + if assistant.UserType != 2 { + logger.Error("not assistant") + RespJson(c, status.InternalServerError, nil) + return + } + + err := model.NewRecycleCardOrderQuerySet(model.DB).IDEq(req.OrderId).GetUpdater(). + SetImages(req.Images).Update() + if err != nil { + logger.Error("game cassette err", err) + RespJson(c, status.InternalServerError, nil) + return + } + operationLog := &model.OperationLog{ + Uid: assistant.Uid, + Description: "回收卡上传图片", + OperationType: model.OperationTypeRecycleCardOrderImageUpdate, + CorrelationName: model.LogCorrelationRecycleCardOrderId, + StoreId: uint32(assistant.StoreId), + StoreName: "", + CooperativeName: assistant.CooperativeName, + CooperativeBusinessId: assistant.CooperativeBusinessId, + } + operationLog.AddLog() + RespOK(c, nil) + return +} + +func RecycleCardOrderCheck(c *gin.Context) { + req := struct { + OrderId uint32 `json:"order_id" binding:"required"` + }{} + if c.ShouldBindJSON(&req) != nil { + logger.Error("ShouldBindJSON err") + RespJson(c, status.BadRequest, nil) + return + } + + uc := auth.GetCurrentUser(c) + if uc == nil { + logger.Error("uc is nil") + RespJson(c, status.Unauthorized, nil) + return + } + + //uc = &auth.UserClaims{Uid: 8588420} + assistant := model.GetUserByUid(uc.Uid) + if assistant.UserType != 2 { + logger.Error("not assistant") + RespJson(c, status.InternalServerError, nil) + return + } + + //err := model.NewRecycleCardOrderQuerySet(model.DB).IDEq(req.OrderId).GetUpdater(). + // SetImages(req.Images).Update() + //if err != nil { + // logger.Error("game cassette err", err) + // RespJson(c, status.InternalServerError, nil) + // return + //} + operationLog := &model.OperationLog{ + Uid: assistant.Uid, + Description: "回收卡上传图片", + OperationType: model.OperationTypeRecycleCardOrderImageUpdate, + CorrelationName: model.LogCorrelationRecycleCardOrderId, + StoreId: uint32(assistant.StoreId), + StoreName: "", + CooperativeName: assistant.CooperativeName, + CooperativeBusinessId: assistant.CooperativeBusinessId, + } + operationLog.AddLog() + RespOK(c, nil) + return +} diff --git a/lib/xianmai/xian.go b/lib/xianmai/xian.go new file mode 100644 index 0000000..373df7c --- /dev/null +++ b/lib/xianmai/xian.go @@ -0,0 +1,147 @@ +package xianmai + +import ( + "github.com/codinl/go-logger" + "strconv" +) + +func GameCassetteList(keyword string, pageNum, pageSize int) ([]Cassette, int, error) { + paraMap := map[string]interface{}{ + "keyword": keyword, + "pageNum": pageNum, + "pageSize": pageSize, + } + games := make([]Cassette, 0) + resp := &GameCassetteListResp{} + err := GetXianClient().post("game/cassetteList", paraMap, resp) + if err != nil { + logger.Error("err:", err) + return games, 0, err + } + + for i, _ := range resp.Data1.List { + cassette := Cassette{ + GoodsId: resp.Data1.List[i].GoodsId, + GoodsName: resp.Data1.List[i].GoodsName, + GoodsImg: resp.Data1.List[i].GoodsImg, + Keyword: resp.Data1.List[i].Keyword, + } + games = append(games, cassette) + } + return games, resp.Data1.Pages, nil +} + +type GameCheckGoodsReq struct { + GoodsId uint32 `json:"goods_id"` +} + +func (m *GameCheckGoodsReq) Get() (*XMCheckGoods, error) { + paraMap := map[string]interface{}{ + "goodsId": m.GoodsId, + } + var xmGoods *XMCheckGoods + resp := &GameCheckGoodsResp{} + err := GetXianClient().post("game/check/goods", paraMap, resp) + if err != nil { + logger.Error("err:", err) + return xmGoods, err + } + xmGoods = &XMCheckGoods{ + GoodsId: resp.Data1.GoodsId, + GoodsName: resp.Data1.GoodsName, + GoodsImg: resp.Data1.GoodsImg, + } + skus := make([]XMSkuTitle, 0) + problems := make([]XMProblemTitle, 0) + + for i, _ := range resp.Data1.SkuTitleVos { + details := make([]XMSkuDetail, 0) + skuTitle := XMSkuTitle{ + ProblemId: resp.Data1.SkuTitleVos[i].ProblemId, + ProblemName: resp.Data1.SkuTitleVos[i].ProblemName, + } + for _, vo := range resp.Data1.SkuTitleVos[i].SkuDetailVoList { + skuDetail := XMSkuDetail{ + ProblemValueId: vo.ProblemValueId, + ProblemValueName: vo.ProblemValueName, + } + details = append(details, skuDetail) + } + skuTitle.List = details + skus = append(skus, skuTitle) + } + + for i, _ := range resp.Data1.ProblemTitleVos { + details := make([]XMSkuDetail, 0) + problemTitle := XMProblemTitle{ + ProblemId: resp.Data1.ProblemTitleVos[i].ProblemId, + ProblemName: resp.Data1.ProblemTitleVos[i].ProblemName, + } + for _, vo := range resp.Data1.ProblemTitleVos[i].ProblemDetailVoList { + skuDetail := XMSkuDetail{ + ProblemValueId: vo.ProblemValueId, + ProblemValueName: vo.ProblemValueName, + } + details = append(details, skuDetail) + } + problemTitle.List = details + problems = append(problems, problemTitle) + } + xmGoods.Skus = skus + xmGoods.Problems = problems + + return xmGoods, nil +} + +type GameEvaluationReq struct { + GoodsId int `json:"goods_id"` + GoodsName string `json:"goods_name"` + GoodsImg string `json:"goods_img"` + Keyword string `json:"keyword"` + StoreId uint32 `json:"store_id"` + ProblemAttrList []struct { + ProblemAttrName string `json:"problem_attr_name"` + ProblemAttrId int `json:"problem_attr_id"` + ProblemAttrValueName string `json:"problem_attr_value_name"` + ProblemAttrValueId int `json:"problem_attr_value_id"` + } `json:"problem_attr_list"` + SkuList []struct { + ProblemAttrName string `json:"problem_attr_name"` + ProblemAttrId int `json:"problem_attr_id"` + ProblemAttrValueName string `json:"problem_attr_value_name"` + ProblemAttrValueId int `json:"problem_attr_value_id"` + } `json:"sku_list"` +} + +func (m *GameEvaluationReq) Evaluation() (int, error) { + paraMap := map[string]interface{}{ + "goodsId": m.GoodsId, + } + problems := make([]XMProblemAttr, 0) + skus := make([]XMProblemAttr, 0) + for i, _ := range m.ProblemAttrList { + attr := XMProblemAttr{ + ProblemAttrId: strconv.Itoa(m.ProblemAttrList[i].ProblemAttrId), + ProblemAttrValueId: strconv.Itoa(m.ProblemAttrList[i].ProblemAttrValueId), + } + problems = append(problems, attr) + } + for i, _ := range m.SkuList { + attr := XMProblemAttr{ + ProblemAttrId: strconv.Itoa(m.SkuList[i].ProblemAttrId), + ProblemAttrValueId: strconv.Itoa(m.SkuList[i].ProblemAttrValueId), + } + skus = append(skus, attr) + } + paraMap["problemAttrList"] = problems + paraMap["skuList"] = skus + + resp := &GameEvaluationResp{} + err := GetXianClient().post("game/evaluation", paraMap, resp) + if err != nil { + logger.Error("err:", err) + return 0, err + } + + return resp.Data, nil +} diff --git a/lib/xianmai/xian_http.go b/lib/xianmai/xian_http.go new file mode 100644 index 0000000..a8c924c --- /dev/null +++ b/lib/xianmai/xian_http.go @@ -0,0 +1,173 @@ +package xianmai + +import ( + "encoding/json" + "fmt" + "io/ioutil" + "net/http" + "strings" +) + +type XianMaiClient struct { + CustomPhone string `json:"custom_phone"` + BaseURL string `json:"base_url"` +} + +var xian *XianMaiClient + +func GetXianClient() *XianMaiClient { + if xian == nil { + xian = &XianMaiClient{ + CustomPhone: "17080320980", + //BaseURL:"https://oam.xianmai.net.cn", + BaseURL: "https://test.oam.xianmai.net.cn/", + } + } + return xian +} + +func (m *XianMaiClient) post(xmApi string, params map[string]interface{}, resp interface{}) error { + //params.Set("customPhone", m.CustomPhone) + //uri := m.BaseURL + xmApi + params.Encode() + params["customPhone"] = m.CustomPhone + + uri := m.BaseURL + xmApi + data, err := json.Marshal(params) + if err != nil { + fmt.Println(err) + return err + } + + res, err := http.Post(uri, "application/json;charset=utf-8", strings.NewReader(string(data))) + if err != nil { + fmt.Println(err) + return err + } + //headers["Content-Type"] = "application/json;charset=utf-8" + //res.Header.Set("Content-Type", "application/x-www-form-urlencoded") + defer res.Body.Close() + + dataRsp, err := ioutil.ReadAll(res.Body) + if err != nil { + fmt.Println(err) + return err + } + if err = json.Unmarshal(dataRsp, resp); err != nil { + fmt.Println(err) + return err + } + + return nil +} + +type GameCassetteListResp struct { + Flag bool `json:"flag"` + Code int `json:"code"` + Message string `json:"message"` + Data1 struct { + Total int `json:"total"` + List []struct { + GoodsId int `json:"goodsId"` + GoodsName string `json:"goodsName"` + GoodsImg string `json:"goodsImg"` + Keyword string `json:"keyword"` + } `json:"list"` + PageNum int `json:"pageNum"` + PageSize int `json:"pageSize"` + Size int `json:"size"` + StartRow int `json:"startRow"` + EndRow int `json:"endRow"` + Pages int `json:"pages"` + PrePage int `json:"prePage"` + NextPage int `json:"nextPage"` + IsFirstPage bool `json:"isFirstPage"` + IsLastPage bool `json:"isLastPage"` + HasPreviousPage bool `json:"hasPreviousPage"` + HasNextPage bool `json:"hasNextPage"` + NavigatePages int `json:"navigatePages"` + NavigatepageNums []int `json:"navigatepageNums"` + NavigateFirstPage int `json:"navigateFirstPage"` + NavigateLastPage int `json:"navigateLastPage"` + } `json:"data1"` + Data interface{} `json:"data"` +} + +type Cassette struct { + GoodsId int `json:"goods_id"` + GoodsName string `json:"goods_name"` + GoodsImg string `json:"goods_img"` + Keyword string `json:"keyword"` +} + +type GameCheckGoodsResp struct { + Flag bool `json:"flag"` + Code int `json:"code"` + Message string `json:"message"` + Data1 struct { + GoodsId int `json:"goodsId"` + GoodsName string `json:"goodsName"` + GoodsImg string `json:"goodsImg"` + SkuTitleVos []struct { + ProblemId int `json:"problemId"` + ProblemName string `json:"problemName"` + Interval int `json:"interval"` + SkuDetailVoList []struct { + ProblemValueId int `json:"problemValueId"` + ProblemValueName string `json:"problemValueName"` + } `json:"skuDetailVoList"` + Toption int `json:"toption"` + Tindex int `json:"tindex"` + } `json:"skuTitleVos"` + ProblemTitleVos []struct { + ProblemId int `json:"problemId"` + ProblemName string `json:"problemName"` + Interval int `json:"interval"` + SkuDetailVoList interface{} `json:"skuDetailVoList"` + ProblemDetailVoList []struct { + ProblemValueId int `json:"problemValueId"` + ProblemValueName string `json:"problemValueName"` + } `json:"problemDetailVoList"` + Toption int `json:"toption"` + Tindex int `json:"tindex"` + } `json:"problemTitleVos"` + } `json:"data1"` + Data interface{} `json:"data"` +} + +type XMCheckGoods struct { + GoodsId int `json:"goods_id"` + GoodsName string `json:"goods_name"` + GoodsImg string `json:"goods_img"` + Skus []XMSkuTitle `json:"skus"` + Problems []XMProblemTitle `json:"problems"` +} + +type XMSkuTitle struct { + ProblemId int `json:"problem_id"` + ProblemName string `json:"problem_name"` + List []XMSkuDetail `json:"list"` +} + +type XMSkuDetail struct { + ProblemValueId int `json:"problem_value_id"` + ProblemValueName string `json:"problem_value_name"` +} + +type XMProblemTitle struct { + ProblemId int `json:"problem_id"` + ProblemName string `json:"problem_name"` + List []XMSkuDetail `json:"list"` +} + +type XMProblemAttr struct { + ProblemAttrId string `json:"problemAttrId"` + ProblemAttrValueId string `json:"problemAttrValueId"` +} + +type GameEvaluationResp struct { + Flag bool `json:"flag"` + Code int `json:"code"` + Message string `json:"message"` + Data1 interface{} `json:"data1"` + Data int `json:"data"` +} diff --git a/model/autogenerated_recycle_card.go b/model/autogenerated_recycle_card.go new file mode 100644 index 0000000..f52705c --- /dev/null +++ b/model/autogenerated_recycle_card.go @@ -0,0 +1,1699 @@ +// Code generated by go-queryset. DO NOT EDIT. +package model + +import ( + "errors" + "fmt" + "strings" + "time" + + "github.com/jinzhu/gorm" +) + +// ===== BEGIN of all query sets + +// ===== BEGIN of query set RecycleCardOrderQuerySet + +// RecycleCardOrderQuerySet is an queryset type for RecycleCardOrder +type RecycleCardOrderQuerySet struct { + db *gorm.DB +} + +// NewRecycleCardOrderQuerySet constructs new RecycleCardOrderQuerySet +func NewRecycleCardOrderQuerySet(db *gorm.DB) RecycleCardOrderQuerySet { + return RecycleCardOrderQuerySet{ + db: db.Model(&RecycleCardOrder{}), + } +} + +func (qs RecycleCardOrderQuerySet) w(db *gorm.DB) RecycleCardOrderQuerySet { + return NewRecycleCardOrderQuerySet(db) +} + +func (qs RecycleCardOrderQuerySet) Select(fields ...RecycleCardOrderDBSchemaField) RecycleCardOrderQuerySet { + names := []string{} + for _, f := range fields { + names = append(names, f.String()) + } + + return qs.w(qs.db.Select(strings.Join(names, ","))) +} + +// Create is an autogenerated method +// nolint: dupl +func (o *RecycleCardOrder) Create(db *gorm.DB) error { + return db.Create(o).Error +} + +// Delete is an autogenerated method +// nolint: dupl +func (o *RecycleCardOrder) Delete(db *gorm.DB) error { + return db.Delete(o).Error +} + +// All is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) All(ret *[]RecycleCardOrder) error { + return qs.db.Find(ret).Error +} + +// AttributeEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) AttributeEq(attribute string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("attribute = ?", attribute)) +} + +// AttributeGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) AttributeGt(attribute string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("attribute > ?", attribute)) +} + +// AttributeGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) AttributeGte(attribute string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("attribute >= ?", attribute)) +} + +// AttributeIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) AttributeIn(attribute ...string) RecycleCardOrderQuerySet { + if len(attribute) == 0 { + qs.db.AddError(errors.New("must at least pass one attribute in AttributeIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("attribute IN (?)", attribute)) +} + +// AttributeLike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) AttributeLike(attribute string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("attribute LIKE ?", attribute)) +} + +// AttributeLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) AttributeLt(attribute string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("attribute < ?", attribute)) +} + +// AttributeLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) AttributeLte(attribute string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("attribute <= ?", attribute)) +} + +// AttributeNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) AttributeNe(attribute string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("attribute != ?", attribute)) +} + +// AttributeNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) AttributeNotIn(attribute ...string) RecycleCardOrderQuerySet { + if len(attribute) == 0 { + qs.db.AddError(errors.New("must at least pass one attribute in AttributeNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("attribute NOT IN (?)", attribute)) +} + +// AttributeNotlike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) AttributeNotlike(attribute string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("attribute NOT LIKE ?", attribute)) +} + +// Count is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) Count() (int, error) { + var count int + err := qs.db.Count(&count).Error + return count, err +} + +// CreatedAtEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) CreatedAtEq(createdAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("created_at = ?", createdAt)) +} + +// CreatedAtGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) CreatedAtGt(createdAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("created_at > ?", createdAt)) +} + +// CreatedAtGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) CreatedAtGte(createdAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("created_at >= ?", createdAt)) +} + +// CreatedAtLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) CreatedAtLt(createdAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("created_at < ?", createdAt)) +} + +// CreatedAtLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) CreatedAtLte(createdAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("created_at <= ?", createdAt)) +} + +// CreatedAtNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) CreatedAtNe(createdAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("created_at != ?", createdAt)) +} + +// Delete is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) Delete() error { + return qs.db.Delete(RecycleCardOrder{}).Error +} + +// DeleteNum is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DeleteNum() (int64, error) { + db := qs.db.Delete(RecycleCardOrder{}) + return db.RowsAffected, db.Error +} + +// DeleteNumUnscoped is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DeleteNumUnscoped() (int64, error) { + db := qs.db.Unscoped().Delete(RecycleCardOrder{}) + return db.RowsAffected, db.Error +} + +// DeletedAtEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DeletedAtEq(deletedAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("deleted_at = ?", deletedAt)) +} + +// DeletedAtGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DeletedAtGt(deletedAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("deleted_at > ?", deletedAt)) +} + +// DeletedAtGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DeletedAtGte(deletedAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("deleted_at >= ?", deletedAt)) +} + +// DeletedAtIsNotNull is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DeletedAtIsNotNull() RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("deleted_at IS NOT NULL")) +} + +// DeletedAtIsNull is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DeletedAtIsNull() RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("deleted_at IS NULL")) +} + +// DeletedAtLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DeletedAtLt(deletedAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("deleted_at < ?", deletedAt)) +} + +// DeletedAtLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DeletedAtLte(deletedAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("deleted_at <= ?", deletedAt)) +} + +// DeletedAtNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DeletedAtNe(deletedAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("deleted_at != ?", deletedAt)) +} + +// DepressionRateEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DepressionRateEq(depressionRate uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("depression_rate = ?", depressionRate)) +} + +// DepressionRateGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DepressionRateGt(depressionRate uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("depression_rate > ?", depressionRate)) +} + +// DepressionRateGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DepressionRateGte(depressionRate uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("depression_rate >= ?", depressionRate)) +} + +// DepressionRateIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DepressionRateIn(depressionRate ...uint32) RecycleCardOrderQuerySet { + if len(depressionRate) == 0 { + qs.db.AddError(errors.New("must at least pass one depressionRate in DepressionRateIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("depression_rate IN (?)", depressionRate)) +} + +// DepressionRateLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DepressionRateLt(depressionRate uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("depression_rate < ?", depressionRate)) +} + +// DepressionRateLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DepressionRateLte(depressionRate uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("depression_rate <= ?", depressionRate)) +} + +// DepressionRateNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DepressionRateNe(depressionRate uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("depression_rate != ?", depressionRate)) +} + +// DepressionRateNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) DepressionRateNotIn(depressionRate ...uint32) RecycleCardOrderQuerySet { + if len(depressionRate) == 0 { + qs.db.AddError(errors.New("must at least pass one depressionRate in DepressionRateNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("depression_rate NOT IN (?)", depressionRate)) +} + +// EvaluationTimeEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) EvaluationTimeEq(evaluationTime time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("evaluation_time = ?", evaluationTime)) +} + +// EvaluationTimeGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) EvaluationTimeGt(evaluationTime time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("evaluation_time > ?", evaluationTime)) +} + +// EvaluationTimeGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) EvaluationTimeGte(evaluationTime time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("evaluation_time >= ?", evaluationTime)) +} + +// EvaluationTimeLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) EvaluationTimeLt(evaluationTime time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("evaluation_time < ?", evaluationTime)) +} + +// EvaluationTimeLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) EvaluationTimeLte(evaluationTime time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("evaluation_time <= ?", evaluationTime)) +} + +// EvaluationTimeNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) EvaluationTimeNe(evaluationTime time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("evaluation_time != ?", evaluationTime)) +} + +// GetDB is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GetDB() *gorm.DB { + return qs.db +} + +// GetUpdater is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GetUpdater() RecycleCardOrderUpdater { + return NewRecycleCardOrderUpdater(qs.db) +} + +// GoodsIdEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsIdEq(goodsId uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_id = ?", goodsId)) +} + +// GoodsIdGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsIdGt(goodsId uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_id > ?", goodsId)) +} + +// GoodsIdGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsIdGte(goodsId uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_id >= ?", goodsId)) +} + +// GoodsIdIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsIdIn(goodsId ...uint32) RecycleCardOrderQuerySet { + if len(goodsId) == 0 { + qs.db.AddError(errors.New("must at least pass one goodsId in GoodsIdIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("goods_id IN (?)", goodsId)) +} + +// GoodsIdLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsIdLt(goodsId uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_id < ?", goodsId)) +} + +// GoodsIdLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsIdLte(goodsId uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_id <= ?", goodsId)) +} + +// GoodsIdNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsIdNe(goodsId uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_id != ?", goodsId)) +} + +// GoodsIdNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsIdNotIn(goodsId ...uint32) RecycleCardOrderQuerySet { + if len(goodsId) == 0 { + qs.db.AddError(errors.New("must at least pass one goodsId in GoodsIdNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("goods_id NOT IN (?)", goodsId)) +} + +// GoodsImgEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsImgEq(goodsImg string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_img = ?", goodsImg)) +} + +// GoodsImgGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsImgGt(goodsImg string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_img > ?", goodsImg)) +} + +// GoodsImgGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsImgGte(goodsImg string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_img >= ?", goodsImg)) +} + +// GoodsImgIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsImgIn(goodsImg ...string) RecycleCardOrderQuerySet { + if len(goodsImg) == 0 { + qs.db.AddError(errors.New("must at least pass one goodsImg in GoodsImgIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("goods_img IN (?)", goodsImg)) +} + +// GoodsImgLike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsImgLike(goodsImg string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_img LIKE ?", goodsImg)) +} + +// GoodsImgLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsImgLt(goodsImg string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_img < ?", goodsImg)) +} + +// GoodsImgLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsImgLte(goodsImg string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_img <= ?", goodsImg)) +} + +// GoodsImgNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsImgNe(goodsImg string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_img != ?", goodsImg)) +} + +// GoodsImgNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsImgNotIn(goodsImg ...string) RecycleCardOrderQuerySet { + if len(goodsImg) == 0 { + qs.db.AddError(errors.New("must at least pass one goodsImg in GoodsImgNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("goods_img NOT IN (?)", goodsImg)) +} + +// GoodsImgNotlike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsImgNotlike(goodsImg string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_img NOT LIKE ?", goodsImg)) +} + +// GoodsNameEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsNameEq(goodsName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_name = ?", goodsName)) +} + +// GoodsNameGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsNameGt(goodsName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_name > ?", goodsName)) +} + +// GoodsNameGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsNameGte(goodsName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_name >= ?", goodsName)) +} + +// GoodsNameIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsNameIn(goodsName ...string) RecycleCardOrderQuerySet { + if len(goodsName) == 0 { + qs.db.AddError(errors.New("must at least pass one goodsName in GoodsNameIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("goods_name IN (?)", goodsName)) +} + +// GoodsNameLike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsNameLike(goodsName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_name LIKE ?", goodsName)) +} + +// GoodsNameLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsNameLt(goodsName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_name < ?", goodsName)) +} + +// GoodsNameLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsNameLte(goodsName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_name <= ?", goodsName)) +} + +// GoodsNameNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsNameNe(goodsName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_name != ?", goodsName)) +} + +// GoodsNameNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsNameNotIn(goodsName ...string) RecycleCardOrderQuerySet { + if len(goodsName) == 0 { + qs.db.AddError(errors.New("must at least pass one goodsName in GoodsNameNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("goods_name NOT IN (?)", goodsName)) +} + +// GoodsNameNotlike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) GoodsNameNotlike(goodsName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("goods_name NOT LIKE ?", goodsName)) +} + +// IDEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) IDEq(ID uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("id = ?", ID)) +} + +// IDGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) IDGt(ID uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("id > ?", ID)) +} + +// IDGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) IDGte(ID uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("id >= ?", ID)) +} + +// IDIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) IDIn(ID ...uint32) RecycleCardOrderQuerySet { + if len(ID) == 0 { + qs.db.AddError(errors.New("must at least pass one ID in IDIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("id IN (?)", ID)) +} + +// IDLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) IDLt(ID uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("id < ?", ID)) +} + +// IDLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) IDLte(ID uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("id <= ?", ID)) +} + +// IDNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) IDNe(ID uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("id != ?", ID)) +} + +// IDNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) IDNotIn(ID ...uint32) RecycleCardOrderQuerySet { + if len(ID) == 0 { + qs.db.AddError(errors.New("must at least pass one ID in IDNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("id NOT IN (?)", ID)) +} + +// ImagesEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) ImagesEq(images string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("images = ?", images)) +} + +// ImagesGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) ImagesGt(images string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("images > ?", images)) +} + +// ImagesGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) ImagesGte(images string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("images >= ?", images)) +} + +// ImagesIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) ImagesIn(images ...string) RecycleCardOrderQuerySet { + if len(images) == 0 { + qs.db.AddError(errors.New("must at least pass one images in ImagesIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("images IN (?)", images)) +} + +// ImagesLike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) ImagesLike(images string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("images LIKE ?", images)) +} + +// ImagesLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) ImagesLt(images string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("images < ?", images)) +} + +// ImagesLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) ImagesLte(images string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("images <= ?", images)) +} + +// ImagesNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) ImagesNe(images string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("images != ?", images)) +} + +// ImagesNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) ImagesNotIn(images ...string) RecycleCardOrderQuerySet { + if len(images) == 0 { + qs.db.AddError(errors.New("must at least pass one images in ImagesNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("images NOT IN (?)", images)) +} + +// ImagesNotlike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) ImagesNotlike(images string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("images NOT LIKE ?", images)) +} + +// KeywordEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) KeywordEq(keyword string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("keyword = ?", keyword)) +} + +// KeywordGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) KeywordGt(keyword string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("keyword > ?", keyword)) +} + +// KeywordGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) KeywordGte(keyword string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("keyword >= ?", keyword)) +} + +// KeywordIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) KeywordIn(keyword ...string) RecycleCardOrderQuerySet { + if len(keyword) == 0 { + qs.db.AddError(errors.New("must at least pass one keyword in KeywordIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("keyword IN (?)", keyword)) +} + +// KeywordLike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) KeywordLike(keyword string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("keyword LIKE ?", keyword)) +} + +// KeywordLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) KeywordLt(keyword string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("keyword < ?", keyword)) +} + +// KeywordLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) KeywordLte(keyword string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("keyword <= ?", keyword)) +} + +// KeywordNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) KeywordNe(keyword string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("keyword != ?", keyword)) +} + +// KeywordNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) KeywordNotIn(keyword ...string) RecycleCardOrderQuerySet { + if len(keyword) == 0 { + qs.db.AddError(errors.New("must at least pass one keyword in KeywordNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("keyword NOT IN (?)", keyword)) +} + +// KeywordNotlike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) KeywordNotlike(keyword string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("keyword NOT LIKE ?", keyword)) +} + +// Limit is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) Limit(limit int) RecycleCardOrderQuerySet { + return qs.w(qs.db.Limit(limit)) +} + +// NumberEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) NumberEq(number string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("number = ?", number)) +} + +// NumberGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) NumberGt(number string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("number > ?", number)) +} + +// NumberGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) NumberGte(number string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("number >= ?", number)) +} + +// NumberIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) NumberIn(number ...string) RecycleCardOrderQuerySet { + if len(number) == 0 { + qs.db.AddError(errors.New("must at least pass one number in NumberIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("number IN (?)", number)) +} + +// NumberLike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) NumberLike(number string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("number LIKE ?", number)) +} + +// NumberLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) NumberLt(number string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("number < ?", number)) +} + +// NumberLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) NumberLte(number string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("number <= ?", number)) +} + +// NumberNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) NumberNe(number string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("number != ?", number)) +} + +// NumberNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) NumberNotIn(number ...string) RecycleCardOrderQuerySet { + if len(number) == 0 { + qs.db.AddError(errors.New("must at least pass one number in NumberNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("number NOT IN (?)", number)) +} + +// NumberNotlike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) NumberNotlike(number string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("number NOT LIKE ?", number)) +} + +// Offset is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) Offset(offset int) RecycleCardOrderQuerySet { + return qs.w(qs.db.Offset(offset)) +} + +// One is used to retrieve one result. It returns gorm.ErrRecordNotFound +// if nothing was fetched +func (qs RecycleCardOrderQuerySet) One(ret *RecycleCardOrder) error { + return qs.db.First(ret).Error +} + +// OrderAscByAttribute is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByAttribute() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("attribute ASC")) +} + +// OrderAscByCreatedAt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByCreatedAt() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("created_at ASC")) +} + +// OrderAscByDeletedAt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByDeletedAt() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("deleted_at ASC")) +} + +// OrderAscByDepressionRate is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByDepressionRate() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("depression_rate ASC")) +} + +// OrderAscByEvaluationTime is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByEvaluationTime() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("evaluation_time ASC")) +} + +// OrderAscByGoodsId is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByGoodsId() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("goods_id ASC")) +} + +// OrderAscByGoodsImg is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByGoodsImg() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("goods_img ASC")) +} + +// OrderAscByGoodsName is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByGoodsName() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("goods_name ASC")) +} + +// OrderAscByID is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByID() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("id ASC")) +} + +// OrderAscByImages is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByImages() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("images ASC")) +} + +// OrderAscByKeyword is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByKeyword() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("keyword ASC")) +} + +// OrderAscByNumber is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByNumber() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("number ASC")) +} + +// OrderAscByPrice is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByPrice() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("price ASC")) +} + +// OrderAscBySerialNumber is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscBySerialNumber() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("serial_number ASC")) +} + +// OrderAscByState is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByState() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("state ASC")) +} + +// OrderAscByStoreId is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByStoreId() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("store_id ASC")) +} + +// OrderAscByStoreName is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByStoreName() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("store_name ASC")) +} + +// OrderAscByUid is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByUid() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("uid ASC")) +} + +// OrderAscByUpdatedAt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderAscByUpdatedAt() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("updated_at ASC")) +} + +// OrderDescByAttribute is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByAttribute() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("attribute DESC")) +} + +// OrderDescByCreatedAt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByCreatedAt() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("created_at DESC")) +} + +// OrderDescByDeletedAt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByDeletedAt() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("deleted_at DESC")) +} + +// OrderDescByDepressionRate is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByDepressionRate() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("depression_rate DESC")) +} + +// OrderDescByEvaluationTime is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByEvaluationTime() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("evaluation_time DESC")) +} + +// OrderDescByGoodsId is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByGoodsId() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("goods_id DESC")) +} + +// OrderDescByGoodsImg is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByGoodsImg() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("goods_img DESC")) +} + +// OrderDescByGoodsName is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByGoodsName() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("goods_name DESC")) +} + +// OrderDescByID is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByID() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("id DESC")) +} + +// OrderDescByImages is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByImages() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("images DESC")) +} + +// OrderDescByKeyword is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByKeyword() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("keyword DESC")) +} + +// OrderDescByNumber is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByNumber() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("number DESC")) +} + +// OrderDescByPrice is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByPrice() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("price DESC")) +} + +// OrderDescBySerialNumber is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescBySerialNumber() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("serial_number DESC")) +} + +// OrderDescByState is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByState() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("state DESC")) +} + +// OrderDescByStoreId is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByStoreId() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("store_id DESC")) +} + +// OrderDescByStoreName is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByStoreName() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("store_name DESC")) +} + +// OrderDescByUid is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByUid() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("uid DESC")) +} + +// OrderDescByUpdatedAt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) OrderDescByUpdatedAt() RecycleCardOrderQuerySet { + return qs.w(qs.db.Order("updated_at DESC")) +} + +// PriceEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) PriceEq(price uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("price = ?", price)) +} + +// PriceGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) PriceGt(price uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("price > ?", price)) +} + +// PriceGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) PriceGte(price uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("price >= ?", price)) +} + +// PriceIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) PriceIn(price ...uint32) RecycleCardOrderQuerySet { + if len(price) == 0 { + qs.db.AddError(errors.New("must at least pass one price in PriceIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("price IN (?)", price)) +} + +// PriceLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) PriceLt(price uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("price < ?", price)) +} + +// PriceLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) PriceLte(price uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("price <= ?", price)) +} + +// PriceNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) PriceNe(price uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("price != ?", price)) +} + +// PriceNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) PriceNotIn(price ...uint32) RecycleCardOrderQuerySet { + if len(price) == 0 { + qs.db.AddError(errors.New("must at least pass one price in PriceNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("price NOT IN (?)", price)) +} + +// SerialNumberEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) SerialNumberEq(serialNumber string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("serial_number = ?", serialNumber)) +} + +// SerialNumberGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) SerialNumberGt(serialNumber string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("serial_number > ?", serialNumber)) +} + +// SerialNumberGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) SerialNumberGte(serialNumber string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("serial_number >= ?", serialNumber)) +} + +// SerialNumberIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) SerialNumberIn(serialNumber ...string) RecycleCardOrderQuerySet { + if len(serialNumber) == 0 { + qs.db.AddError(errors.New("must at least pass one serialNumber in SerialNumberIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("serial_number IN (?)", serialNumber)) +} + +// SerialNumberLike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) SerialNumberLike(serialNumber string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("serial_number LIKE ?", serialNumber)) +} + +// SerialNumberLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) SerialNumberLt(serialNumber string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("serial_number < ?", serialNumber)) +} + +// SerialNumberLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) SerialNumberLte(serialNumber string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("serial_number <= ?", serialNumber)) +} + +// SerialNumberNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) SerialNumberNe(serialNumber string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("serial_number != ?", serialNumber)) +} + +// SerialNumberNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) SerialNumberNotIn(serialNumber ...string) RecycleCardOrderQuerySet { + if len(serialNumber) == 0 { + qs.db.AddError(errors.New("must at least pass one serialNumber in SerialNumberNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("serial_number NOT IN (?)", serialNumber)) +} + +// SerialNumberNotlike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) SerialNumberNotlike(serialNumber string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("serial_number NOT LIKE ?", serialNumber)) +} + +// StateEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StateEq(state uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("state = ?", state)) +} + +// StateGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StateGt(state uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("state > ?", state)) +} + +// StateGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StateGte(state uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("state >= ?", state)) +} + +// StateIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StateIn(state ...uint32) RecycleCardOrderQuerySet { + if len(state) == 0 { + qs.db.AddError(errors.New("must at least pass one state in StateIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("state IN (?)", state)) +} + +// StateLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StateLt(state uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("state < ?", state)) +} + +// StateLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StateLte(state uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("state <= ?", state)) +} + +// StateNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StateNe(state uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("state != ?", state)) +} + +// StateNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StateNotIn(state ...uint32) RecycleCardOrderQuerySet { + if len(state) == 0 { + qs.db.AddError(errors.New("must at least pass one state in StateNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("state NOT IN (?)", state)) +} + +// StoreIdEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreIdEq(storeId uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_id = ?", storeId)) +} + +// StoreIdGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreIdGt(storeId uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_id > ?", storeId)) +} + +// StoreIdGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreIdGte(storeId uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_id >= ?", storeId)) +} + +// StoreIdIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreIdIn(storeId ...uint32) RecycleCardOrderQuerySet { + if len(storeId) == 0 { + qs.db.AddError(errors.New("must at least pass one storeId in StoreIdIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("store_id IN (?)", storeId)) +} + +// StoreIdLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreIdLt(storeId uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_id < ?", storeId)) +} + +// StoreIdLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreIdLte(storeId uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_id <= ?", storeId)) +} + +// StoreIdNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreIdNe(storeId uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_id != ?", storeId)) +} + +// StoreIdNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreIdNotIn(storeId ...uint32) RecycleCardOrderQuerySet { + if len(storeId) == 0 { + qs.db.AddError(errors.New("must at least pass one storeId in StoreIdNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("store_id NOT IN (?)", storeId)) +} + +// StoreNameEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreNameEq(storeName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_name = ?", storeName)) +} + +// StoreNameGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreNameGt(storeName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_name > ?", storeName)) +} + +// StoreNameGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreNameGte(storeName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_name >= ?", storeName)) +} + +// StoreNameIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreNameIn(storeName ...string) RecycleCardOrderQuerySet { + if len(storeName) == 0 { + qs.db.AddError(errors.New("must at least pass one storeName in StoreNameIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("store_name IN (?)", storeName)) +} + +// StoreNameLike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreNameLike(storeName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_name LIKE ?", storeName)) +} + +// StoreNameLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreNameLt(storeName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_name < ?", storeName)) +} + +// StoreNameLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreNameLte(storeName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_name <= ?", storeName)) +} + +// StoreNameNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreNameNe(storeName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_name != ?", storeName)) +} + +// StoreNameNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreNameNotIn(storeName ...string) RecycleCardOrderQuerySet { + if len(storeName) == 0 { + qs.db.AddError(errors.New("must at least pass one storeName in StoreNameNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("store_name NOT IN (?)", storeName)) +} + +// StoreNameNotlike is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) StoreNameNotlike(storeName string) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("store_name NOT LIKE ?", storeName)) +} + +// UidEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UidEq(uid uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("uid = ?", uid)) +} + +// UidGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UidGt(uid uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("uid > ?", uid)) +} + +// UidGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UidGte(uid uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("uid >= ?", uid)) +} + +// UidIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UidIn(uid ...uint32) RecycleCardOrderQuerySet { + if len(uid) == 0 { + qs.db.AddError(errors.New("must at least pass one uid in UidIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("uid IN (?)", uid)) +} + +// UidLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UidLt(uid uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("uid < ?", uid)) +} + +// UidLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UidLte(uid uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("uid <= ?", uid)) +} + +// UidNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UidNe(uid uint32) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("uid != ?", uid)) +} + +// UidNotIn is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UidNotIn(uid ...uint32) RecycleCardOrderQuerySet { + if len(uid) == 0 { + qs.db.AddError(errors.New("must at least pass one uid in UidNotIn")) + return qs.w(qs.db) + } + return qs.w(qs.db.Where("uid NOT IN (?)", uid)) +} + +// UpdatedAtEq is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UpdatedAtEq(updatedAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("updated_at = ?", updatedAt)) +} + +// UpdatedAtGt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UpdatedAtGt(updatedAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("updated_at > ?", updatedAt)) +} + +// UpdatedAtGte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UpdatedAtGte(updatedAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("updated_at >= ?", updatedAt)) +} + +// UpdatedAtLt is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UpdatedAtLt(updatedAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("updated_at < ?", updatedAt)) +} + +// UpdatedAtLte is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UpdatedAtLte(updatedAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("updated_at <= ?", updatedAt)) +} + +// UpdatedAtNe is an autogenerated method +// nolint: dupl +func (qs RecycleCardOrderQuerySet) UpdatedAtNe(updatedAt time.Time) RecycleCardOrderQuerySet { + return qs.w(qs.db.Where("updated_at != ?", updatedAt)) +} + +// SetAttribute is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetAttribute(attribute string) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.Attribute)] = attribute + return u +} + +// SetCreatedAt is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetCreatedAt(createdAt time.Time) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.CreatedAt)] = createdAt + return u +} + +// SetDeletedAt is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetDeletedAt(deletedAt *time.Time) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.DeletedAt)] = deletedAt + return u +} + +// SetDepressionRate is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetDepressionRate(depressionRate uint32) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.DepressionRate)] = depressionRate + return u +} + +// SetEvaluationTime is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetEvaluationTime(evaluationTime time.Time) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.EvaluationTime)] = evaluationTime + return u +} + +// SetGoodsId is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetGoodsId(goodsId uint32) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.GoodsId)] = goodsId + return u +} + +// SetGoodsImg is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetGoodsImg(goodsImg string) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.GoodsImg)] = goodsImg + return u +} + +// SetGoodsName is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetGoodsName(goodsName string) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.GoodsName)] = goodsName + return u +} + +// SetID is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetID(ID uint32) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.ID)] = ID + return u +} + +// SetImages is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetImages(images string) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.Images)] = images + return u +} + +// SetKeyword is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetKeyword(keyword string) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.Keyword)] = keyword + return u +} + +// SetNumber is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetNumber(number string) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.Number)] = number + return u +} + +// SetPrice is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetPrice(price uint32) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.Price)] = price + return u +} + +// SetSerialNumber is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetSerialNumber(serialNumber string) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.SerialNumber)] = serialNumber + return u +} + +// SetState is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetState(state uint32) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.State)] = state + return u +} + +// SetStoreId is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetStoreId(storeId uint32) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.StoreId)] = storeId + return u +} + +// SetStoreName is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetStoreName(storeName string) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.StoreName)] = storeName + return u +} + +// SetUid is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetUid(uid uint32) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.Uid)] = uid + return u +} + +// SetUpdatedAt is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) SetUpdatedAt(updatedAt time.Time) RecycleCardOrderUpdater { + u.fields[string(RecycleCardOrderDBSchema.UpdatedAt)] = updatedAt + return u +} + +// Update is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) Update() error { + return u.db.Updates(u.fields).Error +} + +// UpdateNum is an autogenerated method +// nolint: dupl +func (u RecycleCardOrderUpdater) UpdateNum() (int64, error) { + db := u.db.Updates(u.fields) + return db.RowsAffected, db.Error +} + +// ===== END of query set RecycleCardOrderQuerySet + +// ===== BEGIN of RecycleCardOrder modifiers + +// RecycleCardOrderDBSchemaField describes database schema field. It requires for method 'Update' +type RecycleCardOrderDBSchemaField string + +// String method returns string representation of field. +// nolint: dupl +func (f RecycleCardOrderDBSchemaField) String() string { + return string(f) +} + +// RecycleCardOrderDBSchema stores db field names of RecycleCardOrder +var RecycleCardOrderDBSchema = struct { + ID RecycleCardOrderDBSchemaField + CreatedAt RecycleCardOrderDBSchemaField + UpdatedAt RecycleCardOrderDBSchemaField + DeletedAt RecycleCardOrderDBSchemaField + Uid RecycleCardOrderDBSchemaField + GoodsId RecycleCardOrderDBSchemaField + GoodsName RecycleCardOrderDBSchemaField + GoodsImg RecycleCardOrderDBSchemaField + Keyword RecycleCardOrderDBSchemaField + Price RecycleCardOrderDBSchemaField + State RecycleCardOrderDBSchemaField + StoreId RecycleCardOrderDBSchemaField + StoreName RecycleCardOrderDBSchemaField + Images RecycleCardOrderDBSchemaField + SerialNumber RecycleCardOrderDBSchemaField + EvaluationTime RecycleCardOrderDBSchemaField + Attribute RecycleCardOrderDBSchemaField + Number RecycleCardOrderDBSchemaField + DepressionRate RecycleCardOrderDBSchemaField +}{ + + ID: RecycleCardOrderDBSchemaField("id"), + CreatedAt: RecycleCardOrderDBSchemaField("created_at"), + UpdatedAt: RecycleCardOrderDBSchemaField("updated_at"), + DeletedAt: RecycleCardOrderDBSchemaField("deleted_at"), + Uid: RecycleCardOrderDBSchemaField("uid"), + GoodsId: RecycleCardOrderDBSchemaField("goods_id"), + GoodsName: RecycleCardOrderDBSchemaField("goods_name"), + GoodsImg: RecycleCardOrderDBSchemaField("goods_img"), + Keyword: RecycleCardOrderDBSchemaField("keyword"), + Price: RecycleCardOrderDBSchemaField("price"), + State: RecycleCardOrderDBSchemaField("state"), + StoreId: RecycleCardOrderDBSchemaField("store_id"), + StoreName: RecycleCardOrderDBSchemaField("store_name"), + Images: RecycleCardOrderDBSchemaField("images"), + SerialNumber: RecycleCardOrderDBSchemaField("serial_number"), + EvaluationTime: RecycleCardOrderDBSchemaField("evaluation_time"), + Attribute: RecycleCardOrderDBSchemaField("attribute"), + Number: RecycleCardOrderDBSchemaField("number"), + DepressionRate: RecycleCardOrderDBSchemaField("depression_rate"), +} + +// Update updates RecycleCardOrder fields by primary key +// nolint: dupl +func (o *RecycleCardOrder) Update(db *gorm.DB, fields ...RecycleCardOrderDBSchemaField) error { + dbNameToFieldName := map[string]interface{}{ + "id": o.ID, + "created_at": o.CreatedAt, + "updated_at": o.UpdatedAt, + "deleted_at": o.DeletedAt, + "uid": o.Uid, + "goods_id": o.GoodsId, + "goods_name": o.GoodsName, + "goods_img": o.GoodsImg, + "keyword": o.Keyword, + "price": o.Price, + "state": o.State, + "store_id": o.StoreId, + "store_name": o.StoreName, + "images": o.Images, + "serial_number": o.SerialNumber, + "evaluation_time": o.EvaluationTime, + "attribute": o.Attribute, + "number": o.Number, + "depression_rate": o.DepressionRate, + } + u := map[string]interface{}{} + for _, f := range fields { + fs := f.String() + u[fs] = dbNameToFieldName[fs] + } + if err := db.Model(o).Updates(u).Error; err != nil { + if err == gorm.ErrRecordNotFound { + return err + } + + return fmt.Errorf("can't update RecycleCardOrder %v fields %v: %s", + o, fields, err) + } + + return nil +} + +// RecycleCardOrderUpdater is an RecycleCardOrder updates manager +type RecycleCardOrderUpdater struct { + fields map[string]interface{} + db *gorm.DB +} + +// NewRecycleCardOrderUpdater creates new RecycleCardOrder updater +// nolint: dupl +func NewRecycleCardOrderUpdater(db *gorm.DB) RecycleCardOrderUpdater { + return RecycleCardOrderUpdater{ + fields: map[string]interface{}{}, + db: db.Model(&RecycleCardOrder{}), + } +} + +// ===== END of RecycleCardOrder modifiers + +// ===== END of all query sets diff --git a/model/model_test.go b/model/model_test.go index dfdeaa0..7094391 100644 --- a/model/model_test.go +++ b/model/model_test.go @@ -157,6 +157,7 @@ func InitTestDB() { &UserInvite{}, &UserInviteRecord{}, &CooperativeMemberPromotionStore{}, + &RecycleCardOrder{}, ) fmt.Println("DB init success") diff --git a/model/recycle_card.go b/model/recycle_card.go new file mode 100644 index 0000000..b024dd3 --- /dev/null +++ b/model/recycle_card.go @@ -0,0 +1,148 @@ +package model + +import ( + "encoding/json" + "fmt" + "github.com/codinl/go-logger" + "math/rand" + "mh-server/lib/xianmai" + "time" +) + +//go:generate goqueryset -in recycle_card.go +// gen:qs +type RecycleCardOrder struct { + Model + + Uid uint32 `json:"uid" gorm:"index"` + GoodsId uint32 `json:"goods_id" gorm:"index"` + GoodsName string `json:"goods_name"` + GoodsImg string `json:"goods_img"` + Keyword string `json:"keyword"` + Price uint32 `json:"price"` + State uint32 `json:"state"` // 1-待回收 2-已完成 3-已被拒 4-已取消 + StoreId uint32 `json:"store_id" gorm:"index"` + StoreName string `json:"store_name"` + Images string `json:"images" gorm:"type:text"` // 图片 + SerialNumber string `json:"serial_number"` + EvaluationTime time.Time `json:"evaluation_time"` + Attribute string `json:"attribute" gorm:"type:text"` // + Number string `json:"number"` // 订单 + DepressionRate uint32 `json:"depression_rate"` // + User *User `json:"user" gorm:"-"` +} + +type RecycleAttribute struct { + Id uint32 `json:"id"` + Name string `json:"name"` + ValueId uint32 `json:"value_id"` + ValueName string `json:"value_name"` + Type uint32 `json:"type"` // 1-sku 2-问题 +} + +//type GameEvaluationReq struct { +// GoodsId uint32 `json:"goods_id"` +// ProblemAttrList []struct { +// ProblemAttrId int `json:"problem_attr_id"` +// ProblemAttrValueId int `json:"problem_attr_value_id"` +// } `json:"problem_attr_list"` +// SkuList []struct { +// ProblemAttrId int `json:"problem_attr_id"` +// ProblemAttrValueId int `json:"problem_attr_value_id"` +// } `json:"sku_list"` +//} + +func RecycleCardOrderCreate(uid uint32, req xianmai.GameEvaluationReq) (*RecycleCardOrder, error) { + + order := &RecycleCardOrder{ + Uid: uid, + GoodsId: uint32(req.GoodsId), + GoodsName: req.GoodsName, + GoodsImg: req.GoodsImg, + Keyword: req.Keyword, + State: 1, + StoreId: req.StoreId, + StoreName: "", + Images: "", + SerialNumber: "", + Attribute: "", + DepressionRate: 0, + } + evaluation, err := req.Evaluation() + if err != nil { + logger.Error("evaluation err:", err) + return order, err + } + evaluation = (evaluation * 1) / 100 + order.Price = uint32(evaluation) + attributes := make([]RecycleAttribute, 0, len(req.ProblemAttrList)+len(req.SkuList)) + rand.Seed(time.Now().UnixNano()) + order.Number = fmt.Sprintf("%d%s", rand.Int31n(899999)+100000, time.Now().Format("06-01-02")) + for i, _ := range req.ProblemAttrList { + attribute := RecycleAttribute{ + Id: uint32(req.ProblemAttrList[i].ProblemAttrId), + Name: req.ProblemAttrList[i].ProblemAttrName, + ValueId: uint32(req.ProblemAttrList[i].ProblemAttrValueId), + ValueName: req.ProblemAttrList[i].ProblemAttrValueName, + Type: 2, + } + attributes = append(attributes, attribute) + } + for i, _ := range req.SkuList { + attribute := RecycleAttribute{ + Id: uint32(req.SkuList[i].ProblemAttrId), + Name: req.SkuList[i].ProblemAttrName, + ValueId: uint32(req.SkuList[i].ProblemAttrValueId), + ValueName: req.SkuList[i].ProblemAttrValueName, + Type: 1, + } + attributes = append(attributes, attribute) + } + attributeByte, err := json.Marshal(&attributes) + if err != nil { + logger.Error("attributes marshal err:", err) + return order, err + } + order.Attribute = string(attributeByte) + err = DB.Create(order).Error + if err != nil { + logger.Error("create order err:", err) + return order, err + } + + return order, err +} + +type RecycleCardOrderListReq struct { + PageIdx int `json:"page_idx"` + PageSize int `json:"page_size"` + Uid uint32 `json:"uid"` +} + +func (m *RecycleCardOrderListReq) List() ([]RecycleCardOrder, int, error) { + page := m.PageIdx - 1 + if page < 0 { + page = 0 + } + if m.PageSize == 0 { + m.PageSize = 10 + } + + var list []RecycleCardOrder + qs := NewRecycleCardOrderQuerySet(DB).UidEq(m.Uid) + + count, err := qs.Count() + if err != nil { + logger.Error("err:", err) + return nil, 0, err + } + totalPage := count/m.PageSize + 1 + + err = qs.OrderDescByID().Offset(page * m.PageSize).Limit(m.PageSize).All(&list) + if err != nil { + logger.Error("err:", err) + return nil, 0, err + } + + return list, totalPage, nil +} diff --git a/model/user.go b/model/user.go index a69d347..a478b7e 100644 --- a/model/user.go +++ b/model/user.go @@ -292,13 +292,15 @@ func (m UserOpenMemberRecord) Insert() error { } const ( - LogCorrelationOrderId = "order_id" - LogCorrelationOrderCard = "order_card_id" + LogCorrelationOrderId = "order_id" + LogCorrelationOrderCard = "order_card_id" + LogCorrelationRecycleCardOrderId = "recycle_card_order_id" ) const ( - OperationTypeRentCardRevert = "rent_card_revert" - OperationTypeRentCardDeliver = "rent_card_deliver" - OperationTypeGameCardGoodsInStock = "game_card_goods_in_stock" // 入库 + OperationTypeRentCardRevert = "rent_card_revert" + OperationTypeRentCardDeliver = "rent_card_deliver" + OperationTypeGameCardGoodsInStock = "game_card_goods_in_stock" // 入库 + OperationTypeRecycleCardOrderImageUpdate = "recycle_card_order_image_update" // 回收卡上传图片 ) // gen:qs diff --git a/router/router_app.go b/router/router_app.go index 39e497a..3bbacc0 100644 --- a/router/router_app.go +++ b/router/router_app.go @@ -250,5 +250,18 @@ func ConfigAppRouter(r gin.IRouter) { cooperative.POST("/cannibalize_task/del", controller.CooperativeCannibalizeTaskDel) // //order.POST("/card/adds", stockmanage.GameCardGoodsStockAdds) // 游戏卡入库 } + recycle := api.Group("recycle_card") + { + recycle.Use(auth.UserAccessAuth) + recycle.POST("cassette/list", controller.GameCassetteList) + recycle.POST("check/goods", controller.GameCheckGoods) + recycle.POST("cassette/evaluation", controller.GameEvaluation) + recycle.POST("order/create", controller.RecycleCardCreateOrder) + recycle.POST("order/list", controller.RecycleCardOrderList) + recycle.POST("order/detail", controller.RecycleCardOrderDetail) + recycle.POST("order/cancel", controller.RecycleCardOrderCancel) + recycle.POST("cassette_image/update", controller.RecycleCardOrderImageUpdate) // 管理端 + recycle.POST("order/check", controller.RecycleCardOrderCheck) // 管理端 + } }