repzo-sap-absjo 1.0.1

package/src/commands/bank.ts

@@ -0,0 +1,243 @@
+import Repzo from "repzo";
+import { Service } from "repzo/src/types";
+import DataSet from "data-set-query";
+import { CommandEvent, Result, FailedDocsReport } from "../types";
+import {
+  _fetch,
+  _create,
+  _update,
+  _delete,
+  update_bench_time,
+  date_formatting,
+  set_error,
+} from "../util.js";
+
+interface SAPBank {
+  BANKNAME: string; // "Jordan Kuwait Bank - DABUK BRANCH";
+  BANKCODE: string; // "20590";
+  BRANCH?: string; // "";
+  COUNTRY: string; // "JO";
+}
+
+interface SAPBanks {
+  result: "Success";
+  Banks: SAPBank[];
+}
+
+export const sync_bank = async (commandEvent: CommandEvent) => {
+  const repzo = new Repzo(commandEvent.app.formData?.repzoApiKey, {
+    env: commandEvent.env,
+  });
+
+  const commandLog = new Repzo.CommandLog(
+    repzo,
+    commandEvent.app,
+    commandEvent.command
+  );
+  try {
+    console.log("sync_bank");
+
+    const new_bench_time = new Date().toISOString();
+    const bench_time_key = "bench_time_bank";
+
+    await commandLog.load(commandEvent.sync_id);
+    await commandLog.addDetail("Repzo SAP: Started Syncing Banks").commit();
+
+    const nameSpace: string = commandEvent.nameSpace.join("_");
+    const result: Result & {
+      repzo_bank_list_total: number;
+      repzo_bank_list_updated: boolean;
+    } = {
+      sap_total: 0,
+      repzo_total: 0,
+      created: 0,
+      updated: 0,
+      failed: 0,
+      repzo_bank_list_total: 0,
+      repzo_bank_list_updated: false,
+    };
+    const failed_docs_report: FailedDocsReport = [];
+
+    const country_translator: { [key: string]: string } = {
+      JO: "Jordan",
+    };
+
+    // Bank **************************************************
+
+    const sap_banks: SAPBank[] = await get_sap_banks(
+      commandEvent.app.formData.sapHostUrl,
+      {}
+    );
+    result.sap_total = sap_banks?.length;
+
+    await commandLog.addDetail(`${result.sap_total} Banks in SAP`).commit();
+
+    const db = new DataSet([], { autoIndex: false });
+    db.createIndex({
+      BANKNAME: true,
+      BANKCODE: true,
+      COUNTRY: true,
+    });
+    db.load(sap_banks);
+
+    const sap_bank_query = sap_banks?.map(
+      (bank: SAPBank) => `${nameSpace}_${bank.BANKCODE}`
+    );
+
+    const repzo_banks = await repzo.bank.find({
+      "integration_meta.company_namespace": nameSpace,
+      per_page: 50000,
+    });
+    result.repzo_total = repzo_banks?.data?.length;
+    await commandLog
+      .addDetail(`${repzo_banks?.data?.length} Banks in Repzo`)
+      .commit();
+
+    for (let i = 0; i < sap_banks?.length; i++) {
+      const sap_bank: SAPBank = sap_banks[i];
+      const repzo_bank = repzo_banks.data.find(
+        (r_bank) =>
+          r_bank.integration_meta?.id == `${nameSpace}_${sap_bank.BANKCODE}`
+      );
+
+      const country = country_translator[sap_bank.COUNTRY];
+      if (!country && sap_bank.COUNTRY) {
+        throw `COUNTRY of COUNTRY Code: ${sap_bank.COUNTRY} was not found on the translator`;
+      }
+
+      const body: Service.Bank.Create.Body | Service.Bank.Update.Body = {
+        name: sap_bank.BANKNAME,
+        country: [country],
+        integration_meta: {
+          id: `${nameSpace}_${sap_bank.BANKCODE}`,
+          BANKCODE: sap_bank.BANKCODE,
+          COUNTRY: sap_bank.COUNTRY,
+          company_namespace: nameSpace,
+        },
+      };
+
+      if (!repzo_bank) {
+        // Create
+        try {
+          const created_bank = await repzo.bank.create(
+            body as Service.Bank.Create.Body
+          );
+          result.created++;
+        } catch (e: any) {
+          console.log("Create Bank Failed >> ", e?.response, body);
+          failed_docs_report.push({
+            method: "create",
+            doc: body,
+            error_message: set_error(e),
+          });
+          result.failed++;
+        }
+      } else {
+        if (
+          repzo_bank?.name == body?.name &&
+          repzo_bank?.integration_meta?.COUNTRY ==
+            body?.integration_meta?.COUNTRY &&
+          repzo_bank?.integration_meta?.BANKCODE ==
+            body?.integration_meta?.BANKCODE
+        )
+          continue;
+        // Update
+        try {
+          const updated_bank = await repzo.bank.update(
+            repzo_bank._id,
+            body as Service.Bank.Update.Body
+          );
+          result.updated++;
+        } catch (e: any) {
+          console.log("Update Bank Failed >> ", e?.response?.data, body);
+          failed_docs_report.push({
+            method: "update",
+            doc_id: repzo_bank?._id,
+            doc: body,
+            error_message: set_error(e),
+          });
+          result.failed++;
+        }
+      }
+    }
+
+    // console.log(result);
+    // *******************************************************
+
+    // Bank List *********************************************
+
+    const all_nameSpace_banks = await repzo.bank.find({
+      "integration_meta.company_namespace": nameSpace,
+      per_page: 50000,
+    });
+    const repzo_bankLists = await repzo.bank_list.find({
+      "integration_meta.id": nameSpace,
+      per_page: 50000,
+    });
+    result.repzo_bank_list_total = repzo_banks?.data?.length;
+
+    if (repzo_bankLists.data?.length > 1) {
+      throw `Each nameSpace should have One Bank List but nameSpace: ${nameSpace} more than one Bank List`;
+    }
+
+    const repzo_bank_list = repzo_bankLists?.data?.[0];
+    if (repzo_bank_list) {
+      const ids: { [key: string]: true } = {};
+      repzo_bank_list?.banks?.forEach((bank) => {
+        ids[bank?.bank?.toString()] = true;
+      });
+
+      all_nameSpace_banks?.data?.forEach((bank) => {
+        ids[bank?._id?.toString()] = true;
+      });
+
+      const new_banks = Object.keys(ids).map((bank_id) => {
+        return { bank: bank_id };
+      });
+
+      const repzo_bankList_updated = await repzo.bank_list.update(
+        repzo_bank_list?._id?.toString(),
+        {
+          ...repzo_bank_list,
+          banks: new_banks,
+        } as Service.BankList.Update.Body
+      );
+      result.repzo_bank_list_updated = true;
+    } else {
+      throw `Please Check with IT teams to create BankList for Your nameSpace`;
+    }
+    // *******************************************************
+
+    await update_bench_time(
+      repzo,
+      commandEvent.app._id,
+      bench_time_key,
+      new_bench_time
+    );
+    await commandLog
+      .setStatus(
+        "success",
+        failed_docs_report.length ? failed_docs_report : null
+      )
+      .setBody(result)
+      .commit();
+    return result;
+  } catch (e: any) {
+    //@ts-ignore
+    console.error(e?.response?.data || e);
+    await commandLog.setStatus("fail", e).commit();
+    throw e;
+  }
+};
+
+const get_sap_banks = async (
+  serviceEndPoint: string,
+  query?: { updateAt?: string }
+): Promise<SAPBank[]> => {
+  try {
+    const sap_banks: SAPBanks = await _create(serviceEndPoint, "/Banks", {});
+    return sap_banks.Banks;
+  } catch (e: any) {
+    throw e;
+  }
+};

