create meets endpoint

index.js

@@ -24,10 +24,11 @@ const repositories = new RepositoriesProvider(db)
 const notesRepository = repositories.provideNotesRepository()
 const sessionsRepository = repositories.provideSessionsRepository()
 const teamsRepository = repositories.provideTeamsRepository()
+const meetsRepository = repositories.provideMeetsRepository()
 
 const ControllersProvider = env.controllers
 const controllersProvider = new ControllersProvider(notesRepository, sessionsRepository,
-  teamsRepository)
+  teamsRepository, meetsRepository)
 
 const auth = require('./src/middlewares/auth')
 const RouterProvider = env.router

src/controllers/index.js

@@ -1,12 +1,14 @@
 const NoteController = require('./noteController')
 const SessionController = require('./sessionController')
 const TeamController = require('./teamController')
+const MeetController = require('./meetController')
 
 class ControllersProvider {
-  constructor (noteRepository, sessionRepository, teamRepository) {
+  constructor (noteRepository, sessionRepository, teamRepository, meetRepository) {
     this.noteRepository = noteRepository
     this.sessionRepository = sessionRepository
     this.teamRepository = teamRepository
+    this.meetRepository = meetRepository
   }
 
   getNotesController () {
@@ -20,6 +22,10 @@ class ControllersProvider {
   getTeamsController () {
     return new TeamController(this.teamRepository)
   }
+
+  getMeetsController () {
+    return new MeetController(this.meetRepository)
+  }
 }
 
 module.exports = ControllersProvider

src/controllers/meetController.js

@@ -0,0 +1,27 @@
+class MeetController {
+  constructor (meetRepository) {
+    this.meetRepository = meetRepository
+  }
+
+  async getMeets () {
+    return this.meetRepository.getMeets()
+  }
+
+  async getMeet (meet) {
+    return this.meetRepository.getMeet(meet)
+  }
+
+  async createMeet (meet) {
+    return this.meetRepository.createMeet(meet)
+  }
+
+  async editMeet (meet) {
+    return this.meetRepository.editMeet(meet)
+  }
+
+  async deleteMeet (meet) {
+    return this.meetRepository.deleteMeet(meet.id)
+  }
+}
+
+module.exports = MeetController

src/controllers/sessionController.js

@@ -5,8 +5,8 @@ class SessionController {
     this.sessionRepository = sessionRepository
   }
 
-  async getAllSessions (meeting) {
-    return this.sessionRepository.getAllSessions(meeting)
+  async getAllSessions (meetingId) {
+    return this.sessionRepository.getAllSessions(meetingId)
   }
 
   async getSession (session) {

src/environment/FilterMapper.js

@@ -0,0 +1,31 @@
+class FilterMapper {
+  toFirestore (key) {
+    if (key === 'EQUALS') {
+      return '=='
+    }
+    if (key === 'CONTAINS') {
+      return 'array-contains'
+    }
+    if (key === 'NEQUALS') {
+      return '!='
+    }
+    if (key === 'GREATERTHAN') {
+      return '>'
+    }
+    if (key === 'SMALLERTHAN') {
+      return '<'
+    }
+    if (key === 'CONTAINSANY') {
+      return 'array-contains-any'
+    }
+    if (key === 'EQGREATERTHAN') {
+      return '>='
+    }
+    if (key === 'EQSMALLERTHAN') {
+      return '<='
+    }
+    return ''
+  }
+}
+
+module.exports = FilterMapper

src/environment/FirestoreDB/index.js

@@ -1,4 +1,5 @@
 const admin = require('firebase-admin')
+const FilterMapper = require('../FilterMapper')
 const db = admin.firestore()
 const settings = { timestampsInSnapshots: true }
 db.settings(settings)
@@ -22,12 +23,17 @@ class FirestoreDB {
 
     if (data) {
       console.log('filtering')
+      var filter = data.getFilter()
       for (var field in data) {
         if (data[field] !== undefined && data[field] !== null) {
           if (field === 'id') {
             query = query.doc(data[field])
           } else {
-            query = query.where(field, '==', data[field])
+            if (filter[field] !== undefined && filter[field] !== null) {
+              query = query.where(field, FilterMapper.toFirestore(filter[field]), data[field])
+            } else {
+              query = query.where(field, '==', data[field])
+            }
           }
         }
       }

src/model/meet.js

@@ -0,0 +1,20 @@
+class Meet {
+  constructor (id, date, idTeam, members) {
+    this.id = id
+    this.date = date
+    this.idTeam = idTeam
+    this.members = members
+  }
+
+  // returns javascript object representation of team model
+  getMeet () {
+    return {
+      id: this.id,
+      date: this.date,
+      idTeam: this.idTeam,
+      members: this.members
+    }
+  }
+}
+
+module.exports = Meet

src/model/session.js

@@ -1,8 +1,9 @@
 class Session {
-  constructor (id, topics, timestamp) {
+  constructor (id, topics, timestamp, meetId) {
     this.id = id
     this.topics = topics
     this.timestamp = timestamp
+    this.meetId = this.meetId
   }
 
   getSession () {

src/model/team.js

@@ -15,6 +15,14 @@ class Team {
       members: this.members
     }
   }
+
+  getFilter () {
+    return {
+      name: 'EQUALS',
+      admin: 'EQUALS',
+      members: 'CONTAINS'
+    }
+  }
 }
 
 module.exports = Team

src/repositories/index.js

@@ -1,6 +1,7 @@
 const NoteRepository = require('./noteRepository')
 const SessionRepository = require('./sessionRepository')
 const TeamRepository = require('./teamRepository/teamRepository')
+const MeetRepository = require('./meetRepository/meetRepository')
 
 class RepositoriesProvider {
   constructor (db) {
@@ -18,6 +19,10 @@ class RepositoriesProvider {
   provideTeamsRepository () {
     return new TeamRepository(this.db)
   }
+
+  provideMeetsRepository () {
+    return new MeetRepository(this.db)
+  }
 }
 
 module.exports = RepositoriesProvider

src/repositories/meetRepository/meetRepository.js

@@ -0,0 +1,28 @@
+class MeetRepository {
+  constructor (db) {
+    this.db = db
+    this.table = 'meets'
+  }
+
+  async getMeets () {
+    return this.db.executeGetDB(this.table)
+  }
+
+  async getMeet (meet) {
+    return this.db.executeGetDB(this.table, meet)
+  }
+
+  async createMeet (meet) {
+    return this.db.executeInsert(this.table, meet.getMeet())
+  }
+
+  async editMeet (meet) {
+    return this.db.executeUpdateDB(this.table, meet.id, meet.getMeet())
+  }
+
+  async deleteMeet (id) {
+    return this.db.executeDelete(this.table, id)
+  }
+}
+
+module.exports = MeetRepository

src/repositories/sessionRepository/index.js

@@ -8,12 +8,6 @@ class SessionsRepository {
     return this.db.executeGetDB(this.table, session)
   }
 
-  // todo : getAllSession of a meeting
-  // eslint-disable-next-line no-use-before-define
-  async getAllSessions (meeting) {
-    return this.db.executeGetDB(this.table)
-  }
-
   async createSession (session) {
     return this.db.executeInsert(this.table, session)
   }

src/repositories/teamRepository/teamFilter.js

@@ -0,0 +1,12 @@
+class TeamFilter {
+  getFilter () {
+    return {
+      id: '==',
+      name: '==',
+      admin: '==',
+      members: 'contains'
+    }
+  }
+}
+
+module.exports = TeamFilter

src/router/index.js

@@ -1,9 +1,11 @@
 const notesFromSessionURL = '/notes/'
 const sessionURL = '/sessions/'
 const teamURL = '/teams/'
+const meetURL = '/meets/'
 const NotesRouter = require('./notesRouter')
 const SessionRouter = require('./sessionRouter')
 const TeamRouter = require('./teamRouter/teamRouter')
+const MeetRouter = require('./meetRouter/meetRouter')
 
 class RouterProvider {
   constructor (app, controllers, auth) {
@@ -24,6 +26,9 @@ class RouterProvider {
 
     var teamRouter = new TeamRouter(this.controllers.getTeamsController())
     this.app.use(teamURL, teamRouter.getRoutes())
+
+    var meetRouter = new MeetRouter(this.controllers.getMeetsController())
+    this.app.use(meetURL, meetRouter.getRoutes())
   }
 }
 

src/router/meetRouter/meetMapper.js

@@ -0,0 +1,71 @@
+const Joi = require('joi')
+const GenericMapper = require('../genericMapper')
+const Meet = require('../../model/meet')
+
+class MeetMapper {
+  constructor () {
+    this.genericMapper = new GenericMapper()
+  }
+
+  mapGetMeets (req) {
+    return this.genericMapper.map(this.validateEmpty.bind(this), req.params)
+  }
+
+  mapGetMeet (req) {
+    var map = this.genericMapper.map(this.validateId.bind(this), req.params)
+    var model = new Meet(map.id, null, null, null)
+    return model
+  }
+
+  mapCreateMeet (req) {
+    var map = this.genericMapper.map(this.validateMeet.bind(this), req.body)
+    var model = new Meet(null, map.date, map.idTeam, map.members)
+    return model
+  }
+
+  mapEditMeet (req) {
+    let newMeet = { ...req.params, ...req.body }
+    var map = this.genericMapper.map(this.validateMeetWithId.bind(this), newMeet)
+    var model = new Meet(null, map.date, map.idTeam, map.members)
+    return model
+  }
+
+  mapDeleteMeet (req) {
+    var map = this.genericMapper.map(this.validateId.bind(this), req.params)
+    var model = new Meet(map.id, null, null, null)
+    return model
+  }
+
+  validateEmpty (meet) {
+    return Joi.validate(meet, Joi.object().required())
+  }
+
+  validateId (meet) {
+    return Joi.validate(meet, Joi.object({
+      id: Joi.string().required()
+    }).required())
+  }
+
+  validateMeetWithId (meet) {
+    var model = Joi.validate(meet, Joi.object({
+      id: Joi.string().required(),
+      date: Joi.string().required(),
+      idTeam: Joi.string().required(),
+      members: Joi.array().items(Joi.string()).required()
+    }))
+
+    return model
+  }
+
+  validateMeet (meet) {
+    var model = Joi.validate(meet, Joi.object({
+      date: Joi.string().required(),
+      idTeam: Joi.string().required(),
+      members: Joi.array().items(Joi.string()).required()
+    }))
+
+    return model
+  }
+}
+
+module.exports = MeetMapper