Merge branch 'developer'

Author: MarleneMoraes

README.md

@@ -0,0 +1,109 @@
+# Lounge Occupancy Analyzer (Análise de Capacidade das Salas de Espera)
+Aplicação que analisa a capacidade das salas de espera de passageiros no aeroporto.
+
+## Visão de Negócio
+Este sistema foi desenvolvido como uma solução estratégica para o redimensionamento de salas de espera de aeroportos. O objetivo central é garantir que a infraestrutura possua a quantidade exata de assentos necessária para o conforto de todos os passageiros, evitando transtornos operacionais relatados pelo cliente.
+
+Para compreender a lotação máxima em horários de pico, o sistema utiliza uma análise dinâmica de eventos. Isso permite identificar o momento de maior fluxo simultâneo, auxiliando gestores em decisões assertivas de investimento e otimização de espaço com base nos resultados gerados.
+
+## Explicação Técnica
+API desenvolvida para o desafio técnico da Atech, focada em calcular a ocupação máxima simultânea de salas de espera de aeroportos utilizando o algoritmo **Sweep Line**.
+
+### Tecnologias Utilizadas
+- Java 25
+- Spring Boot 4.0.2
+- Dependências: SpringWeb (REST API), Validation, Swagger API
+- Project Loom (Virtual Threads)
+- *GitHub Actions configurado para compilação e execução de testes automatizados.*
+
+### Arquitetura
+
+A solução baseia-se na técnica de **Sweep Line (Linha de Varredura)**, que é ideal para problemas de sobreposição de intervalos.
+
+#### Lógica de Negócio (N, E, S)
+
+**O problema técnico:** 
+> "Dado um número `N` de passageiros `(1 <= N <= 100)` que passaram pela sala de espera, uma lista `E` com os números do momento de entrada de cada passageiro e uma lista `S` com os números do momento de saída de cada passageiro [...]".
+
+A solução respeitou os padrões do enunciado em toda a aplicação, sendo assim:
+
+- **N**: Número de passageiros (limitado entre 1 e 100 conforme o enunciado).
+- **E**: Lista de horários de entrada (mapeados em uma escala simplificada de 1 a 1000).
+- **S**: Lista de horários de saída (mapeados em uma escala simplificada de 1 a 1000).
+
+#### Tratamento de Eventos Simultâneos
+
+> "[...] você deve calcular qual foi o número máximo de passageiros simultâneos naquela sala de espera durante todo o período. Considere que se um passageiro entra no mesmo momento que outro sai, então naquele instante só é contabilizada uma pessoa para a lotação da sala."
+
+A solução implementada possui tratamento de eventos que ocorrem no mesmo instante: no modelo de domínio `Event.java`, está configurada o critério de desempate para que a saída seja processada antes da entrada, o que garante que a contagem da ocupação não retorne valores irreais.
+
+*OBS: Está definido nas constantes `ENTRY` (Entrada) e `EXIT` (Saída) para facilitar a leitura do código.*
+
+### Instruções de Setup
+
+#### Pré-requisitos
+
+* JDK 25.
+* Maven 3.9+.
+
+#### Passo a Passo
+
+1. Clone o repositório:
+```bash
+git clone https://github.com/MarleneMoraes/lounge-occupancy-analyzer.git
+```
+
+2. Execute a aplicação:
+```bash
+# Se tiver Maven global:
+mvn spring-boot:run
+
+# Ou use o Wrapper incluso no projeto:
+./mvnw spring-boot:run
+```
+
+#### Como Utilizar
+
+A API disponibiliza um endpoint principal para o cálculo da ocupação.
+
+- **Endpoint POST**: `/api/v1/occupancy/calculate`
+
+##### **Teste via Terminal (CURL)**
+
+Você pode testar o cenário padrão do desafio com o seguinte comando:
+
+- Exemplo 1:
+```bash
+curl -X POST http://localhost:8080/api/v1/occupancy/calculate \
+-H "Content-Type: application/json" \
+-d '{
+  "N": 3,
+  "E": [1, 5, 7],
+  "S": [9, 13, 12]
+}'
+
+```
+**Resposta esperada**: `{"maxOccupancy": 3}`
+
+- Exemplo 2:
+```bash
+curl -X POST http://localhost:8080/api/v1/occupancy/calculate \
+-H "Content-Type: application/json" \
+-d '{
+  "N": 4,
+  "E": [1, 4, 8, 10],
+  "S": [3, 8, 10, 17]
+}'
+
+```
+**Resposta esperada**: `{"maxOccupancy": 1}`
+ 
+##### **Interface Visual (Swagger)**
+
+Para uma experiência interativa, acesse a interface do Swagger após iniciar a aplicação: `http://localhost:8080/swagger-ui/index.html`
+
+Na interface, você encontrará a documentação completa dos esquemas de entrada e poderá realizar testes manuais preenchendo os campos de `N`, `E` e `S`.
+
+### Testes Automatizados
+
+A suíte de testes unitários cobre cenários padrão, casos de borda e validações de erro. Execute no terminal: `mvn test`.

