Update app.py

app.py

@@ -1,5 +1,9 @@
 import requests
 import yaml
+import json
+import zipfile
+import io
+import tempfile
 from identityNow import handle_identitynow_call
 from okta import handle_okta_call
 from iiq import handle_iiq_call
@@ -8,6 +12,7 @@ import gradio as gr
 import os
 from dotenv import load_dotenv
 from pathlib import Path
+from api_schema_generatorV5 import ApiSchemaGeneratorV5
 
 # Load environment variables
 script_dir = Path(__file__).resolve().parent
@@ -29,7 +34,7 @@ def fetch_api_endpoints_yaml(spec_url):
         print("No endpoints found in the specification.")
         return {}
     
-    valid_methods = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options']
+    valid_methods = ['get', 'post']  # Only process GET and POST endpoints
     for path, methods in api_spec["paths"].items():
         endpoints[path] = {}
         if not methods or not isinstance(methods, dict):
@@ -64,7 +69,7 @@ def fetch_api_endpoints_json(spec_url):
         print("No endpoints found in the specification.")
         return {}
     
-    valid_methods = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options']
+    valid_methods = ['get', 'post']  # Only process GET and POST endpoints
     for path, methods in api_spec["paths"].items():
         endpoints[path] = {}
         if not methods or not isinstance(methods, dict):
@@ -85,7 +90,15 @@ def fetch_api_endpoints_json(spec_url):
             endpoints[path][method.lower()] = endpoint_info
     return endpoints
 
-def get_endpoints(spec_choice):
+def get_endpoints(spec_choice, base_url=None):
+    # If base_url is provided, use it directly
+    if base_url:
+        spec_url = base_url
+        if "JSON" in spec_choice:
+            return fetch_api_endpoints_json(spec_url), spec_url
+        return fetch_api_endpoints_yaml(spec_url), spec_url
+    
+    # Otherwise, try to use environment variables as fallback
     api_spec_options = {
         "Okta (JSON)": os.getenv("OKTA_API_SPEC"),
         "SailPoint IdentityNow (YAML)": os.getenv("IDENTITY_NOW_API_SPEC"),
@@ -93,166 +106,119 @@ def get_endpoints(spec_choice):
     }
     spec_url = api_spec_options.get(spec_choice)
     if not spec_url:
-        return {}
+        print(f"No API specification URL found for {spec_choice}")
+        return {}, None
+    
     if "JSON" in spec_choice:
-        return fetch_api_endpoints_json(spec_url)
-    return fetch_api_endpoints_yaml(spec_url)
+        return fetch_api_endpoints_json(spec_url), spec_url
+    return fetch_api_endpoints_yaml(spec_url), spec_url
 
-def group_endpoints(endpoints, spec_choice):
+def group_endpoints(endpoints, spec_choice, endpoint_type='get'):
+    """Group endpoints by their first path segment, filtering by endpoint type"""
     groups = {}
-    if spec_choice == "Okta (JSON)":
-        for path, methods in endpoints.items():
-            clean_path = path.replace('/api/v1/', '')
-            segments = clean_path.strip("/").split("/")
-            group_key = segments[0] if segments else "other"
-            if group_key not in groups:
-                groups[group_key] = {}
-            groups[group_key][path] = methods
+    if endpoint_type == 'all':
+        # For 'all' type, include all endpoints regardless of method
+        if spec_choice == "Okta (JSON)":
+            for path, methods in endpoints.items():
+                clean_path = path.replace('/api/v1/', '')
+                segments = clean_path.strip("/").split("/")
+                group_key = segments[0] if segments else "other"
+                if group_key not in groups:
+                    groups[group_key] = {}
+                groups[group_key][path] = methods
+        else:
+            for path, methods in endpoints.items():
+                segments = path.strip("/").split("/")
+                group_key = segments[0] if segments[0] != "" else "other"
+                if group_key not in groups:
+                    groups[group_key] = {}
+                groups[group_key][path] = methods
     else:
-        for path, methods in endpoints.items():
-            segments = path.strip("/").split("/")
-            group_key = segments[0] if segments[0] != "" else "other"
-            if group_key not in groups:
-                groups[group_key] = {}
-            groups[group_key][path] = methods
-    return groups
-
-def verify_credentials(spec_choice, api_base_url, grant_type=None, client_id=None, 
-                      client_secret=None, api_token=None, iiq_username=None, iiq_password=None):
-    if not api_base_url or not api_base_url.strip():
-        return (
-            gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> API Base URL is required</div>", visible=True),
-            False,
-            False
-        )
-
-    try:
+        # For specific method types (get, post)
         if spec_choice == "Okta (JSON)":
-            if not api_token or not api_token.strip():
-                return (
-                    gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> API Token is required</div>", visible=True),
-                    False,
-                    False
-                )
-            result = handle_okta_call(api_base_url, api_token, "", {}, ["/api/v1/users/me"])
-            
-            if isinstance(result[0], dict) and "/api/v1/users/me" in result[0]:
-                response = result[0]["/api/v1/users/me"]
-                
-                if isinstance(response, str) and response.startswith("Error:"):
-                    return (
-                        gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Please check your credentials and try again</div>", visible=True),
-                        False,
-                        False
-                    )
-                
-                if isinstance(response, dict) and "error" in response:
-                    return (
-                        gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Please check your credentials and try again</div>", visible=True),
-                        False,
-                        False
-                    )
-            else:
-                return (
-                    gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Please check your credentials and try again</div>", visible=True),
-                    False,
-                    False
-                )
-
-        elif spec_choice == "SailPoint IdentityNow (YAML)":
-            if not all([grant_type and grant_type.strip(), client_id and client_id.strip(), client_secret and client_secret.strip()]):
-                return (
-                    gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> All IdentityNow credentials are required</div>", visible=True),
-                    False,
-                    False
-                )
-            result = handle_identitynow_call(api_base_url, grant_type, client_id, client_secret, "", {}, ["/accounts"])
-            
-            if isinstance(result[0], dict):
-                if "error" in result[0]:
-                    return (
-                        gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Please check your credentials and try again</div>", visible=True),
-                        False,
-                        False
-                    )
-                
-                if "accounts" in result[0]:
-                    response = result[0]["accounts"]
-                    if isinstance(response, str) and response.startswith("Error:"):
-                        return (
-                            gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Please check your credentials and try again</div>", visible=True),
-                            False,
-                            False
-                        )
-                    if isinstance(response, dict) and "error" in response:
-                        return (
-                            gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Please check your credentials and try again</div>", visible=True),
-                            False,
-                            False
-                        )
-            else:
-                return (
-                    gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Please check your credentials and try again</div>", visible=True),
-                    False,
-                    False
-                )
-
-        elif spec_choice == "Sailpoint IIQ (YAML)":
-            if not all([iiq_username and iiq_username.strip(), iiq_password and iiq_password.strip()]):
-                return (
-                    gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Both IIQ username and password are required</div>", visible=True),
-                    False,
-                    False
-                )
-            result = handle_iiq_call(api_base_url, iiq_username, iiq_password, "", {}, ["/ping"])
-            
-            if isinstance(result[0], dict):
-                if "error" in result[0]:
-                    return (
-                        gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Please check your credentials and try again</div>", visible=True),
-                        False,
-                        False
-                    )
-                
-                if "/ping" in result[0]:
-                    response = result[0]["/ping"]
-                    if isinstance(response, str) and response.startswith("Error:"):
-                        return (
-                            gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Please check your credentials and try again</div>", visible=True),
-                            False,
-                            False
-                        )
-                    if isinstance(response, dict) and "error" in response:
-                        return (
-                            gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Please check your credentials and try again</div>", visible=True),
-                            False,
-                            False
-                        )
-            else:
-                return (
-                    gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Please check your credentials and try again</div>", visible=True),
-                    False,
-                    False
-                )
+            for path, methods in endpoints.items():
+                if endpoint_type not in methods:
+                    continue
+                    
+                clean_path = path.replace('/api/v1/', '')
+                segments = clean_path.strip("/").split("/")
+                group_key = segments[0] if segments else "other"
+                if group_key not in groups:
+                    groups[group_key] = {}
+                groups[group_key][path] = methods
+        else:
+            for path, methods in endpoints.items():
+                if endpoint_type not in methods:
+                    continue
+                    
+                segments = path.strip("/").split("/")
+                group_key = segments[0] if segments[0] != "" else "other"
+                if group_key not in groups:
+                    groups[group_key] = {}
+                groups[group_key][path] = methods
+    return groups
 
