feat(employer): implement employer reviews

backend/api_gateway/src/main/kotlin/com/linkedout/backend/controller/EmployerController.kt

@@ -1,13 +1,16 @@
 package com.linkedout.backend.controller
 
+import com.linkedout.backend.dto.employer.CreateEmployerEvaluationDto
 import com.linkedout.backend.dto.messaging.SendMessageDto
 import com.linkedout.backend.model.Employer
+import com.linkedout.backend.model.EmployerEvaluation
 import com.linkedout.backend.model.Message
 import com.linkedout.backend.model.MessageChannel
 import com.linkedout.backend.service.EmployerService
 import com.linkedout.backend.service.MessageChannelService
 import com.linkedout.backend.service.MessageService
 import org.springframework.http.server.reactive.ServerHttpRequest
+import org.springframework.web.bind.annotation.DeleteMapping
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PathVariable
 import org.springframework.web.bind.annotation.PostMapping
@@ -29,6 +32,35 @@ class EmployerController(
         return Mono.just(employerService.findOne(request.id, employerId))
     }
 
+    @PostMapping("/{employerId}/evaluations")
+    open fun createEmployerEvaluation(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @PathVariable employerId: String,
+        @RequestBody body: CreateEmployerEvaluationDto
+    ): Mono<EmployerEvaluation> {
+        return Mono.just(employerService.createOneEvaluationOfUser(request.id, principal.name, employerId, body))
+    }
+
+    @GetMapping("/{employerId}/evaluations")
+    open fun getEmployerEvaluation(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @PathVariable employerId: String
+    ): Mono<EmployerEvaluation> {
+        return Mono.just(employerService.findOneEvaluationOfUser(request.id, principal.name, employerId))
+    }
+
+    @DeleteMapping("/{employerId}/evaluations")
+    open fun deleteEmployerEvaluation(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @PathVariable employerId: String
+    ): Mono<Unit> {
+        employerService.deleteOneEvaluationOfUser(request.id, principal.name, employerId)
+        return Mono.empty()
+    }
+
     @GetMapping("/{employerId}/messaging")
     open fun getEmployerMessaging(
         request: ServerHttpRequest,

backend/api_gateway/src/main/kotlin/com/linkedout/backend/converter/employer/CreateEmployerEvaluationDtoToProto.kt

@@ -0,0 +1,13 @@
+package com.linkedout.backend.converter.employer
+
+import com.linkedout.backend.dto.employer.CreateEmployerEvaluationDto
+import com.linkedout.proto.dto.employer.CreateEmployerEvaluationDtoOuterClass
+import org.springframework.core.convert.converter.Converter
+
+class CreateEmployerEvaluationDtoToProto : Converter<CreateEmployerEvaluationDto, CreateEmployerEvaluationDtoOuterClass.CreateEmployerEvaluationDto.Builder> {
+    override fun convert(source: CreateEmployerEvaluationDto): CreateEmployerEvaluationDtoOuterClass.CreateEmployerEvaluationDto.Builder {
+        return CreateEmployerEvaluationDtoOuterClass.CreateEmployerEvaluationDto.newBuilder()
+            .setScore(source.score)
+            .setComment(source.review)
+    }
+}

backend/api_gateway/src/main/kotlin/com/linkedout/backend/dto/employer/CreateEmployerEvaluationDto.kt

@@ -0,0 +1,6 @@
+package com.linkedout.backend.dto.employer
+
+data class CreateEmployerEvaluationDto(
+    val score: Int,
+    val review: String
+)

backend/api_gateway/src/main/kotlin/com/linkedout/backend/model/EmployerEvaluation.kt

@@ -0,0 +1,7 @@
+package com.linkedout.backend.model
+
+data class EmployerEvaluation(
+    val id: String,
+    val score: Int,
+    val review: String
+)

backend/api_gateway/src/main/kotlin/com/linkedout/backend/service/EmployerService.kt

@@ -1,9 +1,16 @@
 package com.linkedout.backend.service
 
+import com.linkedout.backend.converter.employer.CreateEmployerEvaluationDtoToProto
+import com.linkedout.backend.dto.employer.CreateEmployerEvaluationDto
 import com.linkedout.backend.model.Employer
+import com.linkedout.backend.model.EmployerEvaluation
 import com.linkedout.common.service.NatsService
 import com.linkedout.common.utils.RequestResponseFactory
+import com.linkedout.proto.models.EmployerEvaluationOuterClass
 import com.linkedout.proto.models.EmployerOuterClass
+import com.linkedout.proto.services.Employer.CreateEmployerEvaluationRequest
+import com.linkedout.proto.services.Employer.DeleteEmployerEvaluationRequest
+import com.linkedout.proto.services.Employer.GetEmployerEvaluationRequest
 import com.linkedout.proto.services.Employer.GetEmployerRequest
 import com.linkedout.proto.services.Employer.GetMultipleEmployersRequest
 import org.springframework.beans.factory.annotation.Value
@@ -13,7 +20,10 @@ import org.springframework.stereotype.Service
 class EmployerService(
     private val natsService: NatsService,
     @Value("\${app.services.employer.subjects.findOne}") private val findOneSubject: String,
-    @Value("\${app.services.employer.subjects.findMultiple}") private val findMultipleSubject: String
+    @Value("\${app.services.employer.subjects.findMultiple}") private val findMultipleSubject: String,
+    @Value("\${app.services.employer.subjects.createEvaluation}") private val createEvaluationSubject: String,
+    @Value("\${app.services.employer.subjects.deleteEvaluation}") private val deleteEvaluationSubject: String,
+    @Value("\${app.services.employer.subjects.findOneEvaluation}") private val findOneEvaluationSubject: String
 ) {
     fun findOne(requestId: String, id: String): Employer {
         // Request the employer from the employer service
@@ -57,6 +67,67 @@ class EmployerService(
         }
     }
 
+    fun createOneEvaluationOfUser(requestId: String, userId: String, employerId: String, dto: CreateEmployerEvaluationDto): EmployerEvaluation {
+        // Create the evaluation using the employer service
+        val request = RequestResponseFactory.newRequest(requestId)
+            .setCreateEmployerEvaluationRequest(
+                CreateEmployerEvaluationRequest.newBuilder()
+                    .setUserId(userId)
+                    .setEmployerId(employerId)
+                    .setEvaluation(CreateEmployerEvaluationDtoToProto().convert(dto))
+            )
+            .build()
+
+        val response = natsService.requestWithReply(createEvaluationSubject, request)
+
+        // Handle the response
+        if (!response.hasCreateEmployerEvaluationResponse()) {
+            throw Exception("Invalid response")
+        }
+
+        val createEmployerEvaluationResponse = response.createEmployerEvaluationResponse
+        return convertEvaluationFromProto(createEmployerEvaluationResponse.evaluation)
+    }
+
+    fun findOneEvaluationOfUser(requestId: String, userId: String, employerId: String): EmployerEvaluation {
+        // Request the evaluation from the employer service
+        val request = RequestResponseFactory.newRequest(requestId)
+            .setGetEmployerEvaluationRequest(
+                GetEmployerEvaluationRequest.newBuilder()
+                    .setUserId(userId)
+                    .setEmployerId(employerId)
+            )
+            .build()
+
+        val response = natsService.requestWithReply(findOneEvaluationSubject, request)
+
+        // Handle the response
+        if (!response.hasGetEmployerEvaluationResponse()) {
+            throw Exception("Invalid response")
+        }
+
+        val getEmployerEvaluationResponse = response.getEmployerEvaluationResponse
+        return convertEvaluationFromProto(getEmployerEvaluationResponse.evaluation)
+    }
+
+    fun deleteOneEvaluationOfUser(requestId: String, userId: String, employerId: String) {
+        // Delete the evaluation using the employer service
+        val request = RequestResponseFactory.newRequest(requestId)
+            .setDeleteEmployerEvaluationRequest(
+                DeleteEmployerEvaluationRequest.newBuilder()
+                    .setUserId(userId)
+                    .setEmployerId(employerId)
+            )
+            .build()
+
+        val response = natsService.requestWithReply(deleteEvaluationSubject, request)
+
+        // Handle the response
+        if (!response.hasDeleteEmployerEvaluationResponse()) {
+            throw Exception("Invalid response")
+        }
+    }
+
     private fun convertEmployerFromProto(source: EmployerOuterClass.Employer): Employer {
         return Employer(
             source.id,
@@ -66,4 +137,12 @@ class EmployerService(
             source.phone
         )
     }
+
+    private fun convertEvaluationFromProto(source: EmployerEvaluationOuterClass.EmployerEvaluation): EmployerEvaluation {
+        return EmployerEvaluation(
+            source.id,
+            source.score,
+            source.comment
+        )
+    }
 }

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

@@ -49,6 +49,9 @@ app:
       subjects:
         findOne: employer.findOne
         findMultiple: employer.findMultiple
+        createEvaluation: employer.createEvaluation
+        deleteEvaluation: employer.deleteEvaluation
+        findOneEvaluation: employer.findOneEvaluation
     notifications:
       subjects:
         sendTo: notifications.sendTo

backend/employer/src/main/kotlin/com/linkedout/employer/converter/evaluation/CreateEvaluationDtoFromProto.kt

@@ -0,0 +1,14 @@
+package com.linkedout.employer.converter.evaluation
+
+import com.linkedout.employer.dto.evaluation.CreateEvaluationDto
+import com.linkedout.proto.dto.employer.CreateEmployerEvaluationDtoOuterClass
+import org.springframework.core.convert.converter.Converter
+
+class CreateEvaluationDtoFromProto : Converter<CreateEmployerEvaluationDtoOuterClass.CreateEmployerEvaluationDto, CreateEvaluationDto> {
+    override fun convert(source: CreateEmployerEvaluationDtoOuterClass.CreateEmployerEvaluationDto): CreateEvaluationDto {
+        return CreateEvaluationDto(
+            source.score,
+            source.comment
+        )
+    }
+}

backend/employer/src/main/kotlin/com/linkedout/employer/converter/evaluation/EvaluationToProto.kt

@@ -0,0 +1,14 @@
+package com.linkedout.employer.converter.evaluation
+
+import com.linkedout.employer.model.Evaluation
+import com.linkedout.proto.models.EmployerEvaluationOuterClass
+import org.springframework.core.convert.converter.Converter
+
+class EvaluationToProto : Converter<Evaluation, EmployerEvaluationOuterClass.EmployerEvaluation.Builder> {
+    override fun convert(source: Evaluation): EmployerEvaluationOuterClass.EmployerEvaluation.Builder {
+        return EmployerEvaluationOuterClass.EmployerEvaluation.newBuilder()
+            .setId(source.id.toString())
+            .setScore(source.score)
+            .setComment(source.comment)
+    }
+}

backend/employer/src/main/kotlin/com/linkedout/employer/dto/evaluation/CreateEvaluationDto.kt

@@ -0,0 +1,6 @@
+package com.linkedout.employer.dto.evaluation
+
+data class CreateEvaluationDto(
+    val score: Int,
+    val comment: String
+)

backend/employer/src/main/kotlin/com/linkedout/employer/function/evaluation/CreateEvaluation.kt

@@ -0,0 +1,42 @@
+package com.linkedout.employer.function.evaluation
+
+import com.linkedout.common.utils.RequestResponseFactory
+import com.linkedout.common.utils.handleRequestError
+import com.linkedout.employer.converter.evaluation.CreateEvaluationDtoFromProto
+import com.linkedout.employer.converter.evaluation.EvaluationToProto
+import com.linkedout.employer.service.EvaluationService
+import com.linkedout.proto.RequestOuterClass.Request
+import com.linkedout.proto.ResponseOuterClass.Response
+import com.linkedout.proto.services.Employer.CreateEmployerEvaluationResponse
+import org.springframework.stereotype.Component
+import java.util.*
+import java.util.function.Function
+
+@Component
+class CreateEvaluation(private val evaluationService: EvaluationService) : Function<Request, Response> {
+    override fun apply(t: Request): Response = handleRequestError {
+        // Extract the request
+        val request = t.createEmployerEvaluationRequest
+        val userId = UUID.fromString(request.userId)
+        val employerId = UUID.fromString(request.employerId)
+        val requestDto = CreateEvaluationDtoFromProto().convert(request.evaluation)
+
+        // Create the evaluation
+        val reactiveResponse = evaluationService.saveOneOfUserAndEmployer(userId, employerId, requestDto)
+            .map { evaluation ->
+                EvaluationToProto().convert(evaluation)
+            }
+            .map { evaluation ->
+                CreateEmployerEvaluationResponse.newBuilder()
+                    .setEvaluation(evaluation)
+                    .build()
+            }
+
+        // Block until the response is ready
+        val response = reactiveResponse.block()
+
+        return RequestResponseFactory.newSuccessfulResponse()
+            .setCreateEmployerEvaluationResponse(response)
+            .build()
+    }
+}

backend/employer/src/main/kotlin/com/linkedout/employer/function/evaluation/DeleteEvaluation.kt

@@ -0,0 +1,28 @@
+package com.linkedout.employer.function.evaluation
+
+import com.linkedout.common.utils.RequestResponseFactory
+import com.linkedout.common.utils.handleRequestError
+import com.linkedout.employer.service.EvaluationService
+import com.linkedout.proto.RequestOuterClass.Request
+import com.linkedout.proto.ResponseOuterClass.Response
+import com.linkedout.proto.services.Employer
+import org.springframework.stereotype.Component
+import java.util.*
+import java.util.function.Function
+
+@Component
+class DeleteEvaluation(private val evaluationService: EvaluationService) : Function<Request, Response> {
+    override fun apply(t: Request): Response = handleRequestError {
+        // Extract the request
+        val request = t.deleteEmployerEvaluationRequest
+        val userId = UUID.fromString(request.userId)
+        val employerId = UUID.fromString(request.employerId)
+
+        // Delete the evaluation
+        evaluationService.deleteByUserIdAndEmployerId(userId, employerId).block()
+
+        return RequestResponseFactory.newSuccessfulResponse()
+            .setDeleteEmployerEvaluationResponse(Employer.DeleteEmployerEvaluationResponse.getDefaultInstance())
+            .build()
+    }
+}

backend/employer/src/main/kotlin/com/linkedout/employer/function/evaluation/GetEvaluation.kt

@@ -0,0 +1,42 @@
+package com.linkedout.employer.function.evaluation
+
+import com.linkedout.common.utils.RequestResponseFactory
+import com.linkedout.common.utils.handleRequestError
+import com.linkedout.employer.converter.evaluation.EvaluationToProto
+import com.linkedout.employer.service.EvaluationService
+import com.linkedout.proto.RequestOuterClass.Request
+import com.linkedout.proto.ResponseOuterClass.Response
+import com.linkedout.proto.services.Employer.GetEmployerEvaluationResponse
+import org.springframework.http.HttpStatus
+import org.springframework.stereotype.Component
+import java.util.*
+import java.util.function.Function
+
+@Component
+class GetEvaluation(private val evaluationService: EvaluationService) : Function<Request, Response> {
+    override fun apply(t: Request): Response = handleRequestError {
+        // Extract the request
+        val request = t.getEmployerEvaluationRequest
+        val userId = UUID.fromString(request.userId)
+        val employerId = UUID.fromString(request.employerId)
+
+        // Get the evaluation from the database
+        val reactiveResponse = evaluationService.findByUserIdAndEmployerId(userId, employerId)
+            .map { evaluation ->
+                EvaluationToProto().convert(evaluation)
+            }
+            .map { evaluation ->
+                GetEmployerEvaluationResponse.newBuilder()
+                    .setEvaluation(evaluation)
+                    .build()
+            }
+
+        // Block until the response is ready
+        val response = reactiveResponse.block()
+            ?: return RequestResponseFactory.newFailedResponse("Evaluation not found", HttpStatus.NOT_FOUND).build()
+
+        return RequestResponseFactory.newSuccessfulResponse()
+            .setGetEmployerEvaluationResponse(response)
+            .build()
+    }
+}

backend/employer/src/main/kotlin/com/linkedout/employer/model/Evaluation.kt

@@ -0,0 +1,17 @@
+package com.linkedout.employer.model
+
+import org.springframework.data.annotation.Id
+import org.springframework.data.relational.core.mapping.Table
+import java.time.LocalDateTime
+import java.util.*
+
+@Table("evaluation")
+data class Evaluation(
+    @Id
+    val id: UUID,
+    val userId: UUID,
+    val employerId: UUID,
+    val score: Int,
+    val comment: String,
+    val createdAt: LocalDateTime
+)