[backend] adding TagRule apis/repo Issue/1998

openbas-api/src/main/java/io/openbas/migration/V3_56__TagRule.java

@@ -0,0 +1,42 @@
+package io.openbas.migration;
+
+import java.sql.Connection;
+import java.sql.Statement;
+import org.flywaydb.core.api.migration.BaseJavaMigration;
+import org.flywaydb.core.api.migration.Context;
+import org.springframework.stereotype.Component;
+
+@Component
+public class V3_56__TagRule extends BaseJavaMigration {
+
+  @Override
+  public void migrate(Context context) throws Exception {
+    Connection connection = context.getConnection();
+    Statement select = connection.createStatement();
+    select.execute(
+        """
+               CREATE TABLE tag_rules (
+                   tag_rule_id varchar(255) not null,
+                   tag_id varchar(255) not null
+                       constraint tag_id_fk
+                           references tags,
+                   primary key (tag_rule_id)
+               );
+           CREATE INDEX idx_tag_id ON tag_rules (tag_id);
+            """);
+
+    select.execute(
+        """
+                   CREATE TABLE tag_rule_assets (
+                       tag_rule_id varchar(255) not null
+                            constraint tag_rule_id_fk
+                               references tag_rules,
+                       asset_id varchar(255) not null
+                           constraint asset_id_fk
+                               references assets
+                                 on delete cascade,
+                       primary key (tag_rule_id, asset_id)
+                   );
+                """);
+  }
+}

openbas-api/src/main/java/io/openbas/rest/tag_rule/TagRuleApi.java

@@ -0,0 +1,104 @@
+package io.openbas.rest.tag_rule;
+
+import static io.openbas.database.model.User.ROLE_ADMIN;
+
+import io.openbas.aop.LogExecutionTime;
+import io.openbas.rest.helper.RestBehavior;
+import io.openbas.rest.tag_rule.form.TagRuleInput;
+import io.openbas.rest.tag_rule.form.TagRuleMapper;
+import io.openbas.rest.tag_rule.form.TagRuleOutput;
+import io.openbas.service.TagRuleService;
+import io.openbas.utils.pagination.SearchPaginationInput;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import java.util.List;
+import org.springframework.data.domain.Page;
+import org.springframework.security.access.annotation.Secured;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+public class TagRuleApi extends RestBehavior {
+
+  public static final String TAG_RULE_URI = "/api/tag-rules";
+
+  private final TagRuleService tagRuleService;
+  private final TagRuleMapper tagRuleMapper;
+
+  public TagRuleApi(TagRuleService tagRuleService, TagRuleMapper tagRuleMapper) {
+    super();
+    this.tagRuleService = tagRuleService;
+    this.tagRuleMapper = tagRuleMapper;
+  }
+
+  @LogExecutionTime
+  @GetMapping(TagRuleApi.TAG_RULE_URI + "/{tagRuleId}")
+  @Operation(summary = "Get TagRule by Id")
+  public TagRuleOutput findTagRule(@PathVariable @NotBlank final String tagRuleId) {
+    return tagRuleService.findById(tagRuleId).map(tagRuleMapper::toTagRuleOutput).orElse(null);
+  }
+
+  @LogExecutionTime
+  @GetMapping(TagRuleApi.TAG_RULE_URI)
+  @Operation(summary = "Get All TagRules")
+  public List<TagRuleOutput> tags() {
+    return tagRuleService.findAll().stream().map(tagRuleMapper::toTagRuleOutput).toList();
+  }
+
+  @Secured(ROLE_ADMIN)
+  @LogExecutionTime
+  @DeleteMapping(TagRuleApi.TAG_RULE_URI + "/{tagRuleId}")
+  @Transactional(rollbackFor = Exception.class)
+  @Operation(summary = "Delete TagRule", description = "TagRule needs to exists")
+  @ApiResponses(
+      value = {
+        @ApiResponse(responseCode = "200", description = "TagRule deleted"),
+        @ApiResponse(responseCode = "404", description = "TagRule not found")
+      })
+  public void deleteTagRule(@PathVariable @NotBlank final String tagRuleId) {
+    tagRuleService.deleteTagRule(tagRuleId);
+  }
+
+  @Secured(ROLE_ADMIN)
+  @LogExecutionTime
+  @PostMapping(TagRuleApi.TAG_RULE_URI)
+  @Transactional(rollbackFor = Exception.class)
+  @Operation(summary = "Create TagRule", description = "Tag and assets needs to exists")
+  @ApiResponses(
+      value = {
+        @ApiResponse(responseCode = "200", description = "TagRule created"),
+        @ApiResponse(responseCode = "404", description = "Tag or Asset not found")
+      })
+  public TagRuleOutput createTagRule(@Valid @RequestBody final TagRuleInput input) {
+    return tagRuleMapper.toTagRuleOutput(
+        tagRuleService.createTagRule(input.getTagName(), input.getAssets()));
+  }
+
+  @Secured(ROLE_ADMIN)
+  @LogExecutionTime
+  @PutMapping(TagRuleApi.TAG_RULE_URI + "/{tagRuleId}")
+  @Transactional(rollbackFor = Exception.class)
+  @Operation(summary = "Update TagRule", description = "Tag and assets needs to exists")
+  @ApiResponses(
+      value = {
+        @ApiResponse(responseCode = "200", description = "TagRule updated"),
+        @ApiResponse(responseCode = "404", description = "TagRule, Tag  or Asset not found")
+      })
+  public TagRuleOutput updateTagRule(
+      @PathVariable @NotBlank final String tagRuleId,
+      @Valid @RequestBody final TagRuleInput input) {
+    return tagRuleMapper.toTagRuleOutput(
+        tagRuleService.updateTagRule(tagRuleId, input.getTagName(), input.getAssets()));
+  }
+
+  @LogExecutionTime
+  @PostMapping(TagRuleApi.TAG_RULE_URI + "/search")
+  @Operation(summary = "Search TagRule")
+  public Page<TagRuleOutput> searchTagRules(
+      @RequestBody @Valid SearchPaginationInput searchPaginationInput) {
+    return tagRuleService.searchTagRule(searchPaginationInput).map(tagRuleMapper::toTagRuleOutput);
+  }
+}

