root/huangguo_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source 
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
root
2026-09-15 13:57:10 +08:00
co-authored by Claude Opus 5
commit 8679200f41
1897 changed files with 257900 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
models/v/adminmod/admin.go
+246
View File
@@ -0,0 +1,246 @@
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
}
models/v/adminmod/type.go
+64
View File
@@ -0,0 +1,64 @@
package adminmod
import (
"time"
"91porn-server/common/db"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type (
// A A from Array
A = bson.A
// D D from Doc
D = bson.D
// M M from Map
M = bson.M
ObjectID = primitive.ObjectID
// Admin Admin
Admin struct {
ID ObjectID `bson:"_id,omitempty"`
Name string `bson:"name"` //账号
Password string `bson:"password"` //密码
Nickname string `bson:"nickname"` //昵称
Email string `bson:"email"` //邮箱
Role string `bson:"role"` //角色
Secret string `bson:"secret"` //两步验证密钥
HasBind bool `bson:"hasBind"` //已绑定 true,曾成功登录,反之false
HasLocked bool `bson:"hasLocked"` //已禁止登陆
LockReason string `bson:"lockReason"` //禁止登陆的原因
CreatedAt time.Time `bson:"createdAt"`
UpdatedAt time.Time `bson:"updatedAt"`
LastLoginAt time.Time `bson:"lastLoginAt"` //最后登陆时间
BindAt time.Time `bson:"bindAt"` //绑定电话时间
}
// AdminDoc AdminDoc
AdminDoc struct {
ID *primitive.ObjectID `json:"id,omitempty" bson:"_id,omitempty"`
PrivilegeID *primitive.ObjectID `json:"privilegeId,omitempty" bson:"privilegeID,omitempty"` //权限ID
Name *string `json:"name,omitempty" bson:"name,omitempty"` //账号
Password *string `json:"password,omitempty" bson:"password,omitempty"` //密码
Nickname *string `json:"nickname,omitempty" bson:"nickname,omitempty"` //昵称
Email *string `json:"email,omitempty" bson:"email,omitempty"` //邮箱
Role *string `json:"role,omitempty" bson:"role,omitempty"` //角色
Secret *string `json:"secret,omitempty" bson:"secret,omitempty"` //两步验证密钥
HasBind *bool `json:"hasBind,omitempty" bson:"hasBind,omitempty"` //已绑定 true,曾成功登录,反之false
HasLocked *bool `json:"hasLocked,omitempty" bson:"hasLocked,omitempty"` //已禁止登陆
LockReason *string `json:"lockReason,omitempty" bson:"lockReason,omitempty"` //禁止登陆的原因
CreatedAt *time.Time `json:"createdAt,omitempty" bson:"createdAt,omitempty"`
UpdatedAt *time.Time `json:"updatedAt,omitempty" bson:"updatedAt,omitempty"`
LastLoginAt *time.Time `json:"lastLoginAt,omitempty" bson:"lastLoginAt,omitempty"`
}
)
func Init() {
mdb = db.Init(table)
initIndex()
}