rez-table-listing-mui/src/listing/libs/utils/apiColumn.ts

A rez table listing component built on TanStack Table

import { api, APP_CODE, MAPPED_ENTITY_TYPE } from "./common";
import {
  createSavedFilterPayload,
  deleteSavedFilterPayload,
  FilterDataMainFilterEntityListProps,
  updateSavedFilterPayload,
} from "../../types/filter";
import { viewSettingsDropDownAPIProps } from "../../types/common";

export const entityTableMetaMaster = async (entity_type: string) => {
  try {
    const response = await api.post(
      `/meta/get-table-data?entity_type=${entity_type}&list_type=${entity_type}`
    );

    const rawColumns = response.data?.data?.column_list || [];

    const res = rawColumns.map((item: any) => ({
      id: item.attribute_key,
      accessorKey: item.attribute_key,
      header: item.name,
    }));
    return { res };
  } catch (error) {
    console.error("Failed to fetch table meta:", error);
    return { res: [] };
  }
};

export const entityTableFilterMaster = async (
  entity_type: string,
  payload?: any
) => {
  try {
    const response = await api.post(
      `/meta/get-table-data?entity_type=${entity_type}&list_type=${entity_type}`,
      payload
    );

    // const filteredData = {
    //   ...response.data.data,
    //   column_list: response.data.data.column_list.filter(
    //     (item: any) => item.attribute_key !== "action"
    //   ),
    // };
    // return response.data.data;
    // return filteredData; // FOR ACTION COLUMN REMOVE
    return response.data.data;
  } catch (error) {
    console.error("Failed to fetch filter operation list meta:", error);
  }
};

export const fetchDetailsByFilterId = async (filterId: string | undefined) => {
  const response = await api.get(`/filter/${filterId}`);
  return response.data;
};

export const commonGetDropdownDataAPI = async (
  entity_type: string,
  // organization_id?: string | null,
  data?: any
) => {
  try {
    const requestBody = {
      status: "ACTIVE",
      organization_id: 1,
      ...data,
    };

    const response = await api.post(
      `/list-master/getDropdownData/${entity_type}`,
      requestBody
    );

    return response.data;
  } catch (error) {
    console.error("Failed to fetch dropdown data:", error);
    throw error;
  }
};

export const createSavedFilter = async (
  entity_type: string,
  payload: createSavedFilterPayload
) => {
  try {
    const response = await api.post(
      `/entity/create?entity_type=${entity_type}`,
      payload
    );
    return response.data;
  } catch (error) {
    console.error("Failed to fetch saved filter list:", error);
    throw error;
  }
};

export const deleteSavedFilter = async (
  entity_type: string,
  payload: deleteSavedFilterPayload
) => {
  try {
    const response = await api.post(
      `/entity/update/${payload?.id}?entity_type=${entity_type}`,
      payload
    );
    return response.data;
  } catch (error) {
    console.error("Failed to delete saved filter:", error);
    throw error;
  }
};

export const updateSavedFilter = async (
  entity_type: string,
  payload: updateSavedFilterPayload
) => {
  try {
    const response = await api.post(
      `/entity/update/${payload?.id}?entity_type=${entity_type}`,
      payload
    );
    return response.data;
  } catch (error) {
    console.error("Failed to update saved filter:", error);
    throw error;
  }
};

// ALL View Settings API
export const saveSettingsData = async (payload: any) => {
  try {
    const response = await api.post(
      `/entity/create?entity_type=${MAPPED_ENTITY_TYPE}`,
      payload
    );
    return response.data;
  } catch (error) {
    console.error("Failed to save settings data:", error);
    throw error;
  }
};

export const getSettingsData = async (entity_type: string, type: string) => {
  let url = `/meta/layout-preference`;

  // if (entity_type === USER || entity_type === ROLE || entity_type === ORGP) {
  //   url = `sso/layout`;
  // }

  const params = {
    entity_type: entity_type,
    type: type,
  };

  try {
    const response = await api.get(url, { params });
    return response.data;
  } catch (error) {
    console.error("Failed to fetch settings data:", error);
    throw error;
  }
};

