dataRT/data/mongo/event.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
}