Remove the Mono.xxx wrapping from the controllers

server/src/main/java/com/objectcomputing/checkins/notifications/email/MailJetNotificationController.java

@@ -1,6 +1,6 @@
 package com.objectcomputing.checkins.notifications.email;
 
-
+import com.objectcomputing.checkins.services.memberprofile.MemberProfile;
 import com.objectcomputing.checkins.services.memberprofile.currentuser.CurrentUserServices;
 import io.micronaut.http.HttpResponse;
 import io.micronaut.http.annotation.Controller;
@@ -10,10 +10,9 @@
 import io.micronaut.security.annotation.Secured;
 import io.micronaut.security.rules.SecurityRule;
 import jakarta.inject.Named;
-import reactor.core.publisher.Mono;
 
 @Controller("/services/email-notifications")
-@ExecuteOn(TaskExecutors.IO)
+@ExecuteOn(TaskExecutors.BLOCKING)
 @Secured(SecurityRule.IS_AUTHENTICATED)
 public class MailJetNotificationController {
 
@@ -27,18 +26,14 @@ public MailJetNotificationController(CurrentUserServices currentUserServices,
     }
 
     @Post
-    public Mono<HttpResponse<?>> sendEmailReceivesStatus(String subject, String content, String... recipients) {
-        return Mono.fromCallable(currentUserServices::getCurrentUser)
-                .map(currentUser -> {
-                    String fromName = currentUser.getFirstName() + " " + currentUser.getLastName();
-                    return emailSender.sendEmailReceivesStatus(fromName, currentUser.getWorkEmail(), subject, content, recipients);
-                })
-                .map(success -> {
-                    if(success){
-                        return HttpResponse.ok();
-                    } else {
-                        return HttpResponse.serverError();
-                    }
-                });
+    public HttpResponse<Void> sendEmailReceivesStatus(String subject, String content, String... recipients) {
+        MemberProfile currentUser = currentUserServices.getCurrentUser();
+        String fromName = currentUser.getFirstName() + " " + currentUser.getLastName();
+        boolean success = emailSender.sendEmailReceivesStatus(fromName, currentUser.getWorkEmail(), subject, content, recipients);
+        if(success){
+            return HttpResponse.ok();
+        } else {
+            return HttpResponse.serverError();
+        }
     }
 }

server/src/main/java/com/objectcomputing/checkins/services/checkins/CheckInController.java

@@ -1,20 +1,22 @@
 package com.objectcomputing.checkins.services.checkins;
 
-import com.objectcomputing.checkins.exceptions.NotFoundException;
 import com.objectcomputing.checkins.services.permissions.Permission;
 import com.objectcomputing.checkins.services.permissions.RequiredPermission;
 import io.micronaut.core.annotation.Nullable;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.HttpResponse;
-import io.micronaut.http.annotation.*;
+import io.micronaut.http.annotation.Body;
+import io.micronaut.http.annotation.Controller;
+import io.micronaut.http.annotation.Get;
+import io.micronaut.http.annotation.Post;
+import io.micronaut.http.annotation.Put;
 import io.micronaut.scheduling.TaskExecutors;
 import io.micronaut.scheduling.annotation.ExecuteOn;
 import io.micronaut.security.annotation.Secured;
 import io.micronaut.security.rules.SecurityRule;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotNull;
-import reactor.core.publisher.Mono;
 
 import java.net.URI;
 import java.util.Set;
@@ -41,9 +43,8 @@ public CheckInController(CheckInServices checkInServices) {
      */
     @Get("/{?teamMemberId,pdlId,completed}")
     @RequiredPermission(Permission.CAN_VIEW_CHECKINS)
-    public Mono<HttpResponse<Set<CheckIn>>> findCheckIns(@Nullable UUID teamMemberId, @Nullable UUID pdlId, @Nullable Boolean completed) {
-        return Mono.fromCallable(() -> checkInServices.findByFields(teamMemberId, pdlId, completed))
-                .map(HttpResponse::ok);
+    public Set<CheckIn> findCheckIns(@Nullable UUID teamMemberId, @Nullable UUID pdlId, @Nullable Boolean completed) {
+        return checkInServices.findByFields(teamMemberId, pdlId, completed);
     }
 
     /**
@@ -52,13 +53,12 @@ public Mono<HttpResponse<Set<CheckIn>>> findCheckIns(@Nullable UUID teamMemberId
      * @param checkIn, {@link CheckInCreateDTO}
      * @return {@link HttpResponse<CheckIn>}
      */
-
     @Post
     @RequiredPermission(Permission.CAN_CREATE_CHECKINS)
-    public Mono<HttpResponse<CheckIn>> createCheckIn(@Body @Valid CheckInCreateDTO checkIn, HttpRequest<?> request) {
-        return Mono.fromCallable(() -> checkInServices.save(new CheckIn(checkIn.getTeamMemberId(), checkIn.getPdlId(), checkIn.getCheckInDate(), checkIn.isCompleted())))
-                .map(createdCheckIn -> HttpResponse.created(createdCheckIn)
-                        .headers(headers -> headers.location(URI.create(String.format("%s/%s", request.getPath(), createdCheckIn.getId())))));
+    public HttpResponse<CheckIn> createCheckIn(@Body @Valid CheckInCreateDTO checkIn, HttpRequest<?> request) {
+        CheckIn createdCheckIn = checkInServices.save(new CheckIn(checkIn.getTeamMemberId(), checkIn.getPdlId(), checkIn.getCheckInDate(), checkIn.isCompleted()));
+        return HttpResponse.created(createdCheckIn)
+                .headers(headers -> headers.location(URI.create(String.format("%s/%s", request.getPath(), createdCheckIn.getId()))));
     }
 
     /**
@@ -69,23 +69,19 @@ public Mono<HttpResponse<CheckIn>> createCheckIn(@Body @Valid CheckInCreateDTO c
      */
     @Put
     @RequiredPermission(Permission.CAN_UPDATE_CHECKINS)
-    public Mono<HttpResponse<CheckIn>> update(@Body @Valid @NotNull CheckIn checkIn, HttpRequest<?> request) {
-        return Mono.fromCallable(() -> checkInServices.update(checkIn))
-                .map(updatedCheckIn -> HttpResponse.ok(updatedCheckIn)
-                        .headers(headers -> headers.location(URI.create(String.format("%s/%s", request.getPath(), updatedCheckIn.getId())))));
-
+    public HttpResponse<CheckIn> update(@Body @Valid @NotNull CheckIn checkIn, HttpRequest<?> request) {
+        CheckIn updatedCheckIn = checkInServices.update(checkIn);
+        return HttpResponse.ok(updatedCheckIn)
+                .headers(headers -> headers.location(URI.create(String.format("%s/%s", request.getPath(), updatedCheckIn.getId()))));
     }
 
     /**
-     * @param id
-     * @return
+     * @param id {@link UUID} the id of the check-in to read
+     * @return {@link CheckIn} the check-in
      */
     @Get("/{id}")
     @RequiredPermission(Permission.CAN_VIEW_CHECKINS)
-    public Mono<HttpResponse<CheckIn>> readCheckIn(@NotNull UUID id) {
-        return Mono.fromCallable(() -> checkInServices.read(id))
-                .switchIfEmpty(Mono.error(new NotFoundException("No checkin for UUID")))
-                .map(HttpResponse::ok);
-
+    public CheckIn readCheckIn(@NotNull UUID id) {
+        return checkInServices.read(id);
     }
 }

server/src/main/java/com/objectcomputing/checkins/services/demographics/DemographicsController.java

@@ -3,20 +3,25 @@
 import io.micronaut.core.annotation.Nullable;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.HttpResponse;
-import io.micronaut.http.annotation.*;
+import io.micronaut.http.HttpStatus;
+import io.micronaut.http.annotation.Body;
+import io.micronaut.http.annotation.Controller;
+import io.micronaut.http.annotation.Delete;
+import io.micronaut.http.annotation.Get;
+import io.micronaut.http.annotation.Post;
+import io.micronaut.http.annotation.Put;
+import io.micronaut.http.annotation.Status;
 import io.micronaut.scheduling.TaskExecutors;
 import io.micronaut.scheduling.annotation.ExecuteOn;
 import io.micronaut.security.annotation.Secured;
 import io.micronaut.security.rules.SecurityRule;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotNull;
-import reactor.core.publisher.Mono;
 
 import java.net.URI;
 import java.util.List;
 import java.util.UUID;
-import java.util.stream.Collectors;
 
 @Controller("/services/demographics")
 @ExecuteOn(TaskExecutors.BLOCKING)
@@ -37,38 +42,38 @@ public DemographicsController(DemographicsServices demographicsServices) {
      * @return {@link DemographicsResponseDTO} Returned demographic
      */
     @Get("/{id}")
-    public Mono<HttpResponse<DemographicsResponseDTO>> getById(UUID id) {
-        return Mono.fromCallable(() -> demographicsServices.getById(id))
-                .map(demographic -> HttpResponse.ok(fromEntity(demographic))
-                        .headers(headers -> headers.location(location(demographic.getId()))));
+    public HttpResponse<DemographicsResponseDTO> getById(UUID id) {
+        Demographics demographic = demographicsServices.getById(id);
+        return demographic == null ? null : HttpResponse.ok(fromEntity(demographic))
+                .headers(headers -> headers.location(location(demographic.getId())));
     }
 
     /**
      * Find demographics by memberId, gender, degreeLevel, industryTenure, personOfColor, veteran, militaryTenure, militaryBranch or find all.
      *
-     * @param memberId {@link UUID} Find demographics with the given memberId
-     * @param gender {@link String} Find demographics with the given gender
-     * @param degreeLevel {@link String} Find demographics with given degree level
+     * @param memberId       {@link UUID} Find demographics with the given memberId
+     * @param gender         {@link String} Find demographics with the given gender
+     * @param degreeLevel    {@link String} Find demographics with given degree level
      * @param industryTenure {@link Integer} Find demographics with given industry tenure
-     * @param personOfColor {@link Boolean} Find demographics who are persons of color
-     * @param veteran {@link Boolean} Find demographics for are veterans
+     * @param personOfColor  {@link Boolean} Find demographics who are persons of color
+     * @param veteran        {@link Boolean} Find demographics for are veterans
      * @param militaryTenure {@link Integer} Find demographics with given military tenure
      * @param militaryBranch {@link String} Find demographics with given military branch
      * @return {@link List <DemographicsResponseDTO>} List of demographics that match the input parameters
      */
     @Get("/{?memberId,gender,degreeLevel,industryTenure,personOfColor,veteran,militaryTenure,militaryBranch}")
-    public Mono<HttpResponse<List<DemographicsResponseDTO>>> findByValue(@Nullable UUID memberId,
-                                                                            @Nullable String gender,
-                                                                            @Nullable String degreeLevel,
-                                                                            @Nullable Integer industryTenure,
-                                                                            @Nullable Boolean personOfColor,
-                                                                            @Nullable Boolean veteran,
-                                                                            @Nullable Integer militaryTenure,
-                                                                            @Nullable String militaryBranch) {
-        return Mono.fromCallable(() -> demographicsServices.findByValues(memberId, gender, degreeLevel, industryTenure,
-                        personOfColor, veteran, militaryTenure, militaryBranch))
-                .map(demographicsEntities -> demographicsEntities.stream().map(this::fromEntity).collect(Collectors.toList()))
-                .map(HttpResponse::ok);
+    public List<DemographicsResponseDTO> findByValue(@Nullable UUID memberId,
+                                                     @Nullable String gender,
+                                                     @Nullable String degreeLevel,
+                                                     @Nullable Integer industryTenure,
+                                                     @Nullable Boolean personOfColor,
+                                                     @Nullable Boolean veteran,
+                                                     @Nullable Integer militaryTenure,
+                                                     @Nullable String militaryBranch) {
+        return demographicsServices.findByValues(memberId, gender, degreeLevel, industryTenure, personOfColor, veteran, militaryTenure, militaryBranch)
+                .stream()
+                .map(this::fromEntity)
+                .toList();
     }
 
     /**
@@ -78,15 +83,12 @@ public Mono<HttpResponse<List<DemographicsResponseDTO>>> findByValue(@Nullable U
      * @return {@link DemographicsResponseDTO} The created demographics
      */
     @Post
-    public Mono<HttpResponse<DemographicsResponseDTO>> save(@Body @Valid DemographicsCreateDTO demographics,
-                                                            HttpRequest<?> request) {
-
-        return Mono.fromCallable(() -> demographicsServices.saveDemographics(fromDTO(demographics)))
-                .map(savedDemographics -> {
-                        DemographicsResponseDTO savedDemographicsResponse = fromEntity(savedDemographics);
-                        return HttpResponse.created(savedDemographicsResponse)
-                                .headers(headers -> headers.location(URI.create(String.format("%s/%s", request.getPath(), savedDemographicsResponse.getId()))));
-                });
+    public HttpResponse<DemographicsResponseDTO> save(@Body @Valid DemographicsCreateDTO demographics,
+                                                      HttpRequest<?> request) {
+
+        Demographics savedDemographic = demographicsServices.saveDemographics(fromDTO(demographics));
+        return HttpResponse.created(fromEntity(savedDemographic))
+                .headers(headers -> headers.location(URI.create(String.format("%s/%s", request.getPath(), savedDemographic.getId()))));
     }
 
     /**
@@ -96,27 +98,23 @@ public Mono<HttpResponse<DemographicsResponseDTO>> save(@Body @Valid Demographic
      * @return {@link DemographicsResponseDTO} The updated demographics
      */
     @Put
-    public Mono<HttpResponse<DemographicsResponseDTO>> update(@Body @Valid DemographicsUpdateDTO demographics,
-                                                                HttpRequest<?> request) {
-
-        return Mono.fromCallable(() -> demographicsServices.updateDemographics(fromDTO(demographics)))
-                .map(savedDemographics -> {
-                    DemographicsResponseDTO updatedDemographics = fromEntity(savedDemographics);
-                    return HttpResponse.ok(updatedDemographics)
-                            .headers(headers -> headers.location(URI.create(String.format("%s/%s", request.getPath(), updatedDemographics.getId()))));
-                });
+    public HttpResponse<DemographicsResponseDTO> update(@Body @Valid DemographicsUpdateDTO demographics,
+                                                        HttpRequest<?> request) {
+
+        Demographics savedDemographics = demographicsServices.updateDemographics(fromDTO(demographics));
+        return HttpResponse.ok(fromEntity(savedDemographics))
+                .headers(headers -> headers.location(URI.create(String.format("%s/%s", request.getPath(), savedDemographics.getId()))));
     }
 
     /**
      * Delete demographics.
      *
      * @param id {@link UUID} Demographics unique id
-     * @return
      */
     @Delete("/{id}")
-    public Mono<HttpResponse<?>> delete(@NotNull UUID id) {
-        return Mono.fromRunnable(() -> demographicsServices.deleteDemographics(id))
-                .thenReturn(HttpResponse.ok());
+    @Status(value = HttpStatus.OK)
+    public void delete(@NotNull UUID id) {
+        demographicsServices.deleteDemographics(id);
     }
 
     protected URI location(UUID id) {
@@ -148,5 +146,4 @@ private DemographicsResponseDTO fromEntity(Demographics entity) {
         dto.setVeteran(entity.getVeteran());
         return dto;
     }
-
 }

server/src/main/java/com/objectcomputing/checkins/services/email/EmailController.java

@@ -1,13 +1,13 @@
 package com.objectcomputing.checkins.services.email;
 
-import io.micronaut.http.HttpResponse;
+import io.micronaut.http.HttpStatus;
 import io.micronaut.http.annotation.Controller;
 import io.micronaut.http.annotation.Post;
+import io.micronaut.http.annotation.Status;
 import io.micronaut.scheduling.TaskExecutors;
 import io.micronaut.scheduling.annotation.ExecuteOn;
 import io.micronaut.security.annotation.Secured;
 import io.micronaut.security.rules.SecurityRule;
-import reactor.core.publisher.Mono;
 
 import java.util.List;
 
@@ -23,9 +23,8 @@ public EmailController(EmailServices emailServices) {
     }
 
     @Post
-    public Mono<HttpResponse<List<Email>>> sendEmail(String subject, String content, boolean html, String... recipients) {
-        return Mono.fromCallable(() -> emailServices.sendAndSaveEmail(subject, content, html, recipients))
-                .map(HttpResponse::created);
+    @Status(HttpStatus.CREATED)
+    public List<Email> sendEmail(String subject, String content, boolean html, String... recipients) {
+        return emailServices.sendAndSaveEmail(subject, content, html, recipients);
     }
-
 }

server/src/main/java/com/objectcomputing/checkins/services/employee_hours/EmployeeHoursController.java

@@ -2,7 +2,6 @@
 
 import com.objectcomputing.checkins.exceptions.NotFoundException;
 import io.micronaut.core.annotation.Nullable;
-import io.micronaut.http.HttpResponse;
 import io.micronaut.http.MediaType;
 import io.micronaut.http.annotation.Controller;
 import io.micronaut.http.annotation.Get;
@@ -14,7 +13,6 @@
 import io.micronaut.security.rules.SecurityRule;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.constraints.NotNull;
-import reactor.core.publisher.Mono;
 
 import java.util.Set;
 import java.util.UUID;
@@ -36,9 +34,8 @@ public EmployeeHoursController(EmployeeHoursServices employeeHoursServices) {
      * @return
      */
     @Get("/{?employeeId}")
-    public Mono<HttpResponse<Set<EmployeeHours>>> findEmployeeHours(@Nullable String employeeId) {
-        return Mono.fromCallable(() -> employeeHoursServices.findByFields(employeeId))
-                .map(HttpResponse::ok);
+    public Set<EmployeeHours> findEmployeeHours(@Nullable String employeeId) {
+        return employeeHoursServices.findByFields(employeeId);
     }
 
 
@@ -47,15 +44,12 @@ public Mono<HttpResponse<Set<EmployeeHours>>> findEmployeeHours(@Nullable String
      * @return
      */
     @Get("/{id}")
-    public Mono<HttpResponse<EmployeeHours>> readEmployeeHours(@NotNull UUID id) {
-        return Mono.fromCallable(() -> {
-            EmployeeHours result = employeeHoursServices.read(id);
-            if (result == null) {
-                throw new NotFoundException("No employee hours for employee id");
-            }
-            return result;
-        }).map(HttpResponse::ok);
-
+    public EmployeeHours readEmployeeHours(@NotNull UUID id) {
+        EmployeeHours result = employeeHoursServices.read(id);
+        if (result == null) {
+            throw new NotFoundException("No employee hours for employee id");
+        }
+        return result;
     }
 
     /**
@@ -64,9 +58,7 @@ public Mono<HttpResponse<EmployeeHours>> readEmployeeHours(@NotNull UUID id) {
      * @{@link HttpResponse<EmployeeHoursResponseDTO>}
      */
     @Post(uri="/upload" , consumes = MediaType.MULTIPART_FORM_DATA)
-    public Mono<HttpResponse<EmployeeHoursResponseDTO>> upload(CompletedFileUpload file){
-        return Mono.fromCallable(() -> employeeHoursServices.save(file))
-                .map(HttpResponse::ok);
+    public EmployeeHoursResponseDTO upload(CompletedFileUpload file){
+        return employeeHoursServices.save(file);
     }
-
 }