@airyrooms/catela/api/Resource.js

import PromiseHttpResourceExecutor from 'api/PromiseHttpResourceExecutor'
import { HttpMethod, Protocol } from 'api/const'
import async from 'async'
import querystring from 'querystring'

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

class RemoteResourceExecution {
  constructor (resource, resourceGroup, apiCaller) {
    this._resource = resource
    this._resourceGroup = resourceGroup
    this._data = null
    this._onProgressListener = null
    this._attachments = null
    this._configuration = {
      context: {},
      trackingContext: {},
      http: {
        headers: {},
        method: HttpMethod.POST,
        contentType: 'application/json'
      },
      protocol: Protocol.HTTP
    }
    this._apiCaller = apiCaller
    this._successHandler = null
    this._errorHandler = null
    this._offlineHandler = null
  }

  data (data) {
    this._data = data
    return this
  }

  onProgress (fn) {
    this._onProgressListener = fn
    return this
  }

  attach (attachments) {
    this._attachments = attachments
    return this
  }

  contentType (contentType) {
    this._configuration.http.contentType = contentType
    return this
  }

  context (key, value) {
    this._configuration.context[key] = value
    return this
  }

  trackingContext(key, value){
    this._configuration.trackingContext[key] = value
    return this
  }

  setTrackingContext(trackingContext){
    let combinedTrackingContext = {
      ...this._configuration.trackingContext,
      ...trackingContext
    }
    try{
        // TODO this is hack
        let fiz = global.__CONFIG__.fiz
        combinedTrackingContext['ipAddress'] = fiz.ip('https://concierge-api.airyrooms.com/getIp')
    } catch(e){

    }

    this._configuration.trackingContext = combinedTrackingContext
    return this
  }


  method (method) {
    this._configuration.http.method = method
    return this
  }

  header (key, value) {
    this._configuration.http.headers[key] = value
    return this
  }

  protocol (protocol) {
    this._configuration.protocol = protocol
    return this
  }

  timeout (timeout) {
    this._configuration.http.timeout = timeout
    return this
  }

  _createHttpAPIExecutionSpec (data, context, trackingContext) {
    let url = this._resource.getUrl()
    if (this._resource._query) {
      url += this._resource._query
    }
    return {
      uri: url,
      body: {
        data: data,
        context: context,
        trackingContext: trackingContext
      },
      headers: this._configuration.http.headers,
      method: this._configuration.http.method,
      contentType: this._configuration.http.contentType,
      timeout: this._configuration.http.timeout
    }
  }

  _executeHttpAPI () {
    let resourceGroupContext = this._resourceGroup.getContext()
    let resourceContext = this._resource.getContext()
    let resourceExecutionContext = this._configuration.context
    let resourceExecutionTrackingContext = this._configuration.trackingContext

    let finalContext = {}
    let finalTrackingContext = {}

    finalTrackingContext = {
      ...finalTrackingContext,
      ...resourceExecutionTrackingContext
    }
    finalContext = {
      ...finalContext,
      ...resourceGroupContext
    }

    finalContext = {
      ...finalContext,
      ...resourceContext
    }

    finalContext = {
      ...finalContext,
      ...resourceExecutionContext
    }

    let apiSpec = this._createHttpAPIExecutionSpec(this._data, finalContext, finalTrackingContext)
    this._apiCaller.execute(apiSpec, this._offlineHandler, this._errorHandler, this._successHandler, this._attachments, this._onProgressListener)
  }

