@sapui5/sap.fe.core 1.100.0 → 1.102.0

package/src/sap/fe/core/controllerextensions/collaboration/ActivityBase.ts

@@ -0,0 +1,98 @@
+import Log from "sap/base/Log";
+import UriParameters from "sap/base/util/UriParameters";
+import { Activity, Message, User } from "sap/fe/core/controllerextensions/collaboration/CollaborationCommon";
+import Event from "sap/ui/base/Event";
+import SapPcpWebSocket, { SUPPORTED_PROTOCOLS } from "sap/ui/core/ws/SapPcpWebSocket";
+import JSONModel from "sap/ui/model/json/JSONModel";
+
+const COLLABORATION = "/collaboration";
+const CONNECTED = "/collaboration/connected";
+const CONNECTION = "/collaboration/connection";
+
+export function isCollaborationConnected(internalModel: JSONModel): boolean {
+	return !!internalModel.getProperty(CONNECTED);
+}
+
+export function initializeCollaboration(
+	user: User,
+	webSocketBaseURL: string,
+	draftUUID: string,
+	internalModel: JSONModel,
+	receiveCallback: (_: Message) => void,
+	sendUserInfo = false
+) {
+	if (internalModel.getProperty(CONNECTION)) {
+		// connection already established
+		return;
+	}
+
+	const activeUsers: any[] = [user];
+	internalModel.setProperty(COLLABORATION, { activeUsers: activeUsers, activities: {} });
+
+	sendUserInfo = sendUserInfo || UriParameters.fromQuery(window.location.search).get("useFLPUser") === "true";
+
+	const webSocket = createWebSocket(user, webSocketBaseURL, draftUUID, sendUserInfo);
+
+	internalModel.setProperty(CONNECTION, webSocket);
+
+	webSocket.attachMessage(function (event: Event) {
+		const message: Message = event.getParameter("pcpFields");
+		receiveCallback(message);
+	});
+
+	webSocket.attachOpen(function () {
+		internalModel.setProperty(CONNECTED, true);
+	});
+
+	webSocket.attachError(function () {
+		Log.error("The connection to the websocket channel " + webSocketBaseURL + " could not be established");
+		internalModel.setProperty(CONNECTED, false);
+	});
+
+	webSocket.attachClose(function () {
+		internalModel.setProperty(CONNECTED, false);
+	});
+}
+
+export function broadcastCollaborationMessage(action: Activity, content: string | undefined, internalModel: JSONModel) {
+	if (isCollaborationConnected(internalModel)) {
+		const webSocket = internalModel.getProperty(CONNECTION) as SapPcpWebSocket;
+
+		webSocket.send("", {
+			clientAction: action,
+			clientContent: content
+		});
+
+		if (action === Activity.Activate || action === Activity.Discard) {
+			endCollaboration(internalModel);
+		}
+	}
+}
+
+export function endCollaboration(internalModel: JSONModel) {
+	const webSocket = internalModel.getProperty(CONNECTION) as SapPcpWebSocket;
+	webSocket.close();
+	internalModel.setProperty(CONNECTION, null);
+}
+
+function createWebSocket(user: User, socketBaseURL: string, draftUUID: string, sendUserInfo = false) {
+	const hostLocation = window.location;
+	let socketURI;
+
+	// Support useBackendUrl for local testing
+	const useBackendUrl = UriParameters.fromQuery(window.location.search).get("useBackendUrl");
+	if (useBackendUrl) {
+		socketURI = useBackendUrl.replace("https", "wss");
+	} else {
+		socketURI = hostLocation.protocol === "https:" ? "wss:" : "ws:";
+		socketURI += "//" + hostLocation.host;
+	}
+
+	socketURI += (socketBaseURL.startsWith("/") ? "" : "/") + socketBaseURL + "?draft=" + draftUUID;
+
+	if (sendUserInfo) {
+		socketURI += "&userID=" + encodeURI(user.id) + "&userName=" + encodeURI(user.initialName || "");
+	}
+
+	return new SapPcpWebSocket(socketURI, [SUPPORTED_PROTOCOLS.v10]);
+}

package/src/sap/fe/core/controllerextensions/collaboration/ActivitySync.js

