Merge pull request #359 from effective-dev-opensource/release/1.0.0

Release/1.0.0

Author: Radch-enko

README.md

@@ -17,7 +17,7 @@ technologies as little as possible.
 
 <img src="media/tablet/demo-tablet.gif" style="height: 50%;" />
 
-### 🔧 Features Overview
+### Features Overview
 
 | Feature                     | Description                                                  |
 |----------------------------|--------------------------------------------------------------|
@@ -54,6 +54,7 @@ technologies as little as possible.
    ```bash
    cp backend/app/src/main/resources/env.example backend/app/src/main/resources/.env
    ```
+   Edit the `.env` file with your configuration.
 
 4. Set up required credentials:
    - Add `google-credentials.json` for Google Calendar API
@@ -75,6 +76,12 @@ technologies as little as possible.
    ./gradlew :backend:app:bootRun --args='--spring.profiles.active=local'
    ```
 
+#### Run Clients
+1. Open the project in Android Studio or IntelliJ IDEA
+2. Sync the Gradle project to download dependencies
+3. Choose the appropriate run configuration in IDE
+4. Run (Shift+F10 or Control+R)
+
 For detailed installation instructions, including setting up credentials and running client applications, see our [Getting Started Guide](https://github.com/effective-dev-opensource/Effective-Office/wiki/Getting-Started-with-Effective-Office) in the wiki.
 
 ## Project Structure
@@ -123,7 +130,7 @@ An application for tracking foosball match results. It allows users to log games
 - [Tatyana Terleeva](https://t.me/tatyana_terleeva) 
 - [Stanislav Radchenko](https://github.com/Radch-enko)
 - [Vitaly Smirnov](https://github.com/KrugarValdes)
-- [Victoria Maksimovna](https://t.me/the_koheskine)
+- [Viktoriya Kokh](https://t.me/the_koheskine)
 
 ## License
 The code is available as open source under the terms of the [MIT LICENSE](LICENSE).

backend/feature/booking/calendar/google/src/main/kotlin/band/effective/office/backend/feature/booking/calendar/google/GoogleCalendarProvider.kt

@@ -33,6 +33,10 @@ class GoogleCalendarProvider(
 
     private val logger = LoggerFactory.getLogger(GoogleCalendarProvider::class.java)
 
+    companion object {
+        private const val RESPONSE_STATUS_DECLINED = "declined"
+    }
+
     @Value("\${calendar.default-calendar}")
     private lateinit var defaultCalendar: String
 
@@ -203,38 +207,154 @@ class GoogleCalendarProvider(
         }
     }
 
+    /**
+     * Deletes an event from Google Calendar.
+     *
+     * @param calendarId The ID of the calendar containing the event
+     * @param eventId The ID of the event to delete
+     * @return true if the event was successfully deleted, false otherwise
+     */
+    private fun deleteEvent(calendarId: String, eventId: String): Boolean {
+        return try {
+            calendar.events().delete(calendarId, eventId).execute()
+            logger.info("Successfully deleted event $eventId from calendar $calendarId because all participants declined")
+            true
+        } catch (e: GoogleJsonResponseException) {
+            logger.error("Failed to delete event $eventId from calendar $calendarId: {}", e.details)
+            false
+        } catch (e: Exception) {
+            logger.error("Unexpected error when deleting event $eventId from calendar $calendarId", e)
+            false
+        }
+    }
+
+    /**
+     * Retrieves a list of events from a Google Calendar within a specified time range.
+     *
+     * This method performs the following operations:
+     * 1. Fetches events from the specified calendar within the given time range
+     * 2. Filters out events where all human participants have declined (and optionally deletes them)
+     * 3. Filters out events where any resource (room/workspace) has declined
+     *
+     * @param calendarId The ID of the Google Calendar to query
+     * @param from The start time for the query (inclusive)
+     * @param to The end time for the query (exclusive), or null for no end time limit
+     * @param q Optional search term to filter events by
+     * @param returnInstances Whether to expand recurring events into individual instances
+     * @return A filtered list of Google Calendar events
+     */
     private fun listEvents(
         calendarId: String,
         from: Instant,
         to: Instant?,
         q: String? = null,
         returnInstances: Boolean = true
     ): List<Event> {
-        val eventsRequest = calendar.events().list(calendarId)
+        // Build the events request with required parameters
+        val eventsRequest = buildEventsRequest(calendarId, from, to, q, returnInstances)
+
+        return try {
+            // Execute the request and get the events
+            val fetchedEvents = eventsRequest.execute().items ?: emptyList()
+
+            // Process and filter the events
+            processEvents(fetchedEvents)
+        } catch (e: GoogleJsonResponseException) {
+            handleGoogleJsonException(e, calendarId)
+            emptyList()
+        } catch (e: Exception) {
+            logger.error("Unexpected error when listing events from Google Calendar for calendar ID: $calendarId", e)
+            emptyList()
+        }
+    }
+
+    /**
+     * Builds a Google Calendar events request with the specified parameters.
+     */
+    private fun buildEventsRequest(
+        calendarId: String,
+        from: Instant,
+        to: Instant?,
+        q: String?,
+        returnInstances: Boolean
+    ): Calendar.Events.List {
+        val request = calendar.events().list(calendarId)
             .setTimeMin(DateTime(from.toEpochMilli()))
             .setSingleEvents(returnInstances)
 
-        if (to != null) {
-            eventsRequest.timeMax = DateTime(to.toEpochMilli())
+        // Add optional parameters if provided
+        to?.let { request.timeMax = DateTime(it.toEpochMilli()) }
+        q?.let { request.q = it }
+
+        return request
+    }
+
+    /**
+     * Processes and filters the fetched events according to business rules.
+     */
+    private fun processEvents(events: List<Event>): List<Event> {
+        // Remove events where all human participants have declined
+        val eventsAfterParticipantCheck = events.filter { event -> 
+            !shouldRemoveEventWithAllDeclinedParticipants(event)
         }
 
-        if (q != null) {
-            eventsRequest.q = q
+        // Remove events where any resource has declined
+        return eventsAfterParticipantCheck.filter { event ->
+            !hasAnyResourceDeclined(event)
         }
+    }
 
-        return try {
-            eventsRequest.execute().items ?: emptyList()
-        } catch (e: GoogleJsonResponseException) {
-            logger.error("Failed to list events from Google Calendar: {}", e.details)
-            if (e.statusCode == 404) {
-                logger.warn("Calendar with ID {} not found", calendarId)
-            } else if (e.statusCode == 403) {
-                logger.warn("Permission denied for calendar with ID {}", calendarId)
-            }
-            emptyList()
-        } catch (e: Exception) {
-            logger.error("Unexpected error when listing events from Google Calendar", e)
-            emptyList()
+    /**
+     * Checks if an event should be removed because all human participants have declined.
+     * If all participants have declined, attempts to delete the event.
+     * 
+     * @return true if the event should be removed from results, false otherwise
+     */
+    private fun shouldRemoveEventWithAllDeclinedParticipants(event: Event): Boolean {
+        val isDefaultOrganizer = event.organizer?.email == defaultCalendar
+
+        // Only check events organized by our default calendar
+        if (event.attendees == null || event.attendees.isEmpty() || !isDefaultOrganizer) {
+            return false
+        }
+
+        // Get all human participants (non-resource attendees)
+        val humanParticipants = event.attendees.filter { it.resource == false || it.resource == null }
+
+        // Check if all human participants have declined
+        val allHumansDeclined = humanParticipants.isNotEmpty() && 
+                                humanParticipants.all { it.responseStatus == RESPONSE_STATUS_DECLINED }
+
+        // If all humans declined, try to delete the event
+        if (allHumansDeclined) {
+            logger.warn("Deleting event with ID {} because all participants declined", event.id)
+            val deletionSucceeded = deleteEvent(defaultCalendar, event.id)
+            return deletionSucceeded
+        }
+
+        return false
+    }
+
+    /**
+     * Checks if any resource (room/workspace) attendee has declined the event.
+     * 
+     * @return true if any resource has declined, false otherwise
+     */
+    private fun hasAnyResourceDeclined(event: Event): Boolean {
+        return event.attendees?.any { attendee ->
+            attendee.resource == true && attendee.responseStatus == RESPONSE_STATUS_DECLINED
+        } ?: false
+    }
+
+    /**
+     * Handles Google JSON API exceptions with appropriate logging.
+     */
+    private fun handleGoogleJsonException(e: GoogleJsonResponseException, calendarId: String) {
+        logger.error("Failed to list events from Google Calendar: {}", e.details)
+        when (e.statusCode) {
+            404 -> logger.warn("Calendar with ID {} not found", calendarId)
+            403 -> logger.warn("Permission denied for calendar with ID {}", calendarId)
+            else -> logger.error("Google API error with status code {} for calendar ID {}", e.statusCode, calendarId)
         }
     }
 

backend/feature/notifications/src/main/kotlin/band/effective/office/backend/feature/notifications/controller/NotificationDeduplicator.kt

@@ -10,7 +10,7 @@ import org.springframework.stereotype.Component
 @Component
 class NotificationDeduplicator {
 
-    private val ttlSeconds = 10L
+    private val ttlSeconds = 5L
 
     @OptIn(ExperimentalTime::class)
     private val seenEvents = ConcurrentHashMap<String, Instant>()

clients/tablet/composeApp/build.gradle.kts

@@ -84,8 +84,8 @@ android {
         targetSdk = libs.versions.android.targetSdk.get().toInt()
 
         applicationId = "band.effective.office.tablet"
-        versionCode = 1
-        versionName = "0.0.2"
+        versionCode = 2
+        versionName = "1.0.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
 

clients/tablet/composeApp/src/androidMain/kotlin/band/effective/office/tablet/App.android.kt

@@ -10,6 +10,7 @@ import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.annotation.RequiresApi
 import band.effective.office.tablet.root.RootComponent
+import band.effective.office.tablet.time.TimeReceiver
 import com.arkivanov.decompose.defaultComponentContext
 
 class AppActivity : ComponentActivity() {
@@ -18,15 +19,25 @@ class AppActivity : ComponentActivity() {
         var isRunKioskMode = false
     }
 
+    val timeReceiver by lazy { TimeReceiver(this) }
+
     @RequiresApi(Build.VERSION_CODES.P)
     override fun onCreate(savedInstanceState: Bundle?) {
         runKioskMode()
         super.onCreate(savedInstanceState)
+
+        timeReceiver.register()
         enableEdgeToEdge()
         val root = RootComponent(componentContext = defaultComponentContext())
         setContent { App(root) }
     }
 
+    override fun onDestroy() {
+        // Unregister the time receiver
+        timeReceiver.unregister()
+        super.onDestroy()
+    }
+
     @RequiresApi(Build.VERSION_CODES.P)
     private fun runKioskMode(){
         val context = this

clients/tablet/composeApp/src/androidMain/kotlin/band/effective/office/tablet/App.kt

@@ -1,13 +1,15 @@
 package band.effective.office.tablet
 
 import android.app.Application
-import android.util.Log
+import band.effective.office.tablet.core.domain.manager.DateResetManager
 import band.effective.office.tablet.core.domain.model.SettingsManager
+import band.effective.office.tablet.core.ui.inactivity.InactivityLifecycleCallbacks
 import band.effective.office.tablet.di.KoinInitializer
 import com.google.firebase.messaging.FirebaseMessaging
 import com.russhwolf.settings.SharedPreferencesSettings
 import org.koin.android.ext.android.get
 import org.koin.core.qualifier.named
+import kotlin.time.Duration.Companion.minutes
 
 class App : Application() {
 
@@ -24,6 +26,7 @@ class App : Application() {
             )
         )
         subscribeOnFirebaseTopics()
+        initializeInactivitySystem()
     }
 
     private fun subscribeOnFirebaseTopics() {
@@ -32,4 +35,14 @@ class App : Application() {
             FirebaseMessaging.getInstance().subscribeToTopic(topic)
         }
     }
+
+    private fun initializeInactivitySystem() {
+        InactivityLifecycleCallbacks.initialize(
+            application = this,
+            timeoutMs = 1.minutes.inWholeMilliseconds,
+            callback = {
+                DateResetManager.resetDate()
+            }
+        )
+    }
 }

clients/tablet/composeApp/src/androidMain/kotlin/band/effective/office/tablet/time/TimeReceiver.kt

@@ -0,0 +1,56 @@
+package band.effective.office.tablet.time
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.util.Log
+import band.effective.office.tablet.feature.main.domain.CurrentTimeHolder
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.datetime.Clock
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+
+/**
+ * A broadcast receiver that listens for time-related broadcasts and emits the current time.
+ */
+actual class TimeReceiver(private val context: Context) {
+
+    actual val currentTime: StateFlow<LocalDateTime> = CurrentTimeHolder.currentTime
+
+    private val receiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            when (intent?.action) {
+                Intent.ACTION_TIME_TICK, Intent.ACTION_TIME_CHANGED -> {
+                    CurrentTimeHolder.updateTime(getCurrentTime())
+                }
+            }
+        }
+    }
+
+    /**
+     * Registers the broadcast receiver to listen for time-related broadcasts.
+     */
+    fun register() {
+        val filter = IntentFilter().apply {
+            addAction(Intent.ACTION_TIME_TICK)
+            addAction(Intent.ACTION_TIME_CHANGED)
+        }
+        context.registerReceiver(receiver, filter)
+    }
+
+    /**
+     * Unregisters the broadcast receiver.
+     */
+    fun unregister() {
+        context.unregisterReceiver(receiver)
+    }
+
+    /**
+     * Gets the current time as a LocalDateTime.
+     */
+    private fun getCurrentTime(): LocalDateTime {
+        return Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault())
+    }
+}

clients/tablet/composeApp/src/commonMain/kotlin/band/effective/office/tablet/root/RootComponent.kt

@@ -2,7 +2,6 @@ package band.effective.office.tablet.root
 
 import band.effective.office.tablet.core.domain.model.EventInfo
 import band.effective.office.tablet.core.domain.model.RoomInfo
-import band.effective.office.tablet.core.domain.model.Slot
 import band.effective.office.tablet.core.domain.useCase.CheckSettingsUseCase
 import band.effective.office.tablet.core.domain.useCase.ResourceDisposerUseCase
 import band.effective.office.tablet.core.ui.common.ModalWindow
@@ -153,16 +152,10 @@ class RootComponent(
             componentContext = componentContext,
             initialEvent = config.event,
             roomName = config.room,
-            onDeleteEvent = ::handleDeleteEvent,
             onCloseRequest = modalNavigation::dismiss,
         )
     }
 
-    private fun handleDeleteEvent(slot: Slot) {
-        val mainComponent = (childStack.value.active.instance as? Child.MainChild)?.component
-        mainComponent?.handleDeleteEvent(slot)
-    }
-
     private fun createFastBookingComponent(
         config: ModalWindowsConfig.FastEvent,
         componentContext: ComponentContext