-        return (
-            gr.update(value="<div class='success-message'><i class='fas fa-check-circle'></i> Credentials verified successfully!</div>", visible=True),
-            True,
-            True
-        )
+def generate_schema_files(api_choice_val, selected_endpoints, api_spec_url, custom_name=None):
+    """Generate JSON and XML schema files for selected endpoints"""
+    # Determine API name based on choice
+    if api_choice_val == "Others" and custom_name:
+        api_name = custom_name.lower().replace(" ", "_")
+    else:
+        api_name = api_choice_val.split(" (")[0].lower().replace(" ", "_")
+    
+    # Debug print to verify api_spec_url is not empty
+    print(f"API Choice: {api_choice_val}")
+    print(f"API Spec URL: {api_spec_url}")
+    print(f"Selected endpoints count: {len(selected_endpoints)}")
+    print(f"Using API name: {api_name}")
+    
+    # Create schema generator with path+method pairs
+    generator = ApiSchemaGeneratorV5(api_spec_url, api_name=api_name, selected_endpoints=selected_endpoints)
+    
+    # Generate files in memory
+    meta_data = generator.generate_datasource_plugin_meta()
+    schema_xml = generator.generate_default_schema()
+    
+    # Create JSON string
+    json_str = json.dumps(meta_data, indent=2)
+    
+    # Create a zip file in memory
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        zip_file.writestr(f"{api_name}_datasource_plugin_meta.json", json_str)
+        zip_file.writestr(f"{api_name}_default_schema.orx", schema_xml)
+    
+    zip_buffer.seek(0)
+    
+    # Return both the individual files and the zip
+    return {
+        "json": json_str,
+        "xml": schema_xml,
+        "zip": zip_buffer
+    }
 
-    except requests.exceptions.ConnectionError:
-        return (
-            gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Please check your credentials and try again</div>", visible=True),
-            False,
-            False
-        )
-    except Exception as e:
-        return (
-            gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> Please check your credentials and try again</div>", visible=True),
-            False,
-            False
-        )
+def update_api_url(api_choice_val):
+    global current_api_spec_url
+    
+    if api_choice_val == "Others":
+        # For "Others", we don't set a URL yet - user will input it
+        current_api_spec_url = ""
+        return gr.update(visible=True), gr.update(value=""), gr.update(value="")
+    
+    # Get URL from environment variables
+    api_spec_options = {
+        "Okta (JSON)": os.getenv("OKTA_API_SPEC"),
+        "SailPoint IdentityNow (YAML)": os.getenv("IDENTITY_NOW_API_SPEC"),
+        "Sailpoint IIQ (YAML)": os.getenv("IIQ_API_SPEC")
+    }
+    
+    url = api_spec_options.get(api_choice_val, "")
+    print(f"Setting API spec URL to: {url}")  # Debug print
+    
+    # Update the global variable
+    current_api_spec_url = url
+    
+    return gr.update(visible=False), gr.update(value=url), gr.update(value=url)  # Update both text field and state
 
 # ----------------------------- CSS -----------------------------
 custom_css = """
@@ -351,6 +317,27 @@ body, .gradio-container {
     margin: 20px auto;
 }
 
+.loading-text {
+    color: black;
+    font-size: 24px;
+    font-weight: bold;
+    margin-top: 20px;
+    text-shadow: 1px 1px 3px rgba(0, 0, 0, 0.8);
+}
+
+.fetch-loading-indicator {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    height: 100px;
+}
+
+.fetch-loading-indicator .loading-spinner {
+    border-width: 6px;
+    width: 50px;
+    height: 50px;
+}
+
 @keyframes spin {
     0% { transform: rotate(0deg); }
     100% { transform: rotate(360deg); }
@@ -520,6 +507,31 @@ body, .gradio-container {
     height: 50px;
 }
 
+.endpoint-type-selector {
+    margin-bottom: 20px;
+    padding: 15px;
+    background: #333333;
+    border-radius: 8px;
+    border: 1px solid #ddd;
+}
+
+.endpoint-type-selector label {
+    color: white !important;
+    font-weight: bold !important;
+    font-size: 18px !important;
+}
+
+.endpoint-type-selector > .block > label:first-child {
+    color: #000000;
+    font-weight: 700;
+    font-size: 18px;
+}
+
+.endpoint-type-selector .gr-radio-group label {
+    color: white;
+    font-weight: 500;
+}
+
 @keyframes fadeIn {
     from { opacity: 0; }
     to { opacity: 1; }
@@ -598,83 +610,59 @@ body, .gradio-container {
 """
 
 with gr.Blocks(css=custom_css) as demo:
-    user_guide_html = """
+    gr.HTML("<div class='banner'>Data Connector Demo</div>")
+    
+    # User Guide Modal
+    user_guide_html = gr.HTML("""
 <div id="user-guide-overlay" class="user-guide-overlay"></div>
 <div id="user-guide-modal" class="user-guide-modal">
   <h2>Data Connector - User Guide</h2>
-  <p>Welcome to Data Connector, a tool that helps you easily extract and explore data from any api platform without writing any code, but that functionality is coming soon for a demo we have locked it for 3 api's.</p>
+  <p>Welcome to Data Connector, a tool that helps you easily extract and explore data from any API platform and generate schema files.</p>
 
   <h3>Getting Started</h3>
   <p><strong>Step 1: Select an API Platform</strong><br/>
   Click on one of the three available platforms:<br/>
   Okta: For Okta Identity Cloud data<br/>
   SailPoint IdentityNow: For cloud-based identity governance data<br/>
