Update app.py

app.py

@@ -139,7 +139,35 @@ with gr.Blocks(
         text_size="md",
         radius_size="md",
         font=gr.themes.GoogleFont("Inter")
-    )
+    ),
+    css="""
+    .disabled-button {
+        opacity: 0.5;
+        pointer-events: none;
+    }
+    .processing-popup {
+        position: fixed;
+        top: 50%;
+        left: 50%;
+        transform: translate(-50%, -50%);
+        background: rgba(255, 255, 255, 0.95);
+        padding: 20px 40px;
+        border-radius: 10px;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        z-index: 1000;
+        text-align: center;
+        font-size: 1.2em;
+    }
+    .overlay-background {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background: rgba(0, 0, 0, 0.5);
+        z-index: 999;
+    }
+    """
 ) as demo:
     gr.Markdown("# Data Connector Demo")
     gr.Markdown("Select an API spec, then click Refresh Endpoints to see available endpoints grouped in accordions.")
@@ -281,101 +309,182 @@ with gr.Blocks(
             gr.update(visible=visibilities[2])
         ]
 
+    loading_overlay = gr.HTML(
+        visible=False,
+        value='''
+        <div class="overlay-background"></div>
+        <div class="processing-popup">
+            ⏳ Processing Endpoints...
+        </div>
+        '''
+    )
+
+    # Add validation function for enabling/disabling Call API button
+    def validate_inputs(spec_choice, api_base_url, grant_type, client_id, client_secret, 
+                       api_token, iiq_username, iiq_password, *param_values):
+        """Validate all required inputs to enable/disable Call API button"""
+        if not api_base_url.strip():
+            return gr.update(interactive=False)
+
+        # Validate auth fields based on API choice
+        if spec_choice == "Okta (JSON)":
+            if not api_token:
+                return gr.update(interactive=False)
+        elif spec_choice == "SailPoint IdentityNow (YAML)":
+            if not all([grant_type, client_id, client_secret]):
+                return gr.update(interactive=False)
+        elif spec_choice == "Sailpoint IIQ (YAML)":
+            if not all([iiq_username, iiq_password]):
+                return gr.update(interactive=False)
+
+        # Validate parameter inputs if they're visible
+        param_inputs = param_values[:len(param_components)]
+        param_displays = [comp[1].value for comp in param_components]
+        
+        for display, value in zip(param_displays, param_inputs):
+            if display and display.visible and not value.strip():
+                return gr.update(interactive=False)
+
+        return gr.update(interactive=True)
+    
     def confirm_selected_endpoints(spec_choice, *checkbox_values):
         """Collect and confirm all selected endpoints"""
+        #gr.update(visible=True)(loading_overlay)
+        header_text = "### Parameters Required"
         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=True),  # loading_overlay - show processing message
+                    gr.update(visible=False),  # call_api_btn
+                    *[gr.update(visible=False) for _ in range(15)])  # 5 sets of 3 components each
+        
         # Get the API spec
         endpoints = get_endpoints(spec_choice)
         
         # Process selected endpoints to find ones with parameters
         endpoints_with_params = []
-        display_values = []  # Track display values
+        display_values = []
+        required_params_count = 0
+        
         for selection in all_selected:
             endpoint = selection.split(" | ")[0]
             endpoint_spec = endpoints.get(endpoint, {}).get('get', {})
             
-            # Get both path and query parameters
             path_params = extract_path_params(endpoint)
-            query_params = extract_query_params(endpoint_spec)
+            # 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
             
             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)
 
         # Create updates for all components
-        updates = []
+        updates = [
+            endpoints_with_params,  # confirmed_endpoints_state
+            display_values,        # display_values_state
+        ]
         updates.append(endpoints_with_params)  # confirmed_endpoints_state
         updates.append(display_values)  # display_values_state
-        
-        # Determine parameter types present
-        has_path_params = any(path_params for _, path_params, _ in endpoints_with_params)
-        has_query_params = any(query_params for _, _, query_params in endpoints_with_params)
-        
-        # Set appropriate header based on parameter types
-        if has_path_params and has_query_params:
-            header_text = "### Path and Query Parameters Required"
-        elif has_path_params:
-            header_text = "### Path Parameters Required/Optional"
-        elif has_query_params:
-            header_text = "### Query Parameters Required/Optional"
+        updates.append(gr.update(visible=bool(required_params_count)))  # param_group
+        updates.append(gr.update(value=header_text, visible=True))  # param_header
+        updates.append(gr.update(visible=False))  # loading_overlay - hide when done
+        updates.append(gr.update(visible=True))  # call_api_btn
+
+        if not required_params_count:
+            updates.append(gr.update(value="✅ No parameters required. You can proceed to call the API.", 
+                                visible=True))  # param_header
         else:
