@ironcode/vas-lib 1.1.0 → 1.2.0

package/fesm2020/ironcode-vas-lib.mjs

@@ -1675,8 +1675,7 @@ class VasJobModel extends VasRestrictedAccountObjectModel {
             .filter(prop => !nativeProps.includes(prop));
     }
     /**
-     * Returns a list of Job static properties i.e. those that are declared by
-     * the type
+     * Returns the list of properties of the Job type
      */
     get staticProperties() {
         return Object.getOwnPropertyNames(VasJobModel.empty());
@@ -1696,6 +1695,27 @@ class VasJobModel extends VasRestrictedAccountObjectModel {
             .forEach((key) => model.$this[key] = dto[key]);
         return model;
     }
+    /**
+     * This method will instantiate a new JobModel. The difference with this
+     * method of instantiation is that we are coming from a relation frame i.e.
+     * the job has a list of {@link VasFieldDto} instead of a Job document.
+     *
+     */
+    static fromRelational(dto, form) {
+        const model = new VasJobModel(dto.id || '', dto.created || '', dto.serverCreated || '', dto.createdBy || '', dto.modified || '', dto.serverModified || '', dto.modifiedBy || '', dto.createdByName || '', dto.modifiedByName || '', dto.account || '', dto.accessGroup || '', dto.reference || '', dto.jobDate || '', dto.jobStatus || '', dto.jobType || '', dto.assigneeId || '', dto.formId || '', dto.timeZoneOffset || moment$1().utcOffset(), dto.pendingFields || 0, dto.childModified || '', dto.version || 0, dto.fields || [], dto.files || [], dto.createdByDisplayName || '', dto.modifiedByDisplayName || '', dto.geoLocation || getEmptyGeoLocation());
+        form.groups
+            .forEach(group => {
+            group.controls
+                .forEach(control => {
+                const field = dto.fields?.find(f => f.control === control.id);
+                if (!field) {
+                    return;
+                }
+                model.getGroup(group.name)[control.name] = field.value;
+            });
+        });
+        return model;
+    }
     /**
      * @param {VasFormModel} formModel
      * @return {Record<string, VasFieldDtoValue>}
@@ -1776,18 +1796,63 @@ class VasJobModel extends VasRestrictedAccountObjectModel {
         };
     }
     /**
-     * This method will hydrate the `fields` property of the model. The reason for
-     * this is that we have different ways to store the field data. One way, is
-     * we store them as dynamic properties of the job. For example job.foo.bar,
-     * where `foo` is the name of a Group, and `bar` is the name of a control.
-     * Thus, when we create a job using a form in the client, the job object will
-     * have its static properties (id, account, reference etc), and also a number
-     * of dynamic properties determined by the Groups and Controls. This kind of
-     * object is nice to work with in certain circumstances. However, the api
-     * works differently. In the API a Job is a record, and references a number of
-     * Field records. Each Field stores the value. Comparing these two models we
-     * have:
-     * A) job with dynamic properties, e.g.
+     * This method will return the dynamic property from the JobModel that
+     * represent a group (from a form).
+     *
+     * @param name the name of the group
+     * @param init if true (default) and group is not found, initialise an empty
+     * group, otherwise throw an error
+     */
+    getGroup(name, init = true) {
+        let prop;
+        if (this.staticProperties.includes(name)) {
+            throw Error(`invalid group name ${name}, not a dynamic property`);
+        }
+        else if (this.$this[name] === undefined) {
+            if (init) {
+                prop = this.$this[name] = {};
+            }
+            else {
+                throw Error(`invalid group name ${name}, not found`);
+            }
+        }
+        else {
+            prop = this.$this[name];
+            if (typeof prop !== 'object') {
+                throw Error(`invalid group name ${name}, not an object`);
+            }
+        }
+        return prop;
+    }
+    /**
+     * @param path path segments
+     */
+    getValueByPath(path = []) {
+        return getValueByPath(path, this.$this);
+    }
+    /**
+     * In order to understand why we need this method it is important to
+     * understand that within the system, Jobs can be represented in one of two
+     * ways, document and relational.
+     *
+     * The important distinction is how values submitted by a form are stored.
+     *
+     * Jobs stored as documents (JSON objects) will store user values, as dynamic
+     * properties of the document.
+     *
+     * Whereas, Jobs stored as relational, will store user values in an array of
+     * {@link VasFieldDto} objects.
+     *
+     * Depending on where we are in the system, either one of these approaches can
+     * be more useful than the other.
+     *
+     * This method, assumes that the JobModel has been instantiated from a
+     * document representation, and serves to hydrate the fields array. In order
+     * to achieve this, knowledge of the {@link VasFormDto} that created the job
+     * is required.
+     *
+     *
+     * Job in document representation
      * {
      *   id: <guid>,
      *   reference: "something"
@@ -1797,7 +1862,7 @@ class VasJobModel extends VasRestrictedAccountObjectModel {
      *   }
      * }
      *
-     * B) job with fields
+     * Job in relational representation
      * {
      *   id: <guid>,
      *   reference: "something"
@@ -1812,46 +1877,11 @@ class VasJobModel extends VasRestrictedAccountObjectModel {
      *   ]
      * }
      *
-     * So, what this method does is given a JobModel in the form of A, read all
-     * of those dynamic properties and set them into `fields`. Doing this requires
-     * knowledge of the Form that was used to create the job. Moreover, since the
-     * dynamic properties do not contain the ids of the fields, we also allow to
-     * pass in a `controlFieldIdMap`. This map stores the mapping between Control
-     * and the Field that was created in the Job to store the value for that
-     * Control. This is useful, if for example you want to compare a Job in form A
-     * with a Job in form B, for example if you want to update the Job on the API
-     * with a Job that was saved by a client in form A.
-     *
-     * E.g.
-     * Client -> API: client requests form
-     * User -> Client: user fills in the form and submits
-     * Client -> Firestore: client saves the Job in form A i.e. dynamic props
-     * Firestore -> Function: A function is triggered to sync the job to the API
-     * Function -> API: Function checks if job already exists, it receives 404
-     * Function -> Function: The function calls `hydrateFields(...)`
-     * Function -> API: The function POST the Job to /jobs
-     * Function -> API: The function POST each field to /fields
-     *
-     * Similarly, if the user updates the job
-     * Client -> API: client requests form
-     * User -> Client: user fills in the form and submits an update
-     * Client -> Firestore: client saves the Job in form A i.e. dynamic props
-     * Firestore -> Function: A function is triggered to sync the job to the API
-     * Function -> API: Function checks if job already exists, it receives 200
-     * Function -> Function: The function calls `hydrateFields(...)` passing in
-     *                       the map is made by iterating over the fields it
-     *                       received from the API and storing the mappings
-     *                       between controlId and fieldId for each field
-     * Function -> API: The function PATCH the Job to /jobs
-     * Function -> API: The function POST/PATCH each field to /fields
-     * treated as new
      *
-     * @param {VasFormModel} formModel the VasFormModel that was used to create
-     * the job
-     * @param {Map<string, string>} controlFieldIdMap a mapping of control to
-     * field ids. This is used to determine whether a new id for the field should
-     * be generated, or to reuse an existing one from the map.
-     * @param {Array<string>} controlNames if a value is provided, it will be used
+     * @param formModel the VasFormModel that was used to create the job
+     * @param controlFieldIdMap This is used to determine the id each field.
+     * Either one will be found in the map, or a new one is generated.
+     * @param controlNames if a value is provided, it will be used
      * to filter the fields that are returned.
      * @return {Array<VasFieldDto>}
      */
@@ -1883,13 +1913,6 @@ class VasJobModel extends VasRestrictedAccountObjectModel {
         });
         this.fields = fields;
     }
