[backend] adding TagRule apis/repo Issue/1998

openbas-api/src/main/java/io/openbas/migration/V3_54__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_54__TagRule extends BaseJavaMigration {
+
+  @Override
+  public void migrate(Context context) throws Exception {
+    Connection connection = context.getConnection();
+    Statement select = connection.createStatement();
+    // Create relations between contracts and attack_patterns
+    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)
+               );
+            """);
+
+    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,91 @@
+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 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;
+
+  public TagRuleApi(TagRuleService tagRuleService) {
+    super();
+    this.tagRuleService = tagRuleService;
+  }
+
+  @LogExecutionTime
+  @GetMapping(TagRuleApi.TAG_RULE_URI + "/{tagRuleId}")
+  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")
+  public void deleteTagRule(@PathVariable @NotBlank final String tagRuleId) {
+    this.tagRuleService.deleteTagRule(tagRuleId);
+  }
+
+  @Secured(ROLE_ADMIN)
+  @LogExecutionTime
+  @PostMapping(TagRuleApi.TAG_RULE_URI)
+  @Transactional(rollbackFor = Exception.class)
+  @Operation(
+      summary = "Create TagRule",
+      description = "If the Tag doesn't exist, it will be created")
+  public TagRuleOutput createTagRule(@Valid @RequestBody final TagRuleInput input) {
+    return TagRuleMapper.toTagRuleOutput(
+        this.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 = "If the Tag doesn't exist, it will be created")
+  public TagRuleOutput updateTagRule(
+      @PathVariable @NotBlank final String tagRuleId,
+      @Valid @RequestBody final TagRuleInput input) {
+    return TagRuleMapper.toTagRuleOutput(
+        this.tagRuleService.updateTagRule(tagRuleId, input.getTagName(), input.getAssets()));
+  }
+
+  @LogExecutionTime
+  @PostMapping(TagRuleApi.TAG_RULE_URI + "/search")
+  @Operation(
+      summary = "Search TagRule",
+      description = "Tries to connect to dependencies (DB/Minio/RabbitMQ)")
+  public Page<TagRuleOutput> searchTagRules(
+      @RequestBody @Valid SearchPaginationInput searchPaginationInput) {
+    return this.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,16 @@
+package io.openbas.rest.tag_rule.form;
+
+import io.openbas.database.model.Asset;
+import io.openbas.database.model.TagRule;
+import java.util.stream.Collectors;
+
+public class TagRuleMapper {
+  public static 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,174 @@
+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.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+
+@RequiredArgsConstructor
+@Service
+public class TagRuleService {
+  private TagRuleRepository tagRuleRepository;
+  private TagRepository tagRepository;
+  private AssetRepository assetRepository;
+
+  /**
+   * Find the TagRule by id
+   *
+   * @param id
+   * @return
+   */
+  public Optional<TagRule> findById(String id) {
+    return tagRuleRepository.findById(id);
+  }
+
+  /**
+   * Find all the TagRules
+   *
+   * @return
+   */
+  public List<TagRule> findAll() {
+    return StreamSupport.stream(tagRuleRepository.findAll().spliterator(), false)
+        .collect(Collectors.toList());
+  }
+
+  /**
+   * Create a TagRule
+   *
+   * @param tagName if the tag doesn't exist it will be created
+   * @param assetIds list of existing assets id
+   * @return
+   */
+  public TagRule createTagRule(@NotBlank final String tagName, final List<String> assetIds) {
+    // if the tag doesn't exist we create it
+    // if one of the asset doesn't exist throw a ResourceNotFoundException
+    TagRule tagRule = new TagRule();
+    tagRule.setTag(getOrCreateTag(tagName));
+    tagRule.setAssets(getAssets(assetIds));
+    return tagRuleRepository.save(tagRule);
+  }
+
+  /**
+   * Update tagRule
+   *
+   * @param tagName
+   * @param assetIds
+   * @return
+   */
+  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));
+
+    // if the tag doesn't exist we create it
+    tagRule.setTag(getOrCreateTag(tagName));
+
+    // if one of the asset doesn't exist throw a ResourceNotFoundException
+    tagRule.setAssets(getAssets(assetIds));
+
+    return tagRuleRepository.save(tagRule);
+  }
+
+  /**
+   * Search TagRule
+   *
+   * @param searchPaginationInput
+   * @return
+   */
+  public Page<TagRule> searchTagRule(SearchPaginationInput searchPaginationInput) {
+    return buildPaginationJPA(
+        (Specification<TagRule> specification, Pageable pageable) ->
+            this.tagRuleRepository.findAll(specification, pageable),
+        searchPaginationInput,
+        TagRule.class);
+  }
+
+  /**
+   * Delete a TagRule
+   *
+   * @param tagRuleId
+   */
+  public void deleteTagRule(@NotBlank final String tagRuleId) {
+    this.tagRuleRepository.deleteById(tagRuleId);
+  }
+
+  @VisibleForTesting
+  protected Tag createtag(final String tagName) {
+    Tag tag = new Tag();
+    tag.setName(tagName);
+    return tag;
+  }
+
+  /**
+   * Check if the tag exists, if no it creates it
+   *
+   * @param tagName
+   * @return
+   */
+  @VisibleForTesting
+  protected Tag getOrCreateTag(@NotBlank final String tagName) {
+    // TODO: tag name normalization needs to be implemented in a reusable method
+    return tagRepository
+        .findByName(tagName.toLowerCase())
+        .orElseGet(() -> tagRepository.save(createtag(tagName)));
+  }
+
+  /**
+   * Get the assets from the DB, and throwns an exception if an asset doesn't exist
+   *
+   * @param assetIds
+   * @return
+   */
+  @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)))
+            .toList();
+  }
+
+  @Autowired
+  public void setTagRuleRepository(TagRuleRepository tagRuleRepository) {
+    this.tagRuleRepository = tagRuleRepository;
+  }
+
+  @Autowired
+  public void setTagRepository(TagRepository tagRepository) {
+    this.tagRepository = tagRepository;
+  }
+
+  @Autowired
+  public void setAssetRepository(AssetRepository assetRepository) {
+    this.assetRepository = assetRepository;
+  }
+}