-  SailPoint IIQ: For on-premise identity governance data</p>
-
-  <p><strong>Step 2: Enter Connection Credentials</strong><br/>
-  Depending on your selection, enter the required credentials:<br/>
-  <strong style="color: #0056b3; font-weight: 600;">For Okta:</strong><br/>
-  API Base URL: Your Okta domain (e.g., https://your-company.okta.com)<br/>
-  API Token: Your Okta API token<br/>
-  <strong style="color: #0056b3; font-weight: 600;">For SailPoint IdentityNow:</strong><br/>
-  API Base URL: Your IdentityNow tenant URL (e.g., https://your-tenant.api.identitynow.com)<br/>
-  Grant Type: Leave as "client_credentials" (default)<br/>
-  Client ID: Your OAuth client ID<br/>
-  Client Secret: Your OAuth client secret<br/>
-  <strong style="color: #0056b3; font-weight: 600;">For SailPoint IIQ:</strong><br/>
-  API Base URL: Your IIQ server URL (e.g., https://your-iiq-server.com/identityiq)<br/>
-  Username: Your IIQ username with API access<br/>
-  Password: Your IIQ password</p>
-
-  <p><strong>Step 3: Verify Credentials</strong><br/>
-  Click the "Verify Credentials" button<br/>
-  Wait for the connection test to complete<br/>
-  A green success message will appear if verification succeeds<br/>
-  If verification fails, check your credentials and connection details</p>
-
-  <p><strong>Step 4: Browse and Select Endpoints</strong><br/>
-  After successful verification, you'll see API endpoints grouped by category<br/>
+  SailPoint IIQ: For on-premise identity governance data<br/>
+  Others: For custom API specifications</p>
+
+  <p><strong>Step 2: Enter API Specification URL</strong><br/>
+  Enter the URL for the API specification (OpenAPI/Swagger) for your selected platform.</p>
+
+  <p><strong>Step 3: Load API Specification</strong><br/>
+  Click the "Load API Specification" button to fetch and parse the API endpoints.</p>
+
+  <p><strong>Step 4: Select Endpoint Type</strong><br/>
+  Choose between GET or POST endpoints to display.</p>
+
+  <p><strong>Step 5: Browse and Select Endpoints</strong><br/>
+  After loading, you'll see API endpoints grouped by category<br/>
   Click on any category to expand it and see available endpoints<br/>
-  Select the checkboxes next to the endpoints you want to query<br/>
-  You can select multiple endpoints across different categories<br/>
-  Click the "Continue" button when you've finished selecting</p>
-
-  <p><strong>Step 5: Enter Parameters (if required)</strong><br/>
-  Some endpoints require additional parameters<br/>
-  If parameters are needed, input fields will appear<br/>
-  Fill in all required parameters (marked with 🔑 or 🔍)<br/>
-  Path parameters (🔑) are part of the URL path<br/>
-  Query parameters (🔍) filter or modify the results</p>
-
-  <p><strong>Step 6: Fetch Data</strong><br/>
-  Click the "Fetch Data" button<br/>
-  Wait while the application contacts the API(s)<br/>
-  A loading indicator will appear during this process</p>
+  Select the checkboxes next to the endpoints you want to include<br/>
+  You can select multiple endpoints across different categories</p>
+
+  <p><strong>Step 6: Generate Schema</strong><br/>
+  Click the "Generate Schema" button to create schema files based on your selected endpoints.</p>
 
   <p><strong>Step 7: View and Download Results</strong><br/>
-  Results will display in JSON format in the "Results" section<br/>
-  Review the data returned from each endpoint<br/>
-  Click the download button to save all data as a ZIP file<br/>
-  The ZIP file contains all responses plus metadata about your session</p>
+  Results will display in both JSON and XML formats<br/>
+  Review the generated schema files<br/>
+  Click the download button to save all files as a ZIP file</p>
 
   <h3>Tips and Troubleshooting</h3>
   <ul>
-    <li><strong>API Base URLs:</strong> Always include the full URL with https:// prefix</li>
-    <li><strong>Connection Issues:</strong> Check your network connection and VPN settings if applicable</li>
-    <li><strong>Authorization Errors:</strong> Verify that your credentials have the proper permissions</li>
-    <li><strong>Parameter Format:</strong> Some parameters may require specific formats (UUIDs, dates, etc.)</li>
-    <li><strong>Session Persistence:</strong> Your data is saved locally during the session for download later</li>
+    <li><strong>API Specification URLs:</strong> Always include the full URL with https:// prefix</li>
+    <li><strong>No Endpoints Found:</strong> Check that the API specification is valid and accessible</li>
+    <li><strong>Schema Generation:</strong> Make sure to select at least one endpoint before generating schemas</li>
   </ul>
 
-  <h3>Data Security Note</h3>
-  <p>This application processes but does not store your credentials permanently. All data is saved temporarily on your device and can be downloaded as a ZIP file.</p>
-
   <h3>Need Help?</h3>
-  <p>If you need assistance or encounter issues, refer to the official API documentation for detailed guidance and instructions on obtaining the necessary credentials:</p>
+  <p>If you need assistance or encounter issues, refer to the official API documentation for detailed guidance:</p>
   <ul>
-    <li><strong>SailPoint IdentityNow:</strong> <a href="https://developer.sailpoint.com/docs/api/v3/identity-security-cloud-v-3-api" target="_blank">Identity Security Cloud V3 API</a> - Find details on API endpoints and how to generate Client ID and Client Secret.</li>
-    <li><strong>SailPoint IIQ:</strong> <a href="https://developer.sailpoint.com/docs/api/iiq/identityiq-scim-rest-api/" target="_blank">IdentityIQ SCIM REST API</a> - Learn about API usage and how to set up username and password for API access.</li>
-    <li><strong>Okta:</strong> <a href="https://developer.okta.com/docs/reference/core-okta-api/" target="_blank">Core Okta API</a> - Instructions for creating an API token and using the Okta API.</li>
+    <li><strong>SailPoint IdentityNow:</strong> <a href="https://developer.sailpoint.com/docs/api/v3/identity-security-cloud-v-3-api" target="_blank">Identity Security Cloud V3 API</a></li>
+    <li><strong>SailPoint IIQ:</strong> <a href="https://developer.sailpoint.com/docs/api/iiq/identityiq-scim-rest-api/" target="_blank">IdentityIQ SCIM REST API</a></li>
+    <li><strong>Okta:</strong> <a href="https://developer.okta.com/docs/reference/core-okta-api/" target="_blank">Core Okta API</a></li>
   </ul>
 
   <p><strong style="color: #222222; font-style: italic;">You can always access these instructions any time by clicking on the "User Guide" button.</strong></p>
@@ -711,54 +699,91 @@ with gr.Blocks(css=custom_css) as demo:
 >
   User Guide
 </button>
-"""
-    user_guide_modal = gr.HTML(user_guide_html, visible=True)
+""", visible=True)
 
-    gr.HTML("<div class='banner'>Data Connector Demo</div>")
-
-    session_id_state = gr.State("")
+    # State variables
     locked_endpoints_state = gr.State([])
+    endpoint_type_state = gr.State("get")  # Default to GET endpoints
+    api_spec_url_state = gr.State("")
     required_params_count = gr.State(0)
 
+    # API selection with card-style UI
     api_options = [
         {"icon": "fa-cloud", "title": "Okta", "description": "Identity and Access Management", "value": "Okta (JSON)"},
         {"icon": "fa-user-shield", "title": "SailPoint IdentityNow", "description": "Cloud Identity Governance", "value": "SailPoint IdentityNow (YAML)"},
         {"icon": "fa-network-wired", "title": "Sailpoint IIQ", "description": "On-premise Identity Governance", "value": "Sailpoint IIQ (YAML)"},
+        {"icon": "fa-cogs", "title": "Other", "description": "Custom API Specification", "value": "Others"}
     ]
+    
+    # Create a radio button with custom styling to look like cards
     choices = [(opt["title"], opt["value"]) for opt in api_options]
-    api_choice = gr.Radio(choices=choices, label="", type="value", elem_classes="api-cards")
-
-    with gr.Column(visible=False, elem_classes="cred-section") as okta_cred:
-        api_base_url_okta = gr.Textbox(label="API Base URL", placeholder="e.g., https://your-okta-domain.okta.com")
-        api_token = gr.Textbox(label="API Token", type="password", placeholder="Enter your Okta API token")
-
-    with gr.Column(visible=False, elem_classes="cred-section") as inow_cred:
-        api_base_url_inow = gr.Textbox(label="API Base URL", placeholder="e.g., https://your-org.api.identitynow.com")
-        grant_type = gr.Textbox(label="Grant Type", value="client_credentials", interactive=False)
-        client_id = gr.Textbox(label="Client ID", placeholder="Enter your client ID")
-        client_secret = gr.Textbox(label="Client Secret", type="password", placeholder="Enter your client secret")
-
-    with gr.Column(visible=False, elem_classes="cred-section") as iiq_cred:
-        api_base_url_iiq = gr.Textbox(label="API Base URL", placeholder="e.g., https://your-iiq-server.com/identityiq")
-        username = gr.Textbox(label="Username", placeholder="Enter your IIQ username")
-        password = gr.Textbox(label="Password", type="password", placeholder="Enter your IIQ password")
+    api_choice = gr.Radio(choices=choices, label="Select API Platform", type="value", elem_classes="api-cards")
+    
+    # Custom API inputs (visible when "Others" is selected)
+    with gr.Group(visible=False) as custom_api_group:
+        custom_api_name = gr.Textbox(label="Custom API Name", placeholder="Enter API name (e.g., 'My API')")
+        custom_api_format = gr.Radio(choices=["JSON", "YAML"], label="API Format", value="JSON")
+    
+    # API Base URL input
+    with gr.Row():
+        api_base_url = gr.Textbox(label="API Specification URL", placeholder="Enter API specification URL")
+    
+    # Connect API choice to custom API visibility
+    api_choice.change(
+        fn=update_api_url,
+        inputs=[api_choice],
+        outputs=[custom_api_group, api_base_url, api_spec_url_state]
+    )
 
-    verify_btn = gr.Button("Verify Credentials", elem_classes="action-btn")
+    # Update API spec URL state when the text field changes
+    def update_api_spec_url_state(url):
+        global current_api_spec_url
+        print(f"Updating API spec URL state to: {url}")
+        # Also update the global variable
+        current_api_spec_url = url
+        return gr.update(value=url)
+    
+    api_base_url.change(
+        fn=update_api_spec_url_state,
+        inputs=[api_base_url],
+        outputs=[api_spec_url_state]
+    )
+    
+    # Load API Specification button
+    load_btn = gr.Button("Load API Specification", elem_classes="action-btn")
     loading_indicator = gr.HTML("<div class='loading-spinner'></div>", visible=False)
-    credentials_message = gr.HTML("", visible=False)
-
-    max_groups = 100
-    with gr.Group(elem_classes="endpoints-section", visible=False) as endpoints_section:
+    message_box = gr.HTML("", visible=False)
+
+    # Endpoints section
+    with gr.Group(visible=False, elem_classes="endpoints-section") as endpoints_section:
+        # Endpoint type selector (GET, POST, or ALL)
+        endpoint_type = gr.Radio(
+            choices=["GET", "POST", "ALL"], 
+            value="GET", 
+            label="Endpoints Type", 
+            elem_classes="endpoint-type-selector"
+        )
+        
+        # Select All / Deselect All checkboxes
+        with gr.Row():
+            select_all_cb = gr.Checkbox(label="Select All", value=False)
+            deselect_all_cb = gr.Checkbox(label="Deselect All", value=False)
+        
         with gr.Row():
             edit_btn = gr.Button("Edit", interactive=False, elem_classes="reset-btn")
             reset_btn = gr.Button("Reset", interactive=False, elem_classes="reset-btn")
+        
+        # Accordion for endpoint groups
+        max_groups = 100  # Reduced for simplicity
         accordion_placeholders = []
         for i in range(max_groups):
             with gr.Accordion(label="", open=False, visible=False, elem_classes="custom-accordion") as acc:
                 cb = gr.CheckboxGroup(label="", choices=[], value=[], elem_classes="custom-checkbox")
             accordion_placeholders.append((acc, cb))
-        continue_btn = gr.Button("Continue", elem_classes="action-btn")
+        
+        continue_btn = gr.Button("Generate Schema", elem_classes="action-btn")
 
+    # Parameters section
     with gr.Group(elem_classes="param-group", visible=False) as param_group:
         param_header = gr.Markdown("### Parameters Required")
         param_components = []
@@ -768,97 +793,130 @@ with gr.Blocks(css=custom_css) as demo:
                 param_input = gr.Textbox(label="Parameter Value", visible=False)
                 param_components.append((group, param_display, param_input))
 
-    with gr.Group(elem_classes="fetch-section", visible=False) as fetch_section:
-        fetch_btn = gr.Button("Fetch Data", interactive=False, elem_classes="action-btn")
-        fetch_loading_indicator = gr.HTML("<div class='fetch-loading-indicator'><div class='loading-spinner'></div></div>", visible=False)
-
-    with gr.Group(elem_classes="results-section", visible=False) as results_section:
+    # Results section
+    with gr.Group(visible=False, elem_classes="results-section") as results_section:
         gr.Markdown("### Results")
-        results_out = gr.Code(label="API Responses", language="json", elem_classes="gr-code")
-        download_out = gr.File(label="Download Session Data (ZIP)", elem_classes="download-btn")
-
-    def update_cred_sections(api_choice_value):
-        return [
-            gr.update(visible=api_choice_value=="Okta (JSON)"),
-            gr.update(visible=api_choice_value=="SailPoint IdentityNow (YAML)"),
-            gr.update(visible=api_choice_value=="Sailpoint IIQ (YAML)"),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(value=None),
-            gr.update(value=None),
-            gr.update(value=""),
-            gr.update(value=[]),
-            gr.update(interactive=True),
-            gr.update(interactive=False),
-            gr.update(interactive=False),  # Reset button explicitly set to inactive
-        ] + [gr.update(interactive=True, value=[]) for _, cb in accordion_placeholders] + [
-            gr.update(visible=False) for _ in range(len(param_components) * 3)
-        ] + [gr.update(interactive=False)] + [
-            gr.update(value=0)
-        ] + [gr.update(value="") for _, _, input_box in param_components]
-
-    def verify_and_load_endpoints(api_choice_val, base_okta, tok_okta, base_inow, gtype, cid, csecret, base_iiq, uname, pw):
+        with gr.Tabs() as result_tabs:
+            with gr.TabItem("JSON Schema"):
+                json_output = gr.Code(label="JSON Schema", language="json", elem_classes="gr-code")
+            with gr.TabItem("XML Schema"):
+                xml_output = gr.Textbox(label="XML Schema", lines=20, elem_classes="gr-code")
+        download_out = gr.File(label="Download Schema Files (ZIP)", visible=True, interactive=True)
+
+    # Function to load API specification
+    def load_api_spec(api_choice_val, base_url, custom_name=None, custom_format=None):
+        global current_api_spec_url
+        
         yield (
-            gr.update(visible=True),
-            gr.update(value=""),
+            gr.update(visible=True),  # Show loading indicator
+            gr.update(value="", visible=False),
             gr.update(visible=False),
             gr.update(visible=False),
-            *[gr.update(visible=False, label="", value=[]) for _ in range(max_groups * 2)]
+            *[gr.update(visible=False, label="", value=[]) for _ in range(max_groups * 2)],
+            gr.update(value="")
         )
-
-        if api_choice_val == "Okta (JSON)":
-            status, endpoints_vis, fetch_vis = verify_credentials(api_choice_val, base_okta, api_token=tok_okta)
-        elif api_choice_val == "SailPoint IdentityNow (YAML)":
-            status, endpoints_vis, fetch_vis = verify_credentials(api_choice_val, base_inow, grant_type=gtype,
-                                                                  client_id=cid, client_secret=csecret)
+        # Handle custom API
+        if api_choice_val == "Others":
+            # Create a custom API choice value if name is provided
+            if custom_name:
+                api_choice_val = f"{custom_name} ({custom_format})"
+            # Make sure we use the base_url directly for "Others" option
+            spec_url = base_url
+            print(f"Using custom API spec URL: {spec_url}")
         else:
-            status, endpoints_vis, fetch_vis = verify_credentials(api_choice_val, base_iiq, iiq_username=uname,
-                                                                  iiq_password=pw)
-
-        if not endpoints_vis:
-            yield (
-                gr.update(visible=False),
-                status,
-                gr.update(visible=False),
-                gr.update(visible=False),
-                *[gr.update(visible=False, label="", value=[]) for _ in range(max_groups * 2)]
-            )
-            return
-
-        endpoints = get_endpoints(api_choice_val)
+            # Get endpoints and API spec URL for predefined platforms
+            _, spec_url = get_endpoints(api_choice_val, None)
+            if base_url:  # If user provided a URL, use it instead
+                spec_url = base_url
+                print(f"Using user-provided API spec URL for {api_choice_val}: {spec_url}")
+            else:
+                print(f"Using default API spec URL for {api_choice_val}: {spec_url}")
+        
+        # Store the current API spec URL
+        current_api_spec_url = spec_url
+        print(f"Setting current_api_spec_url to: {current_api_spec_url}")
+        
+        # Get endpoints using the determined spec_url
+        endpoints, _ = get_endpoints(api_choice_val, spec_url)
+        
         if not endpoints:
             yield (
-                gr.update(visible=False),
-                gr.update(value="<div class='error-message'><i class='fas fa-exclamation-circle'></i> No endpoints found</div>", visible=True),
+                gr.update(visible=True),
+                gr.update(value="<div style='color: red;'>No endpoints found</div>", visible=True),
                 gr.update(visible=False),
                 gr.update(visible=False),
-                *[gr.update(visible=False, label="", value=[]) for _ in range(max_groups * 2)]
+                *[gr.update(visible=False, label="", value=[]) for _ in range(max_groups * 2)],
+                gr.update(value=spec_url)
             )
-            return
-
-        groups = group_endpoints(endpoints, api_choice_val)
+        
+        # Group endpoints by GET method (default)
+        groups = group_endpoints(endpoints, api_choice_val, 'get')
         group_keys = list(groups.keys())
         updates = []
+        
         for i in range(max_groups):
             if i < len(group_keys):
                 group = group_keys[i]
                 choices = [f"{ep} | GET - {methods['get'].get('summary', 'No summary')}" for ep, methods in groups[group].items() if 'get' in methods]
                 updates.extend([
                     gr.update(label=group, visible=bool(choices), open=False),
-                    gr.update(choices=choices, value=[], visible=bool(choices), interactive=True)
+                    gr.update(choices=choices, value=[], visible=bool(choices))
                 ])
             else:
                 updates.extend([gr.update(visible=False, label=""), gr.update(visible=False, choices=[], value=[])])
+        
         yield (
             gr.update(visible=False),
-            gr.update(value="<div class='success-message'><i class='fas fa-check-circle'></i> Endpoints loaded successfully</div>", visible=True),
-            gr.update(visible=True),
+            gr.update(value="<div class='success-message'><i class='fas fa-check-circle'></i> API specification loaded successfully</div>", visible=True),
             gr.update(visible=True),
-            *updates
+            gr.update(visible=False),
+            *updates,
+            gr.update(value=spec_url)
         )
 
+    # Function to update endpoints based on selected type (GET, POST, or ALL)
+    def update_endpoint_display(api_choice_val, endpoint_type_val, api_spec_url):
+        # Convert endpoint type to lowercase
+        endpoint_type_val = endpoint_type_val.lower()
+        
+        # Get endpoints
+        endpoints, _ = get_endpoints(api_choice_val, api_spec_url)
+        if not endpoints:
+            # Even if no endpoints are found, we should still return the endpoint type state
+            # and ensure the endpoints section remains visible
+            return [gr.update(visible=False, label="", value=[]) for _ in range(max_groups * 2)] + [gr.update(value=endpoint_type_val)]
+        
+        # Group endpoints by selected type
+        groups = group_endpoints(endpoints, api_choice_val, endpoint_type_val)
+        group_keys = list(groups.keys())
+        updates = []
+        
+        for i in range(max_groups):
+            if i < len(group_keys):
+                group = group_keys[i]
+                
+                if endpoint_type_val == 'all':
+                    # For 'all' type, include both GET and POST endpoints
+                    choices = []
+                    for ep, methods in groups[group].items():
+                        for method_type in ['get', 'post']:
+                            if method_type in methods:
+                                choices.append(f"{ep} | {method_type.upper()} - {methods[method_type].get('summary', 'No summary')}")
+                else:
+                    # For specific method types
+                    choices = [f"{ep} | {endpoint_type_val.upper()} - {methods[endpoint_type_val].get('summary', 'No summary')}" 
+                              for ep, methods in groups[group].items() if endpoint_type_val in methods]
+                
+                updates.extend([
+                    gr.update(label=group, visible=bool(choices), open=False),
+                    gr.update(choices=choices, value=[], visible=bool(choices))
+                ])
+            else:
+                updates.extend([gr.update(visible=False, label=""), gr.update(visible=False, choices=[], value=[])])
+        
+        return updates + [gr.update(value=endpoint_type_val)]
+
+    # Function to lock selected endpoints and generate schema directly
     def lock_selected_endpoints(*checkbox_values):
         all_selected = [sel for group in checkbox_values if isinstance(group, list) for sel in group]
         if not all_selected:
@@ -866,194 +924,239 @@ with gr.Blocks(css=custom_css) as demo:
                 [],
                 gr.update(interactive=True),
                 gr.update(interactive=False),
-                gr.update(interactive=False),  # Reset button stays inactive if no selection
-                *[gr.update(interactive=True) for _ in range(max_groups)],
-                gr.update(visible=False),
-                gr.update(visible=False),
-                *[gr.update(visible=False) for _ in range(len(param_components) * 3)],
                 gr.update(interactive=False),
-                gr.update(value=0)
+                *[gr.update(interactive=True) for _ in range(max_groups)]
             ]
-
-        all_parameters = get_required_params(api_choice.value, all_selected)
-        param_updates = update_params(api_choice.value, all_selected)
-        has_params = len(all_parameters) > 0
-        fetch_update = gr.update(interactive=not has_params)
         
         return [
             all_selected,
             gr.update(interactive=False),
             gr.update(interactive=True),
-            gr.update(interactive=True),  # Reset button should be active now - CHANGED THIS LINE
-            *[gr.update(interactive=False) for _ in range(max_groups)],
-            *param_updates,
-            fetch_update,
-            gr.update(value=len(all_parameters))
+            gr.update(interactive=True),
+            *[gr.update(interactive=False) for _ in range(max_groups)]
         ]
 
+    # Function to unlock selected endpoints
     def unlock_selected_endpoints():
         return [
             gr.update(value=[]),
             gr.update(interactive=True),
             gr.update(interactive=False),
-            gr.update(interactive=False),  # Reset button
-            *[gr.update(interactive=True) for _ in range(max_groups)],
-            gr.update(visible=False),
-            gr.update(visible=False),
-            *[gr.update(visible=False) for _ in range(len(param_components) * 3)],
             gr.update(interactive=False),
-            gr.update(value=0)
+            *[gr.update(interactive=True) for _ in range(max_groups)]
         ]
 
+    # Function to reset selected endpoints
     def reset_selected_endpoints():
         return [
             gr.update(value=[]),
             gr.update(interactive=True),
             gr.update(interactive=False),
-            gr.update(interactive=False),  # Reset button
-            *[gr.update(interactive=True, value=[]) for _ in range(max_groups)],  # Unselect all endpoints
-            gr.update(visible=False),
-            gr.update(visible=False),
-            *[gr.update(visible=False) for _ in range(len(param_components) * 3)],
             gr.update(interactive=False),
-            gr.update(value=0)
+            *[gr.update(interactive=True, value=[]) for _ in range(max_groups)]
         ]
 
-    def get_required_params(spec_choice_val, selected_endpoints):
-        endpoints = get_endpoints(spec_choice_val)
-        all_params = []
-        for ep in selected_endpoints:
-            endpoint = ep.split(" | GET")[0].strip()
-            endpoint_spec = endpoints.get(endpoint, {}).get('get', {})
-            path_params = extract_path_params(endpoint)
-            query_params = extract_query_params(endpoint_spec)
-            for param in path_params:
-                all_params.append({"endpoint": endpoint, "type": "path", "name": param, "description": "Path parameter"})
-            for _, name, required, desc in query_params:
-                if required:
-                    all_params.append({"endpoint": endpoint, "type": "query", "name": name, "description": desc or "Query parameter"})
-        return all_params
-
-    def update_params(spec_choice_val, locked_endpoints):
-        all_parameters = get_required_params(spec_choice_val, locked_endpoints)
-        updates = []
-        if not all_parameters:
-            updates.extend([
+    # Store the current API spec URL in a global variable
+    current_api_spec_url = ""
+
+    # Function to generate schema files
+    def generate_schemas(api_choice_val, api_spec_url_value, custom_api_name_value, *checkbox_values):
+        global current_api_spec_url
+        
+        print(f"Generate schemas called with api_choice_val: {api_choice_val}")
+        print(f"API spec URL value from state: {api_spec_url_value}")
+        print(f"Current API spec URL: {current_api_spec_url}")
+        print(f"Custom API name from UI: {custom_api_name_value}")
+        
+        # Get custom API name if "Others" is selected
+        custom_name = None
+        if api_choice_val == "Others":
+            # Use the custom API name passed as a parameter
+            custom_name = custom_api_name_value
+            
+            # If custom_name is None or empty, use a default name
+            if not custom_name or custom_name.strip() == "":
+                custom_name = "custom_api"
+                print(f"Using default custom API name: {custom_name}")
+        
+        # Extract both path and method from selected endpoints
+        all_selected = []
+        for group in checkbox_values:
+            if isinstance(group, list):
+                for sel in group:
+                    # Parse both path and method from the selection
+                    parts = sel.split(" | ")
+                    if len(parts) >= 2:
+                        path = parts[0].strip()
+                        method = parts[1].split(" - ")[0].strip().lower()  # Extract GET or POST
+                        all_selected.append((path, method))
+        
+        if not all_selected:
+            return (
+                gr.update(visible=False),
+                gr.update(value=""),
+                gr.update(value=""),
+                gr.update(value=None)
+            )
+        
+        # Use the current API spec URL that was set when loading the API specification
+        api_spec_url = current_api_spec_url
+        
+        # If we still don't have a URL, try to use the one from the state
+        if not api_spec_url:
+            api_spec_url = api_spec_url_value
+            print(f"Using API spec URL from state: {api_spec_url}")
+        
+        print(f"API Choice: {api_choice_val}")
+        print(f"API Spec URL: {api_spec_url}")
+        print(f"Selected endpoints count: {len(all_selected)}")
+        
+        # Check if api_choice_val is None
+        if api_choice_val is None:
+            print(f"Error: API choice is None")
+            return (
                 gr.update(visible=True),
-                gr.update(value="✅ No parameters are required. Press 'Fetch Data' to get data.", visible=True)
-            ])
-            updates.extend([gr.update(visible=False) for _ in range(len(param_components) * 3)])
-        else:
-            updates.extend([
+                gr.update(value="Error: Please select an API platform first"),
+                gr.update(value="Error: Please select an API platform first"),
+                gr.update(value=None)
+            )
+        
+        # Check if api_spec_url is empty
+        if not api_spec_url:
+            print(f"Error: API spec URL is empty")
+            return (
                 gr.update(visible=True),
-                gr.update(value=f"⚠️ Required Parameters ({len(all_parameters)})", visible=True)
-            ])
-            for i in range(5):
-                if i < len(all_parameters):
-                    param = all_parameters[i]
-                    emoji = "🔑" if param['type'] == 'path' else "🔍"
-                    updates.extend([
-                        gr.update(visible=True),
-                        gr.update(visible=True, value=f"Endpoint: {param['endpoint']} - {param['type'].title()} Parameter"),
-                        gr.update(visible=True, label=f"{emoji} {param['name']}", placeholder=param['description'])
-                    ])
-                else:
-                    updates.extend([gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)])
-        return updates
-
-    def update_fetch_button(required_params_count, *param_values):
-        if required_params_count == 0:
-            return gr.update(interactive=True)
-        filled = all(val and val.strip() for val in param_values[:required_params_count])
-        return gr.update(interactive=filled)
-
-    def handle_api_call(api_choice_val, base_okta, tok_okta, base_inow, gtype, cid, csecret, base_iiq, uname, pw,
-                        locked_endpoints, *param_values):
-        yield (
-            gr.update(visible=True),
-            gr.update(visible=False),
-            gr.update(value=None),
-            gr.update(value=None)
-        )
-
-        param_dict = {}
-        param_idx = 0
-        endpoints = get_endpoints(api_choice_val)
-        for ep in locked_endpoints:
-            endpoint = ep.split(" | GET")[0].strip()
-            endpoint_spec = endpoints.get(endpoint, {}).get('get', {})
-            for param in extract_path_params(endpoint):
-                if param_idx < len(param_values):
-                    param_dict[param] = param_values[param_idx]
-                param_idx += 1
-            for _, name, required, _ in extract_query_params(endpoint_spec):
-                if required and param_idx < len(param_values):
-                    param_dict[name] = param_values[param_idx]
-                param_idx += 1
-
-        clean_endpoints = [ep.split(" | GET")[0].strip() for ep in locked_endpoints]
-
-        if api_choice_val == "Okta (JSON)":
-            result = handle_okta_call(base_okta, tok_okta, "", param_dict, clean_endpoints)
-        elif api_choice_val == "SailPoint IdentityNow (YAML)":
-            result = handle_identitynow_call(base_inow, gtype, cid, csecret, "", param_dict, clean_endpoints)
-        else:
-            result = handle_iiq_call(base_iiq, uname, pw, "", param_dict, clean_endpoints)
-
-        if not result or not isinstance(result, tuple) or len(result) < 2:
-            data = {"error": "Invalid API response format"}
-            download_file = None
-        else:
-            api_data = result[0]
-            download_file = result[1] if len(result) > 1 else None
-            if isinstance(api_data, dict):
-                data = api_data
-            elif isinstance(api_data, list):
-                data = {"results": api_data}
-            elif api_data is None:
-                data = {"message": "No data returned from the API"}
+                gr.update(value="Error: API specification URL is empty. Please select a valid API platform or enter a URL."),
+                gr.update(value="Error: API specification URL is empty. Please select a valid API platform or enter a URL."),
+                gr.update(value=None)
+            )
+        
+        # Generate schema files
+        try:
+            # Pass the custom API name if it's available
+            if api_choice_val == "Others" and custom_name:
+                result = generate_schema_files(api_choice_val, all_selected, api_spec_url, custom_name)
             else:
