feat(server): create

Author: VincentHardouin

config.js

@@ -9,6 +9,7 @@ function isFeatureEnabled(environmentVariable) {
 function buildConfiguration() {
   const config = {
     environment: env.NODE_ENV || 'development',
+    port: env.PORT || 3000,
     logging: {
       enabled: isFeatureEnabled(env.LOG_ENABLED),
       logLevel: env.LOG_LEVEL || 'info',
@@ -39,6 +40,9 @@ function buildConfiguration() {
       url: env.NOTIFICATION_URL,
       token: env.NOTIFICATION_TOKEN,
     },
+    calendar: {
+      name: env.CALENDAR_NAME,
+    },
     timeSlotsPreferences: JSON.parse(env.TIME_SLOTS_PREFERENCES),
   };
   if (config.environment === 'test') {

index.js

@@ -2,13 +2,17 @@ import { CronJob } from 'cron';
 
 import { config } from './config.js';
 
+import { createServer } from './server.js';
 import { ReservationController } from './src/application/ReservationController.js';
+import { CreateReservationEventsUseCase } from './src/domain/usecases/CreateReservationEventsUseCase.js';
 import { GetActiveReservationsUseCase } from './src/domain/usecases/GetActiveReservationsUseCase.js';
+import { GetAllEventsUseCase } from './src/domain/usecases/GetAllEventsUseCase.js';
 import { HandleNewReservationUseCase } from './src/domain/usecases/HandleNewReservationUseCase.js';
 import { HandleScheduledReservationUseCase } from './src/domain/usecases/HandleScheduledReservationUseCase.js';
 import { NotifyUseCase } from './src/domain/usecases/NotifyUseCase.js';
 import { SubmitFormUseCase } from './src/domain/usecases/SubmitFormUseCase.js';
 import { Browser } from './src/infrastructure/Browser.js';
+import { CalendarRepository } from './src/infrastructure/CalendarRepository.js';
 import { ImapClient } from './src/infrastructure/ImapClient.js';
 import { logger } from './src/infrastructure/logger.js';
 import { NotificationClient } from './src/infrastructure/NotificationClient.js';
@@ -31,6 +35,8 @@ async function main() {
     start: true,
     timeZone: parisTimezone,
   });
+  const server = await createServer({ reservationController });
+  await server.start();
 }
 
 async function getReservationController() {
@@ -71,12 +77,23 @@ async function getReservationController() {
     reservationRepository,
   });
 
+  const calendarRepository = new CalendarRepository(config.calendar.name);
+
+  const createReservationEventsUseCase = new CreateReservationEventsUseCase({
+    reservationRepository,
+    calendarRepository,
+  });
+
+  const getAllEventsUseCase = new GetAllEventsUseCase({ calendarRepository });
+
   return new ReservationController({
     handleNewReservationUseCase,
     getActiveReservationsUseCase,
     submitFormUseCase,
     notifyUseCase,
     handleScheduledReservationUseCase,
+    createReservationEventsUseCase,
+    getAllEventsUseCase,
     logger,
   });
 }

server.js

@@ -0,0 +1,36 @@
+import Hapi from '@hapi/hapi';
+import { config } from './config.js';
+import * as pino from './src/infrastructure/pino.js';
+import { routes } from './src/infrastructure/routes.js';
+
+const createBareServer = function () {
+  const serverConfiguration = {
+    compression: false,
+    debug: { request: false, log: false },
+    routes: {
+      cors: {
+        origin: ['*'],
+        additionalHeaders: ['X-Requested-With'],
+      },
+      response: {
+        emptyStatusCode: 204,
+      },
+    },
+    port: config.port,
+    router: {
+      isCaseSensitive: false,
+      stripTrailingSlash: true,
+    },
+  };
+
+  return Hapi.server(serverConfiguration);
+};
+
+async function createServer(controllers) {
+  const server = createBareServer();
+  await server.register([pino]);
+  routes.map(Route => new Route(controllers).register(server));
+  return server;
+}
+
+export { createServer };

src/application/ReservationController.js

@@ -1,13 +1,28 @@
 export class ReservationController {
-  constructor({ handleNewReservationUseCase, getActiveReservationsUseCase, submitFormUseCase, notifyUseCase, handleScheduledReservationUseCase, logger }) {
+  constructor({
+    handleNewReservationUseCase,
+    getActiveReservationsUseCase,
+    submitFormUseCase,
+    notifyUseCase,
+    handleScheduledReservationUseCase,
+    createReservationEventsUseCase,
+    getAllEventsUseCase,
+    logger,
+  }) {
     this.handleNewReservationUseCase = handleNewReservationUseCase;
     this.getActiveReservationsUseCase = getActiveReservationsUseCase;
     this.submitFormUseCase = submitFormUseCase;
     this.notifyUseCase = notifyUseCase;
     this.handleScheduledReservationUseCase = handleScheduledReservationUseCase;
+    this.createReservationEventsUseCase = createReservationEventsUseCase;
+    this.getAllEventsUseCase = getAllEventsUseCase;
     this.logger = logger;
   }
 
+  async getCalendar() {
+    return this.getAllEventsUseCase.execute();
+  }
+
   async handleReservations() {
     this.logger.info('Start - HandleNewReservations');
     await this.handleNewReservationUseCase.execute();
@@ -34,5 +49,9 @@ export class ReservationController {
     this.logger.info('Start - HandleScheduledReservations');
     await this.handleScheduledReservationUseCase.execute();
     this.logger.info('End - HandleScheduledReservations');
+
+    this.logger.info('Start - CreateReservationEventsUseCase');
+    await this.createReservationEventsUseCase.execute();
+    this.logger.info('End - CreateReservationEventsUseCase');
   }
 }

src/infrastructure/ReservationInterface.js

@@ -0,0 +1,25 @@
+export class ReservationInterface {
+  constructor({ reservationController }) {
+    this.reservationController = reservationController;
+  }
+
+  register(server) {
+    server.route([
+      {
+        method: 'GET',
+        path: '/reservations/calendar',
+        options: {
+          handler: async (_, h) => {
+            const calendar = await this.reservationController.getCalendar();
+            const response = h
+              .response(calendar)
+              .type('text/calendar; charset=utf-8');
+            response.header('Content-Disposition', 'attachment; filename="calendar.ics"');
+            return response;
+          },
+          tags: ['api', 'reservations', 'calendar'],
+        },
+      },
+    ]);
+  }
+}

src/infrastructure/pino.js

@@ -0,0 +1,58 @@
+import { logger } from './Logger.js';
+
+const plugin = {
+  name: 'hapi-pino',
+  register: async (server, options) => {
+    const logger = options.instance;
+
+    server.ext('onPostStart', async () => {
+      logger.info(server.info, 'server started');
+    });
+
+    server.ext('onPostStop', async () => {
+      logger.info(server.info, 'server stopped');
+    });
+
+    server.events.on('log', (event) => {
+      logger.info({ tags: event.tags, data: event.data });
+    });
+
+    server.events.on('request', (_, event) => {
+      if (event.channel !== 'error') {
+        return;
+      }
+      if (event.error) {
+        logger.error(
+          {
+            tags: event.tags,
+            err: event.error,
+          },
+          'request error',
+        );
+      }
+    });
+
+    server.events.on('response', (request) => {
+      const info = request.info;
+
+      logger.info(
+        {
+          queryParams: request.query,
+          responseTime:
+          (info.completed !== undefined ? info.completed : info.responded)
+          - info.received,
+          payload: request.auth.isAuthenticated ? request.payload : {},
+          req: request,
+          res: request.raw.res,
+        },
+        'request completed',
+      );
+    });
+  },
+};
+
+const options = {
+  instance: logger,
+};
+
+export { options, plugin };

src/infrastructure/routes.js

@@ -0,0 +1,3 @@
+import { ReservationInterface } from './ReservationInterface.js';
+
+export const routes = [ReservationInterface];