ts-etl-mcu-upload-national/source/lib-etl.ts

import axios from "axios";
import config from "./config/config";
import logging from "./config/logging";
import { NAME_SPACE } from "./server";
export const getBranch = async () => {
  const url = config.base_url + "etl/Uploadnational/getbranch";
  logging.info(NAME_SPACE, "\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {},
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const getMgmMcu = async () => {
  const url = config.base_url + "etl/Uploadnational/getMgmMcu/";
  logging.info(NAME_SPACE, "\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {},
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const uploadMgmMcu = async (branch: any, data: any) => {
  const url = config.base_url + "etl/Uploadnational/uploadMgmMcu/";
  logging.info(NAME_SPACE, "\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {
        data: data,
        branch: branch,
      },
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const getMgmHeader = async (mgmMcuID: string) => {
  const url = config.base_url + "etl/Uploadnational/getMgmHeader/" + mgmMcuID;
  logging.info(NAME_SPACE, "\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {},
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const getTop3Kelainan = async (mgmMcuID: string) => {
  const url =
    config.base_url + "etl/Uploadnational/getTop3Kelainan/" + mgmMcuID;
  logging.info(NAME_SPACE, "\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {},
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const getMcuorder = async (mgmMcuID: string) => {
  const url = config.base_url + "etl/Uploadnational/getMcuorder/" + mgmMcuID;
  logging.info(NAME_SPACE, "\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {},
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const getAntropometri = async (mgmMcuID: string) => {
  const url =
    config.base_url + "etl/Uploadnational/getAntropometri/" + mgmMcuID;
  logging.info(NAME_SPACE, "\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {},
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const getMcuSnapshotNote = async (mgmMcuID: string) => {
  const url =
    config.base_url + "etl/Uploadnational/getMcuSnapshotNote/" + mgmMcuID;
  logging.info(NAME_SPACE, "\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {},
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const getMgmMou = async () => {
  const url = config.base_url + "etl/Uploadnational/getMgmMou/";
  logging.info(NAME_SPACE, "\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {},
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const uploadMgmHeader = async (branch: any, data: any) => {
  const url = config.base_url + "etl/Uploadnational/uploadMgmHeader/";
  logging.info(NAME_SPACE, "\t\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {
        data: data,
        branch: branch,
      },
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const getMgmDetail = async (mgmHeaderID: any) => {
  const url =
    config.base_url + "etl/Uploadnational/getMgmDetail/" + mgmHeaderID;
  logging.info(NAME_SPACE, "\t\t\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {},
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const getMgmRiwayat = async (mgmHeaderID: any) => {
  const url =
    config.base_url + "etl/Uploadnational/getMgmRiwayat/" + mgmHeaderID;
  logging.info(NAME_SPACE, "\t\t\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {},
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const uploadMgmDetail = async (branch: any, data: any) => {
  const url = config.base_url + "etl/Uploadnational/uploadMgmDetail/";
  logging.info(NAME_SPACE, "\t\t\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {
        data: data,
        branch: branch,
      },
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
    }
  }
};
export const uploadMgmRiwayat = async (branch: any, data: any) => {
  const url = config.base_url + "etl/Uploadnational/uploadMgmRiwayat/";
  logging.info(NAME_SPACE, "\t\t\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {
        data: data,
        branch: branch,
      },
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const uploadMgmMou = async (branch: any, data: any) => {
  const url = config.base_url + "etl/Uploadnational/uploadMgmMou/";
  logging.info(NAME_SPACE, "\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {
        data: data,
        branch: branch,
      },
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const uploadTop3Kelainan = async (branch: any, data: any) => {
  const url = config.base_url + "etl/Uploadnational/uploadTop3Kelainan/";
  logging.info(NAME_SPACE, "\t\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {
        data: data,
        branch: branch,
      },
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    // console.log(resp.data);
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const uploadMcuOrder = async (branch: any, data: any) => {
  const url = config.base_url + "etl/Uploadnational/uploadMcuOrder/";
  logging.info(NAME_SPACE, "\t\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {
        data: data,
        branch: branch,
      },
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    // console.log(resp.data);
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const uploadAntropometri = async (branch: any, data: any) => {
  const url = config.base_url + "etl/Uploadnational/uploadAntropometri/";
  logging.info(NAME_SPACE, "\t\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {
        data: data,
        branch: branch,
      },
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    // console.log(resp.data);
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const uploadMcuSnapshotNote = async (branch: any, data: any) => {
  const url = config.base_url + "etl/Uploadnational/uploadMcuSnapshotNote/";
  logging.info(NAME_SPACE, "\t\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {
        data: data,
        branch: branch,
      },
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    // console.log(resp.data);
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const uploadMgmCompany = async (branchCode: any, mgmMcuID: any) => {
  const url =
    config.base_url +
    "etl/Uploadnational/getcompany/" +
    mgmMcuID +
    "/" +
    branchCode;
  logging.info(NAME_SPACE, "\t\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {},
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    // console.log(resp.data);
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};
export const uploadMcuExecutiveTest = async (mgmMcuID: any) => {
  const url =
    config.base_url + "etl/Uploadnational/uploadExecutiveTest/" + mgmMcuID;
  logging.info(NAME_SPACE, "\t\t INFO : " + url);
  // logging.info(NAME_SPACE, "PRM : ", prm);
  try {
    const resp = await axios.post(
      url,
      {},
      {
        headers: { "Content-Type": "application/json; charset=UTF-8" },
        responseType: "arraybuffer",
      }
    );
    // console.log(resp.data);
    const jresp = JSON.parse(resp.data.toString());
    return jresp;
  } catch (e) {
    if (axios.isAxiosError(e)) {
      logging.error(NAME_SPACE, e.response?.data.toString());
      return {
        status: "ERR",
        message: e.response?.data.toString(),
      };
    } else if (e instanceof Error) {
      logging.error(NAME_SPACE, e.message);
      return {
        status: "ERR",
        message: e.message,
      };
    }
  }
};