feat: modal to add favourite activity

backend/src/main/java/ca/bc/gov/backendstartapi/dto/FavouriteActivityCreateDto.java

@@ -10,4 +10,7 @@
  * @param activity The activity or page name
  */
 @Schema(description = "An object representing the request body when creating a favourite activity")
-public record FavouriteActivityCreateDto(@NotNull String activity) {}
+public record FavouriteActivityCreateDto(
+        @NotNull String activity,
+    @Schema(description = "Indicates whether this activity is from Consep", defaultValue = "false")
+        Boolean isConsep) {}

backend/src/main/java/ca/bc/gov/backendstartapi/endpoint/FavouriteActivityEndpoint.java

@@ -44,29 +44,29 @@ public class FavouriteActivityEndpoint {
    * Creates to the logged user a {@link FavouriteActivityEntity} record based on the activity or
    * page title.
    *
-   * @param createDto a {@link FavouriteActivityCreateDto} with the activity title
+   * @param createDtos a {@link FavouriteActivityCreateDto} with the activity title
    * @return a {@link FavouriteActivityEntity} created
    */
   @PostMapping(consumes = "application/json", produces = "application/json")
   @Operation(
-      summary = "Creates a Favourite Activity",
+      summary = "Creates a Favourite Activities in bulk",
       description =
           """
-          Creates a Favourite Activity to the logged user based on the activity
-          title or page name.
+          Creates Favourite Activities for the logged user in bulk based on an array
+          of activity titles or page names, with optional isConsep flags.
           """)
   @ApiResponses(
       value = {
         @ApiResponse(
             responseCode = "201",
-            description = "The Favourite Activity entity was successfully created",
+            description = "The Favourite Activities were successfully created",
             content =
                 @Content(
                     mediaType = "application/json",
                     schema = @Schema(implementation = FavouriteActivityEntity.class))),
         @ApiResponse(
             responseCode = "400",
-            description = "The activity doesn't exists or is already defined to that user",
+            description = "One or more activities failed validation or already exist",
             content =
                 @Content(
                     mediaType = "application/json",
@@ -82,16 +82,17 @@ public class FavouriteActivityEndpoint {
             content = @Content(schema = @Schema(implementation = Void.class)))
       })
   @RoleAccessConfig({"SPAR_TSC_ADMIN", "SPAR_MINISTRY_ORCHARD", "SPAR_NONMINISTRY_ORCHARD"})
-  public ResponseEntity<FavouriteActivityEntity> createUserActivity(
+  public ResponseEntity<List<FavouriteActivityEntity>> createUserActivities(
       @io.swagger.v3.oas.annotations.parameters.RequestBody(
               description = "Body containing the activity name that will be created",
               required = true,
               content =
                   @Content(schema = @Schema(implementation = FavouriteActivityCreateDto.class)))
           @Valid
           @RequestBody
-          FavouriteActivityCreateDto createDto) {
-    FavouriteActivityEntity entity = favouriteActivityService.createUserActivity(createDto);
+          List<FavouriteActivityCreateDto> createDtos) {
+    List<FavouriteActivityEntity> entity = 
+        favouriteActivityService.createUserActivities(createDtos);
     return ResponseEntity.status(HttpStatus.CREATED).body(entity);
   }
 

backend/src/main/java/ca/bc/gov/backendstartapi/entity/FavouriteActivityEntity.java

@@ -53,6 +53,12 @@ public class FavouriteActivityEntity {
   @Column(name = "update_timestamp")
   private LocalDateTime updateTimestamp;
 
+  @Column(name = "is_consep", nullable = false, columnDefinition = "BOOLEAN DEFAULT FALSE")
+  @Schema(
+      description = "Defines if the favourite activity is a CONSEP activity",
+      example = "false")
+  private Boolean isConsep = false;
+
   public FavouriteActivityEntity() {
     this.highlighted = false;
   }

backend/src/main/java/ca/bc/gov/backendstartapi/repository/FavouriteActivityRepository.java

@@ -14,6 +14,8 @@ public interface FavouriteActivityRepository extends CrudRepository<FavouriteAct
 
   Optional<FavouriteActivityEntity> findByActivity(String activity);
 
+  boolean existsByUserIdAndActivity(String userId, String activity);
+
   @Modifying
   @Query("update FavouriteActivityEntity set highlighted = false where userId = ?1")
   void removeAllHighlightedByUser(String userId);

backend/src/main/java/ca/bc/gov/backendstartapi/service/FavouriteActivityService.java

@@ -9,6 +9,7 @@
 import ca.bc.gov.backendstartapi.repository.FavouriteActivityRepository;
 import ca.bc.gov.backendstartapi.security.LoggedUserService;
 import jakarta.transaction.Transactional;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
@@ -36,33 +37,53 @@ public FavouriteActivityService(
     this.favouriteActivityRepository = favouriteActivityRepository;
   }
 
+  /**
+  * Validates the activity input.
+  */
+  private void validateActivityInput(FavouriteActivityCreateDto activityDto) {
+    if (Objects.isNull(activityDto.activity()) || activityDto.activity().isBlank()) {
+      throw new InvalidActivityException();
+    }
+  }
+
+  /**
+  * Builds a FavouriteActivityEntity.
+  */
+  private FavouriteActivityEntity buildFavouriteActivityEntity(
+      String userId, FavouriteActivityCreateDto dto) {
+    FavouriteActivityEntity entity = new FavouriteActivityEntity();
+    entity.setUserId(userId);
+    entity.setActivity(dto.activity());
+    entity.setIsConsep(Optional.ofNullable(dto.isConsep()).orElse(false));
+    return entity;
+  }
+
   /**
    * Create a user's activity in the database.
    *
-   * @param activityDto a {@link FavouriteActivityCreateDto} containing the activity title
+   * @param activityDtos a {@link FavouriteActivityCreateDto} containing the activity title
    * @return the {@link FavouriteActivityEntity} created
    */
-  public FavouriteActivityEntity createUserActivity(FavouriteActivityCreateDto activityDto) {
+  public List<FavouriteActivityEntity> createUserActivities(
+      List<FavouriteActivityCreateDto> activityDtos) {
     String userId = loggedUserService.getLoggedUserId();
-    SparLog.info("Creating activity {} for user {}", activityDto.activity(), userId);
-
-    if (Objects.isNull(activityDto.activity()) || activityDto.activity().isBlank()) {
-      throw new InvalidActivityException();
-    }
-
-    List<FavouriteActivityEntity> userFavList = favouriteActivityRepository.findAllByUserId(userId);
-    if (userFavList.stream().anyMatch(ac -> ac.getActivity().equals(activityDto.activity()))) {
-      SparLog.info("Activity {} already exists for user {}!", activityDto.activity(), userId);
-      throw new FavoriteActivityExistsToUser();
+    SparLog.info("Creating activities for user {}", userId);
+
+    List<FavouriteActivityEntity> createdActivities = new ArrayList<>();
+
+    for (FavouriteActivityCreateDto dto : activityDtos) {
+      try {
+        validateActivityInput(dto);
+        if (favouriteActivityRepository.existsByUserIdAndActivity(userId, dto.activity())) {
+          continue;
+        }
+        FavouriteActivityEntity entity = buildFavouriteActivityEntity(userId, dto);
+        createdActivities.add(favouriteActivityRepository.save(entity));
+      } catch (InvalidActivityException | FavoriteActivityExistsToUser e) {
+        SparLog.error("Error creating activity: {}", e.getMessage());
+      }
     }
-
-    FavouriteActivityEntity activityEntity = new FavouriteActivityEntity();
-    activityEntity.setUserId(userId);
-    activityEntity.setActivity(activityDto.activity());
-
-    FavouriteActivityEntity activityEntitySaved = favouriteActivityRepository.save(activityEntity);
-    SparLog.info("Activity {} created for user {}", activityDto.activity(), userId);
-    return activityEntitySaved;
+    return createdActivities;
   }
 
   /**

backend/src/main/resources/db/migration/V47__add_col_to_favourite_activity.sql

@@ -0,0 +1,4 @@
+ALTER TABLE
+  spar.favourite_activity
+ADD
+  COLUMN is_consep BOOLEAN DEFAULT FALSE NOT NULL;

backend/src/test/java/ca/bc/gov/backendstartapi/endpoint/FavouriteActivityEndpointTest.java

@@ -59,26 +59,27 @@ private FavouriteActivityEntity createEntity(String activity) {
   @Test
   @DisplayName("createFavoriteActivitySuccessTest")
   void createFavoriteActivitySuccessTest() throws Exception {
+    String content = "[{\"activity\":\"CREATE_A_CLASS_SEEDLOT\"}]";
     FavouriteActivityEntity activityEntity = createEntity("CREATE_A_CLASS_SEEDLOT");
-    when(favouriteActivityService.createUserActivity(any())).thenReturn(activityEntity);
+    when(favouriteActivityService.createUserActivities(any())).thenReturn(List.of(activityEntity));
 
     mockMvc
         .perform(
             post(API_PATH)
                 .with(csrf().asHeader())
                 .header(CONTENT_HEADER, JSON)
                 .accept(MediaType.APPLICATION_JSON)
-                .content(stringifyCreate("CREATE_A_CLASS_SEEDLOT")))
+                .content(content))
         .andExpect(status().isCreated())
-        .andExpect(jsonPath("$.activity").value("CREATE_A_CLASS_SEEDLOT"))
-        .andExpect(jsonPath("$.highlighted").value("false"))
+        .andExpect(jsonPath("$[0].activity").value("CREATE_A_CLASS_SEEDLOT"))
+        .andExpect(jsonPath("$[0].highlighted").value("false"))
         .andReturn();
   }
 
   @Test
   @DisplayName("createFavoriteActivityNotFoundTest")
   void createFavoriteActivityNotFoundTest() throws Exception {
-    when(favouriteActivityService.createUserActivity(any()))
+    when(favouriteActivityService.createUserActivities(any()))
         .thenThrow(new InvalidActivityException());
 
     mockMvc
@@ -95,23 +96,23 @@ void createFavoriteActivityNotFoundTest() throws Exception {
   @Test
   @DisplayName("createFavoriteActivityDuplicatedTest")
   void createFavoriteActivityDuplicatedTest() throws Exception {
-    String contentString = stringifyCreate("CREATE_A_CLASS_SEEDLOT");
+    String content = "[{\"activity\":\"CREATE_A_CLASS_SEEDLOT\"}]";
     FavouriteActivityEntity activityEntity = createEntity("CREATE_A_CLASS_SEEDLOT");
-    when(favouriteActivityService.createUserActivity(any())).thenReturn(activityEntity);
+    when(favouriteActivityService.createUserActivities(any())).thenReturn(List.of(activityEntity));
 
     mockMvc
         .perform(
             post(API_PATH)
                 .with(csrf().asHeader())
                 .header(CONTENT_HEADER, JSON)
                 .accept(MediaType.APPLICATION_JSON)
-                .content(contentString))
+                .content(content))
         .andExpect(status().isCreated())
-        .andExpect(jsonPath("$.activity").value("CREATE_A_CLASS_SEEDLOT"))
-        .andExpect(jsonPath("$.highlighted").value("false"))
+        .andExpect(jsonPath("$[0].activity").value("CREATE_A_CLASS_SEEDLOT"))
+        .andExpect(jsonPath("$[0].highlighted").value("false"))
         .andReturn();
 
-    when(favouriteActivityService.createUserActivity(any()))
+    when(favouriteActivityService.createUserActivities(any()))
         .thenThrow(new FavoriteActivityExistsToUser());
 
     mockMvc
@@ -120,7 +121,7 @@ void createFavoriteActivityDuplicatedTest() throws Exception {
                 .with(csrf().asHeader())
                 .header(CONTENT_HEADER, JSON)
                 .accept(MediaType.APPLICATION_JSON)
-                .content(contentString))
+                .content(content))
         .andExpect(status().isBadRequest())
         .andReturn();
   }
@@ -153,20 +154,21 @@ void getAllUsersActivityTest() throws Exception {
   @Test
   @DisplayName("updateUserFavoriteActivity")
   void updateUserFavoriteActivity() throws Exception {
+    String content = "[{\"activity\":\"EXISTING_SEEDLOTS\"}]";
     FavouriteActivityEntity activityEntity = createEntity("EXISTING_SEEDLOTS");
     activityEntity.setId(10000L);
-    when(favouriteActivityService.createUserActivity(any())).thenReturn(activityEntity);
+    when(favouriteActivityService.createUserActivities(any())).thenReturn(List.of(activityEntity));
 
     mockMvc
         .perform(
             post(API_PATH)
                 .with(csrf().asHeader())
                 .header(CONTENT_HEADER, JSON)
                 .accept(MediaType.APPLICATION_JSON)
-                .content(stringifyCreate("EXISTING_SEEDLOTS")))
+                .content(content))
         .andExpect(status().isCreated())
-        .andExpect(jsonPath("$.activity").value("EXISTING_SEEDLOTS"))
-        .andExpect(jsonPath("$.highlighted").value("false"))
+        .andExpect(jsonPath("$[0].activity").value("EXISTING_SEEDLOTS"))
+        .andExpect(jsonPath("$[0].highlighted").value("false"))
         .andReturn();
 
     activityEntity.setHighlighted(true);
@@ -191,21 +193,22 @@ void updateUserFavoriteActivity() throws Exception {
   @Test
   @DisplayName("deleteUserFavoriteActivity")
   void deleteUserFavoriteActivity() throws Exception {
+    String content = "[{\"activity\":\"EXISTING_SEEDLOTS\"}]";
     FavouriteActivityEntity activityEntity = createEntity("EXISTING_SEEDLOTS");
     activityEntity.setId(10000L);
 
-    when(favouriteActivityService.createUserActivity(any())).thenReturn(activityEntity);
+    when(favouriteActivityService.createUserActivities(any())).thenReturn(List.of(activityEntity));
 
     mockMvc
         .perform(
             post(API_PATH)
                 .with(csrf().asHeader())
                 .header(CONTENT_HEADER, JSON)
                 .accept(MediaType.APPLICATION_JSON)
-                .content(stringifyCreate("EXISTING_SEEDLOTS")))
+                .content(content))
         .andExpect(status().isCreated())
-        .andExpect(jsonPath("$.activity").value("EXISTING_SEEDLOTS"))
-        .andExpect(jsonPath("$.highlighted").value("false"))
+        .andExpect(jsonPath("$[0].activity").value("EXISTING_SEEDLOTS"))
+        .andExpect(jsonPath("$[0].highlighted").value("false"))
         .andReturn();
 
     activityEntity.setHighlighted(true);

backend/src/test/java/ca/bc/gov/backendstartapi/service/FavouriteActivityServiceTest.java

@@ -7,7 +7,6 @@
 import ca.bc.gov.backendstartapi.dto.FavouriteActivityCreateDto;
 import ca.bc.gov.backendstartapi.dto.FavouriteActivityUpdateDto;
 import ca.bc.gov.backendstartapi.entity.FavouriteActivityEntity;
-import ca.bc.gov.backendstartapi.exception.FavoriteActivityExistsToUser;
 import ca.bc.gov.backendstartapi.exception.InvalidActivityException;
 import ca.bc.gov.backendstartapi.repository.FavouriteActivityRepository;
 import ca.bc.gov.backendstartapi.security.LoggedUserService;
@@ -49,50 +48,17 @@ void createUserActivityTest() {
     entity.setHighlighted(Boolean.FALSE);
     when(favouriteActivityRepository.save(any())).thenReturn(entity);
 
-    FavouriteActivityCreateDto createDto = new FavouriteActivityCreateDto("CREATE_A_CLASS_SEEDLOT");
-    FavouriteActivityEntity entitySaved = favouriteActivityService.createUserActivity(createDto);
+    FavouriteActivityCreateDto createDto = 
+        new FavouriteActivityCreateDto("CREATE_A_CLASS_SEEDLOT", false);
+    List<FavouriteActivityEntity> entitiesSaved = 
+        favouriteActivityService.createUserActivities(List.of(createDto));
+    FavouriteActivityEntity entitySaved = entitiesSaved.get(0);
 
     Assertions.assertNotNull(entitySaved);
     Assertions.assertEquals("CREATE_A_CLASS_SEEDLOT", entitySaved.getActivity());
     Assertions.assertFalse(entitySaved.getHighlighted());
   }
 
-  @Test
-  @DisplayName("createUserActivityExceptionTest")
-  void createUserActivityExceptionTest() {
-    when(loggedUserService.getLoggedUserId()).thenReturn(USER_ID);
-
-    FavouriteActivityEntity entity = new FavouriteActivityEntity();
-    entity.setActivity("CREATE_A_CLASS_SEEDLOT");
-    entity.setHighlighted(Boolean.FALSE);
-    when(favouriteActivityRepository.save(any())).thenReturn(entity);
-
-    FavouriteActivityCreateDto createDto = new FavouriteActivityCreateDto(null);
-
-    Exception notFoundExc =
-        Assertions.assertThrows(
-            InvalidActivityException.class,
-            () -> favouriteActivityService.createUserActivity(createDto));
-
-    Assertions.assertEquals(
-        "404 NOT_FOUND \"Invalid or not found activity id!\"", notFoundExc.getMessage());
-
-    List<FavouriteActivityEntity> userFavList = List.of(entity);
-    when(favouriteActivityRepository.findAllByUserId(any())).thenReturn(userFavList);
-
-    FavouriteActivityCreateDto createAnotherDto =
-        new FavouriteActivityCreateDto("CREATE_A_CLASS_SEEDLOT");
-
-    Exception activityExists =
-        Assertions.assertThrows(
-            FavoriteActivityExistsToUser.class,
-            () -> favouriteActivityService.createUserActivity(createAnotherDto));
-
-    Assertions.assertEquals(
-        "400 BAD_REQUEST \"Activity already registered to this user!\"",
-        activityExists.getMessage());
-  }
-
   @Test
   @DisplayName("getAllUserFavoriteActivitiesTest")
   void getAllUserFavoriteActivitiesTest() {

frontend/src/api-service/favouriteActivitiesAPI.ts

@@ -36,9 +36,9 @@ export const getFavAct = () => {
     });
 };
 
-export const postFavAct = (newAct: FavActivityPostType) => {
+export const postFavAct = (newActs: FavActivityPostType[]) => {
   const url = ApiConfig.favouriteActivities;
-  return api.post(url, newAct);
+  return api.post(url, newActs);
 };
 
 export const patchFavAct = (field: string, activity: FavActivityType) => {