add shared workspace logic

models/models.go

@@ -3,6 +3,7 @@ package models
 import (
 	"cloud.o-forge.io/core/oc-lib/logs"
 
+	"cloud.o-forge.io/core/oc-lib/models/peer"
 	"cloud.o-forge.io/core/oc-lib/models/resource_model"
 	d "cloud.o-forge.io/core/oc-lib/models/resources/data"
 	dc "cloud.o-forge.io/core/oc-lib/models/resources/datacenter"
@@ -13,6 +14,8 @@ import (
 	w2 "cloud.o-forge.io/core/oc-lib/models/workflow"
 	"cloud.o-forge.io/core/oc-lib/models/workflow_execution"
 	w3 "cloud.o-forge.io/core/oc-lib/models/workspace"
+	shared_workspace "cloud.o-forge.io/core/oc-lib/models/workspace/shared"
+	"cloud.o-forge.io/core/oc-lib/models/workspace/shared/rules/rule"
 )
 
 var models = map[string]func() utils.DBObject{
@@ -25,6 +28,9 @@ var models = map[string]func() utils.DBObject{
 	utils.WORKFLOW_EXECUTION.String():  func() utils.DBObject { return &workflow_execution.WorkflowExecution{} },
 	utils.WORKSPACE.String():           func() utils.DBObject { return &w3.Workspace{} },
 	utils.RESOURCE_MODEL.String():      func() utils.DBObject { return &resource_model.ResourceModel{} },
+	utils.PEER.String():                func() utils.DBObject { return &peer.Peer{} },
+	utils.SHARED_WORKSPACE.String():    func() utils.DBObject { return &shared_workspace.SharedWorkspace{} },
+	utils.RULE.String():                func() utils.DBObject { return &rule.Rule{} },
 }
 
 func Model(model int) utils.DBObject {

models/peer/peer.go

@@ -0,0 +1,51 @@
+package peer
+
+import (
+	"encoding/json"
+
+	"cloud.o-forge.io/core/oc-lib/models/utils"
+	"github.com/google/uuid"
+)
+
+type Peer struct {
+	utils.AbstractObject
+	Url       string `json:"url,omitempty" bson:"url,omitempty" validate:"required,base64url"`
+	PublicKey string `json:"public_key,omitempty" bson:"public_key,omitempty"`
+}
+
+func (ao *Peer) GetID() string {
+	return ao.UUID
+}
+
+func (r *Peer) GenerateID() {
+	r.UUID = uuid.New().String()
+}
+
+func (d *Peer) GetName() string {
+	return d.Name
+}
+
+func (d *Peer) GetAccessor() utils.Accessor {
+	data := New()
+	data.SetLogger(utils.PEER)
+	return data
+}
+
+func (dma *Peer) Deserialize(j map[string]interface{}) utils.DBObject {
+	b, err := json.Marshal(j)
+	if err != nil {
+		return nil
+	}
+	json.Unmarshal(b, dma)
+	return dma
+}
+
+func (dma *Peer) 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
+}

models/peer/peer_mongo_accessor.go

@@ -0,0 +1,84 @@
+package peer
+
+import (
+	"cloud.o-forge.io/core/oc-lib/dbs"
+	"cloud.o-forge.io/core/oc-lib/dbs/mongo"
+	"cloud.o-forge.io/core/oc-lib/models/utils"
+)
+
+type peerMongoAccessor struct {
+	utils.AbstractAccessor
+}
+
+func New() *peerMongoAccessor {
+	return &peerMongoAccessor{}
+}
+
+func (wfa *peerMongoAccessor) DeleteOne(id string) (utils.DBObject, int, error) {
+	return wfa.GenericDeleteOne(id, wfa)
+}
+
+func (wfa *peerMongoAccessor) UpdateOne(set utils.DBObject, id string) (utils.DBObject, int, error) {
+	return wfa.GenericUpdateOne(set.(*Peer), id, wfa, &Peer{})
+}
+
+func (wfa *peerMongoAccessor) StoreOne(data utils.DBObject) (utils.DBObject, int, error) {
+	return wfa.GenericStoreOne(data.(*Peer), wfa)
+}
+
+func (wfa *peerMongoAccessor) CopyOne(data utils.DBObject) (utils.DBObject, int, error) {
+	return wfa.GenericStoreOne(data, wfa)
+}
+
+func (wfa *peerMongoAccessor) LoadOne(id string) (utils.DBObject, int, error) {
+	var peer Peer
+	res_mongo, code, err := mongo.MONGOService.LoadOne(id, wfa.GetType())
+	if err != nil {
+		wfa.Logger.Error().Msg("Could not retrieve " + id + " from db. Error: " + err.Error())
+		return nil, code, err
+	}
+	res_mongo.Decode(&peer)
+
+	return &peer, 200, nil
+}
+
+func (wfa peerMongoAccessor) LoadAll() ([]utils.ShallowDBObject, int, error) {
+	objs := []utils.ShallowDBObject{}
+	res_mongo, code, err := mongo.MONGOService.LoadAll(wfa.GetType())
+	if err != nil {
+		wfa.Logger.Error().Msg("Could not retrieve any from db. Error: " + err.Error())
+		return nil, code, err
+	}
+	var results []Peer
+	if err = res_mongo.All(mongo.MngoCtx, &results); err != nil {
+		return nil, 404, err
+	}
+	for _, r := range results {
+		objs = append(objs, &r)
+	}
+	return objs, 200, nil
+}
+
+func (wfa *peerMongoAccessor) Search(filters *dbs.Filters, search string) ([]utils.ShallowDBObject, int, error) {
+	objs := []utils.ShallowDBObject{}
+	if (filters == nil || len(filters.And) == 0 || len(filters.Or) == 0) && search != "" {
+		filters = &dbs.Filters{
+			Or: map[string][]dbs.Filter{
+				"abstractobject.name": {{Operator: dbs.LIKE.String(), Value: search}},
+			},
+		}
+	}
+	res_mongo, code, err := mongo.MONGOService.Search(filters, wfa.GetType())
+	if err != nil {
+		wfa.Logger.Error().Msg("Could not store to db. Error: " + err.Error())
+		return nil, code, err
+	}
+	var results []Peer
+	if err = res_mongo.All(mongo.MngoCtx, &results); err != nil {
+		return nil, 404, err
+	}
+	for _, r := range results {
+		objs = append(objs, &r)
+	}
+	return objs, 200, nil
+}

models/resource_model/resource_model.go

@@ -15,6 +15,7 @@ type AbstractResource struct {
 	Owner            string         `json:"owner,omitempty" bson:"owner,omitempty" validate:"required"`
 	OwnerLogo        string         `json:"owner_logo,omitempty" bson:"owner_logo,omitempty"`
 	SourceUrl        string         `json:"source_url,omitempty" bson:"source_url,omitempty" validate:"required"`
+	PeerID		     string         `json:"peer_id,omitempty" bson:"peer_id,omitempty" validate:"required"`
 	Price            string         `json:"price,omitempty" bson:"price,omitempty"`
 	License          string         `json:"license,omitempty" bson:"license,omitempty"`
 	ResourceModel    *ResourceModel `json:"resource_model,omitempty" bson:"resource_model,omitempty"`

models/utils/enums.go

@@ -13,6 +13,9 @@ const (
 	WORKFLOW_EXECUTION
 	WORKSPACE
 	RESOURCE_MODEL
+	PEER
+	SHARED_WORKSPACE
+	RULE
 )
 
 var Str = [...]string{
@@ -26,6 +29,9 @@ var Str = [...]string{
 	"workflow_execution",
 	"workspace",
 	"resource_model",
+	"peer",
+	"shared_workspace",
+	"rule",
 }
 
 func FromInt(i int) string {

models/workflow/workflow.go

@@ -13,6 +13,7 @@ type AbstractWorkflow struct {
 	resources.ResourceSet
 	Graph    *graph.Graph      `bson:"graph,omitempty" json:"graph,omitempty"`
 	Schedule *WorkflowSchedule `bson:"schedule,omitempty" json:"schedule,omitempty"`
+	Shared   []string          `json:"shared,omitempty" bson:"shared,omitempty"`
 }
 
 func (w *AbstractWorkflow) isDCLink(link graph.GraphLink) bool {

models/workspace/shared/rules/rule/rule.go

@@ -0,0 +1,52 @@
+package rule 
+
+
+import (
+	"encoding/json"
+	"cloud.o-forge.io/core/oc-lib/models/utils"
+	"github.com/google/uuid"
+)
+
+type Rule struct {
+	utils.AbstractObject
+	Description string `json:"description,omitempty" bson:"description,omitempty"`
+	Condition string `json:"condition,omitempty" bson:"condition,omitempty"`
+	Actions []string `json:"actions,omitempty" bson:"actions,omitempty"`
+}
+
+func (ao *Rule) GetID() string {
+	return ao.UUID
+}
+
+func (r *Rule) GenerateID() {
+	r.UUID = uuid.New().String()
+}
+
+func (d *Rule) GetName() string {
+	return d.Name
+}
+
+func (d *Rule) GetAccessor() utils.Accessor {
+	data := New()
+	data.SetLogger(utils.RULE)
+	return data
+}
+
+func (dma *Rule) Deserialize(j map[string]interface{}) utils.DBObject {
+	b, err := json.Marshal(j)
+	if err != nil {
+		return nil
+	}
+	json.Unmarshal(b, dma)
+	return dma
+}
+
+func (dma *Rule) 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
+}

models/workspace/shared/rules/rule/rule_mongo_accessor.go

@@ -0,0 +1,83 @@
+package rule 
+
+import (
+	"cloud.o-forge.io/core/oc-lib/dbs"
+	"cloud.o-forge.io/core/oc-lib/dbs/mongo"
+	"cloud.o-forge.io/core/oc-lib/models/utils"
+)
+
+type ruleMongoAccessor struct {
+	utils.AbstractAccessor
+}
+
+func New() *ruleMongoAccessor {
+	return &ruleMongoAccessor{}
+}
+
+func (wfa *ruleMongoAccessor) DeleteOne(id string) (utils.DBObject, int, error) {
+	return wfa.GenericDeleteOne(id, wfa)
+}
+
+func (wfa *ruleMongoAccessor) UpdateOne(set utils.DBObject, id string) (utils.DBObject, int, error) {
+	return wfa.GenericUpdateOne(set.(*Rule), id, wfa, &Rule{})
+}
+
+func (wfa *ruleMongoAccessor) StoreOne(data utils.DBObject) (utils.DBObject, int, error) {
+	return wfa.GenericStoreOne(data.(*Rule), wfa)
+}
+
+func (wfa *ruleMongoAccessor) CopyOne(data utils.DBObject) (utils.DBObject, int, error) {
+	return wfa.GenericStoreOne(data, wfa)
+}
+
+func (wfa *ruleMongoAccessor) LoadOne(id string) (utils.DBObject, int, error) {
+	var rule Rule
+	res_mongo, code, err := mongo.MONGOService.LoadOne(id, wfa.GetType())
+	if err != nil {
+		wfa.Logger.Error().Msg("Could not retrieve " + id + " from db. Error: " + err.Error())
+		return nil, code, err
+	}
+	res_mongo.Decode(&rule)
+	return &rule, 200, nil
+}
+
+func (wfa ruleMongoAccessor) LoadAll() ([]utils.ShallowDBObject, int, error) {
+	objs := []utils.ShallowDBObject{}
+	res_mongo, code, err := mongo.MONGOService.LoadAll(wfa.GetType())
+	if err != nil {
+		wfa.Logger.Error().Msg("Could not retrieve any from db. Error: " + err.Error())
+		return nil, code, err
+	}
+	var results []Rule
+	if err = res_mongo.All(mongo.MngoCtx, &results); err != nil {
+		return nil, 404, err
+	}
+	for _, r := range results {
+		objs = append(objs, &r)
+	}
+	return objs, 200, nil
+}
+
+func (wfa *ruleMongoAccessor) Search(filters *dbs.Filters, search string) ([]utils.ShallowDBObject, int, error) {
+	objs := []utils.ShallowDBObject{}
+	if (filters == nil || len(filters.And) == 0 || len(filters.Or) == 0) && search != "" {
+		filters = &dbs.Filters{
+			Or: map[string][]dbs.Filter{
+				"abstractobject.name": {{Operator: dbs.LIKE.String(), Value: search}},
+			},
+		}
+	}
+	res_mongo, code, err := mongo.MONGOService.Search(filters, wfa.GetType())
+	if err != nil {
+		wfa.Logger.Error().Msg("Could not store to db. Error: " + err.Error())
+		return nil, code, err
+	}
+	var results []Rule
+	if err = res_mongo.All(mongo.MngoCtx, &results); err != nil {
+		return nil, 404, err
+	}
+	for _, r := range results {
+		objs = append(objs, &r)
+	}
+	return objs, 200, nil
+}

models/workspace/shared/shared_workspace.go

@@ -0,0 +1,56 @@
+package shared_workspace
+
+import (
+	"encoding/json"
+
+	"cloud.o-forge.io/core/oc-lib/models/utils"
+	"github.com/google/uuid"
+)
+
+type SharedWorkspace struct {
+	utils.AbstractObject
+	Version     string                 `json:"version,omitempty" bson:"version,omitempty" validate:"required"`
+	Description string                 `json:"description,omitempty" bson:"description,omitempty"`
+	Attributes  map[string]interface{} `json:"attributes,omitempty" bson:"attributes,omitempty"`
+	Workspaces  []string               `json:"workspaces,omitempty" bson:"workspaces,omitempty"`
+	Workflows   []string               `json:"workflows,omitempty" bson:"workflows,omitempty"`
+	Peers       []string               `json:"peers,omitempty" bson:"peers,omitempty"`
+	Rules       []string               `json:"rules,omitempty" bson:"rules,omitempty"`
+}
+
+func (ao *SharedWorkspace) GetID() string {
+	return ao.UUID
+}
+
+func (r *SharedWorkspace) GenerateID() {
+	r.UUID = uuid.New().String()
+}
+
+func (d *SharedWorkspace) GetName() string {
+	return d.Name
+}
+
+func (d *SharedWorkspace) GetAccessor() utils.Accessor {
+	data := New()
+	data.SetLogger(utils.SHARED_WORKSPACE)
+	return data
+}
+
+func (dma *SharedWorkspace) Deserialize(j map[string]interface{}) utils.DBObject {
+	b, err := json.Marshal(j)
+	if err != nil {
+		return nil
+	}
+	json.Unmarshal(b, dma)
+	return dma
+}
+
+func (dma *SharedWorkspace) 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
+}

models/workspace/shared/shared_workspace_mongo_accessor.go

@@ -0,0 +1,152 @@
+package shared_workspace
+
+import (
+	"slices"
+
+	"cloud.o-forge.io/core/oc-lib/dbs"
+	"cloud.o-forge.io/core/oc-lib/dbs/mongo"
+	"cloud.o-forge.io/core/oc-lib/models/utils"
+	w "cloud.o-forge.io/core/oc-lib/models/workflow"
+	"cloud.o-forge.io/core/oc-lib/models/workspace"
+)
+
+type sharedWorkspaceMongoAccessor struct {
+	utils.AbstractAccessor
+}
+
+func New() *sharedWorkspaceMongoAccessor {
+	return &sharedWorkspaceMongoAccessor{}
+}
+
+func (wfa *sharedWorkspaceMongoAccessor) DeleteOne(id string) (utils.DBObject, int, error) {
+	wfa.sharedWorkflow(&SharedWorkspace{}, id)
+	wfa.sharedWorkspace(&SharedWorkspace{}, id)
+	return wfa.GenericDeleteOne(id, wfa)
+}
+
+func (wfa *sharedWorkspaceMongoAccessor) sharedWorkspace(shared *SharedWorkspace, id string) {
+	eldest, code, _ := wfa.LoadOne(id)
+	if code == 200 {
+		eld := eldest.(*SharedWorkspace)
+		accessor := (&workspace.Workspace{}).GetAccessor()
+		if eld.Workspaces != nil {
+			for _, v := range eld.Workspaces {
+				accessor.UpdateOne(&workspace.Workspace{Shared: false}, v)
+			}
+		}
+	}
+	if shared.Workspaces != nil {
+		for _, v := range shared.Workspaces {
+			wfa.UpdateOne(&workspace.Workspace{Shared: false}, v)
+		}
+	}
+}
+
+func (wfa *sharedWorkspaceMongoAccessor) sharedWorkflow(shared *SharedWorkspace, id string) {
+	accessor := (&w.Workflow{}).GetAccessor()
+	eldest, code, _ := wfa.LoadOne(id)
+	if code == 200 {
+		eld := eldest.(*SharedWorkspace)
+		if eld.Workflows != nil {
+			for _, v := range eld.Workflows {
+				data, code, _ := accessor.LoadOne(v)
+				if code == 200 {
+					s := data.(*w.Workflow)
+					new := []string{}
+					for _, id2 := range s.Shared {
+						if id2 != id {
+							new = append(new, id2)
+						}
+					}
+					n := &w.Workflow{}
+					n.Shared = new
+					accessor.UpdateOne(n, v)
+				}
+			}
+		}
+	}
+	if shared.Workflows != nil {
+		for _, v := range shared.Workflows {
+			data, code, _ := accessor.LoadOne(v)
+			if code == 200 {
+				s := data.(*w.Workflow)
+				if !slices.Contains(s.Shared, id) {
+					s.Shared = append(s.Shared, id)
+					accessor.UpdateOne(s, v)
+				}
+			}
+		}
+	}
+}
+
+func (wfa *sharedWorkspaceMongoAccessor) UpdateOne(set utils.DBObject, id string) (utils.DBObject, int, error) {
+	wfa.sharedWorkflow(set.(*SharedWorkspace), id)
+	wfa.sharedWorkspace(set.(*SharedWorkspace), id)
+	return wfa.GenericUpdateOne(set.(*SharedWorkspace), id, wfa, &SharedWorkspace{})
+}
+
+func (wfa *sharedWorkspaceMongoAccessor) StoreOne(data utils.DBObject) (utils.DBObject, int, error) {
+	data, code, err := wfa.GenericStoreOne(data.(*SharedWorkspace), wfa)
+	if code == 200 {
+		wfa.sharedWorkflow(data.(*SharedWorkspace), data.GetID())
+		wfa.sharedWorkspace(data.(*SharedWorkspace), data.GetID())
+	}
+	return data, code, err
+}
+
+func (wfa *sharedWorkspaceMongoAccessor) CopyOne(data utils.DBObject) (utils.DBObject, int, error) {
+	return wfa.StoreOne(data)
+}
+
+func (wfa *sharedWorkspaceMongoAccessor) LoadOne(id string) (utils.DBObject, int, error) {
+	var sharedWorkspace SharedWorkspace
+	res_mongo, code, err := mongo.MONGOService.LoadOne(id, wfa.GetType())
+	if err != nil {
+		wfa.Logger.Error().Msg("Could not retrieve " + id + " from db. Error: " + err.Error())
+		return nil, code, err
+	}
+	res_mongo.Decode(&sharedWorkspace)
+
+	return &sharedWorkspace, 200, nil
+}
+
+func (wfa sharedWorkspaceMongoAccessor) LoadAll() ([]utils.ShallowDBObject, int, error) {
+	objs := []utils.ShallowDBObject{}
+	res_mongo, code, err := mongo.MONGOService.LoadAll(wfa.GetType())
+	if err != nil {
+		wfa.Logger.Error().Msg("Could not retrieve any from db. Error: " + err.Error())
+		return nil, code, err
+	}
+	var results []SharedWorkspace
+	if err = res_mongo.All(mongo.MngoCtx, &results); err != nil {
+		return nil, 404, err
+	}
+	for _, r := range results {
+		objs = append(objs, &r)
+	}
+	return objs, 200, nil
+}
+
+func (wfa *sharedWorkspaceMongoAccessor) Search(filters *dbs.Filters, search string) ([]utils.ShallowDBObject, int, error) {
+	objs := []utils.ShallowDBObject{}
+	if (filters == nil || len(filters.And) == 0 || len(filters.Or) == 0) && search != "" {
+		filters = &dbs.Filters{
+			Or: map[string][]dbs.Filter{
+				"abstractobject.name": {{Operator: dbs.LIKE.String(), Value: search}},
+			},
+		}
+	}
+	res_mongo, code, err := mongo.MONGOService.Search(filters, wfa.GetType())
+	if err != nil {
+		wfa.Logger.Error().Msg("Could not store to db. Error: " + err.Error())
+		return nil, code, err
+	}
+	var results []SharedWorkspace
+	if err = res_mongo.All(mongo.MngoCtx, &results); err != nil {
+		return nil, 404, err
+	}
+	for _, r := range results {
+		objs = append(objs, &r)
+	}
+	return objs, 200, nil
+}

models/workspace/workspace.go

@@ -13,6 +13,7 @@ type Workspace struct {
 	resources.ResourceSet
 	IsContextual bool `json:"is_contextual" bson:"is_contextual" default:"false"`
 	Active       bool `json:"active" bson:"active" default:"false"`
+	Shared       bool `json:"shared" bson:"shared" default:"false"`
 }
 
 func (ao *Workspace) GetID() string {