247 lines
6.6 KiB
Go
247 lines
6.6 KiB
Go
package adminmod
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"91porn-server/common"
|
|
"91porn-server/common/db"
|
|
"91porn-server/common/log"
|
|
"91porn-server/common/pageopt"
|
|
"91porn-server/models"
|
|
"91porn-server/models/v/authoritymod"
|
|
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
)
|
|
|
|
var mdb *db.MongoDB
|
|
|
|
const table = models.Admin
|
|
|
|
func coll(t *db.MongoTool) *db.MongoTool {
|
|
if t == nil {
|
|
return mdb.Coll(table)
|
|
}
|
|
return t.Coll(table)
|
|
}
|
|
|
|
// initIndex 设置index
|
|
func initIndex() {
|
|
many := []mongo.IndexModel{
|
|
{
|
|
Keys: bson.D{{Key: "name", Value: 1}},
|
|
Options: options.Index().SetUnique(true),
|
|
},
|
|
{
|
|
Keys: bson.D{{Key: "secret", Value: 1}},
|
|
Options: options.Index().SetUnique(true),
|
|
},
|
|
{
|
|
Keys: bson.D{{Key: "createdAt", Value: -1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{Key: "lastLoginAt", Value: -1}},
|
|
},
|
|
}
|
|
if _, err := coll(nil).CreateIndex(many); err != nil {
|
|
panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
|
|
}
|
|
}
|
|
|
|
func FindOneByName(name string) (doc Admin, err error) {
|
|
return findOne(AdminDoc{
|
|
Name: &name,
|
|
})
|
|
}
|
|
|
|
func FindOneByID(id ObjectID) (doc Admin, err error) {
|
|
return findOne(AdminDoc{
|
|
ID: &id,
|
|
})
|
|
}
|
|
|
|
func findOne(filter AdminDoc) (doc Admin, err error) {
|
|
filterM, err := common.ToBsonM(filter)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "findOne", table, "ToBsonM", err))
|
|
return
|
|
}
|
|
if err = coll(nil).FindOne(&doc, filterM); err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "findOne", table, "FindOne", err))
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func ExistsByID(id ObjectID) (existed bool, err error) {
|
|
doc, err := FindOneByID(id)
|
|
existed = !doc.ID.IsZero()
|
|
return
|
|
}
|
|
|
|
func ExistsByName(name string) (existed bool, err error) {
|
|
doc, err := FindOneByName(name)
|
|
existed = !doc.ID.IsZero()
|
|
return
|
|
}
|
|
|
|
// Insert 插入记录
|
|
func Insert(tool *db.MongoTool, doc AdminDoc) (err error) {
|
|
now := time.Now()
|
|
doc.CreatedAt = &now
|
|
doc.UpdatedAt = &now
|
|
if doc.Role != nil {
|
|
authority, err := authoritymod.FindOne(authoritymod.AuthorityDoc{Role: doc.Role})
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Insert", table, "FindOne", err))
|
|
return err
|
|
}
|
|
if authority.ID.IsZero() {
|
|
return fmt.Errorf("coll:%s update Role is not exist", table)
|
|
}
|
|
}
|
|
if _, err = coll(tool).InsertOne(doc); err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Insert", table, "InsertOne", err))
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func Bind(name string) error {
|
|
hasBind := true
|
|
return update(AdminDoc{Name: &name}, AdminDoc{HasBind: &hasBind})
|
|
}
|
|
|
|
// UpdateTo UpdateTo
|
|
func UpdateByID(id ObjectID, updat AdminDoc) error {
|
|
return update(AdminDoc{ID: &id}, updat)
|
|
}
|
|
|
|
// UpdateTo UpdateTo
|
|
func update(filter AdminDoc, update AdminDoc) error {
|
|
filterM, err := common.ToBsonM(filter)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "update", table, "filter ToBsonM", err))
|
|
return err
|
|
}
|
|
now := time.Now()
|
|
update.UpdatedAt = &now
|
|
if update.Role != nil {
|
|
authority, err := authoritymod.FindOne(authoritymod.AuthorityDoc{Role: update.Role})
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "update", table, "FindOne", err))
|
|
return err
|
|
}
|
|
if authority.ID.IsZero() {
|
|
return fmt.Errorf("coll:%s update Role is not exist", table)
|
|
}
|
|
}
|
|
updateM, err := common.ToBsonM(update)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "update", table, "update ToBsonM", err))
|
|
return err
|
|
}
|
|
if _, err := coll(nil).UpdateOne(filterM, bson.M{"$set": updateM}); err != nil {
|
|
log.Error(fmt.Sprintf(
|
|
"[METHOD-%s]==> Model %s %s fail error:%+v:", "update", table, "UpdateOne", err),
|
|
log.Any("filter", filter),
|
|
log.Any("update", update),
|
|
)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func UnsetPrivilege(id ObjectID) error {
|
|
filter := M{"_id": id}
|
|
update := M{"$unset": M{
|
|
"role": 1,
|
|
}}
|
|
result, err := coll(nil).UpdateOne(filter, update)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "UnsetPrivilege", table, "UpdateOne", err), log.Any("id", id))
|
|
return err
|
|
}
|
|
if result.ModifiedCount+result.UpsertedCount != 1 {
|
|
return fmt.Errorf("coll:%s UpdateTo Count error, id:%+v", table, id)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Delete Delete
|
|
func Delete(doc AdminDoc) error {
|
|
filer, err := common.ToBsonM(doc)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Delete", table, "ToBsonM", err))
|
|
return err
|
|
}
|
|
if _, err := coll(nil).DeleteOne(filer); err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Delete", table, "ToBsonM", err), log.Any("filer", filer))
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// IsUsing
|
|
// @return true:角色被使用 否则flase
|
|
func IsUsing(role string) (bool, error) {
|
|
filter := M{"role": role}
|
|
cnt, err := coll(nil).Count(filter)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IsUsing", table, "Count", err))
|
|
return false, err
|
|
}
|
|
return cnt > 0, nil
|
|
}
|
|
|
|
func List(skip, limit int64, matcher ...pageopt.Matcher) ([]Admin, error) {
|
|
filter := pageopt.MergeM(matcher)
|
|
opt := (&options.FindOptions{}).
|
|
SetSkip(skip).
|
|
SetLimit(limit)
|
|
adminList := make([]Admin, 0, limit)
|
|
if err := coll(nil).Find(&adminList, filter, opt); err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "List", table, "Find", err))
|
|
return nil, err
|
|
}
|
|
return adminList, nil
|
|
}
|
|
|
|
func Count(matcher ...pageopt.Matcher) (int64, error) {
|
|
filter := pageopt.MergeM(matcher)
|
|
count, err := coll(nil).Count(filter)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Count", table, "Count", err))
|
|
return 0, err
|
|
}
|
|
return count, nil
|
|
}
|
|
|
|
// GetNickByAccount 通过账号获取名称
|
|
func GetNickByAccount(accounts []string) (map[string]string, error) {
|
|
m := make(map[string]string)
|
|
datas := []Admin{}
|
|
cond := bson.M{"name": bson.M{"$in": accounts}}
|
|
if err := coll(nil).Find(&datas, cond); err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetNickByAccount", table, "Find", err), log.Any("accounts", accounts))
|
|
return m, err
|
|
}
|
|
for _, d := range datas {
|
|
m[d.Name] = d.Nickname
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// GetNameByNick 通过昵称过去账号名
|
|
func GetNameByNick(nick string) (string, error) {
|
|
data := Admin{}
|
|
cond := bson.M{"nickname": nick}
|
|
if err := coll(nil).FindOne(&data, cond); err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetNameByNick", table, "FindOne", err), log.Any("nick", nick))
|
|
return data.Name, err
|
|
}
|
|
return data.Name, nil
|
|
}
|