#%RAML 1.0
title: Booking Service
version: v1
baseUri: /types:Booking:properties:city: stringcinema: stringmovie: stringschedule: datetimecinemaRoom: stringseats: arraytotalAmount: numberUser:properties:name: stringlastname: stringemail: stringcreditcard: objectphoneNumber?: stringmembership?: numberTicket:properties:cinema: stringschedule: stringmovie: stringseat: stringcinemaRoom: stringorderId: stringresourceTypes:GET:get:responses:200:body:application/json:type: <<item>>POST:post:body:application/json:type: <<item>>type: <<item2>>responses:201:body:application/json:type: <<item3>>/booking:type:   { POST: {item : Booking, item2 : User, item3: Ticket} }description: The booking service need a Booking object that contains allthe needed information to make a purchase of cinema tickets.Needs a user information to make the booking succesfully.And returns a ticket object./verify/{orderId}:type:  { GET: {item : Ticket} }description: This route is for verify orders, and would return all the detailsof a specific purchased by orderid.

const bookingSchema = (joi) => ({bookingSchema: joi.object().keys({city: joi.string(),schedule: joi.date().min('now'),movie: joi.string(),cinemaRoom: joi.number(),seats: joi.array().items(joi.string()).single(),totalAmount: joi.number()})
})module.exports = bookingSchema

const ticketSchema = (joi) => ({ticketSchema: joi.object().keys({cinema: joi.string(),schedule: joi.date().min('now'),movie: joi.string(),seat: joi.array().items(joi.string()).single(),cinemaRoom: joi.number(),orderId: joi.number()})
})module.exports = ticketSchema

const userSchema = (joi) => ({userSchema: joi.object().keys({name: joi.string().regex(/^[a-bA-B]+/).required(),lastName: joi.string().regex(/^[a-bA-B]+/).required(),email: joi.string().email().required(),phoneNumber: joi.string().regex(/^(\+0?1\s)?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}$/),creditCard: joi.string().creditCard().required(),membership: joi.number().creditCard()})
})module.exports = userSchema

const joi = require('joi')
const user = require('./user.model')(joi)
const booking = require('./booking.model')(joi)
const ticket = require('./ticket.model')(joi)const schemas = Object.create({user, booking, ticket})const schemaValidator = (object, type) => {return new Promise((resolve, reject) => {if (!object) {reject(new Error('object to validate not provided'))}if (!type) {reject(new Error('schema type to validate not provided'))}const {error, value} = joi.validate(object, schemas[type])if (error) {reject(new Error(`invalid ${type} data, err: ${error}`))}resolve(value)})
}module.exports = Object.create({validate: schemaValidator})

/* eslint-env mocha */
const test = require('assert')
const {validate} = require('./')console.log(Object.getPrototypeOf(validate))describe('Schemas Validation', () => {it('can validate a booking object', (done) => {const now = new Date()now.setDate(now.getDate() + 1)const testBooking = {city: 'Morelia',cinema: 'Plaza Morelia',movie: 'Assasins Creed',schedule: now,cinemaRoom: 7,seats: ['45'],totalAmount: 71}validate(testBooking, 'booking').then(value => {console.log('validated')console.log(value)done()}).catch(err => {console.log(err)done()})})it('can validate a user object', (done) => {const testUser = {name: 'Cristian',lastName: 'Ramirez',email: 'cristiano@nupp.com',creditCard: '1111222233334444',membership: '7777888899990000'}validate(testUser, 'user').then(value => {console.log('validated')console.log(value)done()}).catch(err => {console.log(err)done()})})it('can validate a ticket object', (done) => {const testTicket = {cinema: 'Plaza Morelia',schedule: new Date(),movie: 'Assasins Creed',seats: ['35'],cinemaRoom: 1,orderId: '34jh1231ll'}validate(testTicket, 'ticket').then(value => {console.log('validated')console.log(value)done()}).catch(err => {console.log(err)done()})})
})

