132 lines
3.3 KiB
Go
132 lines
3.3 KiB
Go
package utils
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
|
|
"cloud.o-forge.io/core/oc-lib/dbs"
|
|
"cloud.o-forge.io/core/oc-lib/dbs/mongo"
|
|
"cloud.o-forge.io/core/oc-lib/logs"
|
|
"github.com/go-playground/validator/v10"
|
|
"github.com/google/uuid"
|
|
"github.com/rs/zerolog"
|
|
)
|
|
|
|
var validate = validator.New(validator.WithRequiredStructEnabled())
|
|
|
|
type AbstractObject struct {
|
|
UUID string `json:"id,omitempty" bson:"id,omitempty" validate:"required"`
|
|
Name string `json:"name,omitempty" bson:"name,omitempty" validate:"required"`
|
|
}
|
|
|
|
func (ao *AbstractObject) GetID() string {
|
|
return ao.UUID
|
|
}
|
|
|
|
func (ao *AbstractObject) GetName() string {
|
|
return ao.Name
|
|
}
|
|
|
|
func (dma *AbstractObject) GetAccessor() Accessor {
|
|
return nil
|
|
}
|
|
|
|
func (dma *AbstractObject) Deserialize(j map[string]interface{}) DBObject {
|
|
b, err := json.Marshal(j)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
json.Unmarshal(b, dma)
|
|
return dma
|
|
}
|
|
|
|
func (dma *AbstractObject) Serialize() map[string]interface{} {
|
|
var m map[string]interface{}
|
|
b, err := json.Marshal(dma)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
json.Unmarshal(b, &m)
|
|
return m
|
|
}
|
|
|
|
func (r *AbstractObject) GenerateID() {
|
|
r.UUID = uuid.New().String()
|
|
}
|
|
|
|
type AbstractAccessor struct {
|
|
Logger zerolog.Logger
|
|
Type string
|
|
}
|
|
|
|
func (dma *AbstractAccessor) GetType() string {
|
|
return dma.Type
|
|
}
|
|
|
|
func (dma *AbstractAccessor) SetLogger(t DataType) {
|
|
dma.Logger = logs.CreateLogger(t.String(), "")
|
|
dma.Type = t.String()
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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()
|
|
loaded := r.Serialize()
|
|
|
|
for k, v := range change {
|
|
loaded[k] = v
|
|
}
|
|
id, code, err := mongo.MONGOService.UpdateOne(new.Deserialize(loaded), 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)
|
|
}
|