medreport_mrb2b/lib/services/medipost.service.ts

import {
  GetMessageListResponse,
  MedipostAction,
  Message,
} from "@/lib/types/medipost";
import axios from "axios";
import { xml2json } from "xml-js";

const BASE_URL = process.env.MEDIPOST_URL!;
const USER = process.env.MEDIPOST_USER!;
const PASSWORD = process.env.MEDIPOST_PASSWORD!;

export async function getMessages() {
  try {
    const publicMessage = await getLatestPublicMessageListItem();

    if (!publicMessage) {
      return [];
    }

    return getPublicMessage(publicMessage.messageId);
  } catch (error) {
    console.error(error);
  }
}

export async function getLatestPublicMessageListItem() {
  const { data } = await axios.get<GetMessageListResponse>(BASE_URL, {
    params: {
      Action: MedipostAction.GetPublicMessageList,
      User: USER,
      Password: PASSWORD,
      Sender: "syndev",
      // LastChecked (date+time) can be used here to get only messages since the last check - add when cron is created
      // MessageType check only for messages of certain type
    },
  });

  if (data.code && data.code !== 0) {
    throw new Error("Failed to get public message list");
  }

  return getLatestMessage(data?.messages);
}

export async function getPublicMessage(messageId: string) {
  const { data } = await axios.get(BASE_URL, {
    params: {
      Action: MedipostAction.GetPublicMessage,
      User: USER,
      Password: PASSWORD,
      MessageId: messageId,
    },
    headers: {
      Accept: "application/xml",
    },
  });

  if (data.code && data.code !== 0) {
    throw new Error(`Failed to get public message (id: ${messageId})`);
  }

  const parsed = JSON.parse(
    xml2json(data, {
      compact: true,
      spaces: 2,
    })
  );

  return parsed;
}

export async function sendPrivateMessage(messageXml: string, receiver: string) {
  const body = new FormData();
  body.append("Action", MedipostAction.SendPrivateMessage);
  body.append("User", USER);
  body.append("Password", PASSWORD);
  body.append("Receiver", receiver);
  body.append("MessageType", "Tellimus");
  body.append(
    "Message",
    new Blob([messageXml], {
      type: "text/xml; charset=UTF-8",
    })
  );

  const { data } = await axios.post(BASE_URL, body);

  if (data.code && data.code !== 0) {
    throw new Error(`Failed to send private message`);
  }
}

export async function getLatestPrivateMessageListItem() {
  const { data } = await axios.get<GetMessageListResponse>(BASE_URL, {
    params: {
      Action: MedipostAction.GetPrivateMessageList,
      User: USER,
      Password: PASSWORD,
    },
  });

  if (data.code && data.code !== 0) {
    throw new Error("Failed to get private message list");
  }

  return getLatestMessage(data?.messages);
}

export async function getPrivateMessage(messageId: string) {
  const { data } = await axios.get(BASE_URL, {
    params: {
      Action: MedipostAction.GetPrivateMessage,
      User: USER,
      Password: PASSWORD,
      MessageId: messageId,
    },
    headers: {
      Accept: "application/xml",
    },
  });

  if (data.code && data.code !== 0) {
    throw new Error(`Failed to get private message (id: ${messageId})`);
  }

  const parsed = JSON.parse(
    xml2json(data, {
      compact: true,
      spaces: 2,
    })
  );

  return parsed;
}

export async function deletePrivateMessage(messageId: string) {
  const { data } = await axios.get(BASE_URL, {
    params: {
      Action: MedipostAction.DeletePrivateMessage,
      User: USER,
      Password: PASSWORD,
      MessageId: messageId,
    },
  });

  if (data.code && data.code !== 0) {
    throw new Error(`Failed to delete private message (id: ${messageId})`);
  }
}

export async function readPrivateMessageResponse() {
  try {
    const privateMessage = await getLatestPrivateMessageListItem();

    if (!privateMessage) {
      return null;
    }

    const privateMessageContent = await getPrivateMessage(
      privateMessage.messageId
    );

    if (privateMessageContent) {
      // to be implemented: map and save, only delete if successful
      await deletePrivateMessage(privateMessage.messageId);
    }
  } catch (e) {
    console.error(e);
  }
}

function getLatestMessage(messages?: Message[]) {
  if (!messages?.length) {
    return null;
  }

  return messages.reduce((prev, current) =>
    Number(prev.messageId) > Number(current.messageId) ? prev : current
  );
}