export const viewSettingsDropDown = async ({
  entity_type,
  column,
  sort_by,
}: viewSettingsDropDownAPIProps): Promise<Array<string>> => {
  const response = await api.get(
    `meta/layout-preference/column?entity_type=${entity_type}&column=${column}&sort_by=${sort_by}`
  );

  return response.data;
};

export const getFilterEntityList = async (entity_type: string) => {
  const response = await api.get(
    `meta/entity-relation/${entity_type}?include=true`
  );

  return response.data;
};

export const getFilterCriteriaByEntity = async (
  selectedFilterEntity: FilterDataMainFilterEntityListProps | undefined
) => {
  const params = { entity_type: selectedFilterEntity?.value };

  const response = await api.get(
    `meta/attribute-master/getAttributes?direct=false&entity_type=${selectedFilterEntity?.value}`
  );

  return response.data;
};

export const getOperationList = async () => {
  const response = await api.post(`/meta/operation-list`);
  return response.data;
};

export const getLayoutAttributes = async ({
  entity_type,
  element_type,
}: {
  entity_type: string;
  element_type?: string;
}) => {
  const params = {
    element_type,
  };
  const response = await api.post(
    `meta/layout-preference/attributes`,
    { entity_type },
    { params }
  );
  return response.data;
};

export const getAttributes = async (
  entity_type: string,
  element_type?: string
) => {
  const response = await api.get("/meta/attribute-master/getAttributes", {
    params: {
      // direct: false, // commented as per requirement
      entity_type,
      ...(element_type && { element_type }),
    },
  });

  return response.data;
};

export const getTableTabs = async (payload: any) => {
  const response = await api.post(`filter/${APP_CODE}/tabs`, payload);
  return response.data;
};

export const newCommonGetDropdownDataAPI = async ({
  entity_type,
  attribute_key,
  // organization_id,
  data,
  inactiveIds,
  parentId,
}: {
  entity_type: string | undefined;
  attribute_key?: string;
  // organization_id?: string | null;
  data?: any;
  inactiveIds?: string | null;
  parentId?: number | string;
}) => {
  // Body can still accept optional custom data if needed
  const requestBody = data || {};

  // Build query params dynamically
  const queryParams: string[] = [];

  if (entity_type) queryParams.push(`entity_type=${entity_type}`);
  if (attribute_key) queryParams.push(`attribute_key=${attribute_key}`);
  if (!Number.isNaN(Number(inactiveIds)) && inactiveIds)
    queryParams.push(`inactiveIds=${inactiveIds}`);
  if (parentId !== undefined && parentId !== null)
    queryParams.push(`parent=${parentId}`);

  const queryString = queryParams.length > 0 ? `?${queryParams.join("&")}` : "";

  return await api
    .post(`entity/getAttributeDropdown${queryString}`, requestBody)
    .then((response) => response.data);
};

export const commonFetchDropdownDataAPI = async ({
  entity_type,
  enterprise_id,
  data,
  inactiveIds,
  parentId,
}: {
  entity_type: string | undefined;
  enterprise_id?: number;
  data?: any;
  inactiveIds?: string | null;
  parentId?: number | string;
}) => {
  const requestBody = {
    // status: "ACTIVE",
    enterprise_id,
    ...data,
  };

  let params = "";

  const queryParams: string[] = [];

  if (!Number.isNaN(Number(inactiveIds)) && inactiveIds) {
    queryParams.push(`inactiveIds=${inactiveIds}`);
  }

  if (parentId !== undefined && parentId !== null) {
    queryParams.push(`parent=${parentId}`);
  }

  if (queryParams.length > 0) {
    params = `?${queryParams.join("&")}`;
  }
  // if (entity_type === "ORGP") {
  //   return await api.get(`organization/sso/getdropdown`).then((response) => {
  //     return response.data;
  //   });
  // }
  return await api
    .post(`entity/getListMasterDropdown/${entity_type}${params}`, requestBody)
    .then((response) => {
      return response.data;
    });
};