openbas-api/src/main/java/io/openbas/rest/tag_rule/form/TagRuleInput.java

@@ -0,0 +1,25 @@
+package io.openbas.rest.tag_rule.form;
+
+import static io.openbas.config.AppConfig.MANDATORY_MESSAGE;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import jakarta.validation.constraints.NotBlank;
+import java.util.ArrayList;
+import java.util.List;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.extern.jackson.Jacksonized;
+
+@Builder(toBuilder = true)
+@Getter
+@Jacksonized
+@EqualsAndHashCode
+public class TagRuleInput {
+  @NotBlank(message = MANDATORY_MESSAGE)
+  @JsonProperty("tag_name")
+  private String tagName;
+
+  @JsonProperty("tag_rule_assets")
+  private List<String> assets = new ArrayList<>();
+}

openbas-api/src/main/java/io/openbas/rest/tag_rule/form/TagRuleMapper.java

@@ -0,0 +1,18 @@
+package io.openbas.rest.tag_rule.form;
+
+import io.openbas.database.model.Asset;
+import io.openbas.database.model.TagRule;
+import java.util.stream.Collectors;
+import org.springframework.stereotype.Component;
+
+@Component
+public class TagRuleMapper {
+  public TagRuleOutput toTagRuleOutput(final TagRule tagRule) {
+    return TagRuleOutput.builder()
+        .id(tagRule.getId())
+        .tagName(tagRule.getTag().getName())
+        .assets(
+            tagRule.getAssets().stream().collect(Collectors.toMap(Asset::getId, Asset::getName)))
+        .build();
+  }
+}

openbas-api/src/main/java/io/openbas/rest/tag_rule/form/TagRuleOutput.java

