crudology done ☑️

.dockerignore

@@ -0,0 +1,5 @@
+.gradle
+build
+out
+*.iml
+.idea

Dockerfile

@@ -0,0 +1,23 @@
+FROM eclipse-temurin:21-jdk AS build
+
+WORKDIR /app
+
+COPY build.gradle.kts settings.gradle.kts gradlew ./
+COPY gradle ./gradle
+
+RUN chmod +x gradlew
+
+RUN ./gradlew build -x test --dry-run
+
+COPY src ./src
+RUN ./gradlew clean fatJar -x test
+
+FROM eclipse-temurin:21-jre
+
+WORKDIR /app
+
+COPY --from=build /app/build/libs/*-all.jar app.jar
+
+EXPOSE 8080
+
+CMD ["java", "--enable-preview", "-jar", "app.jar"]

README.md

@@ -1,3 +1,4 @@
+[![Review Assignment Due Date](https://classroom.github.com/assets/deadline-readme-button-22041afd0340ce965d47ae6ef1cefeee28c7c493a6346c4f15d667ab976d596c.svg)](https://classroom.github.com/a/TvkQWWs6)
 # Features of modern Java
 
 # Цели и задачи л/р:

build.gradle.kts

@@ -1,5 +1,16 @@
 plugins {
     id("java")
+    id("application")
+}
+
+application {
+    mainClass.set("org.lab.Main")
+}
+
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(21))
+    }
 }
 
 group = "org.lab"
@@ -10,11 +21,55 @@ repositories {
 }
 
 dependencies {
+    implementation("io.javalin:javalin:6.1.3")
+    implementation("ch.qos.logback:logback-classic:1.4.11")
+    implementation("org.postgresql:postgresql:42.7.8")
+    implementation("com.zaxxer:HikariCP:5.0.1")
+    implementation("com.fasterxml.jackson.core:jackson-databind:2.17.2")
+    implementation("com.fasterxml.jackson.core:jackson-core:2.17.2")
+    implementation("com.fasterxml.jackson.core:jackson-annotations:2.17.2")
+    implementation("com.google.inject:guice:5.1.0")
+    implementation("javax.inject:javax.inject:1")
+
+    compileOnly("org.projectlombok:lombok:1.18.34")
+    annotationProcessor("org.projectlombok:lombok:1.18.34")
+
+    testImplementation("org.mockito:mockito-core:5.12.0")
+    testImplementation("org.mockito:mockito-inline:5.2.0")
     testImplementation(platform("org.junit:junit-bom:5.10.0"))
     testImplementation("org.junit.jupiter:junit-jupiter")
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+    testCompileOnly("org.projectlombok:lombok:1.18.34")
+    testAnnotationProcessor("org.projectlombok:lombok:1.18.34")
+}
+
+tasks.register<Jar>("fatJar") {
+    archiveClassifier.set("all")
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    manifest {
+        attributes["Main-Class"] = "org.lab.Main"
+    }
+    from(sourceSets.main.get().output)
+
+    dependsOn(configurations.runtimeClasspath)
+    from({
+        configurations.runtimeClasspath.get().map { if (it.isDirectory) it else zipTree(it) }
+    })
+}
+
+tasks.withType<JavaCompile> {
+    options.compilerArgs.add("--enable-preview")
+}
+
+tasks.withType<Test> {
+    jvmArgs("--enable-preview")
+}
+
+tasks.withType<JavaExec> {
+    jvmArgs("--enable-preview")
 }
 
 tasks.test {
     useJUnitPlatform()
-}
+}
+

docker-compose.yml

@@ -0,0 +1,27 @@
+services:
+  postgres:
+    image: postgres:16
+    container_name: app-postgres
+    restart: always
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: mydb
+    ports:
+      - "5432:5432"
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+
+  app:
+    build: .
+    container_name: java-app
+    depends_on:
+      - postgres
+    ports:
+      - "7070:7070"
+    restart: always
+    volumes:
+      - "./app:/var/www"
+
+volumes:
+  pgdata:

src/main/java/org/lab/Main.java

@@ -1,4 +1,63 @@
-void main() {
-    IO.println("Hello and welcome!");
-}
+package org.lab;
+
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.google.inject.Stage;
+import io.javalin.Javalin;
+
+import org.lab.api.adapters.employee.EmployeeCreateAdapter;
+import org.lab.api.adapters.employee.EmployeeDeleteAdapter;
+import org.lab.api.adapters.employee.EmployeeGetAdapter;
+import org.lab.api.adapters.error_message.ErrorMessageCloseAdapter;
+import org.lab.api.adapters.error_message.ErrorMessageCreateAdapter;
+import org.lab.api.adapters.project.ProjectCreateAdapter;
+import org.lab.api.adapters.project.ProjectDeleteAdapter;
+import org.lab.api.adapters.project.ProjectGetAdapter;
+import org.lab.api.adapters.project.ProjectListAdapter;
+import org.lab.api.adapters.ticket.TicketCloseAdapter;
+import org.lab.api.adapters.ticket.TicketCreateAdapter;
+import org.lab.infra.di.AppModule;
+
+public class Main {
+
+    public static void main(String[] args) {
+        Injector injector = Guice.createInjector(Stage.DEVELOPMENT, new AppModule());
+        Javalin app = Javalin.create(config -> {}).start(7070);
+
+        EmployeeCreateAdapter createEmployeeAdapter = injector.getInstance(EmployeeCreateAdapter.class);
+        EmployeeDeleteAdapter deleteEmployeeAdapter = injector.getInstance(EmployeeDeleteAdapter.class);
+        EmployeeGetAdapter getEmployeeAdapter = injector.getInstance(EmployeeGetAdapter.class);
+
+        ProjectCreateAdapter createProjectAdapter = injector.getInstance(ProjectCreateAdapter.class);
+        ProjectGetAdapter projectGetAdapter = injector.getInstance(ProjectGetAdapter.class);
+        ProjectDeleteAdapter projectDeleteAdapter = injector.getInstance(ProjectDeleteAdapter.class);
+        ProjectListAdapter projectListAdapter = injector.getInstance(ProjectListAdapter.class);
 
+        TicketCreateAdapter ticketCreateAdapter = injector.getInstance(TicketCreateAdapter.class);
+        TicketCloseAdapter ticketCloseAdapter = injector.getInstance(TicketCloseAdapter.class);
+
+        ErrorMessageCreateAdapter errorMessageCreateAdapter = injector.getInstance(
+                ErrorMessageCreateAdapter.class
+        );
+        ErrorMessageCloseAdapter errorMessageCloseAdapter = injector.getInstance(
+                ErrorMessageCloseAdapter.class
+        );
+
+        app.get("/", ctx -> ctx.result("Hello World"));
+
+        app.post("/employee/{actorId}", createEmployeeAdapter::createEmployee);
+        app.delete("/employee/{employeeId}/{actorId}", deleteEmployeeAdapter::deleteEmployee);
+        app.get("/employee/{employeeId}/{actorId}", getEmployeeAdapter::getEmployee);
+
+        app.get("/project/list/{employeeId}", projectListAdapter::listProjects);
+        app.post("/project/{employeeId}", createProjectAdapter::createProject);
+        app.get("/project/{projectId}/{employeeId}", projectGetAdapter::getProject);
+        app.delete("/project/{projectId}/{employeeId}", projectDeleteAdapter::deleteProject);
+
+        app.post("/ticket/{employeeId}/{projectId}",  ticketCreateAdapter::createTicket);
+        app.patch("/ticket/{employeeId}/{ticketId}",  ticketCloseAdapter::closeTicket);
+
+        app.post("/error_message/{employeeId}", errorMessageCreateAdapter::createErrorMessage);
+        app.patch("/error_message/{messageId}", errorMessageCloseAdapter::closeMessage);
+    }
+}

src/main/java/org/lab/api/adapters/employee/EmployeeCreateAdapter.java

@@ -0,0 +1,58 @@
+package org.lab.api.adapters.employee;
+
+import java.util.Map;
+
+import com.google.inject.Inject;
+import io.javalin.http.Context;
+
+import org.lab.application.employee.dto.GetEmployeeDTO;
+import org.lab.application.employee.dto.CreateEmployeeDTO;
+import org.lab.application.employee.use_cases.CreateEmployeeUseCase;
+import org.lab.core.utils.mapper.ObjectMapper;
+import org.lab.domain.emploee.model.Employee;
+import org.lab.domain.shared.exceptions.NotPermittedException;
+
+public class EmployeeCreateAdapter {
+
+    private final ObjectMapper mapper;
+    private final CreateEmployeeUseCase useCase;
+
+    @Inject
+    public EmployeeCreateAdapter(
+            ObjectMapper mapper,
+            CreateEmployeeUseCase useCase
+    ) {
+        this.mapper = mapper;
+        this.useCase = useCase;
+    }
+
+    public Context createEmployee(
+            Context ctx
+    ) {
+        try {
+            int actorId = Integer.parseInt(ctx.pathParam("actorId"));
+            CreateEmployeeDTO dto = ctx.bodyAsClass(CreateEmployeeDTO.class);
+            Employee employee = mapper.mapToDomain(dto, Employee.class);
+            Employee createdEmployee = useCase.execute(
+                    employee,
+                    actorId
+            );
+            GetEmployeeDTO presentationEmployee = mapper.mapToPresentation(
+                    createdEmployee,
+                    GetEmployeeDTO.class
+            );
+            return ctx.status(201).json(presentationEmployee);
+
+        } catch (NotPermittedException e) {
+            return ctx.status(403).json(
+                    Map.of(
+                            "error",
+                            "You do not have permission to perform this operation"
+                    )
+            );
+
+        } catch (Exception e) {
+            return ctx.status(500).json(Map.of("error", "Internal server error"));
+        }
+    }
+}

src/main/java/org/lab/api/adapters/employee/EmployeeDeleteAdapter.java

@@ -0,0 +1,42 @@
+package org.lab.api.adapters.employee;
+
+import java.util.Map;
+
+import com.google.inject.Inject;
+import io.javalin.http.Context;
+import org.lab.application.employee.use_cases.DeleteEmployeeUseCase;
+import org.lab.domain.shared.exceptions.NotPermittedException;
+
+public class EmployeeDeleteAdapter {
+
+    private final DeleteEmployeeUseCase useCase;
+
+    @Inject
+    public EmployeeDeleteAdapter(
+            DeleteEmployeeUseCase useCase
+    ) {
+        this.useCase = useCase;
+    }
+
+    public Context deleteEmployee(
+            Context ctx
+    ) {
+        try {
+            int employeeId = Integer.parseInt(ctx.pathParam("employeeId"));
+            int actorId = Integer.parseInt(ctx.pathParam("actorId"));
+            this.useCase.execute(employeeId, actorId);
+            return ctx.status(201);
+
+        } catch (NotPermittedException e) {
+            return ctx.status(403).json(
+                    Map.of(
+                            "error",
+                            "You do not have permission to perform this operation"
+                    )
+            );
+
+        } catch (Exception e) {
+            return ctx.status(500).json(Map.of("error", "Internal server error"));
+        }
+    }
+}

src/main/java/org/lab/api/adapters/employee/EmployeeGetAdapter.java

@@ -0,0 +1,56 @@
+package org.lab.api.adapters.employee;
+
+import java.util.Map;
+
+import com.google.inject.Inject;
+import io.javalin.http.Context;
+
+import org.lab.application.employee.dto.GetEmployeeDTO;
+import org.lab.application.employee.use_cases.GetEmployeeUseCase;
+import org.lab.core.utils.mapper.ObjectMapper;
+import org.lab.domain.emploee.model.Employee;
+import org.lab.domain.shared.exceptions.NotPermittedException;
+
+public class EmployeeGetAdapter {
+
+    private final GetEmployeeUseCase useCase;
+    private final ObjectMapper mapper;
+
+    @Inject
+    public EmployeeGetAdapter(
+            GetEmployeeUseCase useCase,
+            ObjectMapper mapper
+    ) {
+        this.useCase = useCase;
+        this.mapper = mapper;
+    }
+
+    public Context getEmployee(
+            Context ctx
+    ) {
+        try {
+            int employeeId = Integer.parseInt(ctx.pathParam("employeeId"));
+            int actorId = Integer.parseInt(ctx.pathParam("actorId"));
+            Employee receivedEmployee = useCase.execute(
+                    employeeId,
+                    actorId
+            );
+            GetEmployeeDTO presentationEmployee = mapper.mapToPresentation(
+                    receivedEmployee,
+                    GetEmployeeDTO.class
+            );
+            return ctx.status(201).json(presentationEmployee);
+
+        } catch (NotPermittedException e) {
+            return ctx.status(403).json(
+                    Map.of(
+                            "error",
+                            "You do not have permission to perform this operation"
+                    )
+            );
+
+        } catch (Exception e) {
+            return ctx.status(500).json(Map.of("error", "Internal server error"));
+        }
+    }
+}