huangguo_server/models/v/productposimod/productposi.go

package productposimod

import (
	"fmt"
	"time"

	"91porn-server/common/db"
	"91porn-server/common/log"
	"91porn-server/models"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

const table = models.ProductPosition

// InitIndex 设置index
func initIndex() {
	coll := coll(nil)
	many := []mongo.IndexModel{
		{
			Keys: bson.D{{Key: "createdAt", Value: 1}},
		},
		{
			Keys: bson.D{{Key: "updatedAt", Value: 1}},
		},
	}
	if _, err := coll.CreateIndex(many); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
	}
}

func coll(t *db.MongoTool) *db.MongoTool {
	if t == nil {
		return mdb.Coll(table)
	}
	return t.Coll(table)
}

// Find 查询
func Find(id primitive.ObjectID) (p *ProductPosition, err error) {
	if err = coll(nil).FindOne(&p, bson.M{"_id": id}); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindProduct", table, "FindOne", err), log.Any("id", id))
		return
	}
	if p == nil || p.ID.IsZero() {
		log.Info("product FindProduct not found", log.Any("id", id))
		return nil, nil
	}
	return
}

// FindByIDs 根据id批量查询
func FindByIDs(ids []primitive.ObjectID) (positions []ProductPosition, err error) {
	err = coll(nil).Find(&positions, bson.M{"_id": bson.M{"$in": ids}})
	return
}

// FindNamesWithStatusTrue 查询
func FindNamesWithStatusTrue() (nameMap map[string]string, showTypeMap map[string]int64, dataList []string, err error) {
	res := make([]ProductPosition, 0)
	opt := options.FindOptions{
		Sort: bson.D{{Key: "sort", Value: 1}},
	}
	if err = coll(nil).Find(&res, bson.M{"status": true}, &opt); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindNamesWithStatusTrue", table, "Find", err))
		return
	}
	nameMap = make(map[string]string)
	showTypeMap = make(map[string]int64)
	dataList = make([]string, len(res))
	for i := range res {
		nameMap[res[i].ID.Hex()] = res[i].Name
		showTypeMap[res[i].ID.Hex()] = res[i].ShowType
		dataList[i] = res[i].ID.Hex()
	}
	return
}

// FindAllNameMap
func FindAllNameMap() (ret map[string]ProductPosition, err error) {
	data := []ProductPosition{}
	if err = coll(nil).Find(&data, bson.M{"status": true}); err != nil {
		return
	}
	ret = make(map[string]ProductPosition)
	for _, p := range data {
		ret[p.Name] = p
	}
	return
}

// FindNames 查询
func FindNames() (data []string, err error) {
	res := make([]ProductPosition, 0)
	opt := options.FindOptions{
		Sort: bson.D{{Key: "sort", Value: 1}},
	}
	if err = coll(nil).Find(&res, bson.M{"status": true}, &opt); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindNamesWithStatusTrue", table, "Find", err))
		return
	}
	data = make([]string, len(res))
	for i := range res {
		data[i] = res[i].Name
	}
	return
}

// FindAll 查询
func FindAll() (data []ProductPosition, err error) {
	data = make([]ProductPosition, 0)
	opt := options.FindOptions{
		Sort: bson.D{{Key: "sort", Value: 1}},
	}
	if err = coll(nil).Find(&data, bson.M{}, &opt); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindAll", table, "Find", err))
		return
	}
	return
}

// Insert 插入一条数据
func Insert(p *ProductPosition) error {
	p.CreatedAt = time.Now()
	if _, err := coll(nil).InsertOne(p); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Insert", table, "InsertOne", err))
		return err
	}
	return nil
}

// UpdateProduct 修改Product类型
func Update(set *ProductPositionSelector) (err error) {
	set.UpdatedAt = time.Now()
	if _, err = coll(nil).UpdateOne(bson.M{"_id": set.ID}, bson.M{"$set": set}); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Update", table, "UpdateOne", err),
			log.Any("set", set),
		)
	}
	return
}

// Remove 删除Product类型
func Remove(id string) (err error) {
	OID, err := primitive.ObjectIDFromHex(id)
	if err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Remove", table, "ObjectIDFromHex", err),
			log.Any("id", id),
		)
		return
	}
	if _, err = coll(nil).DeleteOne(bson.M{"_id": OID}); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Remove", table, "DeleteOne", err),
			log.Any("OID", OID),
		)
	}
	return
}