feat(profile): implement service

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

@@ -0,0 +1,65 @@
+package com.linkedout.backend.controller
+
+import com.linkedout.backend.dto.availability.CreateAvailabilityDto
+import com.linkedout.backend.dto.availability.UpdateAvailabilityDto
+import com.linkedout.backend.model.Availability
+import com.linkedout.backend.service.AvailabilityService
+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.PatchMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+import reactor.core.publisher.Flux
+import reactor.core.publisher.Mono
+import java.security.Principal
+
+@RestController
+@RequestMapping("/api/v1/profile/availabilities")
+class AvailabilityController(private val availabilityService: AvailabilityService) {
+    @GetMapping
+    open fun getAvailabilities(request: ServerHttpRequest, principal: Principal): Flux<Availability> {
+        return Flux.fromIterable(availabilityService.findAllOfUser(request.id, principal.name))
+    }
+
+    @PostMapping
+    open fun createAvailability(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @RequestBody body: CreateAvailabilityDto
+    ): Mono<Availability> {
+        return Mono.just(availabilityService.createOneOfUser(request.id, principal.name, body))
+    }
+
+    @PatchMapping("/{availabilityId}")
+    open fun updateAvailability(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @PathVariable availabilityId: String,
+        @RequestBody body: UpdateAvailabilityDto
+    ): Mono<Availability> {
+        return Mono.just(availabilityService.updateOneOfUser(request.id, principal.name, availabilityId, body))
+    }
+
+    @GetMapping("/{availabilityId}")
+    open fun getAvailability(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @PathVariable availabilityId: String
+    ): Mono<Availability> {
+        return Mono.just(availabilityService.findOneOfUser(request.id, principal.name, availabilityId))
+    }
+
+    @DeleteMapping("/{availabilityId}")
+    open fun deleteAvailability(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @PathVariable availabilityId: String
+    ): Mono<Unit> {
+        availabilityService.deleteOneOfUser(request.id, principal.name, availabilityId)
+        return Mono.empty()
+    }
+}

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

@@ -0,0 +1,30 @@
+package com.linkedout.backend.controller
+
+import com.linkedout.backend.model.EmployeeEvaluation
+import com.linkedout.backend.service.EmployeeEvaluationService
+import org.springframework.http.server.reactive.ServerHttpRequest
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+import reactor.core.publisher.Flux
+import reactor.core.publisher.Mono
+import java.security.Principal
+
+@RestController
+@RequestMapping("/api/v1/profile/evaluations")
+class EmployeeEvaluationController(private val employeeEvaluationService: EmployeeEvaluationService) {
+    @GetMapping
+    open fun getEvaluations(request: ServerHttpRequest, principal: Principal): Flux<EmployeeEvaluation> {
+        return Flux.fromIterable(employeeEvaluationService.findAllOfUser(request.id, principal.name))
+    }
+
+    @GetMapping("/{evaluationId}")
+    open fun getEvaluation(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @PathVariable evaluationId: String
+    ): Mono<EmployeeEvaluation> {
+        return Mono.just(employeeEvaluationService.findOneOfUser(request.id, principal.name, evaluationId))
+    }
+}

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

@@ -0,0 +1,65 @@
+package com.linkedout.backend.controller
+
+import com.linkedout.backend.dto.experience.CreateExperienceDto
+import com.linkedout.backend.dto.experience.UpdateExperienceDto
+import com.linkedout.backend.model.Experience
+import com.linkedout.backend.service.ExperienceService
+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.PatchMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+import reactor.core.publisher.Flux
+import reactor.core.publisher.Mono
+import java.security.Principal
+
+@RestController
+@RequestMapping("/api/v1/profile/experiences")
+class ExperienceController(private val experienceService: ExperienceService) {
+    @GetMapping
+    open fun getExperiences(request: ServerHttpRequest, principal: Principal): Flux<Experience> {
+        return Flux.fromIterable(experienceService.findAllOfUser(request.id, principal.name))
+    }
+
+    @PostMapping
+    open fun createExperience(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @RequestBody body: CreateExperienceDto
+    ): Mono<Experience> {
+        return Mono.just(experienceService.createOneOfUser(request.id, principal.name, body))
+    }
+
+    @PatchMapping("/{experienceId}")
+    open fun updateExperience(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @PathVariable experienceId: String,
+        @RequestBody body: UpdateExperienceDto
+    ): Mono<Experience> {
+        return Mono.just(experienceService.updateOneOfUser(request.id, principal.name, experienceId, body))
+    }
+
+    @GetMapping("/{experienceId}")
+    open fun getExperience(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @PathVariable experienceId: String
+    ): Mono<Experience> {
+        return Mono.just(experienceService.findOneOfUser(request.id, principal.name, experienceId))
+    }
+
+    @DeleteMapping("/{experienceId}")
+    open fun deleteExperience(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @PathVariable experienceId: String
+    ): Mono<Unit> {
+        experienceService.deleteOneOfUser(request.id, principal.name, experienceId)
+        return Mono.empty()
+    }
+}

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

