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

apeman app to handle restful endpoint.

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

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

const { toType, toData, defineRelatedOne, defineRelatedUpdate } = require('apemanmodel')
const validateDataType = require('../../validating/validate_data_type')
const validateModelExists = require('../../validating/validate_model_exists')
const validateDataGiven = require('../../validating/validate_data_given')

const co = require('co')

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

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

    let { state } = ctx
    let { model, id, data, association, transaction } = state
    return co(function * () {
      let relatedOne = defineRelatedOne(model, association, transaction)

      data = [].concat(data || [])

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

        let relatedIds = data.map((data) => data.id)
        let relatedInstances = yield relatedIds.map((relatedId) => relatedOne(id, relatedId))
        let existsErrors = validateModelExists.bulk(model, relatedIds, relatedInstances)
        if (existsErrors) {
          return fail(existsErrors)
        }

        let updated = yield s.bulkUpdate(id, relatedInstances, data, state)
        return succeed(
          {},
          toData(association.target, updated, {}),
          {
            collection: updated.map(
              (updated) => `../${updated.id}`
            )
          }
        )
      })
    })
  }

  /**
   * @override
   */
  validate (data, state) {
    let { model, association, id, instance } = state
    let type = toType(association.target)
    let dataGivenError = validateDataGiven.bulk(data)
    if (dataGivenError) {
      return dataGivenError
    }

    let existsError = validateModelExists(model, id, instance)
    if (existsError) {
      return existsError
    }

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

    return null
  }

  bulkUpdate (id, relatedInstances, data, state) {
    let { model, association, transaction } = state
    let attributes = data.map((data) => data.attributes)
    let relatedUpdate = defineRelatedUpdate(model, association, transaction)
    return co(function * () {
      return yield relatedUpdate.bulk(id, relatedInstances, attributes)
    })
  }
}

module.exports = BulkRelatedUpdateEndpoint