huangguo_server/models/v/faqmod/faq.go

package faqmod

import (
	"fmt"
	"strings"
	"time"

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

	"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"
)

// CateRes 列表
type CateRes struct {
	Category string `json:"category" bson:"_id"`
}

var mdb *db.MongoDB

const table = models.FaqTable

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

func initFaqIndex() {
	many := []mongo.IndexModel{ //batch set indexes   //value is the type 1 or -1
		{
			Keys: bson.D{{Key: "category", Value: 1}},
		},
		{
			Keys:    bson.D{{Key: "query", Value: 1}},
			Options: options.Index().SetUnique(true).SetPartialFilterExpression(bson.M{"query": bson.M{"$exists": true}}),
		},
		{
			Keys: bson.D{{Key: "answer", Value: 1}},
		},
	}
	if _, err := faqColl(nil).CreateIndex(many); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
	}
}

// FaqInsert 新增常见问题
func FaqInsert(f Faq) (code stderr.Code, err error) {
	f.CreatedAt = time.Now()
	f.UpdatedAt = time.Now()
	if _, err = faqColl(nil).InsertOne(f); err != nil {
		if strings.Contains(err.Error(), "E11000 duplicate key") {
			code = stderr.ErrDbInputExist
		} else {
			code = stderr.ErrDbInsertError
		}
		log.ZapLog.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FaqInsert", "Faq", "InsertOne", err))
		return
	}
	return
}

// FaqUpdate 修改常见问题
func FaqUpdate(id primitive.ObjectID, doc FaqUpdateDoc) (err error) {
	doc.UpdatedAt = time.Now()
	update, _ := common.ToBsonM(doc)
	if _, err = faqColl(nil).UpdateOne(bson.M{"_id": id}, bson.M{
		"$set": update,
	}); err != nil {
		log.ZapLog.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FaqUpdate", "Faq", "UpdateOne", err))
		return
	}
	return
}

// FaqDelete 批量删除常见问题
func FaqDelete(ids []primitive.ObjectID) (err error) {
	if _, err = faqColl(nil).DeleteMany(bson.M{"_id": bson.M{"$in": ids}}); err != nil {
		log.ZapLog.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FaqDelete", "Faq", "DeleteMany", err))
		return
	}
	return
}

// FaqCateList 常见问题列表
func FaqCateList() (data []CateRes, err error) {
	query := []bson.M{bson.M{"$group": bson.M{"_id": "$category"}}}
	if err = faqColl(nil).Aggregate(&data, query); err != nil {
		log.ZapLog.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FaqAggregate", "Faq", "Aggregate", err))
		return
	}
	return
}

func faqCount(filter bson.M) (cnt int64, err error) {
	cnt, err = faqColl(nil).Count(filter)
	if err != nil {
		log.ZapLog.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FqaListForSearch", "Faq", "Find", err))
		return
	}
	return
}

// FqaListForSearch 根据搜索条件 获取问题列表
func FaqListForSearch(category string, keywords string, s commod.StdQuery) (data []Faq, total int64, err error) {
	query := bson.M{}
	q1 := bson.M{"query": bson.M{"$regex": keywords, "$options": "i"}}
	q2 := bson.M{"answer": bson.M{"$regex": keywords, "$options": "i"}}
	q3 := bson.M{"category": bson.M{"$regex": keywords, "$options": "i"}}
	if category != "" && keywords != "" {
		query = bson.M{"$and": []bson.M{bson.M{"category": category}, bson.M{"$or": []bson.M{q1, q2}}}}
	} else if keywords != "" {
		query = bson.M{"$or": []bson.M{q1, q2, q3}}
	} else if category != "" {
		query = bson.M{"category": category}
	}
	total, _ = faqCount(query)
	s.Order = &[]commod.OrderBy{{Key: "sortCode", Desc: true}, {Key: "updatedAt", Desc: true}}
	if err = faqColl(nil).Find(&data, query, commod.ConvertToListQuery(s)); err != nil {
		log.ZapLog.Error(fmt.Sprintf("FaqListForSearch FqaListForSearch Faq Find err: %v", err))
		return
	}
	return
}

// FaqList 根据类别条件 获取问题列表
func FaqList(cate string, status bool, s commod.StdQuery) (data []Faq, total int64, err error) {
	query := bson.M{"category": cate, "status": status}
	total, _ = faqCount(query)
	s.Order = &[]commod.OrderBy{{Key: "sortCode", Desc: true}, {Key: "updatedAt", Desc: true}}
	if err = faqColl(nil).Find(&data, query, commod.ConvertToListQuery(s)); err != nil {
		log.ZapLog.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FqaListForSearch", "Faq", "Find", err))
		return
	}
	return
}