1 files changed, 174 insertions, 41 deletions
diff --git a/pkg/utils/utils.go b/pkg/utils/utils.go
index 23f9cfe..fba1fb1 100644
--- a/pkg/utils/utils.go
+++ b/pkg/utils/utils.go
@@ -16,7 +16,7 @@
 //   SPDX-License-Identifier: Apache-2.0
 //   ========================LICENSE_END===================================
 
-// Package utils provides common  functionalities
+// Package provides common  functionalities
 
 package utils
 
@@ -30,6 +30,7 @@ import (
 	"policy-opa-pdp/consts"
 	"policy-opa-pdp/pkg/log"
 	"policy-opa-pdp/pkg/model"
+	"policy-opa-pdp/pkg/model/oapicodegen"
 	"regexp"
 	"strings"
 	"time"
@@ -41,6 +42,7 @@ type (
 
 var (
 	CreateDirectoryVar CreateDirectoryFunc = CreateDirectory
+	removeAll                              = os.RemoveAll
 )
 
 // validates if the given request is in valid uuid form
@@ -63,42 +65,60 @@ func CreateDirectory(dirPath string) error {
 // Helper function to check and remove a directory
 func RemoveDirectory(dirPath string) error {
 
-	entries, err := os.ReadDir(dirPath)
+	fileDirPath := filepath.Clean(dirPath)
+	err := removeAll(fileDirPath)
 	if err != nil {
 		if os.IsNotExist(err) {
-			log.Warnf("Directory does not exist: %s", dirPath)
+			log.Warnf("Directory does not exist: %s", fileDirPath)
 			// Directory does not exist, nothing to do
 			return nil
 		}
-		return fmt.Errorf("failed to read directory: %w", err)
+		return fmt.Errorf("failed to remove file: %s, error: %w", fileDirPath, err)
+
 	}
 
-	for _, entry := range entries {
-		entryPath := filepath.Join(dirPath, entry.Name())
+	// Create a loop to check parent directories.
+	// Move to the parent directory
+	currentPath := filepath.Clean(filepath.Dir(dirPath))
+	for {
+		// Check if we have reached the match path
+		if currentPath == filepath.Clean(consts.DataNode) || currentPath == filepath.Clean(consts.Policies) {
+			return nil // Stop if we reach the match path
+		}
 
-		if entry.IsDir() {
-			// Check if the subdirectory is empty and delete it
-			isEmpty, err := isDirEmpty(entryPath)
-			if err != nil {
-				return err
-			}
-			if isEmpty {
-				log.Debugf("Removing empty subdirectory: %s", entryPath)
-				if err := os.RemoveAll(entryPath); err != nil {
-					return fmt.Errorf("failed to remove directory: %s, error: %w", entryPath, err)
-				}
-			}
-		} else {
-			// Delete specific files in the parent directory
-			if entry.Name() == "data.json" || entry.Name() == "policy.rego" {
-				log.Debugf("Removing file: %s", entryPath)
-				if err := os.Remove(entryPath); err != nil {
-					return fmt.Errorf("failed to remove file: %s, error: %w", entryPath, err)
-				}
-			}
+		if currentPath == "/" || currentPath == "." {
+			log.Infof("Reached root orelative path: %s", currentPath)
+			return nil // Stop if we reach the match path
+		}
+		log.Infof("Processig Parent dir : %s", currentPath)
+		// Check if the parent directory exists before proceeding
+		if _, err := os.Stat(currentPath); os.IsNotExist(err) {
+			log.Debugf("directory does not exist: %s. Stopping iteration.", currentPath)
+			return nil // Stop if we can't find the parent path
+		}
+		// Clean the parent directory
+		err = isSubDirEmpty(currentPath)
+		if err != nil {
+			return err
 		}
+
+		// Move to the parent directory
+		currentPath = filepath.Dir(currentPath)
 	}
+}
 
+func isSubDirEmpty(entryPath string) error {
+
+	isEmpty, err := isDirEmpty(entryPath)
+	if err != nil {
+		return err
+	}
+	if isEmpty {
+		log.Debugf("Removing empty subdirectory: %s", entryPath)
+		if err := removeAll(entryPath); err != nil {
+			return fmt.Errorf("failed to remove directory: %s, error: %w", entryPath, err)
+		}
+	}
 	return nil
 }
 
@@ -144,7 +164,7 @@ func ValidateToscaPolicyJsonFields(policy model.ToscaPolicy) error {
 				return fmt.Errorf("duplicate data key '%s' found, '%s'", key, emphasize)
 			}
 			keySeen[key] = true
-			if !strings.HasPrefix(key, "node." + policy.Name) {
+			if !strings.HasPrefix(key, "node."+policy.Name) {
 				return fmt.Errorf("data key '%s' does not have name node.'%s' as a prefix, '%s'", key, policy.Name, emphasize)
 			}
 		}
@@ -289,24 +309,27 @@ func IsValidCurrentTime(currentTime *string) bool {
 }
 
 // Custom validation function for *string type eg: OnapComponent, OnapInstance, OnapName, PolicyName
-func IsValidString(name *string) bool {
-	if name == nil || strings.TrimSpace(*name) == "" {
-		return false
-	} else {
-		return true
+func IsValidString(name interface{}) bool {
+	switch v := name.(type) {
+	case *string:
+		return v != nil && strings.TrimSpace(*v) != ""
+	case string:
+		return strings.TrimSpace(v) != ""
+	default:
+		return false // Handles cases where name is neither a string nor a *string
 	}
 }
 
 func BuildBundle(cmdFunc func(string, ...string) *exec.Cmd) (string, error) {
-     cmd := cmdFunc(
-         consts.Opa,
-         consts.BuildBundle,
-         consts.V1_COMPATIBLE,
-         consts.Policies,
-         consts.Data,
-         consts.Output,
-         consts.BundleTarGzFile,
-     )
+	cmd := cmdFunc(
+		consts.Opa,
+		consts.BuildBundle,
+		consts.V1Compatible,
+		consts.Policies,
+		consts.Data,
+		consts.Output,
+		consts.BundleTarGzFile,
+	)
 	log.Debugf("Before calling combinedoutput")
 	output, err := cmd.CombinedOutput()
 
@@ -318,3 +341,113 @@ func BuildBundle(cmdFunc func(string, ...string) *exec.Cmd) (string, error) {
 	log.Debug("Bundle Built Sucessfully....")
 	return string(output), nil
 }
+
+// Validation function
+func ValidateOPADataRequest(request interface{}) []string {
+	var validationErrors []string
+	if updateRequest, ok := request.(*oapicodegen.OPADataUpdateRequest); ok {
+		if updateRequest == nil { // Check if updateRequest is nil
+			validationErrors = append(validationErrors, "OPADataUpdateRequest is nil")
+			return validationErrors // Return if the request is nil
+		}
+		// Check if required fields are populated
+		if updateRequest.CurrentDate != nil {
+			dateString := updateRequest.CurrentDate.String()
+			if !IsValidCurrentDate(&dateString) {
+				validationErrors = append(validationErrors, "CurrentDate is invalid")
+			}
+		} else {
+			validationErrors = append(validationErrors, "CurrentDate is required")
+		}
+
+		// Validate CurrentDateTime format
+		if !(IsValidTime(updateRequest.CurrentDateTime)) {
+			validationErrors = append(validationErrors, "CurrentDateTime is invalid or missing")
+		}
+
+		// Validate CurrentTime format
+		if !(IsValidCurrentTime(updateRequest.CurrentTime)) {
+			validationErrors = append(validationErrors, "CurrentTime is invalid or missing")
+		}
+
+		// Validate TimeOffset format (e.g., +02:00 or -05:00)
+		if !(IsValidTimeOffset(updateRequest.TimeOffset)) {
+			validationErrors = append(validationErrors, "TimeOffset is invalid or missing")
+		}
+
+		// Validate TimeZone format (e.g., 'America/New_York')
+		if !(IsValidTimeZone(updateRequest.TimeZone)) {
+			validationErrors = append(validationErrors, "TimeZone is invalid or missing")
+		}
+
+		// Optionally, check if 'OnapComponent', 'OnapInstance', 'OnapName', and 'PolicyName' are provided
+		if !(IsValidString(updateRequest.OnapComponent)) {
+			validationErrors = append(validationErrors, "OnapComponent is required")
+		}
+
+		if !(IsValidString(updateRequest.OnapInstance)) {
+			validationErrors = append(validationErrors, "OnapInstance is required")
+		}
+
+		if !(IsValidString(updateRequest.OnapName)) {
+			validationErrors = append(validationErrors, "OnapName is required")
+		}
+
+		if !(IsValidString(updateRequest.PolicyName)) {
+			validationErrors = append(validationErrors, "PolicyName is required and cannot be empty")
+		}
+	}
+
+	if decisionRequest, ok := request.(*oapicodegen.OPADecisionRequest); ok {
+
+		if decisionRequest == nil { // Check if decisionRequest is nil
+			validationErrors = append(validationErrors, "OPADecisionRequest is nil")
+			return validationErrors // Return if the request is nil
+		}
+		// Check if required fields are populated
+		if decisionRequest.CurrentDate != nil {
+			dateString := decisionRequest.CurrentDate.String()
+			if !IsValidCurrentDate(&dateString) {
+				validationErrors = append(validationErrors, "CurrentDate is invalid")
+			}
+		}
+
+		// Validate CurrentDateTime format
+		if (decisionRequest.CurrentDateTime != nil) && !(IsValidTime(decisionRequest.CurrentDateTime)) {
+			validationErrors = append(validationErrors, "CurrentDateTime is invalid or missing")
+		}
+
+		// Validate CurrentTime format
+		if (decisionRequest.CurrentTime != nil) && !(IsValidCurrentTime(decisionRequest.CurrentTime)) {
+			validationErrors = append(validationErrors, "CurrentTime is invalid or missing")
+		}
+
+		// Validate TimeOffset format (e.g., +02:00 or -05:00)
+		if (decisionRequest.TimeOffset != nil) && !(IsValidTimeOffset(decisionRequest.TimeOffset)) {
+			validationErrors = append(validationErrors, "TimeOffset is invalid or missing")
+		}
+
+		// Validate TimeZone format (e.g., 'America/New_York')
+		if (decisionRequest.TimeZone != nil) && !(IsValidTimeZone(decisionRequest.TimeZone)) {
+			validationErrors = append(validationErrors, "TimeZone is invalid or missing")
+		}
+
+		// Optionally, check if 'OnapComponent', 'OnapInstance', 'OnapName', and 'PolicyName' are provided
+		if (decisionRequest.OnapComponent != nil) && !(IsValidString(decisionRequest.OnapComponent)) {
+			validationErrors = append(validationErrors, "OnapComponent is required")
+		}
+
+		if (decisionRequest.OnapInstance != nil) && !(IsValidString(decisionRequest.OnapInstance)) {
+			validationErrors = append(validationErrors, "OnapInstance is required")
+		}
+
+		if (decisionRequest.OnapName != nil) && !(IsValidString(decisionRequest.OnapName)) {
+			validationErrors = append(validationErrors, "OnapName is required")
+		}
+
+		if !(IsValidString(decisionRequest.PolicyName)) {
+			validationErrors = append(validationErrors, "PolicyName is required and cannot be empty")
+		}
+	}
+	return validationErrors
+}