@sapui5/sap.fe.core 1.110.0 → 1.111.0

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

@@ -0,0 +1,314 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2023 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/Log", "sap/fe/core/CommonUtils", "sap/fe/core/controllerextensions/collaboration/ActivityBase", "sap/fe/core/controllerextensions/collaboration/CollaborationCommon", "sap/m/MessageBox"], function (Log, 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;
+  const MYACTIVITY = "/collaboration/myActivity";
+  const ACTIVEUSERS = "/collaboration/activeUsers";
+  const ACTIVITIES = "/collaboration/activities";
+  const SYNCGROUPID = "$auto.sync";
+  const isConnected = function (control) {
+    const internalModel = control.getModel("internal");
+    return isCollaborationConnected(internalModel);
+  };
+  _exports.isConnected = isConnected;
+  const send = function (control, action, content, triggeredActionName) {
+    if (isConnected(control)) {
+      const internalModel = control.getModel("internal");
+      const clientContent = Array.isArray(content) ? content.join("|") : content;
+      const myActivity = internalModel.getProperty(MYACTIVITY);
+      if (action === Activity.LiveChange) {
+        // To avoid unnecessary traffic we keep track of live changes and send it only once
+
+        if (myActivity === clientContent) {
+          return;
+        } else {
+          internalModel.setProperty(MYACTIVITY, clientContent);
+        }
+      } else {
+        // No need to send an Undo message if there's no current activity
+        if (action === Activity.Undo && myActivity === null) {
+          return;
+        }
+
+        // user finished the activity
+        internalModel.setProperty(MYACTIVITY, null);
+      }
+      broadcastCollaborationMessage(action, clientContent, internalModel, triggeredActionName);
+    }
+  };
+  _exports.send = send;
+  const getWebSocketBaseURL = function (bindingContext) {
+    return bindingContext.getModel().getMetaModel().getObject("/@com.sap.vocabularies.Common.v1.WebSocketBaseURL");
+  };
+  const isCollaborationEnabled = function (view) {
+    const bindingContext = (view === null || view === void 0 ? void 0 : view.getBindingContext) && view.getBindingContext();
+    return !!(bindingContext && getWebSocketBaseURL(bindingContext));
+  };
+  _exports.isCollaborationEnabled = isCollaborationEnabled;
+  const connect = async function (view) {
+    const internalModel = view.getModel("internal");
+    const me = CollaborationUtils.getMe(view);
+
+    // Retrieving ME from shell service
+    if (!me) {
+      // no me = no shell = not sure what to do
+      return;
+    }
+    const bindingContext = view.getBindingContext();
+    const webSocketBaseURL = getWebSocketBaseURL(bindingContext);
+    const serviceUrl = bindingContext.getModel().getServiceUrl();
+    if (!webSocketBaseURL) {
+      return;
+    }
+    const sDraftUUID = await bindingContext.requestProperty("DraftAdministrativeData/DraftUUID");
+    if (!sDraftUUID) {
+      return;
+    }
+    initializeCollaboration(me, webSocketBaseURL, sDraftUUID, serviceUrl, internalModel, message => {
+      messageReceive(message, view);
+    });
+  };
+  _exports.connect = connect;
+  const disconnect = function (control) {
+    const internalModel = control.getModel("internal");
+    endCollaboration(internalModel);
+  };
+  _exports.disconnect = disconnect;
+  function messageReceive(message, view) {
+    var _message$clientConten, _activities;
+    const internalModel = view.getModel("internal");
+    let activeUsers = internalModel.getProperty(ACTIVEUSERS);
+    let activities;
+    let activityKey;
+    const metaPath = calculateMetaPath(view, message.clientContent);
+    message.userAction = message.userAction || message.clientAction;
+    const sender = {
+      id: message.userID,
+      name: message.userDescription,
+      initials: CollaborationUtils.formatInitials(message.userDescription),
+      color: CollaborationUtils.getUserColor(message.userID, activeUsers, [])
+    };
+    let mactivity = sender;
+
+    // eslint-disable-next-line default-case
+    switch (message.userAction) {
+      case Activity.Join:
+      case Activity.JoinEcho:
+        if (activeUsers.findIndex(user => user.id === sender.id) === -1) {
+          activeUsers.unshift(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(user => user.id !== sender.id || user.me);
+        internalModel.setProperty(ACTIVEUSERS, activeUsers);
+        const allActivities = internalModel.getProperty(ACTIVITIES) || {};
+        const removeUserActivities = function (bag) {
+          if (Array.isArray(bag)) {
+            return bag.filter(activity => activity.id !== sender.id);
+          } else {
+            for (const p in bag) {
+              bag[p] = removeUserActivities(bag[p]);
+            }
+            return bag;
+          }
+        };
+        removeUserActivities(allActivities);
+        internalModel.setProperty(ACTIVITIES, allActivities);
+        break;
+      case Activity.Change:
+        const metaPaths = message === null || message === void 0 ? void 0 : (_message$clientConten = message.clientContent) === null || _message$clientConten === void 0 ? void 0 : _message$clientConten.split("|").map(path => {
+          return view.getModel().getMetaModel().getMetaPath(path);
+        });
+        metaPaths.forEach((currentMetaPath, i) => {
+          var _message$clientConten2, _currentActivities;
+          const nesteedMessage = {
+            ...message,
+            clientContent: message === null || message === void 0 ? void 0 : (_message$clientConten2 = message.clientContent) === null || _message$clientConten2 === void 0 ? void 0 : _message$clientConten2.split("|")[i]
+          };
+          let currentActivities = internalModel.getProperty(ACTIVITIES + currentMetaPath) || [];
+          activityKey = getActivityKey(nesteedMessage.clientContent);
+          currentActivities = ((_currentActivities = currentActivities) === null || _currentActivities === void 0 ? void 0 : _currentActivities.filter) && currentActivities.filter(activity => activity.key !== activityKey);
+          if (currentActivities) {
+            internalModel.setProperty(ACTIVITIES + currentMetaPath, currentActivities);
+            update(view, nesteedMessage, currentMetaPath, 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:
+        draftClosedByOtherUser(view, message, CollaborationUtils.getText("C_COLLABORATIONDRAFT_ACTIVATE", sender.name));
+        break;
+      case Activity.Discard:
+        draftClosedByOtherUser(view, message, CollaborationUtils.getText("C_COLLABORATIONDRAFT_DISCARD", sender.name));
+        break;
+      case Activity.Action:
+        update(view, message, metaPath, Activity.Action);
+        break;
+      case Activity.LiveChange:
+        mactivity = sender;
+        mactivity.key = getActivityKey(message.clientContent);
+
+        // stupid JSON model...
+        let initJSONModel = "";
+        const parts = metaPath.split("/");
+        for (let 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(mactivity);
+        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(a => a.key !== activityKey));
+        break;
+    }
+  }
+  function draftClosedByOtherUser(view, message, text) {
+    disconnect(view);
+    MessageBox.information(text);
+    view.getBindingContext().getBinding().resetChanges().then(function () {
+      navigate(message.clientContent, view);
+    }).catch(function () {
+      Log.error("Pending Changes could not be reset - still navigating to active instance");
+      navigate(message.clientContent, view);
+    });
+  }
+  function update(view, message, metaPath, action) {
+    const appComponent = CollaborationUtils.getAppComponent(view);
+    const metaModel = view.getModel().getMetaModel();
+    const currentPage = getCurrentPage(view);
+    const sideEffectsService = appComponent.getSideEffectsService();
+    const currentContext = currentPage.getBindingContext();
+    const currentPath = currentContext.getPath();
+    const currentMetaPath = metaModel.getMetaPath(currentPath);
+    let changedDocument = message.clientContent;
+    if (action === Activity.Delete) {
+      // check if user currently displays one deleted object
+      const deletedObjects = message.clientContent.split("|");
+      const parentDeletedIndex = deletedObjects.findIndex(deletedObject => 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 () {
+            const 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 (action === Activity.Action) {
+      const actionName = message.clientTriggeredActionName,
+        bindingParameters = sideEffectsService.getODataActionSideEffects(actionName, currentContext),
+        targetPaths = bindingParameters === null || bindingParameters === void 0 ? void 0 : bindingParameters.pathExpressions;
+      if (targetPaths && targetPaths.length > 0) {
+        sideEffectsService.requestSideEffects(targetPaths, currentContext, SYNCGROUPID);
+      }
+    }
+    if (changedDocument.startsWith(currentPath)) {
+      // Execute SideEffects (TODO for Meet there should be one central method)
+      const activityPath = metaPath.replace(currentMetaPath, "").slice(1);
+      if (activityPath) {
+        // Request also the property itself
+        const sideEffects = [{
+          $PropertyPath: activityPath
+        }];
+        const entityType = sideEffectsService.getEntityTypeFromContext(currentContext);
+        const entityTypeSideEffects = sideEffectsService.getODataEntitySideEffects(entityType);
+        // Poor man solution without checking source targets, just for POC, this is throw-way coding only
+        const object = Object; // just to overcome TS issues, will be anyway replaced
+        const relevantSideEffects = object.fromEntries(object.entries(entityTypeSideEffects).filter(x => {
+          var _x$1$SourceProperties;
+          return ((_x$1$SourceProperties = x[1].SourceProperties) === null || _x$1$SourceProperties === void 0 ? void 0 : _x$1$SourceProperties.findIndex(source => source.value === activityPath)) > -1;
+        }));
+        for (const p in relevantSideEffects) {
+          relevantSideEffects[p].TargetProperties.forEach(function (targetProperty) {
+            sideEffects.push({
+              $PropertyPath: targetProperty
+            });
+          });
+        }
+        sideEffectsService.requestSideEffects(sideEffects, currentContext, SYNCGROUPID);
+      }
+    }
+
+    // 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
+    const currentPage = getCurrentPage(view);
+    const targetContext = view.getModel().bindContext(path).getBoundContext();
+    currentPage.getController().routing.navigate(targetContext);
+  }
+  function getCurrentPage(view) {
+    const appComponent = CollaborationUtils.getAppComponent(view);
+    return CommonUtils.getCurrentPageView(appComponent);
+  }
+  function getActivityKey(x) {
+    return x.substring(x.lastIndexOf("(") + 1, x.lastIndexOf(")"));
+  }
+
+  /**
+   * Calculates the metapath from one or more data path(s).
+   *
+   * @param view The current view
+   * @param path One ore more data path(s), in case of multiple paths separated by '|'
+   * @returns The calculated metaPath
+   */
+  function calculateMetaPath(view, path) {
+    let metaPath = "";
+    if (path) {
+      // in case more than one path is sent all of them have to use the same metapath therefore we just consider the first one
+      const dataPath = path.split("|")[0];
+      metaPath = view.getModel().getMetaModel().getMetaPath(dataPath);
+    }
+    return metaPath;
+  }
+  return {
+    connect: connect,
+    disconnect: disconnect,
+    isConnected: isConnected,
+    isCollaborationEnabled: isCollaborationEnabled,
+    send: send
+  };
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["MYACTIVITY","ACTIVEUSERS","ACTIVITIES","SYNCGROUPID","isConnected","control","internalModel","getModel","isCollaborationConnected","send","action","content","triggeredActionName","clientContent","Array","isArray","join","myActivity","getProperty","Activity","LiveChange","setProperty","Undo","broadcastCollaborationMessage","getWebSocketBaseURL","bindingContext","getMetaModel","getObject","isCollaborationEnabled","view","getBindingContext","connect","me","CollaborationUtils","getMe","webSocketBaseURL","serviceUrl","getServiceUrl","sDraftUUID","requestProperty","initializeCollaboration","message","messageReceive","disconnect","endCollaboration","activeUsers","activities","activityKey","metaPath","calculateMetaPath","userAction","clientAction","sender","id","userID","name","userDescription","initials","formatInitials","color","getUserColor","mactivity","Join","JoinEcho","findIndex","user","unshift","Leave","filter","allActivities","removeUserActivities","bag","activity","p","Change","metaPaths","split","map","path","getMetaPath","forEach","currentMetaPath","i","nesteedMessage","currentActivities","getActivityKey","key","update","Create","Delete","Activate","draftClosedByOtherUser","getText","Discard","Action","initJSONModel","parts","length","slice","push","a","text","MessageBox","information","getBinding","resetChanges","then","navigate","catch","Log","error","appComponent","getAppComponent","metaModel","currentPage","getCurrentPage","sideEffectsService","getSideEffectsService","currentContext","currentPath","getPath","changedDocument","deletedObjects","parentDeletedIndex","deletedObject","startsWith","onClose","targetContext","bindContext","getBoundContext","getController","_routing","navigateBackFromContext","actionName","clientTriggeredActionName","bindingParameters","getODataActionSideEffects","targetPaths","pathExpressions","requestSideEffects","activityPath","replace","sideEffects","$PropertyPath","entityType","getEntityTypeFromContext","entityTypeSideEffects","getODataEntitySideEffects","object","Object","relevantSideEffects","fromEntries","entries","x","SourceProperties","source","value","TargetProperties","targetProperty","editFlow","updateDocument","Promise","resolve","routing","CommonUtils","getCurrentPageView","substring","lastIndexOf","dataPath"],"sourceRoot":".","sources":["ActivitySync.ts"],"sourcesContent":["import Log from \"sap/base/Log\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport {\n\tbroadcastCollaborationMessage,\n\tendCollaboration,\n\tinitializeCollaboration,\n\tisCollaborationConnected\n} from \"sap/fe/core/controllerextensions/collaboration/ActivityBase\";\nimport type { Message, User, UserActivity } from \"sap/fe/core/controllerextensions/collaboration/CollaborationCommon\";\nimport { Activity, CollaborationUtils } from \"sap/fe/core/controllerextensions/collaboration/CollaborationCommon\";\nimport MessageBox from \"sap/m/MessageBox\";\nimport type Control from \"sap/ui/core/Control\";\nimport type View from \"sap/ui/core/mvc/View\";\nimport type JSONModel from \"sap/ui/model/json/JSONModel\";\nimport type ODataMetaModel from \"sap/ui/model/odata/v4/ODataMetaModel\";\nimport type { V4Context } from \"types/extension_types\";\n\nconst MYACTIVITY = \"/collaboration/myActivity\";\nconst ACTIVEUSERS = \"/collaboration/activeUsers\";\nconst ACTIVITIES = \"/collaboration/activities\";\nconst SYNCGROUPID = \"$auto.sync\";\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 (\n\tcontrol: Control,\n\taction: Activity,\n\tcontent: string | string[] | undefined,\n\ttriggeredActionName?: string | undefined\n) {\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\tconst myActivity = internalModel.getProperty(MYACTIVITY);\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\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// No need to send an Undo message if there's no current activity\n\t\t\tif (action === Activity.Undo && myActivity === null) {\n\t\t\t\treturn;\n\t\t\t}\n\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, triggeredActionName);\n\t}\n};\n\nconst getWebSocketBaseURL = function (bindingContext: V4Context): 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 V4Context);\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 V4Context;\n\tconst webSocketBaseURL = getWebSocketBaseURL(bindingContext);\n\tconst serviceUrl = bindingContext.getModel().getServiceUrl();\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, serviceUrl, 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 = calculateMetaPath(view, 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\tlet mactivity: UserActivity = sender;\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.unshift(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((currentMetaPath, 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 + currentMetaPath) || [];\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 + currentMetaPath, currentActivities);\n\t\t\t\t\tupdate(view, nesteedMessage, currentMetaPath, 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\tdraftClosedByOtherUser(view, message, CollaborationUtils.getText(\"C_COLLABORATIONDRAFT_ACTIVATE\", sender.name));\n\t\t\tbreak;\n\t\tcase Activity.Discard:\n\t\t\tdraftClosedByOtherUser(view, message, CollaborationUtils.getText(\"C_COLLABORATIONDRAFT_DISCARD\", sender.name));\n\t\t\tbreak;\n\n\t\tcase Activity.Action:\n\t\t\tupdate(view, message, metaPath, Activity.Action);\n\t\t\tbreak;\n\n\t\tcase Activity.LiveChange:\n\t\t\tmactivity = sender;\n\t\t\tmactivity.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(mactivity);\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 draftClosedByOtherUser(view: View, message: Message, text: string) {\n\tdisconnect(view);\n\tMessageBox.information(text);\n\t(view.getBindingContext() as V4Context)\n\t\t.getBinding()\n\t\t.resetChanges()\n\t\t.then(function () {\n\t\t\tnavigate(message.clientContent, view);\n\t\t})\n\t\t.catch(function () {\n\t\t\tLog.error(\"Pending Changes could not be reset - still navigating to active instance\");\n\t\t\tnavigate(message.clientContent, view);\n\t\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 (action === Activity.Action) {\n\t\tconst actionName = message.clientTriggeredActionName,\n\t\t\tbindingParameters = sideEffectsService.getODataActionSideEffects(actionName!, currentContext),\n\t\t\ttargetPaths = bindingParameters?.pathExpressions;\n\t\tif (targetPaths && targetPaths.length > 0) {\n\t\t\tsideEffectsService.requestSideEffects(targetPaths, currentContext, SYNCGROUPID);\n\t\t}\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, SYNCGROUPID);\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\treturn CommonUtils.getCurrentPageView(appComponent);\n}\n\nfunction getActivityKey(x: string): string {\n\treturn x.substring(x.lastIndexOf(\"(\") + 1, x.lastIndexOf(\")\"));\n}\n\n/**\n * Calculates the metapath from one or more data path(s).\n *\n * @param view The current view\n * @param path One ore more data path(s), in case of multiple paths separated by '|'\n * @returns The calculated metaPath\n */\nfunction calculateMetaPath(view: View, path?: string): string {\n\tlet metaPath = \"\";\n\tif (path) {\n\t\t// in case more than one path is sent all of them have to use the same metapath therefore we just consider the first one\n\t\tconst dataPath = path.split(\"|\")[0];\n\t\tmetaPath = (view.getModel().getMetaModel() as ODataMetaModel).getMetaPath(dataPath);\n\t}\n\treturn metaPath;\n}\n\nexport default {\n\tconnect: connect,\n\tdisconnect: disconnect,\n\tisConnected: isConnected,\n\tisCollaborationEnabled: isCollaborationEnabled,\n\tsend: send\n};\n"],"mappings":"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"}