trailpack-proxy-cart/lib/routes.js

eCommerce - Trailpack for Proxy Engine

'use strict'
const joi = require('joi')
// const Schemas = require('./schemas')

module.exports = [
  {
    method: ['GET'],
    path: '/generalStats',
    handler: 'ProxyCartController.generalStats',
    config: {
      validate: {
        query: {
          offset: joi.number(),
          limit: joi.number(),
          sort: joi.array().items(joi.array()),
          where: joi.object()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetGeneralStatsRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/gateways',
    handler: 'GatewayController.gateways',
    config: {
      validate: {

      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetGatewaysRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/countries',
    handler: 'CountryController.countries',
    config: {
      validate: {
        query: {
          offset: joi.number(),
          limit: joi.number(),
          sort: joi.array().items(joi.array()),
          where: joi.any(),
          include: joi.array().items(joi.string())
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCountriesRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/provinces',
    handler: 'CountryController.provinces',
    config: {
      validate: {
        query: {
          offset: joi.number(),
          limit: joi.number(),
          sort: joi.array().items(joi.array()),
          where: joi.any(),
          include: joi.array().items(joi.string())
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetProvincesRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/counties',
    handler: 'CountryController.counties',
    config: {
      validate: {
        query: {
          offset: joi.number(),
          limit: joi.number(),
          sort: joi.array().items(joi.array()),
          where: joi.any(),
          include: joi.array().items(joi.string())
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCountiesRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/cities',
    handler: 'CountryController.cities',
    config: {
      validate: {
        query: {
          offset: joi.number(),
          limit: joi.number(),
          sort: joi.array().items(joi.array()),
          where: joi.any(),
          include: joi.array().items(joi.string())
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCitiesRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/country',
    handler: 'CountryController.createCountry',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCountryRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/country/:id',
    handler: 'CountryController.country',
    config: {
      validate: {
        params: {
          id: joi.number()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCountryIdRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/country/:id/provinces',
    handler: 'CountryController.countryProvinces',
    config: {
      validate: {
        params: {
          id: joi.number()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCountryIdProvincesRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/country/:id',
    handler: 'CountryController.updateCountry',
    config: {
      validate: {
        params: {
          id: joi.number()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCountryIdRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['DELETE'],
    path: '/country/:id',
    handler: 'CountryController.destroyCountry',
    config: {
      validate: {
        params: {
          id: joi.number()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiDeleteCountryIdRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/country/:id/addProvince/:province',
    handler: 'CountryController.addProvince',
    config: {
      validate: {
        params: {
          id: joi.number(),
          province: joi.any()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCountryIdAddProvinceProvinceRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/country/:id/removeProvince/:province',
    handler: 'CountryController.removeProvince',
    config: {
      validate: {
        params: {
          id: joi.number(),
          province: joi.any()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCountryIdRemoveProvinceProvinceRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/province',
    handler: 'CountryController.createProvince',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostProvinceRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/province/:id',
    handler: 'CountryController.province',
    config: {
      validate: {
        params: {
          id: joi.number()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetProvinceIdRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/province/:id',
    handler: 'CountryController.updateProvince',
    config: {
      validate: {
        params: {
          id: joi.number()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostProvinceIdRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['DELETE'],
    path: '/province/:id',
    handler: 'CountryController.destroyProvince',
    config: {
      validate: {
        params: {
          id: joi.number()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiDeleteProvinceIdRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/county',
    handler: 'CountryController.createCounty',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCountyRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/county/:id',
    handler: 'CountryController.county',
    config: {
      validate: {
        params: {
          id: joi.number()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCountyIdRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/county/:id',
    handler: 'CountryController.updateCounty',
    config: {
      validate: {
        params: {
          id: joi.number()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCountyIdRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['DELETE'],
    path: '/county/:id',
    handler: 'CountryController.destroyCounty',
    config: {
      validate: {
        params: {
          id: joi.number()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiDeleteCountyIdRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/city',
    handler: 'CountryController.createCity',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCityRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/city/:id',
    handler: 'CountryController.city',
    config: {
      validate: {
        params: {
          id: joi.number()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCityIdRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/city/:id',
    handler: 'CountryController.updateCity',
    config: {
      validate: {
        params: {
          id: joi.number()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCityIdRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['DELETE'],
    path: '/city/:id',
    handler: 'CountryController.destroyCity',
    config: {
      validate: {
        params: {
          id: joi.number()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiDeleteCityIdRoute',
          roles: ['admin']
        }
      }
    }
  },
  // Cart
  {
    method: ['GET'],
    path: '/carts',
    handler: 'CartController.findAll',
    config: {
      validate: {
        query: {
          offset: joi.number(),
          limit: joi.number(),
          sort: joi.array().items(joi.array()),
          where: joi.any(),
          include: joi.array().items(joi.string())
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCartsRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/cart',
    handler: 'CartController.create',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCartRoute',
          roles: ['admin','registered']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/cart',
    handler: 'CartController.session',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCartRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/cart/draft',
    handler: 'CartController.draft',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCartDraftRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/cart/:id',
    handler: 'CartController.resolve',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCartIdRoute',
          roles: ['admin','registered']
        }
      }
    }
  },
  {
    method: ['PUT'],
    path: '/cart',
    handler: 'CartController.update',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPutCartRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/:id',
    handler: 'CartController.update',
    config: {
      validate: {
        params: {
          id: joi.number().required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCartIdRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/:id/addShipping',
    handler: 'CartController.addShipping',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartIdAddShippingRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/:id/removeShipping',
    handler: 'CartController.removeShipping',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartIdRemoveShippingRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/:id/addTaxes',
    handler: 'CartController.addTaxes',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartIdAddTaxesRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/:id/removeTaxes',
    handler: 'CartController.removeTaxes',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartIdRemoveTaxesRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/cart/generalStats',
    handler: 'CartController.generalStats',
    config: {
      validate: {
        query: {
          offset: joi.number(),
          limit: joi.number(),
          sort: joi.array().items(joi.array()),
          where: joi.any(),
          include: joi.array().items(joi.string())
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCartGeneralStatsRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/cart/count',
    handler: 'CartController.count',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCartCountRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET','POST'],
    path: '/cart/init',
    handler: 'CartController.init',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCartInitRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/cart/session',
    handler: 'CartController.session',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/logout',
    handler: 'CartController.logout',
    config: {
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartLogoutRoute',
          roles: ['public','registered','admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/checkout',
    handler: 'CartController.checkout',
    config: {
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartCheckoutRoute',
          roles: ['public','registered']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/addItems',
    handler: 'CartController.addItems',
    config: {
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartAddItemsRoute',
          roles: ['public','registered']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/removeItems',
    handler: 'CartController.removeItems',
    config: {
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartRemoveItemsRoute',
          roles: ['public','registered','admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/cart/clear',
    handler: 'CartController.clear',
    config: {
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartClearRoute',
          roles: ['public','registered','admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/cart/login',
    handler: 'CartController.login',
    config: {
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartLoginRoute',
          roles: ['public','registered','admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/cart/:id/login',
    handler: 'CartController.login',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartIdLoginRoute',
          roles: ['public','registered']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/:id/checkout',
    handler: 'CartController.checkout',
    config: {
      validate: {
        params: {
          id: joi.number().required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartIdCheckoutRoute',
          roles: ['public','registered']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/:id/checkout/:customer',
    handler: 'CartController.checkout',
    config: {
      validate: {
        params: {
          id: joi.number().required(),
          customer: joi.number().required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartIdCheckoutCustomerRoute',
          roles: ['public','registered']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/cart/:id/customer',
    handler: 'CartController.customer',
    config: {
      validate: {
        params: {
          id: joi.number().required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiGetCartIdCustomerRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/cart/:id/switch',
    handler: 'CartController.switchCart',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartIdSwitchRoute',
          roles: ['public','registered']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/:id/addItems',
    handler: 'CartController.addItems',
    config: {
      validate: {
        params: {
          id: joi.number().required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartIdAddItemsRoute',
          roles: ['public','registered']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/:id/removeItems',
    handler: 'CartController.removeItems',
    config: {
      validate: {
        params: {
          id: joi.number().required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartIdRemoveItemsRoute',
          roles: ['public','registered']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/:id/pricingOverrides',
    handler: 'CartController.pricingOverrides',
    config: {
      validate: {
        params: {
          id: joi.number().required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartIdPricingOverridesRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/cart/:id/clear',
    handler: 'CartController.clear',
    config: {
      validate: {
        params: {
          id: joi.number().required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCartIdClearRoute',
          roles: ['public','registered']
        }
      }
    }
  },
  // Collections
  {
    method: ['GET'],
    path: '/collections',
    handler: 'CollectionController.findAll',
    config: {
      validate: {
        query: {
          offset: joi.number(),
          limit: joi.number(),
          sort: joi.array().items(joi.array()),
          where: joi.any(),
          include: joi.array().items(joi.string())
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCollectionsRoute',
          roles: ['public','registered','admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/collection',
    handler: 'CollectionController.create',
    config: {
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCollectionRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/collection/:id',
    handler: 'CollectionController.update',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/collection/:id',
    handler: 'CollectionController.findById',
    config: {
      validate: {
        params: {
          id: joi.number().required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCollectionIdRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/collection/:id/collection/:collection',
    handler: 'CollectionController.addCollection',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          collection: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdCollectionCollectionRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/collection/:id/addCollection/:collection',
    handler: 'CollectionController.addCollection',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          collection: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdAddCollectionCollectionRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/collection/:id/collections',
    handler: 'CollectionController.addCollections',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdCollectionsRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['DELETE'],
    path: '/collection/:id/collection/:collection',
    handler: 'CollectionController.removeCollection',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          collection: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiDeleteCollectionIdCollectionCollectionRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/collection/:id/removeCollection/:collection',
    handler: 'CollectionController.removeCollection',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          collection: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiDeleteCollectionIdRemoveCollectionCollectionRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/collection/:id/collections',
    handler: 'CollectionController.collections',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCollectionIdCollectionsRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/collection/:id/addProduct/:product',
    handler: 'CollectionController.addProduct',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          product: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdAddProductProductRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/collection/:id/product/:product',
    handler: 'CollectionController.addProduct',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          product: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdProductProductRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/collection/:id/removeProduct/:product',
    handler: 'CollectionController.removeProduct',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          product: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdRemoveProductProductRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/collection/:id/products',
    handler: 'CollectionController.addProducts',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdProductsRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['DELETE'],
    path: '/collection/:id/product/:product',
    handler: 'CollectionController.removeProduct',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          product: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiDeleteCollectionIdProductProductRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/collection/:id/products',
    handler: 'CollectionController.products',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCollectionIdProductsRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/collection/:id/discounts',
    handler: 'CollectionController.discounts',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCollectionIdDiscountsRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/collection/:id/addTag/:tag',
    handler: 'CollectionController.addTag',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          tag: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdAddTagTagRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/collection/:id/tag/:tag',
    handler: 'CollectionController.addTag',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          tag: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdTagTagRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/collection/:id/removeTag/:tag',
    handler: 'CollectionController.removeTag',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          tag: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdRemoveTagTagRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['DELETE'],
    path: '/collection/:id/tag/:tag',
    handler: 'CollectionController.removeTag',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          tag: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiDeleteCollectionIdTagTagRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/collection/:id/tags',
    handler: 'CollectionController.tags',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCollectionIdTagsRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/collection/:id/addCustomer/:customer',
    handler: 'CollectionController.addCustomer',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          customer: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdAddCustomerCustomerRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/collection/:id/customer/:customer',
    handler: 'CollectionController.addCustomer',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          customer: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdCustomerCustomerRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/collection/:id/customers',
    handler: 'CollectionController.addCustomers',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdCustomersRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/collection/:id/removeCustomer/:customer',
    handler: 'CollectionController.removeCustomer',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          customer: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiPostCollectionIdRemoveCustomerCustomerRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['DELETE'],
    path: '/collection/:id/customer/:customer',
    handler: 'CollectionController.removeCustomer',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          customer: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiDeleteCollectionIdCustomerCustomerRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/collection/:id/customers',
    handler: 'CollectionController.customers',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCollectionIdCustomersRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/collection/handle/:handle',
    handler: 'CollectionController.findByHandle',
    config: {
      validate: {
        params: {
          handle: joi.string().required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCollectionHandleRoute',
          roles: ['public','registered','admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/collection/count',
    handler: 'CollectionController.count',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCollectionCountRoute',
          roles: ['public','registered','admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/collection/generalStats',
    handler: 'CollectionController.generalStats',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCollectionGeneralStatsRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/collections/search',
    handler: 'CollectionController.search',
    config: {
      validate: {
        query: {
          offset: joi.number(),
          limit: joi.number(),
          sort: joi.array().items(joi.array()),
          where: joi.any().optional(),
          term: joi.any(),
          include: joi.array().items(joi.string())
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCollectionsSearchRoute',
          roles: ['public','registered','admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/collection/uploadCSV',
    handler: 'CollectionController.uploadCSV',
    config: {
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCollectionUploadCsvRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/collection/processUpload/:id',
    handler: 'CollectionController.processUpload',
    config: {
      validate: {
        params: {
          // This is a only ever a String
          id: joi.string().required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCollectionProcessUploadRoute',
          roles: ['admin']
        }
      }
    }
  },
  // Customer
  {
    method: ['GET'],
    path: '/customers',
    handler: 'CustomerController.findAll',
    config: {
      validate: {
        query: {
          offset: joi.number(),
          limit: joi.number(),
          sort: joi.array().items(joi.array()),
          where: joi.any(),
          include: joi.array().items(joi.string())
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCustomersRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/customer',
    handler: 'CustomerController.createAndLogin',
    config: {
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCustomerRoute',
          roles: ['public','registered','admin']
        }
      }
    }
  },
  {
    method: ['PUT'],
    path: '/customer',
    handler: 'CustomerController.update',
    config: {
      app: {
        proxyPermissions: {
          resource_name: 'apiPutCustomerRoute',
          roles: ['registered','admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/customer/create',
    handler: 'CustomerController.create',
    config: {
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCustomerCreateRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/customer/processUpload/:id',
    handler: 'CustomerController.processUpload',
    config: {
      validate: {
        params: {
          // This is a only ever a String
          id: joi.string().required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCustomerProcessUploadRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/customer/:id',
    handler: 'CustomerController.findById',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCustomerIdRoute',
          roles: ['admin','registered']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/customer/token/:token',
    handler: 'CustomerController.findByToken',
    config: {
      validate: {
        params: {
          token: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCustomerTokenTokenRoute',
          roles: ['admin','registered']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/customer/:id/discounts',
    handler: 'CustomerController.discounts',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCustomerIdDiscountsRoute',
          roles: ['admin','registered']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/customer/:id/reviews',
    handler: 'CustomerController.reviews',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCustomerIdReviewsRoute',
          roles: ['admin','registered','public']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/customer/generalStats',
    handler: 'CustomerController.generalStats',
    config: {
      validate: {
        query: {
          offset: joi.number(),
          limit: joi.number(),
          sort: joi.array().items(joi.array()),
          where: joi.any()
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCustomerGeneralStatsRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/customer/count',
    handler: 'CustomerController.count',
    config: {
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCustomerCountRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST'],
    path: '/customer/export',
    handler: 'CustomerController.exportCustomers',
    config: {
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCustomerExportRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['GET'],
    path: '/customers/search',
    handler: 'CustomerController.search',
    config: {
      validate: {
        query: {
          offset: joi.number(),
          limit: joi.number(),
          sort: joi.array().items(joi.array()),
          where: joi.any().optional(),
          term: joi.string().required(),
          include: joi.array().items(joi.string())
        }
      },
      app: {
        proxyRouter: {
          ignore: true
        },
        proxyPermissions: {
          resource_name: 'apiGetCustomersSearchRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/customer/:id',
    handler: 'CustomerController.update',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCustomerIdRoute',
          roles: ['admin','registered']
        }
      }
    }
  },
  {
    method: ['POST', 'PUT'],
    path: '/customer/:id/accountBalance',
    handler: 'CustomerController.accountBalance',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCustomerIdAccountBalanceRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['PUT'],
    path: '/customer/:id/enable',
    handler: 'CustomerController.enable',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPutCustomerIdEnableRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['PUT'],
    path: '/customer/:id/disable',
    handler: 'CustomerController.disable',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPutCustomerIdDisableRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/customer/:id/addTag/:tag',
    handler: 'CustomerController.addTag',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          tag: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCustomerIdAddTagTagRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT'],
    path: '/customer/:id/tag/:tag',
    handler: 'CustomerController.addTag',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          tag: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCustomerIdPostTagTagRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['POST','PUT','DELETE'],
    path: '/customer/:id/removeTag/:tag',
    handler: 'CustomerController.removeTag',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required(),
          tag: joi.alternatives().try(
            joi.number(),
            joi.string()
          ).required()
        }
      },
      app: {
        proxyPermissions: {
          resource_name: 'apiPostCustomerIdRemoveTagTagRoute',
          roles: ['admin']
        }
      }
    }
  },
  {
    method: ['DELETE'],
    path: '/customer/:id/tag/:tag',
    handler: 'CustomerController.removeTag',
    config: {
      validate: {
        params: {
          id: joi.alternatives().try(
            joi.number(),
            joi.stri