breeze-client 2.1.2 → 2.1.3-mjs

package/esm2020/src/entity-aspect.mjs

@@ -0,0 +1,806 @@
+import { core } from './core';
+import { config } from './config';
+import { BreezeEvent } from './event';
+import { assertParam } from './assert-param';
+import { EntityState } from './entity-state';
+import { EntityAction } from './entity-action';
+import { EntityType } from './entity-metadata';
+import { EntityKey } from './entity-key';
+import { Validator, ValidationError } from './validate';
+import { EntityQuery } from './entity-query';
+/**
+An EntityAspect instance is associated with every attached entity and is accessed via the entity's 'entityAspect' property.
+
+The EntityAspect itself provides properties to determine and modify the EntityState of the entity and has methods
+that provide a variety of services including validation and change tracking.
+
+An EntityAspect will almost never need to be constructed directly. You will usually get an EntityAspect by accessing
+an entities 'entityAspect' property.  This property will be automatically attached when an entity is created via either
+a query, import or [[EntityManager.createEntity]] call.
+>      // assume order is an order entity attached to an EntityManager.
+>      var aspect = order.entityAspect;
+>      var currentState = aspect.entityState;
+
+**/
+export class EntityAspect {
+    /** @hidden @internal */
+    constructor(entity) {
+        // if called without new
+        // if (!(this instanceof EntityAspect)) {
+        //   return new EntityAspect(entity);
+        // }
+        /**
+        Sets the entity to an EntityState of 'Unchanged'.  This is also the equivalent of calling [[EntityAspect.acceptChanges]].
+        The same operation can be performed by calling [[EntityAspect.setEntityState]].
+        >      // assume order is an order entity attached to an EntityManager.
+        >      order.entityAspect.setUnchanged();
+        >      // The 'order' entity will now be in an 'Unchanged' state with any changes committed.
+        **/
+        this.setUnchanged = function () {
+            return this.setEntityState(EntityState.Unchanged);
+        };
+        /**
+        Sets the entity to an EntityState of 'Modified'.  This can also be achieved by changing the value of any property on an 'Unchanged' entity.
+        The same operation can be performed by calling [[EntityAspect.setEntityState]].
+        >      // assume order is an order entity attached to an EntityManager.
+        >      order.entityAspect.setModified();
+        >      // The 'order' entity will now be in a 'Modified' state.
+        **/
+        this.setModified = function () {
+            return this.setEntityState(EntityState.Modified);
+        };
+        /**
+        Sets the entity to an EntityState of 'Deleted'.  This both marks the entity as being scheduled for deletion during the next 'Save' call
+        but also removes the entity from all of its related entities.
+        The same operation can be performed by calling [[EntityAspect.setEntityState]].
+        >      // assume order is an order entity attached to an EntityManager.
+        >      order.entityAspect.setDeleted();
+        >      // The 'order' entity will now be in a 'Deleted' state and it will no longer have any 'related' entities.
+        **/
+        this.setDeleted = function () {
+            return this.setEntityState(EntityState.Deleted);
+        };
+        /**
+        Sets the entity to an EntityState of 'Detached'.  This removes the entity from all of its related entities, but does NOT change the EntityState of any existing entities.
+        The same operation can be performed by calling [[EntityAspect.setEntityState]].
+        >      // assume order is an order entity attached to an EntityManager.
+        >      order.entityAspect.setDetached();
+        >      // The 'order' entity will now be in a 'Detached' state and it will no longer have any 'related' entities.
+        **/
+        this.setDetached = function () {
+            return this.setEntityState(EntityState.Detached);
+        };
+        this.entity = entity;
+        // TODO: keep public or not?
+        this.entityGroup = undefined;
+        this.entityManager = undefined;
+        this.entityState = EntityState.Detached;
+        this.isBeingSaved = false;
+        this.originalValues = {};
+        this.hasValidationErrors = false;
+        this._validationErrors = {};
+        // Uncomment when we implement entityAspect.isNavigationPropertyLoaded method
+        // this._loadedNavPropMap = {};
+        this.validationErrorsChanged = new BreezeEvent("validationErrorsChanged", this);
+        this.propertyChanged = new BreezeEvent("propertyChanged", this);
+        // in case this is the NULL entityAspect. - used with ComplexAspects that have no parent.
+        if (entity != null) {
+            // remove properties that should be on prototype but placed on class by Babel
+            if (!entity.entityType) {
+                delete (entity.entityType);
+            }
+            if (!entity.entityAspect) {
+                delete (entity.entityAspect);
+            }
+            entity.entityAspect = this;
+            // entityType should already be on the entity from 'watch'
+            let entityType = entity.entityType || entity._$entityType;
+            if (!entityType) {
+                let typeName = entity.prototype._$typeName;
+                if (!typeName) {
+                    throw new Error("This entity is not registered as a valid EntityType");
+                }
+                else {
+                    throw new Error("Metadata for this entityType has not yet been resolved: " + typeName);
+                }
+            }
+            let entityCtor = entityType.getEntityCtor();
+            config.interfaceRegistry.modelLibrary.getDefaultInstance().startTracking(entity, entityCtor.prototype);
+        }
+    }
+    /** @hidden */
+    // type-guard
+    static isEntity(obj) {
+        return obj.entityAspect != null;
+    }
+    // No longer used
+    // static createFrom(entity: Entity): EntityAspect {
+    //   if (entity == null) {
+    //     return EntityAspect._nullInstance;
+    //   } else if (entity.entityAspect) {
+    //     return entity.entityAspect;
+    //   }
+    //   return new EntityAspect(entity);
+    // }
+    // TODO: refactor this and the instance getPropertyValue method.
+    /**
+    Returns the value of a specified 'property path' for a specified entity.
+  
+    The propertyPath can be either a string delimited with '.' or a string array.
+    **/
+    // used by EntityQuery and Predicate
+    static getPropertyPathValue(obj, propertyPath) {
+        let properties = Array.isArray(propertyPath) ? propertyPath : propertyPath.split(".");
+        if (properties.length === 1) {
+            return obj.getProperty(propertyPath);
+        }
+        else {
+            let nextValue = obj;
+            // hack use of some to perform mapFirst operation.
+            properties.some((prop) => {
+                nextValue = nextValue.getProperty(prop);
+                return nextValue == null;
+            });
+            return nextValue;
+        }
+    }
+    /**
+    Returns the [[EntityKey]] for this Entity.
+    >      // assume order is an order entity attached to an EntityManager.
+    >      var entityKey = order.entityAspect.getKey();
+    @param forceRefresh - (boolean=false) Forces the recalculation of the key.  This should normally be unnecessary.
+    @return The [[EntityKey]] associated with this Entity.
+    **/
+    getKey(forceRefresh = false) {
+        forceRefresh = assertParam(forceRefresh, "forceRefresh").isBoolean().isOptional().check(false);
+        if (forceRefresh || !this._entityKey) {
+            let entityType = this.entity.entityType;
+            let keyProps = entityType.keyProperties;
+            let values = keyProps.map(function (p) {
+                return this.entity.getProperty(p.name);
+            }, this);
+            this._entityKey = new EntityKey(entityType, values);
+        }
+        return this._entityKey;
+    }
+    /**
+    Returns the entity to an [[EntityState]] of 'Unchanged' by committing all changes made since the entity was last queried
+    had 'acceptChanges' called on it.
+    >      // assume order is an order entity attached to an EntityManager.
+    >      order.entityAspect.acceptChanges();
+    >      // The 'order' entity will now be in an 'Unchanged' state with any changes committed.
+    **/
+    acceptChanges() {
+        if (!this.entity)
+            return;
+        this._checkOperation("acceptChanges");
+        let em = this.entityManager;
+        if (this.entityState.isDeleted()) {
+            em.detachEntity(this.entity);
+        }
+        else {
+            this.setUnchanged();
+        }
+        em.entityChanged.publish({ entityAction: EntityAction.AcceptChanges, entity: this.entity });
+    }
+    /**
+    Returns the entity to an [[EntityState]] of 'Unchanged' by rejecting all changes made to it since the entity was last queried
+    had 'rejectChanges' called on it.
+    >      // assume order is an order entity attached to an EntityManager.
+    >      order.entityAspect.rejectChanges();
+    >      // The 'order' entity will now be in an 'Unchanged' state with any changes rejected.
+    **/
+    rejectChanges() {
+        this._checkOperation("rejectChanges");
+        let entity = this.entity;
+        let entityManager = this.entityManager;
+        // we do not want PropertyChange or EntityChange events to occur here
+        core.using(entityManager, "isRejectingChanges", true, function () {
+            rejectChangesCore(entity);
+        });
+        if (this.entityState.isAdded()) {
+            // next line is needed because the following line will cause this.entityManager -> null;
+            entityManager.detachEntity(entity);
+            // need to tell em that an entity that needed to be saved no longer does.
+            entityManager._notifyStateChange(entity, false);
+        }
+        else {
+            if (this.entityState.isDeleted()) {
+                entityManager._linkRelatedEntities(entity);
+            }
+            this.setUnchanged();
+            // propertyChanged propertyName is not specified because more than one property may have changed.
+            this.propertyChanged.publish({ entity: entity, propertyName: null });
+            entityManager.entityChanged.publish({ entityAction: EntityAction.RejectChanges, entity: entity });
+        }
+    }
+    /**  @hidden @internal */
+    // TODO: rename - and use '_'; used on both EntityAspect and ComplexAspect for polymorphic reasons.
+    getPropertyPath(propName) {
+        return propName;
+    }
+    /**
+    Sets the entity to an EntityState of 'Added'.  This is NOT the equivalent of calling [[EntityManager.addEntity]]
+    because no key generation will occur for autogenerated keys as a result of this operation. As a result this operation can be problematic
+    unless you are certain that the entity being marked 'Added' does not already exist in the database and does not have an autogenerated key.
+    The same operation can be performed by calling [[EntityAspect.setEntityState]].
+    >      // assume order is an order entity attached to an EntityManager.
+    >      order.entityAspect.setAdded();
+    >      // The 'order' entity will now be in an 'Added' state.
+    **/
+    setAdded() {
+        return this.setEntityState(EntityState.Added);
+    }
+    /**
+    Sets the entity to the specified EntityState. See also 'setUnchanged', 'setModified', 'setDetached', etc.
+    >      // assume order is an order entity attached to an EntityManager.
+    >      order.entityAspect.setEntityState(EntityState.Unchanged);
+    >      // The 'order' entity will now be in a 'Unchanged' state.
+    **/
+    setEntityState(entityState) {
+        if (this.entityState === entityState)
+            return false;
+        this._checkOperation("setEntityState");
+        if (this.entityState.isDetached()) {
+            throw new Error("You cannot set the 'entityState' of an entity when it is detached - except by first attaching it to an EntityManager");
+        }
+        let entity = this.entity;
+        let em = this.entityManager;
+        let needsSave = true;
+        if (entityState === EntityState.Unchanged) {
+            clearOriginalValues(entity);
+            delete this.hasTempKey;
+            needsSave = false;
+        }
+        else if (entityState === EntityState.Added) {
+            clearOriginalValues(entity);
+            // TODO: more to do here... like regenerating key ???
+        }
+        else if (entityState === EntityState.Deleted) {
+            if (this.entityState.isAdded()) {
+                // turn it into a detach and exit early
+                this.setEntityState(EntityState.Detached);
+                return true;
+            }
+            else {
+                // TODO: think about cascade deletes
+                // entityState needs to be set it early in this one case to insure that fk's are not cleared.
+                this.entityState = EntityState.Deleted;
+                removeFromRelations(entity, EntityState.Deleted);
+            }
+        }
+        else if (entityState === EntityState.Modified) {
+            // nothing extra needed
+        }
+        else if (entityState === EntityState.Detached) {
+            let group = this.entityGroup;
+            // no group === already detached.
+            if (!group)
+                return false;
+            group.detachEntity(entity);
+            // needs to occur early here - so this IS deliberately redundent with the same code later in this method.
+            this.entityState = entityState;
+            removeFromRelations(entity, EntityState.Detached);
+            this._detach();
+            em.entityChanged.publish({ entityAction: EntityAction.Detach, entity: entity });
+            needsSave = false;
+        }
+        this.entityState = entityState;
+        em._notifyStateChange(entity, needsSave);
+        return true;
+    }
+    /**
+    Performs a query for the value of a specified [[NavigationProperty]]. __Async__
+    >      emp.entityAspect.loadNavigationProperty("Orders").then(function (data) {
+    >          var orders = data.results;
+    >      }).catch(function (exception) {
+    >          // handle exception here;
+    >      });
+    @param navigationProperty - The NavigationProperty or the name of the NavigationProperty to 'load'.
+    @param callback - Function to call on success.
+    @param errorCallback - Function to call on failure.
+    @return Promise with shape
+      - results {Array of Entity}
+      - query {EntityQuery} The original query
+      - httpResponse {httpResponse} The HttpResponse returned from the server.
+    **/
+    loadNavigationProperty(navigationProperty, callback, errorCallback) {
+        let entity = this.entity;
+        let navProperty = entity.entityType._checkNavProperty(navigationProperty);
+        let query = EntityQuery.fromEntityNavigation(entity, navProperty);
+        // return entity.entityAspect.entityManager.executeQuery(query, callback, errorCallback);
+        let promise = entity.entityAspect.entityManager.executeQuery(query);
+        return promise.then((data) => {
+            this._markAsLoaded(navProperty.name);
+            if (callback)
+                callback(data);
+            return Promise.resolve(data);
+        }, (error) => {
+            if (errorCallback)
+                errorCallback(error);
+            return Promise.reject(error);
+        });
+    }
+    /**
+    Marks this navigationProperty on this entity as already having been loaded.
+    >      emp.entityAspect.markNavigationPropertyAsLoaded("Orders");
+    @param navigationProperty - The NavigationProperty or name of NavigationProperty to 'load'.
+    **/
+    markNavigationPropertyAsLoaded(navigationProperty) {
+        if (!this.entity)
+            return;
+        let navProperty = this.entity.entityType._checkNavProperty(navigationProperty);
+        this._markAsLoaded(navProperty.name);
+    }
+    /**
+    Determines whether a navigationProperty on this entity has already been loaded.
+  
+    A navigation property is considered loaded when any of the following three conditions applies:
+  
+      1. It was fetched from the backend server.
+          <br/>   This can be the result of an expand query or a call to the [[EntityAspect.loadNavigationProperty]] method.
+          <br/>   Note that even if the fetch returns nothing the property is still marked as loaded in this case.
+      1. The property is scalar and has been set to a nonnull value.
+      1. The [[EntityAspect.markNavigationPropertyAsLoaded]] was called.
+    
+    >     var wasLoaded = emp.entityAspect.isNavigationPropertyLoaded("Orders");
+    @param navigationProperty - The NavigationProperty or name of NavigationProperty to 'load'.
+    **/
+    isNavigationPropertyLoaded(navigationProperty) {
+        if (!this.entity)
+            return;
+        let navProperty = this.entity.entityType._checkNavProperty(navigationProperty);
+        if (navProperty.isScalar && this.entity.getProperty(navProperty.name) != null) {
+            return true;
+        }
+        return this._loadedNps && this._loadedNps.indexOf(navProperty.name) >= 0;
+    }
+    /** @hidden @internal */
+    _markAsLoaded(navPropName) {
+        this._loadedNps = this._loadedNps || [];
+        core.arrayAddItemUnique(this._loadedNps, navPropName);
+    }
+    /**
+    Performs validation on the entity, any errors encountered during the validation are available via the
+    [[EntityAspect.getValidationErrors]] method. Validating an entity means executing
+    all of the validators on both the entity itself as well as those on each of its properties.
+    >      // assume order is an order entity attached to an EntityManager.
+    >      var isOk = order.entityAspect.validateEntity();
+    >      // isOk will be 'true' if there are no errors on the entity.
+    >      if (!isOk) {
+    >          var errors = order.entityAspect.getValidationErrors();
+    >      }
+    @return Whether the entity passed validation.
+    **/
+    validateEntity() {
+        let ok = true;
+        this._processValidationOpAndPublish(function (that) {
+            ok = validateTarget(that.entity);
+        });
+        return ok;
+    }
+    /**
+    Performs validation on a specific property of this entity, any errors encountered during the validation are available via the
+    [[EntityAspect.getValidationErrors]] method. Validating a property means executing
+    all of the validators on the specified property.  This call is also made automatically anytime a property
+    of an entity is changed.
+    >      // assume order is an order entity attached to an EntityManager.
+    >      var isOk = order.entityAspect.validateProperty("Order");
+  
+    or
+    >      var orderDateProperty = order.entityType.getProperty("OrderDate");
+    >      var isOk = order.entityAspect.validateProperty(OrderDateProperty);
+    @param property - The [[DataProperty]] or [[NavigationProperty]] to validate or a string
+    with the name of the property or a property path with the path to a property of a complex object.
+    @param context -  A context object used to pass additional information to each [[Validator]].
+    @return Whether the entity passed validation.
+    **/
+    validateProperty(property, context) {
+        let value = this.getPropertyValue(property); // performs validations
+        if (value && value.complexAspect) {
+            return validateTarget(value);
+        }
+        context = context || {};
+        context.entity = this.entity;
+        if (typeof property === "string") {
+            context.property = this.entity.entityType.getProperty(property, true);
+            context.propertyName = property;
+        }
+        else {
+            context.property = property;
+            context.propertyName = property.name;
+        }
+        return this._validateProperty(value, context);
+    }
+    /**
+    Returns the validation errors associated with either the entire entity or any specified property.
+    
+    This method can return all of the errors for an Entity
+    >      // assume order is an order entity attached to an EntityManager.
+    >      var valErrors = order.entityAspect.getValidationErrors();
+  
+    as well as those for just a specific property.
+    >      // assume order is an order entity attached to an EntityManager.
+    >      var orderDateErrors = order.entityAspect.getValidationErrors("OrderDate");
+  
+    which can also be expressed as
+    >      // assume order is an order entity attached to an EntityManager.
+    >      var orderDateProperty = order.entityType.getProperty("OrderDate");
+    >      var orderDateErrors = order.entityAspect.getValidationErrors(orderDateProperty);
+    @param property - The property for which validation errors should be retrieved.
+    If omitted, all of the validation errors for this entity will be returned.
+    @return A array of validation errors.
+    **/
+    getValidationErrors(property) {
+        assertParam(property, "property").isOptional().isEntityProperty().or().isString().check();
+        let result = core.getOwnPropertyValues(this._validationErrors);
+        if (property) {
+            let propertyName = typeof (property) === 'string' ? property : property.name;
+            result = result.filter(function (ve) {
+                return ve.property && (ve.property.name === propertyName || (propertyName.indexOf(".") !== -1 && ve.propertyName === propertyName));
+            });
+        }
+        return result;
+    }
+    /**
+    Adds a validation error.
+    **/
+    addValidationError(validationError) {
+        assertParam(validationError, "validationError").isInstanceOf(ValidationError).check();
+        this._processValidationOpAndPublish(function (that) {
+            that._addValidationError(validationError);
+        });
+    }
+    /**
+    Removes a validation error.
+    @param validationErrorOrKey - Either a ValidationError or a ValidationError 'key' value
+    **/
+    removeValidationError(validationErrorOrKey) {
+        assertParam(validationErrorOrKey, "validationErrorOrKey").isString().or().isInstanceOf(ValidationError).or().isInstanceOf(Validator).check();
+        let key = (typeof (validationErrorOrKey) === "string") ? validationErrorOrKey : validationErrorOrKey.key;
+        this._processValidationOpAndPublish(function (that) {
+            that._removeValidationError(key);
+        });
+    }
+    /**
+    Removes all of the validation errors for a specified entity
+    **/
+    clearValidationErrors() {
+        this._processValidationOpAndPublish(function (that) {
+            core.objectForEach(that._validationErrors, function (key, valError) {
+                if (valError) {
+                    delete that._validationErrors[key];
+                    that._pendingValidationResult.removed.push(valError);
+                }
+            });
+            that.hasValidationErrors = !core.isEmpty(that._validationErrors);
+        });
+    }
+    /**
+    Returns an [[EntityKey]] for the entity pointed to by the specified scalar NavigationProperty.
+    This only returns an EntityKey if the current entity is a 'child' entity along the specified NavigationProperty.
+    i.e. has a single parent.
+  
+    @param navigationProperty - The [[NavigationProperty]] ( pointing to a parent).
+    @returns Either a parent EntityKey if this is a 'child' entity or null;
+    */
+    getParentKey(navigationProperty) {
+        if (!this.entity)
+            return null;
+        // TODO: review this - not sure about the comment.
+        // NavigationProperty doesn't yet exist
+        // assertParam(navigationProperty, "navigationProperty").isInstanceOf(NavigationProperty).check();
+        let fkNames = navigationProperty.foreignKeyNames;
+        if (fkNames.length === 0)
+            return null;
+        let that = this;
+        let fkValues = fkNames.map(function (fkn) {
+            return that.entity.getProperty(fkn);
+        });
+        return new EntityKey(navigationProperty.entityType, fkValues);
+    }
+    // TODO: refactor this and the static getPropertyPathValue.
+    /**
+    Returns the value of a specified DataProperty or NavigationProperty or 'property path'.
+    **/
+    getPropertyValue(property) {
+        assertParam(property, "property").isString().or().isEntityProperty().check();
+        let value;
+        if (typeof (property) === 'string') {
+            let propNames = property.trim().split(".");
+            let propName = propNames.shift();
+            value = this.entity;
+            value = value.getProperty(propName);
+            while (propNames.length > 0) {
+                propName = propNames.shift();
+                value = value.getProperty(propName);
+            }
+        }
+        else {
+            if (!(property.parentType instanceof EntityType)) {
+                throw new Error("The validateProperty method does not accept a 'property' parameter whose parentType is a ComplexType; " +
+                    "Pass a 'property path' string as the 'property' parameter instead ");
+            }
+            value = this.entity.getProperty(property.name);
+        }
+        return value;
+    }
+    // internal methods
+    /** @hidden @internal */
+    _checkOperation(operationName) {
+        if (this.isBeingSaved) {
+            throw new Error("Cannot perform a '" + operationName + "' on an entity that is in the process of being saved");
+        }
+        // allows chaining
+        return this;
+    }
+    /** @hidden @internal */
+    _detach() {
+        this.entityGroup = undefined;
+        this.entityManager = undefined;
+        this.entityState = EntityState.Detached;
+        this.originalValues = {};
+        this._validationErrors = {};
+        this.hasValidationErrors = false;
+        this.validationErrorsChanged.clear();
+        this.propertyChanged.clear();
+    }
+    // called from defaultInterceptor.
+    /** @hidden @internal */
+    _validateProperty(value, context) {
+        let ok = true;
+        this._processValidationOpAndPublish(function (that) {
+            context.property.getAllValidators().forEach(function (validator) {
+                ok = validate(that, validator, value, context) && ok;
+            });
+        });
+        return ok;
+    }
+    /** @hidden @internal */
+    _processValidationOpAndPublish(validationFn) {
+        if (this._pendingValidationResult) {
+            // only top level processValidations call publishes
+            validationFn(this);
+        }
+        else {
+            try {
+                this._pendingValidationResult = { entity: this.entity, added: [], removed: [] };
+                validationFn(this);
+                if (this._pendingValidationResult.added.length > 0 || this._pendingValidationResult.removed.length > 0) {
+                    this.validationErrorsChanged.publish(this._pendingValidationResult);
+                    // this might be a detached entity hence the guard below.
+                    this.entityManager && this.entityManager.validationErrorsChanged.publish(this._pendingValidationResult);
+                }
+            }
+            finally {
+                this._pendingValidationResult = undefined;
+            }
+        }
+    }
+    /** @hidden @internal */
+    // TODO: add/use a ValidationError type
+    _addValidationError(validationError) {
+        this._validationErrors[validationError.key] = validationError;
+        this.hasValidationErrors = true;
+        this._pendingValidationResult.added.push(validationError);
+    }
+    /** @hidden @internal */
+    _removeValidationError(key) {
+        let valError = this._validationErrors[key];
+        if (valError) {
+            delete this._validationErrors[key];
+            this.hasValidationErrors = !core.isEmpty(this._validationErrors);
+            this._pendingValidationResult.removed.push(valError);
+        }
+    }
+}
+/** @hidden @internal */
+EntityAspect._nullInstance = new EntityAspect(); // TODO: determine if this works
+BreezeEvent.bubbleEvent(EntityAspect.prototype, function () {
+    return this.entityManager;
+});
+function rejectChangesCore(target) {
+    let aspect = target.entityAspect || target.complexAspect;
+    let stype = target.entityType || target.complexType;
+    let originalValues = aspect.originalValues;
+    for (let propName in originalValues) {
+        target.setProperty(propName, originalValues[propName]);
+    }
+    stype.complexProperties.forEach(function (cp) {
+        let cos = target.getProperty(cp.name);
+        if (cp.isScalar) {
+            rejectChangesCore(cos);
+        }
+        else {
+            cos._rejectChanges();
+            cos.forEach(rejectChangesCore);
+        }
+    });
+}
+function removeFromRelations(entity, entityState) {
+    // remove this entity from any collections.
+    // mark the entity deleted or detached
+    let isDeleted = entityState.isDeleted();
+    if (isDeleted) {
+        removeFromRelationsCore(entity);
+    }
+    else {
+        core.using(entity.entityAspect.entityManager, "isLoading", true, function () {
+            removeFromRelationsCore(entity);
+        });
+    }
+}
+function removeFromRelationsCore(entity) {
+    entity.entityType.navigationProperties.forEach(function (np) {
+        let inverseNp = np.inverse;
+        let npValue = entity.getProperty(np.name);
+        if (np.isScalar) {
+            if (npValue) {
+                if (inverseNp) {
+                    if (inverseNp.isScalar) {
+                        npValue.setProperty(inverseNp.name, null);
+                    }
+                    else {
+                        let collection = npValue.getProperty(inverseNp.name);
+                        if (collection.length) {
+                            core.arrayRemoveItem(collection, entity);
+                        }
+                    }
+                }
+                entity.setProperty(np.name, null);
+            }
+        }
+        else {
+            if (inverseNp != null) {
+                // npValue is a live list so we need to copy it first.
+                npValue.slice(0).forEach((v) => {
+                    if (inverseNp.isScalar) {
+                        v.setProperty(inverseNp.name, null);
+                    }
+                    else {
+                        // TODO: many to many - not yet handled.
+                    }
+                });
+            }
+            // now clear it.
+            npValue.length = 0;
+        }
+    });
+}
+// note entityAspect only - ( no complex aspect allowed on the call).
+function validate(entityAspect, validator, value, context) {
+    let ve = validator.validate(value, context);
+    if (ve) {
+        entityAspect._addValidationError(ve);
+        return false;
+    }
+    else {
+        let key = ValidationError.getKey(validator, context ? context.propertyName : null);
+        entityAspect._removeValidationError(key);
+        return true;
+    }
+}
+// coIndex is only used where target is a complex object that is part of an array of complex objects
+// in which case ctIndex is the index of the target within the array.
+function validateTarget(target, coIndex) {
+    let ok = true;
+    let stype = target.entityType || target.complexType;
+    let aspect = target.entityAspect || target.complexAspect;
+    let entityAspect = target.entityAspect || target.complexAspect.getEntityAspect();
+    let context = { entity: entityAspect.entity };
+    if (coIndex !== undefined) {
+        context.index = coIndex;
+    }
+    stype.getProperties().forEach(function (p) {
+        let value = target.getProperty(p.name);
+        let validators = p.getAllValidators();
+        if (validators.length > 0) {
+            context.property = p;
+            context.propertyName = aspect.getPropertyPath(p.name);
+            ok = entityAspect._validateProperty(value, context) && ok;
+        }
+        if (p.isComplexProperty) {
+            if (p.isScalar) {
+                ok = validateTarget(value) && ok;
+            }
+            else {
+                ok = value.reduce(function (pv, cv, ix) {
+                    return validateTarget(cv, ix) && pv;
+                }, ok);
+            }
+        }
+    });
+    // then target level
+    stype.getAllValidators().forEach(function (validator) {
+        ok = validate(entityAspect, validator, target) && ok;
+    });
+    return ok;
+}
+/**
+An ComplexAspect instance is associated with every complex object instance and is accessed via the complex object's 'complexAspect' property.
+
+The ComplexAspect itself provides properties to determine the parent object, parent property and original values for the complex object.
+
+A ComplexAspect will almost never need to be constructed directly. You will usually get an ComplexAspect by accessing
+an entities 'complexAspect' property.  This property will be automatically attached when an complex object is created as part of an
+entity via either a query, import or EntityManager.createEntity call.
+>      // assume address is a complex property on the 'Customer' type
+>      var aspect = aCustomer.address.complexAspect;
+>      // aCustomer === aspect.parent;
+**/
+export class ComplexAspect {
+    /** You will rarely, if ever, create a ComplexAspect directly. */
+    constructor(complexObject, parent, parentProperty) {
+        if (!complexObject) {
+            throw new Error("The  ComplexAspect ctor requires an entity as its only argument.");
+        }
+        if (complexObject.complexAspect) {
+            return complexObject.complexAspect;
+        }
+        // if called without new
+        if (!(this instanceof ComplexAspect)) {
+            return new ComplexAspect(complexObject, parent, parentProperty);
+        }
+        // entityType should already be on the entity from 'watch'
+        this.complexObject = complexObject;
+        complexObject.complexAspect = this;
+        // TODO: keep public or not?
+        this.originalValues = {};
+        // if a standalone complexObject
+        if (parent != null) {
+            this.parent = parent;
+            this.parentProperty = parentProperty;
+        }
+        let complexType = complexObject.complexType;
+        if (!complexType) {
+            let typeName = complexObject.prototype._$typeName;
+            if (!typeName) {
+                throw new Error("This entity is not registered as a valid ComplexType");
+            }
+            else {
+                throw new Error("Metadata for this complexType has not yet been resolved: " + typeName);
+            }
+        }
+        let complexCtor = complexType.getCtor();
+        config.interfaceRegistry.modelLibrary.getDefaultInstance().startTracking(complexObject, complexCtor.prototype);
+    }
+    /**
+    Returns the EntityAspect for the top level entity that contains this complex object.
+    **/
+    getEntityAspect() {
+        let parent = this.parent;
+        if (!parent)
+            return new EntityAspect();
+        let entityAspect = parent.entityAspect;
+        while (parent && !entityAspect) {
+            parent = parent.complexAspect && parent.complexAspect.parent;
+            entityAspect = parent && parent.entityAspect;
+        }
+        return entityAspect || new EntityAspect();
+    }
+    /**  @hidden @internal */
+    // TODO: rename - and use '_'; used on both EntityAspect and ComplexAspect for polymorphic reasons.
+    getPropertyPath(propName) {
+        let parent = this.parent;
+        if (!parent)
+            return null;
+        let aspect = parent.complexAspect || parent.entityAspect;
+        return aspect.getPropertyPath(this.parentProperty.name + "." + propName);
+    }
+}
+function clearOriginalValues(target) {
+    let aspect = target.entityAspect || target.complexAspect;
+    aspect.originalValues = {};
+    let stype = target.entityType || target.complexType;
+    stype.complexProperties.forEach(function (cp) {
+        let cos = target.getProperty(cp.name);
+        if (cp.isScalar) {
+            clearOriginalValues(cos);
+        }
+        else {
+            cos._acceptChanges();
+            cos.forEach(clearOriginalValues);
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-aspect.js","sourceRoot":"","sources":["../../../src/entity-aspect.ts"],"names":[],"mappings":"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","sourcesContent":["import { core } from './core';\r\nimport { config } from './config';\r\nimport { BreezeEvent } from './event';\r\nimport { assertParam } from './assert-param';\r\nimport { EntityState  } from './entity-state';\r\nimport { EntityAction } from './entity-action';\r\nimport { EntityType, ComplexType, DataProperty, NavigationProperty, EntityProperty } from './entity-metadata';\r\nimport { EntityKey } from './entity-key';\r\nimport { EntityGroup } from './entity-group';\r\nimport { EntityManager, QueryResult, QueryErrorCallback, QuerySuccessCallback } from './entity-manager';\r\nimport { Validator, ValidationError } from './validate';\r\nimport { EntityQuery } from './entity-query';\r\n\r\nexport interface Entity {\r\n  entityAspect: EntityAspect;\r\n  entityType: EntityType;\r\n  /** @internal */\r\n  getProperty?(prop: string): any;\r\n  /** @internal */\r\n  setProperty?(prop: any, value: any): void;\r\n  /** @hidden @internal */\r\n  prototype?: { _$typeName: string };\r\n  /** @hidden @internal */\r\n  _$entityType?: EntityType;\r\n}\r\n\r\nexport interface ComplexObject {\r\n  complexAspect: ComplexAspect;\r\n  complexType: ComplexType;\r\n  getProperty(prop: string): any;\r\n  setProperty(prop: any, value: any): void;\r\n  /** @hidden @internal */\r\n  prototype?: { _$typeName: string };\r\n}\r\n\r\nexport type StructuralObject = Entity | ComplexObject;\r\n\r\nexport interface PropertyChangedEventArgs {\r\n  entity: Entity;\r\n  propertyName: string | null;\r\n  parent?: StructuralObject;\r\n  property?: EntityProperty;\r\n  oldValue?: any;\r\n  newValue?: any;\r\n}\r\n\r\nexport interface ValidationErrorsChangedEventArgs {\r\n  entity: Entity;\r\n  added: ValidationError[];\r\n  removed: ValidationError[];\r\n}\r\n\r\n/**\r\nAn EntityAspect instance is associated with every attached entity and is accessed via the entity's 'entityAspect' property.\r\n\r\nThe EntityAspect itself provides properties to determine and modify the EntityState of the entity and has methods\r\nthat provide a variety of services including validation and change tracking.\r\n\r\nAn EntityAspect will almost never need to be constructed directly. You will usually get an EntityAspect by accessing\r\nan entities 'entityAspect' property.  This property will be automatically attached when an entity is created via either\r\na query, import or [[EntityManager.createEntity]] call.\r\n>      // assume order is an order entity attached to an EntityManager.\r\n>      var aspect = order.entityAspect;\r\n>      var currentState = aspect.entityState;\r\n\r\n**/\r\nexport class EntityAspect {\r\n  /** The Entity that this aspect is associated with. __Read Only__  **/\r\n  entity?: Entity;\r\n  /** The [[EntityManager]] that contains this entity. __Read Only__ **/\r\n  entityManager?: EntityManager;\r\n  /**  @hidden @internal */\r\n  entityGroup?: EntityGroup;\r\n  /** The [[EntityState]] of this entity. __Read Only__ **/\r\n  entityState: EntityState;\r\n  /**   Whether this entity is in the process of being saved. __Read Only__ */\r\n  isBeingSaved: boolean;\r\n  /** The 'original values' of this entity where they are different from the 'current values'.\r\n  This is a map where the key is a property name and the value is the 'original value' of the property. */\r\n  originalValues: {};\r\n  /**  Whether this entity has any validation errors. __Read Only__ */\r\n  hasValidationErrors: boolean;\r\n  /** Whether this entity has a temporary [[EntityKey]]. */\r\n  hasTempKey: boolean;\r\n  /** Whether this entity was created by being loaded from the database */\r\n  wasLoaded?: boolean;\r\n  /** Extra metadata about this entity such as the entity's etag.\r\n  You may extend this object with your own metadata information.\r\n  Breeze (de)serializes this object when importing/exporting the entity. **/\r\n  extraMetadata?: any;\r\n  /**\r\n  A [[BreezeEvent]] that fires whenever any of the validation errors on this entity change.\r\n  Note that this might be the removal of an error when some data on the entity is fixed.\r\n  @eventArgs - \r\n    - entity - The entity on which the validation errors are being added or removed.\r\n    - added - An array containing any newly added [[ValidationError]]s\r\n    - removed - An array containing any newly removed [[ValidationError]]s. This is those\r\n      errors that have been 'fixed'.\r\n\r\n>      // assume order is an order entity attached to an EntityManager.\r\n>      order.entityAspect.validationErrorsChanged.subscribe(\r\n>      function (validationChangeArgs) {\r\n>          // this code will be executed anytime a property value changes on the 'order' entity.\r\n>          var entity == validationChangeArgs.entity; // Note: entity === order\r\n>          var errorsAdded = validationChangeArgs.added;\r\n>          var errorsCleared = validationChangeArgs.removed;\r\n>      });\r\n  @event\r\n  **/\r\n  validationErrorsChanged: BreezeEvent<ValidationErrorsChangedEventArgs>;\r\n  /**\r\n  A [[BreezeEvent]] that fires whenever a value of one of this entity's properties change.\r\n  @eventArgs -\r\n    - entity - The entity whose property has changed.\r\n    - property - The [[DataProperty]] that changed.\r\n    - propertyName - The name of the property that changed. This value will be 'null' for operations that replace the entire entity.  This includes\r\n      queries, imports and saves that require a merge. The remaining parameters will not exist in this case either. This will actually be a \"property path\"\r\n      for any properties of a complex type.\r\n    - oldValue - The old value of this property before the change.\r\n    - newValue - The new value of this property after the change.\r\n    - parent - The immediate parent object for the changed property.  This will be a ComplexType instance as opposed to an Entity \r\n      for any complex type or nested complex type properties.\r\n\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      order.entityAspect.propertyChanged.subscribe(\r\n  >      function (propertyChangedArgs) {\r\n  >          // this code will be executed anytime a property value changes on the 'order' entity.\r\n  >          var entity = propertyChangedArgs.entity; // Note: entity === order\r\n  >          var propertyNameChanged = propertyChangedArgs.propertyName;\r\n  >          var oldValue = propertyChangedArgs.oldValue;\r\n  >          var newValue = propertyChangedArgs.newValue;\r\n  >      });\r\n  @event\r\n  **/\r\n  propertyChanged: BreezeEvent<PropertyChangedEventArgs>;\r\n\r\n  /** @hidden @internal */\r\n  _validationErrors: { [index: string]: ValidationError };\r\n  /** @hidden @internal */\r\n  _pendingValidationResult: any;\r\n  /** @hidden @internal */\r\n  _entityKey: EntityKey;\r\n  /** @hidden @internal */\r\n  _loadedNps: any[];\r\n  /** @hidden @internal */\r\n  _initialized?: boolean;\r\n  /** @hidden @internal */\r\n  _inProcess: any[]; // used in defaultPropertyInterceptor for temp storage.\r\n  /** @hidden @internal */\r\n  _inProcessEntity?: Entity; // used in EntityManager\r\n  /** @hidden @internal */\r\n  static _nullInstance = new EntityAspect(); // TODO: determine if this works\r\n  /** @hidden @internal */\r\n  constructor(entity?: Entity) {\r\n\r\n    // if called without new\r\n    // if (!(this instanceof EntityAspect)) {\r\n    //   return new EntityAspect(entity);\r\n    // }\r\n\r\n    this.entity = entity;\r\n    // TODO: keep public or not?\r\n    this.entityGroup = undefined;\r\n    this.entityManager = undefined;\r\n    this.entityState = EntityState.Detached;\r\n    this.isBeingSaved = false;\r\n    this.originalValues = {};\r\n    this.hasValidationErrors = false;\r\n    this._validationErrors = {};\r\n\r\n    // Uncomment when we implement entityAspect.isNavigationPropertyLoaded method\r\n    // this._loadedNavPropMap = {};\r\n\r\n    this.validationErrorsChanged = new BreezeEvent(\"validationErrorsChanged\", this);\r\n    this.propertyChanged = new BreezeEvent(\"propertyChanged\", this);\r\n    // in case this is the NULL entityAspect. - used with ComplexAspects that have no parent.\r\n\r\n    if (entity != null) {\r\n      // remove properties that should be on prototype but placed on class by Babel\r\n      if (!entity.entityType) { delete(entity.entityType); }\r\n      if (!entity.entityAspect) { delete(entity.entityAspect); }\r\n      entity.entityAspect = this;\r\n\r\n      // entityType should already be on the entity from 'watch'\r\n      let entityType = entity.entityType || entity._$entityType;\r\n      if (!entityType) {\r\n        let typeName = entity.prototype._$typeName;\r\n        if (!typeName) {\r\n          throw new Error(\"This entity is not registered as a valid EntityType\");\r\n        } else {\r\n          throw new Error(\"Metadata for this entityType has not yet been resolved: \" + typeName);\r\n        }\r\n      }\r\n      let entityCtor = entityType.getEntityCtor();\r\n      config.interfaceRegistry.modelLibrary.getDefaultInstance().startTracking(entity, entityCtor.prototype);\r\n    }\r\n  }\r\n\r\n  /** @hidden */\r\n  // type-guard\r\n  static isEntity(obj: StructuralObject): obj is Entity {\r\n    return (obj as any).entityAspect != null;\r\n  }\r\n\r\n  // No longer used\r\n  // static createFrom(entity: Entity): EntityAspect {\r\n  //   if (entity == null) {\r\n  //     return EntityAspect._nullInstance;\r\n  //   } else if (entity.entityAspect) {\r\n  //     return entity.entityAspect;\r\n  //   }\r\n  //   return new EntityAspect(entity);\r\n  // }\r\n\r\n  // TODO: refactor this and the instance getPropertyValue method.\r\n  /**\r\n  Returns the value of a specified 'property path' for a specified entity.\r\n\r\n  The propertyPath can be either a string delimited with '.' or a string array.  \r\n  **/\r\n  // used by EntityQuery and Predicate\r\n  static getPropertyPathValue(obj: Entity, propertyPath: string | string[]) {\r\n    let properties = Array.isArray(propertyPath) ? propertyPath : propertyPath.split(\".\");\r\n    if (properties.length === 1) {\r\n      return obj.getProperty(propertyPath as string);\r\n    } else {\r\n      let nextValue = obj;\r\n      // hack use of some to perform mapFirst operation.\r\n      properties.some((prop) => {\r\n        nextValue = nextValue.getProperty(prop);\r\n        return nextValue == null;\r\n      });\r\n      return nextValue;\r\n    }\r\n  }\r\n\r\n  /**\r\n  Returns the [[EntityKey]] for this Entity.\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      var entityKey = order.entityAspect.getKey();\r\n  @param forceRefresh - (boolean=false) Forces the recalculation of the key.  This should normally be unnecessary.\r\n  @return The [[EntityKey]] associated with this Entity.\r\n  **/\r\n  getKey(forceRefresh: boolean = false) {\r\n    forceRefresh = assertParam(forceRefresh, \"forceRefresh\").isBoolean().isOptional().check(false);\r\n    if (forceRefresh || !this._entityKey) {\r\n      let entityType = this.entity!.entityType;\r\n      let keyProps = entityType.keyProperties;\r\n      let values = keyProps.map(function (p) {\r\n        return this.entity.getProperty(p.name);\r\n      }, this);\r\n      this._entityKey = new EntityKey(entityType, values);\r\n    }\r\n    return this._entityKey;\r\n  }\r\n\r\n  /**\r\n  Returns the entity to an [[EntityState]] of 'Unchanged' by committing all changes made since the entity was last queried\r\n  had 'acceptChanges' called on it.\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      order.entityAspect.acceptChanges();\r\n  >      // The 'order' entity will now be in an 'Unchanged' state with any changes committed.\r\n  **/\r\n  acceptChanges() {\r\n    if (!this.entity) return;\r\n    this._checkOperation(\"acceptChanges\");\r\n    let em = this.entityManager!;\r\n    if (this.entityState.isDeleted()) {\r\n      em.detachEntity(this.entity);\r\n    } else {\r\n      this.setUnchanged();\r\n    }\r\n    em.entityChanged.publish({ entityAction: EntityAction.AcceptChanges, entity: this.entity });\r\n  }\r\n\r\n  /**\r\n  Returns the entity to an [[EntityState]] of 'Unchanged' by rejecting all changes made to it since the entity was last queried\r\n  had 'rejectChanges' called on it.\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      order.entityAspect.rejectChanges();\r\n  >      // The 'order' entity will now be in an 'Unchanged' state with any changes rejected.\r\n  **/\r\n  rejectChanges() {\r\n    this._checkOperation(\"rejectChanges\");\r\n    let entity = this.entity!;\r\n    let entityManager = this.entityManager!;\r\n    // we do not want PropertyChange or EntityChange events to occur here\r\n    core.using(entityManager, \"isRejectingChanges\", true, function () {\r\n      rejectChangesCore(entity);\r\n    });\r\n    if (this.entityState.isAdded()) {\r\n      // next line is needed because the following line will cause this.entityManager -> null;\r\n      entityManager.detachEntity(entity);\r\n      // need to tell em that an entity that needed to be saved no longer does.\r\n      entityManager._notifyStateChange(entity, false);\r\n    } else {\r\n      if (this.entityState.isDeleted()) {\r\n        entityManager._linkRelatedEntities(entity);\r\n      }\r\n      this.setUnchanged();\r\n      // propertyChanged propertyName is not specified because more than one property may have changed.\r\n      this.propertyChanged.publish({ entity: entity, propertyName: null });\r\n      entityManager.entityChanged.publish({ entityAction: EntityAction.RejectChanges, entity: entity });\r\n    }\r\n  }\r\n\r\n  /**  @hidden @internal */\r\n  // TODO: rename - and use '_'; used on both EntityAspect and ComplexAspect for polymorphic reasons.\r\n  getPropertyPath(propName: string) {\r\n    return propName;\r\n  }\r\n\r\n  /**\r\n  Sets the entity to an EntityState of 'Added'.  This is NOT the equivalent of calling [[EntityManager.addEntity]]\r\n  because no key generation will occur for autogenerated keys as a result of this operation. As a result this operation can be problematic\r\n  unless you are certain that the entity being marked 'Added' does not already exist in the database and does not have an autogenerated key.\r\n  The same operation can be performed by calling [[EntityAspect.setEntityState]].\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      order.entityAspect.setAdded();\r\n  >      // The 'order' entity will now be in an 'Added' state.\r\n  **/\r\n  setAdded() {\r\n    return this.setEntityState(EntityState.Added);\r\n  }\r\n\r\n  /**\r\n  Sets the entity to an EntityState of 'Unchanged'.  This is also the equivalent of calling [[EntityAspect.acceptChanges]].\r\n  The same operation can be performed by calling [[EntityAspect.setEntityState]].\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      order.entityAspect.setUnchanged();\r\n  >      // The 'order' entity will now be in an 'Unchanged' state with any changes committed.\r\n  **/\r\n  setUnchanged = function () {\r\n    return this.setEntityState(EntityState.Unchanged);\r\n  };\r\n\r\n\r\n  /**\r\n  Sets the entity to an EntityState of 'Modified'.  This can also be achieved by changing the value of any property on an 'Unchanged' entity.\r\n  The same operation can be performed by calling [[EntityAspect.setEntityState]].\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      order.entityAspect.setModified();\r\n  >      // The 'order' entity will now be in a 'Modified' state.\r\n  **/\r\n  setModified = function () {\r\n    return this.setEntityState(EntityState.Modified);\r\n  };\r\n\r\n  /**\r\n  Sets the entity to an EntityState of 'Deleted'.  This both marks the entity as being scheduled for deletion during the next 'Save' call\r\n  but also removes the entity from all of its related entities.\r\n  The same operation can be performed by calling [[EntityAspect.setEntityState]].\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      order.entityAspect.setDeleted();\r\n  >      // The 'order' entity will now be in a 'Deleted' state and it will no longer have any 'related' entities.\r\n  **/\r\n  setDeleted = function () {\r\n    return this.setEntityState(EntityState.Deleted);\r\n  };\r\n\r\n  /**\r\n  Sets the entity to an EntityState of 'Detached'.  This removes the entity from all of its related entities, but does NOT change the EntityState of any existing entities.\r\n  The same operation can be performed by calling [[EntityAspect.setEntityState]].\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      order.entityAspect.setDetached();\r\n  >      // The 'order' entity will now be in a 'Detached' state and it will no longer have any 'related' entities.\r\n  **/\r\n  setDetached = function () {\r\n    return this.setEntityState(EntityState.Detached);\r\n  };\r\n\r\n  /**\r\n  Sets the entity to the specified EntityState. See also 'setUnchanged', 'setModified', 'setDetached', etc.\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      order.entityAspect.setEntityState(EntityState.Unchanged);\r\n  >      // The 'order' entity will now be in a 'Unchanged' state.\r\n  **/\r\n  setEntityState(entityState: EntityState) {\r\n    if (this.entityState === entityState) return false;\r\n    this._checkOperation(\"setEntityState\");\r\n    if (this.entityState.isDetached()) {\r\n      throw new Error(\"You cannot set the 'entityState' of an entity when it is detached - except by first attaching it to an EntityManager\");\r\n    }\r\n    let entity = this.entity!;\r\n    let em = this.entityManager!;\r\n    let needsSave = true;\r\n    if (entityState === EntityState.Unchanged) {\r\n      clearOriginalValues(entity);\r\n      delete this.hasTempKey;\r\n      needsSave = false;\r\n    } else if (entityState === EntityState.Added) {\r\n      clearOriginalValues(entity);\r\n      // TODO: more to do here... like regenerating key ???\r\n    } else if (entityState === EntityState.Deleted) {\r\n      if (this.entityState.isAdded()) {\r\n        // turn it into a detach and exit early\r\n        this.setEntityState(EntityState.Detached);\r\n        return true;\r\n      } else {\r\n        // TODO: think about cascade deletes\r\n        // entityState needs to be set it early in this one case to insure that fk's are not cleared.\r\n        this.entityState = EntityState.Deleted;\r\n        removeFromRelations(entity, EntityState.Deleted);\r\n      }\r\n    } else if (entityState === EntityState.Modified) {\r\n      // nothing extra needed\r\n    } else if (entityState === EntityState.Detached) {\r\n      let group = this.entityGroup;\r\n      // no group === already detached.\r\n      if (!group) return false;\r\n      group.detachEntity(entity);\r\n      // needs to occur early here - so this IS deliberately redundent with the same code later in this method.\r\n      this.entityState = entityState;\r\n      removeFromRelations(entity, EntityState.Detached);\r\n      this._detach();\r\n      em.entityChanged.publish({ entityAction: EntityAction.Detach, entity: entity });\r\n      needsSave = false;\r\n    }\r\n    this.entityState = entityState;\r\n    em._notifyStateChange(entity, needsSave);\r\n    return true;\r\n  }\r\n\r\n  loadNavigationProperty(navigationProperty: string, callback?: QuerySuccessCallback, errorCallback?: QueryErrorCallback): Promise<QueryResult>;\r\n  loadNavigationProperty(navigationProperty: NavigationProperty, callback?: QuerySuccessCallback, errorCallback?: QueryErrorCallback): Promise<QueryResult>;\r\n  /**\r\n  Performs a query for the value of a specified [[NavigationProperty]]. __Async__\r\n  >      emp.entityAspect.loadNavigationProperty(\"Orders\").then(function (data) {\r\n  >          var orders = data.results;\r\n  >      }).catch(function (exception) {\r\n  >          // handle exception here;\r\n  >      });\r\n  @param navigationProperty - The NavigationProperty or the name of the NavigationProperty to 'load'.\r\n  @param callback - Function to call on success.\r\n  @param errorCallback - Function to call on failure.\r\n  @return Promise with shape\r\n    - results {Array of Entity}\r\n    - query {EntityQuery} The original query\r\n    - httpResponse {httpResponse} The HttpResponse returned from the server.\r\n  **/\r\n  loadNavigationProperty(navigationProperty: NavigationProperty | string, callback: QuerySuccessCallback, errorCallback: QueryErrorCallback) {\r\n    let entity = this.entity!;\r\n    let navProperty = entity.entityType._checkNavProperty(navigationProperty);\r\n    let query = EntityQuery.fromEntityNavigation(entity, navProperty);\r\n    // return entity.entityAspect.entityManager.executeQuery(query, callback, errorCallback);\r\n    let promise = entity.entityAspect.entityManager!.executeQuery(query);\r\n\r\n    return promise.then((data) => {\r\n      this._markAsLoaded(navProperty.name);\r\n      if (callback) callback(data);\r\n      return Promise.resolve(data);\r\n    }, (error) => {\r\n      if (errorCallback) errorCallback(error);\r\n      return Promise.reject(error);\r\n    });\r\n\r\n  }\r\n\r\n  /**\r\n  Marks this navigationProperty on this entity as already having been loaded.\r\n  >      emp.entityAspect.markNavigationPropertyAsLoaded(\"Orders\");\r\n  @param navigationProperty - The NavigationProperty or name of NavigationProperty to 'load'.\r\n  **/\r\n  markNavigationPropertyAsLoaded(navigationProperty: NavigationProperty | string) {\r\n    if (!this.entity) return;\r\n    let navProperty = this.entity.entityType._checkNavProperty(navigationProperty);\r\n    this._markAsLoaded(navProperty.name);\r\n  }\r\n\r\n  isNavigationPropertyLoaded(navigationProperty: string): boolean;\r\n  isNavigationPropertyLoaded(navigationProperty: NavigationProperty): boolean;\r\n  /**\r\n  Determines whether a navigationProperty on this entity has already been loaded.\r\n\r\n  A navigation property is considered loaded when any of the following three conditions applies:\r\n\r\n    1. It was fetched from the backend server.\r\n        <br/>   This can be the result of an expand query or a call to the [[EntityAspect.loadNavigationProperty]] method.\r\n        <br/>   Note that even if the fetch returns nothing the property is still marked as loaded in this case.\r\n    1. The property is scalar and has been set to a nonnull value.\r\n    1. The [[EntityAspect.markNavigationPropertyAsLoaded]] was called.\r\n  \r\n  >     var wasLoaded = emp.entityAspect.isNavigationPropertyLoaded(\"Orders\");\r\n  @param navigationProperty - The NavigationProperty or name of NavigationProperty to 'load'.\r\n  **/\r\n  isNavigationPropertyLoaded(navigationProperty: NavigationProperty | string) {\r\n    if (!this.entity) return;\r\n    let navProperty = this.entity.entityType._checkNavProperty(navigationProperty);\r\n    if (navProperty.isScalar && this.entity.getProperty(navProperty.name) != null) {\r\n      return true;\r\n    }\r\n    return this._loadedNps && this._loadedNps.indexOf(navProperty.name) >= 0;\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _markAsLoaded(navPropName: string) {\r\n    this._loadedNps = this._loadedNps || [];\r\n    core.arrayAddItemUnique(this._loadedNps, navPropName);\r\n  }\r\n\r\n\r\n  /**\r\n  Performs validation on the entity, any errors encountered during the validation are available via the\r\n  [[EntityAspect.getValidationErrors]] method. Validating an entity means executing\r\n  all of the validators on both the entity itself as well as those on each of its properties.\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      var isOk = order.entityAspect.validateEntity();\r\n  >      // isOk will be 'true' if there are no errors on the entity.\r\n  >      if (!isOk) {\r\n  >          var errors = order.entityAspect.getValidationErrors();\r\n  >      }\r\n  @return Whether the entity passed validation.\r\n  **/\r\n  validateEntity() {\r\n    let ok = true;\r\n    this._processValidationOpAndPublish(function (that: any) {\r\n      ok = validateTarget(that.entity);\r\n    });\r\n    return ok;\r\n  }\r\n\r\n  validateProperty(property: string, context?: any): boolean;\r\n  validateProperty(property: DataProperty, context?: any): boolean;\r\n  validateProperty(property: NavigationProperty, context?: any): boolean;\r\n  /**\r\n  Performs validation on a specific property of this entity, any errors encountered during the validation are available via the\r\n  [[EntityAspect.getValidationErrors]] method. Validating a property means executing\r\n  all of the validators on the specified property.  This call is also made automatically anytime a property\r\n  of an entity is changed.\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      var isOk = order.entityAspect.validateProperty(\"Order\");\r\n\r\n  or\r\n  >      var orderDateProperty = order.entityType.getProperty(\"OrderDate\");\r\n  >      var isOk = order.entityAspect.validateProperty(OrderDateProperty);\r\n  @param property - The [[DataProperty]] or [[NavigationProperty]] to validate or a string \r\n  with the name of the property or a property path with the path to a property of a complex object.\r\n  @param context -  A context object used to pass additional information to each [[Validator]].\r\n  @return Whether the entity passed validation.\r\n  **/\r\n  validateProperty(property: EntityProperty | string, context: any) {\r\n    let value = this.getPropertyValue(property); // performs validations\r\n    if (value && value.complexAspect) {\r\n      return validateTarget(value);\r\n    }\r\n    context = context || {};\r\n    context.entity = this.entity;\r\n    if (typeof property === \"string\") {\r\n      context.property = this.entity!.entityType.getProperty(property, true);\r\n      context.propertyName = property;\r\n    } else {\r\n      context.property = property;\r\n      context.propertyName = property.name;\r\n    }\r\n\r\n    return this._validateProperty(value, context);\r\n  }\r\n\r\n  getValidationErrors(): ValidationError[];\r\n  getValidationErrors(property: string): ValidationError[];\r\n  getValidationErrors(property: EntityProperty): ValidationError[];\r\n  /**\r\n  Returns the validation errors associated with either the entire entity or any specified property.\r\n  \r\n  This method can return all of the errors for an Entity\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      var valErrors = order.entityAspect.getValidationErrors();\r\n\r\n  as well as those for just a specific property.\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      var orderDateErrors = order.entityAspect.getValidationErrors(\"OrderDate\");\r\n\r\n  which can also be expressed as\r\n  >      // assume order is an order entity attached to an EntityManager.\r\n  >      var orderDateProperty = order.entityType.getProperty(\"OrderDate\");\r\n  >      var orderDateErrors = order.entityAspect.getValidationErrors(orderDateProperty);\r\n  @param property - The property for which validation errors should be retrieved.\r\n  If omitted, all of the validation errors for this entity will be returned.\r\n  @return A array of validation errors.\r\n  **/\r\n  getValidationErrors(property?: DataProperty | NavigationProperty | string) {\r\n    assertParam(property, \"property\").isOptional().isEntityProperty().or().isString().check();\r\n    let result = core.getOwnPropertyValues(this._validationErrors);\r\n    if (property) {\r\n      let propertyName = typeof (property) === 'string' ? property : property.name;\r\n      result = result.filter(function (ve: ValidationError) {\r\n        return ve.property && (ve.property.name === propertyName || (propertyName.indexOf(\".\") !== -1 && ve.propertyName === propertyName));\r\n      });\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /**\r\n  Adds a validation error.\r\n  **/\r\n  addValidationError(validationError: ValidationError) {\r\n    assertParam(validationError, \"validationError\").isInstanceOf(ValidationError).check();\r\n    this._processValidationOpAndPublish(function (that: any) {\r\n      that._addValidationError(validationError);\r\n    });\r\n  }\r\n\r\n  removeValidationError(validationError: ValidationError): void;\r\n  removeValidationError(validationKey: string): void;\r\n  /**\r\n  Removes a validation error.\r\n  @param validationErrorOrKey - Either a ValidationError or a ValidationError 'key' value\r\n  **/\r\n  removeValidationError(validationErrorOrKey: ValidationError | string) {\r\n    assertParam(validationErrorOrKey, \"validationErrorOrKey\").isString().or().isInstanceOf(ValidationError).or().isInstanceOf(Validator).check();\r\n\r\n    let key = (typeof (validationErrorOrKey) === \"string\") ? validationErrorOrKey : validationErrorOrKey.key;\r\n    this._processValidationOpAndPublish(function (that: any) {\r\n      that._removeValidationError(key);\r\n    });\r\n  }\r\n\r\n  /**\r\n  Removes all of the validation errors for a specified entity\r\n  **/\r\n  clearValidationErrors() {\r\n    this._processValidationOpAndPublish(function (that: any) {\r\n      core.objectForEach(that._validationErrors, function (key: string, valError: ValidationError) {\r\n        if (valError) {\r\n          delete that._validationErrors[key];\r\n          that._pendingValidationResult.removed.push(valError);\r\n        }\r\n      });\r\n      that.hasValidationErrors = !core.isEmpty(that._validationErrors);\r\n    });\r\n  }\r\n\r\n  /**\r\n  Returns an [[EntityKey]] for the entity pointed to by the specified scalar NavigationProperty.\r\n  This only returns an EntityKey if the current entity is a 'child' entity along the specified NavigationProperty. \r\n  i.e. has a single parent.\r\n\r\n  @param navigationProperty - The [[NavigationProperty]] ( pointing to a parent). \r\n  @returns Either a parent EntityKey if this is a 'child' entity or null;  \r\n  */\r\n  getParentKey(navigationProperty: NavigationProperty) {\r\n    if (!this.entity) return null;\r\n    // TODO: review this - not sure about the comment.\r\n    // NavigationProperty doesn't yet exist\r\n    // assertParam(navigationProperty, \"navigationProperty\").isInstanceOf(NavigationProperty).check();\r\n    let fkNames = navigationProperty.foreignKeyNames;\r\n    if (fkNames.length === 0) return null;\r\n    let that = this;\r\n    let fkValues = fkNames.map(function (fkn) {\r\n      return that.entity!.getProperty(fkn);\r\n    });\r\n    return new EntityKey(navigationProperty.entityType, fkValues);\r\n  }\r\n\r\n  // TODO: refactor this and the static getPropertyPathValue.\r\n  /**\r\n  Returns the value of a specified DataProperty or NavigationProperty or 'property path'.  \r\n  **/\r\n  getPropertyValue(property: string | DataProperty | NavigationProperty) {\r\n    assertParam(property, \"property\").isString().or().isEntityProperty().check();\r\n    let value: any;\r\n    if (typeof (property) === 'string') {\r\n      let propNames = property.trim().split(\".\");\r\n      let propName = propNames.shift();\r\n      value = this.entity;\r\n      value = value.getProperty(propName);\r\n      while (propNames.length > 0) {\r\n        propName = propNames.shift();\r\n        value = value.getProperty(propName);\r\n      }\r\n    } else {\r\n      if (!(property.parentType instanceof EntityType)) {\r\n        throw new Error(\"The validateProperty method does not accept a 'property' parameter whose parentType is a ComplexType; \" +\r\n          \"Pass a 'property path' string as the 'property' parameter instead \");\r\n      }\r\n      value = this.entity!.getProperty(property.name);\r\n    }\r\n    return value;\r\n  }\r\n\r\n  // internal methods\r\n  /** @hidden @internal */\r\n  _checkOperation(operationName: string) {\r\n    if (this.isBeingSaved) {\r\n      throw new Error(\"Cannot perform a '\" + operationName + \"' on an entity that is in the process of being saved\");\r\n    }\r\n    // allows chaining\r\n    return this;\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _detach() {\r\n    this.entityGroup = undefined;\r\n    this.entityManager = undefined;\r\n    this.entityState = EntityState.Detached;\r\n    this.originalValues = {};\r\n    this._validationErrors = {};\r\n    this.hasValidationErrors = false;\r\n    this.validationErrorsChanged.clear();\r\n    this.propertyChanged.clear();\r\n\r\n  }\r\n\r\n\r\n  // called from defaultInterceptor.\r\n  /** @hidden @internal */\r\n  _validateProperty(value: any, context: any) {\r\n    let ok = true;\r\n    this._processValidationOpAndPublish(function (that: any) {\r\n      context.property.getAllValidators().forEach(function (validator: Validator) {\r\n        ok = validate(that, validator, value, context) && ok;\r\n      });\r\n    });\r\n    return ok;\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _processValidationOpAndPublish(validationFn: any) {\r\n    if (this._pendingValidationResult) {\r\n      // only top level processValidations call publishes\r\n      validationFn(this);\r\n    } else {\r\n      try {\r\n        this._pendingValidationResult = { entity: this.entity, added: [], removed: [] };\r\n        validationFn(this);\r\n        if (this._pendingValidationResult.added.length > 0 || this._pendingValidationResult.removed.length > 0) {\r\n          this.validationErrorsChanged.publish(this._pendingValidationResult);\r\n          // this might be a detached entity hence the guard below.\r\n          this.entityManager && this.entityManager.validationErrorsChanged.publish(this._pendingValidationResult);\r\n\r\n        }\r\n      } finally {\r\n        this._pendingValidationResult = undefined;\r\n      }\r\n    }\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  // TODO: add/use a ValidationError type\r\n  _addValidationError(validationError: any) {\r\n    this._validationErrors[validationError.key] = validationError;\r\n    this.hasValidationErrors = true;\r\n    this._pendingValidationResult.added.push(validationError);\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _removeValidationError(key: string) {\r\n    let valError = this._validationErrors[key];\r\n    if (valError) {\r\n      delete this._validationErrors[key];\r\n      this.hasValidationErrors = !core.isEmpty(this._validationErrors);\r\n      this._pendingValidationResult.removed.push(valError);\r\n    }\r\n  }\r\n\r\n}\r\n\r\nBreezeEvent.bubbleEvent(EntityAspect.prototype, function () {\r\n  return this.entityManager;\r\n});\r\n\r\nfunction rejectChangesCore(target: any) {\r\n  let aspect = target.entityAspect || target.complexAspect;\r\n  let stype = target.entityType || target.complexType;\r\n  let originalValues = aspect.originalValues;\r\n  for (let propName in originalValues) {\r\n    target.setProperty(propName, originalValues[propName]);\r\n  }\r\n  stype.complexProperties.forEach(function (cp: any) {\r\n    let cos = target.getProperty(cp.name);\r\n    if (cp.isScalar) {\r\n      rejectChangesCore(cos);\r\n    } else {\r\n      cos._rejectChanges();\r\n      cos.forEach(rejectChangesCore);\r\n    }\r\n  });\r\n}\r\n\r\nfunction removeFromRelations(entity: Entity, entityState: EntityState) {\r\n  // remove this entity from any collections.\r\n  // mark the entity deleted or detached\r\n\r\n  let isDeleted = entityState.isDeleted();\r\n  if (isDeleted) {\r\n    removeFromRelationsCore(entity);\r\n  } else {\r\n    core.using(entity.entityAspect.entityManager!, \"isLoading\", true, function () {\r\n      removeFromRelationsCore(entity);\r\n    });\r\n  }\r\n}\r\n\r\nfunction removeFromRelationsCore(entity: Entity) {\r\n  entity.entityType.navigationProperties.forEach(function (np) {\r\n    let inverseNp = np.inverse;\r\n    let npValue = entity.getProperty(np.name);\r\n    if (np.isScalar) {\r\n      if (npValue) {\r\n        if (inverseNp) {\r\n          if (inverseNp.isScalar) {\r\n            npValue.setProperty(inverseNp.name, null);\r\n          } else {\r\n            let collection = npValue.getProperty(inverseNp.name);\r\n            if (collection.length) {\r\n              core.arrayRemoveItem(collection, entity);\r\n            }\r\n          }\r\n        }\r\n        entity.setProperty(np.name, null);\r\n      }\r\n    } else {\r\n      if (inverseNp != null) {\r\n        // npValue is a live list so we need to copy it first.\r\n        npValue.slice(0).forEach((v: any) => {\r\n          if (inverseNp!.isScalar) {\r\n            v.setProperty(inverseNp!.name, null);\r\n          } else {\r\n            // TODO: many to many - not yet handled.\r\n          }\r\n        });\r\n      }\r\n      // now clear it.\r\n      npValue.length = 0;\r\n    }\r\n  });\r\n\r\n}\r\n\r\n// note entityAspect only - ( no complex aspect allowed on the call).\r\nfunction validate(entityAspect: EntityAspect, validator: Validator, value: any, context?: any) {\r\n  let ve = validator.validate(value, context);\r\n  if (ve) {\r\n    entityAspect._addValidationError(ve);\r\n    return false;\r\n  } else {\r\n    let key = ValidationError.getKey(validator, context ? context.propertyName : null);\r\n    entityAspect._removeValidationError(key);\r\n    return true;\r\n  }\r\n}\r\n\r\n// coIndex is only used where target is a complex object that is part of an array of complex objects\r\n// in which case ctIndex is the index of the target within the array.\r\nfunction validateTarget(target: any, coIndex?: number) {\r\n  let ok = true;\r\n  let stype = target.entityType || target.complexType;\r\n  let aspect = target.entityAspect || target.complexAspect;\r\n  let entityAspect = target.entityAspect || target.complexAspect.getEntityAspect();\r\n  let context = <any>{ entity: entityAspect.entity };\r\n  if (coIndex !== undefined) {\r\n    context.index = coIndex;\r\n  }\r\n\r\n  stype.getProperties().forEach(function (p: any) {\r\n    let value = target.getProperty(p.name);\r\n    let validators = p.getAllValidators();\r\n    if (validators.length > 0) {\r\n      context.property = p;\r\n      context.propertyName = aspect.getPropertyPath(p.name);\r\n      ok = entityAspect._validateProperty(value, context) && ok;\r\n    }\r\n    if (p.isComplexProperty) {\r\n      if (p.isScalar) {\r\n        ok = validateTarget(value) && ok;\r\n      } else {\r\n        ok = value.reduce(function (pv: any, cv: any, ix: number) {\r\n          return validateTarget(cv, ix) && pv;\r\n        }, ok);\r\n      }\r\n    }\r\n  });\r\n\r\n\r\n  // then target level\r\n  stype.getAllValidators().forEach(function (validator: Validator) {\r\n    ok = validate(entityAspect, validator, target) && ok;\r\n  });\r\n  return ok;\r\n}\r\n\r\n/**\r\nAn ComplexAspect instance is associated with every complex object instance and is accessed via the complex object's 'complexAspect' property.\r\n\r\nThe ComplexAspect itself provides properties to determine the parent object, parent property and original values for the complex object.\r\n\r\nA ComplexAspect will almost never need to be constructed directly. You will usually get an ComplexAspect by accessing\r\nan entities 'complexAspect' property.  This property will be automatically attached when an complex object is created as part of an\r\nentity via either a query, import or EntityManager.createEntity call.\r\n>      // assume address is a complex property on the 'Customer' type\r\n>      var aspect = aCustomer.address.complexAspect;\r\n>      // aCustomer === aspect.parent;\r\n**/\r\nexport class ComplexAspect {\r\n\r\n  /** The complex object that this aspect is associated with. __Read Only__ */\r\n  complexObject: ComplexObject;\r\n  /** The 'original values' of this complex object where they are different from the 'current values'.\r\n  This is a map where the key is a property name and the value is the 'original value' of the property.\r\n  __Read Only__ */\r\n  originalValues: {};\r\n  /** The parent object that to which this aspect belongs; this will either be an entity or another complex object. __Read Only__ */\r\n  parent?: StructuralObject;\r\n  /** The [[DataProperty]] on the 'parent' that contains this complex object. __Read Only__ */\r\n  parentProperty?: DataProperty;\r\n  extraMetadata?: any;\r\n\r\n  /** You will rarely, if ever, create a ComplexAspect directly. */\r\n  constructor(complexObject: ComplexObject, parent: StructuralObject, parentProperty: DataProperty) {\r\n    if (!complexObject) {\r\n      throw new Error(\"The  ComplexAspect ctor requires an entity as its only argument.\");\r\n    }\r\n    if (complexObject.complexAspect) {\r\n      return complexObject.complexAspect;\r\n    }\r\n    // if called without new\r\n    if (!(this instanceof ComplexAspect)) {\r\n      return new ComplexAspect(complexObject, parent, parentProperty);\r\n    }\r\n\r\n    // entityType should already be on the entity from 'watch'\r\n    this.complexObject = complexObject;\r\n    complexObject.complexAspect = this;\r\n\r\n    // TODO: keep public or not?\r\n    this.originalValues = {};\r\n\r\n    // if a standalone complexObject\r\n    if (parent != null) {\r\n      this.parent = parent;\r\n      this.parentProperty = parentProperty;\r\n    }\r\n\r\n    let complexType = complexObject.complexType;\r\n    if (!complexType) {\r\n      let typeName = complexObject.prototype._$typeName;\r\n      if (!typeName) {\r\n        throw new Error(\"This entity is not registered as a valid ComplexType\");\r\n      } else {\r\n        throw new Error(\"Metadata for this complexType has not yet been resolved: \" + typeName);\r\n      }\r\n    }\r\n    let complexCtor = complexType.getCtor();\r\n    config.interfaceRegistry.modelLibrary.getDefaultInstance().startTracking(complexObject, complexCtor.prototype);\r\n\r\n  }\r\n\r\n\r\n  /**\r\n  Returns the EntityAspect for the top level entity that contains this complex object.\r\n  **/\r\n  getEntityAspect() {\r\n    let parent = <any>this.parent;\r\n    if (!parent) return new EntityAspect();\r\n    let entityAspect = parent.entityAspect;\r\n    while (parent && !entityAspect) {\r\n      parent = parent.complexAspect && parent.complexAspect.parent;\r\n      entityAspect = parent && parent.entityAspect;\r\n    }\r\n    return entityAspect || new EntityAspect();\r\n  }\r\n\r\n  /**  @hidden @internal */\r\n  // TODO: rename - and use '_'; used on both EntityAspect and ComplexAspect for polymorphic reasons.\r\n  getPropertyPath(propName: string) {\r\n    let parent = <any>this.parent;\r\n    if (!parent) return null;\r\n    let aspect = parent.complexAspect || parent.entityAspect;\r\n    return aspect.getPropertyPath(this.parentProperty!.name + \".\" + propName);\r\n  }\r\n\r\n}\r\n\r\nfunction clearOriginalValues(target: any) {\r\n  let aspect = target.entityAspect || target.complexAspect;\r\n  aspect.originalValues = {};\r\n  let stype = target.entityType || target.complexType;\r\n  stype.complexProperties.forEach(function (cp: any) {\r\n    let cos = target.getProperty(cp.name);\r\n    if (cp.isScalar) {\r\n      clearOriginalValues(cos);\r\n    } else {\r\n      cos._acceptChanges();\r\n      cos.forEach(clearOriginalValues);\r\n    }\r\n  });\r\n}\r\n\r\n\r\n"]}