-                data = {"raw_response": str(api_data)}
-
-        # Convert data to JSON string for gr.Code
-        import json
-        data_str = json.dumps(data, indent=2)
-
-        yield (
-            gr.update(visible=False),
+                result = generate_schema_files(api_choice_val, all_selected, api_spec_url)
+            
+            # Create a temporary file with .zip extension
+            fd, temp_path = tempfile.mkstemp(suffix='.zip')
+            os.close(fd)
+            
+            # Write the BytesIO content to the temporary file
+            with open(temp_path, 'wb') as f:
+                f.write(result["zip"].getvalue())
+                
+            print(f"Temporary zip file created at: {temp_path}")
+            
+        except Exception as e:
+            print(f"Error generating schema files: {e}")
+            return (
+                gr.update(visible=True),
+                gr.update(value=f"Error generating schema files: {str(e)}"),
+                gr.update(value=f"Error generating schema files: {str(e)}"),
+                gr.update(value=None)
+            )
+        
+        return (
             gr.update(visible=True),
-            gr.update(value=data_str),
-            gr.update(value=download_file)
+            gr.update(value=result["json"]),
+            gr.update(value=result["xml"]),
+            gr.update(value=temp_path)  # Use the temporary file path instead of BytesIO
         )
 
+    # Function to handle API choice change - collapses sections when API is changed
+    def handle_api_choice_change(api_choice_val):
+        global current_api_spec_url
+        # Reset the current API spec URL when changing API choice
+        current_api_spec_url = ""
+        # First, get the outputs from update_api_url
+        custom_api_visibility, api_base_url_value, api_spec_url_value = update_api_url(api_choice_val)
+        # Then, add the visibility updates for endpoints and results sections
+        return custom_api_visibility, api_base_url_value, api_spec_url_value, gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+    
+    # Update API choice to handle collapsing sections
     api_choice.change(
-        fn=update_cred_sections,
+        fn=handle_api_choice_change,
         inputs=[api_choice],
+        outputs=[custom_api_group, api_base_url, api_spec_url_state, endpoints_section, results_section, message_box]
+    )
+    
+    # Connect UI components to functions
+    load_btn.click(
+        fn=load_api_spec,
+        inputs=[api_choice, api_base_url, custom_api_name, custom_api_format],
         outputs=[
-            okta_cred, inow_cred, iiq_cred, 
-            endpoints_section, param_group, fetch_section, results_section,
-            results_out, download_out, credentials_message,
-            locked_endpoints_state, continue_btn, edit_btn, reset_btn
-        ] + [cb for _, cb in accordion_placeholders] +
-          [comp for group, display, input_box in param_components for comp in (group, display, input_box)] +
-          [fetch_btn, required_params_count] +
-          [input_box for _, _, input_box in param_components]
+            loading_indicator,
+            message_box,
+            endpoints_section,
+            results_section
+        ] + [comp for acc, cb in accordion_placeholders for comp in (acc, cb)] + [api_spec_url_state]
     )
 