'use strict'
const status = require('http-status')module.exports = ({repo}, app) => {app.post('/booking', (req, res, next) => {// we grab the dependencies need it for this routeconst validate = req.container.resolve('validate')const paymentService = req.container.resolve('paymentService')const notificationService = req.container.resolve('notificationService')Promise.all([validate(req.body.user, 'user'),validate(req.body.booking, 'booking')]).then(([user, booking]) => {const payment = {userName: user.name + ' ' + user.lastName,currency: 'mxn',number: user.creditCard.number,cvc: user.creditCard.cvc,exp_month: user.creditCard.exp_month,exp_year: user.creditCard.exp_year,amount: booking.amount,description: `Tickect(s) for movie ${booking.movie},with seat(s) ${booking.seats.toString()}at time ${booking.schedule}`}return Promise.all([// we call the payment servicepaymentService(payment),Promise.resolve(user),Promise.resolve(booking)])}).then(([paid, user, booking]) => {return Promise.all([repo.makeBooking(user, booking),repo.generateTicket(paid, booking)])}).then(([booking, ticket]) => {// we call the notification servicenotificationService({booking, ticket})res.status(status.OK).json(ticket)}).catch(next)})app.get('/booking/verify/:orderId', (req, res, next) => {repo.getOrderById(req.params.orderId).then(order => {res.status(status.OK).json(order)}).catch(next)})
}

const { createContainer, asValue, asFunction, asClass } = require('awilix')function initDI ({serverSettings, dbSettings, database, models, services}, mediator) {mediator.once('init', () => {mediator.on('db.ready', (db) => {const container = createContainer()// loading dependecies in a single source of truthcontainer.register({database: asValue(db).singleton(),validate: asValue(models.validate),booking: asValue(models.booking),user: asValue(models.booking),ticket: asValue(models.booking),ObjectID: asClass(database.ObjectID),serverSettings: asValue(serverSettings),paymentService: asValue(services.paymentService),notificationService: asValue(services.notificationService)})// we emit the container to be able to use it in the APImediator.emit('di.ready', container)})mediator.on('db.error', (err) => {mediator.emit('di.error', err)})database.connect(dbSettings, mediator)mediator.emit('boot.ready')})
}module.exports.initDI = initDI

'use strict'
const {EventEmitter} = require('events')
const server = require('./server/server')
const repository = require('./repository/repository')
const di = require('./config')
const mediator = new EventEmitter()console.log('--- Booking Service ---')
console.log('Connecting to movies repository...')process.on('uncaughtException', (err) => {console.error('Unhandled Exception', err)
})process.on('uncaughtRejection', (err, promise) => {console.error('Unhandled Rejection', err)
})mediator.on('di.ready', (container) => {repository.connect(container).then(repo => {container.registerFunction({repo})return server.start(container)}).then(app => {app.on('close', () => {container.resolve('repo').disconnect()})})
})di.init(mediator)mediator.emit('init')

const express = require('express')
const morgan = require('morgan')
const helmet = require('helmet')
const bodyparser = require('body-parser')
const cors = require('cors')
const spdy = require('spdy')
const _api = require('../api/booking')const start = (container) => {return new Promise((resolve, reject) => {// here we grab our dependencies needed for the serverconst {repo, port, ssl} = container.resolve('serverSettings')if (!repo) {reject(new Error('The server must be started with a connected repository'))}if (!port) {reject(new Error('The server must be started with an available port'))}const app = express()app.use(morgan('dev'))app.use(bodyparser.json())app.use(cors())app.use(helmet())app.use((err, req, res, next) => {if (err) {reject(new Error('Something went wrong!, err:' + err))res.status(500).send('Something went wrong!')}next()})// here is where we register the container as middlewareapp.use((req, res, next) => {req.container = container.createScope()next()})// here we inject the repo to the API, since the repo is need it for all of our functions// and we are using inversion of control to make it availableconst api = _api.bind(null, {repo: container.resolve('repo')})api(app)if (process.env.NODE === 'test') {const server = app.listen(port, () => resolve(server))} else {const server = spdy.createServer(ssl, app).listen(port, () => resolve(server))}})
}

'use strict'
const repository = (container) => {// we get the db object via the containerconst {db} = container.resolve('database')const makeBooking = (user, booking) => {return new Promise((resolve, reject) => {// payload to be insterted to the booking collection const payload = {city: booking.city,cinema: booking.cinema,book: {userType: (user.membership) ? 'loyal' : 'normal',movie: {title: booking.movie.title,format: booking.movie.format,schedule: booking.schedule}}}db.collection('booking').insertOne(payload, (err, booked) => {if (err) {reject(new Error('An error occuered registring a user booking, err:' + err))}resolve(booked)})})}const generateTicket = (paid, booking) => {return new Promise((resolve, reject) => {// payload of ticketconst payload = Object.assign({}, {booking, orderId: paid._id})db.collection('tickets').insertOne(payload, (err, ticket) => {if (err) {reject(new Error('an error occured registring a ticket, err:' + err))}resolve(ticket)})})}const getOrderById = (orderId) => {return new Promise((resolve, reject) => {const ObjectID = container.resolve('ObjectID')const query = {_id: new ObjectID(orderId)}const response = (err, order) => {if (err) {reject(new Error('An error occuered retrieving a order, err: ' + err))}resolve(order)}db.collection('booking').findOne(query, {}, response)})}const disconnect = () => {db.close()}return Object.create({makeBooking,getOrderById,generateTicket,disconnect})
}const connect = (container) => {return new Promise((resolve, reject) => {if (!container.resolve('database')) {reject(new Error('connection db not supplied!'))}resolve(repository(container))})
}module.exports = Object.assign({}, {connect})