Add event/operation history + serialized handling

core/event/change-event.js

@@ -177,6 +177,10 @@ var ChangeEvent = exports.ChangeEvent = Montage.specialize({
      */
     removedValues: {
         value: undefined
+    },
+
+    tracksDispatchChain: {
+        value: true
     }
 
 });

core/event/event-manager.js

@@ -3196,6 +3196,7 @@ var EventManager = exports.EventManager = Montage.specialize(/** @lends EventMan
                         }
                         promise = this._invokeTargetListenerEntryForEvent(iTarget, nextEntry, mutableEvent, mutableEventPhase, undefined/*currentTargetIdentifierSpecificCaptureMethodName*/, undefined/*identifierSpecificCaptureMethodName*/, undefined/*captureMethodName*/, previousPromise);
 
+
                         // if(previousPromise && promise) {
                         //     if(!promises) {
                         //         promises = [previousPromise, promise];
@@ -3238,11 +3239,85 @@ var EventManager = exports.EventManager = Montage.specialize(/** @lends EventMan
         }
     },
 
+    _activeEventsByType: {
+        get: function () {
+            return this.__activeEventsByType || (this.__activeEventsByType = new Map());
+        }
+    },
+
+    _eventQueueByType: {
+        get: function () {
+            return this.__eventQueueByType || (this.__eventQueueByType = new Map());
+        }
+    },
+
+    _trackedTargets: {
+        value: new Set(["Person", "EmploymentPositionStaffing", "EmploymentPosition", "JobRole"])
+    },
+
+    handleEvent: {
+        enumerable: false,
+        value: function (event) {
+
+            if (typeof window === "object" && !window._eventQueueByType) {
+                window.eventQueueByType = this._eventQueueByType;
+                window.activeEventsByType = this._activeEventsByType;
+            }
+            if (typeof window === "undefined") {
+                this._handleEvent(event);
+                return;
+            }
+
+            if (event.target.name && this._trackedTargets.has(event.target.name) && event.type.indexOf("Operation") !== -1) {
+                let queued = this._activeEventsByType.has(event.type) &&  !this._hasActiveReferrer(event);
+                console.log("EventManager Event", event.target.name, event.id, event.referrerId, event, {
+                    queued: queued,
+                    firstOfKind: !queued && !this._activeEventsByType.has(event.type)
+                });
+            }
+            if (this._activeEventsByType.has(event.type) &&  !this._hasActiveReferrer(event)) {
+                if (!this._eventQueueByType.has(event.type)) {
+                    this._eventQueueByType.set(event.type, []);
+                }
+                this._eventQueueByType.get(event.type).unshift(event);
+            } else if (!this._activeEventsByType.has(event.type)) {
+                this._activeEventsByType.set(event.type, new Set([event]));
+                this._handleEvent(event);
+            } else {
+                this._activeEventsByType.get(event.type).add(event);
+                this._handleEvent(event);
+            }
+        }
+    },
+
+    _hasActiveReferrer: {
+        value: function (event) {
+            let referrer;
+            if (event.referrer) {
+                return this._isActive(event.referrer) || this._hasActiveReferrer(event.referrer);
+            } else if (event.referrers) {
+                let i, n, isActive;
+                for (i = 0, n = event.referrers.length; i < n && !isActive; ++i) {
+                    isActive = this._isActive(event.referrers[i]) || this._hasActiveReferrer(event.referrers[i]);
+                }
+                return isActive;
+            }
+            return false;
+        }
+    },
+
+    _isActive: {
+        value: function (event) {
+            let activeByType = this._activeEventsByType.get(event.type);
+            return !!activeByType && activeByType.has(event);
+        }
+    },
+
     /**
      @function
      @param {Event} event The handled event.
      */
-    handleEvent: {
+    _handleEvent: {
         enumerable: false,
         value: function EventManager_handleEvent(event) {
             // if(event.type === "pointerdown" || event.type === "pointerup" || event.type.indexOf("press") !== -1) {
@@ -3264,6 +3339,24 @@ var EventManager = exports.EventManager = Montage.specialize(/** @lends EventMan
                 targetEntry, targetEntryForEventType,
                 promise;
 
+            if (event.target.name && this._trackedTargets.has(event.target.name) && event.type.indexOf("Operation") !== -1) {
+                console.log("EventManager HandleEvent", event.target.name, event.id, event.referrerId);
+            }
+
+            // if (event.tracksDispatchChain) {
+            //     if (this._previousEvent && this._previousEvent.dispatchChain && this._previousEvent.dispatchChain.length && event.dispatchChain) {
+            //         // console.log(`[EventManager] Mark Event ${event.target.objectDescriptor.name}`);
+            //         event.dispatchChain.push.apply(event.dispatchChain, this._previousEvent.dispatchChain);
+            //         event.dispatchChain.push(this._previousEvent);
+            //     } else if (this._previousEvent && event.dispatchChain) {
+            //         // console.log(`[EventManager] Push Previous Event ${event.target.objectDescriptor.name}`);
+            //         event.dispatchChain.push(this._previousEvent);
+            //     } else {
+            //         // console.log(`[EventManager] Record initial event ${event.target.objectDescriptor.name}`);
+            //     }
+            //     this._previousEvent = event;
+            // }
+
             if(this.isBrowser) {
                 if(
                     (MontageElement && event.target instanceof MontageElement) ||
@@ -3368,7 +3461,25 @@ var EventManager = exports.EventManager = Montage.specialize(/** @lends EventMan
 
             if(promise) {
                 var self = this;
+                let timeoutId = setTimeout(function () {
+                    if (mutableEvent.target && mutableEvent.target.name) {
+                        if (mutableEvent.referredOperations && mutableEvent.referredOperations.length) {
+                            let ancestry = mutableEvent.referredOperations.map(function (referred) {
+                                return " " + referred.type + ":" + referred.target.name + ":" + referred.id + ":" + referred.rawDataService?.name;
+                            }).join("\n");
+                            ancestry = "Referred: \n" + ancestry;
+                            console.log("Unresolved Event", mutableEvent.type, mutableEvent.target.name, mutableEvent.id, ancestry, mutableEvent);
+
+                        } else {
+                            console.log("Unresolved Event", mutableEvent.type, mutableEvent.target.name, mutableEvent.id, mutableEvent);
+                        }
+                    } else {
+                        console.log("Unresolved Event", mutableEvent.type, mutableEvent.id, mutableEvent);
+                    }
+
+                }, 2000);
                 mutableEvent.propagationPromise = promise.then(function() {
+                    clearTimeout(timeoutId);
                     self._finalizeHandleEvent(mutableEvent, event);
                 });
             } else {
@@ -3398,9 +3509,39 @@ var EventManager = exports.EventManager = Montage.specialize(/** @lends EventMan
                     document.body.removeEventListener("DOMAttrModified", this.domModificationEventHandler, true);
                     document.body.removeEventListener("DOMCharacterDataModified", this.domModificationEventHandler, true);
                 }
+
+                // if (mutableEvent.target && mutableEvent.target.name && mutableEvent.type.indexOf("Operation") !== -1) {
+                //     console.log("EventManager _finalizeHandleEvent", mutableEvent.type, mutableEvent.target.name, mutableEvent.id, mutableEvent.referrerId, mutableEvent);
+                // }
+
+                //Handle next event
+                let type = mutableEvent.type,
+                    next;
+                if (this._eventQueueByType.has(type) && this._eventQueueByType.get(type).length) {
+                    next = this._eventQueueByType.get(type).pop();
+                    this._activeEventsByType.get(type).delete(event);
+                    this._activeEventsByType.get(type).add(next);
+                        this._handleEvent(next);
+                } else {
+                    this._activeEventsByType.delete(type);
+                    this._eventQueueByType.delete(type);
+                }
             }
 
 
+
+            // if (this._previousEvent === event || this._previousEvent === mutableEvent) {
+            //     this._previousEvent = event.dispatchChain[event.dispatchChain.length - 1];
+            //     let name = event.target.name || event.target.objectDescriptor.name,
+            //         previousName;
+            //     if (this._previousEvent) {
+            //         previousName = this._previousEvent.target.name || this._previousEvent.target.objectDescriptor.name;
+            //         // console.log(`[EventManager] Reset previous event ${event.identifier} ${name} ${event.type} to  ${this._previousEvent.identifier} ${previousName} ${this._previousEvent.type}`);
+            //     }  else {
+            //         // console.log(`[EventManager] Clear previous event ${event.identifier} ${name} ${event.type}`);
+            //     }
+            // } 
+
         }
     },
 
@@ -3572,6 +3713,11 @@ var EventManager = exports.EventManager = Montage.specialize(/** @lends EventMan
                 this.unregisterTargetEventListener(iTarget, mutableEvent.type, listener, listenerEntry);
             }
 
+            if (result && result.then) {
+                mutableEvent.triggeredTargets = mutableEvent.triggeredTargets || [];
+                mutableEvent.triggeredTargets.push({target: iTarget, entry: listenerEntry, name: currentTargetIdentifierSpecificPhaseMethodName, result: result});
+            }
+
             return result;
 
         }

core/event/mutable-event.js

@@ -394,12 +394,37 @@ var wrapPropertyGetter = function (key, storageKey) {
         },
         /**
          * @type {Property}
-         * @default {Element} null
+         * @default {Array} null
          */
         composedPath: {
             value: function () {
                 return this._composedPath;
             }
+        },
+
+        /**
+         * @type {Property}
+         * @default {Array} null
+         * An ordered array containing the chain of events that led to the 
+         * dispatch of this one
+         */
+        dispatchChain: {
+            get: function () {
+                return this.tracksDispatchChain ? this._dispatchChain || (this._dispatchChain = []) : null;
+            }
+        },
+
+        /**
+         * @type {Property}
+         * @default {Boolean} false 
+         * Indicates whether the ancestory if this event will be tracked. It is expensive 
+         * so this is only set to true for clearly defined use cases
+         */
+        tracksDispatchChain: {
+            // value: false
+            get: function () {
+                return (this._tracksDispatchChain !== void 0) ? this._tracksDispatchChain : (this._event && this._event.tracksDispatchChain);
+            }
         }
 
     }, {

data/converter/raw-foreign-value-to-object-converter.js

@@ -1,10 +1,12 @@
 var RawValueToObjectConverter = require("./raw-value-to-object-converter").RawValueToObjectConverter,
     Criteria = require("../../core/criteria").Criteria,
+    DataOperation = require("../service/data-operation").DataOperation,
     DataQuery = require("../model/data-query").DataQuery,
     Map = require("../../core/collections/map").Map,
     syntaxProperties = require("../../core/frb/syntax-properties"),
     Uuid = require("core/uuid").Uuid,
     Promise = require("../../core/promise").Promise;
+
 /**
  * @class RawForeignValueToObjectConverter
  * @classdesc Converts a property value of raw data to the referenced object.
@@ -122,7 +124,7 @@ exports.RawForeignValueToObjectConverter = RawValueToObjectConverter.specialize(
         }
     },
     _fetchConvertedDataForObjectDescriptorCriteria: {
-        value: function(typeToFetch, criteria, currentRule, registerMappedPropertiesAsChanged) {
+        value: function(typeToFetch, criteria, currentRule, registerMappedPropertiesAsChanged, referrerOperation) {
             var self = this;
 
             return this.service ? this.service.then(function (service) {
@@ -131,6 +133,10 @@ exports.RawForeignValueToObjectConverter = RawValueToObjectConverter.specialize(
                 //var localResult,
                     localPartialResult;
 
+                if (typeToFetch.name === "EmploymentPosition" || typeToFetch.name === "EmploymentPositionStaffing" || typeToFetch.name === "Organization" ) {
+                    console.log("ExpressionDataMapping._fetchConvertedDataForObjectDescriptorCriteria", typeToFetch, currentRule.propertyDescriptor.name, referrerOperation && referrerOperation.id, criteria);
+                }
+
                 /*
                     Leaving a trace of localPartialResult here. Unless I'm missing something, the problem with a partial result 
                     is that we don't really have an easy way to return a partial result with the promise-based API, 
@@ -208,6 +214,10 @@ exports.RawForeignValueToObjectConverter = RawValueToObjectConverter.specialize(
 
                         query.hints = {rawDataService: service};
 
+                        if (referrerOperation) {
+                            query.hints.referrerOperation = referrerOperation;
+                        }
+
                         if(registerMappedPropertiesAsChanged){
                             query.hints.registerMappedPropertiesAsChanged = registerMappedPropertiesAsChanged;
                         }
@@ -351,12 +361,16 @@ exports.RawForeignValueToObjectConverter = RawValueToObjectConverter.specialize(
                         if(!queryParts) {
                             queryParts = {
                                 criteria: [],
-                                readExpressions: []/*,
+                                readExpressions: [],
+                                referrerOperations: []/*,
                                 hints: {}*/
                             };
                             self._pendingCriteriaByTypeToCombine.set(typeToFetch, queryParts);
                         }
                         queryParts.criteria.push(criteria);
+                        if (referrerOperation) {
+                            queryParts.referrerOperations.push(referrerOperation);
+                        }
 
                         /*
                             Sounds twisted, but this is to deal with the case where we need to fetch to resolve a property of the object itself.
@@ -495,6 +509,10 @@ exports.RawForeignValueToObjectConverter = RawValueToObjectConverter.specialize(
                 query.hints.registerMappedPropertiesAsChanged = registerMappedPropertiesAsChanged;
             }
 
+            if(queryParts.referrerOperations) {
+                query.hints.referrerOperations = queryParts.referrerOperations;
+            }
+
             //console.log("_combineFetchDataMicrotaskFunctionForTypeQueryParts query:",query);
 
             mapIterationFetchPromise = rootService.fetchData(query)
@@ -695,9 +713,23 @@ exports.RawForeignValueToObjectConverter = RawValueToObjectConverter.specialize(
         value: Uuid.noValue
     },
 
+    _findScopedDataOperation: {
+        value: function (scope) {
+            let operation;
+            while (scope.parent && !operation) {
+                if (scope.value instanceof DataOperation) {
+                    operation = scope.value;
+                }
+                scope = scope.parent;
+            }
+            return operation;
+        }
+    },
+
    _convert: {
         value: function (scope, service) {
-            var v = scope.value;
+            var v = scope.value,
+                referrerOperation = this._findScopedDataOperation(scope);
             if((v && !(v instanceof Array )) || (v instanceof Array && v.length > 0)) {
                 var self = this,
                     //We put it in a local variable so we have the right value in the closure
@@ -706,6 +738,8 @@ exports.RawForeignValueToObjectConverter = RawValueToObjectConverter.specialize(
                     criteria,
                     query;
 
+
+
                 if(this.foreignDescriptorMappings) {
                     /*
                         Needs to loop on the mapping and evaluate value. If v is an array, it's possible
@@ -736,7 +770,7 @@ exports.RawForeignValueToObjectConverter = RawValueToObjectConverter.specialize(
                             aCriteria;
                         while (anObjectDescriptor = mapIterator.next().value) {
                             aCriteria = this.convertCriteriaForValue(groupMap.get(anObjectDescriptor));
-                            promises.push(this._fetchConvertedDataForObjectDescriptorCriteria(anObjectDescriptor, aCriteria, currentRule, registerMappedPropertiesAsChanged));
+                            promises.push(this._fetchConvertedDataForObjectDescriptorCriteria(anObjectDescriptor, aCriteria, currentRule, registerMappedPropertiesAsChanged, referrerOperation));
 
                         }
 
@@ -763,7 +797,7 @@ exports.RawForeignValueToObjectConverter = RawValueToObjectConverter.specialize(
                             foreignKeyValue = v[rawDataProperty],
                             aCriteria = this.convertCriteriaForValue(foreignKeyValue);
 
-                            return this._fetchConvertedDataForObjectDescriptorCriteria(valueDescriptor, aCriteria, currentRule, registerMappedPropertiesAsChanged);
+                            return this._fetchConvertedDataForObjectDescriptorCriteria(valueDescriptor, aCriteria, currentRule, registerMappedPropertiesAsChanged, referrerOperation);
 
                         } else {
                             return Promise.resolve(null);
@@ -783,7 +817,7 @@ exports.RawForeignValueToObjectConverter = RawValueToObjectConverter.specialize(
 
                     return this._descriptorToFetch.then(function (typeToFetch) {
 
-                        return self._fetchConvertedDataForObjectDescriptorCriteria(typeToFetch, criteria, currentRule, registerMappedPropertiesAsChanged);
+                        return self._fetchConvertedDataForObjectDescriptorCriteria(typeToFetch, criteria, currentRule, registerMappedPropertiesAsChanged, referrerOperation);
 
                         // if (self.serviceIdentifier) {
                         //     criteria.parameters.serviceIdentifier = self.serviceIdentifier;

data/model/data-event.js

@@ -58,6 +58,10 @@ exports.DataEvent = MutableEvent.specialize({
 
     detail: {
         value: undefined
+    },
+
+    tracksDispatchChain: {
+        value: true
     }
 
 
@@ -101,4 +105,5 @@ exports.DataEvent = MutableEvent.specialize({
         value: "saveChangesProgress"
     }
 
+
 });