Retrieve Results from E/M Coding 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 loadEmCodes(payload: any) {
  const sessionId: string = payload.session_id;
  const links: Record<string, Link[]> = payload._links ?? {};

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

  const response = await fetch(BASE_URL + API_PATH + codesLink.href, {
    headers: HEADERS,
  });
  if (!response.ok) {
    throw new Error(`E/M codes call failed: ${response.status}`);
  }

  const { em_codes } = await response.json();
  const values = em_codes.values ?? [];
  for (const item of values) {
    console.log(`${item.code} (${item.family}, level ${item.level})`);
  }
  return values;
}

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 loadEmCodes(payload map[string]any) ([]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
	}

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

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

	emCodes, _ := response["em_codes"].(map[string]any)
	values, _ := emCodes["values"].([]any)
	return values, nil
}

export async function getEmCodingStatus(
  links: Record<string, Link[]>,
  sessionId: string
) {
  const statusLink = linkFor(links, "status", sessionId);
  if (!statusLink) {
    throw new Error(`No status link found for session ${sessionId}`);
  }

  const response = await fetch(BASE_URL + API_PATH + statusLink.href, {
    headers: HEADERS,
  });
  if (!response.ok) {
    throw new Error(`Status call failed: ${response.status}`);
  }
  const data = await response.json();
  return data.status as string;
}

func getEmCodingStatus(links map[string][]link, sessionID string) (string, error) {
	statusLink, ok := linkFor(links, "status", sessionID)
	if !ok {
		return "", fmt.Errorf("no status link found for session %s", sessionID)
	}
	payload, err := getJSON(statusLink.Href)
	if err != nil {
		return "", err
	}
	status, _ := payload["status"].(string)
	return status, nil
}