@@ -0,0 +1,72 @@
+package com.linkedout.backend.controller
+
+import com.linkedout.backend.dto.profile.ProfileWithStatsDto
+import com.linkedout.backend.dto.profile.SetProfileDto
+import com.linkedout.backend.dto.profile.UpdateProfileDto
+import com.linkedout.backend.model.Profile
+import com.linkedout.backend.service.ProfileService
+import org.springframework.http.server.reactive.ServerHttpRequest
+import org.springframework.security.access.prepost.PreAuthorize
+import org.springframework.web.bind.annotation.DeleteMapping
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PatchMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.PutMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+import reactor.core.publisher.Flux
+import reactor.core.publisher.Mono
+import java.security.Principal
+
+@RestController
+@RequestMapping("/api/v1/profile")
+class ProfileController(
+    private val profileService: ProfileService
+) {
+    @GetMapping
+    open fun getProfile(request: ServerHttpRequest, principal: Principal): Mono<ProfileWithStatsDto> {
+        return Mono.just(profileService.findOne(request.id, principal.name))
+    }
+
+    @PutMapping
+    open fun setProfile(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @RequestBody body: SetProfileDto
+    ): Mono<Profile> {
+        return Mono.just(profileService.setOne(request.id, principal.name, body))
+    }
+
+    @PatchMapping
+    open fun updateProfile(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @RequestBody body: UpdateProfileDto
+    ): Mono<Profile> {
+        return Mono.just(profileService.updateOne(request.id, principal.name, body))
+    }
+
+    @PostMapping("/requestDeletion")
+    open fun requestDeletion(request: ServerHttpRequest, principal: Principal): Mono<Unit> {
+        profileService.requestDeletion(request.id, principal.name)
+        return Mono.empty()
+    }
+
+    @GetMapping("/requestDeletion")
+    @PreAuthorize("hasRole('client_admin')")
+    open fun getProfilesRequestingDeletion(request: ServerHttpRequest): Flux<Profile> {
+        return Flux.fromIterable(profileService.getProfilesRequestingDeletion(request.id))
+    }
+
+    @DeleteMapping("/{profileId}")
+    @PreAuthorize("hasRole('client_admin')")
+    open fun deleteProfile(
+        request: ServerHttpRequest,
+        @PathVariable profileId: String
+    ): Mono<Unit> {
+        profileService.deleteOne(request.id, profileId)
+        return Mono.empty()
+    }
+}

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

