Merge pull request #342 from effective-dev-opensource/release/0.0.2

Release/0.0.2

Author: Radch-enko

README.md

@@ -1,17 +1,37 @@
 # Effective Office
-## Overview
-Effective Office is a comprehensive office management system designed to streamline workplace operations, resource management, and employee interactions. The project consists of a backend server and tablet clients that work together to create an efficient office environment.
 
-## Features
-- Resource booking and management
-- Employee scheduling and coordination
-- Office space optimization
-- Cross-platform support (android, iOS)
-- Secure authentication and authorization
-- Real-time updates and notifications
+## Goal :dart:
+
+The main goal of the project is the automation of various processes in the office and providing
+interesting statistics for employees.
+
+## Technical goal: :wrench:
+
+The main technical task of the project is to create a multi-module application on Kotlin,
+trying to focus on the most modern and relevant solutions in this language. Throughout the project,
+we tried to use other languages and
+technologies as little as possible.
+
+## 📺 Features: (Meeting Room Tablet App)
+
+
+<img src="media/tablet/demo-tablet.gif" style="height: 50%;" />
+
+### 🔧 Features Overview
+
+| Feature                     | Description                                                  |
+|----------------------------|--------------------------------------------------------------|
+| Real-time Availability     | Displays up-to-date status of meeting rooms                  |
+| Quick Booking              | Instantly reserve an available room with a single tap        |
+| Time-Specific Reservations| Book rooms for specific time slots                           |
+| Booking Cancellation       | Cancel existing reservations with ease                       |
+| Early Room Release         | Free up the room before the end of the reservation           |
+| Google Calendar Integration| Syncs all bookings with Google Calendar                      |
 
 ## Architecture
+
 The project follows a client-server architecture:
+
 - **Backend**: Spring Boot application with PostgreSQL database
 - **Clients**: Client applications and iOS tablet app
 - **Deployment**: Docker-based containerization for easy deployment
@@ -20,15 +40,17 @@ The project follows a client-server architecture:
 ## Getting Started
 
 ### Prerequisites
+
 - Git
 - Docker and Docker Compose
 - JDK 17 or higher
 - Gitleaks (for development)
 
 ### Installation
+
 1. Clone the repository:
    ```
-   git clone https://github.com/your-organization/effective-office.git
+   git clone https://github.com/effective-dev-opensource/Effective-Office
    cd effective-office
    ```
 
@@ -51,13 +73,14 @@ The project follows a client-server architecture:
    ```
 
 ## Project Structure
+
 ```
 effective-office/
 ├── backend/           # Server-side application
 │   └── README.md      # Detailed backend documentation
 ├── clients/           # Client applications
 │   └── README.md      # Detailed client documentation
-├── iosApp/            # iOS mobile application
+├── iosApp/            # iOS tablet application
 ├── deploy/            # Deployment configurations
 │   ├── dev/           # Development environment
 │   └── prod/          # Production environment