pom.xml

@@ -6,7 +6,7 @@
 		<groupId>org.springframework.boot</groupId>
 		<artifactId>spring-boot-starter-parent</artifactId>
 		<version>4.0.2</version>
-		<relativePath/> <!-- lookup parent from repository -->
+		<relativePath/>
 	</parent>
 	<groupId>com.atech</groupId>
 	<artifactId>lounge-occupancy-analyzer</artifactId>
@@ -18,7 +18,11 @@
 		<license/>
 	</licenses>
 	<developers>
-		<developer/>
+		<developer>
+			<id>MarleneMoraes</id>
+	        <name>Marlene Moraes</name>
+	        <email>marlenevmoraes@outlook.com</email>
+		</developer>
 	</developers>
 	<scm>
 		<connection/>
@@ -49,6 +53,11 @@
 			<artifactId>spring-boot-starter-webmvc-test</artifactId>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+			<groupId>org.springdoc</groupId>
+			<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
+			<version>2.8.1</version>
+		</dependency>
 	</dependencies>
 
 	<build>

src/main/java/com/atech/loungeoccupancyanalyzer/application/dto/OccupancyRequest.java

@@ -0,0 +1,23 @@
+package com.atech.loungeoccupancyanalyzer.application.dto;
+
+import java.util.List;
+
+import jakarta.validation.constraints.Max;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+public record OccupancyRequest(
+		@NotNull(message = "N is required") 
+		@Min(value = 1, message = "N must be at least 1") 
+		@Max(value = 100, message = "N cannot exceed 100") 
+		int N,
+
+		@NotNull(message = "List E is required") 
+		@Size(min = 1, max = 100, message = "E list size must match N") 
+		List<Integer> E,
+
+		@NotNull(message = "List S is required") 
+		@Size(min = 1, max = 100, message = "S list size must match N") 
+		List<Integer> S) {
+}

src/main/java/com/atech/loungeoccupancyanalyzer/domain/model/Event.java

@@ -0,0 +1,21 @@
+package com.atech.loungeoccupancyanalyzer.domain.model;
+
+/**
+ * Represents a point in time where a passenger enters or exits the lounge.
+ * ENTRY (+1) maps to List E, while EXIT (-1) maps to List S from the
+ * requirements.
+ */
+
+public record Event(int time, int type) implements Comparable<Event> {
+	public static final int ENTRY = 1;
+    public static final int EXIT = -1;
+    
+	@Override
+	public int compareTo(Event other) {
+		if (this.time != other.time) {
+            return Integer.compare(this.time, other.time);
+        }
+		
+		return Integer.compare(this.type, other.type);
+	}
+}

src/main/java/com/atech/loungeoccupancyanalyzer/domain/service/OccupancyCalculator.java

@@ -0,0 +1,34 @@
+package com.atech.loungeoccupancyanalyzer.domain.service;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import com.atech.loungeoccupancyanalyzer.domain.model.Event;
+
+public class OccupancyCalculator {
+	public int calculateMax(int N, List<Integer> E, List<Integer> S) {
+        if (N == 0 || E.isEmpty()) {
+            return 0;
+        } 
+
+        List<Event> events = new ArrayList<>();
+
+        for (int i = 0; i < N; i++) {
+            events.add(new Event(E.get(i), Event.ENTRY));
+            events.add(new Event(S.get(i), Event.EXIT));
+        }
+
+        Collections.sort(events);
+
+        int currentOccupancy = 0;
+        int maxOccupancy = 0;
+
+        for (Event event : events) {
+            currentOccupancy += event.type();
+            maxOccupancy = Math.max(maxOccupancy, currentOccupancy);
+        }
+
+        return maxOccupancy;
+    }
+}

