dataRT/data/mongo/event.go

package mongo

import (
	"context"

	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

const (
	dbevent string = "event"
	tbevent string = "event"
)

const (
	eventStatusHappen = iota
	eventStatusDataAt
	eventStatusReport
	eventStatusConfirm
	eventStatusPersist
	eventStatusClose
)

const (
	eventActionHappened = "happened"
)

type operation struct {
	Action string `bson:"action" json:"action"`
	OP     string `bson:"op" json:"op"`
	TS     int64  `bson:"ts" json:"ts"`
}

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"`
	From       string       `bson:"from" json:"from"`
	Operations []*operation `bson:"operations" json:"operations"`
	// TODO complete
	Alarm *Alarm `bson:"alarm" json:"alarm"`
}

func InsertOneEvent(ctx context.Context, doc *Event) error {
	_, err := getCollection(dbevent, tbevent).InsertOne(ctx, doc)
	return err
}

func InsertEvents(ctx context.Context, docs []*Event) error {
	_, err := getCollection(dbevent, tbevent).InsertMany(ctx, docs)
	return err
}

func DeleteOneEvent(ctx context.Context, filter *bson.D) error {
	_, err := getCollection(dbevent, tbevent).DeleteOne(ctx, filter)
	return err
}

func DeleteEvents(ctx context.Context, filter *bson.D) error {
	_, err := getCollection(dbevent, tbevent).DeleteMany(ctx, filter)
	return err
}

func UpdateOneEvent(ctx context.Context, filter *bson.D, update bson.D) error {
	opts := options.UpdateOne().SetUpsert(true)
	_, err := getCollection(dbevent, tbevent).UpdateOne(ctx, filter, update, opts)
	return err
}

func UpdateEvents(ctx context.Context, filter *bson.D, update bson.D) error {
	opts := options.UpdateMany().SetUpsert(true)
	_, err := getCollection(dbevent, tbevent).UpdateMany(ctx, filter, update, opts)
	return err
}

func FindOneEvent(ctx context.Context, filter *bson.D) (*Event, error) {
	doc := new(Event)
	err := getCollection(dbevent, tbevent).FindOne(ctx, filter).Decode(doc)
	if err != nil {
		return nil, err
	}

	return doc, nil
}

func FindEvents(ctx context.Context, filter *bson.D) ([]*Event, error) {
	cursor, err := getCollection(dbevent, tbevent).Find(ctx, filter)
	if err != nil {
		return nil, err
	}
	defer cursor.Close(ctx)

	var docs []*Event
	if err = cursor.All(ctx, &docs); err != nil {
		return nil, err
	}

	return docs, nil
}

func FindEventsInBatch(ctx context.Context, filter *bson.D, batchSize int32) ([]*Event, error) {
	opt := options.Find().SetBatchSize(batchSize)
	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)
	}

	return docs, nil
}

// sys: 0-hard/1-platform/2-application
//
// level:1-info/2-warn/3-error
func genEventType(sys int, level int) int {
	return sys + level*3
}