huangguo_server/models/v/aichangefaceimgmod/aichangefaceimg.go

package aichangefaceimgmod

import (
	"91porn-server/common/db"
	"91porn-server/common/log"
	"91porn-server/models"
	"errors"
	"fmt"
	"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"
	"time"
)

const table = models.AiChangeFaceImg

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

// InitARDIndex 设置账户充值流水表索引
func initIndex() {
	many := []mongo.IndexModel{ //batch set indexes   //value is the type 1 or -1
		{
			Keys: bson.D{{Key: "uid", Value: 1}},
		},
		{
			Keys: bson.D{{Key: "createdAt", Value: -1}},
		},
		{
			Keys: bson.D{{Key: "status", Value: 1}},
		},
	}
	if _, err := coll(nil).CreateIndex(many); err != nil {
		panic(fmt.Sprintf("AiUnDressIndex err+%v", err))
	}
}

// Insert 插入一条订单
func Insert(a *AiChangeFaceImg) error {
	a.CreatedAt = time.Now()
	a.UpdatedAt = a.CreatedAt
	res, err := coll(nil).InsertOne(a)
	if err != nil {
		log.Warn(fmt.Sprintf("[METHOD-Insert]==> Model %s InsertOne fail error:%+v:", table, err))
		return err
	}
	a.ID, _ = res.InsertedID.(primitive.ObjectID)
	return nil
}

func InsertOne(mt *db.MongoTool, cfg AiChangeFaceImg) error {
	if _, err := coll(mt).InsertOne(cfg); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-InsertOne]==> Model %s InsertOne fail error:%+v:", table, err))
		return err
	}
	return nil
}

// FindOrders 查询AI换脸订单
func FindOrders(cond bson.M, opts *options.FindOptions) (int64, []*AiChangeFaceImg, error) {
	data := make([]*AiChangeFaceImg, 0)
	if err := coll(nil).Find(&data, cond, opts); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-FindOrders]==> Model %s Find fail error:%+v:", table, err),
			log.Any("cond", cond),
		)
		return 0, data, err
	}
	total, err := coll(nil).Count(cond)
	if err != nil {
		log.Warn(fmt.Sprintf("[METHOD-FindOrders]==> Model %s Count fail error:%+v:", table, err),
			log.Any("cond", cond),
		)
		return total, data, err
	}
	return total, data, nil
}

// Update 修改订单
func Update(t *db.MongoTool, id primitive.ObjectID, set bson.M) error {
	set["updatedAt"] = time.Now()
	if _, err := coll(t).UpdateOne(bson.M{"_id": id}, bson.M{"$set": set}); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-Update]==> Model %s UpdateOne fail error:%+v:", table, err),
			log.Any("id", id),
			log.Any("set", set),
		)
		return err
	}
	return nil
}

// TransitionStatus atomically changes an order from the expected status. The
// returned boolean is false when another worker or callback handled it first.
func TransitionStatus(t *db.MongoTool, id primitive.ObjectID, from, to int, set bson.M) (bool, error) {
	if set == nil {
		set = bson.M{}
	}
	set["status"] = to
	set["updatedAt"] = time.Now()
	result, err := coll(t).UpdateOne(bson.M{"_id": id, "status": from}, bson.M{"$set": set})
	if err != nil {
		return false, err
	}
	return result.ModifiedCount == 1, nil
}

// Edit 修改文档
func Edit(t *db.MongoTool, filter, update primitive.M) error {
	result, err := coll(t).UpdateOne(filter, update)
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-Edit]==> Model %s UpdateOne fail error:%+v:", table, err),
			log.Any("filter", filter),
			log.Any("update", update),
		)
		return err
	}
	if result.ModifiedCount == 0 {
		log.Error(fmt.Sprintf("[METHOD-Edit]==> Model %s result.ModifiedCount fail error: ModifiedCount is zero", table),
			log.Any("filter", filter),
			log.Any("update", update),
		)
		return errors.New("result is null")
	}
	return nil
}

// FindDataByID 根据ID查询
func FindDataByID(id string) (AiChangeFaceImg, error) {
	objID, err := primitive.ObjectIDFromHex(id)
	if err != nil {
		log.Warn(fmt.Sprintf("[METHOD-FindDataByID]==> Model %s ObjectIDFromHex fail error:%+v:", table, err),
			log.Any("id", id),
		)
		return AiChangeFaceImg{}, err
	}
	var aud AiChangeFaceImg
	if err = coll(nil).FindOne(&aud, bson.M{"_id": objID}); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-FindDataByID]==> Model %s FindOne fail error:%+v:", table, err),
			log.Any("objID", objID),
		)
		return aud, err
	}
	return aud, nil
}

// QueryAllDocument 分页查询文档
func QueryAllDocument(filter primitive.M, opts ...*options.FindOptions) ([]*AiChangeFaceImg, error) {
	var out []*AiChangeFaceImg
	if err := coll(nil).Find(&out, filter, opts...); err != nil {
		log.Error(fmt.Sprintf("[METHOD-QueryAllDocument]==> Model %s Find fail error:%+v:", table, err),
			log.Any("filter", filter),
		)
		return nil, err
	}
	return out, nil
}

// CountDocument 查询文档条目数
func CountDocument(filter primitive.M) (int64, error) {
	count, err := coll(nil).Count(filter)
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-CountDocument]==> Model %s Count fail error:%+v:", table, err),
			log.Any("filter", filter),
		)
		return 0, err
	}
	return count, nil
}

func FindByID(t *db.MongoTool, id primitive.ObjectID) (*AiChangeFaceImg, error) {
	var acf AiChangeFaceImg
	return &acf, coll(t).FindOne(&acf, bson.M{"_id": id})
}