Update app.py

app.py

@@ -9,6 +9,11 @@ import os
 from dotenv import load_dotenv
 from pathlib import Path
 
+# Load environment variables
+script_dir = Path(__file__).resolve().parent
+env_path = script_dir / '.env'
+load_dotenv(dotenv_path=env_path)
+
 script_dir = Path(__file__).resolve().parent
 env_path = script_dir / '.env'
 load_dotenv(dotenv_path=env_path)
@@ -131,121 +136,362 @@ def group_endpoints(endpoints, spec_choice):
     
     return groups
 
-with gr.Blocks(
-    theme=gr.themes.Default(
-        primary_hue=gr.themes.colors.red,
-        secondary_hue=gr.themes.colors.gray,
-        neutral_hue="slate",
-        text_size="md",
-        radius_size="md",
-        font=gr.themes.GoogleFont("Inter")
-    ),
-    css="""
-    .disabled-button {
-        opacity: 0.5;
-        pointer-events: none;
+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):
+    """Verify API credentials using existing handlers"""
+    
+    # Base URL validation
+    if not api_base_url or not api_base_url.strip():
+        return (
+            gr.update(value="❌ API Base URL is required", visible=True),
+            False,  # endpoints_vis
+            False   # fetch_vis
+        )
+
+    try:
+        # Credential validation based on API type
+        if spec_choice == "Okta (JSON)":
+            if not api_token or not api_token.strip():
+                return (
+                    gr.update(value="❌ API Token is required", visible=True),
+                    False,
+                    False
+                )
+            
+            # Test Okta connection
+            result = handle_okta_call(api_base_url, api_token, "", {}, ["/api/v1/users/me"])
+
+        elif spec_choice == "SailPoint IdentityNow (YAML)":
+            # Validate all required IdentityNow credentials
+            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="❌ All IdentityNow credentials (Grant Type, Client ID, Client Secret) are required", visible=True),
+                    False,
+                    False
+                )
+            
+            # Test IdentityNow connection
+            result = handle_identitynow_call(
+                api_base_url, 
+                grant_type, 
+                client_id, 
+                client_secret,
+                "",  # session_id
+                {},  # param_values
+                []   # endpoints
+            )
+
+        elif spec_choice == "Sailpoint IIQ (YAML)":
+            # Validate IIQ credentials
+            if not all([
+                iiq_username and iiq_username.strip(),
+                iiq_password and iiq_password.strip()
+            ]):
+                return (
+                    gr.update(value="❌ Both IIQ username and password are required", visible=True),
+                    False,
+                    False
+                )
+            
+            # Test IIQ connection
+            result = handle_iiq_call(
+                api_base_url, 
+                iiq_username, 
+                iiq_password,
+                "",  # session_id
+                {},  # param_values
+                []   # endpoints
+            )
+        else:
+            return (
+                gr.update(value="❌ Invalid API type selected", visible=True),
+                False,
+                False
+            )
+
+        # Validate API response
+        if not isinstance(result, tuple) or len(result) < 4:
+            return (
+                gr.update(value="❌ Invalid API response format", visible=True),
+                False,
+                False
+            )
+
+        if "error" in result[0]:
+            return (
+                gr.update(value=f"❌ Connection failed: {result[0]['error']}", visible=True),
+                False,
+                False
+            )
+
+        # Success case
+        return (
+            gr.update(value="✅ API Connection successful! Credentials verified.", visible=True),
+            True,   # Show endpoints section
+            True    # Show fetch button
+        )
+
+    except requests.exceptions.ConnectionError:
+        return (
+            gr.update(value="❌ Connection Error: Could not reach the API. Please check the URL and your network connection.", visible=True),
+            False,
+            False
+        )
+    except Exception as e:
+        return (
+            gr.update(value=f"❌ API Error: {str(e)}", visible=True),
+            False,
+            False
+        )
+
+# CSS to match dummy.html
+custom_css = """
+    body, .gradio-container {
+        font-family: Arial, sans-serif;
+        background: #f3faf7;
+        color: #333
+    }
+    .container {
+        max-width: 800px;
+        margin: auto;
+        padding: 20px;
+        border-radius: 4px;
+        background: black;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+    }
+    .container h1 {
+        color: White !important;
     }
-    .loading-overlay {
-        position: fixed;
-        top: 0;
-        left: 0;
+    .title h1 {
+        color: #ff6347 !important;
+    }
+    .section {
+        margin-bottom: 20px;
+        padding-bottom: 10px;
+        border-bottom: 1px solid #eee;
+    }
+    .section h2 {
+        margin-top: 0;
+    }
+    .section #api_choice {
+        background: #ff6347;
+    }
+    .section-text #api_base_url {
+        background: #ff6347;
+    }
+    .section-acc #acc {
+        background: #ff6347;
+    }
+    .section-acc #lock {
+        background: gray;
+    }
+    .section-acc #unlock {
+        background: gray;
+    }
+    input[type="text"], select, .gr-textbox, .gr-dropdown {
         width: 100%;
-        height: 100%;
-        background: rgba(255, 255, 255, 0.8);
-        display: flex;
-        justify-content: center;
-        align-items: center;
-        z-index: 1000;
+        padding: 8px;
+        margin-bottom: 10px;
+        border: 1px solid #ccc;
+        border-radius: 4px;
+    }
+    .gr-button {
+        background-color: #007BFF;
+        color: #fff;
+        border: none;
+        padding: 10px 20px;
+        border-radius: 4px;
+        cursor: pointer;
+    }
+    .gr-textbox label {
+        color: black !important;
+    }
+    .gradio-container .label-wrap {
+        color: black !important;
+    }
+    .gr-button:disabled {
+        background-color: #ccc;
+        cursor: not-allowed;
+    }
+    .message {
+        margin-top: 10px;
+        padding: 8px;
+        border-radius: 4px;
+        font-size: 0.9em;
+    }
+    .success { background-color: #d4edda; color: #155724; }
+    .error { background-color: #f8d7da; color: #721c24; }
+    .endpoint { padding: 10px 0; border-bottom: 1px solid #eee; }
+    .endpoint:last-child { border-bottom: none; }
+    .endpoint-params { margin-left: 20px; margin-top: 5px; }
+    .results {
+        border: 1px solid #eee;
+        padding: 10px;
+        background: #fafafa;
+        margin-bottom: 10px;
+        white-space: pre;
+        font-family: monospace;
+    }
+    .download-btn {
+        margin-top: 10px;
+        padding: 5px 10px;
+        font-size: 0.9em;
+        background-color: #007BFF;
+        color: #fff;
+    }
+"""
+text_box_css = """    
+    #api_base_url {
+    background: gr.themes.colors.red;
     }
     """
-) as demo:
-    gr.Markdown("# Data Connector Demo")
-    gr.Markdown("Select an API spec, then click Refresh Endpoints to see available endpoints grouped in accordions.")
-    
+
+with gr.Blocks(css=custom_css) as demo:
+    gr.Markdown("# Connect to Your Data Source", elem_classes="title")
+
     # Session state
     session_id_state = gr.State("")
     confirmed_endpoints_state = gr.State([])
     display_values_state = gr.State([])
-    
-    max_groups = 100
-    
-    # API Spec Selection
-    with gr.Row():
-        spec_choice = gr.Radio(
-            label="Choose API Spec",
+    locked_endpoints_state = gr.State([])
+
+    # API Selection Section
+    with gr.Group(elem_classes="section"):
+        gr.Markdown("### Select an API")
+        spec_choice = gr.Dropdown(
             choices=["Okta (JSON)", "SailPoint IdentityNow (YAML)", "Sailpoint IIQ (YAML)"],
-            value="SailPoint IdentityNow (YAML)"
+            value="SailPoint IdentityNow (YAML)",
+            label="Select an API",
+            filterable=True,
+            elem_id="api_choice"
         )
-        refresh_eps = gr.Button("Refresh Endpoints", variant="primary")
-    
-    # Loading indicator
-    loading_status = gr.Markdown("Select an API spec and click 'Refresh Endpoints' to load available endpoints.")
-    
-    # Create accordion placeholders
-    accordion_placeholders = []
-    with gr.Column():
-        for i in range(max_groups):
-            with gr.Accordion(label="", open=False, visible=False) as acc:
-                cb = gr.CheckboxGroup(label="", choices=[], value=[])
-            accordion_placeholders.append((acc, cb))
-    
-    # Parameter group
-    with gr.Group(visible=False) as param_group:
-        param_header = gr.Markdown("### Parameters Required")  # Default header
-        param_components = []
-        with gr.Column() as param_container:
+
+    # Credentials Section
+    with gr.Group(elem_classes="section-text"):
+        gr.Markdown("### Enter Credentials")
+        api_base_url = gr.Textbox(label="API Base URL", placeholder="Enter your API Base URL", elem_id="api_base_url")
+        
+        # Authentication inputs (dynamically shown)
+        with gr.Column(visible=True) as identitynow_auth:
+            grant_type = gr.Textbox(label="Grant Type", value="client_credentials", elem_id="api_base_url")
+            client_id = gr.Textbox(label="Client ID", placeholder="Enter your Client ID", elem_id="api_base_url")
+            client_secret = gr.Textbox(label="Client Secret", placeholder="Enter your Client Secret", type="password", elem_id="api_base_url")
+        with gr.Column(visible=False) as okta_auth:
+            api_token = gr.Textbox(label="API Token", placeholder="Enter your API Token", type="password", elem_id="api_base_url")
+        with gr.Column(visible=False) as iiq_auth:
+            iiq_username = gr.Textbox(label="Username", placeholder="Enter your IIQ Username", elem_id="api_base_url")
+            iiq_password = gr.Textbox(label="Password", placeholder="Enter your IIQ Password", type="password", elem_id="api_base_url")
+        
+        verify_btn = gr.Button("Verify Credentials")
+        loading_indicator = gr.Markdown("", visible=False)  # Add this
+        credentials_message = gr.Markdown("")
+
+    max_groups = 100
+    # Endpoint Selection Section (hidden until verified)
+    with gr.Group(elem_classes="section-acc", visible=False) as endpoints_section:
+        gr.Markdown("### Choose Endpoints")
+        accordion_placeholders = []
+        with gr.Column():
+            for i in range(max_groups):
+                with gr.Accordion(label="", open=False, visible=False, elem_id= "acc") as acc:
+                    cb = gr.CheckboxGroup(label="", choices=[], value=[])
+                accordion_placeholders.append((acc, cb))
+        
+        with gr.Row():
+            lock_endpoints_btn = gr.Button("Lock Endpoints", variant="primary", elem_id= "lock")
+            unlock_endpoints_btn = gr.Button("Unlock Endpoints", variant="secondary", elem_id="unlock", interactive=False)
+        lock_loading_indicator = gr.Markdown("", visible=False)  # Add loading indicator for lock operation
+
+        # Parameter inputs (dynamically populated)
+        with gr.Group(visible=False) as param_group:
+            param_header = gr.Markdown("### Parameters Required")
+            param_components = []
             for i in range(5):
                 with gr.Group(visible=False) as group:
-                    display = gr.Markdown(visible=False)
-                    input_box = gr.Textbox(
-                        label="Parameter Value",
-                        visible=False,
-                        interactive=True
-                    )
-                    param_components.append((group, display, input_box))
-    
-    # Authentication sections
-    with gr.Group() as identitynow_auth:
-        with gr.Row():
-            grant_type = gr.Textbox(label="Enter grant_type", value="client_credentials")
-            client_id = gr.Textbox(label="Enter client_id")
-            client_secret = gr.Textbox(label="Enter client_secret", type="password")
-    
-    with gr.Group(visible=False) as okta_auth:
-        api_token = gr.Textbox(label="Enter Okta API Token", type="password")
-    
-    with gr.Group(visible=False) as iiq_auth:
-        with gr.Row():
-            iiq_username = gr.Textbox(label="Enter IIQ Username")
-            iiq_password = gr.Textbox(label="Enter IIQ Password", type="password")
-    
-    api_base_url = gr.Textbox(label="Enter API Base URL")
-    
-    # Buttons
-    confirm_endpoints_btn = gr.Button("Submit and Confirm Endpoints", variant="primary")
-    call_api_btn = gr.Button("Call API", variant="primary")
-    
-    # Output components
-    responses_out = gr.JSON(label="API Responses")
-    download_out = gr.File(label="Download Session Data (ZIP)")
+                    param_display = gr.Markdown(visible=False)
+                    param_input = gr.Textbox(label="Parameter Value", visible=False)
+                    param_components.append((group, param_display, param_input))
+
+    # Fetch Data Section (hidden until verified)
+    with gr.Group(elem_classes="section", visible=False) as fetch_section:
+        fetch_btn = gr.Button("Fetch Data", interactive=False)
+        fetch_loading_indicator = gr.Markdown("", visible=False)  # Add loading indicator for fetch operation
+    # Results Section (hidden until data fetched)
+    with gr.Group(elem_classes="section", visible=False) as results_section:
+        gr.Markdown("### Results")
+        results_out = gr.JSON(label="API Responses")
+        download_out = gr.File(label="Download Session Data (ZIP)")
+
+    # Event handlers
+    def update_auth_fields(api_choice):
+        """Update authentication fields and reset UI when API selection changes"""
+        # Update auth field visibility
+        auth_updates = {
+            "Okta (JSON)": [False, True, False],
+            "SailPoint IdentityNow (YAML)": [True, False, False],
+            "Sailpoint IIQ (YAML)": [False, False, True]
+        }
+        visibilities = auth_updates.get(api_choice, [False, False, False])
+        
+        return [
+            *[gr.update(visible=v) for v in visibilities],  # auth fields (3)
+            gr.update(visible=False),  # endpoints_section
+            gr.update(visible=False),  # fetch_section
+            gr.update(visible=False),  # results_section
+            gr.update(value=None),     # results_out
+            gr.update(value=None),     # download_out
+            gr.update(value="")        # credentials_message
+        ]
 
-    def update_acc(spec_choice):
-        """Update accordions with endpoints"""
+    def verify_and_load_endpoints(spec_choice, api_base_url, grant_type, client_id, client_secret, 
+                api_token, iiq_username, iiq_password):
+        """Verify credentials and load endpoints into accordions"""
+        # Show loading message first
+        yield (
+            gr.update(value="⏳ Verifying credentials and loading endpoints...", visible=True),  # loading indicator
+            gr.update(value="", visible=False),  # credentials message
+            gr.update(visible=False),  # endpoints_section
+            gr.update(visible=False),  # fetch_section
+            *[gr.update(visible=False, label="", value=[]) for _ in range(max_groups * 2)]  # accordion updates
+        )
+
+        # Verify credentials
+        status, endpoints_vis, fetch_vis = verify_credentials(
+            spec_choice, api_base_url, grant_type, client_id, client_secret, 
+            api_token, iiq_username, iiq_password
+        )
+        
+        if not endpoints_vis:
+            yield (
+                gr.update(visible=False),  # hide loading
+                status,  # show error in credentials message
+                gr.update(visible=False),  # endpoints_section
+                gr.update(visible=False),  # fetch_section
+                *[gr.update(visible=False, label="", value=[]) for _ in range(max_groups * 2)]
+            )
+            return
+        
         try:
             endpoints = get_endpoints(spec_choice)
-            
             if not endpoints:
-                return [gr.update(visible=False)] * (max_groups * 2) + ["⚠️ No endpoints found"]
+                yield (
+                    gr.update(visible=False),
+                    gr.update(value="No endpoints found", visible=True),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    *[gr.update(visible=False, label="", value=[]) for _ in range(max_groups * 2)]
+                )
+                return
             
             groups = group_endpoints(endpoints, spec_choice)
             group_keys = list(groups.keys())
-
-            if not group_keys:
-                return [gr.update(visible=False)] * (max_groups * 2) + ["⚠️ No endpoint groups found"]
-                
             updates = []
             
-            # Always process exactly max_groups number of slots
+            # Process each group
             for i in range(max_groups):
                 if i < len(group_keys):
                     group = group_keys[i]
@@ -254,234 +500,402 @@ with gr.Blocks(
                     for ep, methods in groups[group].items():
                         if 'get' in methods:
                             summary = methods['get'].get('summary', 'No summary')
-                            label = f"{ep} | GET - {summary}"
-                            choices.append(label)
+                            choices.append(f"{ep} | GET - {summary}")
                     
-                    # Add updates regardless of choices
-                    acc_update = gr.update(
-                        label=f"Group: {group}" if choices else "",
-                        visible=bool(choices),
-                        open=(i == 0 and bool(choices))
-                    )
-                    cb_update = gr.update(choices=choices, value=[], visible=bool(choices))
-                    updates.append((acc_update, cb_update))
+                    # Add updates for this accordion
+                    if choices:
+                        updates.extend([
+                            gr.update(
+                                label=f"Group: {group}",
+                                visible=True,
+                                open=False  # Don't auto-open any accordion
+                            ),
+                            gr.update(
+                                choices=choices,
+                                value=[],
+                                visible=True,
+                                interactive=True  # Make sure checkboxes are interactive
+                            )
+                        ])
+                    else:
+                        updates.extend([
+                            gr.update(visible=False, label=""),
+                            gr.update(visible=False, choices=[], value=[])
+                        ])
                 else:
-                    # Fill remaining slots with hidden updates
-                    acc_update = gr.update(visible=False, label="")
-                    cb_update = gr.update(visible=False, choices=[], value=[])
-                    updates.append((acc_update, cb_update))
-
-            # Flatten updates and add status message
-            flattened = []
-            for up in updates:
-                flattened.extend(up)  # This will give us exactly max_groups * 2 updates
+                    # Hide unused accordions
+                    updates.extend([
+                        gr.update(visible=False, label=""),
+                        gr.update(visible=False, choices=[], value=[])
+                    ])
             
-            visible_groups = sum(1 for group in groups.values() if any('get' in methods for methods in group.values()))
-            success_msg = f"✅ Loaded {visible_groups} groups with GET endpoints"
-            flattened.append(success_msg)
+            yield (
+                gr.update(visible=False),  # hide loading
+                gr.update(value="✅ Endpoints loaded successfully", visible=True),
+                gr.update(visible=True),
+                gr.update(visible=True),
+                *updates
+            )
             
-            return flattened
-                
         except Exception as e:
-            error_msg = f"❌ Error loading endpoints: {str(e)}"
-            return [gr.update(visible=False)] * (max_groups * 2) + [error_msg]
-        
-    def update_auth_fields(api_choice):
-        updates = {
-            "Okta (JSON)": [False, True, False],
-            "SailPoint IdentityNow (YAML)": [True, False, False],
-            "Sailpoint IIQ (YAML)": [False, False, True]
-        }
-        visibilities = updates.get(api_choice, [False, False, False])
+            yield (
+                gr.update(visible=False),  # hide loading
+                gr.update(value=f"Error loading endpoints: {str(e)}", visible=True),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                *[gr.update(visible=False, label="", value=[]) for _ in range(max_groups * 2)]
+            )
+
+    def unlock_selected_endpoints():
+        """Unlock endpoints and reset parameter section"""
         return [
-            gr.update(visible=visibilities[0]),
-            gr.update(visible=visibilities[1]),
-            gr.update(visible=visibilities[2])
+            gr.update(value="✅ Endpoints unlocked", visible=True),  # message
+            [],  # locked_endpoints_state
+            gr.update(interactive=True),  # lock button
+            gr.update(interactive=False),  # unlock button - disable when unlocked
+            *[gr.update(interactive=True) for _ in range(max_groups)],  # checkboxes
+            gr.update(visible=False),  # param_group
+            gr.update(visible=False),  # param_header
+            *[gr.update(visible=False) for _ in range(len(param_components) * 3)],  # parameter components
+            gr.update(interactive=False)  # fetch button
         ]
 
-    loading_overlay = gr.HTML(visible=False, value='<div class="loading-overlay">⏳ Processing...</div>')
+    def lock_selected_endpoints(*checkbox_values):
+        """Collect and lock all selected endpoints"""
+        # Show loading message first
+        yield (
+            gr.update(value="⏳ Locking endpoints and processing parameters...", visible=True),  # loading indicator
+            [],  # locked_endpoints_state - clear state initially
+            gr.update(interactive=False),  # lock button
+            gr.update(interactive=False),  # unlock button
+            *[gr.update(interactive=False) for _ in range(len(checkbox_values))],  # checkboxes
+            gr.update(visible=False),  # param_group
+            gr.update(visible=False),  # param_header
+            *[gr.update(visible=False) for _ in range(len(param_components) * 3)],  # parameter components
+            gr.update(interactive=False)  # fetch button
+        )
 
-    def confirm_selected_endpoints(spec_choice, *checkbox_values):
-        """Collect and confirm all selected endpoints"""
         all_selected = []
         for checkbox_group in checkbox_values:
             if isinstance(checkbox_group, list) and checkbox_group:
                 all_selected.extend(checkbox_group)
         
         if not all_selected:
-            return ([],  # confirmed_endpoints_state
-                    [],  # display_values_state
-                    gr.update(visible=False),  # param_group
-                    gr.update(value="❌ No endpoints selected", visible=True),  # param_header
-                    *[gr.update(visible=False) for _ in range(15)])  # 5 sets of 3 components each
+            base_updates = [
+                gr.update(visible=False),  # loading indicator
+                [],  # locked_endpoints_state - keep empty
+                gr.update(interactive=True),  # lock button
+                gr.update(interactive=False),  # unlock button
+                *[gr.update(interactive=True) for _ in range(len(checkbox_values))]  # checkboxes
+            ]
+            param_updates = [
+                gr.update(visible=False),  # param_group
+                gr.update(visible=False),  # param_header
+                *[gr.update(visible=False) for _ in range(len(param_components) * 3)]  # parameter components
+            ]
+            yield base_updates + param_updates + [gr.update(interactive=False)]  # fetch button
+            return
+
+        base_updates = [
+            gr.update(visible=False),  # loading indicator
+            all_selected,  # locked_endpoints_state - update with selected endpoints
+            gr.update(interactive=False),  # lock button
+            gr.update(interactive=True),  # unlock button
+            *[gr.update(interactive=False) for _ in range(len(checkbox_values))]  # checkboxes
+        ]
+        
+        param_updates = update_params(spec_choice.value, all_selected)
+        fetch_update = [gr.update(interactive=True)]
         
+        yield base_updates + param_updates + fetch_update
+
+    def update_params(spec_choice_value, locked_endpoints):
+        """Update parameter inputs based on selected endpoints"""
+        if not locked_endpoints:
+            return [gr.update(visible=False), gr.update(visible=False)] + [gr.update(visible=False)] * (len(param_components) * 3)
+
         # Get the API spec
-        endpoints = get_endpoints(spec_choice)
+        endpoints = get_endpoints(spec_choice_value)
         
-        # Process selected endpoints to find ones with parameters
-        endpoints_with_params = []
-        display_values = []
+        # First pass: collect all parameters from all selected endpoints
+        all_parameters = []  # This will store ALL parameters from ALL endpoints
         required_params_count = 0
         
-        for selection in all_selected:
-            endpoint = selection.split(" | ")[0]
+        # Collect parameters from all endpoints first
+        for ep in locked_endpoints:
+            endpoint = ep.split(" | GET")[0].strip()
             endpoint_spec = endpoints.get(endpoint, {}).get('get', {})
             
+            # Collect path parameters
             path_params = extract_path_params(endpoint)
-            # Only include required query parameters
-            query_params = [param for param in extract_query_params(endpoint_spec) 
-                        if param[2]]  # param[2] is the required flag
+            for param in path_params:
+                all_parameters.append({
+                    'endpoint': endpoint,
+                    'type': 'path',
+                    'name': param,
+                    'required': True,
+                    'description': f"Required path parameter for {endpoint}"
+                })
+                required_params_count += 1
             
-            if path_params or query_params:
-                endpoints_with_params.append((endpoint, path_params, query_params))
-                display_values.append(f"Endpoint: {endpoint}")
-                required_params_count += len(path_params) + len(query_params)
+            # Collect required query parameters
+            query_params = extract_query_params(endpoint_spec)
+            for param_type, name, required, description in query_params:
+                if required:
+                    all_parameters.append({
+                        'endpoint': endpoint,
+                        'type': 'query',
+                        'name': name,
+                        'required': True,
+                        'description': description
+                    })
+                    required_params_count += 1
 
-        # Create updates for all components
+        # Create updates for components
         updates = []
-        updates.append(endpoints_with_params)  # confirmed_endpoints_state
-        updates.append(display_values)  # display_values_state
 
         if not required_params_count:
-            # No parameters required
-            updates.append(gr.update(visible=False))  # param_group
-            updates.append(gr.update(value="✅ No parameters required. You can proceed to call the API.", 
-                                visible=True))  # param_header
-            # Enable API call button here
+            updates.extend([
+                gr.update(visible=False),  # param_group
+                gr.update(value="✅ No parameters required. You can proceed to call the API.", visible=True)  # param_header
+            ])
+            updates.extend([gr.update(visible=False)] * (len(param_components) * 3))
         else:
-            # Parameters required
-            header_text = f"⚠️ Required Parameters ({required_params_count})"
-            updates.append(gr.update(visible=True))  # param_group
-            updates.append(gr.update(value=header_text, visible=True))  # param_header
-
-        # Then create updates for each parameter component
-        param_index = 0
-        for endpoint, path_params, query_params in endpoints_with_params:
-            # Handle path parameters
-            for param_name in path_params:
-                if param_index < 5:
+            # Show parameter section
+            updates.extend([
+                gr.update(visible=True),  # param_group
+                gr.update(value=f"⚠️ Required Parameters ({required_params_count})", visible=True)  # param_header
+            ])
+
+            # Update parameter components (limited to first 5 parameters)
+            for i in range(5):
+                if i < len(all_parameters):
+                    param = all_parameters[i]  # Get parameter from the collected list
+                    emoji = "🔑" if param['type'] == 'path' else "🔍"
                     updates.extend([
-                        gr.update(visible=True),
-                        gr.update(visible=True, 
-                                value=f"Endpoint: {endpoint} - Path Parameter (Required)"),
-                        gr.update(visible=True,
-                                label=f"🔑 Enter path parameter: {param_name}",
-                                placeholder=f"Required path parameter for {endpoint}")
+                        gr.update(visible=True),  # group
+                        gr.update(
+                            visible=True,
+                            value=f"Endpoint: {param['endpoint']} - {param['type'].title()} Parameter"
+                        ),  # display
+                        gr.update(
+                            visible=True,
+                            label=f"{emoji} Enter {param['type']} parameter: {param['name']}",
+                            placeholder=param['description']
+                        )  # input
                     ])
-                    param_index += 1
-            
-            # Handle required query parameters only
-            for _, name, required, description in query_params:
-                if required and param_index < 5:
+                else:
+                    # Hide unused parameter components
                     updates.extend([
-                        gr.update(visible=True),
-                        gr.update(visible=True, 
-                                value=f"Endpoint: {endpoint} - Query Parameter (Required)"),
-                        gr.update(visible=True,
-                                label=f"🔍 Enter query parameter: {name}",
-                                placeholder=description)
+                        gr.update(visible=False),
+                        gr.update(visible=False, value=""),
+                        gr.update(visible=False, label="")
                     ])
-                    param_index += 1
-
-        # Hide remaining parameter components
-        while param_index < 5:
-            updates.extend([
-                gr.update(visible=False),
-                gr.update(visible=False, value=""),
-                gr.update(visible=False, label="")
-            ])
-            param_index += 1
 
         return updates
     
-    def handle_api_call(spec_choice, api_base_url, session_id, grant_type, client_id, client_secret, 
-                   api_token, iiq_username, iiq_password, display_values, *args):
-        # Create param_values dictionary
-        num_params = len(param_components)
+    def update_fetch_button(*param_values):
+        """Enable fetch button if all required parameters are filled"""
+        if all(val.strip() for val in param_values if val is not None):
+            return gr.update(interactive=True)
+        return gr.update(interactive=False)
+    
+    for _, _, input_box in param_components:
+        input_box.change(
+            fn=update_fetch_button,
+            inputs=[input_box for _, _, input_box in param_components],
+            outputs=[fetch_btn]
+        )
+
+    def handle_api_call(spec_choice, api_base_url, grant_type, client_id, client_secret, api_token, 
+                   iiq_username, iiq_password, locked_endpoints, *param_values):
+        """Handle API calls for selected endpoints with parameters"""
+        
+        yield (
+            gr.update(value="⏳ Fetching data from API...", visible=True),  # loading indicator
+            gr.update(visible=False),  # results_section
+            gr.update(value=None),  # results_out
+            gr.update(value=None)  # download_out
+        )
+
+        if not locked_endpoints:
+            yield (
+                gr.update(visible=False),  # hide loading
+                gr.update(visible=True),
+                {"error": "No endpoints selected"},
+                None
+            )
+            return
+
+        # Initialize parameter dictionaries
         path_params = {}
         query_params = {}
-        
-        for i, display_value in enumerate(display_values):
-            if display_value and args[i]:
-                endpoint_text = display_value.split(": ")[1].split(" - ")[0]
-                param_type = "path" if "Path Parameter" in display_value else "query"
-                param_name = args[i].split(":")[0].strip()
-                
-                if param_type == "path":
-                    path_params[param_name] = args[i]
-                else:
-                    query_params[param_name] = args[i]
-        
-        checkbox_values = args[num_params:]
-        
+        param_idx = 0
+        endpoints = get_endpoints(spec_choice)
+
+        # Process each endpoint and map parameters
+        for ep in locked_endpoints:
+            endpoint = ep.split(" | GET")[0].strip()  # Extract endpoint path
+            endpoint_spec = endpoints.get(endpoint, {}).get('get', {})
+            
+            # Get path parameters
+            path_params_list = extract_path_params(endpoint)
+            for param in path_params_list:
+                if param_idx < len(param_values) and param_values[param_idx]:
+                    path_params[param] = param_values[param_idx]
+                param_idx += 1
+            
+            # Get query parameters
+            query_params_list = extract_query_params(endpoint_spec)
+            for _, name, required, _ in query_params_list:
+                if required and param_idx < len(param_values) and param_values[param_idx]:
+                    query_params[name] = param_values[param_idx]
+                param_idx += 1
+
         try:
+            # Call appropriate API handler based on selection
             if spec_choice == "Okta (JSON)":
-                return handle_okta_call(api_base_url, api_token, session_id, path_params, query_params, *checkbox_values)
+                result = handle_okta_call(
+                    api_base_url, 
+                    api_token, 
+                    "", # session_id 
+                    path_params, 
+                    query_params,
+                    locked_endpoints
+                )
             elif spec_choice == "SailPoint IdentityNow (YAML)":
-                return handle_identitynow_call(api_base_url, grant_type, client_id, client_secret, 
-                                        session_id, path_params, query_params, *checkbox_values)
-            else:  # IIQ
-                return handle_iiq_call(api_base_url, iiq_username, iiq_password, session_id, 
-                                path_params, query_params, *checkbox_values)
+                result = handle_identitynow_call(
+                    api_base_url, 
+                    grant_type, 
+                    client_id, 
+                    client_secret, 
+                    "", # session_id
+                    path_params, 
+                    query_params,
+                    locked_endpoints
+                )
+            else:  # Sailpoint IIQ
+                result = handle_iiq_call(
+                    api_base_url, 
+                    iiq_username, 
+                    iiq_password, 
+                    "", # session_id
+                    path_params, 
+                    query_params,
+                    locked_endpoints
+                )
+
+            # Show results section and return API response
+            yield (
+                gr.update(visible=False),  # hide loading
+                gr.update(visible=True),  # Show results section
+                result[0],  # API response data
+                result[1]   # Download file if any
+            )
+
         except Exception as e:
-            print(f"Error in handle_api_call: {str(e)}")
-            return (
+            yield (
+                gr.update(visible=False),  # hide loading
+                gr.update(visible=True),
                 {"error": f"API call failed: {str(e)}"},
-                None,
-                session_id,
-                f"❌ Error: {str(e)}"
+                None
             )
 
-    # Wire up the events
+    # Wire events
+    spec_choice.change(fn=update_auth_fields, inputs=[spec_choice], outputs=[identitynow_auth, okta_auth, iiq_auth])
+    verify_btn.click(
+        fn=verify_and_load_endpoints,
+        inputs=[
+            spec_choice, 
+            api_base_url, 
+            grant_type, 
+            client_id, 
+            client_secret, 
+            api_token, 
+            iiq_username, 
+            iiq_password
+        ],
+        outputs=[
+            loading_indicator,  # Add loading indicator to outputs
+            credentials_message,
+            endpoints_section,
+            fetch_section,
+            *[comp for acc_cb in accordion_placeholders for comp in acc_cb]
+        ]
+    )
+
     spec_choice.change(
-        fn=update_auth_fields,
-        inputs=[spec_choice],
-        outputs=[identitynow_auth, okta_auth, iiq_auth]
+        fn=update_auth_fields, 
+        inputs=[spec_choice], 
+        outputs=[
+            identitynow_auth,  # auth columns
+            okta_auth,
+            iiq_auth,
+            endpoints_section,  # sections
+            fetch_section,
+            results_section,
+            results_out,       # results
+            download_out,
+            credentials_message  # message
+        ]
     )
-    
-    refresh_eps.click(
-        fn=update_acc,
-        inputs=spec_choice,
-        outputs=[*[accordion_placeholders[i][j] for i in range(max_groups) for j in range(2)], loading_status]
+
+
+    lock_endpoints_btn.click(
+        fn=lock_selected_endpoints,
+        inputs=[cb for _, cb in accordion_placeholders],
+        outputs=[
+            lock_loading_indicator,  # Add loading indicator
+            locked_endpoints_state,  # Add state to outputs
+            lock_endpoints_btn,
+            unlock_endpoints_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
+        ]
     )
-    
-    confirm_endpoints_btn.click(
-        fn=confirm_selected_endpoints,
-        inputs=[
-            spec_choice,
-            *[acc_cb[1] for acc_cb in accordion_placeholders]
-        ],
+
+    unlock_endpoints_btn.click(
+        fn=unlock_selected_endpoints,
+        inputs=[],
         outputs=[
-            confirmed_endpoints_state,
-            display_values_state,
+            credentials_message,
+            locked_endpoints_state,
+            lock_endpoints_btn,
+            unlock_endpoints_btn,
+            *[cb for _, cb in accordion_placeholders],
             param_group,
-            param_header,  # Add param_header to outputs
-            *[item for group, display, input_box in param_components 
-            for item in (group, display, input_box)]
+            param_header,
+            *[comp for group, display, input_box in param_components 
+            for comp in (group, display, input_box)],
+            fetch_btn
         ]
     )
-    
-    call_api_btn.click(
+        
+    fetch_btn.click(
         fn=handle_api_call,
         inputs=[
-            spec_choice,
-            api_base_url,
-            session_id_state,
-            grant_type,
-            client_id,
-            client_secret,
-            api_token,
-            iiq_username,
+            spec_choice, 
+            api_base_url, 
+            grant_type, 
+            client_id, 
+            client_secret, 
+            api_token, 
+            iiq_username, 
             iiq_password,
-            display_values_state,
-            *[input_box for _, _, input_box in param_components],
-            *[acc_cb[1] for acc_cb in accordion_placeholders]
+            locked_endpoints_state,
+            *[input_box for _, _, input_box in param_components]
         ],
-        outputs=[responses_out, download_out, session_id_state, loading_status]
+        outputs=[
+            fetch_loading_indicator,  # Add loading indicator
+            results_section,
+            results_out,
+            download_out
+        ]
     )
-    
+
 if __name__ == "__main__":
-    demo.launch(
-        favicon_path="https://www.sailpoint.com/wp-content/uploads/2020/08/favicon.png",
-        show_error=True
-    )
+    demo.launch(show_error=True)