@@ -68,37 +91,39 @@ effective-office/
 ```
 
 For detailed documentation:
+
 - [Backend Documentation](./backend/README.md)
 - [Client Documentation](./clients/README.md)
 - [Build Logic Documentation](./build-logic/README.md)
 - [Calendar Integration Documentation](docs/CALENDAR_INTEGRATION.md)
 
 ## Development Tools
+
 - **Build System**: Gradle with Kotlin DSL
 - **Containerization**: Docker and Docker Compose
 - **Security Scanning**: Gitleaks for secret detection
-- **CI/CD**: Automated build and deployment pipelines
 - **Version Control**: Git with pre-commit hooks
 
 ## Code Style & Conventions
+
 - Follow Kotlin coding conventions for backend development
 - Use consistent naming patterns across the codebase
 - Document public APIs and complex logic
 - Run the pre-commit hook to ensure no secrets are committed
 
-## Contributing
-1. Ensure you've run the installation script (`./scripts/install.sh`)
-2. Follow our [Git Flow](docs/GIT_FLOW.md) for branching and commit conventions
-3. Create a feature branch (`git checkout -b feature/amazing-feature`)
-4. Commit your changes (`git commit -m 'Add some amazing feature'`)
-5. Push to the branch (`git push origin feature/amazing-feature`)
-6. Open a Pull Request
+## Contributing :raised_hands:
+
+Our project is open-source, so we welcome quality contributions! To make your contribution to the
+project efficient and easy to check out, you can familiarize yourself with the project's [git flow
+and commit rules](docs/GIT_FLOW.md). If you want to solve an existing issue in the project, you can read the list in
+the issues tab in the repository.
 
 ## Roadmap
-- TODO
+- 📺 A TV application is in development, featuring a corporate news and photo feed, event announcements with registration
+  from an external service, Duolingo and sports leaderboards, and a tracker for the internal currency.
+
+## Authors :writing_hand:
 
-## Authors
-- TODO
+- [Stanislav Radchenko](https://github.com/Radch-enko)
+- [Vitaly Smirnov](https://github.com/KrugarValdes)
 
-## License
-- TODO

backend/app/src/main/resources/application.yml

@@ -55,10 +55,20 @@ management:
 logging:
   level:
     root: ${LOG_LEVEL:INFO}
-    org.hibernate.SQL: INFO
-    org.hibernate.type.descriptor.sql: INFO
-    org.hibernate.type.descriptor.sql.BasicBinder: TRACE
     band.effective.office.backend: ${LOG_LEVEL:DEBUG}
+    org.postgresql: WARN
+    org.hibernate: WARN
+    org.springframework: WARN
+    org.springframework.boot.autoconfigure: WARN
+    org.hibernate.SQL: WARN
+    org.hibernate.type.descriptor.sql.BasicBinder: WARN
+    org.hibernate.orm: WARN
+    com.zaxxer.hikari: INFO
+    org.apache.coyote.http11: WARN
+    com.google.api.client.http.HttpTransport: WARN
+    sun.net.www.protocol.http.HttpURLConnection: WARN
+    jdk.event.security: WARN
+    org.springframework.web.filter.CommonsRequestLoggingFilter: DEBUG
 
 application:
   url: ${APPLICATION_URL:http://localhost:8080}
@@ -75,7 +85,7 @@ calendar:
     default-app-email: ${DEFAULT_APP_EMAIL}
     google-credentials: ${GOOGLE_CREDENTIALS_FILE:classpath:google-credentials.json}
     application-url: ${APPLICATION_URL}
-    test-application-url: ${TEST_APPLICATION_URL}
+    test-application-url: ${TEST_APPLICATION_URL:}
     calendars: ${CALENDARS}
-    test-calendars: ${TEST_CALENDARS}
+    test-calendars: ${TEST_CALENDARS:}
     firebase-credentials: ${FIREBASE_CREDENTIALS:classpath:firebase-credentials.json}

backend/core/repository/src/main/resources/db/migration/V2__add_count_to_workspace_utilities.sql

@@ -0,0 +1,6 @@
+-- Add count column to workspace_utilities table
+ALTER TABLE workspace_utilities
+ADD COLUMN count INTEGER NOT NULL DEFAULT 1;
+
+-- Add comment to count column
+COMMENT ON COLUMN workspace_utilities.count IS 'Number of this utility in the workspace';

backend/feature/authorization/src/main/kotlin/band/effective/office/backend/feature/authorization/apikey/ApiKeyAuthorizer.kt

@@ -42,12 +42,10 @@ class ApiKeyAuthorizer(
         }
 
         val token = authHeader.substring(BEARER_PREFIX.length)
-        logger.debug("Authorization header found: $token")
 
         try {
             // Hash the token and check if it exists in the database
             val hashedToken = encryptKey(HASH_ALGORITHM, token)
-            logger.debug("Hashed token: $hashedToken")
             val apiKey = apiKeyRepository.findByKeyValue(hashedToken.lowercase())
 
             if (apiKey == null) {

backend/feature/authorization/src/main/kotlin/band/effective/office/backend/feature/authorization/config/PublicEndpoints.kt

@@ -0,0 +1,43 @@
+package band.effective.office.backend.feature.authorization.config
+
+/**
+ * Centralized configuration for public endpoints that don't require authentication.
+ * This class provides a single source of truth for paths that should be accessible without authentication.
+ */
+object PublicEndpoints {
+    /**
+     * List of ANT patterns for public endpoints.
+     */
+    val PATTERNS = listOf(
+        "/auth/**",
+        "/swagger-ui.html/**",
+        "/swagger-ui/**",
+        "/api-docs/**",
+        "/v3/api-docs/**",
+        "/api/swagger-ui.html/**",
+        "/api/swagger-ui/**",
+        "/api/api-docs/**",
+        "/api/v3/api-docs/**",
+        "/api/actuator/**",
+        "/api/notifications/**",
+        "/notifications",
+    )
+
+    /**
+     * Checks if the given URI matches any of the public endpoint patterns.
+     *
+     * @param uri The URI to check
+     * @return True if the URI matches any public endpoint pattern, false otherwise
+     */
+    fun matches(uri: String): Boolean {
+        return PATTERNS.any { pattern ->
+            // Convert ANT pattern to regex pattern
+            val regexPattern = pattern
+                .replace("/**", "(/.*)?") // /** matches zero or more path segments
+                .replace("/*", "(/[^/]*)?") // /* matches zero or one path segment
+                .replace("*", "[^/]*") // * matches zero or more characters within a path segment
+            
+            uri.matches(Regex("^$regexPattern$"))
+        }
+    }
+}

backend/feature/authorization/src/main/kotlin/band/effective/office/backend/feature/authorization/config/SecurityConfig.kt

@@ -1,5 +1,6 @@
 package band.effective.office.backend.feature.authorization.config
 
+import band.effective.office.backend.feature.authorization.config.PublicEndpoints
 import band.effective.office.backend.feature.authorization.security.JwtAuthenticationFilter
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
@@ -28,11 +29,7 @@ class SecurityConfig(
             .sessionManagement { it.sessionCreationPolicy(SessionCreationPolicy.STATELESS) }
             .authorizeHttpRequests { authorize ->
                 authorize
-                    .requestMatchers("/auth/**").permitAll()
-                    .requestMatchers("/swagger-ui.html/**", "/swagger-ui/**", "/api-docs/**", "/v3/api-docs/**").permitAll()
-                    .requestMatchers("/api/swagger-ui.html/**", "/api/swagger-ui/**", "/api/api-docs/**", "/api/v3/api-docs/**").permitAll()
-                    .requestMatchers("/actuator/**").permitAll()
-                    .requestMatchers("/notifications/**").permitAll()
+                    .requestMatchers(*PublicEndpoints.PATTERNS.toTypedArray()).permitAll()
                     .anyRequest().authenticated()
             }
             .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter::class.java)

backend/feature/authorization/src/main/kotlin/band/effective/office/backend/feature/authorization/security/JwtAuthenticationFilter.kt

@@ -1,6 +1,7 @@
 package band.effective.office.backend.feature.authorization.security
 
 import band.effective.office.backend.core.data.ErrorDto
+import band.effective.office.backend.feature.authorization.config.PublicEndpoints
 import band.effective.office.backend.feature.authorization.exception.AuthorizationException
 import band.effective.office.backend.feature.authorization.exception.AuthorizationErrorCodes
 import band.effective.office.backend.feature.authorization.service.AuthorizationService
@@ -29,17 +30,13 @@ class JwtAuthenticationFilter(
     private val logger = LoggerFactory.getLogger(this::class.java)
 
     /**
-     * Checks if the request is for Swagger UI or API docs.
-     *
-     * @param requestURI The request URI to check
-     * @return True if the request is for Swagger UI or API docs, false otherwise
+     * Determines whether the filter should not be applied to this request.
+     * This method is called by the OncePerRequestFilter before doFilterInternal.
+     * 
+     * @param request The HTTP request
+     * @return True if the filter should not be applied, false otherwise
      */
-    private fun isSwaggerUIRequest(requestURI: String): Boolean { // TODO fix this hacky code
-        return requestURI.contains("/swagger-ui") ||
-               requestURI.contains("/api-docs") ||
-               requestURI.contains("/v3/api-docs") ||
-                requestURI.contains("/notifications")
-    }
+    override fun shouldNotFilter(request: HttpServletRequest): Boolean = PublicEndpoints.matches(request.requestURI)
 
     /**
      * Filters incoming requests and attempts to authenticate them.
@@ -53,13 +50,6 @@ class JwtAuthenticationFilter(
         response: HttpServletResponse,
         filterChain: FilterChain
     ) {
-        // Check if the request is for Swagger UI or API docs
-        val requestURI = request.requestURI
-        if (isSwaggerUIRequest(requestURI)) {
-            logger.debug("Skipping authorization for Swagger UI request: {}", requestURI)
-            filterChain.doFilter(request, response)
-            return
-        }
 
         try {
             // Attempt to authorize the request

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

@@ -90,11 +90,7 @@ class GoogleCalendarProvider(
             calendar.events().delete(defaultCalendar, eventId).execute()
         } catch (e: GoogleJsonResponseException) {
             logger.error("Failed to delete event: {}", e.details)
-            if (e.statusCode != 404 && e.statusCode != 410) {
-                throw e
-            }
-            // If the event doesn't exist (404) or has been deleted (410), ignore the exception
-            logger.warn("Event with ID {} not found or already deleted", eventId)
+            throw e
         }
     }
 
@@ -243,10 +239,11 @@ class GoogleCalendarProvider(
     }
 
     private fun convertToGoogleEvent(booking: Booking, workspaceCalendarId: String? = null): Event {
+        val ownerEmail = booking.owner?.email ?: defaultCalendar
         val event = Event()
             .setSummary("Meet${booking.owner?.let { " ${it.firstName} ${it.lastName}" }.orEmpty()}")
             .setDescription(
-                "${booking.owner?.email} - почта организатора"
+                "$ownerEmail - почта организатора"
             )
             .setStart(createEventDateTime(booking.beginBooking.toEpochMilli()))
             .setEnd(createEventDateTime(booking.endBooking.toEpochMilli()))
@@ -262,7 +259,7 @@ class GoogleCalendarProvider(
         }.toMutableList()
 
         // Add the owner as the organizer
-        booking.owner?.email?.let { event.organizer = Event.Organizer().setEmail(it) }
+        event.organizer = Event.Organizer().setEmail(ownerEmail)
 
         // Add workspace as an attendee if workspaceCalendarId is provided
         workspaceCalendarId?.let {
@@ -343,6 +340,11 @@ class GoogleCalendarProvider(
             matchResult?.groupValues?.get(1)
         }
 
+        // Determine if the booking is editable based on the organizer
+        // If the organizer is the defaultCalendar, then the booking is editable
+        // Otherwise, it's not editable (created from Google Calendar)
+        val isEditable = organizer == defaultCalendar
+
         return Booking(
             id = event.id,
             owner = owner,
@@ -351,7 +353,8 @@ class GoogleCalendarProvider(
             beginBooking = Instant.ofEpochMilli(event.start.dateTime.value),
             endBooking = Instant.ofEpochMilli(event.end.dateTime.value),
             recurrence = RecurrenceRuleConverter.fromGoogleRecurrenceRule(event.recurrence),
-            recurringBookingId = recurringBookingIdStr
+            recurringBookingId = recurringBookingIdStr,
+            isEditable = isEditable
         )
     }
 

backend/feature/booking/core/src/main/kotlin/band/effective/office/backend/feature/booking/core/domain/model/Booking.kt

@@ -23,5 +23,6 @@ data class Booking(
     val beginBooking: Instant,
     val endBooking: Instant,
     val recurrence: RecurrenceModel? = null,
-    val recurringBookingId: String? = null // ID of the recurring booking this booking belongs to
+    val recurringBookingId: String? = null, // ID of the recurring booking this booking belongs to
+    val isEditable: Boolean = true, // Flag indicating if booking can be edited/deleted from tablet client
 )

backend/feature/booking/core/src/main/kotlin/band/effective/office/backend/feature/booking/core/dto/BookingDto.kt

@@ -41,7 +41,10 @@ data class BookingDto(
     val recurrence: RecurrenceDto? = null,
 
     @Schema(description = "ID of the recurring booking this booking belongs to")
-    val recurringBookingId: String? = null
+    val recurringBookingId: String? = null,
+
+    @Schema(description = "Flag indicating if booking can be edited/deleted from tablet client", example = "true")
+    val isEditable: Boolean = true
 ) {
     companion object {
         /**
@@ -56,7 +59,8 @@ data class BookingDto(
                 beginBooking = booking.beginBooking.toEpochMilli(),
                 endBooking = booking.endBooking.toEpochMilli(),
                 recurrence = booking.recurrence?.let { RecurrenceDto.fromDomain(it) },
-                recurringBookingId = booking.recurringBookingId
+                recurringBookingId = booking.recurringBookingId,
+                isEditable = booking.isEditable
             )
         }
     }