Initial deployment of da-policyengine-dev

Dockerfile

@@ -0,0 +1,27 @@
+FROM openjdk:21-jdk-slim
+
+WORKDIR /app
+
+# Install required packages
+RUN apt-get update && apt-get install -y \
+    curl \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy application files
+COPY . .
+
+# Build application (if build.gradle.kts exists)
+RUN if [ -f "build.gradle.kts" ]; then \
+        ./gradlew build -x test; \
+    fi
+
+# Expose port
+EXPOSE 8080
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:8080/actuator/health || exit 1
+
+# Run application
+CMD ["java", "-jar", "build/libs/da-policyengine.jar"]

README.md

@@ -1,10 +1,38 @@
 ---
-title: Da Policyengine Dev
-emoji: ⚡
+title: da-policyengine (dev)
+emoji: 🔧
 colorFrom: blue
-colorTo: red
+colorTo: green
 sdk: docker
-pinned: false
+app_port: 8080
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# da-policyengine - dev Environment
+
+This is the da-policyengine microservice deployed in the dev environment.
+
+## Features
+
+- RESTful API endpoints
+- Health monitoring via Actuator
+- JWT authentication integration
+- PostgreSQL database connectivity
+
+## API Documentation
+
+Once deployed, API documentation will be available at:
+- Swagger UI: https://huggingface.co/spaces/dalabsai/da-policyengine-dev/swagger-ui.html
+- Health Check: https://huggingface.co/spaces/dalabsai/da-policyengine-dev/actuator/health
+
+## Environment
+
+- **Environment**: dev
+- **Port**: 8080
+- **Java Version**: 21
+- **Framework**: Spring Boot
+
+## Deployment
+
+This service is automatically deployed via the DALab CI/CD pipeline.
+
+Last updated: 2025-06-16 23:40:00

build.gradle.kts

@@ -0,0 +1,16 @@
+// da-policyengine inherits common configuration from parent build.gradle.kts
+// This build file adds policy-engine-specific dependencies
+
+dependencies {
+    // Easy Rules engine for policy evaluation
+    implementation("org.jeasy:easy-rules-core:4.1.0")
+    implementation("org.jeasy:easy-rules-mvel:4.1.0")
+    
+    // Additional dependencies specific to da-policyengine
+    implementation("org.springframework.cloud:spring-cloud-starter-openfeign:4.1.1")
+}
+
+// Configure main application class
+configure<org.springframework.boot.gradle.dsl.SpringBootExtension> {
+    mainClass.set("com.dalab.policyengine.DaPolicyEngineApplication")
+} 

src/main/docker/Dockerfile

@@ -0,0 +1,23 @@
+# Ultra-lean container using Google Distroless
+# Expected final size: ~120-180MB (minimal base + JRE + JAR only)
+
+FROM gcr.io/distroless/java21-debian12:nonroot
+
+# Set working directory
+WORKDIR /app
+
+# Copy JAR file
+COPY build/libs/da-policyengine.jar app.jar
+
+# Expose standard Spring Boot port
+EXPOSE 8080
+
+# Run application (distroless has no shell, so use exec form)
+ENTRYPOINT ["java", \
+    "-XX:+UseContainerSupport", \
+    "-XX:MaxRAMPercentage=75.0", \
+    "-XX:+UseG1GC", \
+    "-XX:+UseStringDeduplication", \
+    "-Djava.security.egd=file:/dev/./urandom", \
+    "-Dspring.backgroundpreinitializer.ignore=true", \
+    "-jar", "app.jar"]

src/main/docker/Dockerfile.alpine-jlink

@@ -0,0 +1,43 @@
+# Ultra-minimal Alpine + Custom JRE
+# Expected size: ~120-160MB
+
+# Stage 1: Create custom JRE with only needed modules
+FROM eclipse-temurin:21-jdk-alpine as jre-builder
+WORKDIR /app
+
+# Analyze JAR to find required modules
+COPY build/libs/*.jar app.jar
+RUN jdeps --ignore-missing-deps --print-module-deps app.jar > modules.txt
+
+# Create minimal JRE with only required modules
+RUN jlink \
+    --add-modules $(cat modules.txt),java.logging,java.xml,java.sql,java.naming,java.desktop,java.management,java.security.jgss,java.instrument \
+    --strip-debug \
+    --no-man-pages \
+    --no-header-files \
+    --compress=2 \
+    --output /custom-jre
+
+# Stage 2: Production image
+FROM alpine:3.19
+RUN apk add --no-cache tzdata && \
+    addgroup -g 1001 -S appgroup && \
+    adduser -u 1001 -S appuser -G appgroup
+
+# Copy custom JRE
+COPY --from=jre-builder /custom-jre /opt/java
+ENV JAVA_HOME=/opt/java
+ENV PATH="$JAVA_HOME/bin:$PATH"
+
+WORKDIR /app
+COPY build/libs/*.jar app.jar
+RUN chown appuser:appgroup app.jar
+
+USER appuser
+EXPOSE 8080
+
+ENTRYPOINT ["java", \
+    "-XX:+UseContainerSupport", \
+    "-XX:MaxRAMPercentage=70.0", \
+    "-XX:+UseG1GC", \
+    "-jar", "app.jar"]

src/main/docker/Dockerfile.layered

@@ -0,0 +1,34 @@
+# Ultra-optimized layered build using Distroless
+# Expected size: ~180-220MB with better caching
+
+FROM gcr.io/distroless/java21-debian12:nonroot as base
+
+# Stage 1: Extract JAR layers for optimal caching
+FROM eclipse-temurin:21-jdk-alpine as extractor
+WORKDIR /app
+COPY build/libs/*.jar app.jar
+RUN java -Djarmode=layertools -jar app.jar extract
+
+# Stage 2: Production image with extracted layers
+FROM base
+WORKDIR /app
+
+# Copy layers in dependency order (best caching)
+COPY --from=extractor /app/dependencies/ ./
+COPY --from=extractor /app/spring-boot-loader/ ./
+COPY --from=extractor /app/snapshot-dependencies/ ./
+COPY --from=extractor /app/application/ ./
+
+EXPOSE 8080
+
+# Optimized JVM settings for micro-containers
+ENTRYPOINT ["java", \
+    "-XX:+UseContainerSupport", \
+    "-XX:MaxRAMPercentage=70.0", \
+    "-XX:+UseG1GC", \
+    "-XX:+UseStringDeduplication", \
+    "-XX:+CompactStrings", \
+    "-Xshare:on", \
+    "-Djava.security.egd=file:/dev/./urandom", \
+    "-Dspring.backgroundpreinitializer.ignore=true", \
+    "org.springframework.boot.loader.JarLauncher"]

src/main/docker/Dockerfile.native

@@ -0,0 +1,20 @@
+# GraalVM Native Image - Ultra-fast startup, tiny size
+# Expected size: ~50-80MB, startup <100ms
+# Note: Requires native compilation support in Spring Boot
+
+# Stage 1: Native compilation
+FROM ghcr.io/graalvm/graalvm-ce:ol9-java21 as native-builder
+WORKDIR /app
+
+# Install native-image
+RUN gu install native-image
+
+# Copy source and build native executable
+COPY . .
+RUN ./gradlew nativeCompile
+
+# Stage 2: Minimal runtime
+FROM scratch
+COPY --from=native-builder /app/build/native/nativeCompile/app /app
+EXPOSE 8080
+ENTRYPOINT ["/app"]

src/main/java/com/dalab/policyengine/DaPolicyEngineApplication.java

@@ -0,0 +1,37 @@
+package com.dalab.policyengine;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.kafka.annotation.EnableKafka;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+/**
+ * Main application class for DALab Policy Engine Service.
+ * 
+ * This service handles:
+ * - Policy management and evaluation
+ * - Easy Rules engine integration
+ * - Kafka event processing for asset changes
+ * - Policy action execution and notifications
+ * 
+ * @author DALab Development Team
+ * @since 1.0.0
+ */
+@SpringBootApplication(scanBasePackages = {
+    "com.dalab.policyengine",
+    "com.dalab.discovery.common.security" // Include common security utils
+})
+@EnableJpaRepositories
+@EnableFeignClients
+@EnableKafka
+@EnableAsync
+@EnableScheduling
+public class DaPolicyEngineApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(DaPolicyEngineApplication.class, args);
+    }
+} 

src/main/java/com/dalab/policyengine/common/ConflictException.java

@@ -0,0 +1,11 @@
+package com.dalab.policyengine.common;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@ResponseStatus(HttpStatus.CONFLICT)
+public class ConflictException extends RuntimeException {
+    public ConflictException(String message) {
+        super(message);
+    }
+} 

src/main/java/com/dalab/policyengine/common/ResourceNotFoundException.java

@@ -0,0 +1,15 @@
+package com.dalab.policyengine.common;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@ResponseStatus(HttpStatus.NOT_FOUND)
+public class ResourceNotFoundException extends RuntimeException {
+    public ResourceNotFoundException(String resourceName, String fieldName, String fieldValue) {
+        super(String.format("%s not found with %s : '%s'", resourceName, fieldName, fieldValue));
+    }
+
+    public ResourceNotFoundException(String message) {
+        super(message);
+    }
+} 

src/main/java/com/dalab/policyengine/config/OpenAPIConfiguration.java

@@ -0,0 +1,27 @@
+package com.dalab.policyengine.config;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.info.Info;
+import io.swagger.v3.oas.models.info.License;
+
+@Configuration
+public class OpenAPIConfiguration {
+
+    @Bean
+    public OpenAPI customOpenAPI(
+            @Value("${spring.application.name}") String appName,
+            @Value("${spring.application.description:DALab Policy Engine Microservice}") String appDescription,
+            @Value("${spring.application.version:v0.0.1}") String appVersion) {
+        return new OpenAPI()
+                .info(new Info()
+                        .title(appName)
+                        .version(appVersion)
+                        .description(appDescription)
+                        .termsOfService("http://swagger.io/terms/") // Replace with actual terms
+                        .license(new License().name("Apache 2.0").url("http://springdoc.org"))); // Replace with actual license
+    }
+} 

src/main/java/com/dalab/policyengine/config/SecurityConfiguration.java

@@ -0,0 +1,44 @@
+package com.dalab.policyengine.config;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.oauth2.jwt.JwtDecoder;
+import org.springframework.security.oauth2.jwt.NimbusJwtDecoder;
+import org.springframework.security.web.SecurityFilterChain;
+
+@Configuration
+@EnableWebSecurity
+@EnableMethodSecurity(prePostEnabled = true, securedEnabled = true)
+public class SecurityConfiguration {
+
+    @Value("${spring.security.oauth2.resourceserver.jwt.issuer-uri}")
+    private String issuerUri;
+
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+        http
+            .csrf(csrf -> csrf.disable()) // Typically disable CSRF for stateless REST APIs
+            .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+            .authorizeHttpRequests(authz -> authz
+                // Define public endpoints if any (e.g., actuator/health, swagger-ui)
+                // .requestMatchers("/public/**").permitAll()
+                .anyRequest().authenticated() // All other requests require authentication
+            )
+            .oauth2ResourceServer(oauth2 -> oauth2
+                .jwt(jwt -> jwt.decoder(jwtDecoder()))
+            );
+        return http.build();
+    }
+
+    @Bean
+    public JwtDecoder jwtDecoder() {
+        // NimbusJwtDecoder automatically fetches the JWK Set URI from the issuer URI
+        // (e.g., ISSUER_URI/.well-known/openid-configuration or ISSUER_URI/protocol/openid-connect/certs)
+        return NimbusJwtDecoder.withIssuerLocation(issuerUri).build();
+    }
+} 

src/main/java/com/dalab/policyengine/dto/EventAnalyticsDTO.java

@@ -0,0 +1,349 @@
+package com.dalab.policyengine.dto;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+
+import com.dalab.policyengine.model.EventSeverity;
+import com.dalab.policyengine.model.EventType;
+
+/**
+ * DTO for Event Center analytics and metrics dashboard.
+ */
+public class EventAnalyticsDTO {
+
+    // Summary metrics
+    private Long totalEventsToday;
+    private Long totalEventsThisWeek;
+    private Long totalEventsThisMonth;
+    private Long totalActiveSubscriptions;
+    private Long totalUsersWithSubscriptions;
+
+    // Event distribution by type
+    private List<EventTypeCount> eventsByType;
+
+    // Event distribution by severity
+    private List<EventSeverityCount> eventsBySeverity;
+
+    // Event distribution by source service
+    private List<SourceServiceCount> eventsBySourceService;
+
+    // Top active subscriptions
+    private List<TopSubscription> topActiveSubscriptions;
+
+    // Recent event trends (hourly for last 24 hours)
+    private List<EventTrendPoint> recentTrends;
+
+    // Response time metrics
+    private ResponseTimeMetrics responseMetrics;
+
+    // Alert statistics
+    private AlertStatistics alertStats;
+
+    // Time range for this analytics report
+    private Instant fromTime;
+    private Instant toTime;
+    private Instant generatedAt;
+
+    // Constructors
+    public EventAnalyticsDTO() {
+        this.generatedAt = Instant.now();
+    }
+
+    public EventAnalyticsDTO(Instant fromTime, Instant toTime) {
+        this.fromTime = fromTime;
+        this.toTime = toTime;
+        this.generatedAt = Instant.now();
+    }
+
+    // Getters and Setters
+
+    public Long getTotalEventsToday() {
+        return totalEventsToday;
+    }
+
+    public void setTotalEventsToday(Long totalEventsToday) {
+        this.totalEventsToday = totalEventsToday;
+    }
+
+    public Long getTotalEventsThisWeek() {
+        return totalEventsThisWeek;
+    }
+
+    public void setTotalEventsThisWeek(Long totalEventsThisWeek) {
+        this.totalEventsThisWeek = totalEventsThisWeek;
+    }
+
+    public Long getTotalEventsThisMonth() {
+        return totalEventsThisMonth;
+    }
+
+    public void setTotalEventsThisMonth(Long totalEventsThisMonth) {
+        this.totalEventsThisMonth = totalEventsThisMonth;
+    }
+
+    public Long getTotalActiveSubscriptions() {
+        return totalActiveSubscriptions;
+    }
+
+    public void setTotalActiveSubscriptions(Long totalActiveSubscriptions) {
+        this.totalActiveSubscriptions = totalActiveSubscriptions;
+    }
+
+    public Long getTotalUsersWithSubscriptions() {
+        return totalUsersWithSubscriptions;
+    }
+
+    public void setTotalUsersWithSubscriptions(Long totalUsersWithSubscriptions) {
+        this.totalUsersWithSubscriptions = totalUsersWithSubscriptions;
+    }
+
+    public List<EventTypeCount> getEventsByType() {
+        return eventsByType;
+    }
+
+    public void setEventsByType(List<EventTypeCount> eventsByType) {
+        this.eventsByType = eventsByType;
+    }
+
+    public List<EventSeverityCount> getEventsBySeverity() {
+        return eventsBySeverity;
+    }
+
+    public void setEventsBySeverity(List<EventSeverityCount> eventsBySeverity) {
+        this.eventsBySeverity = eventsBySeverity;
+    }
+
+    public List<SourceServiceCount> getEventsBySourceService() {
+        return eventsBySourceService;
+    }
+
+    public void setEventsBySourceService(List<SourceServiceCount> eventsBySourceService) {
+        this.eventsBySourceService = eventsBySourceService;
+    }
+
+    public List<TopSubscription> getTopActiveSubscriptions() {
+        return topActiveSubscriptions;
+    }
+
+    public void setTopActiveSubscriptions(List<TopSubscription> topActiveSubscriptions) {
+        this.topActiveSubscriptions = topActiveSubscriptions;
+    }
+
+    public List<EventTrendPoint> getRecentTrends() {
+        return recentTrends;
+    }
+
+    public void setRecentTrends(List<EventTrendPoint> recentTrends) {
+        this.recentTrends = recentTrends;
+    }
+
+    public ResponseTimeMetrics getResponseMetrics() {
+        return responseMetrics;
+    }
+
+    public void setResponseMetrics(ResponseTimeMetrics responseMetrics) {
+        this.responseMetrics = responseMetrics;
+    }
+
+    public AlertStatistics getAlertStats() {
+        return alertStats;
+    }
+
+    public void setAlertStats(AlertStatistics alertStats) {
+        this.alertStats = alertStats;
+    }
+
+    public Instant getFromTime() {
+        return fromTime;
+    }
+
+    public void setFromTime(Instant fromTime) {
+        this.fromTime = fromTime;
+    }
+
+    public Instant getToTime() {
+        return toTime;
+    }
+
+    public void setToTime(Instant toTime) {
+        this.toTime = toTime;
+    }
+
+    public Instant getGeneratedAt() {
+        return generatedAt;
+    }
+
+    public void setGeneratedAt(Instant generatedAt) {
+        this.generatedAt = generatedAt;
+    }
+
+    @Override
+    public String toString() {
+        return "EventAnalyticsDTO{" +
+                "totalEventsToday=" + totalEventsToday +
+                ", totalEventsThisWeek=" + totalEventsThisWeek +
+                ", totalEventsThisMonth=" + totalEventsThisMonth +
+                ", totalActiveSubscriptions=" + totalActiveSubscriptions +
+                ", fromTime=" + fromTime +
+                ", toTime=" + toTime +
+                ", generatedAt=" + generatedAt +
+                '}';
+    }
+
+    // Nested classes for analytics data structures
+
+    public static class EventTypeCount {
+        private EventType eventType;
+        private Long count;
+        private Double percentage;
+
+        public EventTypeCount() {}
+
+        public EventTypeCount(EventType eventType, Long count) {
+            this.eventType = eventType;
+            this.count = count;
+        }
+
+        public EventType getEventType() { return eventType; }
+        public void setEventType(EventType eventType) { this.eventType = eventType; }
+        public Long getCount() { return count; }
+        public void setCount(Long count) { this.count = count; }
+        public Double getPercentage() { return percentage; }
+        public void setPercentage(Double percentage) { this.percentage = percentage; }
+    }
+
+    public static class EventSeverityCount {
+        private EventSeverity severity;
+        private Long count;
+        private Double percentage;
+
+        public EventSeverityCount() {}
+
+        public EventSeverityCount(EventSeverity severity, Long count) {
+            this.severity = severity;
+            this.count = count;
+        }
+
+        public EventSeverity getSeverity() { return severity; }
+        public void setSeverity(EventSeverity severity) { this.severity = severity; }
+        public Long getCount() { return count; }
+        public void setCount(Long count) { this.count = count; }
+        public Double getPercentage() { return percentage; }
+        public void setPercentage(Double percentage) { this.percentage = percentage; }
+    }
+
+    public static class SourceServiceCount {
+        private String sourceService;
+        private Long count;
+        private Double percentage;
+
+        public SourceServiceCount() {}
+
+        public SourceServiceCount(String sourceService, Long count) {
+            this.sourceService = sourceService;
+            this.count = count;
+        }
+
+        public String getSourceService() { return sourceService; }
+        public void setSourceService(String sourceService) { this.sourceService = sourceService; }
+        public Long getCount() { return count; }
+        public void setCount(Long count) { this.count = count; }
+        public Double getPercentage() { return percentage; }
+        public void setPercentage(Double percentage) { this.percentage = percentage; }
+    }
+
+    public static class TopSubscription {
+        private String subscriptionName;
+        private Long eventsMatched;
+        private Long notificationsSent;
+        private String ownerName;
+        private Instant lastActivity;
+
+        public TopSubscription() {}
+
+        public TopSubscription(String subscriptionName, Long eventsMatched) {
+            this.subscriptionName = subscriptionName;
+            this.eventsMatched = eventsMatched;
+        }
+
+        public String getSubscriptionName() { return subscriptionName; }
+        public void setSubscriptionName(String subscriptionName) { this.subscriptionName = subscriptionName; }
+        public Long getEventsMatched() { return eventsMatched; }
+        public void setEventsMatched(Long eventsMatched) { this.eventsMatched = eventsMatched; }
+        public Long getNotificationsSent() { return notificationsSent; }
+        public void setNotificationsSent(Long notificationsSent) { this.notificationsSent = notificationsSent; }
+        public String getOwnerName() { return ownerName; }
+        public void setOwnerName(String ownerName) { this.ownerName = ownerName; }
+        public Instant getLastActivity() { return lastActivity; }
+        public void setLastActivity(Instant lastActivity) { this.lastActivity = lastActivity; }
+    }
+
+    public static class EventTrendPoint {
+        private Instant timestamp;
+        private Long eventCount;
+        private Long criticalCount;
+        private Long highCount;
+        private Long mediumCount;
+        private Long lowCount;
+
+        public EventTrendPoint() {}
+
+        public EventTrendPoint(Instant timestamp, Long eventCount) {
+            this.timestamp = timestamp;
+            this.eventCount = eventCount;
+        }
+
+        public Instant getTimestamp() { return timestamp; }
+        public void setTimestamp(Instant timestamp) { this.timestamp = timestamp; }
+        public Long getEventCount() { return eventCount; }
+        public void setEventCount(Long eventCount) { this.eventCount = eventCount; }
+        public Long getCriticalCount() { return criticalCount; }
+        public void setCriticalCount(Long criticalCount) { this.criticalCount = criticalCount; }
+        public Long getHighCount() { return highCount; }
+        public void setHighCount(Long highCount) { this.highCount = highCount; }
+        public Long getMediumCount() { return mediumCount; }
+        public void setMediumCount(Long mediumCount) { this.mediumCount = mediumCount; }
+        public Long getLowCount() { return lowCount; }
+        public void setLowCount(Long lowCount) { this.lowCount = lowCount; }
+    }
+
+    public static class ResponseTimeMetrics {
+        private Double averageProcessingTimeMs;
+        private Double averageNotificationTimeMs;
+        private Long totalProcessedEvents;
+        private Long failedNotifications;
+        private Double successRate;
+
+        public ResponseTimeMetrics() {}
+
+        public Double getAverageProcessingTimeMs() { return averageProcessingTimeMs; }
+        public void setAverageProcessingTimeMs(Double averageProcessingTimeMs) { this.averageProcessingTimeMs = averageProcessingTimeMs; }
+        public Double getAverageNotificationTimeMs() { return averageNotificationTimeMs; }
+        public void setAverageNotificationTimeMs(Double averageNotificationTimeMs) { this.averageNotificationTimeMs = averageNotificationTimeMs; }
+        public Long getTotalProcessedEvents() { return totalProcessedEvents; }
+        public void setTotalProcessedEvents(Long totalProcessedEvents) { this.totalProcessedEvents = totalProcessedEvents; }
+        public Long getFailedNotifications() { return failedNotifications; }
+        public void setFailedNotifications(Long failedNotifications) { this.failedNotifications = failedNotifications; }
+        public Double getSuccessRate() { return successRate; }
+        public void setSuccessRate(Double successRate) { this.successRate = successRate; }
+    }
+
+    public static class AlertStatistics {
+        private Long totalAlertsTriggered;
+        private Long totalNotificationsSent;
+        private Long totalActionsExecuted;
+        private Map<String, Long> alertsByChannel; // email, slack, webhook, etc.
+
+        public AlertStatistics() {}
+
+        public Long getTotalAlertsTriggered() { return totalAlertsTriggered; }
+        public void setTotalAlertsTriggered(Long totalAlertsTriggered) { this.totalAlertsTriggered = totalAlertsTriggered; }
+        public Long getTotalNotificationsSent() { return totalNotificationsSent; }
+        public void setTotalNotificationsSent(Long totalNotificationsSent) { this.totalNotificationsSent = totalNotificationsSent; }
+        public Long getTotalActionsExecuted() { return totalActionsExecuted; }
+        public void setTotalActionsExecuted(Long totalActionsExecuted) { this.totalActionsExecuted = totalActionsExecuted; }
+        public Map<String, Long> getAlertsByChannel() { return alertsByChannel; }
+        public void setAlertsByChannel(Map<String, Long> alertsByChannel) { this.alertsByChannel = alertsByChannel; }
+    }
+} 

