Method Routings Create

simonredfern · simonredfern · commit 87301c31ee0b · 2026-02-03T07:23:05.000+01:00
diff --git a/src/routes/(protected)/integration/method-routings/+page.svelte b/src/routes/(protected)/integration/method-routings/+page.svelte
@@ -12,14 +12,17 @@
 
   let methodRoutings = $state<MethodRouting[]>([]);
   let methodNames = $state<string[]>([]);
+  let connectorNames = $state<string[]>([]);
+  let bankIds = $state<string[]>([]);
   let isLoading = $state(false);
   let isLoadingMethodNames = $state(false);
+  let isLoadingConnectors = $state(false);
   let error = $state<string | null>(null);
   let successMessage = $state<string | null>(null);
   let showCreateForm = $state(false);
   let editingRouting = $state<MethodRouting | null>(null);
 
-  const jsonPlaceholder = '{"key": "value"}';
+  const jsonPlaceholder = '{"param1": "value1", "param2": "value2"}';
 
   // Form state
   let formData = $state<MethodRouting>({
@@ -88,6 +91,53 @@
     }
   }
 
+  async function fetchConnectorNames() {
+    try {
+      isLoadingConnectors = true;
+
+      const response = await fetch("/api/system/connectors");
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const errorMsg = errorData.error || response.statusText;
+        console.error(`Failed to fetch connectors (${response.status}): ${errorMsg}`);
+        return;
+      }
+
+      const data = await response.json();
+
+      connectorNames = Array.isArray(data)
+        ? data
+        : data.connector_names || [];
+    } catch (err) {
+      console.error("Error fetching connector names:", err);
+    } finally {
+      isLoadingConnectors = false;
+    }
+  }
+
+  async function fetchBankIds() {
+    try {
+      const response = await fetch("/api/banks");
+
+      if (!response.ok) {
+        console.error(`Failed to fetch banks (${response.status})`);
+        return;
+      }
+
+      const data = await response.json();
+      const banks = Array.isArray(data) ? data : data.banks || [];
+
+      // Extract just the bank_id values
+      bankIds = banks
+        .map((b: { bank_id?: string }) => b.bank_id)
+        .filter((id: string | undefined): id is string => !!id)
+        .sort();
+    } catch (err) {
+      console.error("Error fetching bank IDs:", err);
+    }
+  }
+
   async function createMethodRouting() {
     try {
       isLoading = true;
@@ -202,6 +252,8 @@
   onMount(() => {
     fetchMethodRoutings();
     fetchMethodNames();
+    fetchConnectorNames();
+    fetchBankIds();
   });
 </script>
 
@@ -291,14 +343,30 @@
               <label for="connector_name" class="form-label">
                 Connector Name <span class="required">*</span>
               </label>
-              <input
-                type="text"
-                id="connector_name"
-                bind:value={formData.connector_name}
-                class="form-input"
-                placeholder="e.g., rest_vMar2019"
-                required
-              />
+              {#if isLoadingConnectors}
+                <div class="loading-text">Loading connectors...</div>
+              {:else if connectorNames.length > 0}
+                <select
+                  id="connector_name"
+                  bind:value={formData.connector_name}
+                  class="form-input"
+                  required
+                >
+                  <option value="">Select a connector</option>
+                  {#each connectorNames as connectorName}
+                    <option value={connectorName}>{connectorName}</option>
+                  {/each}
+                </select>
+              {:else}
+                <input
+                  type="text"
+                  id="connector_name"
+                  bind:value={formData.connector_name}
+                  class="form-input"
+                  placeholder="e.g., rest_vMar2019"
+                  required
+                />
+              {/if}
             </div>
 
             <div class="form-group">
@@ -310,8 +378,15 @@
                 id="bank_id_pattern"
                 bind:value={formData.bank_id_pattern}
                 class="form-input"
-                placeholder="e.g., gh.29.uk or .*"
+                placeholder="e.g., gh.29.uk or .* for all"
+                list="bank-ids-list"
               />
+              <datalist id="bank-ids-list">
+                {#each bankIds as bankId}
+                  <option value={bankId}></option>
+                {/each}
+              </datalist>
+              <div class="form-hint">Type a bank ID or pattern (e.g., .* for all banks)</div>
             </div>
 
             <div class="form-group">
@@ -336,6 +411,7 @@
                 rows="4"
                 placeholder={jsonPlaceholder}
               ></textarea>
+              <div class="form-hint">Optional key-value pairs as JSON object, e.g., {"{"}"key1": "value1", "key2": "value2"{"}"}</div>
             </div>
           </div>
 
@@ -562,6 +638,16 @@
     color: var(--color-surface-400);
   }
 
+  .form-hint {
+    font-size: 0.75rem;
+    color: #6b7280;
+    margin-top: 0.25rem;
+  }
+
+  :global([data-mode="dark"]) .form-hint {
+    color: var(--color-surface-400);
+  }
+
   .form-actions {
     display: flex;
     justify-content: flex-end;
diff --git a/src/routes/api/devops/connector-method-names/+server.ts b/src/routes/api/devops/connector-method-names/+server.ts
@@ -27,7 +27,7 @@ export const GET: RequestHandler = async ({ locals }) => {
 
   try {
     logger.info("=== CONNECTOR METHOD NAMES API CALL ===");
-    const endpoint = `/obp/v6.0.0/devops/connector-method-names`;
+    const endpoint = `/obp/v6.0.0/system/connector-method-names`;
     logger.info(`Request: ${endpoint}`);
 
     const response = await obp_requests.get(endpoint, accessToken);
diff --git a/src/routes/api/integration/connector-methods/+server.ts b/src/routes/api/integration/connector-methods/+server.ts
@@ -0,0 +1,55 @@
+import { json } from "@sveltejs/kit";
+import type { RequestHandler } from "./$types";
+import { obp_requests } from "$lib/obp/requests";
+import { extractErrorDetails } from "$lib/obp/errors";
+import { SessionOAuthHelper } from "$lib/oauth/sessionHelper";
+import { createLogger } from "$lib/utils/logger";
+
+const logger = createLogger("ConnectorMethodsAPI");
+
+// GET - Fetch all connector methods
+export const GET: RequestHandler = async ({ locals }) => {
+  const session = locals.session;
+
+  if (!session?.data?.user) {
+    logger.error("No user in session - returning 401");
+    return json(
+      { error: "Unauthorized - No user in session" },
+      { status: 401 },
+    );
+  }
+
+  const sessionOAuth = SessionOAuthHelper.getSessionOAuth(session);
+  const accessToken = sessionOAuth?.accessToken;
+
+  if (!accessToken) {
+    logger.error("No access token available for connector methods API call");
+    return json({ error: "No API access token available" }, { status: 401 });
+  }
+
+  try {
+    logger.info("=== CONNECTOR METHODS API CALL ===");
+    const endpoint = `/obp/v6.0.0/management/connector-methods`;
+    logger.info(`Request: ${endpoint}`);
+
+    const response = await obp_requests.get(endpoint, accessToken);
+
+    logger.info("Connector methods fetched successfully");
+    logger.info(`Response: ${response?.connectors_methods?.length || 0} connector methods`);
+
+    return json(response.connectors_methods || []);
+  } catch (err) {
+    logger.error("ERROR FETCHING CONNECTOR METHODS:", err);
+
+    // Extract full error details - NEVER hide or simplify OBP error messages!
+    const { message, obpErrorCode } = extractErrorDetails(err);
+
+    return json(
+      {
+        error: message,
+        obpErrorCode,
+      },
+      { status: 500 },
+    );
+  }
+};
diff --git a/src/routes/api/integration/method-routings/+server.ts b/src/routes/api/integration/method-routings/+server.ts
@@ -72,6 +72,59 @@ export const GET: RequestHandler = async ({ locals }) => {
   }
 };
 
+// Helper to transform parameters from form input to OBP format
+// OBP expects: parameters: [{key: "k1", value: "v1"}, {key: "k2", value: "v2"}]
+function transformParameters(params: unknown): Array<{key: string, value: string}> {
+  // If empty or null, return empty array
+  if (!params || params === "") {
+    return [];
+  }
+
+  // If already an array, return as-is
+  if (Array.isArray(params)) {
+    return params;
+  }
+
+  // If it's a string, try to parse it as JSON
+  if (typeof params === "string") {
+    const trimmed = params.trim();
+    if (!trimmed) {
+      return [];
+    }
+
+    try {
+      const parsed = JSON.parse(trimmed);
+
+      // If parsed result is an array, return it
+      if (Array.isArray(parsed)) {
+        return parsed;
+      }
+
+      // If parsed result is an object like {"key1": "value1", "key2": "value2"},
+      // convert to [{key: "key1", value: "value1"}, {key: "key2", value: "value2"}]
+      if (typeof parsed === "object" && parsed !== null) {
+        return Object.entries(parsed).map(([key, value]) => ({
+          key,
+          value: String(value),
+        }));
+      }
+    } catch {
+      logger.warn(`Failed to parse parameters as JSON: ${trimmed}`);
+      return [];
+    }
+  }
+
+  // If it's an object (but not array), convert entries
+  if (typeof params === "object" && params !== null) {
+    return Object.entries(params).map(([key, value]) => ({
+      key,
+      value: String(value),
+    }));
+  }
+
+  return [];
+}
+
 // POST - Create a new method routing
 export const POST: RequestHandler = async ({ request, locals }) => {
   const session = locals.session;
@@ -96,12 +149,23 @@ export const POST: RequestHandler = async ({ request, locals }) => {
 
   try {
     const body = await request.json();
-    logger.info("Creating method routing with data:", body);
+    logger.info("Creating method routing with raw data:", body);
+
+    // Transform the body for OBP API
+    const obpBody = {
+      method_name: body.method_name,
+      connector_name: body.connector_name,
+      is_bank_id_exact_match: body.is_bank_id_exact_match ?? false,
+      bank_id_pattern: body.bank_id_pattern || "",
+      parameters: transformParameters(body.parameters),
+    };
+
+    logger.info("Transformed body for OBP:", obpBody);
 
     const endpoint = `/obp/v3.1.0/management/method_routings`;
     logger.info(`Request: POST ${endpoint}`);
 
-    const response = await obp_requests.post(endpoint, body, accessToken);
+    const response = await obp_requests.post(endpoint, obpBody, accessToken);
 
     logger.info("Method routing created successfully");
     logger.debug(JSON.stringify(response, null, 2));
@@ -159,12 +223,23 @@ export const PUT: RequestHandler = async ({ request, locals }) => {
       );
     }
 
-    logger.info(`Updating method routing ${methodRoutingId} with data:`, body);
+    logger.info(`Updating method routing ${methodRoutingId} with raw data:`, body);
+
+    // Transform the body for OBP API
+    const obpBody = {
+      method_name: body.method_name,
+      connector_name: body.connector_name,
+      is_bank_id_exact_match: body.is_bank_id_exact_match ?? false,
+      bank_id_pattern: body.bank_id_pattern || "",
+      parameters: transformParameters(body.parameters),
+    };
+
+    logger.info("Transformed body for OBP:", obpBody);
 
     const endpoint = `/obp/v3.1.0/management/method_routings/${methodRoutingId}`;
     logger.info(`Request: PUT ${endpoint}`);
 
-    const response = await obp_requests.put(endpoint, body, accessToken);
+    const response = await obp_requests.put(endpoint, obpBody, accessToken);
 
     logger.info("Method routing updated successfully");
     logger.debug(JSON.stringify(response, null, 2));
diff --git a/src/routes/api/system/connectors/+server.ts b/src/routes/api/system/connectors/+server.ts
