oc-lib/models/utils/abstracts.go

package utils

import (
	"encoding/json"
	"errors"
	"time"

	"cloud.o-forge.io/core/oc-lib/dbs"
	"cloud.o-forge.io/core/oc-lib/dbs/mongo"
	"cloud.o-forge.io/core/oc-lib/tools"
	"github.com/go-playground/validator/v10"
	"github.com/google/uuid"
	"github.com/rs/zerolog"
	mgb "go.mongodb.org/mongo-driver/mongo"
)

// single instance of the validator used in every model Struct to validate the fields
var validate = validator.New(validator.WithRequiredStructEnabled())

/*
* AbstractObject is a struct that represents the basic fields of an object
* it defines the object id and name
* every data in base root model should inherit from this struct (only exception is the ResourceModel)
 */
type AbstractObject struct {
	UUID           string    `json:"id,omitempty" bson:"id,omitempty" validate:"required"`
	Name           string    `json:"name,omitempty" bson:"name,omitempty" validate:"required"`
	UpdateDate     time.Time `json:"update_date" bson:"update_date"`
	LastPeerWriter string    `json:"last_peer_writer" bson:"last_peer_writer"`
}

// GetID returns the id of the object (abstract)
func (ao *AbstractObject) GetID() string {
	return ao.UUID
}

// GetName returns the name of the object (abstract)
func (ao *AbstractObject) GetName() string {
	return ao.Name
}

func (ao *AbstractObject) UpToDate() {
	ao.UpdateDate = time.Now()
	// ao.LastPeerWriter, _ = static.GetMyLocalJsonPeer()
}

// GetAccessor returns the accessor of the object (abstract)
func (dma *AbstractObject) GetAccessor(peerID string, groups []string, caller *tools.HTTPCaller) Accessor {
	return nil
}

func (ao *AbstractObject) VerifyAuth(peerID string, groups []string) bool {
	return true
}

func (dma *AbstractObject) Deserialize(j map[string]interface{}, obj DBObject) DBObject {
	b, err := json.Marshal(j)
	if err != nil {
		return nil
	}
	json.Unmarshal(b, obj)
	return obj
}

func (dma *AbstractObject) Serialize(obj DBObject) map[string]interface{} {
	var m map[string]interface{}
	b, err := json.Marshal(obj)
	if err != nil {
		return nil
	}
	json.Unmarshal(b, &m)
	return m
}

func (r *AbstractObject) GenerateID() {
	if r.UUID == "" {
		r.UUID = uuid.New().String()
	}
}

type AbstractAccessor struct {
	Logger zerolog.Logger    // Logger is the logger of the accessor, it's a specilized logger for the accessor
	Type   string            // Type is the data type of the accessor
	Caller *tools.HTTPCaller // Caller is the http caller of the accessor (optionnal) only need in a peer connection
	PeerID string            // PeerID is the id of the peer
	Groups []string          // Groups is the list of groups that can access the accessor

	ResourceModelAccessor Accessor
}

func (dma *AbstractAccessor) VerifyAuth() string {
	return ""
}

func (dma *AbstractAccessor) GetType() string {
	return dma.Type
}

func (dma *AbstractAccessor) GetCaller() *tools.HTTPCaller {
	return dma.Caller
}

// GenericLoadOne loads one object from the database (generic)
func (wfa *AbstractAccessor) GenericStoreOne(data DBObject, accessor Accessor) (DBObject, int, error) {
	data.GenerateID()
	f := dbs.Filters{
		Or: map[string][]dbs.Filter{
			"abstractresource.abstractobject.name": {{
				Operator: dbs.LIKE.String(),
				Value:    data.GetName(),
			}},
			"abstractobject.name": {{
				Operator: dbs.LIKE.String(),
				Value:    data.GetName(),
			}},
		},
	}
	if cursor, _, _ := accessor.Search(&f, ""); len(cursor) > 0 {
		return nil, 409, errors.New(accessor.GetType() + " with name " + data.GetName() + " already exists")
	}
	err := validate.Struct(data)
	if err != nil {
		return nil, 422, err
	}
	id, code, err := mongo.MONGOService.StoreOne(data, data.GetID(), wfa.GetType())
	if err != nil {
		wfa.Logger.Error().Msg("Could not store " + data.GetName() + " to db. Error: " + err.Error())
		return nil, code, err
	}
	return accessor.LoadOne(id)
}