package/src/commands/basic.ts

@@ -0,0 +1,64 @@
+import Repzo from "repzo";
+import { EVENT, Config, CommandEvent } from "../types";
+import { _fetch, _create, _update, _delete } from "../util.js";
+
+import { commands, commandsList } from "./index.js";
+export const basic = async (commandEvent: CommandEvent) => {
+  const repzo = new Repzo(commandEvent.app.formData?.repzoApiKey, {
+    env: commandEvent.env,
+  });
+
+  const commandLog = new Repzo.CommandLog(
+    repzo,
+    commandEvent.app,
+    commandEvent.command
+  );
+  try {
+    console.log("basic sync");
+
+    await commandLog.load(commandEvent.sync_id);
+    await commandLog.addDetail("Repzo SAP: Basic Sync").commit();
+
+    const required_syncing_commands: string[] = [
+      "join",
+      "warehouse",
+      "rep",
+      "tax",
+      "tag",
+      "measureunit",
+      "measureunit_family",
+      "category",
+      "channel",
+      "payment_term",
+      "bank",
+      "product",
+      "disabled_product",
+      "price_list",
+      "client",
+      "disabled_client",
+    ];
+
+    for (let i = 0; i < required_syncing_commands.length; i++) {
+      const command = required_syncing_commands[i];
+      const commandDes = commandsList.find((c) => c.command == command);
+      const event: CommandEvent = JSON.parse(JSON.stringify(commandEvent));
+      event.command = command;
+      await commandLog
+        .addDetail(`Start Syncing: ${commandDes?.name || command}`)
+        .commit();
+      await commands(event);
+      await commandLog.load(commandEvent.sync_id);
+    }
+
+    await commandLog
+      .setStatus("success")
+      .setBody({ message: "Basic Sync: Completed" })
+      .commit();
+  } catch (e: any) {
+    //@ts-ignore
+    console.error(e?.response?.data || e);
+    await commandLog.load(commandEvent.sync_id);
+    await commandLog.setStatus("fail", e).commit();
+    throw e;
+  }
+};

