From 4a864cec0a6f3b6320846a9a26c39e1e01cf788c Mon Sep 17 00:00:00 2001 From: Hyojin Ahn Date: Thu, 6 Nov 2025 09:12:03 -0500 Subject: [PATCH] https://github.com/kamilmazurek/layered-architecture-template?utm_source=chatgpt.com --- .classpath | 63 ++ .factorypath | 92 +++ .gitignore | 10 + .mvn/wrapper/maven-wrapper.properties | 19 + .project | 28 + .settings/org.eclipse.core.resources.prefs | 6 + .settings/org.eclipse.jdt.apt.core.prefs | 4 + .settings/org.eclipse.jdt.core.prefs | 10 + .settings/org.eclipse.m2e.core.prefs | 4 + .../org.springframework.ide.eclipse.prefs | 2 + README.md | 576 ++++++++++++++++++ disclaimer.txt | 11 + dockerfile | 5 + mvnw | 259 ++++++++ mvnw.cmd | 149 +++++ pom.xml | 176 ++++++ ...-architecture-template-concept-diagram.png | Bin 0 -> 119590 bytes readme-images/sample-allure-report.png | Bin 0 -> 66755 bytes readme-images/sample-swagger-view.png | Bin 0 -> 29558 bytes src/main/java/template/Application.java | 17 + .../java/template/api/ItemsController.java | 63 ++ .../java/template/config/TemplateConfig.java | 15 + .../exception/ItemIdAlreadySetException.java | 13 + .../java/template/repository/ItemEntity.java | 24 + .../template/repository/ItemsRepository.java | 13 + src/main/java/template/service/Item.java | 18 + .../java/template/service/ItemsService.java | 76 +++ src/main/resources/api.yaml | 109 ++++ src/main/resources/application-dev.yaml | 4 + src/main/resources/application.yaml | 15 + src/main/resources/data-dev.sql | 4 + .../template/AbstractIntegrationTest.java | 21 + .../template/ApplicationIntegrationTest.java | 11 + .../api/ItemsControllerIntegrationTest.java | 163 +++++ .../template/api/ItemsControllerTest.java | 198 ++++++ .../misc/ActuatorIntegrationTest.java | 29 + .../template/misc/OpenApiIntegrationTest.java | 20 + .../template/misc/SwaggerIntegrationTest.java | 18 + .../template/service/ItemsServiceTest.java | 169 +++++ src/test/java/template/util/TestItems.java | 35 ++ src/test/resources/allure.properties | 1 + src/test/resources/application.yaml | 18 + src/test/resources/data-test.sql | 4 + 43 files changed, 2472 insertions(+) create mode 100644 .classpath create mode 100644 .factorypath create mode 100644 .gitignore create mode 100644 .mvn/wrapper/maven-wrapper.properties create mode 100644 .project create mode 100644 .settings/org.eclipse.core.resources.prefs create mode 100644 .settings/org.eclipse.jdt.apt.core.prefs create mode 100644 .settings/org.eclipse.jdt.core.prefs create mode 100644 .settings/org.eclipse.m2e.core.prefs create mode 100644 .settings/org.springframework.ide.eclipse.prefs create mode 100644 README.md create mode 100644 disclaimer.txt create mode 100644 dockerfile create mode 100644 mvnw create mode 100644 mvnw.cmd create mode 100644 pom.xml create mode 100644 readme-images/layered-architecture-template-concept-diagram.png create mode 100644 readme-images/sample-allure-report.png create mode 100644 readme-images/sample-swagger-view.png create mode 100644 src/main/java/template/Application.java create mode 100644 src/main/java/template/api/ItemsController.java create mode 100644 src/main/java/template/config/TemplateConfig.java create mode 100644 src/main/java/template/exception/ItemIdAlreadySetException.java create mode 100644 src/main/java/template/repository/ItemEntity.java create mode 100644 src/main/java/template/repository/ItemsRepository.java create mode 100644 src/main/java/template/service/Item.java create mode 100644 src/main/java/template/service/ItemsService.java create mode 100644 src/main/resources/api.yaml create mode 100644 src/main/resources/application-dev.yaml create mode 100644 src/main/resources/application.yaml create mode 100644 src/main/resources/data-dev.sql create mode 100644 src/test/java/template/AbstractIntegrationTest.java create mode 100644 src/test/java/template/ApplicationIntegrationTest.java create mode 100644 src/test/java/template/api/ItemsControllerIntegrationTest.java create mode 100644 src/test/java/template/api/ItemsControllerTest.java create mode 100644 src/test/java/template/misc/ActuatorIntegrationTest.java create mode 100644 src/test/java/template/misc/OpenApiIntegrationTest.java create mode 100644 src/test/java/template/misc/SwaggerIntegrationTest.java create mode 100644 src/test/java/template/service/ItemsServiceTest.java create mode 100644 src/test/java/template/util/TestItems.java create mode 100644 src/test/resources/allure.properties create mode 100644 src/test/resources/application.yaml create mode 100644 src/test/resources/data-test.sql diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..2a0f845 --- /dev/null +++ b/.classpath @@ -0,0 +1,63 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.factorypath b/.factorypath new file mode 100644 index 0000000..7ad548f --- /dev/null +++ b/.factorypath @@ -0,0 +1,92 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0d6f257 --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +.idea +*.iws +*.iml +*.ipr +target/ +!**/src/main/**/target/ +!**/src/test/**/target/ +!.mvn/wrapper/maven-wrapper.jar +/.allure +/allure-results diff --git a/.mvn/wrapper/maven-wrapper.properties b/.mvn/wrapper/maven-wrapper.properties new file mode 100644 index 0000000..d58dfb7 --- /dev/null +++ b/.mvn/wrapper/maven-wrapper.properties @@ -0,0 +1,19 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +wrapperVersion=3.3.2 +distributionType=only-script +distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.9/apache-maven-3.9.9-bin.zip diff --git a/.project b/.project new file mode 100644 index 0000000..9e77140 --- /dev/null +++ b/.project @@ -0,0 +1,28 @@ + + + integration-service + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + org.springframework.ide.eclipse.boot.validation.springbootbuilder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.m2e.core.maven2Nature + + diff --git a/.settings/org.eclipse.core.resources.prefs b/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..29abf99 --- /dev/null +++ b/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,6 @@ +eclipse.preferences.version=1 +encoding//src/main/java=UTF-8 +encoding//src/main/resources=UTF-8 +encoding//src/test/java=UTF-8 +encoding//src/test/resources=UTF-8 +encoding/=UTF-8 diff --git a/.settings/org.eclipse.jdt.apt.core.prefs b/.settings/org.eclipse.jdt.apt.core.prefs new file mode 100644 index 0000000..dfa4f3a --- /dev/null +++ b/.settings/org.eclipse.jdt.apt.core.prefs @@ -0,0 +1,4 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.apt.aptEnabled=true +org.eclipse.jdt.apt.genSrcDir=target/generated-sources/annotations +org.eclipse.jdt.apt.genTestSrcDir=target/generated-test-sources/test-annotations diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..943cc39 --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,10 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.methodParameters=generate +org.eclipse.jdt.core.compiler.codegen.targetPlatform=21 +org.eclipse.jdt.core.compiler.compliance=21 +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore +org.eclipse.jdt.core.compiler.processAnnotations=enabled +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=21 diff --git a/.settings/org.eclipse.m2e.core.prefs b/.settings/org.eclipse.m2e.core.prefs new file mode 100644 index 0000000..f897a7f --- /dev/null +++ b/.settings/org.eclipse.m2e.core.prefs @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 diff --git a/.settings/org.springframework.ide.eclipse.prefs b/.settings/org.springframework.ide.eclipse.prefs new file mode 100644 index 0000000..a12794d --- /dev/null +++ b/.settings/org.springframework.ide.eclipse.prefs @@ -0,0 +1,2 @@ +boot.validation.initialized=true +eclipse.preferences.version=1 diff --git a/README.md b/README.md new file mode 100644 index 0000000..fcba677 --- /dev/null +++ b/README.md @@ -0,0 +1,576 @@ +> This documentation is also available in an enhanced form at +> [Layered Architecture Template](https://kamilmazurek.pl/layered-architecture-template) page. + +# Layered Architecture Template + +This repository contains a Spring Boot microservice template that follows a modern REST-based Layered Architecture approach. Designed with simplicity and clarity in mind, it provides a solid foundation for building Java applications that are easy to understand, extend, and maintain. The template separates concerns across common layers such as controllers, services, and repositories, and delivers a cleanly structured REST API ready for real-world use. +Core benefits: +* **Simplicity and Familiarity**: Widely adopted, this pattern is easy to understand and implement, especially for traditional enterprise teams. +* **Separation of Responsibilities**: The architecture organizes code into layers like controller, service, and repository, each handling its role clearly. +* **Maintainability**: Encapsulation of responsibilities within layers makes the application easier to debug, extend, and refactor over time. +* **Testability**: With clearly defined boundaries between layers, unit and integration testing become more straightforward and effective. +* **Scalability for Simple Use Cases**: Good fit for CRUD or moderate business logic apps, as layers support growth without much complexity. + +It was designed to be minimalistic, organized, and flexible to change. + +## Quickstart + +You can quickly get started with the Layered Architecture Template by following these steps: +1. Confirm that a JDK is installed to build and run the app. Temurin, based on OpenJDK, is available at [adoptium.net](https://adoptium.net/). +2. Obtain the source code by cloning the repository using Git, or downloading it as a ZIP archive. + If you downloaded the ZIP file, extract it and navigate to the `layered-architecture-template` directory. +3. Launch the application with the development profile to preload sample data: + ```shell + mvnw spring-boot:run -Pdev + ``` +4. Check if the app is running by sending a GET request to the following URL. You can also paste it directly into your browser: + ```console + http://localhost:8080/items/1 + ``` + You should see a response containing the following item: + ```json + [ + { + "id": 1, + "name":"Item A" + } + ] + ``` +5. Customize the code as needed, then rebuild and relaunch the project to see your changes in action 🚀. + +## Table of contents +* [Motivation](#motivation) +* [Architecture Overview](#architecture-overview) +* [When to Use Layered Architecture](#when-to-use-layered-architecture) +* [Technology Stack](#technology-stack) +* [How It Works](#how-it-works) +* [Build and Deployment](#build-and-deployment) +* [REST API Overview](#rest-api-overview) +* [Swagger and OpenAPI Endpoints](#swagger-and-openapi-endpoints) +* [Production-ready Features](#production-ready-features) +* [Testing Strategy](#testing-strategy) +* [Additional Resources](#additional-resources) +* [Author](#author) +* [Disclaimer](#disclaimer) + +## Motivation + +Starting new projects often involves repetitive setup work to establish a solid codebase. +This template aims to streamline that process by providing a clear, Layered Architecture based microservice example that can be reused and adapted quickly. +While Maven Archetypes offer automation, the effort required to maintain a flexible archetype felt too demanding. +Instead, this template balances simplicity and practicality to help developers get started faster. + +## Architecture Overview + +Layered Architecture is a classic software design pattern that organizes code into distinct layers, each with a specific responsibility. +This separation helps manage complexity, improve maintainability, and promote clear boundaries between different parts of an application. + +The classic layers are: +* **Presentation Layer**: Responsible for handling user interactions and input/output operations. +* **Business Layer**: Contains the core application logic and rules. +* **Persistence Layer**: Manages data storage and retrieval from databases. +* **Database**: The actual data storage infrastructure where data physically resides. + +In modern REST-based applications built with Spring Boot, these map naturally to: +* **API Layer**: Exposes REST endpoints and handles HTTP requests/responses (equivalent to Presentation). +* **Service Layer**: Implements business logic and orchestrates operations (equivalent to Business Logic). +* **Repository Layer**: Interfaces with the database, handling CRUD operations (equivalent to Persistence). +* **Database Layer**: Stores the application data. + +Each layer communicates only with the one directly below it, ensuring clear boundaries and straightforward data flow. +This diagram illustrates the REST-based layer concept implemented in this project, while also showing the classic counterparts: + +![Concept diagram](readme-images/layered-architecture-template-concept-diagram.png) +

+Layered Architecture Template concept diagram +

+ +Layered Architecture remains a popular pattern for enterprise applications thanks to its clear separation of concerns and ease of understanding. +Spring Boot's convention-over-configuration approach and built-in support for RESTful services, data access, and testing tools make it particularly well-suited for implementing this pattern. +Together, they provide a solid foundation that helps teams quickly build and maintain scalable applications without unnecessary complexity. + +Consequently, this repository provides a template implementation of a microservice following the Layered Architecture pattern, developed in Java with Spring Boot. It consists of: +* **API Layer** + * REST controllers handling HTTP requests +* **Service Layer** + * Business logic and service operations +* **Repository Layer** + * Data access and persistence interface +* **Supporting Components** + * Swagger for API documentation + * OpenAPI specifications + * Spring Boot Actuator for monitoring and management +* **Database Layer** + * In-memory H2 database for development and testing + +Please keep in mind this project serves as a basic template, providing core support for HTTP request handling and database interactions. +It's flexible by design, allowing you to add features or integrations as your requirements evolve. + +## When to Use Layered Architecture + +Layered Architecture organizes your application into distinct layers, each with a specific responsibility such as presentation, business logic, and data access. +This clear separation simplifies development, improves maintainability, and helps enforce separation of concerns across your codebase. + +This approach is particularly effective for projects with well-defined and stable requirements, where a straightforward division between layers can improve team collaboration and speed up delivery. +It works well for applications that primarily follow a request-response model, such as typical REST APIs, and where concerns like UI, service logic, and database access can be cleanly separated. +For smaller or less complex projects, Layered Architecture offers a familiar and easy-to-understand structure that helps avoid unnecessary complexity. +It also suits teams that prefer conventional architectural patterns or need quick onboarding of new developers. + +However, for systems requiring high flexibility or integration with multiple external interfaces, more decoupled architectures like Hexagonal or Event-Driven might provide better adaptability. +In such cases, you might be interested in the [Hexagonal Architecture Template](https://kamilmazurek.pl/hexagonal-architecture-template). + +Layered Architecture remains a solid choice when the focus is on clear organization, testability, and incremental development. +Ultimately, use Layered Architecture when your project benefits from a clear hierarchical structure that promotes simplicity, maintainability, and team alignment, especially when the application is expected to evolve steadily within a defined scope. + +## Technology Stack + +Layered Architecture Template is built using Java and Spring Boot, which naturally support modular design and clear separation between layers. +It uses the in-memory H2 database for quick prototyping and testing, but thanks to Spring Data, switching to another database later is simple and straightforward. + +OpenAPI is used to clearly define the RESTful APIs exposed by the API layer, helping maintain a clean separation between layers and simplifying client generation. +This aligns well with the layered architecture's goal of separating presentation from business logic. + +Testing is an integral part of the stack, with unit tests focusing on individual service and repository layers, and integration tests verifying end-to-end flow across layers. +Maven Surefire and Failsafe plugins ensure smooth test execution during builds. + +Here’s an overview of the technology stack: +- **Language & Framework** + - **Java 21**: Modern Java version powering the core application logic. + - **Spring Boot**: Simplifies building modular, RESTful Java applications. +- **API & Data** + - **OpenAPI**: Defines clear REST API specs and supports client generation. + - **ModelMapper**: Helps map data between layers smoothly. + - **H2 database**: Lightweight in-memory database for development and testing. +- **Testing** + - **JUnit**: Core framework for unit testing Java code. + - **REST Assured**: Integration testing for REST APIs. + - **Mockito**: Mocks dependencies to isolate components during tests. + - **Allure Report**: Generates detailed and user-friendly test reports. +- **Build & Deployment** + - **Apache Maven**: Manages builds and dependencies efficiently. + - **Docker**: Packages the app into containers for consistent deployment. + +This stack was picked to support the layered design, focusing on clear separation, ease of testing, and flexibility to grow with the application's needs. +It provides a solid foundation for building maintainable, modular, and production-ready microservices. + +## How It Works + +This implementation follows Layered Architecture principles by organizing the application into distinct layers with clear responsibilities. +The key layers here are the presentation layer (controller), service layer (business logic), and data access layer (repository). +To illustrate how these layers interact, let's walk through a typical Read use case, starting with a `GET` request handled by the controller. + +The `ItemsController` serves as the entry point for incoming HTTP requests. It receives the GET request, delegates processing to the service layer, and returns the appropriate HTTP response: + +```java +@RestController +@AllArgsConstructor +public class ItemsController implements ItemsApi { + + private final ItemsService service; + + @Override + public ResponseEntity getItem(Long id) { + return service.getItem(id).map(ResponseEntity::ok).orElse(ResponseEntity.notFound().build()); + } + + (...) + +} +``` + +The `ItemsService` contains the core business logic. It processes requests from the controller, applies any necessary rules or transformations, and interacts with the data access layer to fetch or modify data. +This separation keeps business rules centralized and reusable. It's also the place where more complex domain behavior or custom logic can be introduced as needed. +Since this example only covers a simple read operation, the service currently just retrieves data from the repository, maps between the entity, domain object, and DTO, and returns it to the controller. + +```java +@Service +@AllArgsConstructor +public class ItemsService { + + private final ItemsRepository repository; + + private final ModelMapper mapper; + + (...) + + public Optional getItem(Long id) { + return repository.findById(id).map(this::toDomainObject).map(this::toDTO); + } + + (...) + +} +``` + +Data persistence and retrieval are handled by the `ItemsRepository`, which communicates with the database using Spring Data's `JpaRepository`. +This layer abstracts database operations and keeps the service layer decoupled from storage-specific implementation details. +For development and testing, the application uses an H2 in-memory database, which simplifies setup and allows for fast, isolated tests without the need for a full database installation. + +```java +@Repository +public interface ItemsRepository extends JpaRepository { + + @Query("select max(item.id) from ItemEntity item") + Long findMaxID(); + +} +``` + +Once the data is retrieved, it flows back through the service to the controller, which formats it into an HTTP response sent to the client. +This clear layering helps maintain a strong separation of concerns, making the application easier to develop, test, and maintain. + +By adhering to these layered principles, the application remains organized and scalable, allowing effective work on individual layers without tightly coupling components. +This results in cleaner code and a more maintainable system over time. + +## Build and Deployment + +This template is built with Spring Boot, which works well with the layered approach by clearly separating presentation, service, and data access responsibilities. +The build process is managed using Apache Maven, which handles dependency management, compilation, testing, and packaging. + +To perform a full build, including compiling source code, running unit and integration tests, and installing the jar into your local Maven repo, run: +```shell +mvnw clean install +``` + +To run the application locally during development, you can use the following Maven command, which starts the Spring Boot application without requiring a separate packaging step: +```shell +mvnw spring-boot:run +``` + +Alternatively, you can package the application into an executable jar file and run it directly using the Java command. First, build the package with: +```shell +mvnw clean package +``` +Then, start the application by executing the jar: +```shell +java -jar target/layered-architecture-template-1.0.0-SNAPSHOT.jar +``` + +The project includes a Dockerfile to simplify containerized deployment. To build a Docker image and run the application inside a container, use the following commands: +```shell +mvnw clean package +docker build -t template/layered-architecture-template . +docker run -p 8080:8080 template/layered-architecture-template +``` + +For easier development and testing, the project provides a special profile that preloads sample data. You can launch the application with this profile enabled by running: +```shell +mvnw spring-boot:run -Pdev +``` + +This setup offers a simple and flexible way to build, run, and deploy the application in various environments. Whether you’re working locally, running tests, or preparing for production, these commands cover the essential steps for an efficient development workflow. + + +## REST API Overview + +> **Note:** You can test all the endpoints below using Swagger UI, available at http://localhost:8080/swagger-ui/index.html. + +The API is defined in [api.yaml](src/main/resources/api.yaml) and is intentionally kept simple, as this project is designed to serve as a template. +It supports the standard HTTP methods: `POST`, `GET`, `PUT`, and `DELETE`, providing basic CRUD operations for managing items, including create, read, update (or more precisely, upsert), and delete. +Each request is routed through the application’s layered structure, allowing clear separation between the controller, service, and data access layers. +* `POST /items`: Creates a new item. +* `GET /items`: Retrieves all items. +* `GET /items/{itemId}`: Retrieves a single item by its ID. +* `PUT /items/{itemId}`: Creates or updates an item with the specified ID. +* `DELETE /items/{itemId}`: Deletes an item by its ID. + +By default, the application runs on port `8080`. Once running, items can be retrieved by sending a `GET` request to the following endpoint: +```console +http://localhost:8080/items +``` + +The response will contain all items currently stored in the database. If no items are present, an empty array is returned: +```json +[] +``` + +New items can be added to the database using the `POST` method. For example, the following curl command can be used on Linux to create an item named "Item A": +```console +curl -i -X POST http://localhost:8080/items \ + -H "Content-Type: application/json" \ + -d '{"name":"Item A"}' +``` + +Items can also be added or updated using the `PUT` method. For example, the following curl command adds or updates an item with the ID `1`: +```console +curl -i -X PUT http://localhost:8080/items/1 \ + -H "Content-Type: application/json" \ + -d '{"id":1, "name":"Item A"}' +``` + +After adding the item, you can verify it by retrieving the list of items. A `GET` request to `/items` should now return the newly added entry: +```console +http://localhost:8080/items +``` +```json +[ + { + "id": 1, + "name":"Item A" + } +] +``` + +You can also fetch a specific item by its ID using the `/items/{id}` endpoint. For example, sending `GET /items/1` request: +```console +http://localhost:8080/items/1 +``` +```json +{ + "id": 1, + "name":"Item A" +} +``` + +When the application is started with the `dev` profile enabled, it automatically loads a set of sample data into the database to facilitate easier development and testing. +As a result, sending a `GET` request to the `/items` endpoint will return a predefined list of items like the following: +```console +http://localhost:8080/items +``` +```json +[ + { + "id":1, + "name":"Item A" + }, + { + "id":2, + "name":"Item B" + }, + { + "id":3, + "name":"Item C" + } +] +``` + +Items can be removed from the database using the `DELETE` method. +For instance, to delete the item with ID `1`, you can execute the following curl command on a Linux terminal. +This will send a request to the server to remove the specified item: +```console +curl -i -X DELETE http://localhost:8080/items/1 +``` + +As another option, you can perform all these operations such as GET, POST, PUT and DELETE through the Swagger user interface. +Simply navigate to http://localhost:8080/swagger-ui/index.html to explore and interact with the API endpoints in an easy and interactive way. + +The REST API works well with the layered architecture by offering a clear and consistent way to interact with the application's core functionality. +This setup improves modularity and flexibility, letting each layer evolve independently while keeping communication smooth through well-defined API endpoints. + +## Swagger and OpenAPI Endpoints + +The application includes Swagger UI and an OpenAPI `/api-docs` endpoint that provide interactive API documentation. +These can be accessed locally at the following URLs: +* http://localhost:8080/swagger-ui/index.html +* http://localhost:8080/api-docs + +Swagger UI offers a visual and interactive way to browse the API endpoints exposed by the application’s presentation layer (more precisely, the controller in this template). +It simplifies sending `HTTP` requests such as `GET`, `POST`, `PUT`, and `DELETE`, which correspond to CRUD operations handled through the underlying service and data layers. +This makes Swagger a convenient tool for manual testing, debugging, and exploring how the API interacts with the different layers of the application. +For example, you can easily check what data is returned for a `GET /items` request: + +![Swagger UI](readme-images/sample-swagger-view.png) +

+Sample Swagger UI view. For more details about Swagger, visit +https://swagger.io +

+ +The OpenAPI `/api-docs` endpoint provides a machine-readable JSON specification of the API. This standardized format allows easy integration with various development tools, documentation generators, and client code generators, helping to maintain clear contracts between layers and teams. Sharing this specification fosters better collaboration and ensures that the API remains consistent with the layered architecture principles guiding the project. + +These tools help reinforce the separation of concerns by clearly exposing the API endpoints managed by the presentation layer while hiding the complexities of the underlying service and data layers. +By maintaining this clear contract through Swagger and OpenAPI, you ensure that each layer can evolve independently without breaking the overall system architecture. + + +## Production-ready Features + +The application uses Spring Boot Actuator, a library that adds production-ready features to Spring Boot applications. It provides capabilities like monitoring and health checks, which are enabled through the included configuration. +These features allow you to observe the health and status of the application across its layers, from the presentation layer down to the data layer, helping ensure that each part of the layered architecture is functioning properly. + +Two important actuator endpoints configured in this template are: +* `/actuator` which lists all exposed actuator endpoints: http://localhost:8080/actuator/ +* `/actuator/health` which shows the current health status of the application: http://localhost:8080/actuator/health + +You can find the list of available actuator endpoints by accessing the `/actuator` endpoint in your running application. +This list can be customized by modifying the `management.endpoints.web.exposure.include` property in [application.yaml](src/main/resources/application.yaml). + +For example, to enable the `beans` endpoint, add it to the `management.endpoints.web.exposure.include` list like this: +```yaml +management: + endpoints: + web: + exposure: + include: health, beans +``` + +For more details, visit the Spring Boot Actuator documentation: https://docs.spring.io/spring-boot/reference/actuator/endpoints.html + +You can verify the health status of the application by sending a request to the `/actuator/health` endpoint. +The response will include the current state of the application, such as: +```console +http://localhost:8080/actuator/health +``` +```json +{ + "status": "UP" +} +``` + +By default, the application provides only basic health status information for security reasons. +If more detailed information is needed, such as disk space usage or database connectivity, this can be enabled by updating the [application.yaml](src/main/resources/application.yaml) configuration file as shown below: +```yaml +management: + endpoint: + health: + show-details: "always" +``` + +Applying this change results in more detailed information at the `/actuator/health` endpoint. +It also enables additional endpoints like `/actuator/health/db`, which provide details about the database: +```console +http://localhost:8080/actuator/health/db +``` +```json +{ + "status": "UP", + "details": { + "database": "H2", + "validationQuery": "isValid()" + } +} +``` + +These features help you monitor and maintain the application effectively, providing valuable insights into its health and performance across all layers of the architecture. +Proper use of actuator endpoints can improve reliability and simplify troubleshooting in both development and production environments. + +**Important:** In production environments, actuator endpoints should be secured to prevent unauthorized access. It is recommended to restrict access using authentication and authorization mechanisms. Be cautious when enabling detailed health information or sensitive endpoints. + +## Testing Strategy + +This project includes a structured testing setup that combines unit tests and integration tests, helping ensure both individual components and their interactions behave as expected. +Test execution is handled using Maven’s Surefire and Failsafe plugins, which are configured out of the box. + +Testing is built around well-established tools and libraries: +* JUnit: Used for writing test cases and defining assertions. +* Mockito: Helps simulate dependencies in unit testing. +* REST Assured: Simplifies testing REST endpoints during integration testing. + +This layered approach to testing aligns with the project's architecture and encourages maintainable, focused tests at every level. + +There are two main categories of tests included in this project: +* Unit tests (`*Test.java`), which verify individual classes or methods in isolation. These run using the Maven Surefire Plugin. +* Integration tests (`*IntegrationTest.java`), used to verify how components interact. These tests run with the Maven Failsafe Plugin. + +Here is a simple example of a JUnit unit test, `ItemsControllerTest`, which tests the `ItemsController` behavior. +It uses Mockito to mock the behavior of `ItemsService`, then requests an item using the controller and validates the response: +```java +class ItemsControllerTest { + + @Test + void shouldGetItem() { + //given item + var item = new ItemDTO().id(1L).name("Item A"); + + //and service + var service = mock(ItemsService.class); + when(service.getItem(1L)).thenReturn(Optional.of(item)); + + //and controller + var controller = new ItemsController(service); + + //when item is requested + var response = controller.getItem(1L); + + //then response containing expected item is returned + assertEquals(item, response.getBody()); + + //and OK status is returned + assertEquals(OK, response.getStatusCode()); + + //and service was involved in retrieving the data + verify(service).getItem(1L); + } + + (...) + +} +``` +Following that, here's an example of an integration test, `ItemsControllerIntegrationTest`, which verifies how multiple components work together to handle requests and responses. +This is also a JUnit test, but this one runs with `@SpringBootTest`, so it starts an H2 database and Spring context, including controllers, database connections and more. It uses REST-assured to perform requests and validate responses, testing the actual behavior across multiple layers: +```java +class ItemsControllerIntegrationTest extends AbstractIntegrationTest { + + private final ObjectWriter objectWriter = new ObjectMapper().writer(); + + @Test + void shouldGetItem() throws JsonProcessingException { + when() + .get("/items/1") + .then() + .statusCode(200) + .assertThat() + .body(equalTo(objectWriter.writeValueAsString(new ItemDTO().id(1L).name("Item A")))); + } + + (...) + +} +``` + +Unit tests, which verify individual components in isolation, can be executed using the Maven Surefire Plugin by running the following command: +```console +mvnw clean test +``` + +Integration tests, which validate how multiple components work together within the application, can be run using the Maven Failsafe Plugin: +```console +mvnw clean integration-test +``` +Note that this command also executes unit tests as part of the build lifecycle. + +Both unit and integration tests are executed automatically during the standard Maven build process: +```console +mvnw clean install +``` +This helps ensure that the application behaves correctly across individual components as well as across layers, from the service logic to the data access, before packaging or deployment. + +In addition, the project is configured to work with Allure Report, which provides a visual representation of test execution results. +You can generate and open the report in your browser by running the following commands: +```console +mvnw clean integration-test +mvnw allure:serve +``` +The report provides a clear overview of test results, including which tests passed or failed, how long they took to run, and the overall coverage. +A sample view of the generated report is shown below: + +![Allure Report](readme-images/sample-allure-report.png) +

