@airyrooms/catela/model/Model.js

import ModelProperty from './ModelProperty'

if (global.__MODEL_REGISTRY__ == null || typeof global.__MODEL_REGISTRY__ === 'undefined') {
  global.__MODEL_SPEC_REGISTRY__ = {}
}

class Model {
  constructor (spec) {
    this.props = {}
    this._initFromSpec(spec)
  }

  _initFromSpec (spec) {
    this._key = '' + spec.key
    this._option = spec.option || {}
    Object.keys(spec.props).forEach((k) => {
      let field = spec.props[k]
      let defaultValue = null
      if (field.defaultValue != null && typeof field.defaultValue !== 'undefined') {
        defaultValue = field.defaultValue
      }
      this.props[k] = new ModelProperty(
        this,
        k,
        field.display,
        field.validators,
        defaultValue
      )
      if (field.defaultValue != null && typeof field.defaultValue !== 'undefined') {
        this.props[k].setValue(field.defaultValue)
        this.props[k].defaultValidation()
      }
      this[k] = this.props[k]
    })
  }

  set (data) {
    Object.keys(this.props).forEach((pk) => {
      if (typeof data[pk] === 'undefined') {
        throw new Error('[CATELA_MODEL] [' + pk + '] property is not found in data.')
      } else {
        this.props[pk].setValue(data[pk].value)
      }
    })
    return this
  }

  bind (data) {
    Object.keys(this.props).forEach((pk) => {
      if (typeof data[pk] === 'undefined') {
        throw new Error('[CATELA_MODEL] [' + pk + '] property is not found in data.')
      } else {
        if (data[pk] != null && typeof data[pk] !== 'undefined') {
          // TODO: data[pk].value?
          this.props[pk].set(data[pk])
        }
      }
    })
    return this
  }

  get () {
    let data = {}
    Object.keys(this.props).forEach((pk) => {
      let props = this.props[pk]
      data[pk] = {
        value: props.getValue(),
        validation: props.getValidation()
      }
    })
    data.__MODEL_KEY__ = this._key
    return data
  }

  getValue () {
    let data = {}
    Object.keys(this.props).forEach((pk) => {
      let props = this.props[pk]
      data[pk] = props.getValue()
    })
    return data
  }

  value (field) {
    if (this.props[field] == null || typeof this.props[field] === 'undefined') {
      throw new Error('[CATELA_MODEL] [' + field + '] property is not found in data.')
    } else {
      return this.props[field].getValue()
    }
  }

  clearValidation () {
    Object.keys(this.props).forEach((pk) => {
      let props = this.props[pk]
      props.defaultValidation()
    })
    return this
  }

  default () {
    Object.keys(this.props).forEach((pk) => {
      let props = this.props[pk]
      props.default()
    })
    return this
  }

  validate () {
    let valid = true
    let validations = {}
    Object.keys(this.props).forEach((pk) => {
      let propsValidationResult = this.props[pk].validate(this.props[pk].getValue())
      valid = valid && propsValidationResult.valid
      validations[pk] = propsValidationResult
    })
    return {
      valid: valid,
      validations: validations
    }
  }

  static fromSpec (spec) {
    if (global.__MODEL_SPEC_REGISTRY__[spec.key] == null || typeof global.__MODEL_SPEC_REGISTRY__[spec.key] === 'undefined') {
      global.__MODEL_SPEC_REGISTRY__[spec.key] = spec
    }
    return new Model(global.__MODEL_SPEC_REGISTRY__[spec.key])
  }

  static fromData (modelData) {
    if (modelData.__MODEL_KEY__ != null && typeof modelData.__MODEL_KEY__ !== 'undefined') {
      let spec = global.__MODEL_SPEC_REGISTRY__[modelData.__MODEL_KEY__]
      let model = new Model(spec)
      model.bind(Model.dataOf(modelData))
      return model
    } else {
      throw new Error('[CATELA_MODEL] Model is not properly constructed (no __MODEL_KEY__ property in the object). You may need to specify get() when getting the model data.')
    }
  }

  static valueOf (data) {
    let dataValue = {}
    Object.keys(data).forEach((pk) => {
      dataValue[pk] = {
        value: data[pk]
      }
    })
    return dataValue
  }

  static dataOf (modelData) {
    let dataValue = {}
    Object.keys(modelData).forEach((pk) => {
      if (typeof modelData[pk].value !== 'undefined') {
        dataValue[pk] = modelData[pk].value
      }
    })
    return dataValue
  }
}

export default Model