AT collaborative area

entrypoint.go

@@ -22,7 +22,7 @@ import (
 	w2 "cloud.o-forge.io/core/oc-lib/models/workflow"
 	"cloud.o-forge.io/core/oc-lib/models/workflow_execution"
 	"cloud.o-forge.io/core/oc-lib/models/workspace"
-	shared_workspace "cloud.o-forge.io/core/oc-lib/models/workspace/shared"
+	collaborative_area "cloud.o-forge.io/core/oc-lib/models/workspace/shared"
 	"cloud.o-forge.io/core/oc-lib/models/workspace/shared/rules/rule"
 	"cloud.o-forge.io/core/oc-lib/tools"
 	"github.com/goraz/onion"
@@ -45,7 +45,7 @@ const (
 	WORKSPACE                       = utils.WORKSPACE
 	WORKFLOW_EXECUTION              = utils.WORKFLOW_EXECUTION
 	PEER                            = utils.PEER
-	SHARED_WORKSPACE                = utils.SHARED_WORKSPACE
+	SHARED_WORKSPACE                = utils.COLLABORATIVE_AREA
 	RULE                            = utils.RULE
 	BOOKING                         = utils.BOOKING
 )
@@ -442,15 +442,15 @@ func (l *LibData) ToWorkspace() *workspace.Workspace {
 	return nil
 }
 
-func (l *LibData) ToSharedWorkspace() *shared_workspace.SharedWorkspace {
+func (l *LibData) ToCollaborativeArea() *collaborative_area.CollaborativeArea {
-	if l.Data.GetAccessor(nil).GetType() == utils.SHARED_WORKSPACE.String() {
+	if l.Data.GetAccessor(nil).GetType() == utils.COLLABORATIVE_AREA.String() {
-		return l.Data.(*shared_workspace.SharedWorkspace)
+		return l.Data.(*collaborative_area.CollaborativeArea)
 	}
 	return nil
 }
 
 func (l *LibData) ToRule() *rule.Rule {
-	if l.Data.GetAccessor(nil).GetType() == utils.SHARED_WORKSPACE.String() {
+	if l.Data.GetAccessor(nil).GetType() == utils.COLLABORATIVE_AREA.String() {
 		return l.Data.(*rule.Rule)
 	}
 	return nil

models/models.go

@@ -15,7 +15,7 @@ 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"
+	collaborative_area "cloud.o-forge.io/core/oc-lib/models/workspace/shared"
 	"cloud.o-forge.io/core/oc-lib/models/workspace/shared/rules/rule"
 )
 
@@ -34,7 +34,7 @@ var models = map[string]func() utils.DBObject{
 	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.COLLABORATIVE_AREA.String():  func() utils.DBObject { return &collaborative_area.CollaborativeArea{} },
 	utils.RULE.String():                func() utils.DBObject { return &rule.Rule{} },
 	utils.BOOKING.String():             func() utils.DBObject { return &booking.Booking{} },
 }

models/utils/enums.go

@@ -15,7 +15,7 @@ const (
 	WORKSPACE
 	RESOURCE_MODEL
 	PEER
-	SHARED_WORKSPACE
+	COLLABORATIVE_AREA
 	RULE
 	BOOKING
 )

models/workflow/workflow_mongo_accessor.go

@@ -13,7 +13,7 @@ import (
 	"cloud.o-forge.io/core/oc-lib/models/utils"
 	"cloud.o-forge.io/core/oc-lib/models/workflow_execution"
 	"cloud.o-forge.io/core/oc-lib/models/workspace"
-	"cloud.o-forge.io/core/oc-lib/models/workspace/shared/shallow_shared_workspace"
+	"cloud.o-forge.io/core/oc-lib/models/workspace/shared/shallow_collaborative_area"
 	"cloud.o-forge.io/core/oc-lib/tools"
 	cron "github.com/robfig/cron/v3"
 )
@@ -162,14 +162,14 @@ func (wfa *workflowMongoAccessor) share(realData *Workflow, delete bool, caller
 		return
 	}
 	for _, sharedID := range realData.Shared { // loop through the shared ids
-		access := (&shallow_shared_workspace.ShallowSharedWorkspace{}).GetAccessor(nil)
+		access := (&shallow_collaborative_area.ShallowCollaborativeArea{}).GetAccessor(nil)
 		res, code, _ := access.LoadOne(sharedID)
 		if code != 200 {
 			continue
 		}
 		var err error
 		paccess := &peer.Peer{}
-		for _, p := range res.(*shallow_shared_workspace.ShallowSharedWorkspace).Peers {
+		for _, p := range res.(*shallow_collaborative_area.ShallowCollaborativeArea).Peers {
 			paccess.UUID = p
 			if paccess.IsMySelf() { // if the peer is the current peer, never share because it will create a loop
 				continue

models/workspace/shared/collaborative_area.go

@@ -1,4 +1,4 @@
-package shared_workspace
+package collaborative_area
 
 import (
 	"encoding/json"
@@ -16,7 +16,7 @@ import (
 // WARNING : it got a shallow object version, this one is the full version
 // full version is the one used by API
 // other one is a shallow version used by the Lib for import cycle problem purposes
-type SharedWorkspace struct {
+type CollaborativeArea struct {
 	utils.AbstractObject                        // AbstractObject contains the basic fields of an object (id, name)
 	IsSent               bool                   `json:"is_sent" bson:"-"`                                                       // IsSent is a flag that indicates if the workspace is sent
 	CreatorID            string                 `json:"peer_id,omitempty" bson:"peer_id,omitempty" validate:"required"`         // CreatorID is the ID of the creator
@@ -34,27 +34,27 @@ type SharedWorkspace struct {
 	SharedPeers      []*peer.Peer           `json:"shared_peers,omitempty" bson:"-"`      // SharedPeers is the shared peers of the workspace
 }
 
-func (ao *SharedWorkspace) GetID() string {
+func (ao *CollaborativeArea) GetID() string {
 	return ao.UUID
 }
 
-func (r *SharedWorkspace) GenerateID() {
+func (r *CollaborativeArea) GenerateID() {
 	if r.UUID == "" {
 		r.UUID = uuid.New().String()
 	}
 }
 
-func (d *SharedWorkspace) GetName() string {
+func (d *CollaborativeArea) GetName() string {
 	return d.Name
 }
 
-func (d *SharedWorkspace) GetAccessor(caller *tools.HTTPCaller) utils.Accessor {
+func (d *CollaborativeArea) GetAccessor(caller *tools.HTTPCaller) utils.Accessor {
 	data := New()                               // Create a new instance of the accessor
-	data.Init(utils.SHARED_WORKSPACE, caller) // Initialize the accessor with the SHARED_WORKSPACE model type
+	data.Init(utils.COLLABORATIVE_AREA, caller) // Initialize the accessor with the SHARED_WORKSPACE model type
 	return data
 }
 
-func (dma *SharedWorkspace) Deserialize(j map[string]interface{}) utils.DBObject {
+func (dma *CollaborativeArea) Deserialize(j map[string]interface{}) utils.DBObject {
 	b, err := json.Marshal(j)
 	if err != nil {
 		return nil
@@ -63,7 +63,7 @@ func (dma *SharedWorkspace) Deserialize(j map[string]interface{}) utils.DBObject
 	return dma
 }
 
-func (dma *SharedWorkspace) Serialize() map[string]interface{} {
+func (dma *CollaborativeArea) Serialize() map[string]interface{} {
 	var m map[string]interface{}
 	b, err := json.Marshal(dma)
 	if err != nil {

models/workspace/shared/collaborative_area_mongo_accessor.go

@@ -1,4 +1,4 @@
-package shared_workspace
+package collaborative_area
 
 import (
 	"fmt"
@@ -15,35 +15,35 @@ import (
 	"cloud.o-forge.io/core/oc-lib/tools"
 )
 
-// SharedWorkspace is a struct that represents a shared workspace
+// SharedWorkspace is a struct that represents a collaborative area
-type sharedWorkspaceMongoAccessor struct {
+type collaborativeAreaMongoAccessor struct {
 	utils.AbstractAccessor // AbstractAccessor contains the basic fields of an accessor (model, caller)
 }
 
-// New creates a new instance of the sharedWorkspaceMongoAccessor
+// New creates a new instance of the collaborativeAreaMongoAccessor
-func New() *sharedWorkspaceMongoAccessor {
+func New() *collaborativeAreaMongoAccessor {
-	return &sharedWorkspaceMongoAccessor{}
+	return &collaborativeAreaMongoAccessor{}
 }
 
-// DeleteOne deletes a shared workspace from the database, given its ID, it automatically share to peers if the workspace is shared
+// DeleteOne deletes a collaborative area from the database, given its ID, it automatically share to peers if the workspace is shared
-func (wfa *sharedWorkspaceMongoAccessor) DeleteOne(id string) (utils.DBObject, int, error) {
+func (wfa *collaborativeAreaMongoAccessor) DeleteOne(id string) (utils.DBObject, int, error) {
 	set, code, _ := wfa.LoadOne(id)
 	if code == 200 { // always delete on peers than recreate
-		wfa.deleteToPeer(set.(*SharedWorkspace))
+		wfa.deleteToPeer(set.(*CollaborativeArea))
 	}
-	wfa.sharedWorkflow(&SharedWorkspace{}, id)  // create all shared workflows
+	wfa.sharedWorkflow(&CollaborativeArea{}, id)  // create all shared workflows
-	wfa.sharedWorkspace(&SharedWorkspace{}, id) // create all shared workspaces
+	wfa.sharedWorkspace(&CollaborativeArea{}, id) // create all collaborative areas
 	return wfa.GenericDeleteOne(id, wfa)          // then add on yours
 }
 
 /*
-sharedWorkspace is a function that shares the shared workspace to the peers
+sharedWorkspace is a function that shares the collaborative area to the peers
 */
-func (wfa *sharedWorkspaceMongoAccessor) sharedWorkspace(shared *SharedWorkspace, id string) {
+func (wfa *collaborativeAreaMongoAccessor) sharedWorkspace(shared *CollaborativeArea, id string) {
 	eldest, code, _ := wfa.LoadOne(id) // get the eldest
 	accessor := (&workspace.Workspace{}).GetAccessor(nil)
 	if code == 200 {
-		eld := eldest.(*SharedWorkspace)
+		eld := eldest.(*CollaborativeArea)
 		if eld.Workspaces != nil { // update all your workspaces in the eldest by replacing shared ref by an empty string
 			for _, v := range eld.Workspaces {
 				accessor.UpdateOne(&workspace.Workspace{Shared: ""}, v)
@@ -51,7 +51,7 @@ func (wfa *sharedWorkspaceMongoAccessor) sharedWorkspace(shared *SharedWorkspace
 					continue
 				}
 				paccess := (&peer.Peer{})        // send to all peers
-				for _, p := range shared.Peers { // delete the shared workspace on the peer
+				for _, p := range shared.Peers { // delete the collaborative area on the peer
 					b, err := paccess.LaunchPeerExecution(p, v, utils.WORKSPACE, tools.DELETE, nil, wfa.Caller)
 					if err != nil && b == nil {
 						wfa.Logger.Error().Msg("Could not send to peer " + p + ". Error: " + err.Error())
@@ -61,7 +61,7 @@ func (wfa *sharedWorkspaceMongoAccessor) sharedWorkspace(shared *SharedWorkspace
 		}
 	}
 	if shared.Workspaces != nil {
-		for _, v := range shared.Workspaces { // update all the shared workspaces
+		for _, v := range shared.Workspaces { // update all the collaborative areas
 			workspace, code, _ := accessor.UpdateOne(&workspace.Workspace{Shared: shared.UUID}, v) // add the shared ref to workspace
 			if wfa.Caller != nil || wfa.Caller.URLS == nil || wfa.Caller.URLS[utils.WORKSPACE.String()] == nil {
 				continue
@@ -70,7 +70,7 @@ func (wfa *sharedWorkspaceMongoAccessor) sharedWorkspace(shared *SharedWorkspace
 				if code != 200 {
 					continue
 				}
-				paccess := (&peer.Peer{}) // send to all peers, add the shared workspace on the peer
+				paccess := (&peer.Peer{}) // send to all peers, add the collaborative area on the peer
 				s := workspace.Serialize()
 				s["name"] = fmt.Sprintf("%v", s["name"]) + "_" + p
 				b, err := paccess.LaunchPeerExecution(p, v, utils.WORKSPACE, tools.POST, s, wfa.Caller)
@@ -81,15 +81,15 @@ func (wfa *sharedWorkspaceMongoAccessor) sharedWorkspace(shared *SharedWorkspace
 		}
 	}
 	// deleting on peers before adding, to avoid conflicts on peers side
-	// because you have no reference to the remote shared workspace
+	// because you have no reference to the remote collaborative area
 }
 
 // sharedWorkflow is a function that shares the shared workflow to the peers
-func (wfa *sharedWorkspaceMongoAccessor) sharedWorkflow(shared *SharedWorkspace, id string) {
+func (wfa *collaborativeAreaMongoAccessor) sharedWorkflow(shared *CollaborativeArea, id string) {
 	accessor := (&w.Workflow{}).GetAccessor(nil)
 	eldest, code, _ := wfa.LoadOne(id) // get the eldest
 	if code == 200 {
-		eld := eldest.(*SharedWorkspace)
+		eld := eldest.(*CollaborativeArea)
 		if eld.Workflows != nil {
 			for _, v := range eld.Workflows {
 				data, code, _ := accessor.LoadOne(v)
@@ -148,9 +148,9 @@ func (wfa *sharedWorkspaceMongoAccessor) sharedWorkflow(shared *SharedWorkspace,
 	// because you have no reference to the remote shared workflow
 }
 
-// sharedWorkspace is a function that shares the shared workspace to the peers
+// sharedWorkspace is a function that shares the collaborative area to the peers
-func (wfa *sharedWorkspaceMongoAccessor) deleteToPeer(shared *SharedWorkspace) {
+func (wfa *collaborativeAreaMongoAccessor) deleteToPeer(shared *CollaborativeArea) {
-	if wfa.Caller == nil || wfa.Caller.URLS == nil || wfa.Caller.URLS[utils.SHARED_WORKSPACE.String()] == nil {
+	if wfa.Caller == nil || wfa.Caller.URLS == nil || wfa.Caller.URLS[utils.COLLABORATIVE_AREA.String()] == nil {
 		return
 	}
 	paccess := (&peer.Peer{})
@@ -158,16 +158,16 @@ func (wfa *sharedWorkspaceMongoAccessor) deleteToPeer(shared *SharedWorkspace) {
 		if (&peer.Peer{AbstractObject: utils.AbstractObject{UUID: v}}).IsMySelf() {
 			continue
 		}
-		b, err := paccess.LaunchPeerExecution(v, shared.UUID, utils.SHARED_WORKSPACE, tools.DELETE, nil, wfa.Caller)
+		b, err := paccess.LaunchPeerExecution(v, shared.UUID, utils.COLLABORATIVE_AREA, tools.DELETE, nil, wfa.Caller)
 		if err != nil && b == nil {
 			wfa.Logger.Error().Msg("Could not send to peer " + v + ". Error: " + err.Error())
 		}
 	}
 }
 
-// sharedWorkspace is a function that shares the shared workspace to the peers
+// sharedWorkspace is a function that shares the collaborative area to the peers
-func (wfa *sharedWorkspaceMongoAccessor) sendToPeer(shared *SharedWorkspace) {
+func (wfa *collaborativeAreaMongoAccessor) sendToPeer(shared *CollaborativeArea) {
-	if wfa.Caller == nil || wfa.Caller.URLS == nil || wfa.Caller.URLS[utils.SHARED_WORKSPACE.String()] == nil {
+	if wfa.Caller == nil || wfa.Caller.URLS == nil || wfa.Caller.URLS[utils.COLLABORATIVE_AREA.String()] == nil {
 		return
 	}
 
@@ -177,56 +177,56 @@ func (wfa *sharedWorkspaceMongoAccessor) sendToPeer(shared *SharedWorkspace) {
 			continue
 		}
 		shared.IsSent = true
-		b, err := paccess.LaunchPeerExecution(v, v, utils.SHARED_WORKSPACE, tools.POST, shared.Serialize(), wfa.Caller)
+		b, err := paccess.LaunchPeerExecution(v, v, utils.COLLABORATIVE_AREA, tools.POST, shared.Serialize(), wfa.Caller)
 		if err != nil && b == nil {
 			wfa.Logger.Error().Msg("Could not send to peer " + v + ". Error: " + err.Error())
 		}
 	}
 }
 
-// UpdateOne updates a shared workspace in the database, given its ID and the new data, it automatically share to peers if the workspace is shared
+// UpdateOne updates a collaborative area in the database, given its ID and the new data, it automatically share to peers if the workspace is shared
-func (wfa *sharedWorkspaceMongoAccessor) UpdateOne(set utils.DBObject, id string) (utils.DBObject, int, error) {
+func (wfa *collaborativeAreaMongoAccessor) UpdateOne(set utils.DBObject, id string) (utils.DBObject, int, error) {
-	res, code, err := wfa.GenericUpdateOne(set.(*SharedWorkspace), id, wfa, &SharedWorkspace{})
+	res, code, err := wfa.GenericUpdateOne(set.(*CollaborativeArea), id, wfa, &CollaborativeArea{})
-	wfa.deleteToPeer(res.(*SharedWorkspace))        // delete the shared workspace on the peer
+	wfa.deleteToPeer(res.(*CollaborativeArea))        // delete the collaborative area on the peer
-	wfa.sharedWorkflow(res.(*SharedWorkspace), id)  // replace all shared workflows
+	wfa.sharedWorkflow(res.(*CollaborativeArea), id)  // replace all shared workflows
-	wfa.sharedWorkspace(res.(*SharedWorkspace), id) // replace all shared workspaces (not shared worspace obj but workspace one)
+	wfa.sharedWorkspace(res.(*CollaborativeArea), id) // replace all collaborative areas (not shared worspace obj but workspace one)
-	wfa.sendToPeer(res.(*SharedWorkspace))          // send the shared workspace (shared workspace object) to the peers
+	wfa.sendToPeer(res.(*CollaborativeArea))          // send the collaborative area (collaborative area object) to the peers
 	return res, code, err
 }
 
-// StoreOne stores a shared workspace in the database, it automatically share to peers if the workspace is shared
+// StoreOne stores a collaborative area in the database, it automatically share to peers if the workspace is shared
-func (wfa *sharedWorkspaceMongoAccessor) StoreOne(data utils.DBObject) (utils.DBObject, int, error) {
+func (wfa *collaborativeAreaMongoAccessor) StoreOne(data utils.DBObject) (utils.DBObject, int, error) {
 	id, _ := static.GetMyLocalJsonPeer()                                          // get the local peer
-	data.(*SharedWorkspace).CreatorID = id                                    // set the creator id
+	data.(*CollaborativeArea).CreatorID = id                                      // set the creator id
-	data.(*SharedWorkspace).Peers = append(data.(*SharedWorkspace).Peers, id) // add the creator id to the peers
+	data.(*CollaborativeArea).Peers = append(data.(*CollaborativeArea).Peers, id) // add the creator id to the peers
 	// then reset the shared fields
-	if data.(*SharedWorkspace).Workspaces == nil {
+	if data.(*CollaborativeArea).Workspaces == nil {
-		data.(*SharedWorkspace).Workspaces = []string{}
+		data.(*CollaborativeArea).Workspaces = []string{}
 	}
-	if data.(*SharedWorkspace).Workflows == nil {
+	if data.(*CollaborativeArea).Workflows == nil {
-		data.(*SharedWorkspace).Workflows = []string{}
+		data.(*CollaborativeArea).Workflows = []string{}
 	}
-	if data.(*SharedWorkspace).Rules == nil {
+	if data.(*CollaborativeArea).Rules == nil {
-		data.(*SharedWorkspace).Rules = []string{}
+		data.(*CollaborativeArea).Rules = []string{}
 	}
 
-	d, code, err := wfa.GenericStoreOne(data.(*SharedWorkspace), wfa)
+	d, code, err := wfa.GenericStoreOne(data.(*CollaborativeArea), wfa)
 
 	if code == 200 {
-		wfa.sharedWorkflow(d.(*SharedWorkspace), d.GetID())  // create all shared workflows
+		wfa.sharedWorkflow(d.(*CollaborativeArea), d.GetID())  // create all shared workflows
-		wfa.sharedWorkspace(d.(*SharedWorkspace), d.GetID()) // create all shared workspaces
+		wfa.sharedWorkspace(d.(*CollaborativeArea), d.GetID()) // create all collaborative areas
-		wfa.sendToPeer(d.(*SharedWorkspace))                 // send the shared workspace (shared workspace object) to the peers
+		wfa.sendToPeer(d.(*CollaborativeArea))                 // send the collaborative area (collaborative area object) to the peers
 	}
 	return data, code, err
 }
 
-// CopyOne copies a shared workspace in the database
+// CopyOne copies a CollaborativeArea in the database
-func (wfa *sharedWorkspaceMongoAccessor) CopyOne(data utils.DBObject) (utils.DBObject, int, error) {
+func (wfa *collaborativeAreaMongoAccessor) CopyOne(data utils.DBObject) (utils.DBObject, int, error) {
 	return wfa.StoreOne(data)
 }
 
-// enrich is a function that enriches the shared workspace with the shared objects
+// enrich is a function that enriches the CollaborativeArea with the shared objects
-func (wfa *sharedWorkspaceMongoAccessor) enrich(sharedWorkspace *SharedWorkspace) *SharedWorkspace {
+func (wfa *collaborativeAreaMongoAccessor) enrich(sharedWorkspace *CollaborativeArea) *CollaborativeArea {
 	access := (&workspace.Workspace{}).GetAccessor(nil)
 	res, code, _ := access.Search(&dbs.Filters{
 		Or: map[string][]dbs.Filter{
@@ -274,38 +274,38 @@ func (wfa *sharedWorkspaceMongoAccessor) enrich(sharedWorkspace *SharedWorkspace
 	return sharedWorkspace
 }
 
-// LoadOne loads a shared workspace from the database, given its ID and enrich it
+// LoadOne loads a collaborative area from the database, given its ID and enrich it
-func (wfa *sharedWorkspaceMongoAccessor) LoadOne(id string) (utils.DBObject, int, error) {
+func (wfa *collaborativeAreaMongoAccessor) LoadOne(id string) (utils.DBObject, int, error) {
-	var sharedWorkspace SharedWorkspace
+	var sharedWorkspace CollaborativeArea
 	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 wfa.enrich(&sharedWorkspace), 200, nil // enrich the shared workspace
+	return wfa.enrich(&sharedWorkspace), 200, nil // enrich the collaborative area
 }
 
-// LoadAll loads all the shared workspaces from the database and enrich them
+// LoadAll loads all the collaborative areas from the database and enrich them
-func (wfa sharedWorkspaceMongoAccessor) LoadAll() ([]utils.ShallowDBObject, int, error) {
+func (wfa collaborativeAreaMongoAccessor) 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
+	var results []CollaborativeArea
 	if err = res_mongo.All(mongo.MngoCtx, &results); err != nil {
 		return nil, 404, err
 	}
 	for _, r := range results {
-		objs = append(objs, wfa.enrich(&r)) // enrich the shared workspace
+		objs = append(objs, wfa.enrich(&r)) // enrich the collaborative area
 	}
 	return objs, 200, nil
 }
 
-// Search searches for shared workspaces in the database, given some filters OR a search string
+// Search searches for collaborative areas in the database, given some filters OR a search string
-func (wfa *sharedWorkspaceMongoAccessor) Search(filters *dbs.Filters, search string) ([]utils.ShallowDBObject, int, error) {
+func (wfa *collaborativeAreaMongoAccessor) 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{
@@ -319,12 +319,12 @@ func (wfa *sharedWorkspaceMongoAccessor) Search(filters *dbs.Filters, search str
 		wfa.Logger.Error().Msg("Could not store to db. Error: " + err.Error())
 		return nil, code, err
 	}
-	var results []SharedWorkspace
+	var results []CollaborativeArea
 	if err = res_mongo.All(mongo.MngoCtx, &results); err != nil {
 		return nil, 404, err
 	}
 	for _, r := range results {
-		objs = append(objs, wfa.enrich(&r)) // enrich the shared workspace
+		objs = append(objs, wfa.enrich(&r)) // enrich the collaborative area
 	}
 	return objs, 200, nil
 }

models/workspace/shared/shallow_collaborative_area/shallow_collaborative_area.go

@@ -1,4 +1,4 @@
-package shallow_shared_workspace
+package shallow_collaborative_area
 
 import (
 	"encoding/json"
@@ -8,7 +8,7 @@ import (
 	"github.com/google/uuid"
 )
 
-type ShallowSharedWorkspace struct {
+type ShallowCollaborativeArea struct {
 	utils.AbstractObject
 	IsSent      bool                   `json:"is_sent" bson:"-"`
 	CreatorID   string                 `json:"peer_id,omitempty" bson:"peer_id,omitempty" validate:"required"`
@@ -21,27 +21,27 @@ type ShallowSharedWorkspace struct {
 	Rules       []string               `json:"rules,omitempty" bson:"rules,omitempty"`
 }
 
-func (ao *ShallowSharedWorkspace) GetID() string {
+func (ao *ShallowCollaborativeArea) GetID() string {
 	return ao.UUID
 }
 
-func (r *ShallowSharedWorkspace) GenerateID() {
+func (r *ShallowCollaborativeArea) GenerateID() {
 	if r.UUID == "" {
 		r.UUID = uuid.New().String()
 	}
 }
 
-func (d *ShallowSharedWorkspace) GetName() string {
+func (d *ShallowCollaborativeArea) GetName() string {
 	return d.Name
 }
 
-func (d *ShallowSharedWorkspace) GetAccessor(caller *tools.HTTPCaller) utils.Accessor {
+func (d *ShallowCollaborativeArea) GetAccessor(caller *tools.HTTPCaller) utils.Accessor {
 	data := New()
-	data.Init(utils.SHARED_WORKSPACE, caller)
+	data.Init(utils.COLLABORATIVE_AREA, caller)
 	return data
 }
 
-func (dma *ShallowSharedWorkspace) Deserialize(j map[string]interface{}) utils.DBObject {
+func (dma *ShallowCollaborativeArea) Deserialize(j map[string]interface{}) utils.DBObject {
 	b, err := json.Marshal(j)
 	if err != nil {
 		return nil
@@ -50,7 +50,7 @@ func (dma *ShallowSharedWorkspace) Deserialize(j map[string]interface{}) utils.D
 	return dma
 }
 
-func (dma *ShallowSharedWorkspace) Serialize() map[string]interface{} {
+func (dma *ShallowCollaborativeArea) Serialize() map[string]interface{} {
 	var m map[string]interface{}
 	b, err := json.Marshal(dma)
 	if err != nil {

models/workspace/shared/shallow_collaborative_area/shallow_collaborative_area_mongo_accessor.go

@@ -1,4 +1,4 @@
-package shallow_shared_workspace
+package shallow_collaborative_area
 
 import (
 	"cloud.o-forge.io/core/oc-lib/dbs"
@@ -19,11 +19,11 @@ func (wfa *shallowSharedWorkspaceMongoAccessor) DeleteOne(id string) (utils.DBOb
 }
 
 func (wfa *shallowSharedWorkspaceMongoAccessor) UpdateOne(set utils.DBObject, id string) (utils.DBObject, int, error) {
-	return wfa.GenericUpdateOne(set.(*ShallowSharedWorkspace), id, wfa, &ShallowSharedWorkspace{})
+	return wfa.GenericUpdateOne(set.(*ShallowCollaborativeArea), id, wfa, &ShallowCollaborativeArea{})
 }
 
 func (wfa *shallowSharedWorkspaceMongoAccessor) StoreOne(data utils.DBObject) (utils.DBObject, int, error) {
-	return wfa.GenericStoreOne(data.(*ShallowSharedWorkspace), wfa)
+	return wfa.GenericStoreOne(data.(*ShallowCollaborativeArea), wfa)
 }
 
 func (wfa *shallowSharedWorkspaceMongoAccessor) CopyOne(data utils.DBObject) (utils.DBObject, int, error) {
@@ -31,7 +31,7 @@ func (wfa *shallowSharedWorkspaceMongoAccessor) CopyOne(data utils.DBObject) (ut
 }
 
 func (wfa *shallowSharedWorkspaceMongoAccessor) LoadOne(id string) (utils.DBObject, int, error) {
-	var sharedWorkspace ShallowSharedWorkspace
+	var sharedWorkspace ShallowCollaborativeArea
 	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())
@@ -48,7 +48,7 @@ func (wfa shallowSharedWorkspaceMongoAccessor) LoadAll() ([]utils.ShallowDBObjec
 		wfa.Logger.Error().Msg("Could not retrieve any from db. Error: " + err.Error())
 		return nil, code, err
 	}
-	var results []ShallowSharedWorkspace
+	var results []ShallowCollaborativeArea
 	if err = res_mongo.All(mongo.MngoCtx, &results); err != nil {
 		return nil, 404, err
 	}
@@ -72,7 +72,7 @@ func (wfa *shallowSharedWorkspaceMongoAccessor) Search(filters *dbs.Filters, sea
 		wfa.Logger.Error().Msg("Could not store to db. Error: " + err.Error())
 		return nil, code, err
 	}
-	var results []ShallowSharedWorkspace
+	var results []ShallowCollaborativeArea
 	if err = res_mongo.All(mongo.MngoCtx, &results); err != nil {
 		return nil, 404, err
 	}

models/workspace/workspace_mongo_accessor.go

@@ -12,7 +12,7 @@ import (
 	"cloud.o-forge.io/core/oc-lib/models/resources/storage"
 	w "cloud.o-forge.io/core/oc-lib/models/resources/workflow"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
-	"cloud.o-forge.io/core/oc-lib/models/workspace/shared/shallow_shared_workspace"
+	"cloud.o-forge.io/core/oc-lib/models/workspace/shared/shallow_collaborative_area"
 	"cloud.o-forge.io/core/oc-lib/tools"
 )
 
@@ -208,14 +208,14 @@ func (wfa *workspaceMongoAccessor) share(realData *Workspace, delete bool, calle
 	if realData.Shared == "" {
 		return
 	}
-	access := (&shallow_shared_workspace.ShallowSharedWorkspace{}).GetAccessor(nil)
+	access := (&shallow_collaborative_area.ShallowCollaborativeArea{}).GetAccessor(nil)
 	res, code, _ := access.LoadOne(realData.Shared)
 	if code != 200 {
 		return
 	}
 	var err error
 	paccess := &peer.Peer{}
-	for _, p := range res.(*shallow_shared_workspace.ShallowSharedWorkspace).Peers {
+	for _, p := range res.(*shallow_collaborative_area.ShallowCollaborativeArea).Peers {
 		paccess.UUID = p
 		if paccess.IsMySelf() { // If the peer is the current peer, never share because it will create a loop
 			continue