149 lines
3.6 KiB
Go
149 lines
3.6 KiB
Go
package operatorlgmod
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"strings"
|
|
"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.WebOperatorLog
|
|
|
|
var mdb *db.MongoDB
|
|
|
|
func coll(t *db.MongoTool) *db.MongoTool {
|
|
if t == nil {
|
|
return mdb.Coll(table)
|
|
}
|
|
return t.Coll(table)
|
|
}
|
|
|
|
// initIndexAds 初始化索引
|
|
func initIndex() {
|
|
many := []mongo.IndexModel{
|
|
{
|
|
Keys: bson.D{{Key: "createdAt", Value: 1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{Key: "manager", Value: 1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{Key: "uri", Value: 1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{Key: "position", Value: 1}},
|
|
},
|
|
}
|
|
if _, err := coll(nil).CreateIndex(many); err != nil {
|
|
panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
|
|
}
|
|
}
|
|
|
|
// RecordOperation 记录操作日志
|
|
func RecordOperation(manager string, position string, operator string, content string, uri string) error {
|
|
record := WebOperatorLog{
|
|
Manager: manager,
|
|
Position: position,
|
|
Operator: operator,
|
|
Content: content,
|
|
URI: uri,
|
|
CreatedAt: time.Now(),
|
|
}
|
|
if _, err := coll(nil).InsertOne(&record); err != nil {
|
|
log.Error("RecordOperation error", log.Any("manager", manager), log.Any("position", position),
|
|
log.Any("operator", operator), log.Any("content", content), log.Any("url", uri), log.E(err))
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func backOperatorParam(param OperatorListReq) map[string]interface{} {
|
|
m := make(map[string]interface{})
|
|
if len(param.Manager) != 0 {
|
|
m["manager"] = param.Manager
|
|
}
|
|
if len(param.Position) != 0 {
|
|
m["position"] = param.Position
|
|
}
|
|
if len(param.URI) != 0 {
|
|
m["uri"] = param.URI
|
|
}
|
|
if param.Content != "" {
|
|
param.Content = strings.Trim(param.Content, " ")
|
|
m["content"] = bson.M{"$regex": primitive.Regex{
|
|
Pattern: param.Content,
|
|
Options: "i",
|
|
}}
|
|
}
|
|
if !param.End.IsZero() {
|
|
i := make(map[string]time.Time)
|
|
i["$gte"] = param.Start
|
|
i["$lt"] = param.End
|
|
m["createdAt"] = i
|
|
}
|
|
return m
|
|
}
|
|
|
|
// getTotalCnt 获取后台操作日志总数
|
|
func getTotalCnt(cond bson.M) (int64, error) {
|
|
total, err := coll(nil).Count(cond)
|
|
if err != nil {
|
|
log.Error("getTotalCnt", log.Any("cond", cond), log.E(err))
|
|
return 0, err
|
|
}
|
|
return total, nil
|
|
}
|
|
|
|
// getSkipSize 计算跳转
|
|
func getSkipSize(page, size uint64, cond bson.M) (uint64, uint64, int64, error) {
|
|
total, err := getTotalCnt(cond)
|
|
if err != nil {
|
|
return 0, 0, 0, err
|
|
}
|
|
totalpages := uint64(math.Ceil(float64(total) / float64(size)))
|
|
if page > totalpages {
|
|
page = totalpages
|
|
}
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
return (page - 1) * size, totalpages, total, nil
|
|
}
|
|
|
|
// GetOperatorLog 获取操作日志
|
|
func GetOperatorLog(req OperatorListReq) ([]*WebOperatorLog, int64, error) {
|
|
cond := backOperatorParam(req)
|
|
sort := bson.D{{Key: "createdAt", Value: -1}}
|
|
skip, _, total, err := getSkipSize(req.PageNumber, req.PageSize, bson.M(cond))
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
opts := options.FindOptions{}
|
|
opts.SetSort(sort).SetSkip(int64(skip)).SetLimit(int64(req.PageSize))
|
|
var back []*WebOperatorLog
|
|
if err = coll(nil).Find(&back, bson.M(cond), &opts); err != nil {
|
|
log.Error("GetOperatorLog error", log.Any("req", req), log.E(err))
|
|
}
|
|
return back, total, err
|
|
}
|
|
|
|
// EditRemarks 更新备注
|
|
func EditRemarks(id primitive.ObjectID, remarks string) error {
|
|
cond := bson.M{"_id": id}
|
|
update := bson.M{"$set": bson.M{"remarks": remarks}}
|
|
if _, err := coll(nil).UpdateOne(cond, update); err != nil {
|
|
log.Error("EditRemarks error", log.Any("id", id), log.Any("remarks", remarks), log.E(err))
|
|
return err
|
|
}
|
|
return nil
|
|
}
|