Hugging Face's logo

Spaces:
dalabsai
/
da-policyengine-dev
Build error

App Files Community
1
da-policyengine-dev
File size: 6,602 Bytes 
9373c61
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5cfe5c4
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
package com.dalab.policyengine.web.rest;

import java.net.URI;
import java.util.UUID;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.web.PageableDefault;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
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.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;

import com.dalab.common.security.SecurityUtils;
import com.dalab.policyengine.dto.PolicyImpactRequestDTO;
import com.dalab.policyengine.dto.PolicyImpactResponseDTO;
import com.dalab.policyengine.dto.PolicyInputDTO;
import com.dalab.policyengine.dto.PolicyOutputDTO;
import com.dalab.policyengine.dto.PolicySummaryDTO;
import com.dalab.policyengine.service.IPolicyService;

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;

@RestController
@RequestMapping("/api/v1/policyengine/policies")
@Tag(name = "Policy Management", description = "Endpoints for managing data governance policies")
public class PolicyController {

    private static final Logger log = LoggerFactory.getLogger(PolicyController.class);

    private final IPolicyService policyService;

    @Autowired
    public PolicyController(IPolicyService policyService) {
        this.policyService = policyService;
    }

    @GetMapping
    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_POLICY_MANAGER', 'ROLE_USER')")
    public ResponseEntity<Page<PolicySummaryDTO>> getAllPolicies(

            @PageableDefault(size = 20, sort = "name") Pageable pageable,

            @RequestParam(required = false) String status,

            @RequestParam(required = false) String nameContains) {
        log.info("REST request to get all Policies with filters: status={}, nameContains={}", status, nameContains);
        Page<PolicySummaryDTO> policyPage = policyService.getAllPolicies(pageable, status, nameContains);
        return ResponseEntity.ok(policyPage);
    }

    @GetMapping("/{policyId}")
    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_POLICY_MANAGER', 'ROLE_USER')")
    public ResponseEntity<PolicyOutputDTO> getPolicyById(@PathVariable UUID policyId) {
        log.info("REST request to get Policy by id: {}", policyId);
        PolicyOutputDTO policyDTO = policyService.getPolicyById(policyId);
        return ResponseEntity.ok(policyDTO);
    }

    @PostMapping
    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_POLICY_MANAGER')")
    public ResponseEntity<PolicyOutputDTO> createPolicy(@Valid @RequestBody PolicyInputDTO policyInputDTO) {
        log.info("REST request to create Policy: {}", policyInputDTO.getName());
        
        UUID creatorUserId = SecurityUtils.getAuthenticatedUserId();
        PolicyOutputDTO createdPolicy = policyService.createPolicy(policyInputDTO, creatorUserId);
        
        URI location = ServletUriComponentsBuilder.fromCurrentRequest()
                .path("/{id}")
                .buildAndExpand(createdPolicy.getId())
                .toUri();
        
        return ResponseEntity.created(location).body(createdPolicy);
    }

    @PutMapping("/{policyId}")
    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_POLICY_MANAGER')")
    public ResponseEntity<PolicyOutputDTO> updatePolicy(

            @PathVariable UUID policyId,

            @Valid @RequestBody PolicyInputDTO policyInputDTO) {
        log.info("REST request to update Policy: {}", policyId);
        
        UUID updaterUserId = SecurityUtils.getAuthenticatedUserId();
        PolicyOutputDTO updatedPolicy = policyService.updatePolicy(policyId, policyInputDTO, updaterUserId);
        
        return ResponseEntity.ok(updatedPolicy);
    }

    @DeleteMapping("/{policyId}")
    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_POLICY_MANAGER')")
    public ResponseEntity<Void> deletePolicy(@PathVariable UUID policyId) {
        log.info("REST request to delete Policy by id: {}", policyId);
        policyService.deletePolicy(policyId);
        return ResponseEntity.noContent().build();
    }

    @PostMapping("/analyze-impact")
    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_POLICY_MANAGER', 'ROLE_DATA_STEWARD')")
    @Operation(

        summary = "Analyze policy impact before implementation",

        description = "Provides comprehensive analysis of potential policy impacts including affected assets, performance estimates, cost implications, and compliance analysis. Supports FULL, QUICK, and TARGETED analysis types."

    )
    @ApiResponses(value = {

        @ApiResponse(

            responseCode = "200", 

            description = "Policy impact analysis completed successfully"

        ),

        @ApiResponse(

            responseCode = "400", 

            description = "Invalid analysis request parameters"

        ),

        @ApiResponse(

            responseCode = "403", 

            description = "Insufficient permissions to perform policy analysis"

        )

    })
    public ResponseEntity<PolicyImpactResponseDTO> analyzePolicyImpact(

            @Parameter(description = "Policy impact analysis request with rules content and analysis parameters")

            @Valid @RequestBody PolicyImpactRequestDTO request) {
        log.info("REST request to analyze policy impact with analysis type: {}", request.getAnalysisType());
        
        PolicyImpactResponseDTO response = policyService.analyzePolicy(request);
        
        log.info("Policy impact analysis completed for analysis ID: {}", response.getAnalysisId());
        return ResponseEntity.ok(response);
    }
}