package/src/commands/category.ts

@@ -0,0 +1,176 @@
+import Repzo from "repzo";
+import { Service } from "repzo/src/types";
+import DataSet from "data-set-query";
+import { CommandEvent, Result, FailedDocsReport } from "../types";
+import {
+  _fetch,
+  _create,
+  _update,
+  _delete,
+  update_bench_time,
+  date_formatting,
+  set_error,
+} from "../util.js";
+
+interface SAPCategory {
+  GROUPDESC: string; // "Items",
+  GROUPCODE: string; // "100",
+  BRAND: null | string;
+}
+
+interface SAPCategories {
+  result: "Success";
+  ItemGroup: SAPCategory[];
+}
+
+export const sync_category = async (commandEvent: CommandEvent) => {
+  const repzo = new Repzo(commandEvent.app.formData?.repzoApiKey, {
+    env: commandEvent.env,
+  });
+
+  const commandLog = new Repzo.CommandLog(
+    repzo,
+    commandEvent.app,
+    commandEvent.command
+  );
+  try {
+    console.log("sync_category");
+
+    const new_bench_time = new Date().toISOString();
+    const bench_time_key = "bench_time_category";
+
+    await commandLog.load(commandEvent.sync_id);
+    await commandLog
+      .addDetail("Repzo SAP: Started Syncing Product Categories")
+      .commit();
+
+    const nameSpace: string = commandEvent.nameSpace.join("_");
+    const result: Result = {
+      sap_total: 0,
+      repzo_total: 0,
+      created: 0,
+      updated: 0,
+      failed: 0,
+    };
+    const failed_docs_report: FailedDocsReport = [];
+
+    const sap_categories: SAPCategory[] = await get_sap_categories(
+      commandEvent.app.formData.sapHostUrl,
+      {}
+    );
+    result.sap_total = sap_categories?.length;
+
+    await commandLog
+      .addDetail(`${result.sap_total} Item Groups in SAP`)
+      .commit();
+
+    const repzo_categories = await repzo.category.find({
+      per_page: 50000,
+    });
+    result.repzo_total = repzo_categories?.data?.length;
+    await commandLog
+      .addDetail(`${repzo_categories?.data?.length} Product Category in Repzo`)
+      .commit();
+
+    for (let i = 0; i < sap_categories?.length; i++) {
+      const sap_category: SAPCategory = sap_categories[i];
+      const repzo_category = repzo_categories.data.find(
+        (r_cat) =>
+          r_cat.integration_meta?.id == `${nameSpace}_${sap_category.GROUPCODE}`
+      );
+
+      const body: Service.Category.Create.Body | Service.Category.Update.Body =
+        {
+          name: sap_category.GROUPDESC,
+          disabled: false,
+          integration_meta: { id: `${nameSpace}_${sap_category.GROUPCODE}` },
+          company_namespace: [nameSpace],
+        };
+
+      if (!repzo_category) {
+        // Create
+        try {
+          const created_category = await repzo.category.create(
+            body as Service.Category.Create.Body
+          );
+          result.created++;
+        } catch (e: any) {
+          console.log("Create Product Category Failed >> ", e?.response, body);
+          failed_docs_report.push({
+            method: "create",
+            doc: body,
+            error_message: set_error(e),
+          });
+          result.failed++;
+        }
+      } else {
+        if (
+          repzo_category?.integration_meta?.id == body?.integration_meta?.id &&
+          repzo_category?.name == body?.name
+        ) {
+          continue;
+        }
+
+        // Update
+        try {
+          const updated_category = await repzo.category.update(
+            repzo_category._id,
+            body as Service.Category.Update.Body
+          );
+          result.updated++;
+        } catch (e: any) {
+          console.log(
+            "Update Product Category Failed >> ",
+            e?.response?.data,
+            body
+          );
+          failed_docs_report.push({
+            method: "update",
+            doc_id: repzo_category?._id,
+            doc: body,
+            error_message: set_error(e),
+          });
+          result.failed++;
+        }
+      }
+    }
+
+    // console.log(result);
+
+    await update_bench_time(
+      repzo,
+      commandEvent.app._id,
+      bench_time_key,
+      new_bench_time
+    );
+    await commandLog
+      .setStatus(
+        "success",
+        failed_docs_report.length ? failed_docs_report : null
+      )
+      .setBody(result)
+      .commit();
+    return result;
+  } catch (e: any) {
+    //@ts-ignore
+    console.error(e?.response?.data || e);
+    await commandLog.setStatus("fail", e).commit();
+    throw e;
+  }
+};
+
+const get_sap_categories = async (
+  serviceEndPoint: string,
+  query?: { updateAt?: string }
+): Promise<SAPCategory[]> => {
+  try {
+    const sap_categories: SAPCategories = await _create(
+      serviceEndPoint,
+      "/ItemGroup",
+      {}
+    );
+    return sap_categories.ItemGroup;
+  } catch (e: any) {
+    throw e;
+  }
+};

