catocli 2.0.3__py3-none-any.whl → 2.0.5__py3-none-any.whl

schema/catolib.py

@@ -78,6 +78,11 @@ def openFile(fileName, readMode="rt"):
 ############ parsing schema ############
 
 def parseSchema(schema):
+	# Load settings to get childOperationParent and childOperationObjects configuration
+	settings = loadJSON("../settings.json")
+	childOperationParent = settings.get("childOperationParent", {})
+	childOperationObjects = settings.get("childOperationObjects", {})
+	
 	mutationOperationsTMP = {}
 	queryOperationsTMP = {}
 	for i, type in enumerate(schema["data"]["__schema"]["types"]):
@@ -94,7 +99,7 @@ def parseSchema(schema):
 		elif type["kind"] == "OBJECT":
 			if type["name"] == "Query":
 				for field in type["fields"]:
-					if field["name"] =="xdr":
+					if field["name"] in childOperationParent:
 						queryOperationsTMP[field["name"]] = copy.deepcopy(field)
 					else:
 						catoApiSchema["query"]["query."+field["name"]] = copy.deepcopy(field)
@@ -107,11 +112,11 @@ def parseSchema(schema):
 	
 	for queryType in queryOperationsTMP:
 		parentQueryOperationType = copy.deepcopy(queryOperationsTMP[queryType])
-		getChildOperations("query", parentQueryOperationType, parentQueryOperationType, "query." + queryType)
+		getChildOperations("query", parentQueryOperationType, parentQueryOperationType, "query." + queryType, childOperationObjects)
 	
 	for mutationType in mutationOperationsTMP:
 		parentMutationOperationType = copy.deepcopy(mutationOperationsTMP[mutationType])
-		getChildOperations("mutation", parentMutationOperationType, parentMutationOperationType, "mutation." + mutationType)
+		getChildOperations("mutation", parentMutationOperationType, parentMutationOperationType, "mutation." + mutationType, childOperationObjects)
 
 	for operationType in catoApiSchema:
 		for operationName in catoApiSchema[operationType]:
@@ -129,7 +134,7 @@ def parseSchema(schema):
 			payload = generateGraphqlPayload(parsedOperation["variablesPayload"],parsedOperation,operationName)
 			writeFile("../queryPayloads/"+operationName+".txt",payload["query"])
 
-def getChildOperations(operationType, curType, parentType, parentPath):
+def getChildOperations(operationType, curType, parentType, parentPath, childOperationObjects):
 	# Parse fields for nested args to map out all child operations
 	# This will separate fields like stories and story for query.xdr, 
 	# and all fields which are actually sub operations from mutation.internetFirewall, etc 
@@ -154,12 +159,14 @@ def getChildOperations(operationType, curType, parentType, parentPath):
 		parentFields = []
 		for field in curOfType["fields"]:
 			curFieldObject = copy.deepcopy(field)
-			if "args" in curFieldObject and len(curFieldObject["args"])>0:
+			if (("args" in curFieldObject and len(curFieldObject["args"])>0) or 
+				(curFieldObject["name"] in childOperationObjects) or 
+				(curOfType["name"] in childOperationObjects)):
 				hasChildren = True
 				curParentType = copy.deepcopy(parentType)
 				curFieldObject["args"] = getNestedArgDefinitions(curFieldObject["args"], curFieldObject["name"],None,None)
 				curParentType["childOperations"][curFieldObject["name"]] = curFieldObject
-				getChildOperations(operationType, curFieldObject, curParentType, parentPath + "." + curFieldObject["name"])
+				getChildOperations(operationType, curFieldObject, curParentType, parentPath + "." + curFieldObject["name"], childOperationObjects)
 	if not hasChildren:
 		catoApiSchema[operationType][parentPath] = parentType
 