@@ -0,0 +1,65 @@
+package com.linkedout.backend.controller
+
+import com.linkedout.backend.dto.reference.CreateReferenceDto
+import com.linkedout.backend.dto.reference.UpdateReferenceDto
+import com.linkedout.backend.model.Reference
+import com.linkedout.backend.service.ReferenceService
+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.PatchMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+import reactor.core.publisher.Flux
+import reactor.core.publisher.Mono
+import java.security.Principal
+
+@RestController
+@RequestMapping("/api/v1/profile/references")
+class ReferenceController(private val referenceService: ReferenceService) {
+    @GetMapping
+    open fun getReferences(request: ServerHttpRequest, principal: Principal): Flux<Reference> {
+        return Flux.fromIterable(referenceService.findAllOfUser(request.id, principal.name))
+    }
+
+    @PostMapping
+    open fun createReference(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @RequestBody body: CreateReferenceDto
+    ): Mono<Reference> {
+        return Mono.just(referenceService.createOneOfUser(request.id, principal.name, body))
+    }
+
+    @PatchMapping("/{referenceId}")
+    open fun updateReference(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @PathVariable referenceId: String,
+        @RequestBody body: UpdateReferenceDto
+    ): Mono<Reference> {
+        return Mono.just(referenceService.updateOneOfUser(request.id, principal.name, referenceId, body))
+    }
+
+    @GetMapping("/{referenceId}")
+    open fun getReference(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @PathVariable referenceId: String
+    ): Mono<Reference> {
+        return Mono.just(referenceService.findOneOfUser(request.id, principal.name, referenceId))
+    }
+
+    @DeleteMapping("/{referenceId}")
+    open fun deleteReference(
+        request: ServerHttpRequest,
+        principal: Principal,
+        @PathVariable referenceId: String
+    ): Mono<Unit> {
+        referenceService.deleteOneOfUser(request.id, principal.name, referenceId)
+        return Mono.empty()
+    }
+}

backend/api_gateway/src/main/kotlin/com/linkedout/backend/converter/availability/CreateAvailabilityDtoToProto.kt

@@ -0,0 +1,22 @@
+package com.linkedout.backend.converter.availability
+
+import com.linkedout.backend.dto.availability.CreateAvailabilityDto
+import com.linkedout.proto.dto.availability.CreateAvailabilityDtoOuterClass
+import com.linkedout.proto.models.AddressOuterClass
+import org.springframework.core.convert.converter.Converter
+
+class CreateAvailabilityDtoToProto : Converter<CreateAvailabilityDto, CreateAvailabilityDtoOuterClass.CreateAvailabilityDto.Builder> {
+    override fun convert(source: CreateAvailabilityDto): CreateAvailabilityDtoOuterClass.CreateAvailabilityDto.Builder {
+        return CreateAvailabilityDtoOuterClass.CreateAvailabilityDto.newBuilder()
+            .setStartDate(source.startDate.toEpochDay())
+            .setEndDate(source.endDate.toEpochDay())
+            .setAddress(
+                AddressOuterClass.Address.newBuilder()
+                    .setFirstLine(source.address.firstLine)
+                    .setZipCode(source.address.zipCode)
+                    .setCity(source.address.city)
+            )
+            .setRange(source.range)
+            .setJobCategoryId(source.jobCategoryId)
+    }
+}

backend/api_gateway/src/main/kotlin/com/linkedout/backend/converter/availability/UpdateAvailabilityDtoToProto.kt

@@ -0,0 +1,23 @@
+package com.linkedout.backend.converter.availability
+
+import com.linkedout.backend.dto.availability.UpdateAvailabilityDto
+import com.linkedout.proto.dto.availability.UpdateAvailabilityDtoOuterClass
+import org.springframework.core.convert.converter.Converter
+
+class UpdateAvailabilityDtoToProto : Converter<UpdateAvailabilityDto, UpdateAvailabilityDtoOuterClass.UpdateAvailabilityDto.Builder> {
+    override fun convert(source: UpdateAvailabilityDto): UpdateAvailabilityDtoOuterClass.UpdateAvailabilityDto.Builder {
+        val targetBuilder = UpdateAvailabilityDtoOuterClass.UpdateAvailabilityDto.newBuilder()
+        if (source.startDate != null) targetBuilder.setStartDate(source.startDate.toEpochDay())
+        if (source.endDate != null) targetBuilder.setEndDate(source.endDate.toEpochDay())
+        if (source.range != null) targetBuilder.setRange(source.range)
+        if (source.jobCategoryId != null) targetBuilder.setJobCategoryId(source.jobCategoryId)
+
+        if (source.address != null) {
+            targetBuilder.setAddressFirstLine(source.address.firstLine)
+            targetBuilder.setAddressZip(source.address.zipCode)
+            targetBuilder.setAddressCity(source.address.city)
+        }
+
+        return targetBuilder
+    }
+}