src/main/java/com/dalab/policyengine/dto/EventStreamDTO.java

@@ -0,0 +1,216 @@
+package com.dalab.policyengine.dto;
+
+import java.time.Instant;
+import java.util.Map;
+import java.util.UUID;
+
+import com.dalab.policyengine.model.EventSeverity;
+import com.dalab.policyengine.model.EventType;
+
+/**
+ * DTO for streaming events in real-time to the Event Center UI.
+ */
+public class EventStreamDTO {
+
+    private UUID eventId;
+    private EventType eventType;
+    private EventSeverity severity;
+    private String sourceService;
+    private String title;
+    private String description;
+    private UUID assetId;
+    private String assetName;
+    private UUID policyId;
+    private String policyName;
+    private Map<String, Object> eventData;
+    private Map<String, Object> metadata;
+    private Instant timestamp;
+    private UUID userId;
+    private String userAction;
+
+    // Event processing information
+    private Boolean isProcessed;
+    private Integer matchingSubscriptionsCount;
+    private Boolean notificationSent;
+    private Boolean actionTriggered;
+
+    // Constructors
+    public EventStreamDTO() {}
+
+    public EventStreamDTO(UUID eventId, EventType eventType, EventSeverity severity, String sourceService) {
+        this.eventId = eventId;
+        this.eventType = eventType;
+        this.severity = severity;
+        this.sourceService = sourceService;
+        this.timestamp = Instant.now();
+    }
+
+    // Getters and Setters
+
+    public UUID getEventId() {
+        return eventId;
+    }
+
+    public void setEventId(UUID eventId) {
+        this.eventId = eventId;
+    }
+
+    public EventType getEventType() {
+        return eventType;
+    }
+
+    public void setEventType(EventType eventType) {
+        this.eventType = eventType;
+    }
+
+    public EventSeverity getSeverity() {
+        return severity;
+    }
+
+    public void setSeverity(EventSeverity severity) {
+        this.severity = severity;
+    }
+
+    public String getSourceService() {
+        return sourceService;
+    }
+
+    public void setSourceService(String sourceService) {
+        this.sourceService = sourceService;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public UUID getAssetId() {
+        return assetId;
+    }
+
+    public void setAssetId(UUID assetId) {
+        this.assetId = assetId;
+    }
+
+    public String getAssetName() {
+        return assetName;
+    }
+
+    public void setAssetName(String assetName) {
+        this.assetName = assetName;
+    }
+
+    public UUID getPolicyId() {
+        return policyId;
+    }
+
+    public void setPolicyId(UUID policyId) {
+        this.policyId = policyId;
+    }
+
+    public String getPolicyName() {
+        return policyName;
+    }
+
+    public void setPolicyName(String policyName) {
+        this.policyName = policyName;
+    }
+
+    public Map<String, Object> getEventData() {
+        return eventData;
+    }
+
+    public void setEventData(Map<String, Object> eventData) {
+        this.eventData = eventData;
+    }
+
+    public Map<String, Object> getMetadata() {
+        return metadata;
+    }
+
+    public void setMetadata(Map<String, Object> metadata) {
+        this.metadata = metadata;
+    }
+
+    public Instant getTimestamp() {
+        return timestamp;
+    }
+
+    public void setTimestamp(Instant timestamp) {
+        this.timestamp = timestamp;
+    }
+
+    public UUID getUserId() {
+        return userId;
+    }
+
+    public void setUserId(UUID userId) {
+        this.userId = userId;
+    }
+
+    public String getUserAction() {
+        return userAction;
+    }
+
+    public void setUserAction(String userAction) {
+        this.userAction = userAction;
+    }
+
+    public Boolean getIsProcessed() {
+        return isProcessed;
+    }
+
+    public void setIsProcessed(Boolean isProcessed) {
+        this.isProcessed = isProcessed;
+    }
+
+    public Integer getMatchingSubscriptionsCount() {
+        return matchingSubscriptionsCount;
+    }
+
+    public void setMatchingSubscriptionsCount(Integer matchingSubscriptionsCount) {
+        this.matchingSubscriptionsCount = matchingSubscriptionsCount;
+    }
+
+    public Boolean getNotificationSent() {
+        return notificationSent;
+    }
+
+    public void setNotificationSent(Boolean notificationSent) {
+        this.notificationSent = notificationSent;
+    }
+
+    public Boolean getActionTriggered() {
+        return actionTriggered;
+    }
+
+    public void setActionTriggered(Boolean actionTriggered) {
+        this.actionTriggered = actionTriggered;
+    }
+
+    @Override
+    public String toString() {
+        return "EventStreamDTO{" +
+                "eventId=" + eventId +
+                ", eventType=" + eventType +
+                ", severity=" + severity +
+                ", sourceService='" + sourceService + '\'' +
+                ", title='" + title + '\'' +
+                ", assetId=" + assetId +
+                ", policyId=" + policyId +
+                ", timestamp=" + timestamp +
+                ", isProcessed=" + isProcessed +
+                '}';
+    }
+} 

src/main/java/com/dalab/policyengine/dto/EventSubscriptionInputDTO.java

@@ -0,0 +1,229 @@
+package com.dalab.policyengine.dto;
+
+import java.util.List;
+import java.util.Map;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
+import com.dalab.policyengine.model.EventSeverity;
+import com.dalab.policyengine.model.EventType;
+
+/**
+ * DTO for creating or updating event subscriptions.
+ */
+public class EventSubscriptionInputDTO {
+
+    @NotBlank(message = "Subscription name is required")
+    @Size(max = 255, message = "Subscription name must not exceed 255 characters")
+    private String name;
+
+    @Size(max = 1000, message = "Description must not exceed 1000 characters")
+    private String description;
+
+    /**
+     * Event types to subscribe to
+     */
+    private List<EventType> eventTypes;
+
+    /**
+     * Event severity levels to include
+     */
+    private List<EventSeverity> severities;
+
+    /**
+     * Source services to monitor
+     */
+    private List<String> sourceServices;
+
+    /**
+     * Event filtering rules
+     */
+    private List<EventRuleInputDTO> rules;
+
+    /**
+     * Notification configuration
+     * Example: { "email": true, "slack": { "channel": "#alerts", "webhook": "https://..." } }
+     */
+    private Map<String, Object> notificationConfig;
+
+    /**
+     * Action configuration for automated responses
+     * Example: { "autoQuarantine": true, "escalateTo": "admin", "maxRetries": 3 }
+     */
+    private Map<String, Object> actionConfig;
+
+    // Constructors
+    public EventSubscriptionInputDTO() {}
+
+    public EventSubscriptionInputDTO(String name) {
+        this.name = name;
+    }
+
+    // Getters and Setters
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public List<EventType> getEventTypes() {
+        return eventTypes;
+    }
+
+    public void setEventTypes(List<EventType> eventTypes) {
+        this.eventTypes = eventTypes;
+    }
+
+    public List<EventSeverity> getSeverities() {
+        return severities;
+    }
+
+    public void setSeverities(List<EventSeverity> severities) {
+        this.severities = severities;
+    }
+
+    public List<String> getSourceServices() {
+        return sourceServices;
+    }
+
+    public void setSourceServices(List<String> sourceServices) {
+        this.sourceServices = sourceServices;
+    }
+
+    public List<EventRuleInputDTO> getRules() {
+        return rules;
+    }
+
+    public void setRules(List<EventRuleInputDTO> rules) {
+        this.rules = rules;
+    }
+
+    public Map<String, Object> getNotificationConfig() {
+        return notificationConfig;
+    }
+
+    public void setNotificationConfig(Map<String, Object> notificationConfig) {
+        this.notificationConfig = notificationConfig;
+    }
+
+    public Map<String, Object> getActionConfig() {
+        return actionConfig;
+    }
+
+    public void setActionConfig(Map<String, Object> actionConfig) {
+        this.actionConfig = actionConfig;
+    }
+
+    @Override
+    public String toString() {
+        return "EventSubscriptionInputDTO{" +
+                "name='" + name + '\'' +
+                ", description='" + description + '\'' +
+                ", eventTypes=" + eventTypes +
+                ", severities=" + severities +
+                ", sourceServices=" + sourceServices +
+                ", rulesCount=" + (rules != null ? rules.size() : 0) +
+                '}';
+    }
+
+    /**
+     * Nested DTO for event rules within subscription input
+     */
+    public static class EventRuleInputDTO {
+        @NotBlank(message = "Rule name is required")
+        @Size(max = 255, message = "Rule name must not exceed 255 characters")
+        private String name;
+
+        @Size(max = 500, message = "Rule description must not exceed 500 characters")
+        private String description;
+
+        @NotBlank(message = "Rule condition is required")
+        private String condition;
+
+        private Integer priority = 1;
+
+        private Boolean enabled = true;
+
+        private Map<String, Object> parameters;
+
+        // Constructors
+        public EventRuleInputDTO() {}
+
+        public EventRuleInputDTO(String name, String condition) {
+            this.name = name;
+            this.condition = condition;
+        }
+
+        // Getters and Setters
+
+        public String getName() {
+            return name;
+        }
+
+        public void setName(String name) {
+            this.name = name;
+        }
+
+        public String getDescription() {
+            return description;
+        }
+
+        public void setDescription(String description) {
+            this.description = description;
+        }
+
+        public String getCondition() {
+            return condition;
+        }
+
+        public void setCondition(String condition) {
+            this.condition = condition;
+        }
+
+        public Integer getPriority() {
+            return priority;
+        }
+
+        public void setPriority(Integer priority) {
+            this.priority = priority;
+        }
+
+        public Boolean getEnabled() {
+            return enabled;
+        }
+
+        public void setEnabled(Boolean enabled) {
+            this.enabled = enabled;
+        }
+
+        public Map<String, Object> getParameters() {
+            return parameters;
+        }
+
+        public void setParameters(Map<String, Object> parameters) {
+            this.parameters = parameters;
+        }
+
+        @Override
+        public String toString() {
+            return "EventRuleInputDTO{" +
+                    "name='" + name + '\'' +
+                    ", condition='" + condition + '\'' +
+                    ", priority=" + priority +
+                    ", enabled=" + enabled +
+                    '}';
+        }
+    }
+} 

src/main/java/com/dalab/policyengine/dto/EventSubscriptionOutputDTO.java

@@ -0,0 +1,343 @@
+package com.dalab.policyengine.dto;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import com.dalab.policyengine.model.EventSeverity;
+import com.dalab.policyengine.model.EventSubscriptionStatus;
+import com.dalab.policyengine.model.EventType;
+
+/**
+ * DTO for returning event subscription information.
+ */
+public class EventSubscriptionOutputDTO {
+
+    private UUID id;
+    private String name;
+    private String description;
+    private UUID userId;
+    private EventSubscriptionStatus status;
+    private List<EventType> eventTypes;
+    private List<EventSeverity> severities;
+    private List<String> sourceServices;
+    private List<EventRuleOutputDTO> rules;
+    private Map<String, Object> notificationConfig;
+    private Map<String, Object> actionConfig;
+    private Instant createdAt;
+    private Instant updatedAt;
+    private UUID createdByUserId;
+    private UUID updatedByUserId;
+
+    // Statistics
+    private Long totalRulesCount;
+    private Long enabledRulesCount;
+    private Long eventsMatchedCount;
+    private Instant lastEventMatchedAt;
+
+    // Constructors
+    public EventSubscriptionOutputDTO() {}
+
+    public EventSubscriptionOutputDTO(UUID id, String name, UUID userId, EventSubscriptionStatus status) {
+        this.id = id;
+        this.name = name;
+        this.userId = userId;
+        this.status = status;
+    }
+
+    // Getters and Setters
+
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public UUID getUserId() {
+        return userId;
+    }
+
+    public void setUserId(UUID userId) {
+        this.userId = userId;
+    }
+
+    public EventSubscriptionStatus getStatus() {
+        return status;
+    }
+
+    public void setStatus(EventSubscriptionStatus status) {
+        this.status = status;
+    }
+
+    public List<EventType> getEventTypes() {
+        return eventTypes;
+    }
+
+    public void setEventTypes(List<EventType> eventTypes) {
+        this.eventTypes = eventTypes;
+    }
+
+    public List<EventSeverity> getSeverities() {
+        return severities;
+    }
+
+    public void setSeverities(List<EventSeverity> severities) {
+        this.severities = severities;
+    }
+
+    public List<String> getSourceServices() {
+        return sourceServices;
+    }
+
+    public void setSourceServices(List<String> sourceServices) {
+        this.sourceServices = sourceServices;
+    }
+
+    public List<EventRuleOutputDTO> getRules() {
+        return rules;
+    }
+
+    public void setRules(List<EventRuleOutputDTO> rules) {
+        this.rules = rules;
+    }
+
+    public Map<String, Object> getNotificationConfig() {
+        return notificationConfig;
+    }
+
+    public void setNotificationConfig(Map<String, Object> notificationConfig) {
+        this.notificationConfig = notificationConfig;
+    }
+
+    public Map<String, Object> getActionConfig() {
+        return actionConfig;
+    }
+
+    public void setActionConfig(Map<String, Object> actionConfig) {
+        this.actionConfig = actionConfig;
+    }
+
+    public Instant getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(Instant createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public Instant getUpdatedAt() {
+        return updatedAt;
+    }
+
+    public void setUpdatedAt(Instant updatedAt) {
+        this.updatedAt = updatedAt;
+    }
+
+    public UUID getCreatedByUserId() {
+        return createdByUserId;
+    }
+
+    public void setCreatedByUserId(UUID createdByUserId) {
+        this.createdByUserId = createdByUserId;
+    }
+
+    public UUID getUpdatedByUserId() {
+        return updatedByUserId;
+    }
+
+    public void setUpdatedByUserId(UUID updatedByUserId) {
+        this.updatedByUserId = updatedByUserId;
+    }
+
+    public Long getTotalRulesCount() {
+        return totalRulesCount;
+    }
+
+    public void setTotalRulesCount(Long totalRulesCount) {
+        this.totalRulesCount = totalRulesCount;
+    }
+
+    public Long getEnabledRulesCount() {
+        return enabledRulesCount;
+    }
+
+    public void setEnabledRulesCount(Long enabledRulesCount) {
+        this.enabledRulesCount = enabledRulesCount;
+    }
+
+    public Long getEventsMatchedCount() {
+        return eventsMatchedCount;
+    }
+
+    public void setEventsMatchedCount(Long eventsMatchedCount) {
+        this.eventsMatchedCount = eventsMatchedCount;
+    }
+
+    public Instant getLastEventMatchedAt() {
+        return lastEventMatchedAt;
+    }
+
+    public void setLastEventMatchedAt(Instant lastEventMatchedAt) {
+        this.lastEventMatchedAt = lastEventMatchedAt;
+    }
+
+    @Override
+    public String toString() {
+        return "EventSubscriptionOutputDTO{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                ", userId=" + userId +
+                ", status=" + status +
+                ", eventTypes=" + eventTypes +
+                ", severities=" + severities +
+                ", rulesCount=" + totalRulesCount +
+                ", eventsMatchedCount=" + eventsMatchedCount +
+                '}';
+    }
+
+    /**
+     * Nested DTO for event rules within subscription output
+     */
+    public static class EventRuleOutputDTO {
+        private UUID id;
+        private String name;
+        private String description;
+        private String condition;
+        private Integer priority;
+        private Boolean enabled;
+        private Map<String, Object> parameters;
+        private Instant createdAt;
+        private Instant updatedAt;
+        private UUID createdByUserId;
+        private UUID updatedByUserId;
+
+        // Constructors
+        public EventRuleOutputDTO() {}
+
+        public EventRuleOutputDTO(UUID id, String name, String condition) {
+            this.id = id;
+            this.name = name;
+            this.condition = condition;
+        }
+
+        // Getters and Setters
+
+        public UUID getId() {
+            return id;
+        }
+
+        public void setId(UUID id) {
+            this.id = id;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public void setName(String name) {
+            this.name = name;
+        }
+
+        public String getDescription() {
+            return description;
+        }
+
+        public void setDescription(String description) {
+            this.description = description;
+        }
+
+        public String getCondition() {
+            return condition;
+        }
+
+        public void setCondition(String condition) {
+            this.condition = condition;
+        }
+
+        public Integer getPriority() {
+            return priority;
+        }
+
+        public void setPriority(Integer priority) {
+            this.priority = priority;
+        }
+
+        public Boolean getEnabled() {
+            return enabled;
+        }
+
+        public void setEnabled(Boolean enabled) {
+            this.enabled = enabled;
+        }
+
+        public Map<String, Object> getParameters() {
+            return parameters;
+        }
+
+        public void setParameters(Map<String, Object> parameters) {
+            this.parameters = parameters;
+        }
+
+        public Instant getCreatedAt() {
+            return createdAt;
+        }
+
+        public void setCreatedAt(Instant createdAt) {
+            this.createdAt = createdAt;
+        }
+
+        public Instant getUpdatedAt() {
+            return updatedAt;
+        }
+
+        public void setUpdatedAt(Instant updatedAt) {
+            this.updatedAt = updatedAt;
+        }
+
+        public UUID getCreatedByUserId() {
+            return createdByUserId;
+        }
+
+        public void setCreatedByUserId(UUID createdByUserId) {
+            this.createdByUserId = createdByUserId;
+        }
+
+        public UUID getUpdatedByUserId() {
+            return updatedByUserId;
+        }
+
+        public void setUpdatedByUserId(UUID updatedByUserId) {
+            this.updatedByUserId = updatedByUserId;
+        }
+
+        @Override
+        public String toString() {
+            return "EventRuleOutputDTO{" +
+                    "id=" + id +
+                    ", name='" + name + '\'' +
+                    ", condition='" + condition + '\'' +
+                    ", priority=" + priority +
+                    ", enabled=" + enabled +
+                    '}';
+        }
+    }
+} 

src/main/java/com/dalab/policyengine/dto/PolicyDraftActionDTO.java

@@ -0,0 +1,268 @@
+package com.dalab.policyengine.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
+/**
+ * DTO for policy draft workflow actions (submit, approve, reject, etc.).
+ * Used for all workflow transition operations.
+ */
+public class PolicyDraftActionDTO {
+
+    /**
+     * The action to perform (SUBMIT, APPROVE, REJECT, REQUEST_CHANGES, ARCHIVE).
+     */
+    @NotBlank(message = "Action type is required")
+    private String actionType;
+
+    /**
+     * Comment or reason for the action (required for rejection and optional for others).
+     */
+    @Size(max = 2000, message = "Comment must not exceed 2000 characters")
+    private String comment;
+
+    /**
+     * Priority level if submitting or approving (HIGH, MEDIUM, LOW).
+     */
+    private String priority;
+
+    /**
+     * Target implementation date if approving for publication.
+     */
+    private String targetImplementationDate;
+
+    /**
+     * Additional metadata for the action.
+     */
+    private String metadata;
+
+    // Constructors
+    public PolicyDraftActionDTO() {}
+
+    public PolicyDraftActionDTO(String actionType) {
+        this.actionType = actionType;
+    }
+
+    public PolicyDraftActionDTO(String actionType, String comment) {
+        this.actionType = actionType;
+        this.comment = comment;
+    }
+
+    // Getters and Setters
+    public String getActionType() {
+        return actionType;
+    }
+
+    public void setActionType(String actionType) {
+        this.actionType = actionType;
+    }
+
+    public String getComment() {
+        return comment;
+    }
+
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+
+    public String getPriority() {
+        return priority;
+    }
+
+    public void setPriority(String priority) {
+        this.priority = priority;
+    }
+
+    public String getTargetImplementationDate() {
+        return targetImplementationDate;
+    }
+
+    public void setTargetImplementationDate(String targetImplementationDate) {
+        this.targetImplementationDate = targetImplementationDate;
+    }
+
+    public String getMetadata() {
+        return metadata;
+    }
+
+    public void setMetadata(String metadata) {
+        this.metadata = metadata;
+    }
+}
+
+/**
+ * DTO for bulk operations on multiple policy drafts.
+ */
+class PolicyDraftBulkActionDTO {
+
+    /**
+     * List of draft IDs to perform action on.
+     */
+    @NotBlank(message = "Draft IDs are required")
+    private java.util.List<java.util.UUID> draftIds;
+
+    /**
+     * The action to perform on all selected drafts.
+     */
+    @NotBlank(message = "Action type is required")
+    private String actionType;
+
+    /**
+     * Comment for the bulk action.
+     */
+    @Size(max = 1000, message = "Comment must not exceed 1000 characters")
+    private String comment;
+
+    // Constructors
+    public PolicyDraftBulkActionDTO() {}
+
+    // Getters and Setters
+    public java.util.List<java.util.UUID> getDraftIds() {
+        return draftIds;
+    }
+
+    public void setDraftIds(java.util.List<java.util.UUID> draftIds) {
+        this.draftIds = draftIds;
+    }
+
+    public String getActionType() {
+        return actionType;
+    }
+
+    public void setActionType(String actionType) {
+        this.actionType = actionType;
+    }
+
+    public String getComment() {
+        return comment;
+    }
+
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+}
+
+/**
+ * DTO for policy draft summary information (for list views).
+ */
+class PolicyDraftSummaryDTO {
+
+    private java.util.UUID id;
+    private String name;
+    private String status;
+    private Integer version;
+    private String priority;
+    private String category;
+    private java.time.Instant createdAt;
+    private java.time.Instant updatedAt;
+    private java.util.UUID createdByUserId;
+    private java.time.Instant targetImplementationDate;
+    private int reviewCommentsCount;
+    private boolean isOverdue;
+
+    // Constructors
+    public PolicyDraftSummaryDTO() {}
+
+    public PolicyDraftSummaryDTO(java.util.UUID id, String name, String status) {
+        this.id = id;
+        this.name = name;
+        this.status = status;
+    }
+
+    // Getters and Setters
+    public java.util.UUID getId() {
+        return id;
+    }
+
+    public void setId(java.util.UUID id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+
+    public Integer getVersion() {
+        return version;
+    }
+
+    public void setVersion(Integer version) {
+        this.version = version;
+    }
+
+    public String getPriority() {
+        return priority;
+    }
+
+    public void setPriority(String priority) {
+        this.priority = priority;
+    }
+
+    public String getCategory() {
+        return category;
+    }
+
+    public void setCategory(String category) {
+        this.category = category;
+    }
+
+    public java.time.Instant getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(java.time.Instant createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public java.time.Instant getUpdatedAt() {
+        return updatedAt;
+    }
+
+    public void setUpdatedAt(java.time.Instant updatedAt) {
+        this.updatedAt = updatedAt;
+    }
+
+    public java.util.UUID getCreatedByUserId() {
+        return createdByUserId;
+    }
+
+    public void setCreatedByUserId(java.util.UUID createdByUserId) {
+        this.createdByUserId = createdByUserId;
+    }
+
+    public java.time.Instant getTargetImplementationDate() {
+        return targetImplementationDate;
+    }
+
+    public void setTargetImplementationDate(java.time.Instant targetImplementationDate) {
+        this.targetImplementationDate = targetImplementationDate;
+    }
+
+    public int getReviewCommentsCount() {
+        return reviewCommentsCount;
+    }
+
+    public void setReviewCommentsCount(int reviewCommentsCount) {
+        this.reviewCommentsCount = reviewCommentsCount;
+    }
+
+    public boolean isOverdue() {
+        return isOverdue;
+    }
+
+    public void setOverdue(boolean overdue) {
+        isOverdue = overdue;
+    }
+} 

src/main/java/com/dalab/policyengine/dto/PolicyDraftInputDTO.java

@@ -0,0 +1,227 @@
+package com.dalab.policyengine.dto;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
+/**
+ * DTO for creating and updating policy drafts.
+ * Contains all information needed for draft management and workflow.
+ */
+public class PolicyDraftInputDTO {
+
+    /**
+     * Name of the policy (must be unique when published).
+     */
+    @NotBlank(message = "Policy name is required")
+    @Size(max = 255, message = "Policy name must not exceed 255 characters")
+    private String name;
+
+    /**
+     * Detailed description of the policy's purpose and scope.
+     */
+    @Size(max = 2000, message = "Description must not exceed 2000 characters")
+    private String description;
+
+    /**
+     * Reference to the published policy if this is an update.
+     */
+    private UUID basePolicyId;
+
+    /**
+     * MVEL condition logic for the policy evaluation.
+     */
+    private String conditionLogic;
+
+    /**
+     * JSON representation of policy rules structure.
+     */
+    private List<Map<String, Object>> rulesDefinition;
+
+    /**
+     * JSON representation of actions to be taken when policy is triggered.
+     */
+    private Map<String, Object> actions;
+
+    /**
+     * Change summary describing what was modified in this version.
+     */
+    @Size(max = 1000, message = "Change summary must not exceed 1000 characters")
+    private String changeSummary;
+
+    /**
+     * Justification for the policy changes or creation.
+     */
+    @Size(max = 2000, message = "Justification must not exceed 2000 characters")
+    private String justification;
+
+    /**
+     * Expected impact of implementing this policy.
+     */
+    @Size(max = 1000, message = "Expected impact must not exceed 1000 characters")
+    private String expectedImpact;
+
+    /**
+     * Target implementation date for the policy.
+     */
+    private Instant targetImplementationDate;
+
+    /**
+     * Priority level for policy implementation.
+     */
+    private String priority = "MEDIUM";
+
+    /**
+     * Business category or domain this policy applies to.
+     */
+    @Size(max = 100, message = "Category must not exceed 100 characters")
+    private String category;
+
+    /**
+     * Tags for categorization and searchability.
+     */
+    private List<String> tags;
+
+    /**
+     * Stakeholders who should be notified about this policy.
+     */
+    private List<UUID> stakeholders;
+
+    /**
+     * Additional metadata for workflow management.
+     */
+    private Map<String, Object> workflowMetadata;
+
+    // Constructors
+    public PolicyDraftInputDTO() {}
+
+    public PolicyDraftInputDTO(String name, String description) {
+        this.name = name;
+        this.description = description;
+    }
+
+    // Getters and Setters
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public UUID getBasePolicyId() {
+        return basePolicyId;
+    }
+
+    public void setBasePolicyId(UUID basePolicyId) {
+        this.basePolicyId = basePolicyId;
+    }
+
+    public String getConditionLogic() {
+        return conditionLogic;
+    }
+
+    public void setConditionLogic(String conditionLogic) {
+        this.conditionLogic = conditionLogic;
+    }
+
+    public List<Map<String, Object>> getRulesDefinition() {
+        return rulesDefinition;
+    }
+
+    public void setRulesDefinition(List<Map<String, Object>> rulesDefinition) {
+        this.rulesDefinition = rulesDefinition;
+    }
+
+    public Map<String, Object> getActions() {
+        return actions;
+    }
+
+    public void setActions(Map<String, Object> actions) {
+        this.actions = actions;
+    }
+
+    public String getChangeSummary() {
+        return changeSummary;
+    }
+
+    public void setChangeSummary(String changeSummary) {
+        this.changeSummary = changeSummary;
+    }
+
+    public String getJustification() {
+        return justification;
+    }
+
+    public void setJustification(String justification) {
+        this.justification = justification;
+    }
+
+    public String getExpectedImpact() {
+        return expectedImpact;
+    }
+
+    public void setExpectedImpact(String expectedImpact) {
+        this.expectedImpact = expectedImpact;
+    }
+
+    public Instant getTargetImplementationDate() {
+        return targetImplementationDate;
+    }
+
+    public void setTargetImplementationDate(Instant targetImplementationDate) {
+        this.targetImplementationDate = targetImplementationDate;
+    }
+
+    public String getPriority() {
+        return priority;
+    }
+
+    public void setPriority(String priority) {
+        this.priority = priority;
+    }
+
+    public String getCategory() {
+        return category;
+    }
+
+    public void setCategory(String category) {
+        this.category = category;
+    }
+
+    public List<String> getTags() {
+        return tags;
+    }
+
+    public void setTags(List<String> tags) {
+        this.tags = tags;
+    }
+
+    public List<UUID> getStakeholders() {
+        return stakeholders;
+    }
+
+    public void setStakeholders(List<UUID> stakeholders) {
+        this.stakeholders = stakeholders;
+    }
+
+    public Map<String, Object> getWorkflowMetadata() {
+        return workflowMetadata;
+    }
+
+    public void setWorkflowMetadata(Map<String, Object> workflowMetadata) {
+        this.workflowMetadata = workflowMetadata;
+    }
+} 

src/main/java/com/dalab/policyengine/dto/PolicyDraftOutputDTO.java

@@ -0,0 +1,412 @@
+package com.dalab.policyengine.dto;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * DTO for returning policy draft information including workflow status and audit trail.
+ * Contains comprehensive information for UI display and workflow management.
+ */
+public class PolicyDraftOutputDTO {
+
+    private UUID id;
+    private String name;
+    private String description;
+    private String status;
+    private Integer version;
+    private UUID basePolicyId;
+    private String conditionLogic;
+    private List<Map<String, Object>> rulesDefinition;
+    private Map<String, Object> actions;
+    private String changeSummary;
+    private String justification;
+    private String expectedImpact;
+    private Instant targetImplementationDate;
+    private String priority;
+    private String category;
+    private List<String> tags;
+    private List<UUID> stakeholders;
+    private Map<String, Object> approvalMetadata;
+    private List<Map<String, Object>> reviewComments;
+
+    // Audit trail information
+    private Instant createdAt;
+    private Instant updatedAt;
+    private UUID createdByUserId;
+    private UUID updatedByUserId;
+    private Instant submittedAt;
+    private UUID submittedByUserId;
+    private Instant approvedAt;
+    private UUID approvedByUserId;
+    private Instant rejectedAt;
+    private UUID rejectedByUserId;
+    private Instant publishedAt;
+    private UUID publishedByUserId;
+
+    // Enhanced workflow information
+    private WorkflowStatusDTO workflowStatus;
+    private List<WorkflowActionDTO> availableActions;
+
+    // Constructors
+    public PolicyDraftOutputDTO() {}
+
+    public PolicyDraftOutputDTO(UUID id, String name, String status) {
+        this.id = id;
+        this.name = name;
+        this.status = status;
+    }
+
+    // Getters and Setters
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+
+    public Integer getVersion() {
+        return version;
+    }
+
+    public void setVersion(Integer version) {
+        this.version = version;
+    }
+
+    public UUID getBasePolicyId() {
+        return basePolicyId;
+    }
+
+    public void setBasePolicyId(UUID basePolicyId) {
+        this.basePolicyId = basePolicyId;
+    }
+
+    public String getConditionLogic() {
+        return conditionLogic;
+    }
+
+    public void setConditionLogic(String conditionLogic) {
+        this.conditionLogic = conditionLogic;
+    }
+
+    public List<Map<String, Object>> getRulesDefinition() {
+        return rulesDefinition;
+    }
+
+    public void setRulesDefinition(List<Map<String, Object>> rulesDefinition) {
+        this.rulesDefinition = rulesDefinition;
+    }
+
+    public Map<String, Object> getActions() {
+        return actions;
+    }
+
+    public void setActions(Map<String, Object> actions) {
+        this.actions = actions;
+    }
+
+    public String getChangeSummary() {
+        return changeSummary;
+    }
+
+    public void setChangeSummary(String changeSummary) {
+        this.changeSummary = changeSummary;
+    }
+
+    public String getJustification() {
+        return justification;
+    }
+
+    public void setJustification(String justification) {
+        this.justification = justification;
+    }
+
+    public String getExpectedImpact() {
+        return expectedImpact;
+    }
+
+    public void setExpectedImpact(String expectedImpact) {
+        this.expectedImpact = expectedImpact;
+    }
+
+    public Instant getTargetImplementationDate() {
+        return targetImplementationDate;
+    }
+
+    public void setTargetImplementationDate(Instant targetImplementationDate) {
+        this.targetImplementationDate = targetImplementationDate;
+    }
+
+    public String getPriority() {
+        return priority;
+    }
+
+    public void setPriority(String priority) {
+        this.priority = priority;
+    }
+
+    public String getCategory() {
+        return category;
+    }
+
+    public void setCategory(String category) {
+        this.category = category;
+    }
+
+    public List<String> getTags() {
+        return tags;
+    }
+
+    public void setTags(List<String> tags) {
+        this.tags = tags;
+    }
+
+    public List<UUID> getStakeholders() {
+        return stakeholders;
+    }
+
+    public void setStakeholders(List<UUID> stakeholders) {
+        this.stakeholders = stakeholders;
+    }
+
+    public Map<String, Object> getApprovalMetadata() {
+        return approvalMetadata;
+    }
+
+    public void setApprovalMetadata(Map<String, Object> approvalMetadata) {
+        this.approvalMetadata = approvalMetadata;
+    }
+
+    public List<Map<String, Object>> getReviewComments() {
+        return reviewComments;
+    }
+
+    public void setReviewComments(List<Map<String, Object>> reviewComments) {
+        this.reviewComments = reviewComments;
+    }
+
+    public Instant getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(Instant createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public Instant getUpdatedAt() {
+        return updatedAt;
+    }
+
+    public void setUpdatedAt(Instant updatedAt) {
+        this.updatedAt = updatedAt;
+    }
+
+    public UUID getCreatedByUserId() {
+        return createdByUserId;
+    }
+
+    public void setCreatedByUserId(UUID createdByUserId) {
+        this.createdByUserId = createdByUserId;
+    }
+
+    public UUID getUpdatedByUserId() {
+        return updatedByUserId;
+    }
+
+    public void setUpdatedByUserId(UUID updatedByUserId) {
+        this.updatedByUserId = updatedByUserId;
+    }
+
+    public Instant getSubmittedAt() {
+        return submittedAt;
+    }
+
+    public void setSubmittedAt(Instant submittedAt) {
+        this.submittedAt = submittedAt;
+    }
+
+    public UUID getSubmittedByUserId() {
+        return submittedByUserId;
+    }
+
+    public void setSubmittedByUserId(UUID submittedByUserId) {
+        this.submittedByUserId = submittedByUserId;
+    }
+
+    public Instant getApprovedAt() {
+        return approvedAt;
+    }
+
+    public void setApprovedAt(Instant approvedAt) {
+        this.approvedAt = approvedAt;
+    }
+
+    public UUID getApprovedByUserId() {
+        return approvedByUserId;
+    }
+
+    public void setApprovedByUserId(UUID approvedByUserId) {
+        this.approvedByUserId = approvedByUserId;
+    }
+
+    public Instant getRejectedAt() {
+        return rejectedAt;
+    }
+
+    public void setRejectedAt(Instant rejectedAt) {
+        this.rejectedAt = rejectedAt;
+    }
+
+    public UUID getRejectedByUserId() {
+        return rejectedByUserId;
+    }
+
+    public void setRejectedByUserId(UUID rejectedByUserId) {
+        this.rejectedByUserId = rejectedByUserId;
+    }
+
+    public Instant getPublishedAt() {
+        return publishedAt;
+    }
+
+    public void setPublishedAt(Instant publishedAt) {
+        this.publishedAt = publishedAt;
+    }
+
+    public UUID getPublishedByUserId() {
+        return publishedByUserId;
+    }
+
+    public void setPublishedByUserId(UUID publishedByUserId) {
+        this.publishedByUserId = publishedByUserId;
+    }
+
+    public WorkflowStatusDTO getWorkflowStatus() {
+        return workflowStatus;
+    }
+
+    public void setWorkflowStatus(WorkflowStatusDTO workflowStatus) {
+        this.workflowStatus = workflowStatus;
+    }
+
+    public List<WorkflowActionDTO> getAvailableActions() {
+        return availableActions;
+    }
+
+    public void setAvailableActions(List<WorkflowActionDTO> availableActions) {
+        this.availableActions = availableActions;
+    }
+
+    /**
+     * Nested DTO for workflow status information.
+     */
+    public static class WorkflowStatusDTO {
+        private String currentStage;
+        private String statusDescription;
+        private List<String> nextPossibleStates;
+        private boolean canEdit;
+        private boolean canSubmit;
+        private boolean canApprove;
+        private boolean canReject;
+        private boolean canPublish;
+        private String stageColor; // For UI status indicators
+        private Integer daysInCurrentStatus;
+
+        // Constructors, getters, and setters
+        public WorkflowStatusDTO() {}
+
+        public String getCurrentStage() { return currentStage; }
+        public void setCurrentStage(String currentStage) { this.currentStage = currentStage; }
+
+        public String getStatusDescription() { return statusDescription; }
+        public void setStatusDescription(String statusDescription) { this.statusDescription = statusDescription; }
+
+        public List<String> getNextPossibleStates() { return nextPossibleStates; }
+        public void setNextPossibleStates(List<String> nextPossibleStates) { this.nextPossibleStates = nextPossibleStates; }
+
+        public boolean isCanEdit() { return canEdit; }
+        public void setCanEdit(boolean canEdit) { this.canEdit = canEdit; }
+
+        public boolean isCanSubmit() { return canSubmit; }
+        public void setCanSubmit(boolean canSubmit) { this.canSubmit = canSubmit; }
+
+        public boolean isCanApprove() { return canApprove; }
+        public void setCanApprove(boolean canApprove) { this.canApprove = canApprove; }
+
+        public boolean isCanReject() { return canReject; }
+        public void setCanReject(boolean canReject) { this.canReject = canReject; }
+
+        public boolean isCanPublish() { return canPublish; }
+        public void setCanPublish(boolean canPublish) { this.canPublish = canPublish; }
+
+        public String getStageColor() { return stageColor; }
+        public void setStageColor(String stageColor) { this.stageColor = stageColor; }
+
+        public Integer getDaysInCurrentStatus() { return daysInCurrentStatus; }
+        public void setDaysInCurrentStatus(Integer daysInCurrentStatus) { this.daysInCurrentStatus = daysInCurrentStatus; }
+    }
+
+    /**
+     * Nested DTO for available workflow actions.
+     */
+    public static class WorkflowActionDTO {
+        private String actionType;
+        private String actionLabel;
+        private String actionDescription;
+        private boolean requiresComment;
+        private String confirmationMessage;
+        private String buttonStyle; // For UI styling
+
+        // Constructors, getters, and setters
+        public WorkflowActionDTO() {}
+
+        public WorkflowActionDTO(String actionType, String actionLabel) {
+            this.actionType = actionType;
+            this.actionLabel = actionLabel;
+        }
+
+        public String getActionType() { return actionType; }
+        public void setActionType(String actionType) { this.actionType = actionType; }
+
+        public String getActionLabel() { return actionLabel; }
+        public void setActionLabel(String actionLabel) { this.actionLabel = actionLabel; }
+
+        public String getActionDescription() { return actionDescription; }
+        public void setActionDescription(String actionDescription) { this.actionDescription = actionDescription; }
+
+        public boolean isRequiresComment() { return requiresComment; }
+        public void setRequiresComment(boolean requiresComment) { this.requiresComment = requiresComment; }
+
+        public String getConfirmationMessage() { return confirmationMessage; }
+        public void setConfirmationMessage(String confirmationMessage) { this.confirmationMessage = confirmationMessage; }
+
+        public String getButtonStyle() { return buttonStyle; }
+        public void setButtonStyle(String buttonStyle) { this.buttonStyle = buttonStyle; }
+    }
+} 

src/main/java/com/dalab/policyengine/dto/PolicyEvaluationOutputDTO.java

@@ -0,0 +1,92 @@
+package com.dalab.policyengine.dto;
+
+import java.time.Instant;
+import java.util.Map;
+import java.util.UUID;
+
+import com.dalab.policyengine.model.PolicyEvaluationStatus;
+
+public class PolicyEvaluationOutputDTO {
+    private UUID id;
+    private UUID policyId;
+    private String policyName; // For convenience
+    private String targetAssetId;
+    private PolicyEvaluationStatus status;
+    private Map<String, Object> evaluationDetails; // e.g., facts used, rules evaluated, outcome per rule
+    private Map<String, Object> triggeredActions; // Actions taken based on the policy
+    private Instant evaluatedAt;
+    private UUID evaluationTriggeredByUserId;
+
+    // Getters and Setters
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public UUID getPolicyId() {
+        return policyId;
+    }
+
+    public void setPolicyId(UUID policyId) {
+        this.policyId = policyId;
+    }
+
+    public String getPolicyName() {
+        return policyName;
+    }
+
+    public void setPolicyName(String policyName) {
+        this.policyName = policyName;
+    }
+
+    public String getTargetAssetId() {
+        return targetAssetId;
+    }
+
+    public void setTargetAssetId(String targetAssetId) {
+        this.targetAssetId = targetAssetId;
+    }
+
+    public PolicyEvaluationStatus getStatus() {
+        return status;
+    }
+
+    public void setStatus(PolicyEvaluationStatus status) {
+        this.status = status;
+    }
+
+    public Map<String, Object> getEvaluationDetails() {
+        return evaluationDetails;
+    }
+
+    public void setEvaluationDetails(Map<String, Object> evaluationDetails) {
+        this.evaluationDetails = evaluationDetails;
+    }
+
+    public Map<String, Object> getTriggeredActions() {
+        return triggeredActions;
+    }
+
+    public void setTriggeredActions(Map<String, Object> triggeredActions) {
+        this.triggeredActions = triggeredActions;
+    }
+
+    public Instant getEvaluatedAt() {
+        return evaluatedAt;
+    }
+
+    public void setEvaluatedAt(Instant evaluatedAt) {
+        this.evaluatedAt = evaluatedAt;
+    }
+
+    public UUID getEvaluationTriggeredByUserId() {
+        return evaluationTriggeredByUserId;
+    }
+
+    public void setEvaluationTriggeredByUserId(UUID evaluationTriggeredByUserId) {
+        this.evaluationTriggeredByUserId = evaluationTriggeredByUserId;
+    }
+} 

src/main/java/com/dalab/policyengine/dto/PolicyEvaluationRequestDTO.java

@@ -0,0 +1,32 @@
+package com.dalab.policyengine.dto;
+
+import java.util.Map;
+
+import jakarta.validation.constraints.NotBlank;
+
+public class PolicyEvaluationRequestDTO {
+
+    @NotBlank
+    private String targetAssetId; // The ID of the asset to be evaluated (e.g., from da-catalog)
+
+    // Optional: Additional context or facts that might not be directly part of the asset
+    // but are relevant for this specific evaluation.
+    private Map<String, Object> evaluationContext;
+
+    // Getters and Setters
+    public String getTargetAssetId() {
+        return targetAssetId;
+    }
+
+    public void setTargetAssetId(String targetAssetId) {
+        this.targetAssetId = targetAssetId;
+    }
+
+    public Map<String, Object> getEvaluationContext() {
+        return evaluationContext;
+    }
+
+    public void setEvaluationContext(Map<String, Object> evaluationContext) {
+        this.evaluationContext = evaluationContext;
+    }
+} 

src/main/java/com/dalab/policyengine/dto/PolicyEvaluationSummaryDTO.java

@@ -0,0 +1,64 @@
+package com.dalab.policyengine.dto;
+
+import java.time.Instant;
+import java.util.UUID;
+
+import com.dalab.policyengine.model.PolicyEvaluationStatus;
+
+public class PolicyEvaluationSummaryDTO {
+    private UUID id;
+    private UUID policyId;
+    private String policyName;
+    private String targetAssetId;
+    private PolicyEvaluationStatus status;
+    private Instant evaluatedAt;
+
+    // Getters and Setters
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public UUID getPolicyId() {
+        return policyId;
+    }
+
+    public void setPolicyId(UUID policyId) {
+        this.policyId = policyId;
+    }
+
+    public String getPolicyName() {
+        return policyName;
+    }
+
+    public void setPolicyName(String policyName) {
+        this.policyName = policyName;
+    }
+
+    public String getTargetAssetId() {
+        return targetAssetId;
+    }
+
+    public void setTargetAssetId(String targetAssetId) {
+        this.targetAssetId = targetAssetId;
+    }
+
+    public PolicyEvaluationStatus getStatus() {
+        return status;
+    }
+
+    public void setStatus(PolicyEvaluationStatus status) {
+        this.status = status;
+    }
+
+    public Instant getEvaluatedAt() {
+        return evaluatedAt;
+    }
+
+    public void setEvaluatedAt(Instant evaluatedAt) {
+        this.evaluatedAt = evaluatedAt;
+    }
+} 

src/main/java/com/dalab/policyengine/dto/PolicyImpactRequestDTO.java

@@ -0,0 +1,211 @@
+package com.dalab.policyengine.dto;
+
+import java.util.List;
+import java.util.Map;
+
+import jakarta.validation.constraints.NotBlank;
+
+/**
+ * DTO for requesting policy impact analysis preview.
+ * This allows users to see what assets would be affected by policy changes before implementation.
+ */
+public class PolicyImpactRequestDTO {
+
+    /**
+     * The policy rules content to analyze for impact (JSON format).
+     * Required field containing the policy rules that need impact analysis.
+     */
+    @NotBlank(message = "Policy rules content is required")
+    private String rulesContent;
+
+    /**
+     * Type of analysis to perform: FULL, QUICK, or TARGETED.
+     * - FULL: Comprehensive analysis across all assets
+     * - QUICK: Fast analysis with sampling
+     * - TARGETED: Analysis for specific asset types/groups
+     */
+    @NotBlank(message = "Analysis type is required")
+    private String analysisType;
+
+    /**
+     * Optional scope limitations for targeted analysis.
+     * Can include asset types, data sources, or specific asset IDs.
+     */
+    private PolicyImpactScopeDTO scope;
+
+    /**
+     * Include estimated performance impact in the analysis.
+     * When true, includes estimates for processing time and resource usage.
+     */
+    private Boolean includePerformanceEstimate = false;
+
+    /**
+     * Include cost impact analysis in the preview.
+     * When true, estimates potential costs of policy enforcement.
+     */
+    private Boolean includeCostImpact = false;
+
+    /**
+     * Include compliance impact analysis.
+     * When true, shows how this policy affects compliance with other policies.
+     */
+    private Boolean includeComplianceImpact = false;
+
+    /**
+     * Additional context parameters for policy evaluation.
+     * Flexible map for custom analysis parameters.
+     */
+    private Map<String, Object> contextParameters;
+
+    // Constructors
+    public PolicyImpactRequestDTO() {}
+
+    public PolicyImpactRequestDTO(String rulesContent, String analysisType) {
+        this.rulesContent = rulesContent;
+        this.analysisType = analysisType;
+    }
+
+    // Getters and Setters
+    public String getRulesContent() {
+        return rulesContent;
+    }
+
+    public void setRulesContent(String rulesContent) {
+        this.rulesContent = rulesContent;
+    }
+
+    public String getAnalysisType() {
+        return analysisType;
+    }
+
+    public void setAnalysisType(String analysisType) {
+        this.analysisType = analysisType;
+    }
+
+    public PolicyImpactScopeDTO getScope() {
+        return scope;
+    }
+
+    public void setScope(PolicyImpactScopeDTO scope) {
+        this.scope = scope;
+    }
+
+    public Boolean getIncludePerformanceEstimate() {
+        return includePerformanceEstimate;
+    }
+
+    public void setIncludePerformanceEstimate(Boolean includePerformanceEstimate) {
+        this.includePerformanceEstimate = includePerformanceEstimate;
+    }
+
+    public Boolean getIncludeCostImpact() {
+        return includeCostImpact;
+    }
+
+    public void setIncludeCostImpact(Boolean includeCostImpact) {
+        this.includeCostImpact = includeCostImpact;
+    }
+
+    public Boolean getIncludeComplianceImpact() {
+        return includeComplianceImpact;
+    }
+
+    public void setIncludeComplianceImpact(Boolean includeComplianceImpact) {
+        this.includeComplianceImpact = includeComplianceImpact;
+    }
+
+    public Map<String, Object> getContextParameters() {
+        return contextParameters;
+    }
+
+    public void setContextParameters(Map<String, Object> contextParameters) {
+        this.contextParameters = contextParameters;
+    }
+
+    /**
+     * Nested DTO for defining analysis scope limitations.
+     */
+    public static class PolicyImpactScopeDTO {
+        /**
+         * Specific asset types to include in analysis (e.g., "database", "file", "api").
+         */
+        private List<String> assetTypes;
+
+        /**
+         * Specific data sources to include (e.g., connection IDs or source names).
+         */
+        private List<String> dataSources;
+
+        /**
+         * Specific asset IDs to analyze (for targeted analysis).
+         */
+        private List<String> assetIds;
+
+        /**
+         * Include only assets with specific labels.
+         */
+        private List<String> requiredLabels;
+
+        /**
+         * Exclude assets with specific labels.
+         */
+        private List<String> excludedLabels;
+
+        /**
+         * Maximum number of assets to analyze (for performance control).
+         */
+        private Integer maxAssets;
+
+        // Constructors
+        public PolicyImpactScopeDTO() {}
+
+        // Getters and Setters
+        public List<String> getAssetTypes() {
+            return assetTypes;
+        }
+
+        public void setAssetTypes(List<String> assetTypes) {
+            this.assetTypes = assetTypes;
+        }
+
+        public List<String> getDataSources() {
+            return dataSources;
+        }
+
+        public void setDataSources(List<String> dataSources) {
+            this.dataSources = dataSources;
+        }
+
+        public List<String> getAssetIds() {
+            return assetIds;
+        }
+
+        public void setAssetIds(List<String> assetIds) {
+            this.assetIds = assetIds;
+        }
+
+        public List<String> getRequiredLabels() {
+            return requiredLabels;
+        }
+
+        public void setRequiredLabels(List<String> requiredLabels) {
+            this.requiredLabels = requiredLabels;
+        }
+
+        public List<String> getExcludedLabels() {
+            return excludedLabels;
+        }
+
+        public void setExcludedLabels(List<String> excludedLabels) {
+            this.excludedLabels = excludedLabels;
+        }
+
+        public Integer getMaxAssets() {
+            return maxAssets;
+        }
+
+        public void setMaxAssets(Integer maxAssets) {
+            this.maxAssets = maxAssets;
+        }
+    }
+} 

src/main/java/com/dalab/policyengine/dto/PolicyImpactResponseDTO.java

@@ -0,0 +1,376 @@
+package com.dalab.policyengine.dto;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Comprehensive DTO for policy impact analysis response.
+ * Contains detailed analysis of what assets would be affected by policy changes.
+ */
+public class PolicyImpactResponseDTO {
+
+    /**
+     * Unique identifier for this impact analysis.
+     */
+    private String analysisId;
+
+    /**
+     * Timestamp when the analysis was performed.
+     */
+    private Instant analyzedAt;
+
+    /**
+     * Type of analysis performed: FULL, QUICK, or TARGETED.
+     */
+    private String analysisType;
+
+    /**
+     * Overall impact summary with key metrics.
+     */
+    private ImpactSummaryDTO summary;
+
+    /**
+     * Detailed breakdown of affected assets by category.
+     */
+    private List<AssetImpactDTO> affectedAssets;
+
+    /**
+     * Performance impact estimates (if requested).
+     */
+    private PerformanceImpactDTO performanceImpact;
+
+    /**
+     * Cost impact analysis (if requested).
+     */
+    private CostImpactDTO costImpact;
+
+    /**
+     * Compliance impact analysis (if requested).
+     */
+    private ComplianceImpactDTO complianceImpact;
+
+    /**
+     * Risk assessment for implementing this policy.
+     */
+    private RiskAssessmentDTO riskAssessment;
+
+    /**
+     * Recommendations for policy implementation.
+     */
+    private List<String> recommendations;
+
+    /**
+     * Analysis execution metadata.
+     */
+    private AnalysisMetadataDTO metadata;
+
+    // Constructors
+    public PolicyImpactResponseDTO() {}
+
+    public PolicyImpactResponseDTO(String analysisId, String analysisType) {
+        this.analysisId = analysisId;
+        this.analysisType = analysisType;
+        this.analyzedAt = Instant.now();
+    }
+
+    // Getters and Setters
+    public String getAnalysisId() {
+        return analysisId;
+    }
+
+    public void setAnalysisId(String analysisId) {
+        this.analysisId = analysisId;
+    }
+
+    public Instant getAnalyzedAt() {
+        return analyzedAt;
+    }
+
+    public void setAnalyzedAt(Instant analyzedAt) {
+        this.analyzedAt = analyzedAt;
+    }
+
+    public String getAnalysisType() {
+        return analysisType;
+    }
+
+    public void setAnalysisType(String analysisType) {
+        this.analysisType = analysisType;
+    }
+
+    public ImpactSummaryDTO getSummary() {
+        return summary;
+    }
+
+    public void setSummary(ImpactSummaryDTO summary) {
+        this.summary = summary;
+    }
+
+    public List<AssetImpactDTO> getAffectedAssets() {
+        return affectedAssets;
+    }
+
+    public void setAffectedAssets(List<AssetImpactDTO> affectedAssets) {
+        this.affectedAssets = affectedAssets;
+    }
+
+    public PerformanceImpactDTO getPerformanceImpact() {
+        return performanceImpact;
+    }
+
+    public void setPerformanceImpact(PerformanceImpactDTO performanceImpact) {
+        this.performanceImpact = performanceImpact;
+    }
+
+    public CostImpactDTO getCostImpact() {
+        return costImpact;
+    }
+
+    public void setCostImpact(CostImpactDTO costImpact) {
+        this.costImpact = costImpact;
+    }
+
+    public ComplianceImpactDTO getComplianceImpact() {
+        return complianceImpact;
+    }
+
+    public void setComplianceImpact(ComplianceImpactDTO complianceImpact) {
+        this.complianceImpact = complianceImpact;
+    }
+
+    public RiskAssessmentDTO getRiskAssessment() {
+        return riskAssessment;
+    }
+
+    public void setRiskAssessment(RiskAssessmentDTO riskAssessment) {
+        this.riskAssessment = riskAssessment;
+    }
+
+    public List<String> getRecommendations() {
+        return recommendations;
+    }
+
+    public void setRecommendations(List<String> recommendations) {
+        this.recommendations = recommendations;
+    }
+
+    public AnalysisMetadataDTO getMetadata() {
+        return metadata;
+    }
+
+    public void setMetadata(AnalysisMetadataDTO metadata) {
+        this.metadata = metadata;
+    }
+
+    /**
+     * Overall impact summary with key metrics.
+     */
+    public static class ImpactSummaryDTO {
+        private Integer totalAssetsAnalyzed;
+        private Integer totalAssetsAffected;
+        private Integer highImpactAssets;
+        private Integer mediumImpactAssets;
+        private Integer lowImpactAssets;
+        private String overallRiskLevel; // LOW, MEDIUM, HIGH, CRITICAL
+        private Double impactPercentage;
+
+        // Constructors, getters, and setters
+        public ImpactSummaryDTO() {}
+
+        public Integer getTotalAssetsAnalyzed() { return totalAssetsAnalyzed; }
+        public void setTotalAssetsAnalyzed(Integer totalAssetsAnalyzed) { this.totalAssetsAnalyzed = totalAssetsAnalyzed; }
+
+        public Integer getTotalAssetsAffected() { return totalAssetsAffected; }
+        public void setTotalAssetsAffected(Integer totalAssetsAffected) { this.totalAssetsAffected = totalAssetsAffected; }
+
+        public Integer getHighImpactAssets() { return highImpactAssets; }
+        public void setHighImpactAssets(Integer highImpactAssets) { this.highImpactAssets = highImpactAssets; }
+
+        public Integer getMediumImpactAssets() { return mediumImpactAssets; }
+        public void setMediumImpactAssets(Integer mediumImpactAssets) { this.mediumImpactAssets = mediumImpactAssets; }
+
+        public Integer getLowImpactAssets() { return lowImpactAssets; }
+        public void setLowImpactAssets(Integer lowImpactAssets) { this.lowImpactAssets = lowImpactAssets; }
+
+        public String getOverallRiskLevel() { return overallRiskLevel; }
+        public void setOverallRiskLevel(String overallRiskLevel) { this.overallRiskLevel = overallRiskLevel; }
+
+        public Double getImpactPercentage() { return impactPercentage; }
+        public void setImpactPercentage(Double impactPercentage) { this.impactPercentage = impactPercentage; }
+    }
+
+    /**
+     * Individual asset impact details.
+     */
+    public static class AssetImpactDTO {
+        private String assetId;
+        private String assetName;
+        private String assetType;
+        private String impactLevel; // HIGH, MEDIUM, LOW
+        private List<String> affectedAttributes;
+        private List<String> appliedActions;
+        private String riskAssessment;
+        private Map<String, Object> impactDetails;
+
+        // Constructors, getters, and setters
+        public AssetImpactDTO() {}
+
+        public String getAssetId() { return assetId; }
+        public void setAssetId(String assetId) { this.assetId = assetId; }
+
+        public String getAssetName() { return assetName; }
+        public void setAssetName(String assetName) { this.assetName = assetName; }
+
+        public String getAssetType() { return assetType; }
+        public void setAssetType(String assetType) { this.assetType = assetType; }
+
+        public String getImpactLevel() { return impactLevel; }
+        public void setImpactLevel(String impactLevel) { this.impactLevel = impactLevel; }
+
+        public List<String> getAffectedAttributes() { return affectedAttributes; }
+        public void setAffectedAttributes(List<String> affectedAttributes) { this.affectedAttributes = affectedAttributes; }
+
+        public List<String> getAppliedActions() { return appliedActions; }
+        public void setAppliedActions(List<String> appliedActions) { this.appliedActions = appliedActions; }
+
+        public String getRiskAssessment() { return riskAssessment; }
+        public void setRiskAssessment(String riskAssessment) { this.riskAssessment = riskAssessment; }
+
+        public Map<String, Object> getImpactDetails() { return impactDetails; }
+        public void setImpactDetails(Map<String, Object> impactDetails) { this.impactDetails = impactDetails; }
+    }
+
+    /**
+     * Performance impact estimates.
+     */
+    public static class PerformanceImpactDTO {
+        private Long estimatedProcessingTimeMs;
+        private Double cpuUtilizationIncrease;
+        private Double memoryUtilizationIncrease;
+        private Integer estimatedApiCalls;
+        private String performanceRiskLevel;
+
+        // Constructors, getters, and setters
+        public PerformanceImpactDTO() {}
+
+        public Long getEstimatedProcessingTimeMs() { return estimatedProcessingTimeMs; }
+        public void setEstimatedProcessingTimeMs(Long estimatedProcessingTimeMs) { this.estimatedProcessingTimeMs = estimatedProcessingTimeMs; }
+
+        public Double getCpuUtilizationIncrease() { return cpuUtilizationIncrease; }
+        public void setCpuUtilizationIncrease(Double cpuUtilizationIncrease) { this.cpuUtilizationIncrease = cpuUtilizationIncrease; }
+
+        public Double getMemoryUtilizationIncrease() { return memoryUtilizationIncrease; }
+        public void setMemoryUtilizationIncrease(Double memoryUtilizationIncrease) { this.memoryUtilizationIncrease = memoryUtilizationIncrease; }
+
+        public Integer getEstimatedApiCalls() { return estimatedApiCalls; }
+        public void setEstimatedApiCalls(Integer estimatedApiCalls) { this.estimatedApiCalls = estimatedApiCalls; }
+
+        public String getPerformanceRiskLevel() { return performanceRiskLevel; }
+        public void setPerformanceRiskLevel(String performanceRiskLevel) { this.performanceRiskLevel = performanceRiskLevel; }
+    }
+
+    /**
+     * Cost impact analysis.
+     */
+    public static class CostImpactDTO {
+        private Double estimatedMonthlyCost;
+        private Double estimatedImplementationCost;
+        private Double potentialSavings;
+        private String costRiskLevel;
+        private Map<String, Double> costBreakdown;
+
+        // Constructors, getters, and setters
+        public CostImpactDTO() {}
+
+        public Double getEstimatedMonthlyCost() { return estimatedMonthlyCost; }
+        public void setEstimatedMonthlyCost(Double estimatedMonthlyCost) { this.estimatedMonthlyCost = estimatedMonthlyCost; }
+
+        public Double getEstimatedImplementationCost() { return estimatedImplementationCost; }
+        public void setEstimatedImplementationCost(Double estimatedImplementationCost) { this.estimatedImplementationCost = estimatedImplementationCost; }
+
+        public Double getPotentialSavings() { return potentialSavings; }
+        public void setPotentialSavings(Double potentialSavings) { this.potentialSavings = potentialSavings; }
+
+        public String getCostRiskLevel() { return costRiskLevel; }
+        public void setCostRiskLevel(String costRiskLevel) { this.costRiskLevel = costRiskLevel; }
+
+        public Map<String, Double> getCostBreakdown() { return costBreakdown; }
+        public void setCostBreakdown(Map<String, Double> costBreakdown) { this.costBreakdown = costBreakdown; }
+    }
+
+    /**
+     * Compliance impact analysis.
+     */
+    public static class ComplianceImpactDTO {
+        private Integer conflictingPolicies;
+        private List<String> complianceFrameworksAffected;
+        private String complianceRiskLevel;
+        private List<String> potentialViolations;
+
+        // Constructors, getters, and setters
+        public ComplianceImpactDTO() {}
+
+        public Integer getConflictingPolicies() { return conflictingPolicies; }
+        public void setConflictingPolicies(Integer conflictingPolicies) { this.conflictingPolicies = conflictingPolicies; }
+
+        public List<String> getComplianceFrameworksAffected() { return complianceFrameworksAffected; }
+        public void setComplianceFrameworksAffected(List<String> complianceFrameworksAffected) { this.complianceFrameworksAffected = complianceFrameworksAffected; }
+
+        public String getComplianceRiskLevel() { return complianceRiskLevel; }
+        public void setComplianceRiskLevel(String complianceRiskLevel) { this.complianceRiskLevel = complianceRiskLevel; }
+
+        public List<String> getPotentialViolations() { return potentialViolations; }
+        public void setPotentialViolations(List<String> potentialViolations) { this.potentialViolations = potentialViolations; }
+    }
+
+    /**
+     * Risk assessment for policy implementation.
+     */
+    public static class RiskAssessmentDTO {
+        private String overallRiskLevel;
+        private List<String> identifiedRisks;
+        private List<String> mitigationStrategies;
+        private Double riskScore;
+
+        // Constructors, getters, and setters
+        public RiskAssessmentDTO() {}
+
+        public String getOverallRiskLevel() { return overallRiskLevel; }
+        public void setOverallRiskLevel(String overallRiskLevel) { this.overallRiskLevel = overallRiskLevel; }
+
+        public List<String> getIdentifiedRisks() { return identifiedRisks; }
+        public void setIdentifiedRisks(List<String> identifiedRisks) { this.identifiedRisks = identifiedRisks; }
+
+        public List<String> getMitigationStrategies() { return mitigationStrategies; }
+        public void setMitigationStrategies(List<String> mitigationStrategies) { this.mitigationStrategies = mitigationStrategies; }
+
+        public Double getRiskScore() { return riskScore; }
+        public void setRiskScore(Double riskScore) { this.riskScore = riskScore; }
+    }
+
+    /**
+     * Analysis execution metadata.
+     */
+    public static class AnalysisMetadataDTO {
+        private Long executionTimeMs;
+        private String analysisVersion;
+        private Boolean usesCachedData;
+        private Instant dataFreshnessTimestamp;
+
+        // Constructors, getters, and setters
+        public AnalysisMetadataDTO() {}
+
+        public Long getExecutionTimeMs() { return executionTimeMs; }
+        public void setExecutionTimeMs(Long executionTimeMs) { this.executionTimeMs = executionTimeMs; }
+
+        public String getAnalysisVersion() { return analysisVersion; }
+        public void setAnalysisVersion(String analysisVersion) { this.analysisVersion = analysisVersion; }
+
+        public Boolean getUsesCachedData() { return usesCachedData; }
+        public void setUsesCachedData(Boolean usesCachedData) { this.usesCachedData = usesCachedData; }
+
+        public Instant getDataFreshnessTimestamp() { return dataFreshnessTimestamp; }
+        public void setDataFreshnessTimestamp(Instant dataFreshnessTimestamp) { this.dataFreshnessTimestamp = dataFreshnessTimestamp; }
+    }
+} 

src/main/java/com/dalab/policyengine/dto/PolicyInputDTO.java

@@ -0,0 +1,80 @@
+package com.dalab.policyengine.dto;
+
+import java.util.List;
+import java.util.Map;
+
+import com.dalab.policyengine.model.PolicyStatus;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.Size;
+
+public class PolicyInputDTO {
+
+    @NotBlank
+    @Size(max = 255)
+    private String name;
+
+    @Size(max = 1000)
+    private String description;
+
+    private PolicyStatus status = PolicyStatus.DISABLED;
+
+    private String conditionLogic; // e.g., "rule1 && (rule2 || rule3)"
+
+    @NotEmpty
+    @Valid
+    private List<PolicyRuleDTO> rules;
+
+    private Map<String, Object> actions; // Policy-level actions
+
+    // Getters and Setters
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public PolicyStatus getStatus() {
+        return status;
+    }
+
+    public void setStatus(PolicyStatus status) {
+        this.status = status;
+    }
+
+    public String getConditionLogic() {
+        return conditionLogic;
+    }
+
+    public void setConditionLogic(String conditionLogic) {
+        this.conditionLogic = conditionLogic;
+    }
+
+    public List<PolicyRuleDTO> getRules() {
+        return rules;
+    }
+
+    public void setRules(List<PolicyRuleDTO> rules) {
+        this.rules = rules;
+    }
+
+    public Map<String, Object> getActions() {
+        return actions;
+    }
+
+    public void setActions(Map<String, Object> actions) {
+        this.actions = actions;
+    }
+} 

src/main/java/com/dalab/policyengine/dto/PolicyOutputDTO.java

@@ -0,0 +1,111 @@
+package com.dalab.policyengine.dto;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import com.dalab.policyengine.model.PolicyStatus;
+
+public class PolicyOutputDTO {
+    private UUID id;
+    private String name;
+    private String description;
+    private PolicyStatus status;
+    private String conditionLogic;
+    private List<PolicyRuleDTO> rules;
+    private Map<String, Object> actions;
+    private Instant createdAt;
+    private Instant updatedAt;
+    private UUID createdByUserId;
+    private UUID updatedByUserId;
+
+    // Getters and Setters
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public PolicyStatus getStatus() {
+        return status;
+    }
+
+    public void setStatus(PolicyStatus status) {
+        this.status = status;
+    }
+
+    public String getConditionLogic() {
+        return conditionLogic;
+    }
+
+    public void setConditionLogic(String conditionLogic) {
+        this.conditionLogic = conditionLogic;
+    }
+
+    public List<PolicyRuleDTO> getRules() {
+        return rules;
+    }
+
+    public void setRules(List<PolicyRuleDTO> rules) {
+        this.rules = rules;
+    }
+
+    public Map<String, Object> getActions() {
+        return actions;
+    }
+
+    public void setActions(Map<String, Object> actions) {
+        this.actions = actions;
+    }
+
+    public Instant getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(Instant createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public Instant getUpdatedAt() {
+        return updatedAt;
+    }
+
+    public void setUpdatedAt(Instant updatedAt) {
+        this.updatedAt = updatedAt;
+    }
+
+    public UUID getCreatedByUserId() {
+        return createdByUserId;
+    }
+
+    public void setCreatedByUserId(UUID createdByUserId) {
+        this.createdByUserId = createdByUserId;
+    }
+
+    public UUID getUpdatedByUserId() {
+        return updatedByUserId;
+    }
+
+    public void setUpdatedByUserId(UUID updatedByUserId) {
+        this.updatedByUserId = updatedByUserId;
+    }
+} 

src/main/java/com/dalab/policyengine/dto/PolicyRuleDTO.java

@@ -0,0 +1,72 @@
+package com.dalab.policyengine.dto;
+
+import java.util.Map;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
+public class PolicyRuleDTO {
+    private String id; // UUID as String, can be null for new rules in create/update
+
+    @NotBlank
+    @Size(max = 255)
+    private String name;
+
+    @Size(max = 1000)
+    private String description;
+
+    @NotBlank
+    private String condition; // MVEL expression
+
+    private int priority = 1;
+    private Map<String, Object> actions; // Optional rule-specific actions
+
+    // Getters and Setters
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public String getCondition() {
+        return condition;
+    }
+
+    public void setCondition(String condition) {
+        this.condition = condition;
+    }
+
+    public int getPriority() {
+        return priority;
+    }
+
+    public void setPriority(int priority) {
+        this.priority = priority;
+    }
+
+    public Map<String, Object> getActions() {
+        return actions;
+    }
+
+    public void setActions(Map<String, Object> actions) {
+        this.actions = actions;
+    }
+}

src/main/java/com/dalab/policyengine/dto/PolicySummaryDTO.java

@@ -0,0 +1,73 @@
+package com.dalab.policyengine.dto;
+
+import java.time.Instant;
+import java.util.UUID;
+
+import com.dalab.policyengine.model.PolicyStatus;
+
+public class PolicySummaryDTO {
+    private UUID id;
+    private String name;
+    private String description;
+    private PolicyStatus status;
+    private int ruleCount;
+    private Instant createdAt;
+    private Instant updatedAt;
+
+    // Getters and Setters
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public PolicyStatus getStatus() {
+        return status;
+    }
+
+    public void setStatus(PolicyStatus status) {
+        this.status = status;
+    }
+
+    public int getRuleCount() {
+        return ruleCount;
+    }
+
+    public void setRuleCount(int ruleCount) {
+        this.ruleCount = ruleCount;
+    }
+
+    public Instant getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(Instant createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public Instant getUpdatedAt() {
+        return updatedAt;
+    }
+
+    public void setUpdatedAt(Instant updatedAt) {
+        this.updatedAt = updatedAt;
+    }
+} 

src/main/java/com/dalab/policyengine/event/PolicyActionEvent.java

@@ -0,0 +1,102 @@
+package com.dalab.policyengine.event;
+
+import java.time.Instant;
+import java.util.Map;
+import java.util.UUID;
+
+// This DTO represents an action triggered by a policy evaluation,
+// to be published to a Kafka topic.
+public class PolicyActionEvent {
+    private UUID eventId;
+    private String policyId;
+    private String policyName;
+    private String targetAssetId;
+    private String actionType; // e.g., "ADD_LABEL", "NOTIFY_EMAIL", "ARCHIVE_ASSET"
+    private Map<String, Object> actionParameters; // Parameters for the action, e.g., {"labelName": "PII", "confidence": 0.9} or {"to": "user@example.com", "subject": "Alert"}
+    private Instant timestamp;
+    private UUID triggeredByEvaluationId; // Link back to the PolicyEvaluation record
+
+    public PolicyActionEvent() {
+        this.eventId = UUID.randomUUID();
+        this.timestamp = Instant.now();
+    }
+
+    // Getters and Setters
+    public UUID getEventId() {
+        return eventId;
+    }
+
+    public void setEventId(UUID eventId) {
+        this.eventId = eventId;
+    }
+
+    public String getPolicyId() {
+        return policyId;
+    }
+
+    public void setPolicyId(String policyId) {
+        this.policyId = policyId;
+    }
+
+    public String getPolicyName() {
+        return policyName;
+    }
+
+    public void setPolicyName(String policyName) {
+        this.policyName = policyName;
+    }
+
+    public String getTargetAssetId() {
+        return targetAssetId;
+    }
+
+    public void setTargetAssetId(String targetAssetId) {
+        this.targetAssetId = targetAssetId;
+    }
+
+    public String getActionType() {
+        return actionType;
+    }
+
+    public void setActionType(String actionType) {
+        this.actionType = actionType;
+    }
+
+    public Map<String, Object> getActionParameters() {
+        return actionParameters;
+    }
+
+    public void setActionParameters(Map<String, Object> actionParameters) {
+        this.actionParameters = actionParameters;
+    }
+
+    public Instant getTimestamp() {
+        return timestamp;
+    }
+
+    public void setTimestamp(Instant timestamp) {
+        this.timestamp = timestamp;
+    }
+
+    public UUID getTriggeredByEvaluationId() {
+        return triggeredByEvaluationId;
+    }
+
+    public void setTriggeredByEvaluationId(UUID triggeredByEvaluationId) {
+        this.triggeredByEvaluationId = triggeredByEvaluationId;
+    }
+
+    @Override
+    public String toString() {
+        return "PolicyActionEvent{" +
+                "eventId=" + eventId +
+                ", policyId='" + policyId + '\'' +
+                ", policyName='" + policyName + '\'' +
+                ", targetAssetId='" + targetAssetId + '\'' +
+                ", actionType='" + actionType + '\'' +
+                ", actionParameters=" + actionParameters +
+                ", timestamp=" + timestamp +
+                ", triggeredByEvaluationId=" + triggeredByEvaluationId +
+                '}';
+    }
+} 

src/main/java/com/dalab/policyengine/kafka/consumer/AssetChangeConsumer.java

@@ -0,0 +1,50 @@
+package com.dalab.policyengine.kafka.consumer;
+
+import java.util.UUID;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.messaging.handler.annotation.Payload;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+// Import the common AssetChangeEvent from da-protos
+import com.dalab.common.event.AssetChangeEvent;
+import com.dalab.policyengine.service.IPolicyEvaluationService;
+
+@Component
+public class AssetChangeConsumer {
+
+    private static final Logger log = LoggerFactory.getLogger(AssetChangeConsumer.class);
+    // System UUID for actions triggered by Kafka consumer events
+    private static final UUID KAFKA_CONSUMER_USER_ID = UUID.fromString("00000000-0000-0000-0000-000000000001"); 
+
+    private final IPolicyEvaluationService policyEvaluationService;
+
+    @Autowired
+    public AssetChangeConsumer(IPolicyEvaluationService policyEvaluationService) {
+        this.policyEvaluationService = policyEvaluationService;
+    }
+
+    // Update KafkaListener to consume the common AssetChangeEvent
+    @KafkaListener(topics = "${app.kafka.topic.asset-change-event:asset-change-events}", groupId = "${spring.kafka.consumer.group-id}")
+    public void handleAssetChangeEvent(@Payload AssetChangeEvent event) {
+        log.info("Received AssetChangeEvent: AssetId={}, EventType={}", event.getAssetId(), event.getEventType());
+
+        try {
+            if (event == null || event.getAssetId() == null || !StringUtils.hasText(event.getAssetId())) {
+                log.error("AssetChangeEvent is null or missing assetId. Skipping.");
+                return;
+            }
+            // The PolicyEvaluationService will now fetch active policies and iterate.
+            policyEvaluationService.evaluatePolicyForAssetInternal(event, KAFKA_CONSUMER_USER_ID);
+
+        } catch (Exception e) {
+            log.error("Failed to process AssetChangeEvent for assetId {}: {}. Error: {}", 
+                event != null && event.getAssetId() != null ? event.getAssetId() : "unknown", 
+                e.getMessage(), e);
+        }
+    }
+} 

src/main/java/com/dalab/policyengine/kafka/consumer/AssetChangeEventListener.java

@@ -0,0 +1,61 @@
+package com.dalab.policyengine.kafka.consumer;
+
+import java.util.UUID;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.kafka.support.KafkaHeaders;
+import org.springframework.messaging.handler.annotation.Header;
+import org.springframework.messaging.handler.annotation.Payload;
+import org.springframework.stereotype.Component;
+
+import com.dalab.common.event.AssetChangeEvent;
+import com.dalab.policyengine.service.IPolicyEvaluationService;
+
+@Component
+public class AssetChangeEventListener {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(AssetChangeEventListener.class);
+
+    private final IPolicyEvaluationService policyEvaluationService;
+
+    public AssetChangeEventListener(IPolicyEvaluationService policyEvaluationService) {
+        this.policyEvaluationService = policyEvaluationService;
+    }
+
+    @KafkaListener(
+            topics = "#{'${app.kafka.topic.asset-change-event}'}",
+            groupId = "#{'${spring.kafka.consumer.group-id}'}"
+            // containerFactory = "assetChangeKafkaListenerContainerFactory" // If using custom factory
+    )
+    public void handleAssetChangeEvent(
+            @Payload AssetChangeEvent event,
+            @Header(KafkaHeaders.RECEIVED_TOPIC) String topic,
+            @Header(KafkaHeaders.RECEIVED_PARTITION) int partition,
+            @Header(KafkaHeaders.OFFSET) long offset
+    ) {
+        LOGGER.info(
+                "Received AssetChangeEvent on topic: {}, partition: {}, offset: {}: Asset ID: {}, EventType: {}",
+                topic, partition, offset, event.getAssetId(), event.getEventType()
+        );
+
+        try {
+            // Trigger policy evaluation based on the asset change
+            UUID initiatorUuid = null;
+            if (event.getUserId() != null && !event.getUserId().isEmpty()) {
+                try {
+                    initiatorUuid = UUID.fromString(event.getUserId());
+                } catch (IllegalArgumentException e) {
+                    LOGGER.warn("Could not parse userId '{}' from AssetChangeEvent to UUID. Proceeding with null initiator.", event.getUserId(), e);
+                }
+            }
+            policyEvaluationService.evaluatePolicyForAssetInternal(event, initiatorUuid);
+            LOGGER.debug("Successfully processed AssetChangeEvent for assetId: {}", event.getAssetId());
+        } catch (Exception e) {
+            // TODO: Implement proper error handling and dead-letter queue (DLQ) strategy
+            LOGGER.error("Error processing AssetChangeEvent for assetId: {}. Error: {}", event.getAssetId(), e.getMessage(), e);
+            // Depending on the error, you might rethrow to trigger Kafka's error handlers, or send to DLQ
+        }
+    }
+} 

src/main/java/com/dalab/policyengine/kafka/producer/PolicyActionKafkaProducer.java

@@ -0,0 +1,54 @@
+package com.dalab.policyengine.kafka.producer;
+
+import java.util.concurrent.CompletableFuture;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.kafka.support.SendResult;
+import org.springframework.stereotype.Component;
+
+import com.dalab.policyengine.event.PolicyActionEvent;
+
+@Component
+public class PolicyActionKafkaProducer {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(PolicyActionKafkaProducer.class);
+
+    private final KafkaTemplate<String, PolicyActionEvent> kafkaTemplate;
+
+    @Value("${app.kafka.topic.policy-action-event}")
+    private String topicName;
+
+    public PolicyActionKafkaProducer(KafkaTemplate<String, PolicyActionEvent> kafkaTemplate) {
+        this.kafkaTemplate = kafkaTemplate;
+    }
+
+    public void sendPolicyActionEvent(PolicyActionEvent event) {
+        LOGGER.info("Sending PolicyActionEvent with eventId: {} to topic: {}", event.getEventId(), topicName);
+
+        String eventKey = event.getTargetAssetId();
+        if (eventKey == null || eventKey.isEmpty()) {
+            eventKey = event.getPolicyId();
+        }
+        final String finalEventKey = eventKey;
+
+        CompletableFuture<SendResult<String, PolicyActionEvent>> future = kafkaTemplate.send(topicName, finalEventKey, event);
+
+        future.whenComplete((result, ex) -> {
+            if (ex == null) {
+                LOGGER.info(
+                        "Successfully sent PolicyActionEvent [eventId: {}, key: {}] with offset: {}",
+                        event.getEventId(), finalEventKey, result.getRecordMetadata().offset()
+                );
+            } else {
+                LOGGER.error(
+                        "Failed to send PolicyActionEvent [eventId: {}, key: {}]: {}",
+                        event.getEventId(), finalEventKey, ex.getMessage(), ex
+                );
+                // TODO: Handle send failure (e.g., retry, DLQ, persistent store for later retry)
+            }
+        });
+    }
+}

src/main/java/com/dalab/policyengine/kafka/producer/PolicyActionProducer.java

@@ -0,0 +1,42 @@
+package com.dalab.policyengine.kafka.producer;
+
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.stereotype.Service;
+
+@Service
+public class PolicyActionProducer {
+
+    private static final Logger log = LoggerFactory.getLogger(PolicyActionProducer.class);
+
+    @Value("${app.kafka.topic.policy-action-event:policy-action-events}")
+    private String policyActionEventTopic;
+
+    // Use generic KafkaTemplate since we're sending Map-based events for now
+    private final KafkaTemplate<String, Object> kafkaTemplate;
+
+    @Autowired
+    public PolicyActionProducer(KafkaTemplate<String, Object> kafkaTemplate) {
+        this.kafkaTemplate = kafkaTemplate;
+    }
+
+    // Method to send policy action events as Map objects for now
+    public void sendPolicyActionEvent(Map<String, Object> event) {
+        try {
+            String assetId = (String) event.get("assetId");
+            String actionType = (String) event.get("actionType");
+            log.info("Sending PolicyActionEvent to topic '{}': AssetId={}, ActionType={}", 
+                     policyActionEventTopic, assetId, actionType);
+            // Use assetId as key for partitioning
+            kafkaTemplate.send(policyActionEventTopic, assetId, event);
+        } catch (Exception e) {
+            String assetId = event != null ? (String) event.get("assetId") : "unknown";
+            log.error("Error sending PolicyActionEvent to Kafka for assetId {}: {}", assetId, e.getMessage(), e);
+        }
+    }
+} 

src/main/java/com/dalab/policyengine/mapper/PolicyDraftMapper.java

@@ -0,0 +1,372 @@
+package com.dalab.policyengine.mapper;
+
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.springframework.stereotype.Component;
+
+import com.dalab.policyengine.dto.PolicyDraftInputDTO;
+import com.dalab.policyengine.dto.PolicyDraftOutputDTO;
+import com.dalab.policyengine.model.PolicyDraft;
+import com.dalab.policyengine.model.PolicyDraftStatus;
+
+/**
+ * Mapper for converting between PolicyDraft entities and DTOs.
+ * Handles workflow status calculation and available actions based on current status and user permissions.
+ */
+@Component
+public class PolicyDraftMapper {
+
+    /**
+     * Convert PolicyDraft entity to output DTO with workflow information.
+     */
+    public PolicyDraftOutputDTO toOutputDTO(PolicyDraft draft) {
+        if (draft == null) {
+            return null;
+        }
+
+        PolicyDraftOutputDTO dto = new PolicyDraftOutputDTO();
+        
+        // Basic information
+        dto.setId(draft.getId());
+        dto.setName(draft.getName());
+        dto.setDescription(draft.getDescription());
+        dto.setStatus(draft.getStatus().name());
+        dto.setVersion(draft.getVersion());
+        dto.setBasePolicyId(draft.getBasePolicyId());
+        dto.setConditionLogic(draft.getConditionLogic());
+        dto.setRulesDefinition(draft.getRulesDefinition());
+        dto.setActions(draft.getActions());
+        dto.setChangeSummary(draft.getChangeSummary());
+        dto.setJustification(draft.getJustification());
+        dto.setExpectedImpact(draft.getExpectedImpact());
+        dto.setTargetImplementationDate(draft.getTargetImplementationDate());
+        dto.setPriority(draft.getPriority());
+        dto.setCategory(draft.getCategory());
+        dto.setTags(draft.getTags());
+        dto.setStakeholders(draft.getStakeholders());
+        dto.setApprovalMetadata(draft.getApprovalMetadata());
+        dto.setReviewComments(draft.getReviewComments());
+
+        // Audit trail
+        dto.setCreatedAt(draft.getCreatedAt());
+        dto.setUpdatedAt(draft.getUpdatedAt());
+        dto.setCreatedByUserId(draft.getCreatedByUserId());
+        dto.setUpdatedByUserId(draft.getUpdatedByUserId());
+        dto.setSubmittedAt(draft.getSubmittedAt());
+        dto.setSubmittedByUserId(draft.getSubmittedByUserId());
+        dto.setApprovedAt(draft.getApprovedAt());
+        dto.setApprovedByUserId(draft.getApprovedByUserId());
+        dto.setRejectedAt(draft.getRejectedAt());
+        dto.setRejectedByUserId(draft.getRejectedByUserId());
+        dto.setPublishedAt(draft.getPublishedAt());
+        dto.setPublishedByUserId(draft.getPublishedByUserId());
+
+        // Enhanced workflow information
+        dto.setWorkflowStatus(createWorkflowStatus(draft));
+        dto.setAvailableActions(createAvailableActions(draft));
+
+        return dto;
+    }
+
+    /**
+     * Convert input DTO to PolicyDraft entity.
+     */
+    public PolicyDraft toEntity(PolicyDraftInputDTO inputDTO) {
+        if (inputDTO == null) {
+            return null;
+        }
+
+        PolicyDraft draft = new PolicyDraft();
+        
+        draft.setName(inputDTO.getName());
+        draft.setDescription(inputDTO.getDescription());
+        draft.setBasePolicyId(inputDTO.getBasePolicyId());
+        draft.setConditionLogic(inputDTO.getConditionLogic());
+        draft.setRulesDefinition(inputDTO.getRulesDefinition());
+        draft.setActions(inputDTO.getActions());
+        draft.setChangeSummary(inputDTO.getChangeSummary());
+        draft.setJustification(inputDTO.getJustification());
+        draft.setExpectedImpact(inputDTO.getExpectedImpact());
+        draft.setTargetImplementationDate(inputDTO.getTargetImplementationDate());
+        draft.setPriority(inputDTO.getPriority());
+        draft.setCategory(inputDTO.getCategory());
+        
+        if (inputDTO.getTags() != null) {
+            draft.setTags(new ArrayList<>(inputDTO.getTags()));
+        }
+        if (inputDTO.getStakeholders() != null) {
+            draft.setStakeholders(new ArrayList<>(inputDTO.getStakeholders()));
+        }
+
+        return draft;
+    }
+
+    /**
+     * Update entity from input DTO (for updates).
+     */
+    public void updateEntity(PolicyDraft draft, PolicyDraftInputDTO inputDTO) {
+        if (draft == null || inputDTO == null) {
+            return;
+        }
+
+        draft.setName(inputDTO.getName());
+        draft.setDescription(inputDTO.getDescription());
+        draft.setBasePolicyId(inputDTO.getBasePolicyId());
+        draft.setConditionLogic(inputDTO.getConditionLogic());
+        draft.setRulesDefinition(inputDTO.getRulesDefinition());
+        draft.setActions(inputDTO.getActions());
+        draft.setChangeSummary(inputDTO.getChangeSummary());
+        draft.setJustification(inputDTO.getJustification());
+        draft.setExpectedImpact(inputDTO.getExpectedImpact());
+        draft.setTargetImplementationDate(inputDTO.getTargetImplementationDate());
+        draft.setPriority(inputDTO.getPriority());
+        draft.setCategory(inputDTO.getCategory());
+        
+        if (inputDTO.getTags() != null) {
+            draft.getTags().clear();
+            draft.getTags().addAll(inputDTO.getTags());
+        }
+        if (inputDTO.getStakeholders() != null) {
+            draft.getStakeholders().clear();
+            draft.getStakeholders().addAll(inputDTO.getStakeholders());
+        }
+    }
+
+    /**
+     * Create workflow status information for the draft.
+     */
+    private PolicyDraftOutputDTO.WorkflowStatusDTO createWorkflowStatus(PolicyDraft draft) {
+        PolicyDraftOutputDTO.WorkflowStatusDTO status = new PolicyDraftOutputDTO.WorkflowStatusDTO();
+        
+        PolicyDraftStatus currentStatus = draft.getStatus();
+        status.setCurrentStage(currentStatus.name());
+        status.setStatusDescription(getStatusDescription(currentStatus));
+        status.setNextPossibleStates(getNextPossibleStates(currentStatus));
+        status.setStageColor(getStageColor(currentStatus));
+        
+        // Calculate days in current status
+        Instant statusChangeTime = getLastStatusChangeTime(draft, currentStatus);
+        if (statusChangeTime != null) {
+            long days = ChronoUnit.DAYS.between(statusChangeTime, Instant.now());
+            status.setDaysInCurrentStatus((int) days);
+        }
+
+        // Set permission flags (simplified - would integrate with security context in real implementation)
+        status.setCanEdit(canEdit(currentStatus));
+        status.setCanSubmit(canSubmit(currentStatus));
+        status.setCanApprove(canApprove(currentStatus));
+        status.setCanReject(canReject(currentStatus));
+        status.setCanPublish(canPublish(currentStatus));
+
+        return status;
+    }
+
+    /**
+     * Create available workflow actions for the draft.
+     */
+    private List<PolicyDraftOutputDTO.WorkflowActionDTO> createAvailableActions(PolicyDraft draft) {
+        List<PolicyDraftOutputDTO.WorkflowActionDTO> actions = new ArrayList<>();
+        PolicyDraftStatus status = draft.getStatus();
+
+        switch (status) {
+            case CREATED:
+            case REQUIRES_CHANGES:
+                actions.add(new PolicyDraftOutputDTO.WorkflowActionDTO("SUBMIT", "Submit for Review"));
+                actions.add(new PolicyDraftOutputDTO.WorkflowActionDTO("ARCHIVE", "Archive Draft"));
+                break;
+            case SUBMITTED:
+            case UNDER_REVIEW:
+                actions.add(new PolicyDraftOutputDTO.WorkflowActionDTO("APPROVE", "Approve Draft"));
+                actions.add(new PolicyDraftOutputDTO.WorkflowActionDTO("REJECT", "Reject Draft"));
+                actions.add(new PolicyDraftOutputDTO.WorkflowActionDTO("REQUEST_CHANGES", "Request Changes"));
+                break;
+            case APPROVED:
+                actions.add(new PolicyDraftOutputDTO.WorkflowActionDTO("PUBLISH", "Publish Policy"));
+                actions.add(new PolicyDraftOutputDTO.WorkflowActionDTO("REJECT", "Reject Draft"));
+                break;
+            default:
+                // No actions available for REJECTED, PUBLISHED, ARCHIVED
+                break;
+        }
+
+        // Set action properties
+        for (PolicyDraftOutputDTO.WorkflowActionDTO action : actions) {
+            setActionProperties(action);
+        }
+
+        return actions;
+    }
+
+    /**
+     * Get human-readable description for status.
+     */
+    private String getStatusDescription(PolicyDraftStatus status) {
+        switch (status) {
+            case CREATED:
+                return "Draft has been created and is ready for editing";
+            case SUBMITTED:
+                return "Draft has been submitted and is awaiting review";
+            case UNDER_REVIEW:
+                return "Draft is currently being reviewed";
+            case REQUIRES_CHANGES:
+                return "Draft requires changes based on reviewer feedback";
+            case APPROVED:
+                return "Draft has been approved and is ready for publication";
+            case REJECTED:
+                return "Draft has been rejected and will not be published";
+            case PUBLISHED:
+                return "Draft has been published as an active policy";
+            case ARCHIVED:
+                return "Draft has been archived and is no longer active";
+            default:
+                return "Unknown status";
+        }
+    }
+
+    /**
+     * Get next possible states for workflow transitions.
+     */
+    private List<String> getNextPossibleStates(PolicyDraftStatus status) {
+        switch (status) {
+            case CREATED:
+            case REQUIRES_CHANGES:
+                return Arrays.asList("SUBMITTED", "ARCHIVED");
+            case SUBMITTED:
+                return Arrays.asList("UNDER_REVIEW", "APPROVED", "REJECTED", "REQUIRES_CHANGES");
+            case UNDER_REVIEW:
+                return Arrays.asList("APPROVED", "REJECTED", "REQUIRES_CHANGES");
+            case APPROVED:
+                return Arrays.asList("PUBLISHED", "REJECTED");
+            default:
+                return new ArrayList<>(); // Terminal states
+        }
+    }
+
+    /**
+     * Get color for UI status indicators.
+     */
+    private String getStageColor(PolicyDraftStatus status) {
+        switch (status) {
+            case CREATED:
+                return "blue";
+            case SUBMITTED:
+            case UNDER_REVIEW:
+                return "orange";
+            case REQUIRES_CHANGES:
+                return "yellow";
+            case APPROVED:
+                return "green";
+            case REJECTED:
+                return "red";
+            case PUBLISHED:
+                return "purple";
+            case ARCHIVED:
+                return "gray";
+            default:
+                return "gray";
+        }
+    }
+
+    /**
+     * Get the timestamp of last status change.
+     */
+    private Instant getLastStatusChangeTime(PolicyDraft draft, PolicyDraftStatus currentStatus) {
+        switch (currentStatus) {
+            case SUBMITTED:
+                return draft.getSubmittedAt();
+            case APPROVED:
+                return draft.getApprovedAt();
+            case REJECTED:
+                return draft.getRejectedAt();
+            case PUBLISHED:
+                return draft.getPublishedAt();
+            default:
+                return draft.getUpdatedAt();
+        }
+    }
+
+    /**
+     * Check if draft can be edited in current status.
+     */
+    private boolean canEdit(PolicyDraftStatus status) {
+        return status == PolicyDraftStatus.CREATED || status == PolicyDraftStatus.REQUIRES_CHANGES;
+    }
+
+    /**
+     * Check if draft can be submitted in current status.
+     */
+    private boolean canSubmit(PolicyDraftStatus status) {
+        return status == PolicyDraftStatus.CREATED || status == PolicyDraftStatus.REQUIRES_CHANGES;
+    }
+
+    /**
+     * Check if draft can be approved in current status.
+     */
+    private boolean canApprove(PolicyDraftStatus status) {
+        return status == PolicyDraftStatus.SUBMITTED || status == PolicyDraftStatus.UNDER_REVIEW;
+    }
+
+    /**
+     * Check if draft can be rejected in current status.
+     */
+    private boolean canReject(PolicyDraftStatus status) {
+        return status == PolicyDraftStatus.SUBMITTED || 
+               status == PolicyDraftStatus.UNDER_REVIEW || 
+               status == PolicyDraftStatus.APPROVED;
+    }
+
+    /**
+     * Check if draft can be published in current status.
+     */
+    private boolean canPublish(PolicyDraftStatus status) {
+        return status == PolicyDraftStatus.APPROVED;
+    }
+
+    /**
+     * Set properties for workflow actions.
+     */
+    private void setActionProperties(PolicyDraftOutputDTO.WorkflowActionDTO action) {
+        switch (action.getActionType()) {
+            case "SUBMIT":
+                action.setActionDescription("Submit the draft for review by approvers");
+                action.setRequiresComment(false);
+                action.setConfirmationMessage("Are you sure you want to submit this draft for review?");
+                action.setButtonStyle("primary");
+                break;
+            case "APPROVE":
+                action.setActionDescription("Approve the draft for publication");
+                action.setRequiresComment(false);
+                action.setConfirmationMessage("Are you sure you want to approve this draft?");
+                action.setButtonStyle("success");
+                break;
+            case "REJECT":
+                action.setActionDescription("Reject the draft and prevent publication");
+                action.setRequiresComment(true);
+                action.setConfirmationMessage("Are you sure you want to reject this draft? This action cannot be undone.");
+                action.setButtonStyle("danger");
+                break;
+            case "REQUEST_CHANGES":
+                action.setActionDescription("Request changes from the draft author");
+                action.setRequiresComment(true);
+                action.setConfirmationMessage("Please provide details about the required changes");
+                action.setButtonStyle("warning");
+                break;
+            case "PUBLISH":
+                action.setActionDescription("Publish the draft as an active policy");
+                action.setRequiresComment(false);
+                action.setConfirmationMessage("Are you sure you want to publish this draft as an active policy?");
+                action.setButtonStyle("success");
+                break;
+            case "ARCHIVE":
+                action.setActionDescription("Archive the draft");
+                action.setRequiresComment(false);
+                action.setConfirmationMessage("Are you sure you want to archive this draft?");
+                action.setButtonStyle("secondary");
+                break;
+        }
+    }
+} 

src/main/java/com/dalab/policyengine/mapper/PolicyMapper.java

@@ -0,0 +1,141 @@
+package com.dalab.policyengine.mapper;
+
+import java.util.Collections;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+import org.springframework.stereotype.Component;
+
+import com.dalab.policyengine.dto.PolicyEvaluationOutputDTO;
+import com.dalab.policyengine.dto.PolicyEvaluationSummaryDTO;
+// Add missing DTO imports
+import com.dalab.policyengine.dto.PolicyInputDTO;
+import com.dalab.policyengine.dto.PolicyOutputDTO;
+import com.dalab.policyengine.dto.PolicyRuleDTO;
+import com.dalab.policyengine.dto.PolicySummaryDTO;
+// Add missing entity imports
+import com.dalab.policyengine.model.Policy;
+import com.dalab.policyengine.model.PolicyEvaluation;
+import com.dalab.policyengine.model.PolicyEvaluationStatus;
+import com.dalab.policyengine.model.PolicyRule;
+
+@Component
+public class PolicyMapper {
+
+    public PolicySummaryDTO toPolicySummaryDTO(Policy policy) {
+        if (policy == null) return null;
+        PolicySummaryDTO dto = new PolicySummaryDTO();
+        dto.setId(policy.getId());
+        dto.setName(policy.getName());
+        dto.setDescription(policy.getDescription());
+        dto.setStatus(policy.getStatus());
+        dto.setRuleCount(policy.getRules() != null ? policy.getRules().size() : 0);
+        dto.setCreatedAt(policy.getCreatedAt());
+        dto.setUpdatedAt(policy.getUpdatedAt());
+        return dto;
+    }
+
+    public PolicyOutputDTO toPolicyOutputDTO(Policy policy) {
+        if (policy == null) return null;
+        PolicyOutputDTO dto = new PolicyOutputDTO();
+        dto.setId(policy.getId());
+        dto.setName(policy.getName());
+        dto.setDescription(policy.getDescription());
+        dto.setStatus(policy.getStatus());
+        dto.setConditionLogic(policy.getConditionLogic());
+        dto.setActions(policy.getActions());
+        dto.setRules(policy.getRules().stream().map(this::toPolicyRuleDTO).collect(Collectors.toList()));
+        dto.setCreatedAt(policy.getCreatedAt());
+        dto.setUpdatedAt(policy.getUpdatedAt());
+        dto.setCreatedByUserId(policy.getCreatedByUserId());
+        dto.setUpdatedByUserId(policy.getUpdatedByUserId());
+        return dto;
+    }
+
+    public PolicyRuleDTO toPolicyRuleDTO(PolicyRule policyRule) {
+        if (policyRule == null) return null;
+        PolicyRuleDTO dto = new PolicyRuleDTO();
+        dto.setId(policyRule.getId() != null ? policyRule.getId().toString() : null);
+        dto.setName(policyRule.getName());
+        dto.setDescription(policyRule.getDescription());
+        dto.setCondition(policyRule.getCondition());
+        dto.setPriority(policyRule.getPriority());
+        dto.setActions(policyRule.getActions());
+        return dto;
+    }
+
+    public Policy toPolicyEntity(PolicyInputDTO dto) {
+        if (dto == null) return null;
+        Policy policy = new Policy();
+        updatePolicyEntityFromInputDTO(policy, dto); // Reuse logic for update
+        return policy;
+    }
+
+    public void updatePolicyEntityFromInputDTO(Policy policy, PolicyInputDTO dto) {
+        if (policy == null || dto == null) return;
+
+        policy.setName(dto.getName());
+        policy.setDescription(dto.getDescription());
+        policy.setStatus(dto.getStatus());
+        policy.setConditionLogic(dto.getConditionLogic());
+        policy.setActions(dto.getActions());
+
+        // Handle rules update carefully
+        if (dto.getRules() != null) {
+            // Simple strategy: remove all existing and add new ones based on DTO
+            // More sophisticated merging could be done (e.g. based on rule ID or name)
+            policy.getRules().clear(); 
+            dto.getRules().forEach(ruleDTO -> policy.addRule(toPolicyRuleEntity(ruleDTO)));
+        } else {
+            policy.setRules(Collections.emptyList());
+        }
+    }
+
+    public PolicyRule toPolicyRuleEntity(PolicyRuleDTO dto) {
+        if (dto == null) return null;
+        PolicyRule rule = new PolicyRule();
+        // ID is not set here for new rules, or could be used to fetch existing if updating
+        // For simplicity, if ID is present in DTO, we assume it might be used by service layer
+        // to find and update existing rule, but mapper focuses on new entity creation or field mapping.
+        if (dto.getId() != null) {
+           try {
+             rule.setId(UUID.fromString(dto.getId()));
+           } catch (IllegalArgumentException e) {
+             // Handle invalid UUID string if necessary, or let it be null for new entity
+           }
+        }
+        rule.setName(dto.getName());
+        rule.setDescription(dto.getDescription());
+        rule.setCondition(dto.getCondition());
+        rule.setPriority(dto.getPriority());
+        rule.setActions(dto.getActions());
+        return rule;
+    }
+
+    public PolicyEvaluationOutputDTO toPolicyEvaluationOutputDTO(PolicyEvaluation evaluation, String policyName) {
+        if (evaluation == null) return null;
+        PolicyEvaluationOutputDTO dto = new PolicyEvaluationOutputDTO();
+        dto.setId(evaluation.getId());
+        dto.setPolicyId(evaluation.getPolicyId());
+        dto.setPolicyName(policyName); // Policy name fetched separately for convenience
+        dto.setTargetAssetId(evaluation.getTargetAssetId());
+        dto.setStatus(evaluation.getStatus());
+        dto.setEvaluationDetails(evaluation.getEvaluationDetails());
+        dto.setTriggeredActions(evaluation.getTriggeredActions());
+        dto.setEvaluatedAt(evaluation.getEvaluatedAt());
+        dto.setEvaluationTriggeredByUserId(evaluation.getEvaluationTriggeredByUserId());
+        return dto;
+    }
+
+    public PolicyEvaluationSummaryDTO toPolicyEvaluationSummaryDTO(PolicyEvaluation evaluation, String policyName) {
+        if (evaluation == null) return null;
+        PolicyEvaluationSummaryDTO dto = new PolicyEvaluationSummaryDTO();
+        dto.setId(evaluation.getId());
+        dto.setPolicyId(evaluation.getPolicyId());
+        dto.setPolicyName(policyName);
+        dto.setTargetAssetId(evaluation.getTargetAssetId());
+        dto.setStatus(evaluation.getStatus());
+        dto.setEvaluatedAt(evaluation.getEvaluatedAt());
+        return dto;
+    }
+} 

src/main/java/com/dalab/policyengine/model/EventRule.java

@@ -0,0 +1,226 @@
+package com.dalab.policyengine.model;
+
+import java.time.Instant;
+import java.util.Map;
+import java.util.UUID;
+
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.PrePersist;
+import jakarta.persistence.PreUpdate;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
+/**
+ * Entity representing a filtering rule for event subscriptions.
+ * Uses MVEL expressions to define conditions for event matching.
+ */
+@Entity
+@Table(name = "event_rules")
+public class EventRule {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(columnDefinition = "UUID")
+    private UUID id;
+
+    @NotBlank
+    @Size(max = 255)
+    @Column(nullable = false)
+    private String name;
+
+    @Size(max = 500)
+    private String description;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "subscription_id", nullable = false)
+    private EventSubscription subscription;
+
+    /**
+     * MVEL expression for evaluating events
+     * Example: "eventType == 'POLICY_VIOLATION' && severity == 'HIGH' && assetId.startsWith('prod-')"
+     */
+    @Column(columnDefinition = "TEXT", nullable = false)
+    private String condition;
+
+    /**
+     * Rule priority (lower number = higher priority)
+     */
+    @Column(nullable = false)
+    private Integer priority = 1;
+
+    /**
+     * Whether this rule is enabled
+     */
+    @Column(nullable = false)
+    private Boolean enabled = true;
+
+    /**
+     * Additional parameters for the rule
+     */
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private Map<String, Object> parameters;
+
+    @Column(nullable = false, updatable = false)
+    private Instant createdAt;
+
+    private Instant updatedAt;
+
+    @Column(columnDefinition = "UUID")
+    private UUID createdByUserId;
+
+    @Column(columnDefinition = "UUID")
+    private UUID updatedByUserId;
+
+    // Constructors
+    public EventRule() {}
+
+    public EventRule(String name, String condition) {
+        this.name = name;
+        this.condition = condition;
+    }
+
+    // Getters and Setters
+
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public EventSubscription getSubscription() {
+        return subscription;
+    }
+
+    public void setSubscription(EventSubscription subscription) {
+        this.subscription = subscription;
+    }
+
+    public String getCondition() {
+        return condition;
+    }
+
+    public void setCondition(String condition) {
+        this.condition = condition;
+    }
+
+    public Integer getPriority() {
+        return priority;
+    }
+
+    public void setPriority(Integer priority) {
+        this.priority = priority;
+    }
+
+    public Boolean getEnabled() {
+        return enabled;
+    }
+
+    public void setEnabled(Boolean enabled) {
+        this.enabled = enabled;
+    }
+
+    public Map<String, Object> getParameters() {
+        return parameters;
+    }
+
+    public void setParameters(Map<String, Object> parameters) {
+        this.parameters = parameters;
+    }
+
+    public Instant getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(Instant createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public Instant getUpdatedAt() {
+        return updatedAt;
+    }
+
+    public void setUpdatedAt(Instant updatedAt) {
+        this.updatedAt = updatedAt;
+    }
+
+    public UUID getCreatedByUserId() {
+        return createdByUserId;
+    }
+
+    public void setCreatedByUserId(UUID createdByUserId) {
+        this.createdByUserId = createdByUserId;
+    }
+
+    public UUID getUpdatedByUserId() {
+        return updatedByUserId;
+    }
+
+    public void setUpdatedByUserId(UUID updatedByUserId) {
+        this.updatedByUserId = updatedByUserId;
+    }
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = Instant.now();
+        updatedAt = Instant.now();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = Instant.now();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof EventRule)) return false;
+        EventRule eventRule = (EventRule) o;
+        return id != null && id.equals(eventRule.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return getClass().hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return "EventRule{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                ", condition='" + condition + '\'' +
+                ", priority=" + priority +
+                ", enabled=" + enabled +
+                '}';
+    }
+} 

src/main/java/com/dalab/policyengine/model/EventSeverity.java

@@ -0,0 +1,31 @@
+package com.dalab.policyengine.model;
+
+/**
+ * Enumeration representing the severity levels of events in the DALab platform.
+ */
+public enum EventSeverity {
+    /**
+     * Critical severity - immediate attention required
+     */
+    CRITICAL,
+    
+    /**
+     * High severity - urgent attention required
+     */
+    HIGH,
+    
+    /**
+     * Medium severity - attention required
+     */
+    MEDIUM,
+    
+    /**
+     * Low severity - informational
+     */
+    LOW,
+    
+    /**
+     * Informational - for logging and tracking purposes
+     */
+    INFO
+} 

src/main/java/com/dalab/policyengine/model/EventSubscription.java

@@ -0,0 +1,339 @@
+package com.dalab.policyengine.model;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.CollectionTable;
+import jakarta.persistence.Column;
+import jakarta.persistence.ElementCollection;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.PrePersist;
+import jakarta.persistence.PreUpdate;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+/**
+ * Entity representing an event subscription configuration.
+ * Users can subscribe to specific types of events and configure
+ * notification preferences and action triggers.
+ */
+@Entity
+@Table(name = "event_subscriptions")
+public class EventSubscription {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(columnDefinition = "UUID")
+    private UUID id;
+
+    @NotBlank
+    @Size(max = 255)
+    @Column(nullable = false)
+    private String name;
+
+    @Size(max = 1000)
+    private String description;
+
+    @NotNull
+    @Column(columnDefinition = "UUID", nullable = false)
+    private UUID userId;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private EventSubscriptionStatus status = EventSubscriptionStatus.ACTIVE;
+
+    /**
+     * Event types to subscribe to (e.g., POLICY_VIOLATION, ASSET_DISCOVERED, COMPLIANCE_ISSUE)
+     */
+    @ElementCollection(fetch = FetchType.EAGER)
+    @CollectionTable(name = "event_subscription_types", joinColumns = @JoinColumn(name = "subscription_id"))
+    @Enumerated(EnumType.STRING)
+    @Column(name = "event_type")
+    private List<EventType> eventTypes = new ArrayList<>();
+
+    /**
+     * Event severity levels to include (e.g., HIGH, MEDIUM, LOW)
+     */
+    @ElementCollection(fetch = FetchType.EAGER)
+    @CollectionTable(name = "event_subscription_severities", joinColumns = @JoinColumn(name = "subscription_id"))
+    @Enumerated(EnumType.STRING)
+    @Column(name = "severity")
+    private List<EventSeverity> severities = new ArrayList<>();
+
+    /**
+     * Source services to monitor (e.g., da-catalog, da-discovery, da-compliance)
+     */
+    @ElementCollection(fetch = FetchType.EAGER)
+    @CollectionTable(name = "event_subscription_sources", joinColumns = @JoinColumn(name = "subscription_id"))
+    @Column(name = "source_service")
+    private List<String> sourceServices = new ArrayList<>();
+
+    /**
+     * Filter conditions for events (MVEL expressions)
+     */
+    @OneToMany(mappedBy = "subscription", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
+    private List<EventRule> rules = new ArrayList<>();
+
+    /**
+     * Notification preferences and action configurations
+     */
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private Map<String, Object> notificationConfig; // e.g., { "email": true, "slack": { "channel": "#alerts" } }
+
+    /**
+     * Action configurations to trigger when events match
+     */
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private Map<String, Object> actionConfig; // e.g., { "autoQuarantine": true, "escalateTo": "admin" }
+
+    @Column(nullable = false, updatable = false)
+    private Instant createdAt;
+
+    private Instant updatedAt;
+
+    @Column(columnDefinition = "UUID")
+    private UUID createdByUserId;
+
+    @Column(columnDefinition = "UUID")
+    private UUID updatedByUserId;
+
+    // Constructors
+    public EventSubscription() {}
+
+    public EventSubscription(String name, UUID userId) {
+        this.name = name;
+        this.userId = userId;
+    }
+
+    // Getters and Setters
+
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public UUID getUserId() {
+        return userId;
+    }
+
+    public void setUserId(UUID userId) {
+        this.userId = userId;
+    }
+
+    public EventSubscriptionStatus getStatus() {
+        return status;
+    }
+
+    public void setStatus(EventSubscriptionStatus status) {
+        this.status = status;
+    }
+
+    public List<EventType> getEventTypes() {
+        return eventTypes;
+    }
+
+    public void setEventTypes(List<EventType> eventTypes) {
+        this.eventTypes = eventTypes != null ? eventTypes : new ArrayList<>();
+    }
+
+    public void addEventType(EventType eventType) {
+        if (this.eventTypes == null) {
+            this.eventTypes = new ArrayList<>();
+        }
+        this.eventTypes.add(eventType);
+    }
+
+    public void removeEventType(EventType eventType) {
+        if (this.eventTypes != null) {
+            this.eventTypes.remove(eventType);
+        }
+    }
+
+    public List<EventSeverity> getSeverities() {
+        return severities;
+    }
+
+    public void setSeverities(List<EventSeverity> severities) {
+        this.severities = severities != null ? severities : new ArrayList<>();
+    }
+
+    public void addSeverity(EventSeverity severity) {
+        if (this.severities == null) {
+            this.severities = new ArrayList<>();
+        }
+        this.severities.add(severity);
+    }
+
+    public void removeSeverity(EventSeverity severity) {
+        if (this.severities != null) {
+            this.severities.remove(severity);
+        }
+    }
+
+    public List<String> getSourceServices() {
+        return sourceServices;
+    }
+
+    public void setSourceServices(List<String> sourceServices) {
+        this.sourceServices = sourceServices != null ? sourceServices : new ArrayList<>();
+    }
+
+    public void addSourceService(String sourceService) {
+        if (this.sourceServices == null) {
+            this.sourceServices = new ArrayList<>();
+        }
+        this.sourceServices.add(sourceService);
+    }
+
+    public void removeSourceService(String sourceService) {
+        if (this.sourceServices != null) {
+            this.sourceServices.remove(sourceService);
+        }
+    }
+
+    public List<EventRule> getRules() {
+        return rules;
+    }
+
+    public void setRules(List<EventRule> rules) {
+        this.rules = rules != null ? rules : new ArrayList<>();
+        this.rules.forEach(rule -> rule.setSubscription(this));
+    }
+
+    public void addRule(EventRule rule) {
+        if (this.rules == null) {
+            this.rules = new ArrayList<>();
+        }
+        this.rules.add(rule);
+        rule.setSubscription(this);
+    }
+
+    public void removeRule(EventRule rule) {
+        if (this.rules != null) {
+            this.rules.remove(rule);
+            rule.setSubscription(null);
+        }
+    }
+
+    public Map<String, Object> getNotificationConfig() {
+        return notificationConfig;
+    }
+
+    public void setNotificationConfig(Map<String, Object> notificationConfig) {
+        this.notificationConfig = notificationConfig;
+    }
+
+    public Map<String, Object> getActionConfig() {
+        return actionConfig;
+    }
+
+    public void setActionConfig(Map<String, Object> actionConfig) {
+        this.actionConfig = actionConfig;
+    }
+
+    public Instant getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(Instant createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public Instant getUpdatedAt() {
+        return updatedAt;
+    }
+
+    public void setUpdatedAt(Instant updatedAt) {
+        this.updatedAt = updatedAt;
+    }
+
+    public UUID getCreatedByUserId() {
+        return createdByUserId;
+    }
+
+    public void setCreatedByUserId(UUID createdByUserId) {
+        this.createdByUserId = createdByUserId;
+    }
+
+    public UUID getUpdatedByUserId() {
+        return updatedByUserId;
+    }
+
+    public void setUpdatedByUserId(UUID updatedByUserId) {
+        this.updatedByUserId = updatedByUserId;
+    }
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = Instant.now();
+        updatedAt = Instant.now();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = Instant.now();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof EventSubscription)) return false;
+        EventSubscription that = (EventSubscription) o;
+        return id != null && id.equals(that.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return getClass().hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return "EventSubscription{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                ", userId=" + userId +
+                ", status=" + status +
+                ", eventTypes=" + eventTypes +
+                ", severities=" + severities +
+                '}';
+    }
+} 

src/main/java/com/dalab/policyengine/model/EventSubscriptionStatus.java

@@ -0,0 +1,26 @@
+package com.dalab.policyengine.model;
+
+/**
+ * Enumeration representing the status of an event subscription.
+ */
+public enum EventSubscriptionStatus {
+    /**
+     * Subscription is active and receiving events
+     */
+    ACTIVE,
+    
+    /**
+     * Subscription is temporarily paused
+     */
+    PAUSED,
+    
+    /**
+     * Subscription is disabled and not receiving events
+     */
+    DISABLED,
+    
+    /**
+     * Subscription has been archived
+     */
+    ARCHIVED
+} 

src/main/java/com/dalab/policyengine/model/EventType.java

@@ -0,0 +1,123 @@
+package com.dalab.policyengine.model;
+
+/**
+ * Enumeration representing different types of events that can occur in the DALab platform.
+ */
+public enum EventType {
+    // Policy-related events
+    /**
+     * Policy violation detected
+     */
+    POLICY_VIOLATION,
+    
+    /**
+     * Policy evaluation completed
+     */
+    POLICY_EVALUATION_COMPLETED,
+    
+    /**
+     * Policy applied to assets
+     */
+    POLICY_APPLIED,
+    
+    /**
+     * Policy rule triggered
+     */
+    POLICY_RULE_TRIGGERED,
+    
+    // Asset-related events
+    /**
+     * New asset discovered
+     */
+    ASSET_DISCOVERED,
+    
+    /**
+     * Asset metadata changed
+     */
+    ASSET_METADATA_CHANGED,
+    
+    /**
+     * Asset classification changed
+     */
+    ASSET_CLASSIFICATION_CHANGED,
+    
+    /**
+     * Asset access pattern detected
+     */
+    ASSET_ACCESS_DETECTED,
+    
+    // Compliance-related events
+    /**
+     * Compliance violation detected
+     */
+    COMPLIANCE_VIOLATION,
+    
+    /**
+     * Compliance scan completed
+     */
+    COMPLIANCE_SCAN_COMPLETED,
+    
+    /**
+     * Regulatory requirement changed
+     */
+    REGULATORY_CHANGE,
+    
+    // Data lifecycle events
+    /**
+     * Asset scheduled for archival
+     */
+    ASSET_ARCHIVAL_SCHEDULED,
+    
+    /**
+     * Asset archival completed
+     */
+    ASSET_ARCHIVAL_COMPLETED,
+    
+    /**
+     * Asset deletion scheduled
+     */
+    ASSET_DELETION_SCHEDULED,
+    
+    /**
+     * Asset deletion completed
+     */
+    ASSET_DELETION_COMPLETED,
+    
+    // System events
+    /**
+     * System alert generated
+     */
+    SYSTEM_ALERT,
+    
+    /**
+     * Service health check failed
+     */
+    SERVICE_HEALTH_ISSUE,
+    
+    /**
+     * Data quality issue detected
+     */
+    DATA_QUALITY_ISSUE,
+    
+    /**
+     * Security incident detected
+     */
+    SECURITY_INCIDENT,
+    
+    // User activity events
+    /**
+     * User access pattern anomaly
+     */
+    USER_ACCESS_ANOMALY,
+    
+    /**
+     * Unauthorized access attempt
+     */
+    UNAUTHORIZED_ACCESS_ATTEMPT,
+    
+    // Generic event type for custom events
+    /**
+     * Custom event type
+     */
+    CUSTOM_EVENT
+} 

src/main/java/com/dalab/policyengine/model/Policy.java

@@ -0,0 +1,171 @@
+package com.dalab.policyengine.model;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
+@Entity
+@Table(name = "policies")
+public class Policy {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(columnDefinition = "UUID")
+    private UUID id;
+
+    @NotBlank
+    @Size(max = 255)
+    @Column(nullable = false, unique = true)
+    private String name;
+
+    @Size(max = 1000)
+    private String description;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private PolicyStatus status = PolicyStatus.DISABLED;
+
+    // MVEL condition for the policy. If all rules pass, this condition is evaluated.
+    // Could be null if policy relies solely on its individual rules.
+    @Column(columnDefinition = "TEXT")
+    private String conditionLogic; // e.g., "rule1 && (rule2 || rule3)"
+
+    @OneToMany(mappedBy = "policy", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
+    private List<PolicyRule> rules = new ArrayList<>();
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private Map<String, Object> actions; // e.g., { "notify": { "email": "admin@example.com" }, "addLabel": "Sensitive" }
+
+    @Column(nullable = false, updatable = false)
+    private Instant createdAt;
+
+    private Instant updatedAt;
+
+    @Column(columnDefinition = "UUID")
+    private UUID createdByUserId;
+
+    @Column(columnDefinition = "UUID")
+    private UUID updatedByUserId;
+
+    // Getters and Setters
+
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public PolicyStatus getStatus() {
+        return status;
+    }
+
+    public void setStatus(PolicyStatus status) {
+        this.status = status;
+    }
+
+    public String getConditionLogic() {
+        return conditionLogic;
+    }
+
+    public void setConditionLogic(String conditionLogic) {
+        this.conditionLogic = conditionLogic;
+    }
+
+    public List<PolicyRule> getRules() {
+        return rules;
+    }
+
+    public void setRules(List<PolicyRule> rules) {
+        this.rules = rules;
+        this.rules.forEach(rule -> rule.setPolicy(this));
+    }
+
+    public void addRule(PolicyRule rule) {
+        this.rules.add(rule);
+        rule.setPolicy(this);
+    }
+
+    public void removeRule(PolicyRule rule) {
+        this.rules.remove(rule);
+        rule.setPolicy(null);
+    }
+
+    public Map<String, Object> getActions() {
+        return actions;
+    }
+
+    public void setActions(Map<String, Object> actions) {
+        this.actions = actions;
+    }
+
+    public Instant getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(Instant createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public Instant getUpdatedAt() {
+        return updatedAt;
+    }
+
+    public void setUpdatedAt(Instant updatedAt) {
+        this.updatedAt = updatedAt;
+    }
+
+    public UUID getCreatedByUserId() {
+        return createdByUserId;
+    }
+
+    public void setCreatedByUserId(UUID createdByUserId) {
+        this.createdByUserId = createdByUserId;
+    }
+
+    public UUID getUpdatedByUserId() {
+        return updatedByUserId;
+    }
+
+    public void setUpdatedByUserId(UUID updatedByUserId) {
+        this.updatedByUserId = updatedByUserId;
+    }
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = Instant.now();
+        updatedAt = Instant.now();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = Instant.now();
+    }
+} 

src/main/java/com/dalab/policyengine/model/PolicyDraft.java

@@ -0,0 +1,495 @@
+package com.dalab.policyengine.model;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+
+import jakarta.persistence.CollectionTable;
+import jakarta.persistence.Column;
+import jakarta.persistence.ElementCollection;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.PrePersist;
+import jakarta.persistence.PreUpdate;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
+/**
+ * Entity representing a policy draft that goes through approval workflow.
+ * Supports versioning, collaboration, and audit trails.
+ */
+@Entity
+@Table(name = "policy_drafts")
+public class PolicyDraft {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(columnDefinition = "UUID")
+    private UUID id;
+
+    /**
+     * Name of the policy (must be unique when published).
+     */
+    @NotBlank
+    @Size(max = 255)
+    @Column(nullable = false)
+    private String name;
+
+    /**
+     * Detailed description of the policy's purpose and scope.
+     */
+    @Size(max = 2000)
+    @Column(columnDefinition = "TEXT")
+    private String description;
+
+    /**
+     * Current status in the approval workflow.
+     */
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private PolicyDraftStatus status = PolicyDraftStatus.CREATED;
+
+    /**
+     * Version number for this draft (incremented on each revision).
+     */
+    @Column(nullable = false)
+    private Integer version = 1;
+
+    /**
+     * Reference to the published policy (if this is an update to existing policy).
+     */
+    @Column(columnDefinition = "UUID")
+    private UUID basePolicyId;
+
+    /**
+     * MVEL condition logic for the policy evaluation.
+     */
+    @Column(columnDefinition = "TEXT")
+    private String conditionLogic;
+
+    /**
+     * JSON representation of policy rules structure.
+     * Stored as JSON to support complex rule configurations.
+     */
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private List<Map<String, Object>> rulesDefinition;
+
+    /**
+     * JSON representation of actions to be taken when policy is triggered.
+     */
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private Map<String, Object> actions;
+
+    /**
+     * Change summary describing what was modified in this version.
+     */
+    @Size(max = 1000)
+    @Column(columnDefinition = "TEXT")
+    private String changeSummary;
+
+    /**
+     * Justification for the policy changes or creation.
+     */
+    @Size(max = 2000)
+    @Column(columnDefinition = "TEXT")
+    private String justification;
+
+    /**
+     * Expected impact of implementing this policy.
+     */
+    @Size(max = 1000)
+    @Column(columnDefinition = "TEXT")
+    private String expectedImpact;
+
+    /**
+     * Target implementation date for the policy.
+     */
+    private Instant targetImplementationDate;
+
+    /**
+     * Priority level for policy implementation (HIGH, MEDIUM, LOW).
+     */
+    @Size(max = 50)
+    private String priority = "MEDIUM";
+
+    /**
+     * Business category or domain this policy applies to.
+     */
+    @Size(max = 100)
+    private String category;
+
+    /**
+     * Tags for categorization and searchability.
+     */
+    @ElementCollection
+    @CollectionTable(name = "policy_draft_tags", joinColumns = @JoinColumn(name = "draft_id"))
+    @Column(name = "tag")
+    private List<String> tags = new ArrayList<>();
+
+    /**
+     * Stakeholders who should be notified about this policy.
+     */
+    @ElementCollection
+    @CollectionTable(name = "policy_draft_stakeholders", joinColumns = @JoinColumn(name = "draft_id"))
+    @Column(name = "stakeholder_id", columnDefinition = "UUID")
+    private List<UUID> stakeholders = new ArrayList<>();
+
+    /**
+     * Approval workflow metadata.
+     */
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private Map<String, Object> approvalMetadata;
+
+    /**
+     * Reviewer comments and feedback.
+     */
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private List<Map<String, Object>> reviewComments = new ArrayList<>();
+
+    // Audit fields
+    @Column(nullable = false, updatable = false)
+    private Instant createdAt;
+
+    private Instant updatedAt;
+
+    @Column(columnDefinition = "UUID", nullable = false)
+    private UUID createdByUserId;
+
+    @Column(columnDefinition = "UUID")
+    private UUID updatedByUserId;
+
+    private Instant submittedAt;
+
+    @Column(columnDefinition = "UUID")
+    private UUID submittedByUserId;
+
+    private Instant approvedAt;
+
+    @Column(columnDefinition = "UUID")
+    private UUID approvedByUserId;
+
+    private Instant rejectedAt;
+
+    @Column(columnDefinition = "UUID")
+    private UUID rejectedByUserId;
+
+    private Instant publishedAt;
+
+    @Column(columnDefinition = "UUID")
+    private UUID publishedByUserId;
+
+    // Constructors
+    public PolicyDraft() {}
+
+    public PolicyDraft(String name, String description, UUID createdByUserId) {
+        this.name = name;
+        this.description = description;
+        this.createdByUserId = createdByUserId;
+    }
+
+    // Getters and Setters
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public PolicyDraftStatus getStatus() {
+        return status;
+    }
+
+    public void setStatus(PolicyDraftStatus status) {
+        this.status = status;
+    }
+
+    public Integer getVersion() {
+        return version;
+    }
+
+    public void setVersion(Integer version) {
+        this.version = version;
+    }
+
+    public UUID getBasePolicyId() {
+        return basePolicyId;
+    }
+
+    public void setBasePolicyId(UUID basePolicyId) {
+        this.basePolicyId = basePolicyId;
+    }
+
+    public String getConditionLogic() {
+        return conditionLogic;
+    }
+
+    public void setConditionLogic(String conditionLogic) {
+        this.conditionLogic = conditionLogic;
+    }
+
+    public List<Map<String, Object>> getRulesDefinition() {
+        return rulesDefinition;
+    }
+
+    public void setRulesDefinition(List<Map<String, Object>> rulesDefinition) {
+        this.rulesDefinition = rulesDefinition;
+    }
+
+    public Map<String, Object> getActions() {
+        return actions;
+    }
+
+    public void setActions(Map<String, Object> actions) {
+        this.actions = actions;
+    }
+
+    public String getChangeSummary() {
+        return changeSummary;
+    }
+
+    public void setChangeSummary(String changeSummary) {
+        this.changeSummary = changeSummary;
+    }
+
+    public String getJustification() {
+        return justification;
+    }
+
+    public void setJustification(String justification) {
+        this.justification = justification;
+    }
+
+    public String getExpectedImpact() {
+        return expectedImpact;
+    }
+
+    public void setExpectedImpact(String expectedImpact) {
+        this.expectedImpact = expectedImpact;
+    }
+
+    public Instant getTargetImplementationDate() {
+        return targetImplementationDate;
+    }
+
+    public void setTargetImplementationDate(Instant targetImplementationDate) {
+        this.targetImplementationDate = targetImplementationDate;
+    }
+
+    public String getPriority() {
+        return priority;
+    }
+
+    public void setPriority(String priority) {
+        this.priority = priority;
+    }
+
+    public String getCategory() {
+        return category;
+    }
+
+    public void setCategory(String category) {
+        this.category = category;
+    }
+
+    public List<String> getTags() {
+        return tags;
+    }
+
+    public void setTags(List<String> tags) {
+        this.tags = tags;
+    }
+
+    public List<UUID> getStakeholders() {
+        return stakeholders;
+    }
+
+    public void setStakeholders(List<UUID> stakeholders) {
+        this.stakeholders = stakeholders;
+    }
+
+    public Map<String, Object> getApprovalMetadata() {
+        return approvalMetadata;
+    }
+
+    public void setApprovalMetadata(Map<String, Object> approvalMetadata) {
+        this.approvalMetadata = approvalMetadata;
+    }
+
+    public List<Map<String, Object>> getReviewComments() {
+        return reviewComments;
+    }
+
+    public void setReviewComments(List<Map<String, Object>> reviewComments) {
+        this.reviewComments = reviewComments;
+    }
+
+    public Instant getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(Instant createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public Instant getUpdatedAt() {
+        return updatedAt;
+    }
+
+    public void setUpdatedAt(Instant updatedAt) {
+        this.updatedAt = updatedAt;
+    }
+
+    public UUID getCreatedByUserId() {
+        return createdByUserId;
+    }
+
+    public void setCreatedByUserId(UUID createdByUserId) {
+        this.createdByUserId = createdByUserId;
+    }
+
+    public UUID getUpdatedByUserId() {
+        return updatedByUserId;
+    }
+
+    public void setUpdatedByUserId(UUID updatedByUserId) {
+        this.updatedByUserId = updatedByUserId;
+    }
+
+    public Instant getSubmittedAt() {
+        return submittedAt;
+    }
+
+    public void setSubmittedAt(Instant submittedAt) {
+        this.submittedAt = submittedAt;
+    }
+
+    public UUID getSubmittedByUserId() {
+        return submittedByUserId;
+    }
+
+    public void setSubmittedByUserId(UUID submittedByUserId) {
+        this.submittedByUserId = submittedByUserId;
+    }
+
+    public Instant getApprovedAt() {
+        return approvedAt;
+    }
+
+    public void setApprovedAt(Instant approvedAt) {
+        this.approvedAt = approvedAt;
+    }
+
+    public UUID getApprovedByUserId() {
+        return approvedByUserId;
+    }
+
+    public void setApprovedByUserId(UUID approvedByUserId) {
+        this.approvedByUserId = approvedByUserId;
+    }
+
+    public Instant getRejectedAt() {
+        return rejectedAt;
+    }
+
+    public void setRejectedAt(Instant rejectedAt) {
+        this.rejectedAt = rejectedAt;
+    }
+
+    public UUID getRejectedByUserId() {
+        return rejectedByUserId;
+    }
+
+    public void setRejectedByUserId(UUID rejectedByUserId) {
+        this.rejectedByUserId = rejectedByUserId;
+    }
+
+    public Instant getPublishedAt() {
+        return publishedAt;
+    }
+
+    public void setPublishedAt(Instant publishedAt) {
+        this.publishedAt = publishedAt;
+    }
+
+    public UUID getPublishedByUserId() {
+        return publishedByUserId;
+    }
+
+    public void setPublishedByUserId(UUID publishedByUserId) {
+        this.publishedByUserId = publishedByUserId;
+    }
+
+    /**
+     * Utility method to add a review comment.
+     */
+    public void addReviewComment(String comment, UUID reviewerId, String reviewerRole) {
+        Map<String, Object> commentData = Map.of(
+            "comment", comment,
+            "reviewerId", reviewerId.toString(),
+            "reviewerRole", reviewerRole,
+            "timestamp", Instant.now().toString()
+        );
+        this.reviewComments.add(commentData);
+    }
+
+    /**
+     * Utility method to add a tag if not already present.
+     */
+    public void addTag(String tag) {
+        if (!this.tags.contains(tag)) {
+            this.tags.add(tag);
+        }
+    }
+
+    /**
+     * Utility method to add a stakeholder if not already present.
+     */
+    public void addStakeholder(UUID stakeholderId) {
+        if (!this.stakeholders.contains(stakeholderId)) {
+            this.stakeholders.add(stakeholderId);
+        }
+    }
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = Instant.now();
+        updatedAt = Instant.now();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = Instant.now();
+    }
+} 

src/main/java/com/dalab/policyengine/model/PolicyDraftStatus.java

@@ -0,0 +1,47 @@
+package com.dalab.policyengine.model;
+
+/**
+ * Status enumeration for policy drafts supporting complete workflow lifecycle.
+ * Tracks the draft from creation through approval and publication.
+ */
+public enum PolicyDraftStatus {
+    /**
+     * Draft has been created but not yet submitted for review.
+     */
+    CREATED,
+    
+    /**
+     * Draft has been submitted and is awaiting review.
+     */
+    SUBMITTED,
+    
+    /**
+     * Draft is currently under review by approvers.
+     */
+    UNDER_REVIEW,
+    
+    /**
+     * Draft requires changes based on reviewer feedback.
+     */
+    REQUIRES_CHANGES,
+    
+    /**
+     * Draft has been approved and is ready for publication.
+     */
+    APPROVED,
+    
+    /**
+     * Draft has been rejected and will not be published.
+     */
+    REJECTED,
+    
+    /**
+     * Draft has been published as an active policy.
+     */
+    PUBLISHED,
+    
+    /**
+     * Draft has been archived (no longer active).
+     */
+    ARCHIVED
+} 

src/main/java/com/dalab/policyengine/model/PolicyEvaluation.java

@@ -0,0 +1,119 @@
+package com.dalab.policyengine.model;
+
+import java.time.Instant;
+import java.util.Map;
+import java.util.UUID;
+
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "policy_evaluations")
+public class PolicyEvaluation {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(columnDefinition = "UUID")
+    private UUID id;
+
+    @Column(nullable = false, columnDefinition = "UUID")
+    private UUID policyId;
+
+    @Column(nullable = false, length = 255) // External asset ID from da-catalog or other source
+    private String targetAssetId;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private PolicyEvaluationStatus status;
+
+    // Store details about the evaluation, e.g., which rules passed/failed, input facts snapshot
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private Map<String, Object> evaluationDetails;
+
+    // Store actions that were triggered as a result of this evaluation
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private Map<String, Object> triggeredActions;
+
+    @Column(nullable = false)
+    private Instant evaluatedAt;
+
+    @Column(columnDefinition = "UUID")
+    private UUID evaluationTriggeredByUserId; // Optional: if triggered by a user action
+
+    // Getters and Setters
+
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public UUID getPolicyId() {
+        return policyId;
+    }
+
+    public void setPolicyId(UUID policyId) {
+        this.policyId = policyId;
+    }
+
+    public String getTargetAssetId() {
+        return targetAssetId;
+    }
+
+    public void setTargetAssetId(String targetAssetId) {
+        this.targetAssetId = targetAssetId;
+    }
+
+    public PolicyEvaluationStatus getStatus() {
+        return status;
+    }
+
+    public void setStatus(PolicyEvaluationStatus status) {
+        this.status = status;
+    }
+
+    public Map<String, Object> getEvaluationDetails() {
+        return evaluationDetails;
+    }
+
+    public void setEvaluationDetails(Map<String, Object> evaluationDetails) {
+        this.evaluationDetails = evaluationDetails;
+    }
+
+    public Map<String, Object> getTriggeredActions() {
+        return triggeredActions;
+    }
+
+    public void setTriggeredActions(Map<String, Object> triggeredActions) {
+        this.triggeredActions = triggeredActions;
+    }
+
+    public Instant getEvaluatedAt() {
+        return evaluatedAt;
+    }
+
+    public void setEvaluatedAt(Instant evaluatedAt) {
+        this.evaluatedAt = evaluatedAt;
+    }
+
+    public UUID getEvaluationTriggeredByUserId() {
+        return evaluationTriggeredByUserId;
+    }
+
+    public void setEvaluationTriggeredByUserId(UUID evaluationTriggeredByUserId) {
+        this.evaluationTriggeredByUserId = evaluationTriggeredByUserId;
+    }
+
+    @PrePersist
+    protected void onPersist() {
+        if (evaluatedAt == null) {
+            evaluatedAt = Instant.now();
+        }
+    }
+} 

src/main/java/com/dalab/policyengine/model/PolicyEvaluationStatus.java

@@ -0,0 +1,9 @@
+package com.dalab.policyengine.model;
+
+public enum PolicyEvaluationStatus {
+    PASS,       // Policy conditions met, actions may have been triggered
+    FAIL,       // Policy conditions not met
+    ERROR,      // Error during evaluation (e.g., bad rule syntax, fact unavailable)
+    PENDING,    // Evaluation is queued or in progress
+    NOT_APPLICABLE // Policy was not applicable to the target asset
+} 

src/main/java/com/dalab/policyengine/model/PolicyRule.java

@@ -0,0 +1,137 @@
+package com.dalab.policyengine.model;
+
+import java.time.Instant;
+import java.util.Map;
+import java.util.UUID;
+
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
+@Entity
+@Table(name = "policy_rules")
+public class PolicyRule {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(columnDefinition = "UUID")
+    private UUID id;
+
+    @NotBlank
+    @Size(max = 255)
+    @Column(nullable = false)
+    private String name; // A unique name for the rule within the policy, e.g., "rule1", "checkPII"
+
+    @Size(max = 1000)
+    private String description;
+
+    @NotBlank
+    @Column(nullable = false, columnDefinition = "TEXT")
+    private String condition; // MVEL expression, e.g., "asset.assetType == 'S3_BUCKET' && asset.tags.contains('PII')"
+
+    // Rules with lower numbers have higher priority
+    @Column(nullable = false)
+    private int priority = 1;
+
+    // Optional: Actions specific to this rule, if different from policy-level actions or to augment them
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private Map<String, Object> actions;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "policy_id", nullable = false)
+    private Policy policy;
+
+    @Column(nullable = false, updatable = false)
+    private Instant createdAt;
+
+    private Instant updatedAt;
+
+    // Getters and Setters
+
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public String getCondition() {
+        return condition;
+    }
+
+    public void setCondition(String condition) {
+        this.condition = condition;
+    }
+
+    public int getPriority() {
+        return priority;
+    }
+
+    public void setPriority(int priority) {
+        this.priority = priority;
+    }
+
+    public Map<String, Object> getActions() {
+        return actions;
+    }
+
+    public void setActions(Map<String, Object> actions) {
+        this.actions = actions;
+    }
+
+    public Policy getPolicy() {
+        return policy;
+    }
+
+    public void setPolicy(Policy policy) {
+        this.policy = policy;
+    }
+
+    public Instant getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(Instant createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public Instant getUpdatedAt() {
+        return updatedAt;
+    }
+
+    public void setUpdatedAt(Instant updatedAt) {
+        this.updatedAt = updatedAt;
+    }
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = Instant.now();
+        updatedAt = Instant.now();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = Instant.now();
+    }
+} 

src/main/java/com/dalab/policyengine/model/PolicyStatus.java

@@ -0,0 +1,6 @@
+package com.dalab.policyengine.model;
+
+public enum PolicyStatus {
+    ENABLED,
+    DISABLED
+} 

src/main/java/com/dalab/policyengine/repository/EventRuleRepository.java

@@ -0,0 +1,86 @@
+package com.dalab.policyengine.repository;
+
+import java.util.List;
+import java.util.UUID;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import com.dalab.policyengine.model.EventRule;
+
+/**
+ * Repository interface for EventRule entities.
+ * Provides data access methods for event rule management.
+ */
+@Repository
+public interface EventRuleRepository extends JpaRepository<EventRule, UUID> {
+
+    /**
+     * Find all rules for a specific subscription
+     */
+    List<EventRule> findBySubscriptionId(UUID subscriptionId);
+
+    /**
+     * Find enabled rules for a specific subscription ordered by priority
+     */
+    List<EventRule> findBySubscriptionIdAndEnabledTrueOrderByPriorityAsc(UUID subscriptionId);
+
+    /**
+     * Find rules by name pattern
+     */
+    List<EventRule> findByNameContainingIgnoreCase(String namePattern);
+
+    /**
+     * Find rules for a subscription by name pattern
+     */
+    List<EventRule> findBySubscriptionIdAndNameContainingIgnoreCase(UUID subscriptionId, String namePattern);
+
+    /**
+     * Check if a rule with the given name already exists for a subscription
+     */
+    boolean existsBySubscriptionIdAndName(UUID subscriptionId, String name);
+
+    /**
+     * Find rules by enabled status
+     */
+    List<EventRule> findByEnabled(Boolean enabled);
+
+    /**
+     * Find rules with a specific priority
+     */
+    List<EventRule> findByPriority(Integer priority);
+
+    /**
+     * Find rules created by a specific user
+     */
+    List<EventRule> findByCreatedByUserId(UUID createdByUserId);
+
+    /**
+     * Count rules for a specific subscription
+     */
+    long countBySubscriptionId(UUID subscriptionId);
+
+    /**
+     * Count enabled rules for a specific subscription
+     */
+    long countBySubscriptionIdAndEnabledTrue(UUID subscriptionId);
+
+    /**
+     * Find rules that contain a specific condition pattern
+     */
+    @Query("SELECT er FROM EventRule er WHERE er.condition LIKE %:conditionPattern%")
+    List<EventRule> findByConditionContaining(@Param("conditionPattern") String conditionPattern);
+
+    /**
+     * Find the highest priority rule for a subscription
+     */
+    @Query("SELECT er FROM EventRule er WHERE er.subscription.id = :subscriptionId AND er.enabled = true ORDER BY er.priority ASC LIMIT 1")
+    EventRule findHighestPriorityEnabledRule(@Param("subscriptionId") UUID subscriptionId);
+
+    /**
+     * Find rules for a subscription ordered by priority
+     */
+    List<EventRule> findBySubscriptionIdOrderByPriorityAsc(UUID subscriptionId);
+} 

src/main/java/com/dalab/policyengine/repository/EventSubscriptionRepository.java

@@ -0,0 +1,100 @@
+package com.dalab.policyengine.repository;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import com.dalab.policyengine.model.EventSubscription;
+import com.dalab.policyengine.model.EventSubscriptionStatus;
+import com.dalab.policyengine.model.EventType;
+
+/**
+ * Repository interface for EventSubscription entities.
+ * Provides data access methods for event subscription management.
+ */
+@Repository
+public interface EventSubscriptionRepository extends JpaRepository<EventSubscription, UUID> {
+
+    /**
+     * Find all event subscriptions for a specific user
+     */
+    List<EventSubscription> findByUserId(UUID userId);
+
+    /**
+     * Find event subscriptions by user ID with pagination
+     */
+    Page<EventSubscription> findByUserId(UUID userId, Pageable pageable);
+
+    /**
+     * Find event subscriptions by status
+     */
+    List<EventSubscription> findByStatus(EventSubscriptionStatus status);
+
+    /**
+     * Find active event subscriptions for a specific user
+     */
+    List<EventSubscription> findByUserIdAndStatus(UUID userId, EventSubscriptionStatus status);
+
+    /**
+     * Find event subscriptions that monitor a specific event type
+     */
+    @Query("SELECT es FROM EventSubscription es JOIN es.eventTypes et WHERE et = :eventType AND es.status = 'ACTIVE'")
+    List<EventSubscription> findActiveSubscriptionsByEventType(@Param("eventType") EventType eventType);
+
+    /**
+     * Find event subscriptions that monitor a specific source service
+     */
+    @Query("SELECT es FROM EventSubscription es JOIN es.sourceServices ss WHERE ss = :sourceService AND es.status = 'ACTIVE'")
+    List<EventSubscription> findActiveSubscriptionsBySourceService(@Param("sourceService") String sourceService);
+
+    /**
+     * Find event subscriptions by name pattern
+     */
+    List<EventSubscription> findByNameContainingIgnoreCase(String namePattern);
+
+    /**
+     * Find event subscriptions for a user by name pattern
+     */
+    List<EventSubscription> findByUserIdAndNameContainingIgnoreCase(UUID userId, String namePattern);
+
+    /**
+     * Check if a subscription with the given name already exists for a user
+     */
+    boolean existsByUserIdAndName(UUID userId, String name);
+
+    /**
+     * Find active subscriptions that could match an event based on event type and source service
+     */
+    @Query("SELECT DISTINCT es FROM EventSubscription es " +
+           "LEFT JOIN es.eventTypes et " +
+           "LEFT JOIN es.sourceServices ss " +
+           "WHERE es.status = 'ACTIVE' " +
+           "AND (et = :eventType OR es.eventTypes IS EMPTY) " +
+           "AND (ss = :sourceService OR es.sourceServices IS EMPTY)")
+    List<EventSubscription> findPotentialMatchingSubscriptions(
+            @Param("eventType") EventType eventType, 
+            @Param("sourceService") String sourceService);
+
+    /**
+     * Count active subscriptions for a user
+     */
+    long countByUserIdAndStatus(UUID userId, EventSubscriptionStatus status);
+
+    /**
+     * Find subscriptions created by a specific user
+     */
+    List<EventSubscription> findByCreatedByUserId(UUID createdByUserId);
+
+    /**
+     * Find subscriptions with a specific notification type enabled
+     */
+    @Query("SELECT es FROM EventSubscription es WHERE jsonb_extract_path_text(CAST(es.notificationConfig AS text), :notificationType) = 'true'")
+    List<EventSubscription> findSubscriptionsWithNotificationType(@Param("notificationType") String notificationType);
+} 

src/main/java/com/dalab/policyengine/repository/PolicyDraftRepository.java

@@ -0,0 +1,169 @@
+package com.dalab.policyengine.repository;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.UUID;
+
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import com.dalab.policyengine.model.PolicyDraft;
+import com.dalab.policyengine.model.PolicyDraftStatus;
+
+/**
+ * Repository interface for PolicyDraft entities.
+ * Provides comprehensive query methods for draft management and workflow operations.
+ */
+@Repository
+public interface PolicyDraftRepository extends JpaRepository<PolicyDraft, UUID>, JpaSpecificationExecutor<PolicyDraft> {
+
+    /**
+     * Find all drafts by their current status.
+     */
+    Page<PolicyDraft> findByStatus(PolicyDraftStatus status, Pageable pageable);
+
+    /**
+     * Find all drafts created by a specific user.
+     */
+    Page<PolicyDraft> findByCreatedByUserId(UUID createdByUserId, Pageable pageable);
+
+    /**
+     * Find all drafts where the user is a stakeholder.
+     */
+    @Query("SELECT pd FROM PolicyDraft pd WHERE :userId MEMBER OF pd.stakeholders")
+    Page<PolicyDraft> findByStakeholder(@Param("userId") UUID userId, Pageable pageable);
+
+    /**
+     * Find all drafts pending review (submitted or under review).
+     */
+    @Query("SELECT pd FROM PolicyDraft pd WHERE pd.status IN ('SUBMITTED', 'UNDER_REVIEW')")
+    Page<PolicyDraft> findPendingReview(Pageable pageable);
+
+    /**
+     * Find all drafts that require attention from a specific user (created by them or they are stakeholder).
+     */
+    @Query("SELECT DISTINCT pd FROM PolicyDraft pd WHERE pd.createdByUserId = :userId OR :userId MEMBER OF pd.stakeholders")
+    Page<PolicyDraft> findRequiringAttention(@Param("userId") UUID userId, Pageable pageable);
+
+    /**
+     * Find drafts by name containing specific text (case insensitive).
+     */
+    Page<PolicyDraft> findByNameContainingIgnoreCase(String name, Pageable pageable);
+
+    /**
+     * Find drafts by category.
+     */
+    Page<PolicyDraft> findByCategory(String category, Pageable pageable);
+
+    /**
+     * Find drafts by priority level.
+     */
+    Page<PolicyDraft> findByPriority(String priority, Pageable pageable);
+
+    /**
+     * Find drafts that are based on a specific policy (updates to existing policies).
+     */
+    List<PolicyDraft> findByBasePolicyId(UUID basePolicyId);
+
+    /**
+     * Find the latest version of drafts for a specific base policy.
+     */
+    @Query("SELECT pd FROM PolicyDraft pd WHERE pd.basePolicyId = :basePolicyId ORDER BY pd.version DESC")
+    List<PolicyDraft> findLatestVersionByBasePolicyId(@Param("basePolicyId") UUID basePolicyId);
+
+    /**
+     * Find drafts with target implementation date before specified date.
+     */
+    List<PolicyDraft> findByTargetImplementationDateBefore(Instant date);
+
+    /**
+     * Find drafts created within a specific time range.
+     */
+    Page<PolicyDraft> findByCreatedAtBetween(Instant startDate, Instant endDate, Pageable pageable);
+
+    /**
+     * Find drafts that have been in a specific status for longer than specified time.
+     */
+    @Query("SELECT pd FROM PolicyDraft pd WHERE pd.status = :status AND pd.updatedAt < :cutoffTime")
+    List<PolicyDraft> findStaleInStatus(@Param("status") PolicyDraftStatus status, @Param("cutoffTime") Instant cutoffTime);
+
+    /**
+     * Find drafts containing specific tags.
+     */
+    @Query("SELECT pd FROM PolicyDraft pd WHERE :tag MEMBER OF pd.tags")
+    Page<PolicyDraft> findByTag(@Param("tag") String tag, Pageable pageable);
+
+    /**
+     * Find drafts by multiple criteria (complex search).
+     */
+    @Query("SELECT pd FROM PolicyDraft pd WHERE " +
+           "(:status IS NULL OR pd.status = :status) AND " +
+           "(:category IS NULL OR pd.category = :category) AND " +
+           "(:priority IS NULL OR pd.priority = :priority) AND " +
+           "(:createdBy IS NULL OR pd.createdByUserId = :createdBy) AND " +
+           "(:nameFilter IS NULL OR LOWER(pd.name) LIKE LOWER(CONCAT('%', :nameFilter, '%')))")
+    Page<PolicyDraft> findByCriteria(
+        @Param("status") PolicyDraftStatus status,
+        @Param("category") String category,
+        @Param("priority") String priority,
+        @Param("createdBy") UUID createdBy,
+        @Param("nameFilter") String nameFilter,
+        Pageable pageable
+    );
+
+    /**
+     * Count drafts by status.
+     */
+    long countByStatus(PolicyDraftStatus status);
+
+    /**
+     * Count drafts created by a specific user.
+     */
+    long countByCreatedByUserId(UUID createdByUserId);
+
+    /**
+     * Check if a draft name already exists (for validation).
+     */
+    boolean existsByName(String name);
+
+    /**
+     * Check if a draft name exists excluding a specific draft (for updates).
+     */
+    @Query("SELECT CASE WHEN COUNT(pd) > 0 THEN true ELSE false END FROM PolicyDraft pd WHERE pd.name = :name AND pd.id != :excludeId")
+    boolean existsByNameExcludingId(@Param("name") String name, @Param("excludeId") UUID excludeId);
+
+    /**
+     * Find all distinct categories used in drafts.
+     */
+    @Query("SELECT DISTINCT pd.category FROM PolicyDraft pd WHERE pd.category IS NOT NULL")
+    List<String> findAllCategories();
+
+    /**
+     * Find all distinct tags used in drafts.
+     */
+    @Query("SELECT DISTINCT tag FROM PolicyDraft pd JOIN pd.tags tag")
+    List<String> findAllTags();
+
+    /**
+     * Get draft statistics for dashboard.
+     */
+    @Query("SELECT pd.status, COUNT(pd) FROM PolicyDraft pd GROUP BY pd.status")
+    List<Object[]> getDraftStatisticsByStatus();
+
+    /**
+     * Get drafts summary by user.
+     */
+    @Query("SELECT pd.createdByUserId, pd.status, COUNT(pd) FROM PolicyDraft pd GROUP BY pd.createdByUserId, pd.status")
+    List<Object[]> getDraftStatisticsByUser();
+
+    /**
+     * Find overdue drafts (target implementation date passed and still not published).
+     */
+    @Query("SELECT pd FROM PolicyDraft pd WHERE pd.targetImplementationDate < :currentDate AND pd.status != 'PUBLISHED' AND pd.status != 'REJECTED' AND pd.status != 'ARCHIVED'")
+    List<PolicyDraft> findOverdueDrafts(@Param("currentDate") Instant currentDate);
+}