model/Model.js

  1. import { checkType, hasKeys } from '../lib/check'
  2. import { pickOr } from '../lib/utils'
  4. import ModelBase, { DIRTY_PROPERTY_LIST } from './ModelBase'
  5. import createPropertyDefinitionsForAttributes from './helpers/attibutes'
  7. const pickAttributeValues = pickOr('attributeValues', [])
  9. // TODO: Perhaps we can generate model classes dynamically based on the schemas and inherit from this.
  10. /**
  11.  * @extends ModelBase
  12.  *
  13.  * @description
  14.  * A Model represents an object from the DHIS2 Api. A model is created based of a ModelDefinition. The ModelDefinition
  15.  * has the properties that the model should have.
  16.  *
  17.  * @memberof module:model
  18.  */
  19. class Model extends ModelBase {
  20.     /**
  21.      * @constructor
  22.      *
  23.      * @param {ModelDefinition} modelDefinition The model definition that corresponds with the model.
  24.      * This is essential defining what type the model is representing.
  25.      *
  26.      * @description
  27.      * Will create a new model instanced based on the model definition. When creating a new instance the model
  28.      * definition needs to have both the modelValidations and modelProperties.
  29.      *
  30.      * The model properties will depend on the ModelDefinition. A model definition is based on a DHIS2 Schema.
  31.      */
  32.     constructor(modelDefinition) {
  33.         super()
  34.         checkType(modelDefinition, 'object', 'modelDefinition')
  35.         checkType(modelDefinition.modelProperties, 'object', 'modelProperties')
  37.         /**
  38.          * @property {ModelDefinition} modelDefinition Stores reference to the modelDefinition that was used when
  39.          * creating the model. This property is not enumerable or writable and will therefore not show up when looping
  40.          * over the object properties.
  41.          */
  42.         Object.defineProperty(this, 'modelDefinition', {
  43.             value: modelDefinition,
  44.         })
  46.         /**
  47.          * @property {Boolean} dirty Represents the state of the model. When the model is concidered `dirty`
  48.          * there are pending changes.
  49.          * This property is not enumerable or writable and will therefore not show up when looping
  50.          * over the object properties.
  51.          */
  52.         Object.defineProperty(this, 'dirty', { writable: true, value: false })
  54.         /**
  55.          * @private
  56.          * @property {Object} dataValues Values object used to store the actual model values. Normally access to the
  57.          * Model data will be done through accessor properties that are generated from the modelDefinition.
  58.          *
  59.          * @note {warning} This should not be accessed directly.
  60.          */
  61.         Object.defineProperty(this, 'dataValues', {
  62.             configurable: true,
  63.             writable: true,
  64.             value: {},
  65.         })
  67.         /**
  68.          * Attach the modelDefinition modelProperties (the properties from the schema) onto the Model.
  69.          *
  70.          * For a data element model the modelProperties would be the following
  71.          * https://play.dhis2.org/demo/api/schemas/dataElement.json?fields=properties
  72.          */
  73.         Object.defineProperties(this, modelDefinition.modelProperties)
  75.         const attributes = {}
  76.         const { attributeProperties } = modelDefinition
  77.         if (hasKeys(attributeProperties)) {
  78.             /**
  79.              * @property {Object} attributes The attributes objects contains references to custom attributes defined
  80.              * on the metadata object.
  81.              *
  82.              * @description
  83.              * These properties are generated based of the attributes that are created for the the specific schema.
  84.              * As these properties are not defined on the schemas they're put on a separate attributes object.
  85.              * When there are no attributes defined for the object type, the attributes property will not be attached
  86.              * to the model.
  87.              *
  88.              * @see https://docs.dhis2.org/2.27/en/user/html/dhis2_user_manual_en_full.html#manage_attribute
  89.              */
  90.             Object.defineProperty(this, 'attributes', { value: attributes })
  92.             const getAttributeValues = () => pickAttributeValues(this)
  93.             const setAttributeValues = attributeValues =>
  94.                 (this.attributeValues = attributeValues)
  95.             const setDirty = () => (this.dirty = true)
  96.             const attributeDefinitions = createPropertyDefinitionsForAttributes(
  97.                 attributeProperties,
  98.                 getAttributeValues,
  99.                 setAttributeValues,
  100.                 setDirty
  101.             )
  103.             Object.defineProperties(attributes, attributeDefinitions)
  104.         }
  106.         this[DIRTY_PROPERTY_LIST] = new Set([])
  107.     }
  109.     /**
  110.      * @static
  111.      *
  112.      * @param {ModelDefinition} modelDefinition ModelDefinition from which the model should be created
  113.      * @returns {Model} Returns an instance of the model.
  114.      *
  115.      * @description The static method is a factory method to create Model objects. It calls `new Model()` with the passed `ModelDefinition`.
  116.      *
  117.      * ```js
  118.      * let myModel = Model.create(modelDefinition);
  119.      * ```
  120.      */
  121.     static create(modelDefinition) {
  122.         return new Model(modelDefinition)
  123.     }
  124. }
  126. export default Model