apeman-app-rest/lib/endpoints/bulk/bulk_update_endpoint.js

apeman app to handle restful endpoint.

/**
 * Endpoint for bulk update
 * @augments Endpoint
 * @class BulkUpdateEndpoint
 */
'use strict'

const Endpoint = require('../endpoint')

const { toType, toData, defineOne, defineUpdate } = require('apemanmodel')
const validateDataType = require('../../validating/validate_data_type')
const validateDataGiven = require('../../validating/validate_data_given')
const validateDataVr = require('../../validating/validate_data_vr')
const validateModelExists = require('../../validating/validate_model_exists')

const co = require('co')

/** @lends BulkUpdateEndpoint */
class BulkUpdateEndpoint extends Endpoint {
  /**
   * @override
   */
  getDefaultConfig () {
    return {
      name: 'bulkUpdate'
    }
  }

  /**
   * @override
   */
  handle (ctx, next) {
    const s = this
    let succeed = s.bindSucceed(ctx)
    let fail = s.bindFail(ctx)

    let { state } = ctx
    let { model, data, transaction } = state

    data = [].concat(data || [])
    return co(function * () {
      let one = defineOne(model, transaction)
      let instances = yield data.map((data) => one(data.id))

      Object.assign(state, { instances })

      let error = s.validate(data, state)
      if (error) {
        return fail(error)
      }

      let updated = yield s.bulkUpdate(instances, data, state)

      return succeed(
        {},
        toData(model, updated, {}),
        {
          collection: updated.map(
            (updated) => `../${updated.id}`
          )
        }
      )
    })
  }

  /**
   * @override
   */
  validate (data, state) {
    let vrs = data.map((data) => data.vr)
    let ids = data.map((data) => data.id)
    let { model, instances } = state
    let type = toType(model)

    let dataGivenError = validateDataGiven.bulk(data)
    if (dataGivenError) {
      return dataGivenError
    }

    let typeErrors = validateDataType.bulk(data, type)
    if (typeErrors) {
      return typeErrors
    }

    let vrError = validateDataVr.bulk(data, vrs)
    if (vrError) {
      return vrError
    }

    let existsErrors = validateModelExists.bulk(model, ids, instances)
    if (existsErrors) {
      return existsErrors
    }
    return null
  }

  bulkUpdate (instances, data, state) {
    let { model, transaction } = state
    return co(function * () {
      let attributes = data.map((data) => data.attributes)
      let update = defineUpdate(model, transaction)
      return yield update.bulk(instances, attributes)
    })
  }
}

module.exports = BulkUpdateEndpoint