  execute () {
    let beforeExecuteFilterFn = []
    if (this._resourceGroup.getOnBeforeExecuteFilters() != null) {
      if (this._resourceGroup.getOnBeforeExecuteFilters().length > 0) {
        this._resourceGroup.getOnBeforeExecuteFilters().forEach((f) => {
          beforeExecuteFilterFn.push(f)
        })
      }
    }

    if (this._resource.getOnBeforeExecuteFilters() != null) {
      if (this._resource.getOnBeforeExecuteFilters().length > 0) {
        this._resource.getOnBeforeExecuteFilters().forEach((f) => {
          beforeExecuteFilterFn.push(f)
        })
      }
    }

    if (beforeExecuteFilterFn.length > 0) {
      let beforeExecuteFilterFnCallQueue = []
      let idx = 0
      beforeExecuteFilterFn.forEach((beff) => {
        if (idx === 0) {
          beforeExecuteFilterFnCallQueue.push(
            (callback) => {
              // TODO handle short circuit
              return beff(this, callback)
            }
          )
        } else {
          beforeExecuteFilterFnCallQueue.push(
            (result, callback) => {
              // TODO handle short circuit
              console.log(arguments, result)
              return beff(this, callback)
            }
          )
        }
        idx += 1
      })

      async.waterfall(beforeExecuteFilterFnCallQueue, (err, results) => {
        if (err) {
          // TODO handle error
        } else {
          if (this._configuration.protocol === Protocol.HTTP) {
            this._executeHttpAPI()
          } else {
            // TODO should we call / handle additional protocol?
          }
        }
      })
    } else {
      if (this._configuration.protocol === Protocol.HTTP) {
        this._executeHttpAPI()
      } else {
        // TODO should we call / handle additional protocol?
      }
    }
  }

  success (fn) {
    this._successHandler = fn
    return this
  }

  error (fn) {
    this._errorHandler = fn
    return this
  }

  offline (fn) {
    this._offlineHandler = fn
    return this
  }
}

class RemoteResource {
  constructor (resourceGroup, url) {
    this._resourceGroup = resourceGroup
    this._url = url
    this._originalUrl = url
    this._query = ''
    this._configuration = {
      context: {}
    }
    this._onBeforeExecuteFilters = []
    this._onAfterExecuteFilters = []
    this._resourceExecutor = resourceGroup.getResourceExecutor()
  }

  onBeforeExecute (filterFn) {
    this._onBeforeExecuteFilters.push(filterFn)
  }

  onAfterExecute (filterFn) {
    this._onAfterExecuteFilters.push(filterFn)
  }

  context (key, value) {
    this._configuration.context[key] = value
  }

  prepare () {
    return new RemoteResourceExecution(
      this,
      this._resourceGroup,
      this._resourceExecutor
    )
  }

  param (param) {
    if (param) {
      Object.keys(param).forEach((key) => {
        let value = param[key]
        this._url = this._originalUrl.replace(':' + key, value)
      })
    }
    return this
  }

  use (resourceExecutor) {
    this._resourceExecutor = resourceExecutor
  }

  getContext () {
    return this._configuration.context
  }

  getOnBeforeExecuteFilters () {
    return this._onBeforeExecuteFilters
  }

  getOnAfterExecuteFilters () {
    return this._onAfterExecuteFilters
  }

  getUrl () {
    return this._url
  }

  getQuery () {
    return this._query
  }

  setQuery (q) {
    this._query = q
  }
}

class RemoteResourceGroup {
  constructor (name) {
    this._name = name
    this._configuration = {
      context: {}
    }
    this._onBeforeExecuteFilters = []
    this._onAfterExecuteFilters = []
    this._resourceExecutor = new PromiseHttpResourceExecutor()
  }

  use (resourceExecutor) {
    this._resourceExecutor = resourceExecutor
  }

  create (url) {
    return new RemoteResource(this, url)
  }

  createWithQuery (url, query) {
    let q = "?" + querystring.stringify(query)
    this._query = q
    let remoteResource = new RemoteResource(this, url)
    remoteResource.setQuery(q)
    return remoteResource
  }

  context (key, value) {
    this._configuration.context[key] = value
  }

  onBeforeExecute (filterFn) {
    this._onBeforeExecuteFilters.push(filterFn)
  }

  onAfterExecute (filterFn) {
    this._onAfterExecuteFilters.push(filterFn)
  }

  getContext () {
    return this._configuration.context
  }

  getOnBeforeExecuteFilters () {
    return this._onBeforeExecuteFilters
  }

  getOnAfterExecuteFilters () {
    return this._onAfterExecuteFilters
  }

  getResourceExecutor () {
    return this._resourceExecutor
  }
}

RemoteResource.group = function (groupName) {
  if (global.__RESOURCE_GROUP_REGISTRY__[groupName] == null || typeof global.__RESOURCE_GROUP_REGISTRY__[groupName] === 'undefined') {
    global.__RESOURCE_GROUP_REGISTRY__[groupName] = new RemoteResourceGroup(groupName)
  }
  return global.__RESOURCE_GROUP_REGISTRY__[groupName]
}

export default {
  RemoteResource: RemoteResource
}