Adjust + Test

models/utils/abstracts.go

@@ -1,7 +1,10 @@
 package utils
 
 import (
+	"crypto/sha256"
 	"encoding/json"
+	"errors"
+	"slices"
 	"time"
 
 	"cloud.o-forge.io/core/oc-lib/dbs"
@@ -37,20 +40,43 @@ type AbstractObject struct {
 	UpdaterID     string     `json:"updater_id,omitempty" bson:"updater_id,omitempty"`
 	UserUpdaterID string     `json:"user_updater_id,omitempty" bson:"user_updater_id,omitempty"`
 	AccessMode    AccessMode `json:"access_mode" bson:"access_mode" default:"0"`
+	Signature     []byte     `bson:"signature,omitempty" json:"signature,omitempty"`
 }
 
 func (ri *AbstractObject) GetAccessor(request *tools.APIRequest) Accessor {
 	return nil
 }
 
-func (r *AbstractObject) Unsign() {}
+func (r *AbstractObject) Unsign() {
+	r.Signature = nil
+}
 
-func (r *AbstractObject) Sign() {}
+func (r *AbstractObject) Sign() {
+	priv, err := tools.LoadKeyFromFilePrivate() // your node private key
+	if err != nil {
+		return
+	}
+	b, _ := json.Marshal(r.DeepCopy())
+	hash := sha256.Sum256(b)
+	r.Signature, err = priv.Sign(hash[:])
+}
 
 func (r *AbstractObject) SetID(id string) {
 	r.UUID = id
 }
 
+func (r *AbstractObject) DeepCopy() *AbstractObject {
+	var obj AbstractObject
+	b, err := json.Marshal(r)
+	if err != nil {
+		return nil
+	}
+	if err := json.Unmarshal(b, &obj); err != nil {
+		return nil
+	}
+	return &obj
+}
+
 func (r *AbstractObject) SetName(name string) {
 	r.Name = name
 }
@@ -82,6 +108,10 @@ func (ao AbstractObject) GetID() string {
 	return ao.UUID
 }
 
+func (ao AbstractObject) GetSignature() []byte {
+	return ao.Signature
+}
+
 // GetName implements ShallowDBObject.
 func (ao AbstractObject) GetName() string {
 	return ao.Name
@@ -103,7 +133,7 @@ func (ao *AbstractObject) UpToDate(user string, peer string, create bool) {
 }
 
 func (ao *AbstractObject) VerifyAuth(callName string, request *tools.APIRequest) bool {
-	return (ao.AccessMode == Public && callName == "get") || request.Admin || (request != nil && ao.CreatorID == request.PeerID && request.PeerID != "")
+	return (ao.AccessMode == Public && callName == "get") || (request != nil && (request.Admin || (ao.CreatorID == request.PeerID && request.PeerID != "")))
 }
 
 // TODO : check write per auth
@@ -137,50 +167,104 @@ func (dma *AbstractObject) Serialize(obj DBObject) map[string]interface{} {
 	return m
 }
 
-type AbstractAccessor struct {
+type AbstractAccessor[T DBObject] struct {
 	Logger                zerolog.Logger    // Logger is the logger of the accessor, it's a specilized logger for the accessor
 	Type                  tools.DataType    // Type is the data type of the accessor
 	Request               *tools.APIRequest // Caller is the http caller of the accessor (optionnal) only need in a peer connection
 	ResourceModelAccessor Accessor
+	New                   func() T
+	NotImplemented        []string
 }
 
-func (r *AbstractAccessor) ShouldVerifyAuth() bool {
+func (r *AbstractAccessor[T]) ShouldVerifyAuth() bool {
 	return true
 }
 
-func (r *AbstractAccessor) GetRequest() *tools.APIRequest {
+func (r *AbstractAccessor[T]) GetRequest() *tools.APIRequest {
 	return r.Request
 }
 
-func (dma *AbstractAccessor) GetUser() string {
+func (dma *AbstractAccessor[T]) GetUser() string {
 	if dma.Request == nil {
 		return ""
 	}
 	return dma.Request.Username
 }
 
-func (dma *AbstractAccessor) GetPeerID() string {
+func (dma *AbstractAccessor[T]) GetPeerID() string {
 	if dma.Request == nil {
 		return ""
 	}
 	return dma.Request.PeerID
 }
-func (dma *AbstractAccessor) GetGroups() []string {
+func (dma *AbstractAccessor[T]) GetGroups() []string {
 	if dma.Request == nil {
 		return []string{}
 	}
 	return dma.Request.Groups
 }
-func (dma *AbstractAccessor) GetLogger() *zerolog.Logger {
+func (dma *AbstractAccessor[T]) GetLogger() *zerolog.Logger {
 	return &dma.Logger
 }
-func (dma *AbstractAccessor) GetType() tools.DataType {
+func (dma *AbstractAccessor[T]) GetType() tools.DataType {
 	return dma.Type
 }
 
-func (dma *AbstractAccessor) GetCaller() *tools.HTTPCaller {
+func (dma *AbstractAccessor[T]) GetCaller() *tools.HTTPCaller {
 	if dma.Request == nil {
 		return nil
 	}
 	return dma.Request.Caller
 }
+
+/*
+* Nothing special here, just the basic CRUD operations
+ */
+func (a *AbstractAccessor[T]) DeleteOne(id string) (DBObject, int, error) {
+	if len(a.NotImplemented) > 0 && slices.Contains(a.NotImplemented, "DeleteOne") {
+		return nil, 404, errors.New("not implemented")
+	}
+	return GenericDeleteOne(id, a)
+}
+
+func (a *AbstractAccessor[T]) UpdateOne(set DBObject, id string) (DBObject, int, error) {
+	if len(a.NotImplemented) > 0 && slices.Contains(a.NotImplemented, "UpdateOne") {
+		return nil, 404, errors.New("not implemented")
+	}
+	// should verify if a source is existing...
+	return GenericUpdateOne(set, id, a, a.New())
+}
+
+func (a *AbstractAccessor[T]) StoreOne(data DBObject) (DBObject, int, error) {
+	if len(a.NotImplemented) > 0 && slices.Contains(a.NotImplemented, "StoreOne") {
+		return nil, 404, errors.New("not implemented")
+	}
+	return GenericStoreOne(data.(T), a)
+}
+
+func (a *AbstractAccessor[T]) CopyOne(data DBObject) (DBObject, int, error) {
+	if len(a.NotImplemented) > 0 && slices.Contains(a.NotImplemented, "CopyOne") {
+		return nil, 404, errors.New("not implemented")
+	}
+	return GenericStoreOne(data.(T), a)
+}
+
+func (a *AbstractAccessor[T]) LoadOne(id string) (DBObject, int, error) {
+	return GenericLoadOne[T](id, func(d DBObject) (DBObject, int, error) {
+		return d, 200, nil
+	}, a)
+}
+
+func (a *AbstractAccessor[T]) LoadAll(isDraft bool) ([]ShallowDBObject, int, error) {
+	return GenericLoadAll[T](a.GetExec(isDraft), isDraft, a)
+}
+
+func (a *AbstractAccessor[T]) Search(filters *dbs.Filters, search string, isDraft bool) ([]ShallowDBObject, int, error) {
+	return GenericSearch[T](filters, search, a.New().GetObjectFilters(search), a.GetExec(isDraft), isDraft, a)
+}
+
+func (a *AbstractAccessor[T]) GetExec(isDraft bool) func(DBObject) ShallowDBObject {
+	return func(d DBObject) ShallowDBObject {
+		return d
+	}
+}