+Sample Allure Report. For more information, visit +https://allurereport.org/ +

+ +This testing setup supports the layered architecture by ensuring that each level, from isolated service logic to fully integrated REST interactions, is thoroughly verified. +It helps maintain confidence that every layer of the application behaves reliably both on its own and in coordination with others. + +## Additional resources +* [Layered Architecture, Baeldung](https://www.baeldung.com/cs/layered-architecture) +* [Multitier architecture, Wikipedia](https://en.wikipedia.org/wiki/Multitier_architecture) +* [Repository Pattern with Layered Architecture, Medium](https://medium.com/@leadcoder/repository-pattern-with-layered-architecture-35f7b9182ebf) +* [Layered Architecture Template on LibHunt](https://www.libhunt.com/r/layered-architecture-template) + +## Author +This project was created by [Kamil Mazurek](https://kamilmazurek.pl), a Software Engineer based in Warsaw, Poland. +You can also find me on my [LinkedIn profile](https://www.linkedin.com/in/kamil-mazurek). Thanks for visiting 🙂 + +## Disclaimer + +THIS SOFTWARE AND ANY ACCOMPANYING DOCUMENTATION (INCLUDING, BUT NOT LIMITED TO, THE README.MD FILE) ARE PROVIDED +FOR EDUCATIONAL PURPOSES ONLY. + +THE SOFTWARE AND DOCUMENTATION ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE, +THE DOCUMENTATION, OR THE USE OR OTHER DEALINGS IN THE SOFTWARE OR DOCUMENTATION. + +Spring Boot is a trademark of Broadcom Inc. and/or its subsidiaries. +Oracle, Java, MySQL, and NetSuite are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners. \ No newline at end of file diff --git a/disclaimer.txt b/disclaimer.txt new file mode 100644 index 0000000..e368182 --- /dev/null +++ b/disclaimer.txt @@ -0,0 +1,11 @@ +THIS SOFTWARE AND ANY ACCOMPANYING DOCUMENTATION (INCLUDING, BUT NOT LIMITED TO, THE README.MD FILE) ARE PROVIDED +FOR EDUCATIONAL PURPOSES ONLY. + +THE SOFTWARE AND DOCUMENTATION ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE, +THE DOCUMENTATION, OR THE USE OR OTHER DEALINGS IN THE SOFTWARE OR DOCUMENTATION. + +Spring Boot is a trademark of Broadcom Inc. and/or its subsidiaries. +Oracle, Java, MySQL, and NetSuite are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners. \ No newline at end of file diff --git a/dockerfile b/dockerfile new file mode 100644 index 0000000..d649f33 --- /dev/null +++ b/dockerfile @@ -0,0 +1,5 @@ +FROM openjdk:21-jdk-slim +RUN addgroup --system template-group && adduser --system --ingroup template-group template-user +USER template-user:template-group +COPY target/layered-architecture-template*.jar layered-architecture-template.jar +ENTRYPOINT ["java","-jar","/layered-architecture-template.jar"] \ No newline at end of file diff --git a/mvnw b/mvnw new file mode 100644 index 0000000..19529dd --- /dev/null +++ b/mvnw @@ -0,0 +1,259 @@ +#!/bin/sh +# ---------------------------------------------------------------------------- +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# ---------------------------------------------------------------------------- + +# ---------------------------------------------------------------------------- +# Apache Maven Wrapper startup batch script, version 3.3.2 +# +# Optional ENV vars +# ----------------- +# JAVA_HOME - location of a JDK home dir, required when download maven via java source +# MVNW_REPOURL - repo url base for downloading maven distribution +# MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven +# MVNW_VERBOSE - true: enable verbose log; debug: trace the mvnw script; others: silence the output +# ---------------------------------------------------------------------------- + +set -euf +[ "${MVNW_VERBOSE-}" != debug ] || set -x + +# OS specific support. +native_path() { printf %s\\n "$1"; } +case "$(uname)" in +CYGWIN* | MINGW*) + [ -z "${JAVA_HOME-}" ] || JAVA_HOME="$(cygpath --unix "$JAVA_HOME")" + native_path() { cygpath --path --windows "$1"; } + ;; +esac + +# set JAVACMD and JAVACCMD +set_java_home() { + # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched + if [ -n "${JAVA_HOME-}" ]; then + if [ -x "$JAVA_HOME/jre/sh/java" ]; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + JAVACCMD="$JAVA_HOME/jre/sh/javac" + else + JAVACMD="$JAVA_HOME/bin/java" + JAVACCMD="$JAVA_HOME/bin/javac" + + if [ ! -x "$JAVACMD" ] || [ ! -x "$JAVACCMD" ]; then + echo "The JAVA_HOME environment variable is not defined correctly, so mvnw cannot run." >&2 + echo "JAVA_HOME is set to \"$JAVA_HOME\", but \"\$JAVA_HOME/bin/java\" or \"\$JAVA_HOME/bin/javac\" does not exist." >&2 + return 1 + fi + fi + else + JAVACMD="$( + 'set' +e + 'unset' -f command 2>/dev/null + 'command' -v java + )" || : + JAVACCMD="$( + 'set' +e + 'unset' -f command 2>/dev/null + 'command' -v javac + )" || : + + if [ ! -x "${JAVACMD-}" ] || [ ! -x "${JAVACCMD-}" ]; then + echo "The java/javac command does not exist in PATH nor is JAVA_HOME set, so mvnw cannot run." >&2 + return 1 + fi + fi +} + +# hash string like Java String::hashCode +hash_string() { + str="${1:-}" h=0 + while [ -n "$str" ]; do + char="${str%"${str#?}"}" + h=$(((h * 31 + $(LC_CTYPE=C printf %d "'$char")) % 4294967296)) + str="${str#?}" + done + printf %x\\n $h +} + +verbose() { :; } +[ "${MVNW_VERBOSE-}" != true ] || verbose() { printf %s\\n "${1-}"; } + +die() { + printf %s\\n "$1" >&2 + exit 1 +} + +trim() { + # MWRAPPER-139: + # Trims trailing and leading whitespace, carriage returns, tabs, and linefeeds. + # Needed for removing poorly interpreted newline sequences when running in more + # exotic environments such as mingw bash on Windows. + printf "%s" "${1}" | tr -d '[:space:]' +} + +# parse distributionUrl and optional distributionSha256Sum, requires .mvn/wrapper/maven-wrapper.properties +while IFS="=" read -r key value; do + case "${key-}" in + distributionUrl) distributionUrl=$(trim "${value-}") ;; + distributionSha256Sum) distributionSha256Sum=$(trim "${value-}") ;; + esac +done <"${0%/*}/.mvn/wrapper/maven-wrapper.properties" +[ -n "${distributionUrl-}" ] || die "cannot read distributionUrl property in ${0%/*}/.mvn/wrapper/maven-wrapper.properties" + +case "${distributionUrl##*/}" in +maven-mvnd-*bin.*) + MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ + case "${PROCESSOR_ARCHITECTURE-}${PROCESSOR_ARCHITEW6432-}:$(uname -a)" in + *AMD64:CYGWIN* | *AMD64:MINGW*) distributionPlatform=windows-amd64 ;; + :Darwin*x86_64) distributionPlatform=darwin-amd64 ;; + :Darwin*arm64) distributionPlatform=darwin-aarch64 ;; + :Linux*x86_64*) distributionPlatform=linux-amd64 ;; + *) + echo "Cannot detect native platform for mvnd on $(uname)-$(uname -m), use pure java version" >&2 + distributionPlatform=linux-amd64 + ;; + esac + distributionUrl="${distributionUrl%-bin.*}-$distributionPlatform.zip" + ;; +maven-mvnd-*) MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ ;; +*) MVN_CMD="mvn${0##*/mvnw}" _MVNW_REPO_PATTERN=/org/apache/maven/ ;; +esac + +# apply MVNW_REPOURL and calculate MAVEN_HOME +# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-,maven-mvnd--}/ +[ -z "${MVNW_REPOURL-}" ] || distributionUrl="$MVNW_REPOURL$_MVNW_REPO_PATTERN${distributionUrl#*"$_MVNW_REPO_PATTERN"}" +distributionUrlName="${distributionUrl##*/}" +distributionUrlNameMain="${distributionUrlName%.*}" +distributionUrlNameMain="${distributionUrlNameMain%-bin}" +MAVEN_USER_HOME="${MAVEN_USER_HOME:-${HOME}/.m2}" +MAVEN_HOME="${MAVEN_USER_HOME}/wrapper/dists/${distributionUrlNameMain-}/$(hash_string "$distributionUrl")" + +exec_maven() { + unset MVNW_VERBOSE MVNW_USERNAME MVNW_PASSWORD MVNW_REPOURL || : + exec "$MAVEN_HOME/bin/$MVN_CMD" "$@" || die "cannot exec $MAVEN_HOME/bin/$MVN_CMD" +} + +if [ -d "$MAVEN_HOME" ]; then + verbose "found existing MAVEN_HOME at $MAVEN_HOME" + exec_maven "$@" +fi + +case "${distributionUrl-}" in +*?-bin.zip | *?maven-mvnd-?*-?*.zip) ;; +*) die "distributionUrl is not valid, must match *-bin.zip or maven-mvnd-*.zip, but found '${distributionUrl-}'" ;; +esac + +# prepare tmp dir +if TMP_DOWNLOAD_DIR="$(mktemp -d)" && [ -d "$TMP_DOWNLOAD_DIR" ]; then + clean() { rm -rf -- "$TMP_DOWNLOAD_DIR"; } + trap clean HUP INT TERM EXIT +else + die "cannot create temp dir" +fi + +mkdir -p -- "${MAVEN_HOME%/*}" + +# Download and Install Apache Maven +verbose "Couldn't find MAVEN_HOME, downloading and installing it ..." +verbose "Downloading from: $distributionUrl" +verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName" + +# select .zip or .tar.gz +if ! command -v unzip >/dev/null; then + distributionUrl="${distributionUrl%.zip}.tar.gz" + distributionUrlName="${distributionUrl##*/}" +fi + +# verbose opt +__MVNW_QUIET_WGET=--quiet __MVNW_QUIET_CURL=--silent __MVNW_QUIET_UNZIP=-q __MVNW_QUIET_TAR='' +[ "${MVNW_VERBOSE-}" != true ] || __MVNW_QUIET_WGET='' __MVNW_QUIET_CURL='' __MVNW_QUIET_UNZIP='' __MVNW_QUIET_TAR=v + +# normalize http auth +case "${MVNW_PASSWORD:+has-password}" in +'') MVNW_USERNAME='' MVNW_PASSWORD='' ;; +has-password) [ -n "${MVNW_USERNAME-}" ] || MVNW_USERNAME='' MVNW_PASSWORD='' ;; +esac + +if [ -z "${MVNW_USERNAME-}" ] && command -v wget >/dev/null; then + verbose "Found wget ... using wget" + wget ${__MVNW_QUIET_WGET:+"$__MVNW_QUIET_WGET"} "$distributionUrl" -O "$TMP_DOWNLOAD_DIR/$distributionUrlName" || die "wget: Failed to fetch $distributionUrl" +elif [ -z "${MVNW_USERNAME-}" ] && command -v curl >/dev/null; then + verbose "Found curl ... using curl" + curl ${__MVNW_QUIET_CURL:+"$__MVNW_QUIET_CURL"} -f -L -o "$TMP_DOWNLOAD_DIR/$distributionUrlName" "$distributionUrl" || die "curl: Failed to fetch $distributionUrl" +elif set_java_home; then + verbose "Falling back to use Java to download" + javaSource="$TMP_DOWNLOAD_DIR/Downloader.java" + targetZip="$TMP_DOWNLOAD_DIR/$distributionUrlName" + cat >"$javaSource" <<-END + public class Downloader extends java.net.Authenticator + { + protected java.net.PasswordAuthentication getPasswordAuthentication() + { + return new java.net.PasswordAuthentication( System.getenv( "MVNW_USERNAME" ), System.getenv( "MVNW_PASSWORD" ).toCharArray() ); + } + public static void main( String[] args ) throws Exception + { + setDefault( new Downloader() ); + java.nio.file.Files.copy( java.net.URI.create( args[0] ).toURL().openStream(), java.nio.file.Paths.get( args[1] ).toAbsolutePath().normalize() ); + } + } + END + # For Cygwin/MinGW, switch paths to Windows format before running javac and java + verbose " - Compiling Downloader.java ..." + "$(native_path "$JAVACCMD")" "$(native_path "$javaSource")" || die "Failed to compile Downloader.java" + verbose " - Running Downloader.java ..." + "$(native_path "$JAVACMD")" -cp "$(native_path "$TMP_DOWNLOAD_DIR")" Downloader "$distributionUrl" "$(native_path "$targetZip")" +fi + +# If specified, validate the SHA-256 sum of the Maven distribution zip file +if [ -n "${distributionSha256Sum-}" ]; then + distributionSha256Result=false + if [ "$MVN_CMD" = mvnd.sh ]; then + echo "Checksum validation is not supported for maven-mvnd." >&2 + echo "Please disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2 + exit 1 + elif command -v sha256sum >/dev/null; then + if echo "$distributionSha256Sum $TMP_DOWNLOAD_DIR/$distributionUrlName" | sha256sum -c >/dev/null 2>&1; then + distributionSha256Result=true + fi + elif command -v shasum >/dev/null; then + if echo "$distributionSha256Sum $TMP_DOWNLOAD_DIR/$distributionUrlName" | shasum -a 256 -c >/dev/null 2>&1; then + distributionSha256Result=true + fi + else + echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2 + echo "Please install either command, or disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2 + exit 1 + fi + if [ $distributionSha256Result = false ]; then + echo "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised." >&2 + echo "If you updated your Maven version, you need to update the specified distributionSha256Sum property." >&2 + exit 1 + fi +fi + +# unzip and move +if command -v unzip >/dev/null; then + unzip ${__MVNW_QUIET_UNZIP:+"$__MVNW_QUIET_UNZIP"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -d "$TMP_DOWNLOAD_DIR" || die "failed to unzip" +else + tar xzf${__MVNW_QUIET_TAR:+"$__MVNW_QUIET_TAR"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -C "$TMP_DOWNLOAD_DIR" || die "failed to untar" +fi +printf %s\\n "$distributionUrl" >"$TMP_DOWNLOAD_DIR/$distributionUrlNameMain/mvnw.url" +mv -- "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" "$MAVEN_HOME" || [ -d "$MAVEN_HOME" ] || die "fail to move MAVEN_HOME" + +clean || : +exec_maven "$@" diff --git a/mvnw.cmd b/mvnw.cmd new file mode 100644 index 0000000..249bdf3 --- /dev/null +++ b/mvnw.cmd @@ -0,0 +1,149 @@ +<# : batch portion +@REM ---------------------------------------------------------------------------- +@REM Licensed to the Apache Software Foundation (ASF) under one +@REM or more contributor license agreements. See the NOTICE file +@REM distributed with this work for additional information +@REM regarding copyright ownership. The ASF licenses this file +@REM to you under the Apache License, Version 2.0 (the +@REM "License"); you may not use this file except in compliance +@REM with the License. You may obtain a copy of the License at +@REM +@REM http://www.apache.org/licenses/LICENSE-2.0 +@REM +@REM Unless required by applicable law or agreed to in writing, +@REM software distributed under the License is distributed on an +@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +@REM KIND, either express or implied. See the License for the +@REM specific language governing permissions and limitations +@REM under the License. +@REM ---------------------------------------------------------------------------- + +@REM ---------------------------------------------------------------------------- +@REM Apache Maven Wrapper startup batch script, version 3.3.2 +@REM +@REM Optional ENV vars +@REM MVNW_REPOURL - repo url base for downloading maven distribution +@REM MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven +@REM MVNW_VERBOSE - true: enable verbose log; others: silence the output +@REM ---------------------------------------------------------------------------- + +@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0) +@SET __MVNW_CMD__= +@SET __MVNW_ERROR__= +@SET __MVNW_PSMODULEP_SAVE=%PSModulePath% +@SET PSModulePath= +@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @( + IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B) +) +@SET PSModulePath=%__MVNW_PSMODULEP_SAVE% +@SET __MVNW_PSMODULEP_SAVE= +@SET __MVNW_ARG0_NAME__= +@SET MVNW_USERNAME= +@SET MVNW_PASSWORD= +@IF NOT "%__MVNW_CMD__%"=="" (%__MVNW_CMD__% %*) +@echo Cannot start maven from wrapper >&2 && exit /b 1 +@GOTO :EOF +: end batch / begin powershell #> + +$ErrorActionPreference = "Stop" +if ($env:MVNW_VERBOSE -eq "true") { + $VerbosePreference = "Continue" +} + +# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties +$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl +if (!$distributionUrl) { + Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties" +} + +switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) { + "maven-mvnd-*" { + $USE_MVND = $true + $distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip" + $MVN_CMD = "mvnd.cmd" + break + } + default { + $USE_MVND = $false + $MVN_CMD = $script -replace '^mvnw','mvn' + break + } +} + +# apply MVNW_REPOURL and calculate MAVEN_HOME +# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-,maven-mvnd--}/ +if ($env:MVNW_REPOURL) { + $MVNW_REPO_PATTERN = if ($USE_MVND) { "/org/apache/maven/" } else { "/maven/mvnd/" } + $distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace '^.*'+$MVNW_REPO_PATTERN,'')" +} +$distributionUrlName = $distributionUrl -replace '^.*/','' +$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$','' +$MAVEN_HOME_PARENT = "$HOME/.m2/wrapper/dists/$distributionUrlNameMain" +if ($env:MAVEN_USER_HOME) { + $MAVEN_HOME_PARENT = "$env:MAVEN_USER_HOME/wrapper/dists/$distributionUrlNameMain" +} +$MAVEN_HOME_NAME = ([System.Security.Cryptography.MD5]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join '' +$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME" + +if (Test-Path -Path "$MAVEN_HOME" -PathType Container) { + Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME" + Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD" + exit $? +} + +if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) { + Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl" +} + +# prepare tmp dir +$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile +$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir" +$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null +trap { + if ($TMP_DOWNLOAD_DIR.Exists) { + try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null } + catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" } + } +} + +New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null + +# Download and Install Apache Maven +Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..." +Write-Verbose "Downloading from: $distributionUrl" +Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName" + +$webclient = New-Object System.Net.WebClient +if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) { + $webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD) +} +[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12 +$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null + +# If specified, validate the SHA-256 sum of the Maven distribution zip file +$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum +if ($distributionSha256Sum) { + if ($USE_MVND) { + Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." + } + Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash + if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) { + Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property." + } +} + +# unzip and move +Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null +Rename-Item -Path "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" -NewName $MAVEN_HOME_NAME | Out-Null +try { + Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null +} catch { + if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) { + Write-Error "fail to move MAVEN_HOME" + } +} finally { + try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null } + catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" } +} + +Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD" diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..49e9cca --- /dev/null +++ b/pom.xml @@ -0,0 +1,176 @@ + + + 4.0.0 + + org.springframework.boot + spring-boot-starter-parent + 3.5.4 + + + template + layered-architecture-template + 1.0.0-SNAPSHOT + layered-architecture-template + Layered Architecture Template + + 21 + 0.2.6 + 7.9.0 + 2.8.6 + 3.2.2 + 2.29.0 + 33.4.8-jre + + + + default + + default + + + true + + + + dev + + dev + + + + + + + org.springframework.boot + spring-boot-starter + + + org.springframework.boot + spring-boot-starter-web + + + org.springframework.boot + spring-boot-starter-data-jpa + + + org.springframework.boot + spring-boot-starter-actuator + + + + org.openapitools + jackson-databind-nullable + ${jackson-databind-nullable.version} + + + org.springdoc + springdoc-openapi-starter-webmvc-ui + ${springdoc-openapi-starter-webmvc-ui.version} + + + + com.h2database + h2 + + + + com.google.guava + guava + ${guava.version} + + + org.projectlombok + lombok + provided + + + org.modelmapper + modelmapper + ${modelmapper.version} + + + + org.springframework.boot + spring-boot-starter-test + test + + + io.rest-assured + rest-assured + test + + + io.qameta.allure + allure-junit5 + ${allure.version} + test + + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + org.openapitools + openapi-generator-maven-plugin + ${openapi-generator-maven-plugin.version} + + + + generate + + + + ${project.basedir}/src/main/resources/api.yaml + + spring + template.api + template.api.model + + true + true + true + + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + + + **/*IntegrationTest.java + + + + + org.apache.maven.plugins + maven-failsafe-plugin + + + + + **/*IntegrationTest.java + + + + + + + io.qameta.allure + allure-maven + 2.15.2 + + ${allure.version} + + + + + + diff --git a/readme-images/layered-architecture-template-concept-diagram.png b/readme-images/layered-architecture-template-concept-diagram.png new file mode 100644 index 0000000000000000000000000000000000000000..c59e95e5cfc035688c7fa6513383f945058d3649 GIT binary patch literal 119590 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
^8*SJY$^p2o;&clM=-oyjAoYZ zVJ5^FIRc)J`**LWHQJkkT;Hqs+!Pf{tS4AW#Q!{e2ftY^qc4*chSn7vZq>gj_aFnX z2^G5M&L9SG@^lLW?;3bd3|HU(!FfW9+&P$E7G4jq`Ss#_k=M9sh?hf2k9#18U`U@v z=-9f7y!E$ycDty5{X10Y!QUTKjU{^%n1HsMT5IxU;ZS5cCiCt-PDEsj2o<)_ zN*cx}2j#dwg5t9Ny_*WOa<*W}9F^qO|Ik7`Xcea%&L!clpSE#6A+i?LkOntKQme?l z`hz=sn>0O;R2MT8i?_+5wB*A?zHs~D?KF0i=C-j;7e6HLg0ajH#aV()m-g`IS7)iY zr9NCxJ#MNgTL~ekkRBoB8Kq8dN4kZLvmP*~>etqKsiFU(8sHp;u{zBLm=Q`l6%&|p zb!`q50XOgkU(-q7;Ocpj{?v=g-~7c8p@r-CAKNpMGckE%Wj$~`J(*h>JO4Pa_mrp8 z_B!2o>{w=Jk4A;g>OuN_G^ClUH=Wxt4>aPeOoCqH8k}lIhNUf`&`Z4KpS*heAIwFx zj{cWyITDDZfsrZLM~hZN`m84Pi~8qz1HF%bp9@ zs3hEIZMS~so3~2iw{WzdkUlRUTnoo*V(`te*LYG=CX8{o|>EtG*vsr4`CrkVaLEUNE@`EnF0 zWm*%;WsAR`vQuqcuvwJN%r?ZH^!6)=L{f__c$(Y9iW~So2?&y^n`MpgWGIaAd=Fng znLLP*ZIv#5{iu|Hkq0s1-3TQ&L9+TY2OG&g1Vgx6L7@L{=>b0 zt7$7A2}YsDEUQrY$4ev~1t;G;4F8haTTM^Tvg$j{q4SH;?#G zRfaCSHv|Q6O`&&Ep(*E+r_8_0#LvTn)4?Ih8_74-a8!LZn0MZBU$6`mN)^)k1OwJ- zfKN8g5@$#g#6AvB|At|O(!jS(vGpDkPmiYMSl8xXYPwSRfyMykI^#9b=?pI!$q&1J zv>Ft%e!QwE=rxCmO>Mu$`ij?Tfw=VLQvJM>2N-k@2H9q4$|^eSEpv7i2VqAZOuH5) zsCsMA|839;-IVCNV7Ez|#WVDKzU520dhotfc|-xTCiv#}?4Zu(3oZ7R+H39|+dbZs z$N`uE_zgZ3yv@naFaoqh?%s~?(qK=J3PE3_ZaC%LB9*z4r30-zMbcZpj$2e-1IU+w z)rbB&OJ`B@{2uOf(X^>3jPPkYd^r5}`+OjZG*T2@{H|awTY-VMBq<-?+W8PMi2;57 zgr4A)!!^R&9Hj|FnjjVS&LQ#W#5-nW!Tm^`dviNtJzZwI^-E`Wi8pK3w_kjUHFdTB z+ul&-OzAp!9sC75)cUjnGlu|p#LeGiA!G*#)#gO7`&VnaSUNDJbRzA*^1@Kz2yLE4 zy`Z+%+RL+IMW*Z61gr)M@;%KMEq}Bc2Ec(d-DA#9u;eI%fGdkyTwf?h^QC0Z; zD*a8h5#=)G!oelek}MrW!9pZ&rRh?I$Z;RV;ZofDH%H>tMk<0}6lh5R{wbX z@yAG>UTJXO`>zg&SN&Agvy0M9#oED70ghE$h^yQSN&{np2=mrV%YGww0 zF!AnuUCh^8);+#52AHMf6|mR12U4yNb(0~mQ^?^nbF!r+yhMo@Fm)KXoH1xr26sc(uO!v3oyi3nS&)2dNM84;uyHTO=3sZ$P6*B zPCO_$D3@F(BzjcoZn&%%Ucsqh;wMv9xrf93DZ~*VC3O38&D)03av;Dd{)0e0{X;Bt z7ycJ)e{lc{yhW-U;V(*Y^``nTO>`QzV3-g0 zA4;!7sgrGpvT9XjILuf9=sQ+pTt%fzp`n4^m9flYLm1k$yASWzQsGytK>@fu3v?Rh z&^$T(-T)$gU!>Bo;jI|3S<`?zq?s{&7*otwt{Y=(LLnWUjqEC+rY2xY%v!6=A`|Y3 z>vEFzbqWrOR^j@fXqA*EUAiLp6o$)#IIH-lM_%re7WZ71%uTnO2^|NyKWV%Ya*a&cz!cJQYnq4XExqA= zO}Ud}ce@?^rhMrea;9J56nlLcgO~kW?273w3&@NG^CkZ>go}aFLLJQI^td{b97EDu z6Jc?swc>%dk_t2le7w-z_Ja|3xvv5-*ovj(d7SUNezyS%RvCUC%%Ggpo7z8{b0)0L zR}aIR1?y|VkxlJt#T-cXRnWGP;+f3gLKgG~vH3v4RZTz=Tr?%@p|HB!=o}UiI|V^;hWg4|LnB z3#{cG94^p5<3+wX>gj|E{KzS$OG5&)@3ui16e9y2tI1LQFa_+kF*Gh6Oa(FuSl&cr z&@dW-abZx4L4fW!dR9a!Y|3gl1$jwnB$9$)E>)$EBT-hvbJ3Qjb%kbm zFfxX*DIR_WJ*8cyP-|?rG&eHUHH*0^x|R4$D5@&vD25IW%e&M)+>n1SI2~fq>9#&j zzHP%_`h?SM9YB&t+TY)k2$!Vf2B*x0hu&dR;`-2Wa^l@_6Q31T-^l*C!_8wd(mKmG zZI+jh&Uukj+f;x(zP6u>rbjTYdUI4{b6Q#*=JP(+mwKA$RI{T$Hn@glY|4_csT3Fg zP)I7QtK1I))RJjD_3%`23I{S8yy0MJewt76=y8Y1dK8Z7+$XJ3w}`N%%3Ax_T{z2H@2#|Wt@Mt2>V{;Hn|mfeZkwiwCdH!D(-vQ1#4SKIBYzf&Foj$AN#tF`T(OTDR~NTnvGW4q2ChWj@36 zP&7tp@Wl9mC}FQoq1ymmhwgrNQFMGL3t`zsVD{Dih`pg!jRxDaxJVn52OkA_|JCL< z4T|ClK@^!BX_Fd^a91rOyttj2z=OeAPaY+`pJ&`X)pk`GyE9%(BW+y;3x@M1YH@QP zj;P*8jbK)h3K<&`Pm8UTlXw1&SU8|ID-l96HWv5-q*}YsKSM=N z82;Nvf3xuj%qG1WS}E!QxuJvE9GskDHbO#z1O?8ZoZLGHb>VlgyonseMl3Kh*#`J) zaAsz63tE$3zjVKL7_JO>wTouf4CH^$f}UK&C}K>99ZBXx6ILKD*9pBeRugi>HX4bw zsGlT7U4*`tQd(#LO!~Jh5aN%eXE{C|%Z)Z4Y)9{>3O`{ggB72Jms`qQmx2+}&gS1g zut8I^2e7c_jVd#ahsn$9$LFaD?f2iAy<3&eVjp z>7bD~VVaj^bUMoS5oNKM)Ph9SrN@KDci|7*$&etR76lHPw`KW+3Wd=cM2F* zU~L3k4=H9?r?VEZNCe${O*YPw+OsR(cQwpgIXaEIFBrz~Prv2qN-D$fVln`l3NlHK z)%|#iCiY{Ou{qAqqr~j-zYRh5ozB`P7Jat49yvahmXSq}AT5WZ=pwtfbKu6AJLKH+ zkawV-YC&ZE!joJ1fuglo{w(=D&ws7ZmH2XWYL6}49I+=W|R)bG_C8fw%CzR`T0nd_}uW$y2%2qz+d%yvu z6-#eKc$D*Bc+&L!=N)*dwv5HeDt#q)7xw#n!bd`K4vaCvi6F`ck3*#`xEnCer-)7)}rp~>)h z5nrIZ@0H0Fr*l>~o4I)Q?`6130kRAX(MTe9$(Un2^I$!tYH6j|EAf2SLo6fW=E-E}OS<3J zQ@eL2*9oBE=Mfgjt^5N$Evgx=uWmD+o&l_S&QvvE#wXWfoDlT?x!X<G2|U*61aKrLFjSOUb{O`n)xdwdm`aJ9@85&EF;1DO2}rDd zIaUy%dnfo)e@acwRi(j;6jEXVnzx{7ZP@!c6!ufDNd#E_fU`Qq8fA3jZ3Z|;T39@tf9 z@)r?M4G}>DF9-XF<=8JMfvS2u7koIlM2DA1!^y;|9IECIBWw3m&THF`31h@)>w;Ip zrL+NKzBD{sdu{E<-;s4LDi#l1?vl5b57+~iC@u7NhSIJXA#Zv|_~nxCQG9L2jwR>L z9KBaY?wr?(ujgxQ2s**fy|1w~YFrJ(ic6sV75PH9oD`OtLtrz~Mq7qxs1`+E!a~9p zQf%a4>W+B2Xc(3ZPct58ZTdIKiIBX@>1*g~LOvKedWRWxfM@z9CyU4AJ3ij~D8`Qx zs>aFaS)niZa3xMpqUn{$W6o7 z$hUi8MO^;AV;UF4vPe+bw?-EtOkanBe=qkOd_G}AHK-u{Kbu!cdW24SG{f}J0JT1Y zK>C;y1yNp331yF}`wgNafy2*6(8%`6WImVl2$3LnFiXe0_&{^6UYCWZng7Mq>!w!+ zKv48cNJUWrpEouVLUW0$Q8x{Omuj?7(l;Lk^ugFz8J{TDbp%>&lI0Iqnh$yiA_A0N z{y&ckJWiX|KW(hSAy0P?U^(buru0QL%0=k$2_=3{s&)yNi^wYG3rYP*8_iM47FRv6 zo-Ce4`qg#pzn#oCgrD?VZid@RM@SovjVYolnG2;-^!v0e3sz=2zGhHz)%L+5HqXD{v_$_%e_$I(_>WOeyWil5VAv-Sr*)J>a$5m|18>%YlfqWN#K^9r{AO*WiDZnywUnXOqd zy-)^LLD6(VRlH9sLxq&i=Zy|&+Yo2YH?SJ#j`8VwNP;j90yTm>4;|C}7BG&## zywAfzI217M7@S?1WsTzeYKY^6`ZtqOmP+BTE~R`d!5yln<~n<*%$ODRXkrKJXDr?CM!8+Zz5q zrM+cbR$bFROm}y8N=S3k-6^QFbmvJU-QC@dAcBB&NrxcaUD7Eji2nD9Ue|L!@qT*! zqCb_rXRkGJ%rUdp_`=o&#bVgg@GQkB`E|7r_WcMk_~6WYC0uVD1=Yyh8^q@}a&QFQ zy_Tx{M;o4;1oF^dX|)+X-~m@&J z?PZL^JX_=g->AFVLXy?dx-hD)hLGnH=;JTV^Q%!9o1OUxo>v@4<2r?_?E%;gXlFt( zw4Ifl0gBLw8_rP z1AZi^d=`}g-xKlu;C<+Tr1YfR3?fl4pYznu86O4=V+I#n8Guea+dG_@bDvkc3Y9_c z)}shDcg;h0EG@$8egqx@U~^*aQ_&u-7(pjNAwIoE5IU{y%MeZ)4FY;8(t0u#$~kwq zUSn&!zGoO%Q!bu?hfF^!L zk6_J>A)+jiBiit2M;t0Vjd1nNMBE}m#2O7NYnoQd*V`l3(ckyIpg(MNEuSaqOStB@ zeF0re4>PYoi=}JY?HOF`EC6eklY20-xfzjjSmgVo${=2N)$RA;m7_%|Z(wi77%kly zJy^7+i8Ri*43C5}HqCfRaw2ZkEy+11h4)w|14!j7;QB)4TjbXp7!T+mJHId?SC>d! zO+p?P!_KcU0j-NGdToBkTC1@S%?a<@B3Rw8Lc)M7>(Ub09SD#w=JBU_qp#K}FZzey z7mIqL&h(>iwiTo$m&5d2Y$b&`H*Tm>=8j?RR(_vfI^@bsE9G|+xmSK5zvXdt?GNQs zJ|y@ek3WII5NO94cGA&hjnb-Q4_ew$lqQvYOSZ?EIcr6J2`inPika#QA({x z;X@aQi%i7P!<^pz^|V3YYQqrHmQWB)&ls7J;tKNa zj5~@DtiniFhFPRBHuxY`azHz*k@)UP<|xgMFlO7zN)-bWol=13{ud_0CrzSiK@uBo z04ox5@`Nz{s!vH>iz@C860-Lc6w4SN2VQK_l$Op+UX_{8`2V_o3eo26w7f)j5>;T)Z1A9{g!W&BsiYWWY zsT>zr{+jAyq4R{udKg0u42yRo?1TVPJ~XyDfyy+iC=~G9)L)PLT8!BE_4S@WQ461o zl;-YI83|qD&@+V}2k5sm+U{jdg6pFw^$qSG!q=JA-V|2*F}`e)SrY^mPTH@N+6h4_ zfd+dLuBa^V*bqk)R?!xAkb{jjEwD}ZNXP84whayBzRwUdsWdK9awea|ds|Ay8fbMv zKS5-{fk(pt?}R{$PA0^-h=HZ)k;@Qhnl0_4ho#RFBKEKZqrCg>o!odX@luob@x+|X zPh1*Mx7(b#gY}r}+&r9PQEJ%C0lLSU^f{wDH*WvOXq%#{z1GHuIrg_Z!}oKIt@m$B zprH*co=X{_KgiV6f~$7uYRS>tw67=8sQ-$rv1CyE4Uc4R%}gVX_+{hBHV{NzUQiK8 zKg&zve%nPs5Z=Qs6Vm7{&XME9LG|8%>XvSlL#)sij=B5S59S18cP}U3kmllU#J72> z3#=63^KynPHgL_gmwRv5Jq3hZ%SiI|dNLirzPkg!aSV|j88e0#&pI|mhrU_fyL>X8 z{b6g*#>=bX@!`a4YnzSb<6gE-cb| z*;hg(cptIBo+fSqcjB~`2hCH;GH8bEdd$uK!U8Ja4mUjcZ9vzanY(k5|L?U#55v4K zuf7?!cPTh}nVzHRYZ_o-C}QQWm0fZNw=5RwzkE%e%fGVxxNu3{wEjv{kC3p1P7J#W zne5b!g4*jN)_fh{|M^;QCc_e5$uBwsnPe`k>XaG^zTJf<8sG`^Sx4c9Q-rp2-Z8To zd{LB;)(rV7V8u;_7GX2X%axFaZM5{Ff)z1n36yeClH2LJnsfpKU=+CB(b20r?e$ag z?Y8yoEQ(&I*~yp5Eu8``DpFBUmZkhFVA$zyRQbw_ior1Dvg^k1wmFeGzsr+`SQY$m zJ}6w%8|;|P=8iPVwGxZxYrWd$ZYQ>0M>!}kJ3i=%JGl)1HHc$(o-=9#Cz=- ze~c;te=$^&3?SSE^LV(a_yq7@lgU}se+)Fus8f1qg!L3bPo5wUG3EEX#%8!m`HME3*@x$dvXK9eA zgxSM3GwdBWjkn-NA>9;Hn*>v7l+kLNF-F|Yk<0zh8g2pAe-~tNn247&)&o~DE^m}k zIu56tklYqnO+cGQ0V#NJU_=ZlOud1CE(H`pgsWI~rC-{~aRCJ2#;uS5gGS(3!0684 zSbp32AwT28`0E2D^<^9GrUnZF`kyfR`|*~5g1-7;@w$LI`M~dIe>LJ9kD*HycfBz} zrNiW;)u0!ai6b4dXm38J5ol&f87qLKQuaZXzuG(|G3no(PJ)<|wKx(WC4S7JULR*j ztp=9VrxL7sTnq&1>y_#;@vGXY6i!pw^a(DDpIIb{QwNuOCC+f&Yvy){z?#B;Up(H} z45od!jmup@e0L~rwar2#NJ=IqmiuM=D)c!Ox`TbgOH1T3sm@l6`qa z#GOo_>N-Nan zUhON`O^vc78V7~DdQe-NIL#Q|=#Xc-pc_<40A#kyLm4=ISm;Yi%w-L(wD zxs)1Yf+>uZo^M2a;Q zw6xQRvwpU)bx|@1Xed4GyWjGuG~Y@nTpX~Idvr`nslqH2B#x8Rr(=qD0*u1n!662b z3=-mUlp;GHEbX4sE$BNx0|vECwz!3lD!*QWjLX z92BYjl73)o;%)ROk|wF){GKTyi)b1U$M6)3I#!+Phk;O}tAVnlY$Xsn(87;?z^Kr2 zNudT0@j)pYA1Es{Ad3jr+gF-rM@Nj9WBWjI0#{58R6ryMp_#l8=;#1 z)6fQqO_NM-+_5saxdBtTIU`^EA)6|j-+$d5P4qr7?&$PT`_k$*_{iqy2uR+#2F+fE zfT=a$>v0*Hj3`(XO&8WsbIJnPH#qwXp^UkiWUwZ|FqKs13m)}-^?$_+MQQXD#@{H; z-opvT^)FF;u~_0lsA5el`5MLKsKyX4$N@Voq?8-qni^D`1WiN8N0Q9CSR}PSNdEd^ zOkwYuk;BrtWw@{#^{hQn$jyi=z26Cc@2R#mlTq3oplamG z1lK!>$eEPJ&I@M1gf~V5s8YpV>aYr>SU$ITz>I@{-OMS;$Aj$V%NT$_Q$kbyk*Fy5 z#Y=>sDYVmdTM-;ksN-y&H7QE=LAnX5KG*LG3R^BLmo)IAS3R&-u(*BdK>wyrHz$p*fq|>H6^av` z)+BVDmg%v%wLVHb16zlTZNSv24R`5;ywdA#4*NpzDVxFAT!Y3t(w#*IkBo*ca@&NbqZRz!iaH=|mmcRemQD`B#-3@|0Ej0tsz%H4soL<-=n zZY?$D&mXxtS>~?$RyBM9opPCP6Y21kH*=0Re_yww+I}`x7G`>wSwP0x6Dv5$8y5p9 zhF$SQzCw#;iJ50A2{_B8_Y~!vl{LEw;`fpudsr86>02_D==VlV&?AzV@i=wCR2Rzt z;Yq<1PEo+a%o^~0fd#u4{fL4$2TJpzyOVW{*I>A;Y13jLBabIv5t{Ty>%GkULAh#U z%XPxPGT(4|5hrw-dMktUvt_Z;%xYTIz`y_~?L$(TgfuoN9;FT&Ao9L0G*b$Bv1BFY zFhKP!L&CgGI8P}E*uD{X)yqUhl`m`q87}D=VKqvS?fdej0C(xML)z9MF}Bsb0COzC zjH+zX9JufTe+hbw@r1*)gkJ~#4Q?+T4`X=vSm%A!&&*!U&GVmTqH_Epjk~*fV~k?6 zUgNN_t0Fi{H6;5)mY7y@47qYH6f4#^t2p*ZI?Qm)%*PrDT*rfr$5XNoU~awx#wT4* zCxEy!!kk^&)VQn5w_FbCcVQDOp;ks#X?R@|5nSE+f#oj(;>N^*YL_WXhyqIPBPU>R~G8+2O zf4vvj-IxYPMh03i=UrTOVL>A%{dhewA)6lDV@^(|KI|K5cbhu@v#~_-GnKFJv^Yj9 z_X*mc_n_Z;h+Rt_xy{e>^7cyD)g|NR2Nu(Ia+cka>`Pg*fmFKpi)P|d-qIJLQ&%R` zJ>gNFl6<;vW8T7AP{2NFVdNc*&^!`|5H~6LpcLZ;z9KXF$7_k(X78|r85o!G5QDN1 z2@Nf|3ZCmWsu!nnbxr1w5K{;@`|m%dyG(v^qvX6~Y;{}xuD*BAD0J4IF3^?P8gRE_ z9zR*{8}Pbh*QVPVWgmtjGg)6@Ax0U6Mo`rVzdmyUz-}&%BvWch&U+$xERZH|78KQU zK-qQlu4-J0Gr&D>6uxK3k|Eigs6*uj#?->$B;mqiO3HmaH%B9aR-NE}+g1?o2=VTV zk&$cU*^D=58978f=W;`G6cF>PT4ia?|KYk^;3MC_aSG!zrB#fxUbn{aZu`*6^Zx~NE)yYESRC^1hqFS<2vPK3C4W*U z>2!!-UqLa@DPsxJ3tMSa+${{&idu2wI3<`)-+Ny_Pz7kcs#X@wCKrBdWwu^@flE31 zW|4b4HQoWBF>bsm^{y6NB&<-kbtMmbp7|4mbWL8~KyA7g@!lv__`-U(Z4y~1P*-Bj zZb7gP9>d+WIi z3*@i6sKV3fGJlj^gbFAuM8VpT-$YAJu=OO#SGeG-m}Eph+TKMq^_Q4(VWHIDBic^1)p5ES6b^LEn09?&BHFBaD&8lTg8sio7armT! zO&IK9130Fdvq0$}imGTE4hY5n3oMKx0(vz{>lybv{i-cSVNaHGJESA2nG*$$kQrG~ zQUzCCNHdXQdZ;_M7I}idRb#1bV}W5(w1Jb@Lxn~xKc8q{E`SukSM2BPv|3cH4Q{N~ z{yU4+v+*+xaD}lipeipBa|OdA5n5+N#fM>Ws^H%tduo3e2-sA&{R0nZAnX|65fuI= zbGw+3H6j=Onyz$jFi`T>A*^H=rH5oO6u6hseApTxI1z`nM*g0Y8AkeTSU|!jZLC@o z$;s2)>|=xvpODY7)9;(F$(CYhOX=YwB&)ilx>={o6AkWCz?IxKq$F7I83-|02#74n zIj+nLQ*mUW{87Y=W~Ee( z7!NWMuEa56@(P=Mr#-dFxC!TQUk#8C&@1ywf?qjuvS-2SM_M6aOee&f{>b&|DsTH^Ze*d06FYUfaO>=>neOYA#=B5T+c#b! z&H-kuzxCZUU@K36=H=ov_F^I7~qSgdwR0SyWSiKetrN_diNqY3bE0^h(rE z+JCK=Z0+!7=2zc4!PE98@TAEu)Q7Ij(TUlQFS^k7%(WG*Yx|y+Zo-0jILwPVseqV| zw}sU^Q!1-lhchXw^q)+NCO%}@7$D15*SNpg9J@u@!`=_wnD&H-L$WN$-Ueh{$eRFH zlA>wf1f<}c1x(NE2dhUH?|Fe;W8C(4E`Es!g^PJUXJQYEj(4c~T2*D6fA;3q)7Lwk zj;)%Bp6|s(32m16biKdu`@~qT;szs-JB0iBFU@LcqWcTHh#N)`!yY+J|YJPyi?%XwQ&t+Q%a14vC4x%Ey@Zac}kiofinS$ld0eRl=|{v^LDm z@~?Fix_qUrnl~`ir0fX5lTS0@!bR_9T;7iu=7dqf&0-@~jbAgd?VV)MVhi{b`s#mr z&iB{=Y?+P9IRjt|`x9)DS||l|%^81YieL|(OeoJ=mbo`pDAYriFP~aqAn(|^dpr6= z^97A5&D9&#FTy@n_Nr)Cx8w`_b=w_4$*=KCQQcGIt2sP{fa1FEt*vDiaI7WJ;(^d< zK^JWf;*C%?Cr%4Qv|&Jdl{St5k`k3}Qw*mbl&J>OB93ti0@yoQLBK+Nkv;z1AwZsJ zuAcK45R%^XBCTBrWrCC9$`o;P(qY$Mh!|sR!H^-Sb#XUC zZ`f^g2Nm~-g1~&;jf~08f@NrwnVUl->U)1YFh4L(mXSH_k<8WF;LhsU;-Ru9b(Ed< zCYY>?NxXZbbh0Xh-Drc`Lj6n3s(Ex-l{qa38PakgRG9Vu#_ES%0N{HS3jU%db)*80 z1~_vx{wl(^^SQ!b{E2Ryz6GTh{#b@#l5l6`pT)$bJ~N|DL_=GKFXJ_L#SAFJS_LMFbriXyS@`ejf-LpQgd>;+Uk4Nn{JRX`M^ z-X}0dmL@HXl2o%X3&@hBeWA=CP^NYF_M@t!T`kY+I0Xf25-TxnON#-7d$rEXxrIVs zTw20~DNwPVi%OaC>?64?fBmYDt*;&;*{~W;O}#?Qaj8-_$2E3LG4VdEhKsfjlAyFA zwzO+b*ZV{QUU&}Wy%-~a$7KBLy0qwlm{{$6)gng!A9jdrnv_rz75u6IQ~HP%e*Z{8 zf^ua+W{0tmOM$v~%mAtr9H}9x?h>Z^pu2&`jzJ{qy*pZcvbXNlVimeDSykl%eh4EJ zJo9hvEXAjfgT32+LG=SUV*BSN^K0Z++TZ9=wUM{eMGJ5jd%SEC3Us0h%Agt*0$&yT zuHplz6jHAeV}@K6(GmqAFRzQ$E)Nv`0q_efk)*f~h7E2;wtULey?Tp7*)+XtZ}^y< z{A5JN$-LsZYJL4xhEa-)g{3zpIjHvHdb79964la+9Kbbty7QvzKPHyS`bV%*HmJ~{ z6ttY^#OUFkFUk`w1#IGOZ_IQN%^6rr5Q$C%3C8{(Y)mBuu%D=*3!nUG4m?Vci2={0 z17O!)zZXzd5*#FwD%=>rk-yvyG&-#dVi0V{3!YtbLhNvs2$IkvDwae}*d5ZS;l#vC zN(xZhx79?`w%V#sqMypyrR);v0EBrInQ=n=^la(sB9(ds_ zp1^}pgIekiXKz#WT)sLRO+30ni_LC_Cq8p{a`M-W$F$^mP?NpNF?lhlD{uUelD`9;)l^iNBi4;Nm zNMOq4Q2Z|qQfG4om6#Mn#ce&fKk$O95_xInhcar%mut?~q<7A7^W5+*jSRuRWkTYJ zV|c6%s*y}lzsT!2#az}Y?OFph>X{{MqeFIprm|9CmM6Y3)zc+14Fb@W-Ctn*)IUtX z1P-Li{1>US%fL!~!lOP2FGcD}sxd3#((Q7;D%s(Hz4&HBl+4l4OZ=ga?;D5}SutlD z9hZpFFU`%(Eyq$pLYwR5!Aw6dStLhLdW`k-fG7r5c+g;BS-~6&Ct2GJK->LKT>f-) zgMjCzMGXDGgZQ5y2R3~oVgZ^Z0ortG$QV3C2?s_1y(=y()?$OgM71KZ^d$!xw{=l1 zo~JdIVUhDG8Icj}7Z1M=m9>bez5_!55lWaf>VMXA2)F<{7Ixv1Q2eq~6u!+D<%k4H z-gIBbx(7{SF*8HeCyu&m6<9073{;e>`%8tC;`%aWhESOt*3l)wq6NN!t4jf88R?pX z3K|B8V4Y~p$@6uUS7DeIi#}>~bHpl8oBy}8Oc-$f@r*R)ToWk`GMIz*coV3Wn7xzH!pvi{G7f>XZ+SbnIYbMMXN{uz4l0Q=x zdWAh-hB(PGe4{x|?IGd_k=1Rb`>!(Q6LmER3#hc`t~wXlLdm*`@&M$GZ%eVz(Y|WD zmH?7w`IqA-hh`Qr^i*wE?LU9MoG7(I%AGAgK$Sg^=7N@ShT@_j;iXM?I3Q*e#)E%- zT1s0+07nnp?uLF9@F6J0eg26?{}<9xbOYZvNT&j-QTWWFLV(S!y05`A(OJv&vX%#E zk!A`Y?|0RrRfx{&A!7I9Nz?9s$Iu=D%1GnE!KNy2NYDrf4hHV-`bGlF!&xx`+KQ8{ z(xNt2{!7RamAMQse9I^UXp{Is$U+XrVv}ej`K5CntT0*RBxqQYa3U)T;z>W;ylF&I z9M+S@BOL^^nGCB4btz3q8Ngy-gWV&bYU_he+6%Y|OxcVR zkA^Mywh=b|zg_AD2ym&}3O#Wc^vwSOR*h_Rc$bi$JOczwkZ&AcAyC7*hiyNTd`)_f z1a}iq0w-mJPhCpKMke=;oqEBL2qCGOr%`I-G6PQ=IoGLg#nu(NJ}mAHeD6PmKcpTJ z&qxe-%e<++(r~yxu+fK}8&=&Nt5Q&dV{qHZloNFp+L zH_>OW_K!j^ia;#cJQ<4$=U>w5N%!8sx6#d*Xp|s3yO{fqhu)h|{AHFtIU}HhfE<-L+#>#3w87?84hJ@6M6d>IJZZ?xIVT%6O zCw{=|o2x@{S17lJv7+sO-qS8Yi6{<7PnJxW!onfUX$dUL!TY=F{Tz9h2%^THq??yhm-uUbPGc?z`_0JUD|0LYe$G{Q!JY zPE9t4U42bd0?@;SPX0lVGa_t)4Q21yg853oO)N2%U34ZK5cRf%LahoOL4}+EbVbq&mMDOL%5 z&qeu+XssUBs98vv>;qny6dMa?4%|O4kOWFD6yq`g9X9A<9TAN^{9mw}$In#R2kPq- zmh=OJ5EEC^kVi(7Q>0;NpvEbJ)w@xoj$M8k6 zlmB!HY`4%o39m?}ks|Zo_!Y+#c}W^$!i&_4sCz8qKJfz6CA zQLkqI!Cj#bZ=C=kjFR6X;Scy7bU}t#LCe+tPGa7_+X^A2y4jI=Rm8u(yDg!c2+>t8 zp21KmQnF$|&Psab+CIV1K%fz1B%c~knxR1goQZu10&S5>Dni+3(4e7-IgA1YmM1T@ zmjo~ZgDx!`FmfbcmQ3g}EVCbhCvqrAQ#+jX@7|Y`qxEtXha}{Suj@?0Ko(h8>Oi2 ztt;WM8NSbW`Bw=uQ+t^bVn4o>SJAVYr}f9nWa(P(_z%-TYoL+O}Gn) z*E5vB{CDeCp0NM97+6`20!J>rfhz z*=kZ!LvjV!*u*(X6gOCLgW}%A;&@XdsbE7o{Mm3`LzjZW(g5yCvXagmJs7AC06hEv zz#20#L&rN87d7^9+Dr zuq7o>y12{GOJ;Wgw9L|j*tA*ult~&P?jd(GZ&lcV-g<(NIXn^(DiCAtKh9ee2NKpr zO>%VTGXEGdgiOWJGo6LmPov;)a&JIDrZ)+H0o?014b-loF1D4i$5JEadaN~&TD1>qAgu%2Kad~>kV#0?LWh3PL>EFKF$yyN*hhpL_-dl8mSll#FC$@MHZsK2^>~&k zmH?>M-vu(imQXCN47KWZ(q1w}PT^ICl!84)ou7~f>M${V+`p!j0zM0}8OJ?=J83D+ z=wsqVW+TNQ<&@vUw`6gEs(kUqCY{b$gF_K&kT1Dq1qgeVzW|PZkoz+eOI8B#UBeKD zO7bIKQKUm;!5q!8bPrPll@d?Nd6Hb^KQ)zqok(MZc@;mXLg!fY%WKzeCwAZf$GUCxnL)nZ15OdsJo4P8kb2)B z_d3M1GT*%<(D}>cu`&bXIppU{vE)z-c#+E3fQz4wrIT{PnPN0*2Bm@BGA1$Du#+G) zFF{#|lNg3(Og;JTDSU|q(NnKja?Pm(zjR1t&MybRSX->U%r3>$5ubRJlel0fQ_^0* zoDi92rND+^sU#_718peJmcIeiD;p%Jy$ay|kV5y!ZYjxy^{E6<$w-#oZUOHGEVMz2 z8sj&K3X#vlI80*sYBi8#k@rEqoNijSSgM)cxg}(uDm;q^w=(`t(*`fdP9X%%0^l|>b4jG*C!PTiR*FnaL_5Q6(j2w7({ zaFUVU$#$f zU%bSIymeObo~M|Z9~OBmb_vfwL%w3N%mu3N$2S`6K?176qa4C|Yc#ra;Mf!+gsB#O z6$J^>ZkiHV%(hA`k%~MrEACbXBsHlVPMmZlOq0kkR%~==AWR&&EMgT1%zC%<hb?>z+M?j05e`Di}5 zo=Jh^n%W)V+T4`BZ=@I3;&niA293LgRUzw#bNs=DXEg)FGOGEW$qW49&l?P@5j03T z16SEHt*^ut$oUI6f9}-L4PSnv__}?epZer1bLqk<82|qN{C4`U(9@#}3t%~+Z#J;S zsrqHzEu}%*z?AMvBFOqyrlo8SP(4;(=_ocSo;p)7o^F6U%giXErm3j;=+zkPl%d+5 zE$?4=5@0}l>nn+RMasr0@u+cWdWA|spP>syjq^1Ww$ znTr4ESsPOP;5Jx;)c3|y7&Qz<1Evu`5}4D_FUX~M@NjhCX_~}$(rB{Sv0A7TQ%|4C z$OI;}@tC7~1L#TN=O+h>@t)GUcXeM@zvX=9BCKNOmlW7z88WtRyz|_<@SJ-3qKOJB zOoJshLfj#C0WkCXI@eU^bU<_B8AW~}mQjpLBDNH+?5kf8V9iFAUnCBs?~`cHQ#+4* zb~x~O<>VAU_$dLRHWzR&v8Z~SG&b4)O7(`XC>lAERVF7tEQ|b-3uC8-rhak9 zKBZ4AjUXX-(WYGVHL9F5z1#zwj)Tu!eisDbrl9`c)!D#jt1q7A8@ylFZR`2`=w9(% z6MpdNO)1g-bHEEh;w9y*5eenhDf>)O<>1H&3|%Vc=RsfMTol-swl7$DAm1PV4h~-o zk?-Rh!MB;^Aip0gyBD6%dc}@_-xRTg3tzq%+mOYY)gmNxnXaCD0IrXqB)}; zJ1i$+=)G=HHW+*>TOtfR%jfCetXqbLBt5ZkbT0Gu55uHim+Jq-2Bd}oy1C*9H7U~R zy0It}ad|~;iflCjiL#VDnSfP-oRk18xu^6i4-BRf&5?Zr6G1vG;6ZeW$G4fi@F+&C#ds2H~sVFp>0D$`t21zi0k{8fmq+*VCzmOEZ!SR z(e}L!iJW#$|IUwR4Jz5Hc>xsVZ!6;McNNr=YN4qtAgx3em)1dhmoaGe#@9y?y@M-Gfw?wD{Oq$E8;L z_X(L!WMq`{d$AttN0ekC!E=~vYj>xOCxfavz{NG^0orcNT`5W_)fw7>z6mZJ9YQz2 zSc6YY2ffNhJ|^FD?UxxD7zHq?0>}us?Ifmm0$hcJmi%{GEVWqm__zcc!AGz4>tnzO zk~!yG(M>6FDIt1Pu38vD_yus?uExOq!!WlecQZMpIQrU1w{`F;mm8b3!0OJJBG32& zmuyCt3<4^Qa=t1T@gY>gHCu{ignPUz^ZVn;GGcg`L+55#I&hQ!aVTmB?Bkik>fFjo zi1Out(AgC_8oNPVb73ci$uuwp&*S8fl;rr})WOD%jGS`4*=yuR#M>$1tC0KFi#P37 zlfbTdFE=`_)tWkadcM%oGL?d5hp$Sktz~O-H}p7(5_!Np7H}#k?&v5j{YJX}=)f-a z$!^$W^yfxZlheWcNBu~B__!QU;`m;oKab$T3vmdokzxUGrDEX${KFh*O#V( zMz#Pu`{oQxGH9_lNZNj0#fAh}Z6Drpw;h=cDSt!oqnzhpgOOovCSDVKmN|xLC*aHpm=I2Rl2T>yuc^v3$c8 zlm3>q&e&$en`7ea4DFfK*_D~AhO_pVw%dh@uq^7XRefP;Jdn}meqjqj1Y@Wed3;g}<;_Jwx) z_1Z&=4}}LU#bBOH^f|}LN)zVTq4!yTaKATgAP)Az_Jt=qf=@nI1c?^vWEDyz>-f*z z{b5Z;)%?J_^MzXeHSg!yBbae${s%|v3%8r$A|la-i_PHmz+jNC-=p`skngXR+@{t0 zv9zj>_AAzZu>HOqD1!9qhbZI?|k8>=zNS zrS#m$6LJvq+3K6vXKF;lK&Sn9jzXK9dv?;#E9|s0lzrwXYbW`^YdhCt-RG=h*|7y4 z`JgoYvk;dc$(v(V8p16LzVwcR`=f8aHpPe~<+^0ruYWx}U{VfTXJ%#HA9{2K)2_H* zs;v8NUw>WpF!H$!orv-21jl*Xv{qQ?%=i*C`vMwglw1D4%tb zhu%Lcs(eG`EHXRHHvdug_Xg~^!@|VEM9pb8BBkNO`BYwBVInqMasIF4c+uMh)7%sC zXhJp;V)E>aoD~mX=!Wh5n*Y3kn#gzg^Av3cm(HfMzD(}hRWM@E$ZFGS6dDln_U5xG z^qOu0+fMJVF2~W)(5d}Dbly_zRCRA|PFs$djJVBLPrPv4LwvX;7hafI@Vr0Pxv%>A z)&Jr1@8d8xTS7N?pfeoU(hH^2G}3Ch>bIK}?+$Hj=0xtg?q@5(4TB6(Ui}Kb2CE$& zD}m+V5y8>gzq??sY;A4)?piGUcYf@(2?~AGt2J@8V@)4vY-+4-ckd4k4Ad9>-7~Gm zKQr&LU~w&S>+>^`G3~iQtM534KIclcoKHm+iu^u4j#oY^u{lGoa601k*F0Ue|&hBkmcb)FNUBB(o zRQn$2ZT2-Quev&9-OhV=QjTBv=Xp|I-qCATL*KIwO8+gea6yaD>FKiLphyf-gXas( z9%3#XJ=>A@wjX8Sq#Yh6)jB4oR>;VEOcuBLp9^1JWj&lOx7zZbRv&3qw>$j!o>o@Y zfr#n6@oj!x+|~OcIbRn_oM{zF;ow9IA0BP zibmq7Nxtjj&&(oxc9!P)wE3Jm6!YS4XGg2^`ULRje06vxh-7p`Io?M{LCF@rzT_rY z(&x{57DtCaSz?llq-AGHL~+qz1i_Cjf>?L4QPbFTrq-sM_ZMmn9&XpcmtTkcC-vp! z^p@59?x)p0=-qbkuOE^Vb-f~?AbJXKF~6rp3S%yq=}##`k%% z^(bL{ZM_!P@Eb60M3q~N`*ME$;n&E=&yC){{dU;`l*Ha{^*ttwf3bUym*_P;DK#*U z=5os8&04$fU<)eY4nwYh|F6_o(tPiqwfLJKNw=cm7~o#}l6&@2JHY~@mCkEu;@7;6 z*jUm(Za_H>bxly+hRt)fCN;x=SbvrcP>qe1Bk}{&$pPd1f%V_Qj z_Ub@R>}CZwzA0?Ht-i6ozNyjA^NMK-L3N6@TTP7H-YJ{pW5;fmC7G!XqTZ7j7 zwy=jbx4Ru{$i>`Hblz3eVy_B0w3zR8Vq%bs`8}}llZr94oeYp_>3=%jL_7`m^PMiU z<6E8=bGn*20LH2;Op{Xd!-J1atgIb6&*GL7%X)8&-1+>5IqGAr=~B5-{rkMdc5^NX!`YN=y$0HYBlQsrj9ywc2=k z=gsx+o7D7yfv=YDo)r{Up8^BP^Rn`QCImfjv=xoNsOz}M^UuEq@_+s?Bop&O85=zw zP0JO!M?hF#uH82D`PJlq!0&JCX?9iiYMxD}eqZdd>ABBEX?lWAi`L~L;hX)Fv)>Kt zzjD`q_Yfi?gk!xj-olWO{W+=T_kAOgR_OLLxjt$+&O3MlJK=`!gI@H*rnz)^b@l1k z*mJ)VTSH)!>GYx<4>+>CvdVXV&HIL2@F(T3tIwTn_TG1++PlHQloTRf-@6iNe}DJz zBjhI|iTt_waQ6GA^5d@?%EybolpjnR_q4v%`n6k4zt7|SAH{wS0#1!)>r*J{_k|_5 zX2dssCvJUxY(gH78z)U(EQd!&9=b0O&qDGc!Zg zOx3^xoF-IOrBUFSncuF@8u>g5V6LfwE1 zX(9|q-UavfY;QjUPa!*kFrtIE>(ossFrL3$hi$(SxE1Hq(j#1fZH8$l1s6Lt)WWPJ zH>(AOi~96|Nxx+@`*X%rqQ-imUDi@vyEPZvaERri4v_RdJOlL{+c{15$O$)3IO#bs zG>?C~o3J_{4KiR;QCYq{eeBM5e2gVDJU%_{g3@hnIu|dFW(hEU;|c?DT)>KJ!sL8k zU+#QdJrR1%s>8)0yfQg=Lpv_EJ|(<2SWGYAdc2T**1^x4`HTZj6>#MV^e!}j{rClxhxXWwC8#ZYP_ZI{E^z^(n9^IKdf}*Rl-U) z6(%MEnF9Vu(0W4j3fB`Q0Pt4z8#CUV6-P8p-ojm7dO5jh&0lIgrqb`NlQ0KC?&1ZAl)q8jevA_Nh7ekd_cNEx}K^->l7TA#K+yA;(E6RqKcfmM-Q@M% zbez7rd78U?0lYW2adhL>kk_Rb#0fQHJc zpc3`}$)mUdyheNSul$i8J~VUy5$bA)N;VM~|H^Gq`NzWyl^);!zt{h#QNR-bAQ20I zfvUm#hMyNL|9?~;-@wfOAEoc8{NsU+qJ#dgrnbmiRPO)0#mCG0_;i2f`t8u7y$=9@ zfGEpJ>w1|St>C`X-OUk3@G~&HW=K-%oRxlWg+tZ(hh<*qYu4`(($1#RuS6}_%}!bV zOHd<)RRL8vOt9A3xqJ!4w8FyFL2pUbXp%46P^xUt_)8a8`CT8z=h&xl(eiRya$Csd zu?+s64D+W?x6k36S(3XM{JYsAW81emyD)LZR6&(`KK!aOEsy{Bv>f$>sPX$5d0X}B*T00{zZ0~7`}d(I zIs)K6xYLV^J{LRcTE11N*3r`1SXd26CBDbhW5=F|mxRl}ydraZD8+?j+OU*#KVMLd za}6I-w@!22Qnk`crC*2&>6zoyjaR?F<|a_1b$qqy`$&4P(QdBRVYO2v%K#Dp&vF8@ z(YAdc;_3o$jJM7<$b2k~g7Zjc?Z5D-e@K{(;c;<=FH&_?Jwf7dmZka|T{c0zYQ;%-*jM;--Q;w6-;uk(SSJPs9;)FU zeNRtM9i3?)5(Y$0OTnkt;45p#^YxoobEZy?j^u<9kv@*os_EQOQ#Hg5)&-j!e0p!n zOyFy#2Y0doInOUps&Q_pSjn}>SbM3r)flH_K+q!NX^A%OmE03@srHWiO_6M%>6*u(Gf}r zyy-zcj3dR}_9g~XSl4_GYaTlXJgV<+aa^G~|FQ0|@6_~-+12onCq>EY9S)6YhL@nt zC%aD=6;AOn-^Q{|FI#Tw@9OR9Op)8ocH<@;*8_3Xo*teTtlg0oujdQhICbrJRxrtz z6as=w^E%QK9Db(zc=EK(8KiIp2eD7inXzw=x`;fR99P}O%&@^tp!*Ie>eQ7(w@bA= z`}5wKY&}$#7FPYzXk2UY=@JXfBU^Ce=TXP4?cFj}fS)^HYPK{4_>ZL?1J!JsFInd`|*^Z2sHP%1+g8cv?V#V@59hsHb@NAy$$|b z{qm?L!=Do4k&==ww>gLK#8U~fb8^O#df^7@nY6p@r$ZjTSXwfgzI0J~tE;QqWZ54N zmctb$?r%o8jLk%xkPZjL{~13AQt$PCY`%-F09WDE_^$% zGhM7lR2R-Zh@_*F2Tob+9Q33eLwUWF%Br+}36CDmW*5!5*7;+kDv{-mufllj&n z1M_LIgRy~u_trqt;apvep>n&+_Rv_4*oFV zc!8hwWJ-EgwLzf^?q<&okhVkf;U;L&`Fu_8LEmpO^IO-hQCY2QVJB4-)z{$um zB>K2`OGh}h82*IR2)0GM{;|FP$vCX)_6JS^->AfEVe@Ygj5$6&$)3cG)Pl#wLUyJ% zhGJ%J1zXZ0XtM^bo?gs#2QP~6w@lZ7$85Dh(F@+h_vX{3>il0vh=vPx1eNXbC%b3J zJg;Br(j!iQImK}7YMr2K-czZD0Xw($I)xm5Pk-ZT{GK0goNRn5LR$Z#^zkJ>a|8*P zRp?lGA1i;eY(eO|{(pytVBd#&$P(u_)ZE50HH!Bpz8Ph}!z6(8mu8BxMM-I;cd>e@ zw}||1(m?UayJZaa`vn3SbMiWMp7jCYb3o%?F7lkPZ-|FmNjY2$8;wgm%BP~bdu;jE z1^mu0HQ#A_7J0>fn5YDnpZgUYr(j;C+Xx4W5%`f&5Db09alhRAXCEb$Il|| zb}r93P^{rus;jF5A2#XWcwY!`aT$*T>WP@@0@r6Fa6%o=HhK&9mP~;Tq|6Wo#Ioo? z_mvh9B-vg7uic5~S?d(ZXqsSR3p-Mnss9W8Jh8737M3)9s&L_%&~&&)=hQ*vA#IQA z*!n-CqU-0kyUYCwow8_5K%k^QS5s5d*3M3@6wri|-*eU5%G})C-rinTwkJhXa$$1v z6|EULr+#8yo|MOte*KY=p5ENai!Y8JEoLe|?C(a99G5QlgH-n22T|WFchwBVmrUOVEX#(-fs6+ ztB4?;7Cy8$nWd0`kk+3cE>f8M8@Ue0E*!xrt7Vb%P|pltjC0_`NV8wir0R&y`M7rS zWVq2Os+jq6C2CaE(1fVLql|*vRV_ zwHXOaBP)+be@+EM$4rgu7BoFy{9}GIyQg1-hELHpJWvO;d_#h7Rm6) z#XGvV7yMsu&$lgt21iCX+1aDx;+VI8|NgxOhkBaA5A<$j<>cgkOTd;H$?pz&DNOy& z2U$Ij=Fc|ikT-jiMTOTN_n8gb5UEiI*m>f8>`L16rec-|Q}~`wUXkb@4|h+gNj}61 z$FO^~6l(tLxw-45bxx*LP?KmN85G7}y65S4NTt>0oTQElS_brKYyC6r_8RN_wmCf4 z{9E-Ci%(C#EjFZvg@wt>%ST}<`|K4&d>zl_BEKuBt%cUKuG%^{FmI#OOjUk<*FYk= z!PX&O;%Z@7orW&q(EA)5QGM@E`!>Y9k=uammow)>aeTg+z=w#K3?TU76exrQ0(?)NEJkvkU-VYOe{OVK_%hL|8(SE#ML)_3;4kQLG>__Y|4<-S+4P`O?FjrV z0cdYcbWy>h|Fg@YzT7e@(b~r5_974YfGLY}ASOYG0i2YXqggkuUq>mz$tyhtVT?aj z`5);FOsGr6X5CNn>dIQfdJp?zY2^_N-R_r8msVLz_m{qjSKdynz>9@FqA!jghP;?%Wd?~cSJ8< zh`8>k)&Dh8RP3*+1K;U|lMYy@sl|HP18%ZN_79@P{P7K++5LKcF|64ulZYB1Y5PL* zVd`n!3j5vNZkLcEYi|Lrj#`=<)#19|mHvr{@j54!&Gqgu&sK3(_-mvI*bTHJHAM>y zBAekH2VVixPVfIV)7)Ocr4|RHZ|h!~u(5!}>w$xdT%A84_opg+%gfEcLB_(5$+J?h zSxt%Ou|i}m^5rkKW!{Uh(Ce^uH!()mljsOm!KuXX>J+~ScG z{ZKu}dZ>Ppnj2;boQEI@`?o|4`inV{6|YxqNp_G2iYPy%Pc1evzHutH8PnHf#Hd*= z6i06U$KIf8IuN;^Q{w$9i|*0K1w8Hg!Dl%&J?(kCc(t^KxTZs_)8(S3(P)-%%HQ?J zH9d{XNT^8$Q_5#hjsfXjX6UXeO3b-@1ckQ0K-f%(DA~?+8!5!$6Ixo5?a|S-b|EZ^ zRy@ZERySeP@Y?CR59Jvt4Bhw>300MA;N-YH9;m?8_zr_v98m9Ubi*PRqr> z9OJDMmfMci8Gra!It9*h!8P%rdlH2+a2VfuQD5kx!n9cP3g3FQegz>IVqYu%6yDA1 zbW(=A_t}3gQo(BPxQJ|b;IC+*@jikwi3FzFhh8O3Y?pW9)} zp-&Z?bz(!xC2P=e-}W-{yiD5+tGLix=YIaLX|dZFa<^U4_PXh@(5!09p!8c{hlN5+ z>RmDD&|YoXd*#RE)a#Sn%)K*znl&*-r>HksT$-{Ql3vhLY_0F5Bjaimy+-?YQB;yX zhAp2F0wVg>cH)IE+0E-jUL~Yth+deW{9V-1M)N=bF%wa8SwmM>F2tM#ee?ess$ZrF zmfWu6BWWrMexZ{PshwCF;EDL;JrI%|{yQh&EJRaIE3=7d(^;!COjLA>;E6f(=B$uO zp67Poyt!ZJJGGBopZVTD`pXK4ukRfU=+Q{u7>$6tdGZ2#^N$njS{dy);NGNm5 zN7DzM%?d%gU8qOryvIU^#KVoJp7|uX1W% zO1%Dj_W)aYPU?PEv)2S}E%tDDpLcrnz0F^?SI_yG;kf4goDFxH2;9d zuh+S%HueGT}=TxELgYr_4*Nb-{t`(J;A!t^vEB`^NY zotJ5f_>K2Pb+SBD&09q}aiBlUA+|g@=9aeBVvUHo+J@4_8!{+^h>6c}-Oz77&KhE%23~pL4F_jXCK??vpwd$1Ltt0>nj#a~ZU@uM_VlcqQB?@};<1r&IxF zEV&tKwl1@cRAgm8Uhk!1hS+EruCcI6OjhGb{b<^%FVmx98vOa@q_-?xle{^|7rLUk z_03#+5$V0XU(I}pIZ*?0Z#%Dnk0V_XYc-!-e4zyY7@@z3BhRdjfHzNHXy6)?IL3D9 z89r=hxw4FCwl&dfS5y7Gw=z}9@NxLFCwZ-E&HrVLVnNMbs2E4<@^ZOAbNl+2fcv1Q zUZe%DN5H|DHx0j?e8AayPw%arPVlk5naOLP8xUmF$v;UJ0Dy5GEA0ou9pU`#bsy^PZrC+XTX`kebL_aNK=1w30<R^qw4?MPMAc>2*BVB7Gb{1Z%KuAg2(efWjT550qnQV{PN<9nQYV?JXf z%qV?F6XbExH_9z)mWfb*^E*1icW*dbiOBW`2{wwL*%p1AkI6F&4JPg#YeoITxLeCu zCXM_8^!rVuEUwx}FuLoDQKjUtY9kQjsp|v^eyL+{2 z&^1@+v{b$OBa;BiYINJ?1XuSKw% z*?uWVvl)I*$OARK51~ooK1a)Ou#qGZzor;B|E(3Wsh~|2~9!9PkCQ*{j1+)_UArZ$%L3xZDYtbN5{dV7pMBEqtn=p(D6a3}ZmvgS_5rj|&H`-E5%6ax>woIK%V8$nI;d@S)njAcRMKm6dt9=j zectbGXEbZKF801I0ZKw>Co=u!Anb{yo>LsRk0qx86Ovi*;g$T%+2n)PKbf>0-z7)= znf_6~*{9j*`tbY4CZ%}hBEjE#$aLY8va$NEQ!bc32T?Vqhi7Kux6*WT_eZRKP?Suu z?`?d(rTNcyEGWzLTlbMD9C`qy0cM|;>X4X~Ymp+4=40F+aDviz&Drbe9;i&0e62Yz>j z^7D`=a{fy!E#z%Pu||POfX9V_NI>_d2j#ftJJsr{9iCZM|!{_$n+-JC*p z%H8oiKEJi;&Y3U{a8Y%$*p-`YdN4^PW^FTQic_YCSF4Bm8@Zmjf z%+Z_gkqu06tI;)BqnAi-TWIYu=Nye=A-`4d(2$H1hgoh(r8V4JI>2Q8sG4niW42(xv~SiH$mo z=Mi_m4?0~md|!aR-W>3=0DUr|4A0oX!9iNUBLURrz7}KDdh9=Yoq3)hmkUjeAXyfY zh}){U!usDlZ(G@sK!mP(Ay>u-r667kx|m0qhk{148*P)HmZvV&>)P*Vzl6Kl%~6@$ z&%nt0kPRG6wpE!r(#mTuWlAw^Ji{ z@_UNqo9HmKX^*B2$lBdS!TC9%lT{b*YquPc%e6YXyNg4J)XfX@aHIH8jH=>u>IQ$$ z-BIcRJC6TuYoXqay0D|s5vS!5H>EyS1^7F0qH-}|RnOllWqPV~HED=N26cQ7dX^}x zH2LOZ#Hgvz!wyeJR(HCD(601ZTO2_8DEwHhX;?t+06Q`Dy~zW5z@kU9PH?}zfydN+;ky5C$z|B&c!MtBwD|;5dKKyPYGtu^ z&C35c!oo5Ex|#PyvKz6nB=ul8dlDipP~RLid@*d7$unJJT+KFaDw$+|oM-y*zFLr; zi0j?6BqxUJb=L2y&+#ED2B%e~{^Q2VJU-5AjTax@dV=oR7wrs+8UuO{eLK>2f|`@p z#HQt=jdzhQxQjzah9{`lyY_F;IaK5<&`qO)Y0JmsY@SW(e8_iq-rcqSFSxu~_j*6` zj!OzV^#04skBf^Ws(0XJ79X zu%AU@|GP)&MV)$rUC$P-0U~(jZm48!9c1c-2r{6!GJr`T;<-rO=8V&l&-F#jQnZWX zVN8e?@hhwfyLN$))F%RV9@TDrSNmu!-|`pc#B)0aPj0R3*)V2*B^Er|| z&(#t*@>lk`oaBjN9x6hrbQTRzGxlC{Al@aI$(qE0lQ6dNW!JRO9<)uxZ&Hf)*SxuI z_eZPrmA)Ov5PI%7_+Q2Fc{nHJy4O7LA)`B+e%Fva&ex3NJn|OP=*n zjCRavGWEuY%{huH>ER}J3Oe19HFYqy)vS2=PK(0&xJ|y^%A~K5b<8^Wh@Fn%)Hl~B zfEQ2uc<6-GK9^Z{n%^#NH_mT9!I?x4#kr+b9#Y+&>psA(oL+%wDqfhV)RxU4Z+Y)u zbY#`(avy7RyG-0A_s^?5uxH*ZCKnrfH)A%P7v*6t@>JL|ySA3s_?6Z&Ge@+0s$^Zz z+vO#_FX(i9kf;`7T_NI{BXMvSobqqF%Vl$L-zzsDdF4KCK@G4dsuQ=^+EO8Y zFki9+lt)fDhO}&ZNtqDI3ddnKe*zM^-44E^ zW@bvGPkQGg$i`nBU?pm^x?dxBwS+fy=K?g%f{bf}qd%Dby36x-E9zSu_N;-9DQn+j z*3&Dm?D8n-q_|tK5pk4EZe5go);~#C3b9#Uiz<1SJ%5=6X|P2|ji%`* zNuYtSbF?^5uT2-BhTu^c8n3H4XEMwIp*|F^BM?VuCt8J0(tz zcNJY#%dk{wvfY}hb{g{s&ND<6A#VJcu=H)wRIS^s-qP)sYDG18%cwK>eZa;b^+|KJ zx3}j7$F}g$Nx+*ZEV8Y*xqF_gU7lLwGiZXOy_cl(Nxa^DZb#kuV(r?`<5+*MQGXIv z?v;m#p>x?25v z#{B|$pSFW(Mj%d~vr-F~GtVx-C?^$Dn*g!bXw^9UoQ3@^cAwXw!QgL`N;YA5@ z0Z2i)Eae{F|M856Xl|9b%zWu9c&Z1f49;zv6Ov#fduV;&lC3K|9!lZS6ThQ@T{XY^ z^e}99@bQh};t&>s_*1&+L}6SEezn;TL3vv{8AnjGHtrb6$oK1zL@{VU4Q%yG%Y_!Z^FL294VjfF{-Kyctm=SzNx5+) z;!)$wFU3v%``DL7(8xxIA<#yX1{fwuO!;T1;JXW;u}txT|3!J46r>b2q=C3&CL zdtYmb#_;@Ej70FaGqu*&%2RBfTSTFUmDF$DOrD2kTKKz}w5U7i!*@q4_(3({aUn490ilvmli5%4 z`tHQ!g5P;FB7*DCJLvY@vP#0~+1Vm2`MfyT=ZvK8n%5uJ77}gJ2|8xgbASLl&1KI$ z1^NJ=sHHxx5D_SaTu7L-wb&i&0cED$(j*^dqMEQQ2R%KaTJFrP>Lh4`=NDHrKM0v3 ztob1|eR>Xpiq%i|`+7m+pc_mB0x!E-Luc!NPCe?q0%eW>)uP5BRw(iC^7)#Hr53g8 z)`>6n>>VCTJB1(4M@*&btgOjKJv~`6*6y!NQ1KksSslI5_D;7BxsX-9>UitpcBk=i zjg=%lk-R-zF%1LGManLq7y7#D!u^+oPobxY-GzLbZQ&{WlX~kqQ??U`Q@)?QZgcF% zSs^Kgi1&^Jkm3o*gGn7aoa++}kG^Izx=#)AT~h-KXIybUMyLJuyPTl`ru2_9N_345R#ryN?gaCk6jEP-7779h z%pyS^d!EqYX1B;junwM$b>943&{$7cKx%fZ+;n26B|v42?HtzF!Ji{;J7CC#^pfiI z&N824zZRf#t|p`dgH9F~)|?(@VFD@s#di0rP^)v0ugl^<)B$(d-&n!ov7EQp!G=`IcTTgT>Mi;Ib2>P$}PnEg1ObxS3&*Q3>i#}iNnY2I&utA_J0*` zRwX;7Ia$Y-r~6~}WC@SO&AfHo@@2;B$>DFgs!d}gc1JosQ~SSY2ZTHsC15yEzCWVt zOzHN{rr#xH12qQ`WtH^2vToEA+|{OM(Qq!K9sR+CBmJULn>6y&xsd4PbM}Xw*K{Ra zUida|U8^mRx-Y$2NPiBzhRG?BF!ac?Ju6b|;7|DKwWYk`6NS=frSJz%d}SLbzqkfU zlmlY_mGMygq2ox*9eKaXB(NW8Ht2M@LbAuCYW2xfsaER9XHBo_9#?OIq>P0Mx*k@a z01ZHz(#EH7(=HGDPzoW}XB2z)BACP9Es^-yxd`{p^B|8}C1k?_TT3;`Bl<*ux6S*F zrNHBK+BqkvGQs7u3PO<#Y&8FtFj*9K8Dk%PA+Q*O{ye%%duBu z6@mW_kELH@W6W_*7h?6Y#_&%&g^lR56d}4Cl+u zwpd=?%|ni9G@hmH5lKRT4ymtakt}I(hcI&6G%e7 zSg12~RpqoRGDk6horD7)N1SQxrexiy)cI@f3-7LE4h`%CtVFEW(jjukL-U24;m|eY z1hVxHKx?tto$SBQBxf&ELtI29L46}-#5g0rH~=3Tmz#=QC8iX#kDGx^21JbnO?+PsGL%%~~vCgj<=52-sA3xPI#f3BLjycy_A zQq~7df8qO@idM#Q<90dGtQ?z8MJ;h|?Z{&LRvglzKtNhlvGfY6ax4MF`R5OFZxu)`g(+FoIsn0cMa=O=nJZ+CP!nFO{kJKmb zLs#k7ygj-BSz&FgC$ZK}cK38G-?H}fBv>Rea?3Kpb-A=pja$B(kOc0(?T%5tnL~TexjN`dOs6S4{aLxW9XLSR%8PfNy=N?vw^wU^ zbjDoo&S$;45_7Nc6EKSZwg~y$?xgqjHL3YsZjTP%zu~^^F-G2HUNGQ?)f&5juZOXS z_n*Z@B_Nk{Bm&;aJVnjoXoMAAeMRDHA=lu(Z?ApW3ImoR{7O2v&`Z{`@%KrTn~D_6 zRPTc+1-Bh8f6wp;ls|cTe&*<9e)StIi=#`pXn&QBlQ6VAZnVuRn)HU*q=>EOwTOX+ zua?&BF8@@>K|Up!!>2O`_pWy`VNP|tKEi0Sw&$RPW&T{N_4HOXy{X#yNUJ0npv5dG zQ!oC8*AZbcY@|IknBpBM9T7gg>r=e_2ix|{A^W*(g$?D^j^ejv*gH@4&2`fJ zjc9l$-mfnW`(WtsezPvc>gW&Vthl4wei(5wP%7ez+98;{Wh!P(*&^F}h9x@8ZbwgL z9sMj0>vHzZm&jnam`e+BmYR&;_S7d*$wk4RFLX=R+?~u?4e~v$EQL*OYP{&*?+Vv1 zasKRRoTTP?(Eo$=^}p<}`ef4QppVPJaR@f`HssxkDM52g#H>b2Jcz=6x2FuatmxF( zh;YTYpjCe3pdVaK>rOu*94@!2q^s?KmZPW|&+hNl z_Ia&HBQrq`*J2s{{@3n_S|-KZ5?`9V)LKPJm!1p`TM1ehK6&s6gD6$!xy4Xm`ENd_#9jp={k5nHw^n2)cEev4N=p<~Aju%P{bUC^ymHViiX9z1FMK+Y376A(cWJeB%Ti8Apn=n(I}%Y5!x zfjnncUTm~Vc#Ua4nkiT)x9E_7RQ?`p?saxpD6pJFejG7CfqkS?(ZwDY77JB2Jpz*vK&|sG&BXqaw6ZqGIOZSoF>uP>5J}7sy-ZHb)Sm; z&ZcGYLV-yR*Mx`*L!;xr#Ro*=EE04zLkMYOQMNp3zZcVlXB|h?-GR58Awq7a3P-cS z8#G+`PG|!7w_p?&_Zj92@-EFyaKQIMUcnt1p=3|!`c>Ij&s*fZd6IEBu~u3!vikOZ zjGNCr02vk$2R9j#iosN7=ixay!rLgtLB%5vhO6@=&m7Zz7smoa<7gyy7kqoWzfn+A z-|v^@p|Cl;6^XfHc~Vl35lM1b&YSzj(WK7id@p(2w$(?}HMm5A9w$ggqQrMYSdPui zL{mB1m|dmdZ*%ht{@{+uhPgYE;5>^0Ld_TLvnco_3QUpR^r_b+ae!oSdQjo_o9SJL z_|yLzmOQNxyDys()>BCeVlGaa0sl&tl=pBQf_1RgBz80OHUQ0&K7TnUtsf{>2mYai z#hv~{5Nt3R(J#F+A{ic8@m$MEOeCURz4s>@5dEy)0M`EsHO!;*MgI9&kH*}YJTow~ z#b)7+aWjX)VGRrnpx_j-P?B@GbGL@)^&+L?OE1@r4hcUq1POg+c>F&Q`))w)UtB&g zkpBMwogM!FSZJ-W{NpR(RZ`~1=sP8pMIm7mb2$ee-R0)g{NG>U!1daysu&7h*8d?s zFfji8(F6egp`jmNS|s}4-;6*ZIo!v4KtBHet@?FYn1CaKBSh_ zq|#l$c(>}`pO3^KYc!cc(CqESlbU|9--WI5@&4P2c~u|=^2g_9O7EHgufDaIFBM#S z)c+kGt(5JD<&fcm*v9{S(VLKwE#NDe=soyMmLY0s9-_bZWX_{#%s0#b9f54R0XI2m zW!yB`@2W)1pNF}1V;_FV2z}qLF9?zy>vRb%KC01-m>d=o)Y#-=%KLV%aUp&|ws1M2 zTbGWIrEKl+sa+7R6n?Ve@=PQ6P8|1~4@()YQ1XQ*_rx|ho1=xo<&Dz}H5tGx^1XkI zt)J|aq6Ap?HbHWFbNJc=6`hCA`usIJe4#a4j7zu~rqM5!cSWwtTWdKJPWpsPq$<1O zsYKOhCD-5f6x#*)zn9lOnt6jiH0UQE&;DKVdzEN!cjRHmSuO;Fi0u6ug}#ZAV8n=Op|@E)QS^2=YEe2PqoTqR$NhV z`Kng(CE0u8p%V?T?7>8-G>~F{b#&MmP%v{L{9WPzvHps^fuy?Pfg?R&;dwI#Kyze$wxhS1(P})87=d={#Qy_Xf&lj3Ir(JME?N#z1$(~W4klZ%*brb0^R7n*hyMy=B4WfyOJa|Cj&pTwt~XQSZt zXJE~Ox#B}1uFrN)gPYn%W-uRQTC8GC?9y8r4&KD@kB=B3Ie(`!-qCXxPLr3-tNLrW zNA=4Ghh@EN`P?x(^Kn)|*I3G|Zc=yg_@~lSBY)2d>(r0m(2H3vxeJ2@ssqG>&-;C7$b+sFF@FAsUhxtZ4kiKP57FYRG ze{JiBVSj>4!3^G4g<6;+N@i_$PB`eWG~ZrClQ-b1#$ienDNfxuHZiNFH8^^B zubx2WplXIjPW<10xGR4+dN$zt@M*$_p>ojbv;;dP>CQeqT)WBVnv{2oU^Ej1&kYy=20*Ed^ z4S4nM6Ma@?<&hhWZIuv0W_;1o@>`%`C!!$GZF*@{!q0{16HS?=zGsU3Og5F=II*M0 z=TMv>v~$gf8`?DJg|g3E9M(tAF4b`F-IBlR1msR@vluqr#WkhUy+0@H*s|X=(im|k z^}6!gbA?S2wsEP? zB3JU6-9vv_?9Kf3xsD2tnUYK6d_uH6zZ9*9+0a+@5`n!T6!!LG&Nrz&^XbUQfCY&! zdI;?K!SC~`EU!{NFI0-^A|F7Xr6KjT9i{zCQJpWgPQIKwXh7C%e3F$E7z9;>DJ0xC z76~1M8|wm0vBp0y+=MYxUHuZXYPvzfHpEI4nP1?v{KQ-o)eG>|r;DdLZvLy*y8=yD zTf3H+)XaNXdL5jN1JP$z;9pHf`|4T`(gTN~ap|)iku*SmUCd^2T zUr{KBaY{mu@o-PgD~C(OkYuMmT~z$@$CgNzP1oNS?43R?o)_vL(?siH2L1er)7_OT z{xhgS%wxn|ZEV-?q=*{Jkt|TeZS)d**WU3TU^#GA5F`twcK#&lK8$XdYZQk(CvC#g zab#}fSUWgemKcj2S4ki*zU%JX#l#!^SZ#GU{mH`lCpjzJQM>hdZwBsBsBg11f2G5f zdo`ar*3)@@Il)&AA|QlKlTo`P*yN3R5%Co`T$z$Qx&W6+a$Q;RGUkV|97T?}y`Z`z zfuvFZ5+rV&kbg==BEusVrTA84PGh0k2G`%ULDZ8~foMQXnoN!lys8QSFeU_8<}eOB zeqC#5pGh9QPqv`Dy1{-{`X7n79PWgsv(|&U+l-0N0~6QJ!1a#B0`%t;)NCq-)-1^b zk_^e!8mle`I%44}W&UJMjfHtj`*f>1&oB2heI|`(0HgHyosx0x*N)QXrQT+pc}qq@ zTJ)^TAayJU*znwnNX$TVQWP|u-Ujk{)>WQ*LVUc&sx;#zHA+Qp7c-*vYgBk8#3*o9 z{vC=462C!gI0t9j^^b|mb{ITM%aZ%}?B|6c0r97;POoVKe>8x?>&52bnJpEGx}RPZ zAJki=fj;O$iTJdS-DuqGKbNsu>UB`*BC4WcPxM?qx=}7H4{O?0vW(wJB8lhxbvx7g zF`a=gT`1Dpcfd0k!(qcqJ&I8UF*$}YW0hq>JxhO{G}3$Cu-hmAdCu;!B(Ymqz#2;E zbsiu};#H#NjyBJs*C2d3tf6sM_Qxvz*;c4dsdgHWt@S-VZpya3mtY+*a}_KB2Y(Ls zm~7Z-@BuRh^*;^kIEFg8Hoz7uC46JDq0+dSelPtJeZ+1gE#bPHiXZPk{LIVf3(gJM z7o1$?_4uM%h09%@CkzODE_Zu=`CpY&+Qa3U{Z<#|-97b7R8LI@`BZx`Dh>jJ_Fk|j zzGZN+Nq&8|QC+z``cX8jL=0KX^C_%yaK~VCNi!s&>~rMdXzlUWFL(flw?ldD(W4(v z(q86F^-J^yEubdsu%gTCP(p*%APB#^Jn{Rf@6DRQ5OgH`5`a>v&RJ7T>r|l*mHHJ|O*$@^;u( zn}^28e18Z}Y@;>1&0}+T7G8sU=NF+ zcdXWDsZkJ+)%8Cl;wcJCce(WE18!er;WJ9A_|`nnOFS|ro7KV>Y=wIyhHd_;9AocO;VRH4M_zBO)JHe4`+`|gb#)qTAmwv; z#XCb1AILprj=It+MNUMJ#7aLltV2C*nk~wRyEt8lT**(A(?wT)!LQLiM|ZYag<4De@qTA&C+w>cS8#C+x+TYmekk9*t)0W9}LKdOMr~6?EA%pJG=j(pidbX^s1ma^nE!dl+ylTsX!6KBN6qq?l z_dUv^E44^yk^T!|los>~E-~u#s(+1M{!-FU|2w+#cF4J=sr7k0ey5yz43NdYUEGp* z*#tkVuek6fU#FMSi*`jx@n1MPN;d^+rEQxc~U$w(tFd z`CGvmIb!SmL_`H8#KdAA{H<)n>w?y;m#5r7%&Ti1Yzn}+uc0`A9s>3Mv{!n#*D?=M zbx<%lStF&Quu~fwyE%UeHla6P6&73Pq!LNll#{eJ85#PLA@j5lU0m(KPDnY+C@B~I|L-1)>pK*g`ysk1a_`Mh)ErlkeL zmh{A<3&Z;s-=0N#t9ttoJSr15+aBGJpb>B|?|Snoom9vM{EWI$ z+1^+(k6ujRt7_z=%zRUc9j!k-pCPNU#95ghp*yGXRo5JHM~v{dUlTG;bFsZwrGQuD zcoN_7Yf(8ZK;fdx@gIK7Oli-QC7Ig?Dy$daPp&F@cM4o}6wDk9&Td(CzaBtHxpNLG zWj&Xs7zf=yAc~HHBqKGA(#>Nfjc+?;nfQ~Q`Y-A-3FGGn{LlaEBHH92VY5H@Q&C7+ zjS}^m3FxNwTSZ6BIw9GZSb7;xG@)MHHyXi!%2(?|n-w*)s?^!mq;Gmn|Lop8eV2W8Vp&qu^&s0A{Gsu`-ZJ?ll=;a~Wm zH3m}_nK$Th=4qiES=5UGry+Ea|7SDr$_fM99vrr|i&8eyt8~Z+k)e3Acvt&AW%rZeUlMj5X+apr{x=KuYPRKni ziS&~?F$Zr-%2x&9UkCc-KVA9;;p69HKCTZLzRFDMM)9Ew@RHc%^;u}De(?xM!v zP#ha==B4h7FYY8$vn9Q%yHpy@aS2hD3DadtlYAEKtee#p>bc|pz@L=eca&UeLL=Lj znWj8aS3U5*Q&GW^NX;asm(>071!o6(jT>><7Il{2%bS|MJQ7=~CJoIsaslGN3H~KW< zWn-A>C0Rc;aIZO5&-`&#ExpUs_zYbC+IrT6~dkVT!=SV27b7_Ikh0)7*( z&Djt{Sr;aHX^GCrhra%0JPop3x=Z~f4$#eVZ*S9Bt&^25(*$yrY$c<#y3U!==5o)I&9TK=ihs zciE+EqlH#^55@X?CSi_Q5M$FrYYwaSSRtoj6kIj% zXaCJ`Z?H_Wb9-=l?jcs!haZLFS|A;5A@T;XGFVn8+tmVUi+*5`q7gyo=w>Nm9|A`) z0%@jwJMW|LU2wm<$E#raY|ILTNfvvk-~6igo$467Ri(5hPVuX(&+1%dZEa3d+G}>=;;1P2sCbz^ky3f0Sq&L( z2wEZLUR|jxmZ6;1|3}(eM%B@^NyCH?+&#FvTY|g0y9U?b4gmte-Q8V+I|O%k4;CDP z2hH1u-1E%LqqDy6{9-Nobno5Wr@OAIx@wOU$D2q_*e2I=M7A%aG7>;%dv?_qX$))1 zet;mi{&+&~K(W%0UpqiPlL#K*-Kb7fDe3IDLHe<3SRQ5W&=wYF11@EF8Dpt*Z~8eR zQ~fHT9sANsBq69*M>|o)Tjp5KQNL8G1M57&aN_5o9I+?c3V9LxP~M7QbX1~#W%j^C zH2d0$dOL|#y@L_?lbE(;CZ~ulC`aM@>yc!MLFszq5Lo{w8A=UhdQ8QxNp@D+;oS}Q z3%K#j5h__|eS}P85Fg~!@2uK_Z z<;jO-#KHoeB34GfwzF&8BcR380<7!3RU5dyY<`JNC4;#!)(x)BoT+O->pX*v$(#vh z(dv5&LdA<5=dXwT{+6|+C}&tUO=0b`dn!o~4hDQTs+lD!E=dJiaS{c5jfGQ*beh90 zM;tU&nM?^T+;rtbliSG$vJw zHp}rTyL8KCkut#CiLM;>kz6ebHMShgS+f^wBWu!J&4xR_o9ZfIJaAIdL$oG5Z#~%l z{0t6U$f7vKy&{Q7RUz-7qj z4+HQOf<|^X-P#cDo_#5Z zU_qW2mnR4GyCZX`u<(dS$Bg4KV@1H`5e`(BKeg=`8dlnKW=^S+uWT3HvUClo<#Nw) zJxW6`h=#>uo9Mv0U#-AgW*5BTa!WdvW+`?le3u^@>kAN@v4=$0m$UL{yktT_Yu#U< zel4rtW1?~-FSQ6F*kx~^lRvu4#LkIBiI;Xg2ZR!K7R(p%l1>NpU9gDiPC5tvmH7wrx_GXuKCc!bFGSR96J3?S(>!PUA$T5nHFp-Z;44(}>wS7-; zX6J*xQ_E|2bLXDSTrIxA99N+2Ub;dxh|>%$tGP&pLZQpPVFjoaS^-?`~0&gRdg zl-We+H%2 zITAGtz+1$oxbJTF#5mXyohN%fF`%h%?VSF+l`b~-sOU3Aj5eHKnO@s(@iUnmbX!2y ze#hbInx@xl(?EZvf=I|mC*{|4A$V8B$mTu(sh3;W#~;V1o5>6V3B!e+Km3DWPa&p+ zb`0K)ivsvIHo<>aIf&kH$gtaqg-7(~&+D?x_pKbHD%j!syxYeG7w9sTC-aufjJUve zz;fR}CjkDriAG**Rz@L88sp8Wm@`&EvkSr#9qf!L8PJaGw13(#wZ z7$HR>o4!eg3@PIzDK(7|-|iqX6#pGJ9|eUF0mKWU3P59t`JVVsD-FOx1v>EmNrnOC z)_^|CA3NVn-rVEbh5m)E(eeh){TH4vk?B7*_yDR8XrmzPzy1L8pNTRj=3(KY;1Z%t z1pN!lAo;+mj>+XTboBa&Kr`uXaur(fMZN*+kxp{tVrAD`v^XJULzk13-qo(K= zPX{BNs*fAM$$VH7pHC_UnabtcRGuz3IB)SEtcu*wL8AOQ*a+@atLt$F60N6 zUg33jmqa@eT7XjZZ?r9J)T!>Bx`zm*wP#@C5ZIE+-117BLoa)atbSBjpLSoM6r+vU zF0inWV*ETsrnZ=k$Qo{{*vLR1QJ#GzD&t}|y~Z!7#!+w%HDB-+sN+k0qQuwQ35NUU zaNj15b69iFt}|eIHETNW|LPFvDZ7x-b$LV2hK{2Qt6MG?OT*$UWZGPO_#&FMkMZR} z&0I36;JOl43b>1us2*v z1z|9-cc=MaFj&HqXxy`Uo?Awy`X3}cpLBK^lnRv@tFeK?-6FPT{4*PYP;@kr4UJ~t zy<4t5&IU`FKDAwJWrgLDJZry~OqqV=V_ETLOvv<^peL^eo6tMHoXCagh~nJf&BE(% zUGuED<&szorqd@*ZI_yMf^W9D)NCY}Cu3`eQ!FQEQ12d-%iwTYLp-#d#fr5iUJo0T z6%Ei%_MEDx&-h|2nU<6@yi<%tb;Ms1{c#eE1)2?vs&Y~5l$s3(Vr13+( z9fzIalGc;?$3id-LP&E1U=hJy%b4fT4Wx#d*BZ*)w3m2n?O_0s8Q{d~Q>LwTRQZlqlVXOvo*$G$*~c z163zWQ5N;C5d$ zPf|#JNi!r!l9bZg{P z!LR9KcJA(b+6;^Hck?NA;Y*anOa1E?`3crJW4A`TwLRS-WMwMfvk%w=iEQjuX?Zj| zdNVUEa+c)sRbsOC>f%G>OMLQ#pCNAg^JYjF6u)^0u>pdxG&qdIqrFYzaxEU6HPKbG zr;U<5l!_`+$d@A!+ZKMnAOK~O?)^DLJw%N1yz~>&{m1oV+pJff7^IkDQxV%9KY>j%6ktt-D8cE>7 z+;3H`%P+qnEnhS7QOMC=JKxbxb+ro<7V>ntHW8 z@pl&`n^=h(c40N(;^ujgSevLMhi9&b+S2q9*RrEq?3tK-qQ5wJU1QeRpL4 zy{};E67|M!7ysP8#~CA`s3=4b22Sf%okMcljBKiooB;mkozg*g8QD4zZv=2h{GO-H z!$}EyduEx*9-0C;PC&2A>HB%We3M67`{jN)9mk78~#ze{?wf)tnf64!tXM@du) zRs7NgeAC%|oppriYCrkR(oBE+wYMK{u|6{}$5lP2Uo5zO$STFz(D_|xZ7XcHIgG!U zzyvc~RrZh**nG0BLedJSQi7qOtO{yN;vnX(M1~#pE3c9l#Ceh&8ZQopy{tYDtS!wB z6qZjoMmKGG5jO557Z~}g08T?d<&eNbX=al|_qJD?yP(6F)^pXrpSP>iw5+%r&KG#= z!f7#q*gYO{?$L-*wp;2v{FP87ddJT?=ve1g8K+L=EOVu^mFmY z6kH>RyUN!+jk5fo3M;jk#Lz{*O@3^9YRfY#CX&3w9Fss1)gP8V*`lxfjF4UuzgG1r z$Iulli<}QSnVfxUZxQE7?C?Iq`L8R*yp^($ROzgtQ4q@4*dIfqR8;El81A5UUM%=L$uV(KeXc+X=nzuArwPWH0w2f(2rjp9?i$Vx#oq{Cfm~S~B1+`*tEo$wJIO zb|KG$_Wdfn>u-_=WXM{#Oernyu=?0i##-;kz!7I2UYI6OvXc@~rI*6<0i5i5wO>-P z#rZ_Oe3F@rzjjs5q{N<%azCev@u3v!YrGra0)zEvsV8Bpw|y8u)cbx}Sh@qo>!G!;a)gX9k<2vk1VP7zLlPpb*bAeT#ffZmd(scOj5(}cY zuyY}SphiRbeRIEkOB<*5p99hZJVj#&QITvLtUc-3%-R^M9)LCJsQbP}r)088%K;*_ z55x!d-~nZZoPO?`oZ2TP$IF6k`ZdMsZPS5)UXj6oY|wAb;Nt}befW;zIFmqk9)(N_ zr}vWoTR5|IKZTe7LjSE0_}7-Lzik5evCKW6BHoFDN-D6R){v=fw^z5?pFUk}`@9f= zOugU#`~ijxh?k&^{)hAHZ@c-&Be53yH}H*Tdz|c4Pv8^ka;~q>El=SSFw;<29#6kH z|KaZXIqW67z~E;Wd@0l9GA?dIyVKP{K!qy(JBeZeOD=9(j>bA}#Fk9AlKCm8j4DvB zCYUfJaCSm&wDu;D>Ilw|!`8XDZW0K+D{n$IKqv1L@hiX{{B0@7=F9R*pFiWfGDQ3h zS2en;LLTKLT|pobvOiu3t4z760oR$A=Jmov(FlNaTSgtKv-hj*)eS@C$m7~+ItQ)P z8w7?gl=l7mB~LYM zdz{FQsgmXl0O#{xHd{10y79{Tma$~Y)xyKjM4y1`_X(hTWtdlL@!EzA$~bTvZy%OT zsen7_*^NrT#YJ1VM;%>_itOZNQGqfOmj!o?27X)ydgF@31tH(IoFf$Vc+&gWm_u8mI#KXSVB$x|U%sm^mI<&pM;t8y_)q;@;)%89RW$8 zMqZp%6ME1N1~6n|G|aSXh^4}+kzcIGG&JNQqjRiUkVd^nckkv^v~5ZBnQVw(jb=A{ z03&De2Z$T;5iK;@qXlE!boS#5stM@q14#J0xkC2zX|11g-(g;XlzuZEb!|~a*eL8> z&RY~13{>A(JbKAE0=B;KLiTr-e676%)BPJq09Gwx4@r1&HSKzzE!#2-yI4zZO1I}S zdpN)9tUG&~x3FALQQk7THOhLK$YvE&6dIiA0uJFem4R2=mUN$fh}yi7XDF{&(N_qI z@m|@!5s!b8Qp&{IcX+cPDONZ()+S=@YPr+@^V^6wkklhnx^dE(GD!9B#jiBu0a7tu z*jXzpc2WAHhWVhOuEqprP5S(p7Y1PMa=A+jo~{~aj*k!e6To>Hja4v z7LY zYd{X$rhw>(y&BidmR)&mNqpPH5TzeS63iFTn#l$`X1g`DoxOq^YhNg_EbTnD8S-ho zjo5M6gA~lv6A>xnZ8_-_^Sq;XTs!gxcEFQ477v5$2bV-zCaJcp-hL5UZ~dC(ghTvA z57C##1&ZBWDD14AJ;{c4HtXzZX?)F7;d<-cYarZEav0Scy09LzWO-=*quLw}4dAPD_$>U7gsC zWoKXvyV$-(^_Z=ZgA)T>2;RS1Ereo(!i|+62;kmY)AdQ9?5jeoM{N;LHi3M|kkMS) ze&qPrQssW*;Vb}BiWY_QcnTj3o-z_NaT3{q_ong`Hi%Ba=TF4qT4AtN1`pBz2+lU( z=`W8eN?)jy`k6AdJCbgwd*(h&7H~-pC%AE~Hx9fv0Fp8-l-oy1?j$FRU^ov8>qa!` zUwkpDDgv!I@0Zp08IwZveqk*M3SRKd8n~GfGy8QY0Yk!`1-JMK!I%#SLVQ2~XVc>L z*|q#f;mS=0PScWPB2|1QWM1JnsNy0FvZ$i^>8kZSszG%|Yc|@-%y78a9_}5$!RfE` zpoRqqaqNsu?tMZnr2V=WG=?$0qmQ?{>w}9rA3AZ@hkQkM z3Iu2DC$TiZ&zDG8P$K1bL*Ri&a~2JA)d0gbUF_naQ=H8Tps*R>x&BEzEV4kQl65)- zBje&%&pHI~DA59_sB^~|wJK#ZJa6YvvWT=+A=RE|wNZRZN#%~xN}Wb7n^U*yx7djP z6vFJ=@a0`7wYr7T8VYBH+;E-6FsZNL^qE`OSg+?;GB*UvMeh7F;4&K`#@1^$N{tC6 zV4^Z(i^frfaw1XUN=T5g9lQ|72)FFG#Vb#n))tKS1_5^;>F8KzYvd0=sq|5* zzLb|WdIg#HZ_vz20gv+StPo1dS3ZQ=9q5xC(A%78$H_S)#2iQv?1IzTxW_c=zja)7 z*!hL6=x=EFcg~Ffp?l0Ul{#@JohvgXkc}MsS%}N_l~~O`r#o>-dIg2DTHh4~uT9eb zlC%IOV_akR=8nA>yvCpaU5E{P+Cq^S+Hyj>47{MIX zcz=lq*iV3u@M3f@W_WF(lq`emO6R!Z5}9mTU-uhS32UYiKVh%s7KEeeEy*GCWr1y& z|=tMB=>`a6ZcOMQdD~5 z(f6u14!fFTGGr|oZz*p(M>)2Aay@l1O{jKbDhN{~K;LBQ{WUCds9hKROJKfTS!Agv z)8e1JY2h7cDe=NgNEVIH}=r(G@jclTQ3B`h@l7lDMiddca!It022 zs`qgpC?&QdXx+O}$iEOeiyt!7%H9|Po+04VqaF=p zYG11#@~B8xUt*#()VLQMBttW?DHFkkvsn51Cmav)$c%~XC9cAIzi)#A?E%}DnZ&AH z&H$C!?Jo!px-Pd6yNF1`Rpu6zmxt0qr)9K`li79NM0%4 zcyWcj+W%^)q)lB=?Ke_t?)L_)-~1f?I;Qnq?z-EgIERd3JS%XtZ-Xd@oG}FYd}aKu zYlmFtH(`QfArOr?FYz*;Vo2*8N!al`_Il@RtC8zY%P7}5Kfgd|FoS4ZR9CZr6|ld= zaB=eo5WxxD<-h(B@`h`J*?8kMe*C{6-KIC#<|h#dD|%e_S6%a^iMV9IVgVWW@6xoF z@u749KKjVKWn3Llg#aWA7~wvPcvf8QL1{&~28-JLALMavT1*dR0K!#f1F-XhR8H93 zloSS_j^on-rHR~<>4s`_-VhxY9PC{G0qmCQAowD?dt!C;Mr7~hwZo&Ty0NF-5>l0L zY?Nkw-gE4`g69EHotO=H#CUwppZ92K11V!43n~Zh;_laiHg)Cv6*X3RyKH^RqXma$O5g7Z+ynLjl5Jl)Q;sCdq4s?0oDaBYy?iy&L4doJ_(%&DDD0qb@j#<4}fXMjXSoFb0($@bQNdxI0m=S0T)UvHi%cW9!OO8VV{goAzyN>)z@CW87x;|K^&B4s@RO@2K8|-7WOF(Qa8p?V7dn^JZ0j{_KH%y}XjT z6~h?#hWk^c=BG7UGrg&9kA?(ra+Y&fiSUKU{rlMc#&aG;@*mUn<%zaBNq?g~v+DlP zo~21&yjnTKZgN2j2oOnxG&`@AS7nw`(Z|qPCGda)z_;)b&3c|(wR&S)Y`XvJbe8o7 zLZ-rtPoSnC4lCERe}y3J_h?NqRmU+RMlc){jTR7Rnu6*3Aw!Zj(Hm6+647Ex%RHcE zk&OL)nN>zfuBdeDp8q4+zN3}Oko3^S?oYrjKjuPG5cR7?x%kHh0m4o$-wg#BYscYiXJgWws!&L#10AQ8bKjsPF07iv3^Vw1>|xf zRqi1%4^A?>$`duuMBzyJ{VoajJ0tmv5F^|qMmMs`A;}++nKg3y#eds?WpOi9#e?mfL{OI}ue<5HDpH`GDq zTo|_=O(XT(9H}ZjEErofc681*uXj5ve&LZAzyHBbZyOUFw`}r(*gaRDjoj2Dv5CxT zVjP-cj)=jH3V>|u2Zm0re^Ha!Q$P5ol8vtCJkDF>#Ipbzl+q1Uk!!UwO;rQ2?K{xeBGoBS&VmYTE*j*$As14D?~$y7aMu^f{QK8x^hlJ6q~v6c{)|# z{)dA%2-P0@J^LWh@u!IAwN=;+#C!CQM7TVl{hJO%?FNoFgssGXB31+By0fOG^EeU3 zFc2d*<>k>GLmna-9V%ODA@J5LLD}18oqwKjO4l?-O3K^EV}H&&Q@3XdFHOKrSE^{? znmyQy%(1%d*!h)S?b4dMAAT$@zPR4W@kjym7z4_+CI~TtP1%pWicGm8{!ik%S(}@T ze=mu(RR@coe9&4Adt+lhPwHI}yj}5M`Z~)y8^v9?=7zM2dXnobj>27e-M$|Lnp_9k ztE6~1uw(9gsl#-HLz=Yw!bUE;ce3PpIJyZpX zeLDiIa6w2GcpvRImXu+Jqlls~vEkYAp8>{jiRm^`Rwa?Cq`yGwYvJx)K)iyKRhX`Z z@dZz24@O!vk(9mSY!K^o|NSq>wxGzC!WXTbKxwprbof~F4e{O&WaZYoa&22OmM638IJb8K6A$VW_Y_>)VkZK=B z@@aUp=Zh#cvN|8t@2fzHv&C=Hvvt4Bri(^cDY||F)MNf-6ZJM8z^)Xeyh8K@cJfIu zuS{A-r1phfn`{KjVY0PoSw}rPTSL$5v|<$sG^Ao)NHk$g*!$va)2J3^u?Bp};613x zkL6$bgPGcrL-Ca$TRWYFbDG}|piFaS0uQF|H$oJs=5P#XL&9bc1wVdB4`{dK84Zj@ zMumh#LkWW3uiw6ZmLY30`TtFz{TK7q(6MGmOvgfDc~#%gfLIORGjU|sMh(Q$0%&km zHk@DpPVZKGU%SqL%|;?kq4D?buwyQGP{!Z%_~b5o*9OV31!EJlnNBEF(HCwE3|{Fq zGQEh1_`ugrXvIwqE~C-KVCZ`+J~0(wmcS&4Fz(F_FN`h$Bo@Pexiysg0)oMUi2k@4 z0W(055^zX610mJ^X0Ey#^`_1c-Z^qh5+i#b>8U23 zVwiSuHWH@VHti_%!!#R0%j?aj(g!JgeqGf|!t z$>I48eOEwANvW`5t6yX6`e1w-T{U$~$m-u8NLAIhB))x9DcTedKos0 zF2%qi5WgI14=2yP+uwNC{G%y=#nog|XC>mvy(OGL#Op_rqRORGy`@tfL3K-;>W z8fn^z3HKqE#K@z}Od3y-;l_9O{>tt~#y~ zkU57@n0%rcY1IvYH-`o4_Y!bx zV=GA%8-V%T4dU(LTO7$EO4YNnIu8QkXbh{9DSp zC{q_i23VVB62D2$G{2_LEjCdZuE{rhH>!m@ux>Smg#Zb+<;p!|1B?5nZw3nQD4u&%c#jC#J%q@}}O`gt7k-N3npoy{=lIrc$ki zUE+~6^G9A)-d@+t8A|I;9mSCP?Z{f0xr-Co4rc*sZJT!m@3eZnW{&lji3;8(`JKYTb~YsuA~-mem6&A%cJ^Gxaz@ zR(Xcw=lOt+*D_ZW87b1mWWbO`lt(3-bH_djQP;q)!l>OT1f1DM!{9&u`hc?p@jBMZ zvWi@)K=E)`EYZl%up#`Ck%{^Lt$ zCy|qpQ&uO_YHGTs_CHeGkFx43l->74Ni7h{mWO?&Fx&n#q$;aeO#%GstXehuU^O|q z$>oQcW15__gyCP?!(C}ot@xPpCW@)!LV@s-R}Hf(rL1i|*iZc}{on!dyZe>I2;Tgj zb%1Mgdf6k*?=z;PDo4wtxpaf}-CHZFI^ZERL|}3i2qJG+09MX`Oq%iJltDF>3-BrC ziroD!xLNxS6PSZS|MMzODkO^3fW@s)aRTwPV}jkBWPgHnK>{=3NmVPI?97N^|A92~ z+vAuz7-th7D24@9l}yZS%*779N_e(ypM1`x=^;2p)@_@pF<($F8vkflUA$e-R?5Y+!#ZkU6>DLe$ntB37P ze4`Yu2i#BC$mN<_r*mf~Ny}rk0E?Xyj48L^_466(>WuNaB6ilJEtOG?ut@sa*AS`w zx8RsXi^|x7S7*OnW-CV``c9$cv8SAtQ^SQxHEfA-57H`HMP@Vozn?2o`QSec&k+;;J-C%2os06-(+MCg9;(DisFMaQ>`$bK#oFV zI~Z)#yDgT;*n7ed&Pp2=kD`Kyiz_(%kkjS_deg#7^SJ1mohg>uea#u@ye*nh?>|IM_Dk{>dP z+eF92gwEDdRc}`>;b+`EDaSjnnX^28BJv?tMVN#(>={i|m!V31P`Jh9bX_t~G@oYZ zF=}_;Ig0P9$yN{oM-~{R0Fy{D^5QR%H?I>N$h|4a_w(B+gVV1tpD zA>SE{)$Zw|5SE(gX!u0_Vr0ETU^2HvkeA%j$=4->UQQtjB2mcH3|a^JvfZSj7HU0m zKeU!*_%I?txH@+(@ZJ+crg}nOJpw06AbbC(2?scFv4S9q1W;Q5eL-3i8L$a6V+*}v zP&i|B4n<^wgJc7A31_uAu-L(wIp86rBuNw@xs2nbT0Ykqb>eF!f*{l!qM3Q~rSKSv zX+K5oRX+UHflYedA8r{Q#4W$*-4%3y^loUWja&i*>zg=4mCTfA%B7ncJdqo^+d3hq z+}BZpb63~%T4NVoGefCu518(adDyup*GBAD4dVRf`J4DHlRU+loYKJHC)F`hB-Ki? znSUulf%@s@8_jbL29I)pB?01LoDG6g|C1T^qZ1dAWc~qQn16kcvmFqi3G^s_KIHIe z1=C-I7n<`b2TQ{n`q0Z-#i)Dq^{W(yw`~NeYQCK6u3NYRCM!3L(=!SA-50*FUjEWA zZKx3-SRNoxHExlAi8FOSO4p)!U+}HS7^5}&694+q$1n~nrak&wHgEyNayhDeU{aNK znWaJX*A-O8_s?wjJ6S#y-;O-~TPOdwt%2~=7)xAMq1-t3Ht&FV2=gM4Tl~{X@qdGM zA?D$?27kvK3ny8`$!^^S=g?eSD($We0N?rc5m7||1Xk0{X{Quw zZ;>Dsla$7Q>V@<<$87;vAo5*4U?EO0rgCC5n7TJf|CS8~K>aGqrXpJ5XnKcrS9l=n znLsh{T`;E4|Fy>BKZ!p1`(+^idy~^fuw^~pZCOQ-u={D#*68ZJ-p`f|z}G)HAJtk5 z`rUs+4*2s2n83&XLi+z0fbx%=;Al4N^8NdOL%?v#=j!FO>*lF$CGP6hTbx{6EsfQi zwzr1DpavTHr!FYg;%)&eJL|=p>8T>52DSQCU{R)$gX5;9)#=ms`yN{bTH-U#9XOz^ z;ok;h5|J%iW$^P)dbA1Cc^vI8s{33uFVh;mtRWHv0kp=0o8dO#TiRj4b*z?iIeBep zR!^q=Paqe&vur!-K4NSI5n&r@Q|n8^GK3Nz_9oDB+v&|Yjq$7FRGtw4&xP)gT^X#( zW$DJ8w43m^AxiR@&PCpb5(Gi&rc3VrpUu zJ5)GwKaCRf-^F&*j}&n&5vVS&Q40xsLC7MY5~*ZI)EE+BvX zO8q~fwJ{^t#cZV*n+D1iyz;eG+_`J(C`cn!pU~nT>PMWaNI?%5wF7}(C(>)fdf|8M zxuMJ&HSjm^`sy_Y39kjMv#bZKlhWt&^(v{TzVucmVbN46UeoD+>AhZ!=?}>@BW)Er z5FoN@nTQ$~Ixg9ho{804)*#YUr_G=*HM6+=cEvMDz$h|DoX3R=yqrsI(sq8)c!yQA z_$mVD^Bb5!XD!UUN|>k$Q{737X3pcc7<~b)9%>u-h>ddvP?!wRfAg1XGSiVTMuGU8 za%d`+?LbiZ*jmdm??%d3PmJJFXF;4YBQF76Ap zk0}^kuTf^-P1hZ$?_pb(EuK%AVVHzH!-$u%cRgsPLLJ-*4ZgDo>UEVttl<)lJQ}{N zP#VW^jr!sv+tAgqvZn~T+7z5u>gDg1>6(|uT3PR^(sFvsrAv)E2O{z#3=2AgI)IiI z&iCd!OpvcinWv$}U&cV}5bd^}?^X zajjtYgOp_%Gi~(ZFdxw_b%~9*a*$ZpS*f_8`+}D>84z=E(U-Y{*2iIsoV14qYUYV6 zB>$GwPmZJ1#~cUQ-r6~+a{SeeZ)8Id_65>)5_xXMI7EfJQq{j ztdqrjMeNc0*G5Vs7X7S0IW1Q<>)*@e^!Ar#D_(eDZ?E_^kYCt*0b=Utt7#46Q1)_4 zCfkSCg4(&I0r_JJjOFd82~j)Obo1u(TkN*PU#nr;31cbmMU{dO(>Rd4t4xiL>D=UIV9wyheV!ur)hS1KC%4O-Oto%2aOkU~$8M$Rd zDk=##CW5*o4q<_Eftl|ho1x1-fsU2@I$G|5#@s9rpgZZ;m6?mh=S@Q%@l(74eX^&B zWD$khzBt`t)8l^=)DkI;4ewWHs6n#x>jN#IEZhS^VHorx6udu+EuQnCs~6`yHdQ{X z#oR{CvUAkyBrp<1rCnb;A5EX4N;4ggMq>FH{bT$^pNdr6&)!i^ApPQ;QeV01g^~=g z9i;d%4U;fT_Z%y4eyNzDn>W`xD^#@_HtHD)tibrU7z~X(PGfLxvUeV9?aOaVrBMXi z*#OR&@+kPHj~db|ynI8$8Wr#IJsPbw5n|p=VAKIZLnXlFB5>!Qd3({QSZ<^KOD!>Uw!B*DYKTbF&U zk(pIIQh6q>u6(D_S!?XV=7VsPVEM~6Adj9Aox}f>?AKX$G5VQD5?Gws} zxbvl!rNeSdLcesvg!=6HZndL&`NKUtm#EUnK&$@Kcakau|EV@&n^LN>y14{zyto*O z=G$4UD|55V<<7DTfInyne_J#R)Vx==Jw2=cnihVw%H`xSUs^HTR_9d6X;GEcItYv{ z{JpNO5nfj$KDV16TpE{Z9{GA%uc*F!^7~Nho7vU}z7`^yW_#ASy|pF#QXr8)zr%i0 zNW`C+Pbrop&nasm^WvR%Vd3SqYIl7r=Gyt)^Y7(bL|r27+^E6U15%GV<|IC1+*XIu zL|f(A9weWiuN7f?lMft8^W^L2brky|GL5cWpQhO|qD;Y>`i#yp6n|%|#dPY7U3?$@ z?YgXA@jGrtTMqOlmY80nPqjbm{LRPs5h!aYD1GOU-vvRyQI@S+1HCEeZFz4bTUr|&JQsLk(Vo6E$JhoxqY2~+!OL!Wx&)8X;j zH3R`(yGs;7bXUtU`L`ha-yo3hA`b%p!|a`>g@%vEjn={)fBNLxlKh zgx*?bK@`lm=;VjRZnN4rj2X zx5d}zbSx(k>`r!m0Cl$lI>I~gzOo@OJXSJN(xEK`=$##?e|k;vcVBa6h&iM zE-gv~n;$DLD!3#?P*RrNdvQ+5q_yuI~(u z9AUA@@0hhxQyT8Q9k{{MT>ijaw17e#8Wy3 zYE0iM6^;-~3VVu9LUr-WB@VSFUb!$f63t0RYIb*r5_Ot+w%UsZBE{g{SY}V z=(PK}&U4SCA43*M1^qR^k5@dhw)+G)J0EV{OkC0e5u)yKf2{TZ-8QMYLy*0Lz=lz_ zKe^>zDhq?bqa&)l(;#7ATO&05Kv`)|r?F`ZoDZ7LQ?;kslot=JD~E{q7KU?;lDeXr z8OA!)V)#F~YeK$&E2~#$SrZ9c8vqd-j8M(MFB+%eMf zuljIf**tQ6^g``V>&#Jvoie!FTz`LQWY_pa^v0FZ4D?0pVXw83X8kGf6Ag`)i=4Z- zN7>k=HTzQuPN6{Jz5nG2x#W})#-mp-w7)#l_qi<(!O6?u9-n_Ys2E1`0w>2-0u(0T z1LQdKKAR~200}*b(Rt7uRzktPVu>SJee5o?e zsRGvb1nuD4$1nf7f)wKnXyA)<=y17M+>4B=#IrlIJlRK#!p1;jcRBEPyKLj`?t4*W zn0^_=v;KbzzVu!*$jkene>b&fSrse_8WJ`tP+LK#|8Kh9tWU^pnALd+qYlvCWT>60 zxwPhC`cHBzkpQ}$%OuTPJ*H&FBr)ubXjDWita2|iYs#_eov2=G%^Rh}ETP8Hi6O9@ zqNLL@676kgVCLVxci9_1d69lk;#@`e21=CWH!)3$n0fN_YU^C#I!*y8Epv_R&xdmU<%>TFRl7$W03#FwNLG3 z{AOGGM9e>VY7Mtrviz>C;J~FmIS!phrFPD2#W)QpW9k$CUx|*><)WEDnO2TQ z^zGqB~OQ-iP>zOIdY2r52y+}#;i9BZ;kkKfiR8vu%ruRcVnkldP8<7cU zx$U92gB;AgV7{;#6{}c>V!0z_R8JU0I0VjexT7VZ#F>_qN}){iN($VfeJk|pFJ(We zTTLoFzueDp2E|Sz`z`^e;S*s#LiYW&D}EU!`LOMJhNN%XkxdY4Eknt0zt51(kPEHN z%CG-xaDp`nA^N>!_LxbxVGLc}iM9-yu~aLrV2kv!NC@%-_+hb)tFNV+d$*b zq9QXb^9D3()tx;~dXp{X(vAISe!q4_eHe*R=V%UI@rKkk1-;4dFOdm5>Nyi@R&f^> zufydpF3DE(a5xkW3L@!lbF>;RJeHqGOhQhKMaKpOXqmi+EMMg%7^gP?|3Q$yKY@#)E0#7S1!@&61%) zZ^~=I2<0F2Tv{x^FaKas+DmNDbhWK(gvl-vJ9o5wipHxlb=#dH-Ak$`f|?ZSlNWK# ziCpSM)6%69AR)X3aM`a%uR*qh$=oHVQt8ljk9>8AnU_d~kF5{CpCs?lRNKSCw(N4t zZl<>>E&SfVZ_EMqoTfzy#c3hd7?B$kL7d4pi!@z9A?TuMVxkl&3rIyU^(~7cf}`^2 zM$$vOSATraL3)E`=0Y(fVSBvPJT*~|EQ=bUF(lv1pv!NAZgel)0t%SU$1#xnAVGvH zvJ#1kK?uex+(AerP`Ja=`3Lu$+LJ8~a)V&t@Ppj8E{|l2vqCcw)wOOxPd?pjMcqB~UP(cessFusWBrKn); zC)?d?k@4C35yJaM1O*OdW?(pxy@n$LhW$M;dnPM-K5CW8Af7hh8I<6WXnVfZmkUjr z>Cx1EN#WZA*QR@y{Wyb_+Vv6nJIcmw=%cT>TEhjd$~t8(~rT@r7rS3==M+6=umf7aB|FYQUYGEXK%jPG zhZ%|czIEs9s@H*=w5tlh#-1}Xqg)V~16zP$r$+-eQW>||&(y3%jM_{eHb=RUX+Zyh zH~h!!?f-%g*EaE&t88(6shG<;7ztUU8Z|s7N)Vnz2FD?}@ByO1Vw^9&6y$BIct-%3 zKB^;D8OK#O;)7Nz4*`}cM{==rS$HOovPLn%ru#!ihsyxoD%V4E!ih04xB^(!dyJdK+^dv=DRBSI%Vg z$_rprm?rdB&;@$)2NAnVjn5NpA9mg>i}ro}gPshGftEG+ln46gpWiB03*>!|G{fA? zvlp|Pe21W6|9D;6uIRPipNGusa>+eMdOPUE;_%&lP7Jtn^l=cfE|ur-Jw_$Bd~&qI z$K(+Xj#n4C-c-L3#W-R{PJqz&)8@Q*p_^`ZWpW0eElQ+iLMV&N9>K7 zm2AFf@=6=Ge9fwqj|)p=3xg+DW1Mm(yB6DbJhNLDv`hd@;Pp+UogKf$ckEqLPCcqc z9IMTLzphAf%$nWJf%xMFCsj6Qjk$1nuC9rFK4D~%oR-(~lBR=vZe*3Wrct3~sk8J^e%cCTntoQGdY|f9INe<0)UZ92i5q7*E+=foo*F=tOIh zE2(vAl^yp@CCw{~C&$~kZ`-0cG|1Wn)UKk8>_?)@fZzfe;~ZCN<>ee`JO+c< zEP3g?i&<_*pY!E6BQ6?xxJ8h=s=bKy-O>e=Lk3ej`EuDFEck`5Ry`M_?=H>i@jVA7 zFuj)V@*WOOM|7vl6O0K-t@nlgjemNw(cJL1>UXF9qyN*>GJ_*t4S+v<`I zD=R+YCHZ&KQ}!Xbg|2KP`%EzC9%ASuZx1-n*vPg-YSRaM$@|^Me;is|lJX!LRu4$n z|Jx*b1$awJlZlL`RgD@;hN(F0D0kjP?ax$4IzbvZUAd1zwViuJ zQ-&GMyhu*z4clRlD5}~;cOXY?kBo?=nRX$?W90IcDRtqa`!cPi5R1~p9kc9f(&Ioujk@ab@JiY_Shv6G~qP03t* z&*t5d$$ZV&I_aiV(V}fKs!6P4gBPeb+{P3HM{u=dhrj*~P^dYf`uKDU?Cky!slUP- zPqD&*tMOksy`ZhpbD?}*(%VHP4KLFx7b*d#E8hLowVNPMjEaB`|`I$M`;&!3yX z&JJ0<&TaDW?W*%hwk0Q#*$dYmP?Zzwy~M9X9YcZEwO5?#&+;`utUqq;hQY6^J+N|M zYv7lLg_=yv{)`maX5fH_JzQ5(6PWQ9DE(D`%kkUPgF`ivoX03IS<2L6($zkICo80N zMocZXCf=BGWOq>F&9TdJUs_(Ve9yY7XyvRrt%JyH!O#(4Zly8bUob#3%x&eP=Jvu< zgzEgqUXc8YL#O1DEV6 zsTE+srJxSA4?F^@Cqk5Fty#V`yPKN+U~Mh3@uUk8eSe!~(Le3vj4p)2w5ZSu9h1oD znxm7*DCeeo*D((9GxKpCso2d`q_lQB=}PIkDp^y5Og8gQdy1WZHBY`q>57K+z6 z)53rN;(|+cN7sYFI@t{6JX838a+u#@x+fj2q2x~(#+YZIWdm|);bDHRWQjFgPL$dy zsk3?uv9?Nth)Up6QS@6UpjNalymUoW?e+j|7T2Dvt-CfUe*gW+LwwZZQ8t0uv1`_u zt7)$Ukj9yY8@Ss|e zeM&6FV^qmlX{(whrriFXqVuFL(n5xqvf>S3!{LnP^ao)8D8- z5GPF0)bdcVsev#F5o@FlYCl*>Nmr0wEARZSBi5XeZWf4s188T{)Qwu716IVw`3g$% zVfG>-Y!2PB{Qok>YOXyQudWsC*Zj1yg*a?N)+;?&OkFw4Y~=S%+Ay|e{-HJ#JE2Ul zk=$PsW;fC;qPx%~)A>`u``c|!rQ#OUwA7h(W18#q=pDM>d(GFG|0;|Fc1P^!loe1KGAx!oK=;*rn6ac@R#df& za%>dJrPkPg(|5*`HGDoV$p9o<5CbGhu?GJ;{r&WcREF_y6L-;pn4EzDY{%WIb+7z^ zn1Uppg-pP8cya+@?{Lw&DOZ4+pf4;ebz2{dB01S&Yzda4^IN6)DeEurRqfiuc1T<$dVwlx}y zIWG~)0Y7;sKslXC8mI~u426*&fvwne<}-Q3ZSIxZF*>#^N@e|A_mz36G8a?} z(yFP*i<5o<-BF+m14O5q5F6gm!449k;z`$*1MIJkJXLUp3b3Yo5)W0OA{Pb0APA1g zdUc^hNJI&aVH$#H!?MI&G^W}VWrPJO;3Ls)9<0!F>L@nG-mw(v&S&&vTAP1RGZot6 zF_#%gDkB)DoQ(wu%8&!idzuV)5OTWzvJ?x5zJ4;MiOpZ&c;i-giI zgGwp$UdfCCQAw+mMzwbE`#{h1RmXcLkr7$`$SvB02;#sN!073xnmQ~l7N-SKj7)Ua zK$%)UWWd;MyhiL~SEbd%*5D3ctp{{Jv&U`&Yl&vWi6^(G+2w`y6hWca?+riH;K><` z=qeD&navYhndL~brN4O|Obom|kc3RF5W|l+pag48QMX0nWTTgQh1q|IFMZTip4R|7?2^}se9BcZR^j;OpuOy{}aUgAw0{0I^3;TeFc2BH98Y)&t@US9D$w-bYTb^m$PlP{#<8(`oUnTxkzBy-v;x_Yn~( zasC>5m~PCN0Vz!9cC?&CY`@|%V{ao@Lo!RG1^nu35THC-yi582iSo$)pB9O+ChaH=0`uTurM{W7r$BNTu!)1xu6ZW)=p+rnHz3bQ=8!u^9Eu`HM29A16l$B)z@kj%`D+z7|qdij@?Ju z{V^VwB9qk`DjLSqg(auw=+2s34##Abii*agfFn?r359u@sYMiwC{VcALo^oZ^P9ky zMG~7bO)nCYPOx(EaZUHOmo1y<#fZk#OtF-T8A;C?SxPX`z{{WmQ<$%1!9Jkh%%cKm zG0SRBG8l3twO{Pz()B?dZY4zrhId_odOF6)&ce!nyBg_ ztP}A#at48?Yh+AwwAdA@93HoVacw6tw%O%U_HIU?IQ=1AWtj!sJVl!~OaOtNLvt}_ zXENgEV5PW=aWzR$3dj_0fA)PP`}x@%ycIgHer?g_ij<^tPIiqEas$}b&my~PvEhjG zc1=UbI3VlJt_G|VPd#@2Lp4+}<|7OgOp2F20xAWdc@no(I#6wiWR9T#Ffv>4w0L+k zkdLN~c~#^(H~(JUtq-WXiIx4TB5A9j)g}38b3*D1qDgBfosLXE8*d03L>#Eqk8(x< zrF-wp{rP!PEYmcxVF2eDMI|QSQ8o-Hzgso|e^d-=qx@dBg(#b8e@nj>9a{HW!oHc1 z%#RfovEOiRg?>z{lJ@B?^h#sG!gj&i0MMRw>$Zky%2 z_-2@Qve&mX^g%^suZfQQ{4$`bGW&q_4*}4XS&y%;G5jHCnj2>G^>oA+!eYZ~{?VhL zkE1fBCS5)vSf3{R76-{NL_+Kd-!hD^#dT5ZqMkLiaOv@kP`G&k$mz3BOE>-sFL2La z;Ya@{RAh|{xZ|YE99c3+ug4P1%i)vTRjYc#VY&-NefOT0QQi#N*XO^JS6^PgO8X&7 zeD5z>!RgdFZ<*L~7k_VqqK&Hz$T8gC4A962{4je`lHvNr(O;jKi+Y(Tw4v1Z*-!E~ z3B)6#a-zWk+{GJlmLZ~(u3xqZN&J<}kVfp#g_dL9%j_Q0!Msd#(#fQ3XnDW0s1K^3QN$7dR9a5s>zC$VmAPVukWR9lfx!&RqkOHYB8tEXE=0Frz1CYxx1&1uAfpgZsA(A9wzfoACCsMgnPI3wxo7lP-dBoN2Wl&kwdafX`yg zsO4T!HSJSGhMvwzaqg|ooi+XyAT#ecAIY>fCu!d<|7;AUfiEZ3!&c^vo4lJhoiK7O zpJI$;6m3Jla1r9bPsN-%9^LbiOVWtF3x?r+Q+Ft^Yqhm~QQ+$TLZabQ2&&}0>R5MZ z{Y{l4h|NRJ)Ec#eu1^CL+!P(M?!0FuSElgtO@mUfdiwEskPF^;Uy;7v!pDOHJXfQg zH8Fr@43+4w9hxaa-V%TSOL6_yM%?B9*3;u(ZOPmt7!sBZyvXTxcS0~B`}P=PVpTS1 zJUGkCpW8qFQ7&1-mi#W@81S)(8XA*2!xM&YU@B+<;J*E#_HZZ)z*f0PKwwSkF?eo!5OJq5@U! z`B7yi!G_3Qyo`ju>n7KJ39Wen1tdILaul%vea7H^2sch5%uci@mKBk?#w$0}B|=!(XePBNGwo-(GnVl?nMB#1nzreH zmV=U9+=v-Nwb&|qk^WD!f33u6|0M@lSN{;!&tg?sOvXO>05-oxfB}R!#0fyl&=c?w z>70!p7scZ)YHv43FL1m{bh&xV%^2~P^{|m4CljuR2|C>qgAPoN?%VWE_kvjw|u<~XN zfM&X|uP`}fDy!l~PK)TklSdR~-pGrsF*m?EEy0=X2# zFKndsDgQl8zQ~Gqpg)=;uEvqt2^y_r-okUNZR?)g*x>f6A1eAy5C&<)O_tX-O+<(B z%02>$TL8xQ;VX%up}5dmTallkiFgEPXhg`~;EcCtd!KUE8#cRw>+CZK^{*WJd>l$@ zE-WXl$b1}bo$G-%Z@Pyhe|)$y13fyG7wM{7YaMLs|GZ!36S926?QU?k7%!1Ji9a!< z9?gE`ea#FsyJM+bpK#zUYH*t23EC2J*OW*RWc%8)egAB_0%HaRuGq}PWw)bq-pZig zoyD1q+gf2}UgOTUOyxFQ-q;s!uBFa3DJ&=`S*qR{Kr1!IKOQ~(M)2@4+8YA{9|ezD zXG?=oL6^8E6rXA0x8-NB`qENH{?pU_@j2v7Pma1W{kn<^4jwuhUh#vF|Gcb!D9ZUY zuGB*Vube~H5nzCOMk*{^Im0ak7(Pk?2EacrMApCDY>4YYQEwuO+EFBQN3qUgtW9hU z5KRI4l%>m}5wD>b7LG%?Yg#d1*_R``!HZCFOP^4BO$dG#kyg7Zev4EhWu2OmVxS5TJ93_S4?WbM zUi7C`%i@#VaLOIy)~$WoI>w{|Q3%8zIUHdmtucWWrighiE}{G|POb$Z<1*qGW3Qr; zn)TGpf-S5=(*AG@@!U~c>F`fWh_TDF^Z5>W_uDE&ICRv2xc%fG>5mPdin-nCzxwQr zLB4$Xr^ATI@AMBu+dqB+0a5iQr2p%jlFlp8=yVUZV(H&#%>e`kuT)*Wbk@X$^178( z7i_+QMHl@m{vBL(J*K(;aO*X_j;A}O_KzY{O_U(;ATW@Ev)k+oWrwmZjh|084W`o9 z?}r0@mZJ^#DyWUp(?{dwcXaJ40wt5n%lK(t>$x3Ic`HN|qq!U)TUYUf6>oR(-HEbS~;_rOBHFM?-l(>H6ioG{^&D`e%s96 zzFw$m3Y4Jo=QPn-cZB?Ad!e+SUz+iASpJ6*-{`i5RCNiGTpZv>*XAz|w!)|hdBCB( z6{}_sx*kncT=pw{kdI2W1L1yp3c0>-T;T)zGWKO7Hd@wJ03 zo>k%$^)ul&a#t+SF%ee zOoy@0hHb*LomtWGa^q+#v53Y_6Eo`ePB39!{tD-g&GM@fg-ealr?x5|d%V%mAWbef zqtB(ho<5V7@Xk{H z8)g62_~P9g!(TvSiZS;fCU{GEzna?NQf;;ISGWVg@+T6|zj@Q6IOjxr!pQ94%&kS9 z!~_~*bFmyf;oI$^y<6QoR2+Z`@FW!Q`REbEk?^xi6&h;vE08|_A1PCrsz^K)Yic$? zxZ*jx9k}&)P9&&$aW0>&3i=kWDUSTwoDmH4sZbz?wkatu?_QcBN9H_YsfJkPXHTv`|Ey>%|n`snkJZ* zR%B+cX%&or2uV-mM#0}cN>$aB`eae2u1VPow7 z!GwP9Lh~Bd$<~=~khA}_qF^goX$bQg@0tdA62NbsAIHSRdyn%T&WGyg z>F<6TvY^Oh)%O!g^^gAhW+c9TXOgH$^_eIYbzC+dnZV_e+Jtt0`t-fK!ytUyO)E8{ zw)WVZ2;gIL;XDR}Y|C=7enbp)9~n>(*~8@;b6(iK8~OQt zP-4iZy&;P>^AEUGJ(?MWmf^U)QWnlp-rpY=UJCGc_^#D{Xx<6w**a_?$IS10Whi(w zpO^rRyGu^Cochy0QvS8ArFdJ$=Y7~}+VXTFv;8$Y@uneXwB~J&?Lj_c(hyoQQ;L-l zsbNXdp)sQ@rgUSts^odduMNoq0vl5*$ke;+tK|u_}JQ4B4m70>E!+a>hb~?Vaz3hub4UHP2Y{ zWx%{uG{((`b2;3{e7#hQMS|-4*`q)fp8%Q7Sg=rsZf+aYoS;$+Eb>}wn9n?)Vn_4(H}h=lqLe^#>UN(${h{7$W&#Lz;hYKv0yYaKdswe>Y}QU zwM?iNBMpT7Y-jih{qfxn-^z8P*3-=yqg8RShaJVoYk}J<8r)`44(}+o-mP2N42C4d zh3|ah!ICnkuj3G;cgM`gdzA;Ks*Z=2m?^6lCbVTvn{^FIxGk;l*G&!_tU@FE^E8Ox zr)uBzpM5T!Z~yFQ)+dT#XtBV9%F&3i_lB5~X-*v^Pvou?NW-Pq3ZE<0;Y11|iK*3! z%6(B1ILE>NRDjXQmV?UdP7WWyb4CK-trOMH%{&UhJIZ>pXflYE2eejkNVWvIWrD^I zE(8_OMq`<0Gl>PgoJja5C2m~`KFeAnVGLKpJ~v}gRoe^M^!P!~XB4G&_%9MwQ{PL) zZwZDq9Nk~aXIHrDf8>^5v$EHBT0C-Lzziywl;xeu{fQyCry0{Yg8oV{%EOp55>I~R zqr=-6b1#({I@t+FF=^eo35-A&|&ZEgSj4`^ReYCSG}1C`B1} zo2VvADcosh z!O>T;M96;G#H+}HIke;1sJg1a$QH*BcDX#U?$dz`I4E1~qL4aX4=wPWWcyeHVQ#%+ z{oqL9l1Y8{1QN$;%I_c`SXA|(>o>c{t&X?U;2t(0iQ8e)VufFRQ}Y5)-dx<0WBa^G z%_xD|YcyI`>)CH3E)oAu!U!@6ZfP#T#rCqPX-D$Mdb^t-BX`HU1^{ zFmrn+t$o2A>6i`A`6tJa+r-#gaBY7R%iANHZ1>{jr0#@!N5=!z$Zp-Q^x8P2;E7f) z?S$f%JXFM!<}Hflew0e}6$skp$@o}M#X@-3?pPFjTZeR=W2hX-p;%DywQ}g!1R@O} zn-=w99Or+TypnBwoxv=3xE5&=9W7*A{4(QC&x~J2RBGVmm*y7}#K6^!_;9vXS3@Or$bUH;PB{Dd-U^f8`moOwm5lfc{4LlT1G`O6{3VU{GEq6mt+2Y=h z(db9VIx#U8lT`H)|7-On^zsiva_^rpxxauE@G8F(Z*18838?gM7c z#zTl{J|Va=uTb|<&^L$#DSQVdJHDLjYCuMcopQIRa(|-633z@s`dDkgVZ(xCqHilq zb4N-Br&~{<64EXiFb;dmSJfS{NY6=jvs!=(QSOMs2S*00qZ$ALQIcXP!6gZvHVrP& z^D|@5->HFIQ+bE!AQ9SL9jJg_eyw*nPN9N6-LS0p zcv#i3vyja`Upfkd2~(pcZ^w@!fHi)kVn!)`3(MAe-mU?huZ)k!B?lv;-swDtMij{B z+OxY_FeDvV*s|LBczi|A@6g0(&0uzU61I>JfQM zT*$M<=W(rQEZk3Hh5cRYbVVL4=pC1nd4A8wZT0Z*aHEn`VHNedRpQmuz z-~W2@>4CFlz>Gtl15OWoZvOW}9-5&~u5C-@rLE8z949K_;bV`y`jKVNipv71{z;-Tf5!3I8^wifvN zlg+)$k(!!GVV)68KDGM`iRv*)I&_>q1sztm20jgpdzxFt9b0FR`I{$gGP0CPiQ9;9 zP9thZpTYtPc6vIK#QuP0aR6a(x^>>u6`mN*ZMQqMBAwd08x&~Pqs-jf@r=2pVT|Rc z$z-{%+eSG6q8W(qN4?_vjADs@7kRV_1r$-ib2s2o?NFnauxN-@QIET|SA3!+W1}gE z+ri_C?YR{TG^C0dOmpsaC{Ai&XKsiLV8+1zAZ&tw?f;$t0dA~i)1B5K%x zSG2(IxuG&W&>iU__4s~?-oy1azHWNDwE->7CEe8}HbgV)UAq{ro*Mfz1|r2&O?YdJ ze&^k1`WWyA_4CI9e}=rtl~R+|&*0>VM%>+j4+nk=axJ+;sra&qdF&!$`jd1-36jE< z0S)G_q#L~paPKl|YVZ5wAkuf+>m29lzL*)QonPXwPD1EWyglBg5eaVE%+TCf&`@KUhrZ56^ z2OEda8C8u6kaLh#J94-CQXoBG4mr;7uH_3Hmu8A!xoitO?1;^uAC6;&{q(qvnsE+O zVyWhpOJEoZz_(kvR`_;z7W3j%l#Ev`f3RD>o}2HBun2wr>uN980+}FM|H)?EE^_Cj zF6|PAv<6CI`*XgLm(Jw6zK$$*S}d@0v_SiC0(~$2?MVwAZ4=F~L9#{I0H4$sjT&Bi z!l&2TIThh=A7LjI34-&7ko=V?ckKi(laC%Svc*-Abc~k0fFrRi$_cXSJ#$G1q-fx$m>+D+YnYc=c+NI66TQX zbW3j><1eHtkr|)}q3zr%K+8u%FgqvOYK7R1=ey_9>vWun1WC zxJ%$D=O_5z6n~(j8muau_9{X{Z%x|plSd@tCX=NYQl}AqwdnSdhUpEf;nu?KIv95D zp|1Kh#Mq!b2G$W>YvP1d^j<{Irl~d6>&cIy;HyQhM=iVphPy9);B-CtAf#mHUYSzo zBnQsJ^{eS){rk#8%Sqi9yVJDT5cP}!*C`soW=2Dv=un$G-BiPua(Jhdfs^~)bNEe2 z+~amsD4|`7`HXj04F>A7>-lC(r+GMGikCDa5laPIw4a-)Ls*L=F~e?ta7qY_2u>YG zWM467L}3IuaysoaO+91)OUg%D9HVeNw!I;t;N$}FS6yYmVAB{OS zGdDO7Mdkl}b^9qF(&1o-2z2&|Bw})hq(p{UpTv10UNa!qSLI6S9LBFFjfmo*fCE2_o!KCoq1Mo?>opoGvo6~Pwg ze5pnBhghj=hK{@U>=^4Fq|XL+toW3SnKgx}o4EGJs%cal#87fdb*+Uq`!i(Tp}-({ zk{jJs#Cw%xDz;B^2^XhNVkH=VY49|Ap^ARUnTr7=KM>T-3);^8KW*PBmgC!$zlSM5 zscTyP_%89lxl;IQTRwopR9lN=@|#ZePMqaP0t&}TU+TLWy%9%gBOwmSRBz)#f^V-d z1HDPOODKZov$)|vl5b7?PepT7sy^(hz{WgpD11^eHPgj?SrjRhqUN$WkxXh3t=k8S zz}8>!Tcj#WP~6dxBf*tw_p4qcXp>ms5DuUH@4*yAgDy@X$j4P5ebcGoS4LN5ti-J% zLD(U!v8$*0_iuEqNI6cGLr72?nJH6xl!FY7@Q6;I2@rSea^D8c$m!Fiphyq} zD_}8Y*5%FPQf=~US+Z-dokga4c65(@W|DS~RwL=kTD9+6JOdyrU>>Dm6x((j$5Fis z_onT9uM2Cy!zec@(YT+GNAfq&Ng-|A8myRcpX#8O<+Au;g%&z6Ni>@bM_2mczPmf=xW5}&K9uMBRs9A(ksx_DlWy`Xq-)S0Mf*Dz@Vf&JtbmtK_H3wq zUtIQ2@9x&CL&UeoIw=|(8<13^{%G)I*&#~mXw1pk`rL`uGm`3L`KxO|6nvi$SB!rH zkNkNEb)I)C-{UQP0r*9LC~c?>eHZIffUX$v8<#Bq1~dRJarpz{{9lPn>Y^te(GG>p*MB7PuXZDwN_J2S&oVT0RcJkI{m_i-Qu=ie}2;Yn&4K}(~1Whv1->l z;F+Z*1Dhxi!u~A^5RtbdG-ZPO zy8!%aGY!dw<8h(N0%lRM^GzuiZo$s>$LHIYmB+K5xUc|I^T$H27Y&&GwT5#$Lj5R7 zRs3uteyBdHS@ZU4QWOSX`ts&YLY*PrS~>`JTiiNqUrbh&&JJz=COTHGj^B~R$Thll z8A@Oa_r1C z{jGmD4DK$bZXPFT96q3V0t1*QWv%`T4q+G)cyC!>(S0+AuIS^5DKVfT*v zm&Uz+E?jeKD89}?GW=;Kh4DzOgcdi(^QMgEK6fnZzXFMlOw{2Il|)ZcHDMKP6*eZdsVCVH z{`Go+OngwVIeSWL?GBf-RN@HnMUwhL^aufZ+6)RRqJeZl2w{u)9hI2{_qs$mmmm;3 zca7qBCQZF8iW?+iXuQ;-_}CFT4^!OhOWM6N#<3!Df~Z8mm?~TI^s|5^sY~GyAGk+O zX^33I&yk$T*vwPB`lKV7w>g{1EA);=h~S9(TZp;J4)<8`^V+wt5eNHza|+O}CmV{^ za&qx7Hk={5P{SL$;Z|6aqRHV9VcvI0x_%M|(ckyVIN3Zc1ne*6Y%bb%> zevZASj-RATO-*8mf`98X@nqE*5Q9rKG7>N6Cf;(U-HnCe!`YFm`(Sio*P5>HhgitF zTJDrACE1X1Y<-tmq=7xnWgy9XXacewrXIX-+E*V-#|71`qL37vupqfCxxUDN^q=aX)CnSDh~VY z1L$V`o7(<}&<}HuOpNp5pq@Fi4OES-LIWbsU(83nB&j&MzM>S6K{9ePFD^A$j*Hjr zv{97FIwIn!ScO+Kl}XLRa!rC$SmWNXqTR6^TYA>N7k)G6OkUtlqUQq|363_JEFQb? z51q~5OT~X$+`AUa6*o`;Ztp~3axtRw%Sc%wgnen`Qk=piZF519WwAb)iwEts$GoF3pFXJo%rS)K% zsbji)VMG;Irfh$@ZiTsoDn=GAT|E7iIK_R$cu6o`xkniPg@BVhM)P$Z8a&&hmMr@_ zt~^>BEGQ5}9u=V7e(!xUGiGdg4Il9+o7sq^PC8}#wjsuHq(Jztz;MbRK~QDYy>l_Ap+gF|4Jh{| zn#tb|geyMFj3$WL-J|xQaKgY+5on*R0H4)>_Ns&p^vkI$-Nvopb6EZ7U?HP3h_HdB zPoAy;PDpS=iy@M6d$|~Fd+lWgY(b(LNUmoTezbGUDQK#U`3ed=&_~n3nh6VpaG@u4 zDKsWg(+NU|zEGPY&MY~&8Mj)z1DXW+2Ki)jQ}Jc792uAKrkuju=vOT&1Vf>-uSZx4 zDhc})HhRF(8oeI{e(y?u#j0YN4x|@2W_#S}WL{AaieUg6RzEJ}NugtLT}EBsfyz_V z$qVVMxXg_j0ZwE0LbPim6+VxeyM-oJ05vS5fPf!n83YuKulq7Tm^ zPz^4zl?P;1r15ep6%=15D&ybz|3v=4rE2{ofi)PN^MjQ(-OwN_i;6FPjo%{-h{2R+ zv4&M`P>h;M3~_3SG3eLqGTq}1M2bdIlFT!SK<1A=z>4N+ut7|=rdw*|%HuCG-e%0A`B&@8Ud;_B# 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

