add shared workspace logic

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 {