src/main/java/com/atech/loungeoccupancyanalyzer/infrastructure/controller/OccupancyController.java

@@ -0,0 +1,41 @@
+package com.atech.loungeoccupancyanalyzer.infrastructure.controller;
+
+import java.util.Map;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.atech.loungeoccupancyanalyzer.LoungeOccupancyAnalyzerApplication;
+import com.atech.loungeoccupancyanalyzer.application.dto.OccupancyRequest;
+import com.atech.loungeoccupancyanalyzer.domain.service.OccupancyCalculator;
+
+import jakarta.validation.Valid;
+
+@RestController
+@RequestMapping("/api/v1/occupancy")
+public class OccupancyController {
+
+    private final LoungeOccupancyAnalyzerApplication loungeOccupancyAnalyzerApplication;
+	
+	private final OccupancyCalculator calculator = new OccupancyCalculator();
+
+    OccupancyController(LoungeOccupancyAnalyzerApplication loungeOccupancyAnalyzerApplication) {
+        this.loungeOccupancyAnalyzerApplication = loungeOccupancyAnalyzerApplication;
+    }
+	
+	@PostMapping("/calculate")
+	public ResponseEntity<?> calculate(@Valid @RequestBody OccupancyRequest request) {
+		 if (request.E().size() != request.N() || request.S().size() != request.N()) {
+            return ResponseEntity.badRequest()
+                .body(Map.of("error", "The size of lists E and S must be equal to N"));
+        }
+		 
+		int maxOccupancy = calculator.calculateMax(request.N(), request.E(), request.S());
+		
+		return ResponseEntity.ok(Map.of("maxOccupancy", maxOccupancy));
+	}
+
+}

src/main/resources/application.yaml

@@ -1,3 +1,12 @@
 spring:
   application:
-    name: Lounge Occupancy Analyzer
+    name: lounge-occupancy-analyzer
+  threads:
+    virtual:
+      enabled: true
+  web:
+    error:
+      include-message: always
+
+server:
+  port: 8080

src/test/java/com/atech/loungeoccupancyanalyzer/LoungeOccupancyAnalyzerApplicationTests.java

@@ -0,0 +1,74 @@
+package com.atech.loungeoccupancyanalyzer.domain.service;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.List;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class OccupancyCalculatorTest {
+	private final OccupancyCalculator calculator = new OccupancyCalculator();
+
+	private void assertOccupancy(int expected, int N, List<Integer> E, List<Integer> S, String message) {
+		assertEquals(expected, calculator.calculateMax(N, E, S), message);
+	}
+	
+	@Test
+	@DisplayName("Standard Example - Max occupancy is 3")
+	void maxOccupancyIsThree() {
+		assertOccupancy(
+				3, 
+				3, 
+				List.of(1,5,7),
+				List.of(9,13,12),
+				"The  maximun occupancy should be 3");
+	}
+	
+	@Test
+	@DisplayName("Standard Example - Max occupancy is 1")
+	void maxOccupancyIsOne() {
+		assertOccupancy(
+				1, 
+				4, 
+				List.of(1,4,8,10),
+				List.of(3,8,10,17),
+				"The  maximun occupancy should be 1");
+	}
+
+	@Test
+	@DisplayName("Case Empty Lists")
+	void returnZeroWhenListsAreEmpty() {
+		assertOccupancy(
+				0, 
+				0, 
+				List.of(),
+				List.of(),
+				"The  maximun occupancy should be 0 for empty lists");
+	}
+
+	@Test
+	@DisplayName("Case: Simultaneous Entry and Exit")
+	void handleSameEntryAndExitTime() {
+		assertOccupancy(
+	            0, 
+	            1, 
+	            List.of(1), 
+	            List.of(1), 
+	            "Should count 1 occupant even if entry and exit happen at the same time"
+	        );
+	}
+
+	@Test
+	@DisplayName("Case: Exception on Size Mismatch")
+	void throwExceptionWhenSizesMismatch() {
+		int n = 3;
+        List<Integer> e = List.of(1, 2);
+        List<Integer> s = List.of(5, 6, 7);
+
+        assertThrows(IndexOutOfBoundsException.class, () -> {
+            calculator.calculateMax(n, e, s);
+        }, "Should throw IndexOutOfBoundsException when list size does not match N");
+	}
+}