-    verify_btn.click(
-        fn=verify_and_load_endpoints,
-        inputs=[
-            api_choice,
-            api_base_url_okta, api_token,
-            api_base_url_inow, grant_type, client_id, client_secret,
-            api_base_url_iiq, username, password
-        ],
-        outputs=[
-            loading_indicator, credentials_message,
-            endpoints_section, fetch_section
-        ] + [comp for acc, cb in accordion_placeholders for comp in (acc, cb)]
+    # Function to update endpoints and ensure endpoints section remains visible
+    def update_endpoints_and_maintain_visibility(api_choice_val, endpoint_type_val, api_spec_url):
+        # Get updates for accordion placeholders and endpoint type state
+        updates = update_endpoint_display(api_choice_val, endpoint_type_val, api_spec_url)
+        # Return these updates plus an update to keep the endpoints section visible
+        return updates + [gr.update(visible=True)]
+    
+    endpoint_type.change(
+        fn=update_endpoints_and_maintain_visibility,
+        inputs=[api_choice, endpoint_type, api_spec_url_state],
+        outputs=[comp for acc, cb in accordion_placeholders for comp in (acc, cb)] + [endpoint_type_state, endpoints_section]
     )
 
+    # Function to handle select all checkbox
+    def select_all_endpoints(select_all, endpoint_type_val, *current_values):
+        if not select_all:
+            return [gr.update(value=False)] + [gr.update(value=val) for val in current_values]
+        
+        # Get all visible checkboxes
+        updates = []
+        
+        # For each checkbox in the accordion
+        for i, (acc, cb) in enumerate(accordion_placeholders):
+            # If this is a valid index in current_values
+            if i < len(current_values):
+                # Get all choices for this checkbox
+                if hasattr(cb, 'choices'):
+                    updates.append(gr.update(value=cb.choices))
+                else:
+                    # If we can't get choices, use the update_endpoint_display function
+                    # to get the choices for this accordion group
+                    updates.append(gr.update(value=current_values[i]))
+            else:
+                # If we don't have a current value, just append an empty update
+                updates.append(gr.update(value=[]))
+        
+        # Reset deselect all checkbox
+        return [gr.update(value=False)] + updates
+    
+    # Function to handle deselect all checkbox
+    def deselect_all_endpoints(deselect_all, *current_values):
+        if not deselect_all:
+            return [gr.update(value=False)] + [gr.update(value=val) for val in current_values]
+        
+        # Deselect all checkboxes
+        updates = [gr.update(value=[]) for _ in current_values]
+        
+        # Reset select all checkbox
+        return [gr.update(value=False)] + updates
+    
+    # Connect select all and deselect all checkboxes
+    select_all_cb.change(
+        fn=select_all_endpoints,
+        inputs=[select_all_cb, endpoint_type_state] + [cb for _, cb in accordion_placeholders],
+        outputs=[deselect_all_cb] + [cb for _, cb in accordion_placeholders]
+    )
+    
+    deselect_all_cb.change(
+        fn=deselect_all_endpoints,
+        inputs=[deselect_all_cb] + [cb for _, cb in accordion_placeholders],
+        outputs=[select_all_cb] + [cb for _, cb in accordion_placeholders]
+    )
+    
     continue_btn.click(
         fn=lock_selected_endpoints,
         inputs=[cb for _, cb in accordion_placeholders],
@@ -1062,10 +1165,7 @@ with gr.Blocks(css=custom_css) as demo:
             continue_btn, 
             edit_btn,
             reset_btn
-        ] + [cb for _, cb in accordion_placeholders] +
-          [param_group, param_header] +
-          [comp for group, display, input_box in param_components for comp in (group, display, input_box)] +
-          [fetch_btn, required_params_count]
+        ] + [cb for _, cb in accordion_placeholders]
     )
 
     edit_btn.click(
@@ -1076,10 +1176,7 @@ with gr.Blocks(css=custom_css) as demo:
             continue_btn, 
             edit_btn,
             reset_btn
-        ] + [cb for _, cb in accordion_placeholders] +
-          [param_group, param_header] +
-          [comp for group, display, input_box in param_components for comp in (group, display, input_box)] +
-          [fetch_btn, required_params_count]
+        ] + [cb for _, cb in accordion_placeholders]
     )
 
     reset_btn.click(
@@ -1090,35 +1187,54 @@ with gr.Blocks(css=custom_css) as demo:
             continue_btn, 
             edit_btn,
             reset_btn
-        ] + [cb for _, cb in accordion_placeholders] +
-          [param_group, param_header] +
-          [comp for group, display, input_box in param_components for comp in (group, display, input_box)] +
-          [fetch_btn, required_params_count]
+        ] + [cb for _, cb in accordion_placeholders]
     )
 