@@ -0,0 +1,27 @@
+package io.openbas.rest.tag_rule.form;
+
+import static io.openbas.config.AppConfig.MANDATORY_MESSAGE;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import jakarta.validation.constraints.NotBlank;
+import java.util.HashMap;
+import java.util.Map;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+
+@Builder(toBuilder = true)
+@Getter
+@EqualsAndHashCode
+public class TagRuleOutput {
+  @NotBlank(message = MANDATORY_MESSAGE)
+  @JsonProperty("tag_rule_id")
+  private String id;
+
+  @NotBlank(message = MANDATORY_MESSAGE)
+  @JsonProperty("tag_name")
+  private String tagName;
+
+  @JsonProperty("tag_rule_assets")
+  Map<String, String> assets = new HashMap<>();
+}

openbas-api/src/main/java/io/openbas/service/TagRuleService.java

@@ -0,0 +1,99 @@
+package io.openbas.service;
+
+import static io.openbas.utils.pagination.PaginationUtils.buildPaginationJPA;
+
+import com.cronutils.utils.VisibleForTesting;
+import io.openbas.database.model.Asset;
+import io.openbas.database.model.Tag;
+import io.openbas.database.model.TagRule;
+import io.openbas.database.repository.AssetRepository;
+import io.openbas.database.repository.TagRepository;
+import io.openbas.database.repository.TagRuleRepository;
+import io.openbas.rest.exception.ElementNotFoundException;
+import io.openbas.utils.pagination.SearchPaginationInput;
+import jakarta.validation.constraints.NotBlank;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class TagRuleService {
+  private final TagRuleRepository tagRuleRepository;
+  private final TagRepository tagRepository;
+  private final AssetRepository assetRepository;
+
+  public Optional<TagRule> findById(String id) {
+    return tagRuleRepository.findById(id);
+  }
+
+  public List<TagRule> findAll() {
+    return StreamSupport.stream(tagRuleRepository.findAll().spliterator(), false)
+        .collect(Collectors.toList());
+  }
+
+  public TagRule createTagRule(@NotBlank final String tagName, final List<String> assetIds) {
+    // if the tag  or one of the asset doesn't exist we exist throw a ElementNotFoundException
+    TagRule tagRule = new TagRule();
+    tagRule.setTag(getTag(tagName));
+    tagRule.setAssets(getAssets(assetIds));
+    return tagRuleRepository.save(tagRule);
+  }
+
+  public TagRule updateTagRule(
+      @NotBlank final String tagRuleId, final String tagName, final List<String> assetIds) {
+
+    // verify that the tag rule exists
+    TagRule tagRule =
+        tagRuleRepository
+            .findById(tagRuleId)
+            .orElseThrow(
+                () -> new ElementNotFoundException("TagRule not found with id: " + tagRuleId));
+
+    tagRule.setTag(getTag(tagName));
+
+    // if one of the asset doesn't exist throw a ResourceNotFoundException
+    tagRule.setAssets(getAssets(assetIds));
+
+    return tagRuleRepository.save(tagRule);
+  }
+
+  public Page<TagRule> searchTagRule(SearchPaginationInput searchPaginationInput) {
+    return buildPaginationJPA(tagRuleRepository::findAll, searchPaginationInput, TagRule.class);
+  }
+
+  public void deleteTagRule(@NotBlank final String tagRuleId) {
+    // verify that the TagRule exists
+    tagRuleRepository
+        .findById(tagRuleId)
+        .orElseThrow(() -> new ElementNotFoundException("TagRule not found with id: " + tagRuleId));
+    tagRuleRepository.deleteById(tagRuleId);
+  }
+
+  @VisibleForTesting
+  protected Tag getTag(@NotBlank final String tagName) {
+    // TODO: tag name normalization needs to be implemented in a reusable method
+    return tagRepository
+        .findByName(tagName.toLowerCase())
+        .orElseThrow(() -> new ElementNotFoundException("Tag not found with name: " + tagName));
+  }
+
+  @VisibleForTesting
+  protected List<Asset> getAssets(final List<String> assetIds) {
+    return assetIds == null
+        ? new ArrayList<>()
+        : assetIds.stream()
+            .map(
+                id ->
+                    assetRepository
+                        .findById(id)
+                        .orElseThrow(
+                            () -> new ElementNotFoundException("Asset not found with id: " + id)))
+            .collect(Collectors.toList());
+  }
+}