Add data masking framework for dataset fields

odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/controller/MaskingController.java

@@ -0,0 +1,58 @@
+package org.opendatadiscovery.oddplatform.controller;
+
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.opendatadiscovery.oddplatform.dto.masking.DatasetFieldMaskingDto;
+import org.opendatadiscovery.oddplatform.dto.masking.MaskingRuleDto;
+import org.opendatadiscovery.oddplatform.service.MaskingService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import reactor.core.publisher.Mono;
+
+@RestController
+@RequestMapping("/api/masking")
+@RequiredArgsConstructor
+public class MaskingController {
+    private final MaskingService maskingService;
+
+    @GetMapping("/rules")
+    public Mono<ResponseEntity<List<MaskingRuleDto>>> getMaskingRules() {
+        return maskingService.getMaskingRules()
+            .map(ResponseEntity::ok);
+    }
+
+    @GetMapping("/dataset-fields/{fieldId}")
+    public Mono<ResponseEntity<DatasetFieldMaskingDto>> getFieldMasking(
+        @PathVariable final long fieldId) {
+        return maskingService.getFieldMasking(fieldId)
+            .map(ResponseEntity::ok);
+    }
+
+    @GetMapping("/datasets/{datasetId}")
+    public Mono<ResponseEntity<List<DatasetFieldMaskingDto>>> getDatasetMaskings(
+        @PathVariable final long datasetId) {
+        return maskingService.getDatasetMaskings(datasetId)
+            .map(ResponseEntity::ok);
+    }
+
+    @PostMapping("/dataset-fields/{fieldId}")
+    public Mono<ResponseEntity<Void>> applyMasking(
+        @PathVariable final long fieldId,
+        @RequestParam final long ruleId) {
+        return maskingService.applyMasking(fieldId, ruleId)
+            .thenReturn(ResponseEntity.ok().build());
+    }
+
+    @DeleteMapping("/dataset-fields/{fieldId}")
+    public Mono<ResponseEntity<Void>> removeMasking(
+        @PathVariable final long fieldId) {
+        return maskingService.removeMasking(fieldId)
+            .thenReturn(ResponseEntity.ok().build());
+    }
+}

odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/dto/masking/DatasetFieldMaskingDto.java

@@ -0,0 +1,16 @@
+package org.opendatadiscovery.oddplatform.dto.masking;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class DatasetFieldMaskingDto {
+    private Long id;
+    private Long datasetFieldId;
+    private MaskingRuleDto maskingRule;
+}

odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/dto/masking/MaskingRuleDto.java

@@ -0,0 +1,18 @@
+package org.opendatadiscovery.oddplatform.dto.masking;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class MaskingRuleDto {
+    private Long id;
+    private String name;
+    private MaskingRuleType type;
+    private String replacement;
+    private String pattern;
+}

odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/dto/masking/MaskingRuleType.java

@@ -0,0 +1,11 @@
+package org.opendatadiscovery.oddplatform.dto.masking;
+
+public enum MaskingRuleType {
+    SHOW_LAST_4,
+    SHOW_FIRST_4,
+    HASH_SHA256,
+    REDACT,
+    EMAIL_MASK,
+    PHONE_MASK,
+    ID_CARD_MASK
+}

odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/dto/policy/PolicyPermissionDto.java