-    for _, _, input_box in param_components:
-        input_box.change(
-            fn=update_fetch_button,
-            inputs=[required_params_count] + [input_box for _, _, input_box in param_components],
-            outputs=[fetch_btn]
-        )
-
-    fetch_btn.click(
-        fn=handle_api_call,
-        inputs=[
-            api_choice,
-            api_base_url_okta, api_token,
-            api_base_url_inow, grant_type, client_id, client_secret,
-            api_base_url_iiq, username, password,
-            locked_endpoints_state
-        ] + [input_box for _, _, input_box in param_components],
+    continue_btn.click(
+        fn=generate_schemas,
+        inputs=[api_choice, api_spec_url_state, custom_api_name] + [cb for _, cb in accordion_placeholders],
         outputs=[
-            fetch_loading_indicator, 
-            results_section, 
-            results_out, 
+            results_section,
+            json_output,
+            xml_output,
             download_out
         ]
     )
 
+    # Function to return the zip file for download
+    def download_schema_files(json_content, xml_content):
+        # Generate schema files in memory
+        if not json_content or not xml_content:
+            return None
+            
+        try:
+            # Determine API name from JSON content
+            meta_data = json.loads(json_content)
+            api_name = meta_data.get("name", "schema").lower().replace(" ", "_")
+            
+            # Create a zip file in memory
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+                zip_file.writestr(f"{api_name}_datasource_plugin_meta.json", json_content)
+                zip_file.writestr(f"{api_name}_default_schema.orx", xml_content)
+            
+            zip_buffer.seek(0)
+            
+            # Create a temporary file with .zip extension
+            fd, temp_path = tempfile.mkstemp(suffix='.zip')
+            os.close(fd)
+            
+            # Write the BytesIO content to the temporary file
+            with open(temp_path, 'wb') as f:
+                f.write(zip_buffer.getvalue())
+            
+            # Return the file path with a filename for download
+            return (temp_path, f"{api_name}_schema_files.zip")
+            
+        except Exception as e:
+            print(f"Error creating download file: {e}")
+            return None
+    
+
 if __name__ == "__main__":
-    demo.launch(show_error=True)
+    demo.launch(show_error=True)