-    /**
-     * @param {string[]} path path segments
-     * @return {void}
-     */
-    getValueByPath(path = []) {
-        return getValueByPath(path, this.$this);
-    }
     /**
      * A very non sophisticated way to set values in the job via paths
      *
@@ -1904,8 +1927,8 @@ class VasJobModel extends VasRestrictedAccountObjectModel {
      *   }
      * }
      *
-     * @param {any} value the value to set
-     * @param {string[]} path path segments
+     * @param value the value to set
+     * @param path path segments
      */
     setValueByPath(value, path = []) {
         switch (path.length) {
@@ -1932,9 +1955,8 @@ class VasJobModel extends VasRestrictedAccountObjectModel {
         }
     }
     /**
-     * @param {boolean} staticOnly if true, will only output values for the static
+     * @param staticOnly if true, will only output values for the static
      * properties in the dto
-     * @return {VasJobDto}
      */
     toDto(staticOnly = false) {
         if (staticOnly) {
@@ -1969,7 +1991,7 @@ class VasJobModel extends VasRestrictedAccountObjectModel {
         }
         const dto = {};
         [...this.staticProperties, ...this.dynamicProperties]
-            .forEach(prop => (dto)[prop] = this.$this[prop]);
+            .forEach(prop => dto[prop] = this.$this[prop]);
         return dto;
     }
     /**
@@ -1996,7 +2018,7 @@ class VasJobModel extends VasRestrictedAccountObjectModel {
      *
      * @param {string} value a string with the syntax
      * @param {ParseSyntaxOptions} options
-     * @return {string} the results of parsing the syntax on this job
+     * @return the results of parsing the syntax on this job
      */
     parseSyntax(value, options = {
         timeZoneOffset: 0
@@ -2030,7 +2052,7 @@ class VasJobModel extends VasRestrictedAccountObjectModel {
                 result = (this.getValueByPath(path) || '').toString();
             }
             else if (objectKey === 'fields') {
-                result = (getValueByPath(path, this.getFields2()) || '').toString();
+                result = (getValueByPath(['fields.' + path.shift(), ...path], this.getFields2()) || '').toString();
             }
             else if (objectKey.length) {
                 if (options.objects) {