package/src/commands/channel.ts

@@ -0,0 +1,219 @@
+import Repzo from "repzo";
+import { Service } from "repzo/src/types";
+import DataSet from "data-set-query";
+import { CommandEvent, Result, FailedDocsReport } from "../types";
+import {
+  _fetch,
+  _create,
+  _update,
+  _delete,
+  update_bench_time,
+  date_formatting,
+  set_error,
+} from "../util.js";
+
+interface SAPClient {
+  CLIENTID: string; // "C01077";
+  CLIENTDESC: string; // "س م عايش";
+  CLIENTADDRESS?: string; // null;
+  CLIENTCITY?: string; // null;
+  CLIENTCOUNTRY?: string; // null;
+  CLIENTCOUNTY?: string; // null;
+  CLIENTGROUPCODE: number; // 123;
+  CLIENTGROUP: string; // "Cash Van";
+  PAYMENTTERM: number; // 0;
+  CLIENTCONTACTPERSON?: string; // null;
+  CLIENTPHONE1?: string; // null;
+  CLIENTPHONE2?: string; // null;
+  CLIENTNOTE?: string; // null;
+  CLIENTSTATUS: "N" | "Y";
+  CLIENTCREDITCONSUMED: number; // 0.0;
+  CLIENTMAXCHEQUEVALUE: number; // 0.0;
+  CLIENTCREDITLIMIT: number; // 0.0;
+  CLIENTPRICELISTID: number; // 2;
+  CLIENTADDRESSID?: string; // null;
+  CLIENTDESCF?: string; // null;
+  SALESPERSONCODE: number; // -1;
+  DISCOUNTPERCENT: number; // 0.0;
+  ACTIVE: "N" | "Y";
+  FROZEN: "N" | "Y";
+  TERRITORYID?: string; // null;
+  TERRITORYNAME?: string; // null;
+  CREATEDATE: string; // "2021-12-06T21:00:00Z";
+  UPDATEDATE: string; // "2022-11-29T21:00:00Z";
+  PARENTCODE?: string; // null;
+}
+
+interface SAPClients {
+  result: "Success";
+  Customers: SAPClient[];
+}
+
+export const sync_channel = async (commandEvent: CommandEvent) => {
+  const repzo = new Repzo(commandEvent.app.formData?.repzoApiKey, {
+    env: commandEvent.env,
+  });
+
+  const commandLog = new Repzo.CommandLog(
+    repzo,
+    commandEvent.app,
+    commandEvent.command
+  );
+  try {
+    console.log("sync_channel");
+
+    const new_bench_time = new Date().toISOString();
+    const bench_time_key = "bench_time_channel";
+
+    await commandLog.load(commandEvent.sync_id);
+    await commandLog
+      .addDetail("Repzo SAP: Started Syncing Client Channels")
+      .commit();
+
+    const nameSpace: string = commandEvent.nameSpace.join("_");
+    const result: Result = {
+      sap_total: 0,
+      repzo_total: 0,
+      created: 0,
+      updated: 0,
+      failed: 0,
+    };
+    const failed_docs_report: FailedDocsReport = [];
+
+    const sap_clients: SAPClient[] = await get_sap_clients(
+      commandEvent.app.formData.sapHostUrl,
+      {
+        updateAt: commandEvent.app.options_formData[bench_time_key],
+        GroupCode: commandEvent.app.formData.GroupCode,
+      }
+    );
+
+    const sap_unique_channels: { [key: string]: true } = {};
+    sap_clients?.forEach((client: SAPClient) => {
+      const channel = client.CLIENTGROUP;
+      sap_unique_channels[channel] = true;
+    });
+
+    const sap_channels = Object.keys(sap_unique_channels);
+
+    result.sap_total = sap_channels?.length;
+    await commandLog
+      .addDetail(
+        `${result.sap_total} Client Channels in SAP  changed since ${
+          commandEvent.app.options_formData[bench_time_key] || "ever"
+        }`
+      )
+      .commit();
+
+    const repzo_channels = await repzo.channel.find({ per_page: 50000 });
+    result.repzo_total = repzo_channels?.data?.length;
+    await commandLog
+      .addDetail(`${repzo_channels?.data?.length} Client Channels in Repzo`)
+      .commit();
+
+    for (let i = 0; i < sap_channels?.length; i++) {
+      const sap_channel: string = sap_channels[i];
+      const repzo_channel = repzo_channels.data.find(
+        (r_channel) =>
+          r_channel.integration_meta?.id == `${nameSpace}_${sap_channel}`
+      );
+
+      const body: Service.Channel.Create.Body | Service.Channel.Update.Body = {
+        name: sap_channel,
+        disabled: false,
+        integration_meta: {
+          id: `${nameSpace}_${sap_channel}`,
+        },
+        company_namespace: [nameSpace],
+      };
+
+      if (!repzo_channel) {
+        // Create
+        try {
+          const created_channel = await repzo.channel.create(
+            body as Service.Channel.Create.Body
+          );
+          result.created++;
+        } catch (e: any) {
+          console.log("Create Client Channel Failed >> ", e?.response, body);
+          failed_docs_report.push({
+            method: "create",
+            doc: body,
+            error_message: set_error(e),
+          });
+          result.failed++;
+        }
+      } else {
+        if (
+          repzo_channel?.name == body?.name &&
+          repzo_channel?.disabled == body?.disabled
+        )
+          continue;
+        // Update
+        try {
+          const updated_channel = await repzo.channel.update(
+            repzo_channel._id,
+            body as Service.Channel.Update.Body
+          );
+          result.updated++;
+        } catch (e: any) {
+          console.log(
+            "Update Client Channel Failed >> ",
+            e?.response?.data,
+            body
+          );
+          failed_docs_report.push({
+            method: "update",
+            doc_id: repzo_channel?._id,
+            doc: body,
+            error_message: set_error(e),
+          });
+          result.failed++;
+        }
+      }
+    }
+
+    // console.log(result);
+
+    await update_bench_time(
+      repzo,
+      commandEvent.app._id,
+      bench_time_key,
+      new_bench_time
+    );
+    await commandLog
+      .setStatus(
+        "success",
+        failed_docs_report.length ? failed_docs_report : null
+      )
+      .setBody(result)
+      .commit();
+    return result;
+  } catch (e: any) {
+    //@ts-ignore
+    console.error(e?.response?.data || e);
+    await commandLog.setStatus("fail", e).commit();
+    throw e;
+  }
+};
+
+const get_sap_clients = async (
+  serviceEndPoint: string,
+  query?: { updateAt?: string; GroupCode?: string }
+): Promise<SAPClient[]> => {
+  try {
+    const sap_clients: SAPClients = await _create(
+      serviceEndPoint,
+      "/Customers",
+      {
+        Active: "Y",
+        Frozen: "N",
+        UpdateAt: date_formatting(query?.updateAt, "YYYYMMDD:HHmmss"),
+        GroupCode: query?.GroupCode || "",
+      }
+    );
+    return sap_clients.Customers;
+  } catch (e: any) {
+    throw e;
+  }
+};