@@ -0,0 +1,360 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/CommonUtils", "sap/fe/core/controllerextensions/collaboration/ActivityBase", "sap/fe/core/controllerextensions/collaboration/CollaborationCommon", "sap/m/MessageBox"], function (CommonUtils, ActivityBase, CollaborationCommon, MessageBox) {
+  "use strict";
+
+  var _exports = {};
+  var CollaborationUtils = CollaborationCommon.CollaborationUtils;
+  var Activity = CollaborationCommon.Activity;
+  var isCollaborationConnected = ActivityBase.isCollaborationConnected;
+  var initializeCollaboration = ActivityBase.initializeCollaboration;
+  var endCollaboration = ActivityBase.endCollaboration;
+  var broadcastCollaborationMessage = ActivityBase.broadcastCollaborationMessage;
+
+  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+  var MYACTIVITY = "/collaboration/myActivity";
+  var ACTIVEUSERS = "/collaboration/activeUsers";
+  var ACTIVITIES = "/collaboration/activities";
+
+  var isConnected = function (control) {
+    var internalModel = control.getModel("internal");
+    return isCollaborationConnected(internalModel);
+  };
+
+  _exports.isConnected = isConnected;
+
+  var send = function (control, action, content) {
+    if (isConnected(control)) {
+      var internalModel = control.getModel("internal");
+      var clientContent = Array.isArray(content) ? content.join("|") : content;
+
+      if (action === Activity.LiveChange) {
+        // To avoid unnecessary traffic we keep track of live changes and send it only once
+        var myActivity = internalModel.getProperty(MYACTIVITY);
+
+        if (myActivity === clientContent) {
+          return;
+        } else {
+          internalModel.setProperty(MYACTIVITY, clientContent);
+        }
+      } else {
+        // user finished the activity
+        internalModel.setProperty(MYACTIVITY, null);
+      }
+
+      broadcastCollaborationMessage(action, clientContent, internalModel);
+    }
+  };
+
+  _exports.send = send;
+
+  var getWebSocketBaseURL = function (bindingContext) {
+    return bindingContext.getModel().getMetaModel().getObject("/@com.sap.vocabularies.Common.v1.WebSocketBaseURL");
+  };
+
+  var isCollaborationEnabled = function (view) {
+    var bindingContext = (view === null || view === void 0 ? void 0 : view.getBindingContext) && view.getBindingContext();
+    return !!(bindingContext && getWebSocketBaseURL(bindingContext));
+  };
+
+  _exports.isCollaborationEnabled = isCollaborationEnabled;
+
+  var connect = function (view) {
+    try {
+      var internalModel = view.getModel("internal");
+      var me = CollaborationUtils.getMe(view); // Retrieving ME from shell service
+
+      if (!me) {
+        // no me = no shell = not sure what to do
+        return Promise.resolve();
+      }
+
+      var bindingContext = view.getBindingContext();
+      var webSocketBaseURL = getWebSocketBaseURL(bindingContext);
+
+      if (!webSocketBaseURL) {
+        return Promise.resolve();
+      }
+
+      return Promise.resolve(bindingContext.requestProperty("DraftAdministrativeData/DraftUUID")).then(function (sDraftUUID) {
+        if (!sDraftUUID) {
+          return;
+        }
+
+        initializeCollaboration(me, webSocketBaseURL, sDraftUUID, internalModel, function (message) {
+          messageReceive(message, view);
+        });
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
+  _exports.connect = connect;
+
+  var disconnect = function (control) {
+    var internalModel = control.getModel("internal");
+    endCollaboration(internalModel);
+  };
+
+  _exports.disconnect = disconnect;
+
+  function messageReceive(message, view) {
+    var _message$clientConten, _activities;
+
+    var internalModel = view.getModel("internal");
+    var activeUsers = internalModel.getProperty(ACTIVEUSERS);
+    var activities;
+    var activityKey;
+    var metaPath = message.clientContent && view.getModel().getMetaModel().getMetaPath(message.clientContent);
+    message.userAction = message.userAction || message.clientAction;
+    var sender = {
+      id: message.userID,
+      name: message.userDescription,
+      initials: CollaborationUtils.formatInitials(message.userDescription),
+      color: CollaborationUtils.getUserColor(message.userID, activeUsers, [])
+    }; // eslint-disable-next-line default-case
+
+    switch (message.userAction) {
+      case Activity.Join:
+      case Activity.JoinEcho:
+        if (activeUsers.findIndex(function (user) {
+          return user.id === sender.id;
+        }) === -1) {
+          activeUsers.push(sender);
+          internalModel.setProperty(ACTIVEUSERS, activeUsers);
+        }
+
+        if (message.userAction === Activity.Join) {
+          // we echo our existence to the newly entered user and also send the current activity if there is any
+          broadcastCollaborationMessage(Activity.JoinEcho, internalModel.getProperty(MYACTIVITY), internalModel);
+        }
+
+        if (message.userAction === Activity.JoinEcho) {
+          if (message.clientContent) {
+            // another user was already typing therefore I want to see his activity immediately. Calling me again as a live change
+            message.userAction = Activity.LiveChange;
+            messageReceive(message, view);
+          }
+        }
+
+        break;
+
+      case Activity.Leave:
+        // Removing the active user. Not removing "me" if I had the screen open in another session
+        activeUsers = activeUsers.filter(function (user) {
+          return user.id !== sender.id || user.me;
+        });
+        internalModel.setProperty(ACTIVEUSERS, activeUsers);
+        var allActivities = internalModel.getProperty(ACTIVITIES) || {};
+
+        var removeUserActivities = function (bag) {
+          if (Array.isArray(bag)) {
+            return bag.filter(function (activity) {
+              return activity.id !== sender.id;
+            });
+          } else {
+            for (var p in bag) {
+              bag[p] = removeUserActivities(bag[p]);
+            }
+
+            return bag;
+          }
+        };
+
+        removeUserActivities(allActivities);
+        internalModel.setProperty(ACTIVITIES, allActivities);
+        break;
+
+      case Activity.Change:
+        var metaPaths = message === null || message === void 0 ? void 0 : (_message$clientConten = message.clientContent) === null || _message$clientConten === void 0 ? void 0 : _message$clientConten.split("|").map(function (path) {
+          return view.getModel().getMetaModel().getMetaPath(path);
+        });
+        metaPaths.forEach(function (metaPath, i) {
+          var _message$clientConten2, _currentActivities;
+
+          var nesteedMessage = _objectSpread(_objectSpread({}, message), {}, {
+            clientContent: message === null || message === void 0 ? void 0 : (_message$clientConten2 = message.clientContent) === null || _message$clientConten2 === void 0 ? void 0 : _message$clientConten2.split("|")[i]
+          });
+
+          var currentActivities = internalModel.getProperty(ACTIVITIES + metaPath) || [];
+          activityKey = getActivityKey(nesteedMessage.clientContent);
+          currentActivities = ((_currentActivities = currentActivities) === null || _currentActivities === void 0 ? void 0 : _currentActivities.filter) && currentActivities.filter(function (activity) {
+            return activity.key !== activityKey;
+          });
+
+          if (currentActivities) {
+            internalModel.setProperty(ACTIVITIES + metaPath, currentActivities);
+            update(view, nesteedMessage, metaPath, Activity.Change);
+          }
+        });
+        break;
+
+      case Activity.Create:
+        // For create we actually just need to refresh the table
+        update(view, message, metaPath, Activity.Create);
+        break;
+
+      case Activity.Delete:
+        // For now also refresh the page but in case of deletion we need to inform the user
+        update(view, message, metaPath, Activity.Delete);
+        break;
+
+      case Activity.Activate:
+        disconnect(view);
+        MessageBox.information(CollaborationUtils.getText("C_COLLABORATIONDRAFT_ACTIVATE", sender.name));
+        navigate(message.clientContent, view);
+        break;
+
+      case Activity.Discard:
+        disconnect(view);
+        MessageBox.information(CollaborationUtils.getText("C_COLLABORATIONDRAFT_DISCARD", sender.name));
+        navigate(message.clientContent, view);
+        break;
+
+      /*
+      // TODO: Action to be implemented
+      case Activity.Action:
+      	// Just for test reasons show a toast - to be checked with UX
+      	MessageToast.show("User " + sender.name + " has executed action " + metaPath.split("|")[0]);
+      	//update(view, message, metaPath, Activity.Delete);
+      	break;
+       */
+
+      case Activity.LiveChange:
+        var activity = sender;
+        activity.key = getActivityKey(message.clientContent); // stupid JSON model...
+
+        var initJSONModel = "";
+        var parts = metaPath.split("/");
+
+        for (var i = 1; i < parts.length - 1; i++) {
+          initJSONModel += "/" + parts[i];
+
+          if (!internalModel.getProperty(ACTIVITIES + initJSONModel)) {
+            internalModel.setProperty(ACTIVITIES + initJSONModel, {});
+          }
+        }
+
+        activities = internalModel.getProperty(ACTIVITIES + metaPath);
+        activities = (_activities = activities) !== null && _activities !== void 0 && _activities.slice ? activities.slice() : [];
+        activities.push(activity);
+        internalModel.setProperty(ACTIVITIES + metaPath, activities);
+        break;
+
+      case Activity.Undo:
+        // The user did a change but reverted it, therefore unblock the control
+        activities = internalModel.getProperty(ACTIVITIES + metaPath);
+        activityKey = getActivityKey(message.clientContent);
+        internalModel.setProperty(ACTIVITIES + metaPath, activities.filter(function (a) {
+          return a.key !== activityKey;
+        }));
+        break;
+    }
+  }
+
+  function update(view, message, metaPath, action) {
+    var appComponent = CollaborationUtils.getAppComponent(view);
+    var metaModel = view.getModel().getMetaModel();
+    var currentPage = getCurrentPage(view);
+    var sideEffectsService = appComponent.getSideEffectsService();
+    var currentContext = currentPage.getBindingContext();
+    var currentPath = currentContext.getPath();
+    var currentMetaPath = metaModel.getMetaPath(currentPath);
+    var changedDocument = message.clientContent;
+
+    if (action === Activity.Delete) {
+      // check if user currently displays one deleted object
+      var deletedObjects = message.clientContent.split("|");
+      var parentDeletedIndex = deletedObjects.findIndex(function (deletedObject) {
+        return currentPath.startsWith(deletedObject);
+      });
+
+      if (parentDeletedIndex > -1) {
+        // any other user deleted the object I'm currently looking at. Inform the user we will navigate to root now
+        MessageBox.information(CollaborationUtils.getText("C_COLLABORATIONDRAFT_DELETE", message.userDescription), {
+          onClose: function () {
+            var targetContext = view.getModel().bindContext(deletedObjects[parentDeletedIndex]).getBoundContext();
+
+            currentPage.getController()._routing.navigateBackFromContext(targetContext);
+          }
+        });
+      } // TODO: For now just take the first object to get the meta path and do a full refresh of the table
+
+
+      changedDocument = deletedObjects[0];
+    }
+
+    if (changedDocument.startsWith(currentPath)) {
+      // Execute SideEffects (TODO for Meet there should be one central method)
+      var activityPath = metaPath.replace(currentMetaPath, "").slice(1);
+
+      if (activityPath) {
+        (function () {
+          // Request also the property itself
+          var sideEffects = [{
+            $PropertyPath: activityPath
+          }];
+          var entityType = sideEffectsService.getEntityTypeFromContext(currentContext);
+          var entityTypeSideEffects = sideEffectsService.getODataEntitySideEffects(entityType); // Poor man solution without checking source targets, just for POC, this is throw-way coding only
+
+          var object = Object; // just to overcome TS issues, will be anyway replaced
+
+          var relevantSideEffects = object.fromEntries(object.entries(entityTypeSideEffects).filter(function (x) {
+            var _x$1$SourceProperties;
+
+            return ((_x$1$SourceProperties = x[1].SourceProperties) === null || _x$1$SourceProperties === void 0 ? void 0 : _x$1$SourceProperties.findIndex(function (source) {
+              return source.value === activityPath;
+            })) > -1;
+          }));
+
+          for (var p in relevantSideEffects) {
+            relevantSideEffects[p].TargetProperties.forEach(function (targetProperty) {
+              sideEffects.push({
+                $PropertyPath: targetProperty
+              });
+            });
+          }
+
+          sideEffectsService.requestSideEffects(sideEffects, currentContext, "$auto");
+        })();
+      }
+    } // Simulate any change so the edit flow shows the draft indicator and sets the page to dirty
+
+
+    currentPage.getController().editFlow.updateDocument(currentContext, Promise.resolve());
+  }
+
+  function navigate(path, view) {
+    // TODO: routing.navigate doesn't consider semantic bookmarking
+    var currentPage = getCurrentPage(view);
+    var targetContext = view.getModel().bindContext(path).getBoundContext();
+    currentPage.getController().routing.navigate(targetContext);
+  }
+
+  function getCurrentPage(view) {
+    var appComponent = CollaborationUtils.getAppComponent(view);
+    var rootViewController = appComponent.getRootViewController();
+    return rootViewController.isFclEnabled() ? rootViewController.getRightmostView() : CommonUtils.getTargetView(appComponent.getRootContainer().getCurrentPage());
+  }
+
+  function getActivityKey(x) {
+    return x.substring(x.lastIndexOf("(") + 1, x.lastIndexOf(")"));
+  }
+
+  return {
+    connect: connect,
+    disconnect: disconnect,
+    isConnected: isConnected,
+    isCollaborationEnabled: isCollaborationEnabled,
+    send: send
+  };
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["ActivitySync.ts"],"names":["MYACTIVITY","ACTIVEUSERS","ACTIVITIES","isConnected","control","internalModel","getModel","isCollaborationConnected","send","action","content","clientContent","Array","isArray","join","Activity","LiveChange","myActivity","getProperty","setProperty","broadcastCollaborationMessage","getWebSocketBaseURL","bindingContext","getMetaModel","getObject","isCollaborationEnabled","view","getBindingContext","connect","me","CollaborationUtils","getMe","webSocketBaseURL","requestProperty","sDraftUUID","initializeCollaboration","message","messageReceive","disconnect","endCollaboration","activeUsers","activities","activityKey","metaPath","getMetaPath","userAction","clientAction","sender","id","userID","name","userDescription","initials","formatInitials","color","getUserColor","Join","JoinEcho","findIndex","user","push","Leave","filter","allActivities","removeUserActivities","bag","activity","p","Change","metaPaths","split","map","path","forEach","i","nesteedMessage","currentActivities","getActivityKey","key","update","Create","Delete","Activate","MessageBox","information","getText","navigate","Discard","initJSONModel","parts","length","slice","Undo","a","appComponent","getAppComponent","metaModel","currentPage","getCurrentPage","sideEffectsService","getSideEffectsService","currentContext","currentPath","getPath","currentMetaPath","changedDocument","deletedObjects","parentDeletedIndex","deletedObject","startsWith","onClose","targetContext","bindContext","getBoundContext","getController","_routing","navigateBackFromContext","activityPath","replace","sideEffects","$PropertyPath","entityType","getEntityTypeFromContext","entityTypeSideEffects","getODataEntitySideEffects","object","Object","relevantSideEffects","fromEntries","entries","x","SourceProperties","source","value","TargetProperties","targetProperty","requestSideEffects","editFlow","updateDocument","Promise","resolve","routing","rootViewController","getRootViewController","isFclEnabled","getRightmostView","CommonUtils","getTargetView","getRootContainer","substring","lastIndexOf"],"mappings":";AAAA;AACA;AACA;;;;;;;;;;;;;;;;;;AAmBA,MAAMA,UAAU,GAAG,2BAAnB;AACA,MAAMC,WAAW,GAAG,4BAApB;AACA,MAAMC,UAAU,GAAG,2BAAnB;;AAEO,MAAMC,WAAW,GAAG,UAAUC,OAAV,EAAqC;AAC/D,QAAMC,aAAa,GAAGD,OAAO,CAACE,QAAR,CAAiB,UAAjB,CAAtB;AACA,WAAOC,wBAAwB,CAACF,aAAD,CAA/B;AACA,GAHM;;;;AAKA,MAAMG,IAAI,GAAG,UAAUJ,OAAV,EAA4BK,MAA5B,EAA8CC,OAA9C,EAAsF;AACzG,QAAIP,WAAW,CAACC,OAAD,CAAf,EAA0B;AACzB,UAAMC,aAAa,GAAGD,OAAO,CAACE,QAAR,CAAiB,UAAjB,CAAtB;AACA,UAAMK,aAAa,GAAGC,KAAK,CAACC,OAAN,CAAcH,OAAd,IAAyBA,OAAO,CAACI,IAAR,CAAa,GAAb,CAAzB,GAA6CJ,OAAnE;;AAEA,UAAID,MAAM,KAAKM,QAAQ,CAACC,UAAxB,EAAoC;AACnC;AACA,YAAMC,UAAU,GAAGZ,aAAa,CAACa,WAAd,CAA0BlB,UAA1B,CAAnB;;AACA,YAAIiB,UAAU,KAAKN,aAAnB,EAAkC;AACjC;AACA,SAFD,MAEO;AACNN,UAAAA,aAAa,CAACc,WAAd,CAA0BnB,UAA1B,EAAsCW,aAAtC;AACA;AACD,OARD,MAQO;AACN;AACAN,QAAAA,aAAa,CAACc,WAAd,CAA0BnB,UAA1B,EAAsC,IAAtC;AACA;;AAEDoB,MAAAA,6BAA6B,CAACX,MAAD,EAASE,aAAT,EAAwBN,aAAxB,CAA7B;AACA;AACD,GApBM;;;;AAsBP,MAAMgB,mBAAmB,GAAG,UAAUC,cAAV,EAA2C;AACtE,WAAOA,cAAc,CAAChB,QAAf,GAA0BiB,YAA1B,GAAyCC,SAAzC,CAAmD,mDAAnD,CAAP;AACA,GAFD;;AAIO,MAAMC,sBAAsB,GAAG,UAAUC,IAAV,EAA+B;AACpE,QAAMJ,cAAc,GAAG,CAAAI,IAAI,SAAJ,IAAAA,IAAI,WAAJ,YAAAA,IAAI,CAAEC,iBAAN,KAA4BD,IAAI,CAACC,iBAAL,EAAnD;AACA,WAAO,CAAC,EAAEL,cAAc,IAAID,mBAAmB,CAACC,cAAD,CAAvC,CAAR;AACA,GAHM;;;;AAKA,MAAMM,OAAO,aAAmBF,IAAnB;AAAA,QAA+B;AAClD,UAAMrB,aAAa,GAAGqB,IAAI,CAACpB,QAAL,CAAc,UAAd,CAAtB;AACA,UAAMuB,EAAE,GAAGC,kBAAkB,CAACC,KAAnB,CAAyBL,IAAzB,CAAX,CAFkD,CAIlD;;AACA,UAAI,CAACG,EAAL,EAAS;AACR;AACA;AACA;;AAED,UAAMP,cAAc,GAAGI,IAAI,CAACC,iBAAL,EAAvB;AACA,UAAMK,gBAAgB,GAAGX,mBAAmB,CAACC,cAAD,CAA5C;;AAEA,UAAI,CAACU,gBAAL,EAAuB;AACtB;AACA;;AAfiD,6BAiBzBV,cAAc,CAACW,eAAf,CAA+B,mCAA/B,CAjByB,iBAiB5CC,UAjB4C;AAkBlD,YAAI,CAACA,UAAL,EAAiB;AAChB;AACA;;AAEDC,QAAAA,uBAAuB,CAACN,EAAD,EAAKG,gBAAL,EAAuBE,UAAvB,EAAmC7B,aAAnC,EAAkD,UAAC+B,OAAD,EAAsB;AAC9FC,UAAAA,cAAc,CAACD,OAAD,EAAUV,IAAV,CAAd;AACA,SAFsB,CAAvB;AAtBkD;AAyBlD,KAzBmB;AAAA;AAAA;AAAA,GAAb;;;;AA2BA,MAAMY,UAAU,GAAG,UAAUlC,OAAV,EAA4B;AACrD,QAAMC,aAAa,GAAGD,OAAO,CAACE,QAAR,CAAiB,UAAjB,CAAtB;AACAiC,IAAAA,gBAAgB,CAAClC,aAAD,CAAhB;AACA,GAHM;;;;AAKP,WAASgC,cAAT,CAAwBD,OAAxB,EAA0CV,IAA1C,EAAsD;AAAA;;AACrD,QAAMrB,aAAkB,GAAGqB,IAAI,CAACpB,QAAL,CAAc,UAAd,CAA3B;AACA,QAAIkC,WAAmB,GAAGnC,aAAa,CAACa,WAAd,CAA0BjB,WAA1B,CAA1B;AACA,QAAIwC,UAAJ;AACA,QAAIC,WAAJ;AACA,QAAMC,QAAgB,GAAGP,OAAO,CAACzB,aAAR,IAA0Be,IAAI,CAACpB,QAAL,GAAgBiB,YAAhB,EAAD,CAAmDqB,WAAnD,CAA+DR,OAAO,CAACzB,aAAvE,CAAlD;AACAyB,IAAAA,OAAO,CAACS,UAAR,GAAqBT,OAAO,CAACS,UAAR,IAAsBT,OAAO,CAACU,YAAnD;AAEA,QAAMC,MAAY,GAAG;AACpBC,MAAAA,EAAE,EAAEZ,OAAO,CAACa,MADQ;AAEpBC,MAAAA,IAAI,EAAEd,OAAO,CAACe,eAFM;AAGpBC,MAAAA,QAAQ,EAAEtB,kBAAkB,CAACuB,cAAnB,CAAkCjB,OAAO,CAACe,eAA1C,CAHU;AAIpBG,MAAAA,KAAK,EAAExB,kBAAkB,CAACyB,YAAnB,CAAgCnB,OAAO,CAACa,MAAxC,EAAgDT,WAAhD,EAA6D,EAA7D;AAJa,KAArB,CARqD,CAerD;;AACA,YAAQJ,OAAO,CAACS,UAAhB;AACC,WAAK9B,QAAQ,CAACyC,IAAd;AACA,WAAKzC,QAAQ,CAAC0C,QAAd;AACC,YAAIjB,WAAW,CAACkB,SAAZ,CAAsB,UAACC,IAAD;AAAA,iBAAUA,IAAI,CAACX,EAAL,KAAYD,MAAM,CAACC,EAA7B;AAAA,SAAtB,MAA2D,CAAC,CAAhE,EAAmE;AAClER,UAAAA,WAAW,CAACoB,IAAZ,CAAiBb,MAAjB;AACA1C,UAAAA,aAAa,CAACc,WAAd,CAA0BlB,WAA1B,EAAuCuC,WAAvC;AACA;;AAED,YAAIJ,OAAO,CAACS,UAAR,KAAuB9B,QAAQ,CAACyC,IAApC,EAA0C;AACzC;AACApC,UAAAA,6BAA6B,CAACL,QAAQ,CAAC0C,QAAV,EAAoBpD,aAAa,CAACa,WAAd,CAA0BlB,UAA1B,CAApB,EAA2DK,aAA3D,CAA7B;AACA;;AAED,YAAI+B,OAAO,CAACS,UAAR,KAAuB9B,QAAQ,CAAC0C,QAApC,EAA8C;AAC7C,cAAIrB,OAAO,CAACzB,aAAZ,EAA2B;AAC1B;AACAyB,YAAAA,OAAO,CAACS,UAAR,GAAqB9B,QAAQ,CAACC,UAA9B;AACAqB,YAAAA,cAAc,CAACD,OAAD,EAAUV,IAAV,CAAd;AACA;AACD;;AAED;;AACD,WAAKX,QAAQ,CAAC8C,KAAd;AACC;AACArB,QAAAA,WAAW,GAAGA,WAAW,CAACsB,MAAZ,CAAmB,UAACH,IAAD;AAAA,iBAAUA,IAAI,CAACX,EAAL,KAAYD,MAAM,CAACC,EAAnB,IAAyBW,IAAI,CAAC9B,EAAxC;AAAA,SAAnB,CAAd;AACAxB,QAAAA,aAAa,CAACc,WAAd,CAA0BlB,WAA1B,EAAuCuC,WAAvC;AACA,YAAMuB,aAAa,GAAG1D,aAAa,CAACa,WAAd,CAA0BhB,UAA1B,KAAyC,EAA/D;;AACA,YAAM8D,oBAAoB,GAAG,UAAUC,GAAV,EAAoB;AAChD,cAAIrD,KAAK,CAACC,OAAN,CAAcoD,GAAd,CAAJ,EAAwB;AACvB,mBAAOA,GAAG,CAACH,MAAJ,CAAW,UAACI,QAAD;AAAA,qBAAcA,QAAQ,CAAClB,EAAT,KAAgBD,MAAM,CAACC,EAArC;AAAA,aAAX,CAAP;AACA,WAFD,MAEO;AACN,iBAAK,IAAMmB,CAAX,IAAgBF,GAAhB,EAAqB;AACpBA,cAAAA,GAAG,CAACE,CAAD,CAAH,GAASH,oBAAoB,CAACC,GAAG,CAACE,CAAD,CAAJ,CAA7B;AACA;;AACD,mBAAOF,GAAP;AACA;AACD,SATD;;AAUAD,QAAAA,oBAAoB,CAACD,aAAD,CAApB;AACA1D,QAAAA,aAAa,CAACc,WAAd,CAA0BjB,UAA1B,EAAsC6D,aAAtC;AACA;;AAED,WAAKhD,QAAQ,CAACqD,MAAd;AACC,YAAMC,SAAS,GAAGjC,OAAH,aAAGA,OAAH,gDAAGA,OAAO,CAAEzB,aAAZ,0DAAG,sBAAwB2D,KAAxB,CAA8B,GAA9B,EAAmCC,GAAnC,CAAuC,UAACC,IAAD,EAAU;AAClE,iBAAQ9C,IAAI,CAACpB,QAAL,GAAgBiB,YAAhB,EAAD,CAAmDqB,WAAnD,CAA+D4B,IAA/D,CAAP;AACA,SAFiB,CAAlB;AAIAH,QAAAA,SAAS,CAACI,OAAV,CAAkB,UAAC9B,QAAD,EAAW+B,CAAX,EAAiB;AAAA;;AAClC,cAAMC,cAAc,mCAChBvC,OADgB;AAEnBzB,YAAAA,aAAa,EAAEyB,OAAF,aAAEA,OAAF,iDAAEA,OAAO,CAAEzB,aAAX,2DAAE,uBAAwB2D,KAAxB,CAA8B,GAA9B,EAAmCI,CAAnC;AAFI,YAApB;;AAIA,cAAIE,iBAAwB,GAAGvE,aAAa,CAACa,WAAd,CAA0BhB,UAAU,GAAGyC,QAAvC,KAAoD,EAAnF;AACAD,UAAAA,WAAW,GAAGmC,cAAc,CAACF,cAAc,CAAChE,aAAhB,CAA5B;AACAiE,UAAAA,iBAAiB,GAAG,uBAAAA,iBAAiB,UAAjB,gEAAmBd,MAAnB,KAA6Bc,iBAAiB,CAACd,MAAlB,CAAyB,UAACI,QAAD;AAAA,mBAAcA,QAAQ,CAACY,GAAT,KAAiBpC,WAA/B;AAAA,WAAzB,CAAjD;;AACA,cAAIkC,iBAAJ,EAAuB;AACtBvE,YAAAA,aAAa,CAACc,WAAd,CAA0BjB,UAAU,GAAGyC,QAAvC,EAAiDiC,iBAAjD;AACAG,YAAAA,MAAM,CAACrD,IAAD,EAAOiD,cAAP,EAAuBhC,QAAvB,EAAiC5B,QAAQ,CAACqD,MAA1C,CAAN;AACA;AACD,SAZD;AAaA;;AACD,WAAKrD,QAAQ,CAACiE,MAAd;AACC;AACAD,QAAAA,MAAM,CAACrD,IAAD,EAAOU,OAAP,EAAgBO,QAAhB,EAA0B5B,QAAQ,CAACiE,MAAnC,CAAN;AACA;;AACD,WAAKjE,QAAQ,CAACkE,MAAd;AACC;AACAF,QAAAA,MAAM,CAACrD,IAAD,EAAOU,OAAP,EAAgBO,QAAhB,EAA0B5B,QAAQ,CAACkE,MAAnC,CAAN;AACA;;AACD,WAAKlE,QAAQ,CAACmE,QAAd;AACC5C,QAAAA,UAAU,CAACZ,IAAD,CAAV;AACAyD,QAAAA,UAAU,CAACC,WAAX,CAAuBtD,kBAAkB,CAACuD,OAAnB,CAA2B,+BAA3B,EAA4DtC,MAAM,CAACG,IAAnE,CAAvB;AACAoC,QAAAA,QAAQ,CAAClD,OAAO,CAACzB,aAAT,EAAwBe,IAAxB,CAAR;AACA;;AACD,WAAKX,QAAQ,CAACwE,OAAd;AACCjD,QAAAA,UAAU,CAACZ,IAAD,CAAV;AACAyD,QAAAA,UAAU,CAACC,WAAX,CAAuBtD,kBAAkB,CAACuD,OAAnB,CAA2B,8BAA3B,EAA2DtC,MAAM,CAACG,IAAlE,CAAvB;AACAoC,QAAAA,QAAQ,CAAClD,OAAO,CAACzB,aAAT,EAAwBe,IAAxB,CAAR;AACA;;AACD;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;AACE,WAAKX,QAAQ,CAACC,UAAd;AACC,YAAMkD,QAAsB,GAAGnB,MAA/B;AACAmB,QAAAA,QAAQ,CAACY,GAAT,GAAeD,cAAc,CAACzC,OAAO,CAACzB,aAAT,CAA7B,CAFD,CAIC;;AACA,YAAI6E,aAAqB,GAAG,EAA5B;AACA,YAAMC,KAAK,GAAG9C,QAAQ,CAAC2B,KAAT,CAAe,GAAf,CAAd;;AACA,aAAK,IAAII,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGe,KAAK,CAACC,MAAN,GAAe,CAAnC,EAAsChB,CAAC,EAAvC,EAA2C;AAC1Cc,UAAAA,aAAa,IAAI,MAAMC,KAAK,CAACf,CAAD,CAA5B;;AACA,cAAI,CAACrE,aAAa,CAACa,WAAd,CAA0BhB,UAAU,GAAGsF,aAAvC,CAAL,EAA4D;AAC3DnF,YAAAA,aAAa,CAACc,WAAd,CAA0BjB,UAAU,GAAGsF,aAAvC,EAAsD,EAAtD;AACA;AACD;;AAED/C,QAAAA,UAAU,GAAGpC,aAAa,CAACa,WAAd,CAA0BhB,UAAU,GAAGyC,QAAvC,CAAb;AACAF,QAAAA,UAAU,GAAG,eAAAA,UAAU,UAAV,0CAAYkD,KAAZ,GAAoBlD,UAAU,CAACkD,KAAX,EAApB,GAAyC,EAAtD;AACAlD,QAAAA,UAAU,CAACmB,IAAX,CAAgBM,QAAhB;AACA7D,QAAAA,aAAa,CAACc,WAAd,CAA0BjB,UAAU,GAAGyC,QAAvC,EAAiDF,UAAjD;AACA;;AACD,WAAK1B,QAAQ,CAAC6E,IAAd;AACC;AACAnD,QAAAA,UAAU,GAAGpC,aAAa,CAACa,WAAd,CAA0BhB,UAAU,GAAGyC,QAAvC,CAAb;AACAD,QAAAA,WAAW,GAAGmC,cAAc,CAACzC,OAAO,CAACzB,aAAT,CAA5B;AACAN,QAAAA,aAAa,CAACc,WAAd,CACCjB,UAAU,GAAGyC,QADd,EAECF,UAAU,CAACqB,MAAX,CAAkB,UAAC+B,CAAD;AAAA,iBAAOA,CAAC,CAACf,GAAF,KAAUpC,WAAjB;AAAA,SAAlB,CAFD;AAIA;AAjHF;AAmHA;;AAED,WAASqC,MAAT,CAAgBrD,IAAhB,EAA4BU,OAA5B,EAA8CO,QAA9C,EAAgElC,MAAhE,EAAkF;AACjF,QAAMqF,YAAY,GAAGhE,kBAAkB,CAACiE,eAAnB,CAAmCrE,IAAnC,CAArB;AACA,QAAMsE,SAAS,GAAGtE,IAAI,CAACpB,QAAL,GAAgBiB,YAAhB,EAAlB;AACA,QAAM0E,WAAW,GAAGC,cAAc,CAACxE,IAAD,CAAlC;AACA,QAAMyE,kBAAkB,GAAGL,YAAY,CAACM,qBAAb,EAA3B;AACA,QAAMC,cAAc,GAAGJ,WAAW,CAACtE,iBAAZ,EAAvB;AACA,QAAM2E,WAAW,GAAGD,cAAc,CAACE,OAAf,EAApB;AACA,QAAMC,eAAe,GAAGR,SAAS,CAACpD,WAAV,CAAsB0D,WAAtB,CAAxB;AACA,QAAIG,eAAe,GAAGrE,OAAO,CAACzB,aAA9B;;AAEA,QAAIF,MAAM,KAAKM,QAAQ,CAACkE,MAAxB,EAAgC;AAC/B;AACA,UAAMyB,cAAc,GAAGtE,OAAO,CAACzB,aAAR,CAAsB2D,KAAtB,CAA4B,GAA5B,CAAvB;AACA,UAAMqC,kBAAkB,GAAGD,cAAc,CAAChD,SAAf,CAAyB,UAACkD,aAAD;AAAA,eAAmBN,WAAW,CAACO,UAAZ,CAAuBD,aAAvB,CAAnB;AAAA,OAAzB,CAA3B;;AACA,UAAID,kBAAkB,GAAG,CAAC,CAA1B,EAA6B;AAC5B;AACAxB,QAAAA,UAAU,CAACC,WAAX,CAAuBtD,kBAAkB,CAACuD,OAAnB,CAA2B,6BAA3B,EAA0DjD,OAAO,CAACe,eAAlE,CAAvB,EAA2G;AAC1G2D,UAAAA,OAAO,EAAE,YAAY;AACpB,gBAAMC,aAAa,GAAGrF,IAAI,CAACpB,QAAL,GAAgB0G,WAAhB,CAA4BN,cAAc,CAACC,kBAAD,CAA1C,EAAgEM,eAAhE,EAAtB;;AACAhB,YAAAA,WAAW,CAACiB,aAAZ,GAA4BC,QAA5B,CAAqCC,uBAArC,CAA6DL,aAA7D;AACA;AAJyG,SAA3G;AAMA,OAZ8B,CAa/B;;;AACAN,MAAAA,eAAe,GAAGC,cAAc,CAAC,CAAD,CAAhC;AACA;;AAED,QAAID,eAAe,CAACI,UAAhB,CAA2BP,WAA3B,CAAJ,EAA6C;AAC5C;AACA,UAAMe,YAAY,GAAG1E,QAAQ,CAAC2E,OAAT,CAAiBd,eAAjB,EAAkC,EAAlC,EAAsCb,KAAtC,CAA4C,CAA5C,CAArB;;AACA,UAAI0B,YAAJ,EAAkB;AAAA;AACjB;AACA,cAAME,WAAkB,GAAG,CAC1B;AACCC,YAAAA,aAAa,EAAEH;AADhB,WAD0B,CAA3B;AAKA,cAAMI,UAAU,GAAGtB,kBAAkB,CAACuB,wBAAnB,CAA4CrB,cAA5C,CAAnB;AACA,cAAMsB,qBAAqB,GAAGxB,kBAAkB,CAACyB,yBAAnB,CAA6CH,UAA7C,CAA9B,CARiB,CASjB;;AACA,cAAMI,MAAW,GAAGC,MAApB,CAViB,CAUW;;AAC5B,cAAMC,mBAAmB,GAAGF,MAAM,CAACG,WAAP,CAC3BH,MAAM,CACJI,OADF,CACUN,qBADV,EAEE7D,MAFF,CAES,UAACoE,CAAD;AAAA;;AAAA,mBAAc,0BAAAA,CAAC,CAAC,CAAD,CAAD,CAAKC,gBAAL,gFAAuBzE,SAAvB,CAAiC,UAAC0E,MAAD;AAAA,qBAAiBA,MAAM,CAACC,KAAP,KAAiBhB,YAAlC;AAAA,aAAjC,KAAmF,CAAC,CAAlG;AAAA,WAFT,CAD2B,CAA5B;;AAKA,eAAK,IAAMlD,CAAX,IAAgB4D,mBAAhB,EAAqC;AACpCA,YAAAA,mBAAmB,CAAC5D,CAAD,CAAnB,CAAuBmE,gBAAvB,CAAwC7D,OAAxC,CAAgD,UAAU8D,cAAV,EAA+B;AAC9EhB,cAAAA,WAAW,CAAC3D,IAAZ,CAAiB;AAChB4D,gBAAAA,aAAa,EAAEe;AADC,eAAjB;AAGA,aAJD;AAKA;;AACDpC,UAAAA,kBAAkB,CAACqC,kBAAnB,CAAsCjB,WAAtC,EAAmDlB,cAAnD,EAAmE,OAAnE;AAvBiB;AAwBjB;AACD,KAvDgF,CAyDjF;;;AACAJ,IAAAA,WAAW,CAACiB,aAAZ,GAA4BuB,QAA5B,CAAqCC,cAArC,CAAoDrC,cAApD,EAAoEsC,OAAO,CAACC,OAAR,EAApE;AACA;;AAED,WAAStD,QAAT,CAAkBd,IAAlB,EAAgC9C,IAAhC,EAA4C;AAC3C;AACA,QAAMuE,WAAW,GAAGC,cAAc,CAACxE,IAAD,CAAlC;AACA,QAAMqF,aAAa,GAAGrF,IAAI,CAACpB,QAAL,GAAgB0G,WAAhB,CAA4BxC,IAA5B,EAAkCyC,eAAlC,EAAtB;AACAhB,IAAAA,WAAW,CAACiB,aAAZ,GAA4B2B,OAA5B,CAAoCvD,QAApC,CAA6CyB,aAA7C;AACA;;AAED,WAASb,cAAT,CAAwBxE,IAAxB,EAAoC;AACnC,QAAMoE,YAAY,GAAGhE,kBAAkB,CAACiE,eAAnB,CAAmCrE,IAAnC,CAArB;AACA,QAAMoH,kBAAkB,GAAGhD,YAAY,CAACiD,qBAAb,EAA3B;AACA,WAAOD,kBAAkB,CAACE,YAAnB,KACJF,kBAAkB,CAACG,gBAAnB,EADI,GAEJC,WAAW,CAACC,aAAZ,CAA2BrD,YAAY,CAACsD,gBAAb,EAAD,CAAyClD,cAAzC,EAA1B,CAFH;AAGA;;AAED,WAASrB,cAAT,CAAwBqD,CAAxB,EAA2C;AAC1C,WAAOA,CAAC,CAACmB,SAAF,CAAYnB,CAAC,CAACoB,WAAF,CAAc,GAAd,IAAqB,CAAjC,EAAoCpB,CAAC,CAACoB,WAAF,CAAc,GAAd,CAApC,CAAP;AACA;;SAEc;AACd1H,IAAAA,OAAO,EAAEA,OADK;AAEdU,IAAAA,UAAU,EAAEA,UAFE;AAGdnC,IAAAA,WAAW,EAAEA,WAHC;AAIdsB,IAAAA,sBAAsB,EAAEA,sBAJV;AAKdjB,IAAAA,IAAI,EAAEA;AALQ,G","sourceRoot":".","sourcesContent":["import CommonUtils from \"sap/fe/core/CommonUtils\";\nimport {\n\tbroadcastCollaborationMessage,\n\tendCollaboration,\n\tinitializeCollaboration,\n\tisCollaborationConnected\n} from \"sap/fe/core/controllerextensions/collaboration/ActivityBase\";\nimport {\n\tActivity,\n\tCollaborationUtils,\n\tMessage,\n\tUser,\n\tUserActivity\n} from \"sap/fe/core/controllerextensions/collaboration/CollaborationCommon\";\nimport MessageBox from \"sap/m/MessageBox\";\nimport Control from \"sap/ui/core/Control\";\nimport View from \"sap/ui/core/mvc/View\";\nimport JSONModel from \"sap/ui/model/json/JSONModel\";\nimport Context from \"sap/ui/model/odata/v4/Context\";\nimport ODataMetaModel from \"sap/ui/model/odata/v4/ODataMetaModel\";\n\nconst MYACTIVITY = \"/collaboration/myActivity\";\nconst ACTIVEUSERS = \"/collaboration/activeUsers\";\nconst ACTIVITIES = \"/collaboration/activities\";\n\nexport const isConnected = function (control: Control): boolean {\n\tconst internalModel = control.getModel(\"internal\") as JSONModel;\n\treturn isCollaborationConnected(internalModel);\n};\n\nexport const send = function (control: Control, action: Activity, content: string | string[] | undefined) {\n\tif (isConnected(control)) {\n\t\tconst internalModel = control.getModel(\"internal\") as JSONModel;\n\t\tconst clientContent = Array.isArray(content) ? content.join(\"|\") : content;\n\n\t\tif (action === Activity.LiveChange) {\n\t\t\t// To avoid unnecessary traffic we keep track of live changes and send it only once\n\t\t\tconst myActivity = internalModel.getProperty(MYACTIVITY);\n\t\t\tif (myActivity === clientContent) {\n\t\t\t\treturn;\n\t\t\t} else {\n\t\t\t\tinternalModel.setProperty(MYACTIVITY, clientContent);\n\t\t\t}\n\t\t} else {\n\t\t\t// user finished the activity\n\t\t\tinternalModel.setProperty(MYACTIVITY, null);\n\t\t}\n\n\t\tbroadcastCollaborationMessage(action, clientContent, internalModel);\n\t}\n};\n\nconst getWebSocketBaseURL = function (bindingContext: Context): string {\n\treturn bindingContext.getModel().getMetaModel().getObject(\"/@com.sap.vocabularies.Common.v1.WebSocketBaseURL\");\n};\n\nexport const isCollaborationEnabled = function (view: View): boolean {\n\tconst bindingContext = view?.getBindingContext && (view.getBindingContext() as Context);\n\treturn !!(bindingContext && getWebSocketBaseURL(bindingContext));\n};\n\nexport const connect = async function (view: View) {\n\tconst internalModel = view.getModel(\"internal\") as JSONModel;\n\tconst me = CollaborationUtils.getMe(view);\n\n\t// Retrieving ME from shell service\n\tif (!me) {\n\t\t// no me = no shell = not sure what to do\n\t\treturn;\n\t}\n\n\tconst bindingContext = view.getBindingContext() as Context;\n\tconst webSocketBaseURL = getWebSocketBaseURL(bindingContext);\n\n\tif (!webSocketBaseURL) {\n\t\treturn;\n\t}\n\n\tconst sDraftUUID = await bindingContext.requestProperty(\"DraftAdministrativeData/DraftUUID\");\n\tif (!sDraftUUID) {\n\t\treturn;\n\t}\n\n\tinitializeCollaboration(me, webSocketBaseURL, sDraftUUID, internalModel, (message: Message) => {\n\t\tmessageReceive(message, view);\n\t});\n};\n\nexport const disconnect = function (control: Control) {\n\tconst internalModel = control.getModel(\"internal\") as JSONModel;\n\tendCollaboration(internalModel);\n};\n\nfunction messageReceive(message: Message, view: View) {\n\tconst internalModel: any = view.getModel(\"internal\");\n\tlet activeUsers: User[] = internalModel.getProperty(ACTIVEUSERS);\n\tlet activities: UserActivity[];\n\tlet activityKey: string;\n\tconst metaPath: string = message.clientContent && (view.getModel().getMetaModel() as ODataMetaModel).getMetaPath(message.clientContent);\n\tmessage.userAction = message.userAction || message.clientAction;\n\n\tconst sender: User = {\n\t\tid: message.userID,\n\t\tname: message.userDescription,\n\t\tinitials: CollaborationUtils.formatInitials(message.userDescription),\n\t\tcolor: CollaborationUtils.getUserColor(message.userID, activeUsers, [])\n\t};\n\n\t// eslint-disable-next-line default-case\n\tswitch (message.userAction) {\n\t\tcase Activity.Join:\n\t\tcase Activity.JoinEcho:\n\t\t\tif (activeUsers.findIndex((user) => user.id === sender.id) === -1) {\n\t\t\t\tactiveUsers.push(sender);\n\t\t\t\tinternalModel.setProperty(ACTIVEUSERS, activeUsers);\n\t\t\t}\n\n\t\t\tif (message.userAction === Activity.Join) {\n\t\t\t\t// we echo our existence to the newly entered user and also send the current activity if there is any\n\t\t\t\tbroadcastCollaborationMessage(Activity.JoinEcho, internalModel.getProperty(MYACTIVITY), internalModel);\n\t\t\t}\n\n\t\t\tif (message.userAction === Activity.JoinEcho) {\n\t\t\t\tif (message.clientContent) {\n\t\t\t\t\t// another user was already typing therefore I want to see his activity immediately. Calling me again as a live change\n\t\t\t\t\tmessage.userAction = Activity.LiveChange;\n\t\t\t\t\tmessageReceive(message, view);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tbreak;\n\t\tcase Activity.Leave:\n\t\t\t// Removing the active user. Not removing \"me\" if I had the screen open in another session\n\t\t\tactiveUsers = activeUsers.filter((user) => user.id !== sender.id || user.me);\n\t\t\tinternalModel.setProperty(ACTIVEUSERS, activeUsers);\n\t\t\tconst allActivities = internalModel.getProperty(ACTIVITIES) || {};\n\t\t\tconst removeUserActivities = function (bag: any) {\n\t\t\t\tif (Array.isArray(bag)) {\n\t\t\t\t\treturn bag.filter((activity) => activity.id !== sender.id);\n\t\t\t\t} else {\n\t\t\t\t\tfor (const p in bag) {\n\t\t\t\t\t\tbag[p] = removeUserActivities(bag[p]);\n\t\t\t\t\t}\n\t\t\t\t\treturn bag;\n\t\t\t\t}\n\t\t\t};\n\t\t\tremoveUserActivities(allActivities);\n\t\t\tinternalModel.setProperty(ACTIVITIES, allActivities);\n\t\t\tbreak;\n\n\t\tcase Activity.Change:\n\t\t\tconst metaPaths = message?.clientContent?.split(\"|\").map((path) => {\n\t\t\t\treturn (view.getModel().getMetaModel() as ODataMetaModel).getMetaPath(path);\n\t\t\t});\n\n\t\t\tmetaPaths.forEach((metaPath, i) => {\n\t\t\t\tconst nesteedMessage = {\n\t\t\t\t\t...message,\n\t\t\t\t\tclientContent: message?.clientContent?.split(\"|\")[i]\n\t\t\t\t};\n\t\t\t\tlet currentActivities: any[] = internalModel.getProperty(ACTIVITIES + metaPath) || [];\n\t\t\t\tactivityKey = getActivityKey(nesteedMessage.clientContent);\n\t\t\t\tcurrentActivities = currentActivities?.filter && currentActivities.filter((activity) => activity.key !== activityKey);\n\t\t\t\tif (currentActivities) {\n\t\t\t\t\tinternalModel.setProperty(ACTIVITIES + metaPath, currentActivities);\n\t\t\t\t\tupdate(view, nesteedMessage, metaPath, Activity.Change);\n\t\t\t\t}\n\t\t\t});\n\t\t\tbreak;\n\t\tcase Activity.Create:\n\t\t\t// For create we actually just need to refresh the table\n\t\t\tupdate(view, message, metaPath, Activity.Create);\n\t\t\tbreak;\n\t\tcase Activity.Delete:\n\t\t\t// For now also refresh the page but in case of deletion we need to inform the user\n\t\t\tupdate(view, message, metaPath, Activity.Delete);\n\t\t\tbreak;\n\t\tcase Activity.Activate:\n\t\t\tdisconnect(view);\n\t\t\tMessageBox.information(CollaborationUtils.getText(\"C_COLLABORATIONDRAFT_ACTIVATE\", sender.name));\n\t\t\tnavigate(message.clientContent, view);\n\t\t\tbreak;\n\t\tcase Activity.Discard:\n\t\t\tdisconnect(view);\n\t\t\tMessageBox.information(CollaborationUtils.getText(\"C_COLLABORATIONDRAFT_DISCARD\", sender.name));\n\t\t\tnavigate(message.clientContent, view);\n\t\t\tbreak;\n\t\t/*\n\t\t// TODO: Action to be implemented\n\t\tcase Activity.Action:\n\t\t\t// Just for test reasons show a toast - to be checked with UX\n\t\t\tMessageToast.show(\"User \" + sender.name + \" has executed action \" + metaPath.split(\"|\")[0]);\n\t\t\t//update(view, message, metaPath, Activity.Delete);\n\t\t\tbreak;\n\t\t */\n\t\tcase Activity.LiveChange:\n\t\t\tconst activity: UserActivity = sender;\n\t\t\tactivity.key = getActivityKey(message.clientContent);\n\n\t\t\t// stupid JSON model...\n\t\t\tlet initJSONModel: string = \"\";\n\t\t\tconst parts = metaPath.split(\"/\");\n\t\t\tfor (let i = 1; i < parts.length - 1; i++) {\n\t\t\t\tinitJSONModel += \"/\" + parts[i];\n\t\t\t\tif (!internalModel.getProperty(ACTIVITIES + initJSONModel)) {\n\t\t\t\t\tinternalModel.setProperty(ACTIVITIES + initJSONModel, {});\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tactivities = internalModel.getProperty(ACTIVITIES + metaPath);\n\t\t\tactivities = activities?.slice ? activities.slice() : [];\n\t\t\tactivities.push(activity);\n\t\t\tinternalModel.setProperty(ACTIVITIES + metaPath, activities);\n\t\t\tbreak;\n\t\tcase Activity.Undo:\n\t\t\t// The user did a change but reverted it, therefore unblock the control\n\t\t\tactivities = internalModel.getProperty(ACTIVITIES + metaPath);\n\t\t\tactivityKey = getActivityKey(message.clientContent);\n\t\t\tinternalModel.setProperty(\n\t\t\t\tACTIVITIES + metaPath,\n\t\t\t\tactivities.filter((a) => a.key !== activityKey)\n\t\t\t);\n\t\t\tbreak;\n\t}\n}\n\nfunction update(view: View, message: Message, metaPath: string, action: Activity) {\n\tconst appComponent = CollaborationUtils.getAppComponent(view);\n\tconst metaModel = view.getModel().getMetaModel() as ODataMetaModel;\n\tconst currentPage = getCurrentPage(view);\n\tconst sideEffectsService = appComponent.getSideEffectsService();\n\tconst currentContext = currentPage.getBindingContext();\n\tconst currentPath = currentContext.getPath();\n\tconst currentMetaPath = metaModel.getMetaPath(currentPath);\n\tlet changedDocument = message.clientContent;\n\n\tif (action === Activity.Delete) {\n\t\t// check if user currently displays one deleted object\n\t\tconst deletedObjects = message.clientContent.split(\"|\");\n\t\tconst parentDeletedIndex = deletedObjects.findIndex((deletedObject) => currentPath.startsWith(deletedObject));\n\t\tif (parentDeletedIndex > -1) {\n\t\t\t// any other user deleted the object I'm currently looking at. Inform the user we will navigate to root now\n\t\t\tMessageBox.information(CollaborationUtils.getText(\"C_COLLABORATIONDRAFT_DELETE\", message.userDescription), {\n\t\t\t\tonClose: function () {\n\t\t\t\t\tconst targetContext = view.getModel().bindContext(deletedObjects[parentDeletedIndex]).getBoundContext();\n\t\t\t\t\tcurrentPage.getController()._routing.navigateBackFromContext(targetContext);\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\t// TODO: For now just take the first object to get the meta path and do a full refresh of the table\n\t\tchangedDocument = deletedObjects[0];\n\t}\n\n\tif (changedDocument.startsWith(currentPath)) {\n\t\t// Execute SideEffects (TODO for Meet there should be one central method)\n\t\tconst activityPath = metaPath.replace(currentMetaPath, \"\").slice(1);\n\t\tif (activityPath) {\n\t\t\t// Request also the property itself\n\t\t\tconst sideEffects: any[] = [\n\t\t\t\t{\n\t\t\t\t\t$PropertyPath: activityPath\n\t\t\t\t}\n\t\t\t];\n\t\t\tconst entityType = sideEffectsService.getEntityTypeFromContext(currentContext);\n\t\t\tconst entityTypeSideEffects = sideEffectsService.getODataEntitySideEffects(entityType!);\n\t\t\t// Poor man solution without checking source targets, just for POC, this is throw-way coding only\n\t\t\tconst object: any = Object; // just to overcome TS issues, will be anyway replaced\n\t\t\tconst relevantSideEffects = object.fromEntries(\n\t\t\t\tobject\n\t\t\t\t\t.entries(entityTypeSideEffects)\n\t\t\t\t\t.filter((x: any[]) => x[1].SourceProperties?.findIndex((source: any) => source.value === activityPath) > -1)\n\t\t\t);\n\t\t\tfor (const p in relevantSideEffects) {\n\t\t\t\trelevantSideEffects[p].TargetProperties.forEach(function (targetProperty: any) {\n\t\t\t\t\tsideEffects.push({\n\t\t\t\t\t\t$PropertyPath: targetProperty\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t}\n\t\t\tsideEffectsService.requestSideEffects(sideEffects, currentContext, \"$auto\");\n\t\t}\n\t}\n\n\t// Simulate any change so the edit flow shows the draft indicator and sets the page to dirty\n\tcurrentPage.getController().editFlow.updateDocument(currentContext, Promise.resolve());\n}\n\nfunction navigate(path: string, view: View) {\n\t// TODO: routing.navigate doesn't consider semantic bookmarking\n\tconst currentPage = getCurrentPage(view);\n\tconst targetContext = view.getModel().bindContext(path).getBoundContext();\n\tcurrentPage.getController().routing.navigate(targetContext);\n}\n\nfunction getCurrentPage(view: View) {\n\tconst appComponent = CollaborationUtils.getAppComponent(view);\n\tconst rootViewController = appComponent.getRootViewController() as any;\n\treturn rootViewController.isFclEnabled()\n\t\t? rootViewController.getRightmostView()\n\t\t: CommonUtils.getTargetView((appComponent.getRootContainer() as any).getCurrentPage());\n}\n\nfunction getActivityKey(x: string): string {\n\treturn x.substring(x.lastIndexOf(\"(\") + 1, x.lastIndexOf(\")\"));\n}\n\nexport default {\n\tconnect: connect,\n\tdisconnect: disconnect,\n\tisConnected: isConnected,\n\tisCollaborationEnabled: isCollaborationEnabled,\n\tsend: send\n};\n"]}