|
|
package mongodb
import ( "context" "errors" "git.aiterp.net/rpdata/api/internal/generate" "git.aiterp.net/rpdata/api/models" "github.com/globalsign/mgo" "github.com/globalsign/mgo/bson" "strconv" "sync" )
type logRepository struct { openMutex sync.Mutex restoreIds bool
logs *mgo.Collection posts *mgo.Collection shortIdCounter *counter }
func newLogRepository(db *mgo.Database, restoreIds bool) (*logRepository, error) { logs := db.C("logbot3.logs") posts := db.C("logbot3.posts")
err := logs.EnsureIndexKey("date") if err != nil { return nil, err } err = logs.EnsureIndexKey("channel") if err != nil { return nil, err } err = logs.EnsureIndexKey("characterIds") if err != nil { return nil, err } err = logs.EnsureIndexKey("event") if err != nil { return nil, err } err = logs.EnsureIndex(mgo.Index{Key: []string{"channel", "open"}}) if err != nil { return nil, err }
err = logs.EnsureIndex(mgo.Index{ Key: []string{"shortId"}, Unique: true, DropDups: true, }) if err != nil { return nil, err }
return &logRepository{ restoreIds: restoreIds, logs: logs, posts: posts, shortIdCounter: newCounter(db, "auto_increment", "Log"), }, nil }
func (r *logRepository) Find(ctx context.Context, id string) (*models.Log, error) { log := new(models.Log) err := r.logs.Find(bson.M{"$or": []bson.M{{"_id": id}, {"shortId": id}}}).One(log) if err != nil { return nil, err }
return log, nil }
func (r *logRepository) List(ctx context.Context, filter models.LogFilter) ([]*models.Log, error) { query := bson.M{} if filter.Search != nil { searchQuery := bson.M{ "$text": bson.M{"$search": *filter.Search}, "logId": bson.M{"$ne": nil}, }
logIds := make([]string, 0, 64) err := r.posts.Find(searchQuery).Distinct("logId", &logIds) if err != nil { return nil, err }
query["shortId"] = bson.M{"$in": logIds} } if filter.Open != nil { r.openMutex.Lock() defer r.openMutex.Unlock()
query["open"] = filter.Open } if len(filter.Characters) > 0 { query["characterIds"] = bson.M{"$all": filter.Characters} } if len(filter.Channels) > 0 { query["channel"] = bson.M{"$in": filter.Channels} } if len(filter.Events) > 0 { query["event"] = bson.M{"$in": filter.Events} } if filter.MinDate != nil && filter.MaxDate != nil { query["date"] = bson.M{"$gte": *filter.MinDate, "$lte": *filter.MaxDate} } else if filter.MinDate != nil { query["date"] = bson.M{"$gte": *filter.MinDate} } else if filter.MaxDate != nil { query["date"] = bson.M{"$lt": *filter.MaxDate} }
logs := make([]*models.Log, 0, 32) err := r.logs.Find(query).Sort("-date").Limit(filter.Limit).All(&logs) if err != nil { if err == mgo.ErrNotFound { return logs, nil }
return nil, err }
return logs, nil }
func (r *logRepository) Insert(ctx context.Context, log models.Log) (*models.Log, error) { if !r.restoreIds || log.ID == "" || log.ShortID == "" { nextShortId, err := r.shortIdCounter.Increment(1) if err != nil { return nil, err }
log.ID = generate.LogID(log) log.ShortID = "L" + strconv.Itoa(nextShortId) } else { n, err := strconv.Atoi(log.ShortID[1:]) if err != nil { return nil, err }
_ = r.shortIdCounter.Bump(n) }
if log.Open { // There can be only one open log in the same channel.
r.openMutex.Lock() defer r.openMutex.Unlock()
_, err := r.logs.UpdateAll(bson.M{"channel": log.ChannelName, "open": true}, bson.M{"$set": bson.M{"open": false}}) if err != nil { return nil, errors.New("Cannot close other logs: " + err.Error()) } }
err := r.logs.Insert(&log) if err != nil { return nil, err }
return &log, nil }
func (r *logRepository) Update(ctx context.Context, log models.Log, update models.LogUpdate) (*models.Log, error) { updateBson := bson.M{} if update.Open != nil { if *update.Open == true { // There can be only one open log in the same channel.
r.openMutex.Lock() defer r.openMutex.Unlock()
_, err := r.logs.UpdateAll(bson.M{"channel": log.ChannelName, "open": true}, bson.M{"$set": bson.M{"open": false}}) if err != nil { return nil, errors.New("Cannot close other logs: " + err.Error()) } }
updateBson["open"] = *update.Open log.Open = *update.Open } if update.Title != nil { updateBson["title"] = *update.Title log.Title = *update.Title } if update.Description != nil { updateBson["description"] = *update.Description log.Description = *update.Description } if update.EventName != nil { updateBson["event"] = *update.EventName log.EventName = *update.EventName } if update.CharacterIDs != nil { updateBson["characterIds"] = update.CharacterIDs log.CharacterIDs = update.CharacterIDs }
err := r.logs.UpdateId(log.ID, bson.M{"$set": updateBson}) if err != nil { return nil, err }
return &log, nil }
func (r *logRepository) Delete(ctx context.Context, log models.Log) error { err := r.logs.RemoveId(log.ID) if err != nil { return err }
_, _ = r.posts.RemoveAll(bson.M{"logId": log.ShortID})
return nil }
|