// GenericLoadOne loads one object from the database (generic)
func (dma *AbstractAccessor) GenericDeleteOne(id string, accessor Accessor) (DBObject, int, error) {
	res, code, err := accessor.LoadOne(id)
	if err != nil {
		dma.Logger.Error().Msg("Could not retrieve " + id + " to db. Error: " + err.Error())
		return nil, code, err
	}
	_, code, err = mongo.MONGOService.DeleteOne(id, accessor.GetType())
	if err != nil {
		dma.Logger.Error().Msg("Could not delete " + id + " to db. Error: " + err.Error())
		return nil, code, err
	}
	return res, 200, nil
}

// GenericLoadOne loads one object from the database (generic)
// json expected in entry is a flatted object no need to respect the inheritance hierarchy
func (dma *AbstractAccessor) GenericUpdateOne(set DBObject, id string, accessor Accessor, new DBObject) (DBObject, int, error) {
	r, c, err := accessor.LoadOne(id)
	if err != nil {
		return nil, c, err
	}
	change := set.Serialize(set) // get the changes
	loaded := r.Serialize(r)     // get the loaded object

	for k, v := range change { // apply the changes, with a flatten method
		loaded[k] = v
	}
	id, code, err := mongo.MONGOService.UpdateOne(new.Deserialize(loaded, new), id, accessor.GetType())
	if err != nil {
		dma.Logger.Error().Msg("Could not update " + id + " to db. Error: " + err.Error())
		return nil, code, err
	}
	return accessor.LoadOne(id)
}

func GenericLoadOne[T DBObject](id string, f func(DBObject) (DBObject, int, error), wfa Accessor) (DBObject, int, error) {
	var data T
	res_mongo, code, err := mongo.MONGOService.LoadOne(id, wfa.GetType())
	if !data.VerifyAuth(wfa.GetPeerID(), wfa.GetGroups()) {
		return nil, 403, errors.New("You are not allowed to access this collaborative area")
	}
	if err != nil {
		wfa.GetLogger().Error().Msg("Could not retrieve " + id + " from db. Error: " + err.Error())
		return nil, code, err
	}
	res_mongo.Decode(&data)
	return f(data)
}

func genericLoadAll[T DBObject](res *mgb.Cursor, code int, err error, f func(DBObject) ShallowDBObject, wfa Accessor) ([]ShallowDBObject, int, error) {
	objs := []ShallowDBObject{}
	results := []T{}
	if err != nil {
		wfa.GetLogger().Error().Msg("Could not retrieve any from db. Error: " + err.Error())
		return nil, code, err
	}
	if err = res.All(mongo.MngoCtx, &results); err != nil {
		return nil, 404, err
	}
	for _, r := range results {
		if !r.VerifyAuth(wfa.GetPeerID(), wfa.GetGroups()) {
			continue
		}
		objs = append(objs, f(r))
	}
	return objs, 200, nil
}

func GenericLoadAll[T DBObject](f func(DBObject) ShallowDBObject, wfa Accessor) ([]ShallowDBObject, int, error) {
	res_mongo, code, err := mongo.MONGOService.LoadAll(wfa.GetType())
	return genericLoadAll[T](res_mongo, code, err, f, wfa)
}

func GenericSearch[T DBObject](filters *dbs.Filters, search string, defaultFilters *dbs.Filters,
	f func(DBObject) ShallowDBObject, wfa Accessor) ([]ShallowDBObject, int, error) {
	if (filters == nil || len(filters.And) == 0 || len(filters.Or) == 0) && search != "" {
		filters = defaultFilters
	}
	res_mongo, code, err := mongo.MONGOService.Search(filters, wfa.GetType())
	return genericLoadAll[T](res_mongo, code, err, f, wfa)
}

// GenericLoadOne loads one object from the database (generic)
// json expected in entry is a flatted object no need to respect the inheritance hierarchy
func (dma *AbstractAccessor) GenericRawUpdateOne(set DBObject, id string, accessor Accessor) (DBObject, int, error) {
	id, code, err := mongo.MONGOService.UpdateOne(set, id, accessor.GetType())
	if err != nil {
		dma.Logger.Error().Msg("Could not update " + id + " to db. Error: " + err.Error())
		return nil, code, err
	}
	return accessor.LoadOne(id)
}

func (dma *AbstractAccessor) GetPeerID() string {
	return dma.PeerID
}
func (dma *AbstractAccessor) GetGroups() []string {
	return dma.Groups
}
func (dma *AbstractAccessor) GetLogger() *zerolog.Logger {
	return &dma.Logger
}