schema/remove_policyid.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+
+import json
+import glob
+import os
+import sys
+
+def remove_policy_id_from_object(obj, path=""):
+    """
+    Recursively remove policyId fields from a JSON object.
+    """
+    if isinstance(obj, dict):
+        # Remove policyId field if it exists
+        if "policyId" in obj:
+            print(f"Removing policyId field at path: {path}")
+            del obj["policyId"]
+        
+        # Recursively process all other fields
+        for key, value in obj.items():
+            new_path = f"{path}.{key}" if path else key
+            remove_policy_id_from_object(value, new_path)
+    
+    elif isinstance(obj, list):
+        # Process each item in the list
+        for i, item in enumerate(obj):
+            new_path = f"{path}[{i}]" if path else f"[{i}]"
+            remove_policy_id_from_object(item, new_path)
+
+def process_file(file_path):
+    """
+    Process a single JSON file to remove policyId fields.
+    """
+    print(f"Processing file: {file_path}")
+    
+    try:
+        # Read the JSON file
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        
+        # Remove policyId fields
+        remove_policy_id_from_object(data, os.path.basename(file_path))
+        
+        # Write the modified JSON back to the file
+        with open(file_path, 'w') as f:
+            json.dump(data, f, indent=4, sort_keys=True)
+        
+        print(f"Successfully processed: {file_path}")
+        
+    except Exception as e:
+        print(f"Error processing {file_path}: {e}")
+        return False
+    
+    return True
+
+def main():
+    # Get the directory where this script is located
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    base_dir = os.path.dirname(script_dir)  # Go up one level to cato-cli directory
+    
+    # Find all query.policy*.json files in the models directory
+    models_dir = os.path.join(base_dir, "models")
+    pattern = os.path.join(models_dir, "query.policy*.json")
+    
+    files = glob.glob(pattern)
+    
+    if not files:
+        print("No query.policy*.json files found!")
+        return 1
+    
+    print(f"Found {len(files)} files to process:")
+    for file in files:
+        print(f"  - {os.path.basename(file)}")
+    
+    # Process each file
+    success_count = 0
+    for file_path in files:
+        if process_file(file_path):
+            success_count += 1
+    
+    print(f"\nProcessing complete!")
+    print(f"Successfully processed: {success_count}/{len(files)} files")
+    
+    if success_count != len(files):
+        return 1
+    
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())

schema/remove_policyid_mutations.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+
+import json
+import os
+import glob
+
+def remove_policy_id_recursive(obj, path=""):
+    """
+    Recursively remove all 'policyId' keys from a JSON object.
+    Returns the number of removals made.
+    """
+    removals = 0
+    
+    if isinstance(obj, dict):
+        # Create a list of keys to remove to avoid modifying dict during iteration
+        keys_to_remove = []
+        for key in obj.keys():
+            if key == "policyId":
+                keys_to_remove.append(key)
+                current_path = f"{path}.{key}" if path else key
+                print(f"  Removing policyId at: {current_path}")
+                removals += 1
+        
+        # Remove the policyId keys
+        for key in keys_to_remove:
+            del obj[key]
+        
+        # Recursively process remaining values
+        for key, value in obj.items():
+            current_path = f"{path}.{key}" if path else key
+            removals += remove_policy_id_recursive(value, current_path)
+    
+    elif isinstance(obj, list):
+        for i, item in enumerate(obj):
+            current_path = f"{path}[{i}]" if path else f"[{i}]"
+            removals += remove_policy_id_recursive(item, current_path)
+    
+    return removals
+
+def process_mutation_policy_files():
+    """
+    Find and process all mutation.policy*.json files in the models directory.
+    """
+    models_dir = "/Users/briananderson/Documents/Dev/github.com/catonetworks/cato-cli/models"
+    pattern = os.path.join(models_dir, "mutation.policy*.json")
+    
+    files = glob.glob(pattern)
+    
+    if not files:
+        print("No mutation.policy*.json files found!")
+        return
+    
+    print(f"Found {len(files)} mutation.policy*.json files to process:")
+    
+    total_removals = 0
+    processed_files = 0
+    
+    for file_path in sorted(files):
+        filename = os.path.basename(file_path)
+        print(f"\nProcessing: {filename}")
+        
+        try:
+            # Read the JSON file
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            # Remove policyId fields
+            removals = remove_policy_id_recursive(data, filename)
+            
+            if removals > 0:
+                # Write back the modified JSON
+                with open(file_path, 'w', encoding='utf-8') as f:
+                    json.dump(data, f, indent=4, ensure_ascii=False)
+                
+                print(f"  Removed {removals} policyId field(s)")
+                total_removals += removals
+                processed_files += 1
+            else:
+                print("  No policyId fields found")
+                
+        except Exception as e:
+            print(f"  Error processing {filename}: {e}")
+    
+    print(f"\n=== Summary ===")
+    print(f"Files processed: {processed_files}")
+    print(f"Total policyId fields removed: {total_removals}")
+
+if __name__ == "__main__":
+    process_mutation_policy_files()