Merge pull request #150 from effectivemade/backend

Backend hotfix #2

effectiveOfficeBackend/src/main/kotlin/office/effective/features/booking/repository/BookingCalendarRepository.kt

@@ -20,40 +20,29 @@ class BookingCalendarRepository(
     private val calendar: Calendar,
     private val workspaceRepository: WorkspaceRepository
 ) : IBookingRepository {
-    private val calendarEvents = calendar.Events();
+    private val calendarEvents = calendar.Events()
+    private val defaultCalendar = config.propertyOrNull("auth.app.defaultAppEmail")?.getString()
+        ?: throw Exception("Config file does not contain default gmail value")
 
     private fun getCalendarIdByWorkspace(workspaceId: UUID): String {
         if (workspaceRepository.findById(workspaceId)?.tag != "meeting") {
-            return config.propertyOrNull("auth.app.defaultAppEmail")?.getString() ?: throw Exception(
-                "Config file does not contain default gmail value"
-            )
+            return defaultCalendar
         }
         return calendarRepository.findByWorkspace(workspaceId)
     }
 
     override fun existsById(id: String): Boolean {
-        var event: Any? = null
-        calendarRepository.findAllCalendarsId().forEach {
-            event = calendarEvents.get(it, id).execute()
-        }
+        val event: Any?
+        event = calendarEvents.get(defaultCalendar, id).execute()
         return event != null
     }
 
     override fun deleteById(id: String) {
-        calendarEvents.delete("effective.office@effective.band", id).execute()
-//        calendarRepository.findAllCalendarsId().forEach {
-//            calendarEvents.delete(it, id).execute()
-//        }
+        calendarEvents.delete(defaultCalendar, id).execute()
     }
 
     override fun findById(bookingId: String): Booking? {
-        var event: Event? = null;
-        calendarRepository.findAllCalendarsId().forEach {
-            val a = findByCalendarIdAndBookingId(it, bookingId)
-            if (a != null) {
-                event = a
-            }
-        }
+        val event: Event? = findByCalendarIdAndBookingId(defaultCalendar, bookingId)
         return event?.toBookingModel()
     }
 
@@ -64,21 +53,18 @@ class BookingCalendarRepository(
     override fun findAllByOwnerId(ownerId: UUID): List<Booking> {
         val userEmail: String = findUserEmailByUserId(ownerId)
         val eventsList = mutableListOf<Event>()
-        for (calendarId in calendarRepository.findAllCalendarsId()) {
-            calendarEvents.list(calendarId).execute().items.filter {
-                it.status != "cancelled"
-            }.filter {
-                it?.organizer?.email?.equals(
-                    userEmail
-                ) ?: false
-            }.forEach { eventsList.add(it) }
-        }
-//        calendarRepository.findAllCalendarsId().forEach {
-//            eventsList.addAll(calendarEvents.list(it).execute().items.filter { it.organizer.email.equals(userEmail) }
-//                .toList())
-//        }
+        calendarEvents.list(defaultCalendar).execute().items.filter {
+            it.status != "cancelled"
+        }.filter {
+            it?.organizer?.email?.equals(
+                userEmail
+            ) ?: false
+        }.forEach { eventsList.add(it) }
+
         val bookingList = mutableListOf<Booking>()
-        eventsList.forEach { bookingList.add(it.toBookingModel()) }
+        eventsList.forEach {
+            bookingList.add(it.toBookingModel())
+        }
         return bookingList;
     }
 
@@ -94,40 +80,37 @@ class BookingCalendarRepository(
 
     private fun findAllEntitiesByWorkspaceId(workspaceId: UUID): List<Event> {
         val calendarId = getCalendarIdByWorkspace(workspaceId)
-        return calendarEvents.list(calendarId).execute().items.filter {
+        return calendarEvents.list(defaultCalendar).execute().items.filter {
             it.status != "cancelled"
         }.filter { (it?.start?.dateTime?.value ?: 0) > GregorianCalendar().time.time }
+            .filter { hasId(it, calendarId) }
+    }
+
+    private fun hasId(event: Event, calendarId: String): Boolean {
+        event.attendees.forEach {
+            if(it.email == calendarId) return true
+        }
+        return false
     }
 
     override fun findAllByOwnerAndWorkspaceId(ownerId: UUID, workspaceId: UUID): List<Booking> {
-        val email = findUserEmailByUserId(ownerId)
         return findAllByOwnerId(ownerId).filter {
             it.workspace.id == workspaceId
         }
-//        return findAllByWorkspaceId(workspaceId).filter {
-//            it.owner.email.equals(
-//                email
-//            )
-//        }
     }
 
     override fun findAll(): List<Booking> {
         val bookingList = mutableListOf<Booking>()
-        calendarRepository.findAllCalendarsId().forEach { calendarId ->
-            calendarEvents.list(calendarId).execute().items.filter { event ->
-                event.status != "cancelled"
-            }.filter { (it?.start?.dateTime?.value ?: 0) > GregorianCalendar().time.time }
-                .forEach { bookingList.add(it.toBookingModel()) }
-        }
+        calendarEvents.list(defaultCalendar).execute().items.filter { event ->
+            event.status != "cancelled"
+        }.filter { (it?.start?.dateTime?.value ?: 0) > GregorianCalendar().time.time }
+            .forEach { bookingList.add(it.toBookingModel()) }
         return bookingList
     }
 
     override fun save(booking: Booking): Booking {
-
         val event = booking.toGoogleEvent()
-        val calendarID: String =
-            calendarRepository.findByWorkspace(booking.workspace.id ?: throw MissingIdException("workspace model"))
-        val savedEvent = calendar.Events().insert("effective.office@effective.band", event).execute()
+        val savedEvent = calendar.Events().insert(defaultCalendar, event).execute()
         return savedEvent.toBookingModel()//findById(savedEvent.id) ?: throw Exception("Calendar save goes wrong")
     }
 

effectiveOfficeBackend/src/main/kotlin/office/effective/plugins/CalendarNotifications.kt

@@ -3,6 +3,7 @@ package office.effective.plugins
 import com.google.api.services.calendar.Calendar
 import com.google.api.services.calendar.model.Channel
 import io.ktor.server.application.*
+import office.effective.config
 import office.effective.features.calendar.repository.CalendarRepository
 import org.koin.core.context.GlobalContext
 import java.util.*
@@ -13,11 +14,15 @@ import java.util.*
  * @author Daniil Zavyalov
  */
 fun Application.configureCalendarNotifications() {
+    val defaultCalendar = config.propertyOrNull("auth.app.defaultAppEmail")?.getString()
+        ?: throw Exception("Config file does not contain default gmail value")
 
     val calendar: Calendar = GlobalContext.get().get()
     val appAddress: String = System.getenv("APPLICATION_URL")
     val calendarRepository: CalendarRepository = GlobalContext.get().get()
-    calendarRepository.findAllCalendarsId().forEach { calendar_id ->
+    val calendarIds = calendarRepository.findAllCalendarsId().toMutableList()
+    calendarIds.add(defaultCalendar)
+    calendarIds.forEach { calendar_id ->
         val channel = Channel().apply {
             id = UUID.randomUUID().toString()
             type = "web_hook"