v<~BFeNs8DNchEFeoh zMJNhH9JP<_^If_>nvWrkRNQSQmZ$W20gwdfCX|)HYt-`$)1Lxh zfx2M3ThfTVZv0v9MLV5EdEnk}as+E9G`$^6SOGiIkTrdvm%!P)oF(?}!pH~XY*~>A zRo<)G6sC$g>mlGMoB;jE@-WEzdJS_RH?wRVuxsz2el^E}|Vro-UHcjbQYAaqlq^_;mE`eJjcLgt4TVvNGO{<&`pAPa2vX+*5cOPV!|ZOJSW8Bf{(Sm zWDxd9G`f9E?HWZY^(`y&QZ2CTUqVJIpEaKv*Ky;2{A)565WfHHQ`zv8E*(TOZl?SaD-?Q8$tjL zAr^g#2{vy4hVM*yvt86#G4|x@3UxIZ#`*qbnOp7GX9!?#Q<)%aR3b9O_V6s#7k=NF zwYdylw~d4_2@dH9r@P74nvQStiOOy%WJZ&#;~##G9VD}m(&TvA+Bo03Y@HS>fw?%c zNi87xhMJ8lrh@=HaRm@%dDLgCy>A~M@%MSdH(csZwiZn1baczY#qC}dRq}HAAo`eo>oi-@>vbg==nwJ%2Zd59tCj=ZMw-E7AebGWUCV2Yy2rBR z*baN9qjo%^jZZ!(?RQNMMTt)mJ2Z*J1FWC9CkvC1Gjo={wc16gt`~!Cn=n!Fx1zDx z4>YnxKoEOoxgn?4Q+jdBZ`F4Fw*32QtX7tby0gdLbvYsV^D|f*W70z4Sj`teI2b&~*m>jOvbAEp>l6z#1Q*SXipmeaYjyAYIXz6m@}fz+9m6bQ*~ARp>}I z^mEdBrC%UWrc>r}i4B-eewmWaD(2c%RDNI+MklXYCa{VZtvNWRCsCi~+zLX;`U^VZ zv4l*8{K(UDw^IIEv_hfL+`H35@PB&9abDwxP}y|mE!de!}HV?B~FGZ$wa(6}diEgju&2^UnvX?ebkNBxeUR!$*!P=Ht`ZEgq|LV$76P5^;yQ+CgrnAQ0EPQp+Za zg_4^lw1di%eB*v2Z=|b153`T&;~f3yBqtNMp?E+PnY$$eMr{9vDu7IhgL%NxgO6Wt z1%1jXr5hsG?RcVgOumI_ToIuau;Z@B;7Bu%re(UrxFYQ*)-uF@uZmmK$!*5q@ylAU z+8}tZ`7pJz7~L(=eI=4FrqcL1(KHmn8B#PaJrfuy``6y-Wa2(_8PNN(;lX;jHJ$5o zumcmmfoV8~l({+`VZHwwINX@5PuHybx;41@gqtKyYdF$hb`PT;6-jdwwA zOF|aA>)S3~dbm#JN)W$$jcs+GytMtb`d2};zn8FZNrg+xb!V@kEe_vK){th)MYKO1 ziV0rxF^t0zz(j5-Qm~qS$e8L7F(!_#3~bh!4pGR3r^fSS0ddy<9%{UEGqOuxWeIY$ ztNeihAN<6>6|mO%6+Pn|VszN!w`p*erG)QlgnAwR$S05bvqtW!sQ=w8rG_%@^n^v8 zpg&7l0O^wrRb~3mS{CGp*v)KhQ=)NNqgbXA-9dvxuCFu!MJgc=8Q4a17t=9mpFoNO zTHybiWy^w1>9STOy=35J^O+azPloRfNds714?%$#Kz{LRmzma-p9OP9eNo+%9q zmI*nIl<0W!ty`C@f)=^lYb0MxmFkgT4%-y`PD9>4o+lGWbbajN2Jec12C$; mQv3gZ(i%5&=zcTo^n5@9{`qsuN;>e@T#}UpNqiPJ^8F9kps)u3 literal 0 HcmV?d00001 diff --git a/readme-images/sample-swagger-view.png b/readme-images/sample-swagger-view.png new file mode 100644 index 0000000000000000000000000000000000000000..d30a16cb855305b79c3c150139b29ddf62eafc89 GIT binary patch literal 29558 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 Bo>2e* literal 0 HcmV?d00001 diff --git a/src/main/java/template/Application.java b/src/main/java/template/Application.java new file mode 100644 index 0000000..9a02771 --- /dev/null +++ b/src/main/java/template/Application.java @@ -0,0 +1,17 @@ +package template; + +import io.swagger.v3.oas.annotations.OpenAPIDefinition; +import io.swagger.v3.oas.annotations.info.Info; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +import static org.springframework.boot.SpringApplication.run; + +@SpringBootApplication +@OpenAPIDefinition(info = @Info(title = "Items API")) +public class Application { + + public static void main(String[] args) { + run(Application.class, args); + } + +} diff --git a/src/main/java/template/api/ItemsController.java b/src/main/java/template/api/ItemsController.java new file mode 100644 index 0000000..14c435a --- /dev/null +++ b/src/main/java/template/api/ItemsController.java @@ -0,0 +1,63 @@ +package template.api; + +import lombok.AllArgsConstructor; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.RestController; +import template.api.model.ItemDTO; +import template.service.ItemsService; + +import java.util.List; +import java.util.Objects; + +@RestController +@AllArgsConstructor +public class ItemsController implements ItemsApi { + + private final ItemsService service; + + @Override + public ResponseEntity getItem(Long id) { + return service.getItem(id).map(ResponseEntity::ok).orElse(ResponseEntity.notFound().build()); + } + + @Override + public ResponseEntity> getItems() { + return ResponseEntity.ok(service.getItems().stream().toList()); + } + + @Override + public ResponseEntity postItem(ItemDTO itemDTO) { + if (itemDTO.getId() != null) { + return ResponseEntity.badRequest().build(); + } + + service.postItem(itemDTO); + return ResponseEntity.ok().build(); + } + + + @Override + public ResponseEntity putItem(Long itemId, ItemDTO itemDTO) { + if (!hasValidId(itemId, itemDTO)) { + return ResponseEntity.badRequest().build(); + } + + service.putItem(itemId, itemDTO); + return ResponseEntity.ok().build(); + } + + @Override + public ResponseEntity deleteItem(Long id) { + if (service.getItem(id).isEmpty()) { + return ResponseEntity.notFound().build(); + } + + service.deleteItem(id); + return ResponseEntity.ok().build(); + } + + private boolean hasValidId(Long itemId, ItemDTO itemDTO) { + return itemDTO.getId() == null || Objects.equals(itemId, itemDTO.getId()); + } + +} diff --git a/src/main/java/template/config/TemplateConfig.java b/src/main/java/template/config/TemplateConfig.java new file mode 100644 index 0000000..ca05450 --- /dev/null +++ b/src/main/java/template/config/TemplateConfig.java @@ -0,0 +1,15 @@ +package template.config; + +import org.modelmapper.ModelMapper; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +@Configuration +public class TemplateConfig { + + @Bean + public ModelMapper modelMapper() { + return new ModelMapper(); + } + +} diff --git a/src/main/java/template/exception/ItemIdAlreadySetException.java b/src/main/java/template/exception/ItemIdAlreadySetException.java new file mode 100644 index 0000000..f888911 --- /dev/null +++ b/src/main/java/template/exception/ItemIdAlreadySetException.java @@ -0,0 +1,13 @@ +package template.exception; + +import static java.lang.String.format; + +public final class ItemIdAlreadySetException extends RuntimeException { + + public static final String MESSAGE = "Item ID must be null when creating a new item. Expected null so the service can assign a new ID, but received: %s."; + + public ItemIdAlreadySetException(Long id) { + super(format(MESSAGE, id)); + } + +} \ No newline at end of file diff --git a/src/main/java/template/repository/ItemEntity.java b/src/main/java/template/repository/ItemEntity.java new file mode 100644 index 0000000..5c66c4a --- /dev/null +++ b/src/main/java/template/repository/ItemEntity.java @@ -0,0 +1,24 @@ +package template.repository; + +import jakarta.persistence.Entity; +import jakarta.persistence.Id; +import jakarta.persistence.Table; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Entity +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +@Table(name = "item") +public class ItemEntity { + + @Id + private Long id; + + private String name; + +} diff --git a/src/main/java/template/repository/ItemsRepository.java b/src/main/java/template/repository/ItemsRepository.java new file mode 100644 index 0000000..0b9e297 --- /dev/null +++ b/src/main/java/template/repository/ItemsRepository.java @@ -0,0 +1,13 @@ +package template.repository; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.stereotype.Repository; + +@Repository +public interface ItemsRepository extends JpaRepository { + + @Query("select max(item.id) from ItemEntity item") + Long findMaxID(); + +} diff --git a/src/main/java/template/service/Item.java b/src/main/java/template/service/Item.java new file mode 100644 index 0000000..7d66dec --- /dev/null +++ b/src/main/java/template/service/Item.java @@ -0,0 +1,18 @@ +package template.service; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +public class Item { + + private Long id; + + private String name; + +} diff --git a/src/main/java/template/service/ItemsService.java b/src/main/java/template/service/ItemsService.java new file mode 100644 index 0000000..96523c8 --- /dev/null +++ b/src/main/java/template/service/ItemsService.java @@ -0,0 +1,76 @@ +package template.service; + +import com.google.common.annotations.VisibleForTesting; +import lombok.AllArgsConstructor; +import org.modelmapper.ModelMapper; +import org.springframework.stereotype.Service; +import template.api.model.ItemDTO; +import template.exception.ItemIdAlreadySetException; +import template.repository.ItemEntity; +import template.repository.ItemsRepository; + +import java.util.List; +import java.util.Optional; + +@Service +@AllArgsConstructor +public class ItemsService { + + private final ItemsRepository repository; + + private final ModelMapper mapper; + + public List getItems() { + return repository.findAll().stream().map(this::toDomainObject).map(this::toDTO).toList(); + } + + public Optional getItem(Long id) { + return repository.findById(id).map(this::toDomainObject).map(this::toDTO); + } + + public void postItem(ItemDTO itemDTO) { + var item = toDomainObject(itemDTO); + + if (item.getId() != null) { + throw new ItemIdAlreadySetException(item.getId()); + } + + var itemEntity = toEntity(item); + var maxID = repository.findMaxID(); + itemEntity.setId(maxID + 1); + + repository.save(itemEntity); + } + + public void putItem(Long itemId, ItemDTO itemDTO) { + var item = toDomainObject(itemDTO); + item.setId(itemId); + repository.save(toEntity(item)); + } + + public void deleteItem(Long id) { + repository.deleteById(id); + } + + @VisibleForTesting + ItemDTO toDTO(Item item) { + return mapper.map(item, ItemDTO.class); + } + + @VisibleForTesting + Item toDomainObject(ItemDTO itemDTO) { + return mapper.map(itemDTO, Item.class); + } + + @VisibleForTesting + Item toDomainObject(ItemEntity itemEntity) { + return mapper.map(itemEntity, Item.class); + } + + @VisibleForTesting + ItemEntity toEntity(Item item) { + return mapper.map(item, ItemEntity.class); + } + +} + diff --git a/src/main/resources/api.yaml b/src/main/resources/api.yaml new file mode 100644 index 0000000..66b29fd --- /dev/null +++ b/src/main/resources/api.yaml @@ -0,0 +1,109 @@ +openapi: 3.0.0 +info: + version: 1.0.0 + title: Items API + description: Template of API using items as an example +tags: + - name: itemsAPI +paths: + /items: + get: + operationId: getItems + description: Returns a list of items + tags: + - items + responses: + '200': + description: Successful response + content: + application/json: + schema: + type: array + items: + $ref: '#/components/schemas/ItemDTO' + post: + operationId: postItem + description: Creates new item with the request content and ID set by server + tags: + - items + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/ItemDTO' + responses: + '200': + description: Successful response + '400': + description: Bad request + /items/{itemId}: + get: + operationId: getItem + description: Returns item with given ID + parameters: + - name: itemId + in: path + description: ID of an item + required: true + schema: + type: long + tags: + - items + responses: + '200': + description: Successful response + content: + application/json: + schema: + $ref: '#/components/schemas/ItemDTO' + '404': + description: Not found + put: + operationId: putItem + description: Creates new item or replaces target item with the request content + parameters: + - $ref: '#/components/parameters/itemId' + tags: + - items + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/ItemDTO' + responses: + '200': + description: Successful response + '400': + description: Bad request + delete: + operationId: deleteItem + description: Deletes item with given ID + parameters: + - $ref: '#/components/parameters/itemId' + tags: + - items + responses: + '200': + description: Successful response + '404': + description: Not found +components: + schemas: + ItemDTO: + type: object + required: + - id + - name + properties: + id: + type: long + name: + type: string + parameters: + itemId: + name: itemId + in: path + description: ID of an item + required: true + schema: + type: long \ No newline at end of file diff --git a/src/main/resources/application-dev.yaml b/src/main/resources/application-dev.yaml new file mode 100644 index 0000000..301f014 --- /dev/null +++ b/src/main/resources/application-dev.yaml @@ -0,0 +1,4 @@ +spring: + sql: + init: + data-locations: optional:classpath*:data-dev.sql \ No newline at end of file diff --git a/src/main/resources/application.yaml b/src/main/resources/application.yaml new file mode 100644 index 0000000..64c144e --- /dev/null +++ b/src/main/resources/application.yaml @@ -0,0 +1,15 @@ +spring: + profiles: + active: @activeProfile@ + datasource: + url: jdbc:h2:mem:layered + jpa: + defer-datasource-initialization: true +springdoc: + api-docs: + path: /api-docs +management: + endpoints: + web: + exposure: + include: health \ No newline at end of file diff --git a/src/main/resources/data-dev.sql b/src/main/resources/data-dev.sql new file mode 100644 index 0000000..02867ba --- /dev/null +++ b/src/main/resources/data-dev.sql @@ -0,0 +1,4 @@ +INSERT INTO item (id, name) VALUES + (1, 'Item A'), + (2, 'Item B'), + (3, 'Item C'); \ No newline at end of file diff --git a/src/test/java/template/AbstractIntegrationTest.java b/src/test/java/template/AbstractIntegrationTest.java new file mode 100644 index 0000000..be7f78b --- /dev/null +++ b/src/test/java/template/AbstractIntegrationTest.java @@ -0,0 +1,21 @@ +package template; + +import io.restassured.RestAssured; +import org.junit.jupiter.api.BeforeEach; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.web.server.LocalServerPort; + +import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT; + +@SpringBootTest(webEnvironment = RANDOM_PORT) +public abstract class AbstractIntegrationTest { + + @LocalServerPort + private int port; + + @BeforeEach + void setUp() { + RestAssured.port = this.port; + } + +} diff --git a/src/test/java/template/ApplicationIntegrationTest.java b/src/test/java/template/ApplicationIntegrationTest.java new file mode 100644 index 0000000..0c7901f --- /dev/null +++ b/src/test/java/template/ApplicationIntegrationTest.java @@ -0,0 +1,11 @@ +package template; + +import org.junit.jupiter.api.Test; + +class ApplicationIntegrationTest extends AbstractIntegrationTest { + + @Test + void shouldStartContext() { + } + +} diff --git a/src/test/java/template/api/ItemsControllerIntegrationTest.java b/src/test/java/template/api/ItemsControllerIntegrationTest.java new file mode 100644 index 0000000..6ea34c3 --- /dev/null +++ b/src/test/java/template/api/ItemsControllerIntegrationTest.java @@ -0,0 +1,163 @@ +package template.api; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.ObjectWriter; +import org.junit.jupiter.api.Test; +import template.AbstractIntegrationTest; +import template.api.model.ItemDTO; + +import static io.restassured.RestAssured.given; +import static io.restassured.RestAssured.when; +import static org.hamcrest.Matchers.emptyString; +import static org.hamcrest.Matchers.equalTo; + +class ItemsControllerIntegrationTest extends AbstractIntegrationTest { + + private final ObjectWriter objectWriter = new ObjectMapper().writer(); + + @Test + void shouldGetItem() throws JsonProcessingException { + when() + .get("/items/1") + .then() + .statusCode(200) + .assertThat() + .body(equalTo(objectWriter.writeValueAsString(new ItemDTO().id(1L).name("Item A")))); + } + + @Test + void shouldNotFindItem() { + when() + .get("/items/4") + .then() + .statusCode(404) + .assertThat() + .body(emptyString()); + } + + @Test + void shouldCreateItemByPostRequest() throws JsonProcessingException { + //given item + var item = new ItemDTO().name("Item D"); + + //when POST request with item is sent + given() + .contentType("application/json") + .body(item) + .when() + .post("/items") + .then() + .statusCode(200); + + //then item can be retrieved by ID + var expectedItem = new ItemDTO().id(4L).name("Item D"); + when() + .get("/items/4") + .then() + .statusCode(200) + .assertThat() + .body(equalTo(objectWriter.writeValueAsString(expectedItem))); + + //cleanup + when() + .delete("/items/4") + .then() + .statusCode(200); + } + + @Test + void shouldNotAcceptPostRequestWhenItemHasID() { + given() + .contentType("application/json") + .body(new ItemDTO().id(4L).name("Item D")) + .when() + .post("/items") + .then() + .statusCode(400); + } + + @Test + void shouldInsertItemByPutRequest() throws JsonProcessingException { + //given item + var item = new ItemDTO().id(4L).name("Item D"); + + //when PUT request with item is sent + given() + .contentType("application/json") + .body(item) + .when() + .put("/items/4") + .then() + .statusCode(200); + + //then item can be retrieved by ID + when() + .get("/items/4") + .then() + .statusCode(200) + .assertThat() + .body(equalTo(objectWriter.writeValueAsString(item))); + + //cleanup + when() + .delete("/items/4") + .then() + .statusCode(200); + } + + @Test + void shouldNotAcceptPutRequestWhenItemHasAmbiguousID() { + given() + .contentType("application/json") + .body(new ItemDTO().id(5L).name("Item E")) + .when() + .put("/items/6") + .then() + .statusCode(400); + } + + @Test + void shouldDeleteItem() throws JsonProcessingException { + //given item + var item = new ItemDTO().id(4L).name("Item D"); + + //and item has been put + given() + .contentType("application/json") + .body(item) + .when() + .put("/items/4") + .then() + .statusCode(200); + + //and item can be retrieved by ID + when() + .get("/items/4") + .then() + .statusCode(200) + .assertThat() + .body(equalTo(objectWriter.writeValueAsString(item))); + + //when item is deleted + when() + .delete("/items/4") + .then() + .statusCode(200); + + //then item can no longer be retrieved by ID + when() + .get("/items/4") + .then() + .statusCode(404); + } + + @Test + void shouldNotFindItemToDelete() { + when() + .delete("/items/4") + .then() + .statusCode(404); + } + +} diff --git a/src/test/java/template/api/ItemsControllerTest.java b/src/test/java/template/api/ItemsControllerTest.java new file mode 100644 index 0000000..9f75ba4 --- /dev/null +++ b/src/test/java/template/api/ItemsControllerTest.java @@ -0,0 +1,198 @@ +package template.api; + +import org.junit.jupiter.api.Test; +import template.api.model.ItemDTO; +import template.service.ItemsService; + +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.springframework.http.HttpStatus.BAD_REQUEST; +import static org.springframework.http.HttpStatus.NOT_FOUND; +import static org.springframework.http.HttpStatus.OK; +import static template.util.TestItems.createTestItemDTOs; + +class ItemsControllerTest { + + @Test + void shouldGetItem() { + //given item + var item = new ItemDTO().id(1L).name("Item A"); + + //and service + var service = mock(ItemsService.class); + when(service.getItem(1L)).thenReturn(Optional.of(item)); + + //and controller + var controller = new ItemsController(service); + + //when item is requested + var response = controller.getItem(1L); + + //then response containing expected item is returned + assertEquals(item, response.getBody()); + + //and OK status is returned + assertEquals(OK, response.getStatusCode()); + + //and service was involved in retrieving the data + verify(service).getItem(1L); + } + + @Test + void shouldNotFindItem() { + //given service + var service = mock(ItemsService.class); + when(service.getItem(1L)).thenReturn(Optional.empty()); + + //and controller + var controller = new ItemsController(service); + + //when item is requested + var response = controller.getItem(1L); + + //then response contains no item + assertNull(response.getBody()); + + //and Not Found status is returned + assertEquals(NOT_FOUND, response.getStatusCode()); + + //and service was involved in retrieving the data + verify(service).getItem(1L); + } + + @Test + void shouldGetItems() { + //given service + var service = mock(ItemsService.class); + when(service.getItems()).thenReturn(createTestItemDTOs()); + + //and controller + var controller = new ItemsController(service); + + //when items are requested + var response = controller.getItems(); + + //then response containing expected items is returned + assertEquals(createTestItemDTOs(), response.getBody()); + + //and OK status is returned + assertEquals(OK, response.getStatusCode()); + + //and service was involved in retrieving the data + verify(service).getItems(); + } + + @Test + void shouldPostItem() { + //given item + var item = new ItemDTO().name("Item A"); + + //and service + var service = mock(ItemsService.class); + + //and controller + var controller = new ItemsController(service); + + //when POST request with item is handled + var response = controller.postItem(item); + + //then OK status is returned + assertEquals(OK, response.getStatusCode()); + + //and service was involved in saving the data + verify(service).postItem(item); + } + + @Test + void shouldNotAcceptPostRequestWhenItemHasID() { + //given item + var item = new ItemDTO().id(1L).name("Item A"); + + //and service + var service = mock(ItemsService.class); + + //and controller + var controller = new ItemsController(service); + + //when POST request with item containing ID is received + var response = controller.postItem(item); + + //then Bad Request status is returned + assertEquals(BAD_REQUEST, response.getStatusCode()); + + //and service was not involved in saving the data + verify(service, never()).postItem(any()); + } + + @Test + void shouldPutItem() { + //given item + var item = new ItemDTO().name("Item A"); + + //and service + var service = mock(ItemsService.class); + + //and controller + var controller = new ItemsController(service); + + //when item is put + var response = controller.putItem(1L, item); + + //then OK status is returned + assertEquals(OK, response.getStatusCode()); + + //and service was involved in saving data + verify(service).putItem(1L, item); + } + + @Test + void shouldDeleteItem() { + //given item + var item = new ItemDTO().id(1L).name("Item A"); + + //and service + var service = mock(ItemsService.class); + when(service.getItem(item.getId())).thenReturn(Optional.of(item)); + + //and controller + var controller = new ItemsController(service); + + //when DELETE request is handled + var response = controller.deleteItem(item.getId()); + + //then OK status is returned + assertEquals(OK, response.getStatusCode()); + + //and service was involved in deleting the data + verify(service).deleteItem(item.getId()); + } + + @Test + void shouldNotFindItemToDelete() { + //given service + var service = mock(ItemsService.class); + + //and controller + var controller = new ItemsController(service); + + //and item id + var itemId = 1L; + + //when DELETE request is handled + var response = controller.deleteItem(itemId); + + //then Not Found status is returned + assertEquals(NOT_FOUND, response.getStatusCode()); + + //and service was not involved in deleting the data + verify(service, never()).deleteItem(any()); + } + +} diff --git a/src/test/java/template/misc/ActuatorIntegrationTest.java b/src/test/java/template/misc/ActuatorIntegrationTest.java new file mode 100644 index 0000000..85dfedb --- /dev/null +++ b/src/test/java/template/misc/ActuatorIntegrationTest.java @@ -0,0 +1,29 @@ +package template.misc; + +import org.junit.jupiter.api.Test; +import template.AbstractIntegrationTest; + +import static io.restassured.RestAssured.when; +import static org.hamcrest.Matchers.containsString; + +class ActuatorIntegrationTest extends AbstractIntegrationTest { + + @Test + void shouldReturnResponseFromActuatorEndpoint() { + when() + .get("/actuator") + .then() + .statusCode(200) + .body(containsString("/actuator/health")); + } + + @Test + void shouldReturnResponseFromHealthEndpoint() { + when() + .get("/actuator/health") + .then() + .statusCode(200) + .body(containsString("{\"status\":\"UP\"}")); + } + +} diff --git a/src/test/java/template/misc/OpenApiIntegrationTest.java b/src/test/java/template/misc/OpenApiIntegrationTest.java new file mode 100644 index 0000000..e3ae693 --- /dev/null +++ b/src/test/java/template/misc/OpenApiIntegrationTest.java @@ -0,0 +1,20 @@ +package template.misc; + +import org.junit.jupiter.api.Test; +import template.AbstractIntegrationTest; + +import static io.restassured.RestAssured.when; +import static org.hamcrest.Matchers.containsString; + +class OpenApiIntegrationTest extends AbstractIntegrationTest { + + @Test + void shouldReturnResponseFromOpenApiEndpoint() { + when() + .get("/api-docs") + .then() + .statusCode(200) + .body(containsString("Items API")); + } + +} diff --git a/src/test/java/template/misc/SwaggerIntegrationTest.java b/src/test/java/template/misc/SwaggerIntegrationTest.java new file mode 100644 index 0000000..0d192ad --- /dev/null +++ b/src/test/java/template/misc/SwaggerIntegrationTest.java @@ -0,0 +1,18 @@ +package template.misc; + +import org.junit.jupiter.api.Test; +import template.AbstractIntegrationTest; + +import static io.restassured.RestAssured.when; + +class SwaggerIntegrationTest extends AbstractIntegrationTest { + + @Test + void shouldReturnResponseFromSwaggerEndpoint() { + when() + .get("/swagger-ui/index.html") + .then() + .statusCode(200); + } + +} diff --git a/src/test/java/template/service/ItemsServiceTest.java b/src/test/java/template/service/ItemsServiceTest.java new file mode 100644 index 0000000..dae1d00 --- /dev/null +++ b/src/test/java/template/service/ItemsServiceTest.java @@ -0,0 +1,169 @@ +package template.service; + +import org.junit.jupiter.api.Test; +import org.modelmapper.ModelMapper; +import template.api.model.ItemDTO; +import template.exception.ItemIdAlreadySetException; +import template.repository.ItemEntity; +import template.repository.ItemsRepository; + +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static template.util.TestItems.createTestItemDTOs; +import static template.util.TestItems.createTestItemEntities; + +class ItemsServiceTest { + + @Test + void shouldGetItem() { + //given entity + var entity = ItemEntity.builder().id(1L).name("Item A").build(); + + //and repository + var repository = mock(ItemsRepository.class); + when(repository.findById(entity.getId())).thenReturn(Optional.of(entity)); + + //and service + var service = new ItemsService(repository, new ModelMapper()); + + //when item is requested + var result = service.getItem(entity.getId()); + + //then expected item is returned + var item = service.toDomainObject(entity); + assertEquals(Optional.of(service.toDTO(item)), result); + + //and repository was queried for data + verify(repository).findById(entity.getId()); + } + + @Test + void shouldNotFindItem() { + //given repository + var repository = mock(ItemsRepository.class); + when(repository.findById(1L)).thenReturn(Optional.empty()); + + //and service + var service = new ItemsService(repository, new ModelMapper()); + + //when item is requested + var result = service.getItem(1L); + + //then no items are returned + assertTrue(result.isEmpty()); + + //and repository was queried for data + verify(repository).findById(1L); + } + + @Test + void shouldGetItems() { + //given repository + var repository = mock(ItemsRepository.class); + when(repository.findAll()).thenReturn(createTestItemEntities()); + + //and service + var service = new ItemsService(repository, new ModelMapper()); + + //when items are requested + var items = service.getItems(); + + //then items are returned + assertEquals(createTestItemDTOs(), items); + + //and repository was involved in retrieving the data + verify(repository).findAll(); + } + + @Test + void shouldCreateItem() { + //given DTO + var dto = new ItemDTO().name("Item A"); + + //and repository + var repository = mock(ItemsRepository.class); + + //and service + var service = new ItemsService(repository, new ModelMapper()); + + //when item is created + service.postItem(dto); + + //then item is saved in repository + var item = service.toDomainObject(dto); + var expectedEntity = service.toEntity(item); + expectedEntity.setId(1L); + verify(repository).save(expectedEntity); + } + + @Test + void shouldNotCreateItem() { + //given DTO + var dto = new ItemDTO().name("Item A").id(1L); + + //and repository + var repository = mock(ItemsRepository.class); + + //and service + var service = new ItemsService(repository, new ModelMapper()); + + //when item is created + var exception = assertThrows(ItemIdAlreadySetException.class, () -> service.postItem(dto)); + + //then exception is thrown + var expectedMessage = "Item ID must be null when creating a new item. Expected null so the service can assign a new ID, but received: 1."; + assertEquals(expectedMessage, exception.getMessage()); + + //and item has not been saved in repository + verify(repository, never()).save(any()); + } + + @Test + void shouldPutItem() { + //given DTO + var dto = new ItemDTO().name("Item A"); + + //and repository + var repository = mock(ItemsRepository.class); + + //and service + var service = new ItemsService(repository, new ModelMapper()); + + //when item is put + service.putItem(1L, dto); + + //then item has been saved in repository with proper ID + var item = service.toDomainObject(dto); + var expectedEntity = service.toEntity(item); + expectedEntity.setId(1L); + verify(repository).save(expectedEntity); + } + + @Test + void shouldDeleteItem() { + //given entity + var entity = ItemEntity.builder().id(1L).name("Item A").build(); + + //and repository + var repository = mock(ItemsRepository.class); + when(repository.findById(entity.getId())).thenReturn(Optional.of(entity)); + + //and service + var service = new ItemsService(repository, new ModelMapper()); + + //when item is deleted + service.deleteItem(entity.getId()); + + //then item is deleted from repository + verify(repository).deleteById(entity.getId()); + } + +} diff --git a/src/test/java/template/util/TestItems.java b/src/test/java/template/util/TestItems.java new file mode 100644 index 0000000..5a461d4 --- /dev/null +++ b/src/test/java/template/util/TestItems.java @@ -0,0 +1,35 @@ +package template.util; + +import template.api.model.ItemDTO; +import template.service.Item; +import template.repository.ItemEntity; + +import java.util.List; + +public class TestItems { + + public static List createTestItemDTOs() { + var itemA = new ItemDTO().id(1L).name("Item A"); + var itemB = new ItemDTO().id(2L).name("Item B"); + var itemC = new ItemDTO().id(3L).name("Item C"); + + return List.of(itemA, itemB, itemC); + } + + public static List createTestItems() { + var itemA = Item.builder().id(1L).name("Item A").build(); + var itemB = Item.builder().id(2L).name("Item B").build(); + var itemC = Item.builder().id(3L).name("Item C").build(); + + return List.of(itemA, itemB, itemC); + } + + public static List createTestItemEntities() { + var itemA = ItemEntity.builder().id(1L).name("Item A").build(); + var itemB = ItemEntity.builder().id(2L).name("Item B").build(); + var itemC = ItemEntity.builder().id(3L).name("Item C").build(); + + return List.of(itemA, itemB, itemC); + } + +} diff --git a/src/test/resources/allure.properties b/src/test/resources/allure.properties new file mode 100644 index 0000000..6c1e0bb --- /dev/null +++ b/src/test/resources/allure.properties @@ -0,0 +1 @@ +allure.results.directory=target/allure-results \ No newline at end of file diff --git a/src/test/resources/application.yaml b/src/test/resources/application.yaml new file mode 100644 index 0000000..4f8fea4 --- /dev/null +++ b/src/test/resources/application.yaml @@ -0,0 +1,18 @@ +spring: + profiles: + active: test + datasource: + url: jdbc:h2:mem:layered-test + jpa: + defer-datasource-initialization: true + sql: + init: + data-locations: optional:classpath*:data-test.sql +springdoc: + api-docs: + path: /api-docs +management: + endpoints: + web: + exposure: + include: health \ No newline at end of file diff --git a/src/test/resources/data-test.sql b/src/test/resources/data-test.sql new file mode 100644 index 0000000..02867ba --- /dev/null +++ b/src/test/resources/data-test.sql @@ -0,0 +1,4 @@ +INSERT INTO item (id, name) VALUES + (1, 'Item A'), + (2, 'Item B'), + (3, 'Item C'); \ No newline at end of file