-            header_text = "### Parameters Required"
-        
-        # Update group visibility and header text separately
-        updates.append(gr.update(visible=bool(endpoints_with_params)))  # param_group visibility
-        updates.append(gr.update(value=header_text, visible=True))  # param_header update
+            updates.append(gr.update(value=f"⚠️ Required Parameters ({required_params_count})", visible=True))
+
+        updates.append(gr.update(visible=False))  # loading_overlay
+        updates.append(gr.update(visible=True))  # call_api_btn
 
         # Then create updates for each parameter component
+
         param_index = 0
-        for i in range(100):  # Assuming max 5 endpoints
-            if i < len(endpoints_with_params):
-                endpoint, path_params, query_params = endpoints_with_params[i]
-                
-                # Handle path parameters
-                for param_name in path_params:  # Changed: iterate directly over parameter names
-                    if param_index < 5:  # Stay within component limit
-                        updates.extend([
-                            gr.update(visible=True),
-                            gr.update(visible=True, value=f"Endpoint: {endpoint} - Path Parameter"),
-                            gr.update(
-                                visible=True,
-                                label=f"Enter path parameter: {param_name}",
-                                placeholder=f"Required path parameter for {endpoint}"
-                            )
-                        ])
-                        param_index += 1
-                
-                # Handle query parameters
-                for param in query_params:  # Changed: handle query parameter tuples
-                    _, name, required, description = param  # Unpack all 4 values
-                    if param_index < 5:  # Stay within component limit
-                        updates.extend([
-                            gr.update(visible=True),
-                            gr.update(visible=True, value=f"Endpoint: {endpoint} - Query Parameter"),
-                            gr.update(
-                                visible=True,
-                                label=f"Enter query parameter: {name}" + (" (Required)" if required else " (Optional)"),
-                                placeholder=description
-                            )
-                        ])
-                        param_index += 1
+        for endpoint, path_params, query_params in endpoints_with_params:
+            # Handle path parameters
+            for param_name in path_params:
+                if param_index < 5:
+                    updates.extend([
+                        gr.update(visible=True, 
+                                value=f"Endpoint: {endpoint} - Path Parameter (Required)"),  # markdown
+                        gr.update(visible=True,
+                                label=f"🔑 Enter path parameter: {param_name}",
+                                placeholder=f"Required path parameter for {endpoint}")  # textbox
+                    ])
+                    param_index += 1
+            
+            # Handle query parameters
+            for _, name, required, description in query_params:
+                if required and param_index < 5:
+                    updates.extend([
+                        gr.update(visible=True,
+                                value=f"Endpoint: {endpoint} - Query Parameter (Required)"),  # markdown
+                        gr.update(visible=True,
+                                label=f"🔍 Enter query parameter: {name}",
+                                placeholder=description)  # textbox
+                    ])
+                    param_index += 1
 
-        # Fill remaining parameter components with hidden updates
+        # Fill remaining parameter slots
         while param_index < 5:
             updates.extend([
-                gr.update(visible=False),
-                gr.update(visible=False, value=""),
-                gr.update(visible=False, label="")
+                gr.update(visible=False),  # markdown
+                gr.update(visible=False)   # textbox
             ])
             param_index += 1
-        
+
+        updates.append(gr.update(value=header_text, visible=True))  # param_header
+        updates.append(gr.update(visible=False))  # loading_overlay
+        updates.append(gr.update(visible=True))  # call_api_btn
+
         return updates
     
+    for input_component in [api_base_url, grant_type, client_id, client_secret, 
+                          api_token, iiq_username, iiq_password]:
+        input_component.change(
+            fn=validate_inputs,
+            inputs=[
+                spec_choice,
+                api_base_url,
+                grant_type,
+                client_id,
+                client_secret,
+                api_token,
+                iiq_username,
+                iiq_password,
+                *[input_box for _, _, input_box in param_components]
+            ],
+            outputs=call_api_btn
+        )
+
+    for _, _, input_box in param_components:
+        input_box.change(
+            fn=validate_inputs,
+            inputs=[
+                spec_choice,
+                api_base_url,
+                grant_type,
+                client_id,
+                client_secret,
+                api_token,
+                iiq_username,
+                iiq_password,
+                *[input_box for _, _, input_box in param_components]
+            ],
+            outputs=call_api_btn
+        )
+    
     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
@@ -437,9 +546,11 @@ with gr.Blocks(
             confirmed_endpoints_state,
             display_values_state,
             param_group,
-            param_header,  # Add param_header to outputs
+            param_header,
+            loading_overlay,
+            call_api_btn,
             *[item for group, display, input_box in param_components 
-            for item in (group, display, input_box)]
+              for item in (group, display, input_box)]
         ]
     )