146 lines
3.5 KiB
Go
146 lines
3.5 KiB
Go
package mongo
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"time"
|
|
|
|
"go.mongodb.org/mongo-driver/v2/bson"
|
|
"go.mongodb.org/mongo-driver/v2/mongo/options"
|
|
)
|
|
|
|
const (
|
|
dbevent string = "cl"
|
|
tbevent string = "events"
|
|
)
|
|
|
|
const (
|
|
EventStatusHappen = iota
|
|
EventStatusDataAt
|
|
EventStatusReport
|
|
EventStatusConfirm
|
|
EventStatusPersist
|
|
EventStatusClose
|
|
)
|
|
|
|
const (
|
|
EventActionHappen = "happen"
|
|
EventActionDataAt = "data_attach"
|
|
EventActionReport = "report"
|
|
EventActionConfirm = "confirm"
|
|
EventActionPersist = "persist"
|
|
EventActionClose = "close"
|
|
)
|
|
|
|
var EventStatusAction = []string{
|
|
EventStatusHappen: EventActionHappen,
|
|
EventStatusDataAt: EventActionDataAt,
|
|
EventStatusReport: EventActionReport,
|
|
EventStatusConfirm: EventActionConfirm,
|
|
EventStatusPersist: EventActionPersist,
|
|
EventStatusClose: EventActionClose,
|
|
}
|
|
|
|
type operation struct {
|
|
Action string `bson:"action" json:"action"`
|
|
OP string `bson:"op" json:"op"`
|
|
TS int64 `bson:"ts" json:"ts"`
|
|
}
|
|
|
|
func GenOperation(action, op string) operation {
|
|
return operation{
|
|
Action: action,
|
|
OP: op,
|
|
TS: time.Now().UnixMilli(),
|
|
}
|
|
}
|
|
|
|
type Event struct {
|
|
Event string `bson:"event" json:"event"`
|
|
EventUUID string `bson:"event_uuid" json:"event_uuid"`
|
|
Type int `bson:"type" json:"type"`
|
|
Priority int `bson:"priority" json:"priority"` // 0~9
|
|
Status int `bson:"status" json:"status"`
|
|
Timestamp int64 `bson:"timestamp" json:"timestamp"`
|
|
From string `bson:"from" json:"from"`
|
|
Operations []*operation `bson:"operations" json:"operations"`
|
|
// others
|
|
Alarm *Alarm `bson:"alarm" json:"alarm"`
|
|
}
|
|
|
|
func (e *Event) Marshall() ([]byte, error) {
|
|
return json.Marshal(e)
|
|
}
|
|
|
|
func InsertOneEvent(ctx context.Context, doc any) error {
|
|
_, err := getCollection(dbevent, tbevent).InsertOne(ctx, doc)
|
|
return err
|
|
}
|
|
|
|
func InsertEvents(ctx context.Context, docs any) error {
|
|
_, err := getCollection(dbevent, tbevent).InsertMany(ctx, docs)
|
|
return err
|
|
}
|
|
|
|
func DeleteOneEvent[T bson.M | bson.D](ctx context.Context, filter T) error {
|
|
_, err := getCollection(dbevent, tbevent).DeleteOne(ctx, filter)
|
|
return err
|
|
}
|
|
|
|
func DeleteEvents[T bson.M | bson.D](ctx context.Context, filter T) error {
|
|
_, err := getCollection(dbevent, tbevent).DeleteMany(ctx, filter)
|
|
return err
|
|
}
|
|
|
|
func UpdateOneEvent[T bson.M | bson.D](ctx context.Context, filter T, update T) error {
|
|
_, err := getCollection(dbevent, tbevent).UpdateOne(ctx, filter, update)
|
|
return err
|
|
}
|
|
|
|
func UpdateEvents[T bson.M | bson.D](ctx context.Context, filter T, update T) error {
|
|
_, err := getCollection(dbevent, tbevent).UpdateMany(ctx, filter, update)
|
|
return err
|
|
}
|
|
|
|
func FindEventsWithPageLimit[T bson.M | bson.D](ctx context.Context, filter T,
|
|
sort int, page int64, limit int64) ([]*Event, error) {
|
|
|
|
opt := options.Find()
|
|
if sort == 1 || sort == -1 {
|
|
opt.SetSort(bson.D{{Key: "timestamp", Value: sort}})
|
|
} else {
|
|
opt.SetSort(bson.D{{Key: "_id", Value: 1}})
|
|
}
|
|
|
|
if page > 0 && limit > 0 {
|
|
opt.SetSkip(limit * (page - 1)).SetLimit(limit)
|
|
}
|
|
|
|
cursor, err := getCollection(dbevent, tbevent).Find(ctx, filter, opt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer cursor.Close(ctx)
|
|
|
|
var docs []*Event
|
|
for cursor.Next(ctx) {
|
|
doc := new(Event)
|
|
if err := cursor.Decode(doc); err != nil {
|
|
return nil, err
|
|
}
|
|
docs = append(docs, doc)
|
|
}
|
|
if err := cursor.Err(); err != nil {
|
|
return docs, err
|
|
}
|
|
|
|
return docs, nil
|
|
}
|
|
|
|
// sys: 0-hard/1-platform/2-application
|
|
//
|
|
// level:0-info/1-warn/2-error
|
|
func genEventType(sys int, level int) int {
|
|
return sys + level*3
|
|
}
|