Retrieve Results from Form Filling Webhook

const BASE_URL = "https://sdp.suki.ai";
const API_PATH = "/api/v1";
const HEADERS = { sdp_suki_token: "<sdp_suki_token>" };

type Link = {
  href: string;
  method: string;
  name: string;
  type: string;
};

function linkFor(
  links: Record<string, Link[]>,
  key: string,
  name: string
): Link | undefined {
  return (links[key] ?? []).find((link) => link.name === name);
}

export async function loadFormFillingResults(payload: any) {
  const sessionId: string = payload.session_id;
  const links: Record<string, Link[]> = payload._links ?? {};

  const structuredLink = linkFor(links, "structured_data", sessionId);
  if (!structuredLink) {
    throw new Error(`No structured_data link found for session ${sessionId}`);
  }

  const response = await fetch(BASE_URL + API_PATH + structuredLink.href, {
    headers: HEADERS,
  });
  if (!response.ok) {
    throw new Error(`Structured data call failed: ${response.status}`);
  }

  const { structured_data } = await response.json();

  for (const form of structured_data.generated_values ?? []) {
    console.log(`Filled: ${form.title} (${form.form_template_id})`);
  }
  for (const missing of structured_data.non_generated_values ?? []) {
    console.log(`Not filled: ${missing.form_template_id}`);
  }

  return structured_data;
}

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

const (
	baseURL   = "https://sdp.suki.ai"
	apiPath   = "/api/v1"
	sukiToken = "<sdp_suki_token>"
)

type link struct {
	Href   string `json:"href"`
	Method string `json:"method"`
	Name   string `json:"name"`
	Type   string `json:"type"`
}

func linkFor(links map[string][]link, key, name string) (link, bool) {
	for _, item := range links[key] {
		if item.Name == name {
			return item, true
		}
	}
	return link{}, false
}

func getJSON(path string) (map[string]any, error) {
	req, err := http.NewRequest(http.MethodGet, baseURL+apiPath+path, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("sdp_suki_token", sukiToken)

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()

	body, err := io.ReadAll(res.Body)
	if err != nil {
		return nil, err
	}
	if res.StatusCode < 200 || res.StatusCode >= 300 {
		return nil, fmt.Errorf("request failed: %s", res.Status)
	}

	var payload map[string]any
	if err := json.Unmarshal(body, &payload); err != nil {
		return nil, err
	}
	return payload, nil
}

func loadFormFillingResults(payload map[string]any) (map[string]any, error) {
	sessionID, _ := payload["session_id"].(string)
	rawLinks, _ := payload["_links"].(map[string]any)

	links := map[string][]link{}
	for key, value := range rawLinks {
		encoded, err := json.Marshal(value)
		if err != nil {
			return nil, err
		}
		var items []link
		if err := json.Unmarshal(encoded, &items); err != nil {
			return nil, err
		}
		links[key] = items
	}

	structuredLink, ok := linkFor(links, "structured_data", sessionID)
	if !ok {
		return nil, fmt.Errorf("no structured_data link found for session %s", sessionID)
	}

	response, err := getJSON(structuredLink.Href)
	if err != nil {
		return nil, err
	}

	structuredData, _ := response["structured_data"].(map[string]any)
	return structuredData, nil
}

export async function getFormFillingStatus(sessionId: string) {
  const response = await fetch(
    `${BASE_URL}${API_PATH}/form-filling/session/${sessionId}/status`,
    { headers: HEADERS }
  );
  if (!response.ok) {
    throw new Error(`Status call failed: ${response.status}`);
  }
  const data = await response.json();
  return data.status as string;
}

func getFormFillingStatus(sessionID string) (string, error) {
	payload, err := getJSON("/form-filling/session/" + sessionID + "/status")
	if err != nil {
		return "", err
	}
	status, _ := payload["status"].(string)
	return status, nil
}