@@ -86,6 +86,8 @@ public enum PolicyPermissionDto {
     LOOKUP_TABLE_DATA_CREATE(MANAGEMENT),
     LOOKUP_TABLE_DATA_UPDATE(MANAGEMENT),
     LOOKUP_TABLE_DATA_DELETE(MANAGEMENT),
+    DATA_MASKING_RULE_MANAGE(MANAGEMENT),
+    DATA_MASKING_FIELD_MANAGE(MANAGEMENT),
     ALL(null);
 
     private final PolicyTypeDto type;

odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/ReactiveDatasetFieldMaskingRepositoryImpl.java

@@ -0,0 +1,112 @@
+package org.opendatadiscovery.oddplatform.repository.reactive;
+
+import java.util.List;
+import org.opendatadiscovery.oddplatform.dto.masking.DatasetFieldMaskingDto;
+import org.opendatadiscovery.oddplatform.dto.masking.MaskingRuleDto;
+import org.opendatadiscovery.oddplatform.dto.masking.MaskingRuleType;
+import lombok.RequiredArgsConstructor;
+import org.jooq.impl.DSL;
+import org.opendatadiscovery.oddplatform.repository.util.JooqReactiveOperations;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Mono;
+
+@Repository
+@RequiredArgsConstructor
+public class ReactiveDatasetFieldMaskingRepositoryImpl {
+    private static final String FIELD_MASKING_TABLE = "dataset_field_masking";
+    private static final String MASKING_RULE_TABLE = "masking_rule";
+
+    private final JooqReactiveOperations jooqReactiveOperations;
+
+    public Mono<DatasetFieldMaskingDto> getByFieldId(final long datasetFieldId) {
+        final var query = DSL.select(
+                DSL.field("dfm.id", Long.class),
+                DSL.field("dfm.dataset_field_id", Long.class),
+                DSL.field("mr.id", Long.class),
+                DSL.field("mr.name", String.class),
+                DSL.field("mr.type", String.class),
+                DSL.field("mr.replacement", String.class),
+                DSL.field("mr.pattern", String.class)
+            )
+            .from(DSL.table(FIELD_MASKING_TABLE).as("dfm"))
+            .join(DSL.table(MASKING_RULE_TABLE).as("mr"))
+            .on(DSL.field("dfm.masking_rule_id").eq(DSL.field("mr.id")))
+            .where(DSL.field("dfm.dataset_field_id").eq(datasetFieldId))
+            .and(DSL.field("mr.is_deleted").eq(false));
+
+        return jooqReactiveOperations.mono(query)
+            .map(r -> {
+                final MaskingRuleDto rule = MaskingRuleDto.builder()
+                    .id(r.component3())
+                    .name(r.component4())
+                    .type(MaskingRuleType.valueOf(r.component5()))
+                    .replacement(r.component6())
+                    .pattern(r.component7())
+                    .build();
+                return DatasetFieldMaskingDto.builder()
+                    .id(r.component1())
+                    .datasetFieldId(r.component2())
+                    .maskingRule(rule)
+                    .build();
+            });
+    }
+
+    public Mono<List<DatasetFieldMaskingDto>> getByDatasetId(final long datasetId) {
+        final var query = DSL.select(
+                DSL.field("dfm.id", Long.class),
+                DSL.field("dfm.dataset_field_id", Long.class),
+                DSL.field("mr.id", Long.class),
+                DSL.field("mr.name", String.class),
+                DSL.field("mr.type", String.class),
+                DSL.field("mr.replacement", String.class),
+                DSL.field("mr.pattern", String.class)
+            )
+            .from(DSL.table(FIELD_MASKING_TABLE).as("dfm"))
+            .join(DSL.table(MASKING_RULE_TABLE).as("mr"))
+            .on(DSL.field("dfm.masking_rule_id").eq(DSL.field("mr.id")))
+            .join(DSL.table("dataset_structure").as("ds"))
+            .on(DSL.field("ds.dataset_field_id").eq(DSL.field("dfm.dataset_field_id")))
+            .where(DSL.field("ds.dataset_data_entity_id").eq(datasetId))
+            .and(DSL.field("mr.is_deleted").eq(false));
+
+        return jooqReactiveOperations.flux(query)
+            .map(r -> {
+                final MaskingRuleDto rule = MaskingRuleDto.builder()
+                    .id(r.component3())
+                    .name(r.component4())
+                    .type(MaskingRuleType.valueOf(r.component5()))
+                    .replacement(r.component6())
+                    .pattern(r.component7())
+                    .build();
+                return DatasetFieldMaskingDto.builder()
+                    .id(r.component1())
+                    .datasetFieldId(r.component2())
+                    .maskingRule(rule)
+                    .build();
+            })
+            .collectList();
+    }
+
+    public Mono<Void> applyMasking(final long datasetFieldId, final long ruleId) {
+        final var deleteQuery = DSL.deleteFrom(DSL.table(FIELD_MASKING_TABLE))
+            .where(DSL.field("dataset_field_id").eq(datasetFieldId));
+
+        final var insertQuery = DSL.insertInto(DSL.table(FIELD_MASKING_TABLE))
+            .columns(
+                DSL.field("dataset_field_id"),
+                DSL.field("masking_rule_id")
+            )
+            .values(datasetFieldId, ruleId);
+
+        return jooqReactiveOperations.mono(deleteQuery)
+            .then(jooqReactiveOperations.mono(insertQuery))
+            .then();
+    }
+
+    public Mono<Void> removeMasking(final long datasetFieldId) {
+        final var deleteQuery = DSL.deleteFrom(DSL.table(FIELD_MASKING_TABLE))
+            .where(DSL.field("dataset_field_id").eq(datasetFieldId));
+
+        return jooqReactiveOperations.mono(deleteQuery).then();
+    }
+}

odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/ReactiveMaskingRuleRepository.java

@@ -0,0 +1,11 @@
+package org.opendatadiscovery.oddplatform.repository.reactive;
+
+import java.util.List;
+import org.opendatadiscovery.oddplatform.dto.masking.MaskingRuleDto;
+import reactor.core.publisher.Mono;
+
+public interface ReactiveMaskingRuleRepository {
+    Mono<List<MaskingRuleDto>> findAll();
+
+    Mono<MaskingRuleDto> getById(long id);
+}

odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/repository/reactive/ReactiveMaskingRuleRepositoryImpl.java

@@ -0,0 +1,64 @@
+package org.opendatadiscovery.oddplatform.repository.reactive;
+
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.jooq.impl.DSL;
+import org.opendatadiscovery.oddplatform.dto.masking.MaskingRuleDto;
+import org.opendatadiscovery.oddplatform.dto.masking.MaskingRuleType;
+import org.opendatadiscovery.oddplatform.repository.util.JooqReactiveOperations;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Mono;
+
+@Repository
+@RequiredArgsConstructor
+public class ReactiveMaskingRuleRepositoryImpl implements ReactiveMaskingRuleRepository {
+    private static final String MASKING_RULE_TABLE = "masking_rule";
+
+    private final JooqReactiveOperations jooqReactiveOperations;
+
+    @Override
+    public Mono<List<MaskingRuleDto>> findAll() {
+        final var query = DSL.select(
+                DSL.field("id", Long.class),
+                DSL.field("name", String.class),
+                DSL.field("type", String.class),
+                DSL.field("replacement", String.class),
+                DSL.field("pattern", String.class)
+            )
+            .from(DSL.table(MASKING_RULE_TABLE))
+            .where(DSL.field("is_deleted").eq(false));
+
+        return jooqReactiveOperations.flux(query)
+            .map(r -> MaskingRuleDto.builder()
+                .id(r.component1())
+                .name(r.component2())
+                .type(MaskingRuleType.valueOf(r.component3()))
+                .replacement(r.component4())
+                .pattern(r.component5())
+                .build())
+            .collectList();
+    }
+
+    @Override
+    public Mono<MaskingRuleDto> getById(final long id) {
+        final var query = DSL.select(
+                DSL.field("id", Long.class),
+                DSL.field("name", String.class),
+                DSL.field("type", String.class),
+                DSL.field("replacement", String.class),
+                DSL.field("pattern", String.class)
+            )
+            .from(DSL.table(MASKING_RULE_TABLE))
+            .where(DSL.field("id").eq(id))
+            .and(DSL.field("is_deleted").eq(false));
+
+        return jooqReactiveOperations.mono(query)
+            .map(r -> MaskingRuleDto.builder()
+                .id(r.component1())
+                .name(r.component2())
+                .type(MaskingRuleType.valueOf(r.component3()))
+                .replacement(r.component4())
+                .pattern(r.component5())
+                .build());
+    }
+}

odd-platform-api/src/main/java/org/opendatadiscovery/oddplatform/service/MaskingService.java

@@ -0,0 +1,20 @@
+package org.opendatadiscovery.oddplatform.service;
+
+import java.util.List;
+import org.opendatadiscovery.oddplatform.dto.masking.DatasetFieldMaskingDto;
+import org.opendatadiscovery.oddplatform.dto.masking.MaskingRuleDto;
+import reactor.core.publisher.Mono;
+
+public interface MaskingService {
+    Mono<List<MaskingRuleDto>> getMaskingRules();
+
+    Mono<DatasetFieldMaskingDto> getFieldMasking(long datasetFieldId);
+
+    Mono<List<DatasetFieldMaskingDto>> getDatasetMaskings(long datasetId);
+
+    Mono<Void> applyMasking(long datasetFieldId, long ruleId);
+
+    Mono<Void> removeMasking(long datasetFieldId);
+
+    String maskValue(String value, String ruleType);
+}