@qite/tide-client/src/services/odata.service.ts

Frontend client for Tide

import { Column, DataType, FilterItem, OdataParams } from "../types";

export const createParams = (
  filter: FilterItem,
  all: boolean,
  gridColumns?: Column[],
  mode?: string,
  forceToLower?: boolean
): OdataParams => {
  let params: OdataParams = {};
  if (!filter) return params;

  if (!all && filter.take == 0) {
    Object.assign(params, {
      $top: "0",
    });
  } else if (!all && filter.take) {
    Object.assign(params, {
      $skip: `${filter.take * (filter.page - 1)}`,
      $top: `${filter.take}`,
    });
  }

  if (filter.sort.name) {
    Object.assign(params, {
      $orderby: `${filter.sort.name} ${filter.sort.asc ? "asc" : "desc"}`,
    });
  }

  let filters = [];
  for (const columnName in filter.columns) {
    const column = filter.columns[columnName];

    if (column.value !== undefined) {
      if (typeof column.value === "string")
        column.value = column.value.replace(/[']/, "''");
      filters.push(
        getColumnFilter(
          column.type,
          column.value,
          columnName,
          gridColumns,
          forceToLower
        )
      );
    }
  }
  filters = filters.filter((x) => x);

  if (filters.length > 0) {
    Object.assign(params, {
      $filter: filters.join(mode || " and "),
    });
  }

  return params;
};

const getColumnFilter = (
  columnType: string,
  columnValue: any,
  columnName: string,
  gridColumns?: Column[],
  forceToLower?: boolean
) => {
  switch (columnType) {
    case DataType.text:
      if (forceToLower) {
        return `contains(tolower(${columnName}),tolower('${columnValue}'))`;
      } else {
        return `contains(${columnName},'${columnValue}')`;
      }

    case "textStart":
      return `startswith(${columnName},'${columnValue}')`;

    case "textExact":
      return `${columnName} eq '${columnValue || ""}'`;

    case "notEqualId":
      return `${columnName} ne ${columnValue}`;

    case "numberId":
    case DataType.bool:
    case DataType.enum:
    case DataType.int:
      return `${columnName} eq ${columnValue}`;

    case DataType.numeric:
      return `${columnName} ge ${columnValue}`;

    case DataType.date:
    case DataType.dateTime:
      const startDate = new Date(
        columnValue.year,
        columnValue.month - 1,
        columnValue.day
      );
      const tillDate = new Date(
        columnValue.year,
        columnValue.month - 1,
        columnValue.day + 1
      );

      if (isValidDate(startDate) && isValidDate(tillDate)) {
        return `${columnName} ge ${startDate.toISOString()} and ${columnName} le ${tillDate.toISOString()}`;
      }
      return "";
    case DataType.dateFrom:
      const fromDate = new Date(
        columnValue.year,
        columnValue.month - 1,
        columnValue.day
      );

      if (isValidDate(fromDate)) {
        return `${columnName} ge ${fromDate.toISOString()}`;
      }
      return "";
    case DataType.list:
      if (!gridColumns) return "";
      const gridColumn = gridColumns.find((x) => x.id == columnName);
      let filter: string = "";

      if (columnName.indexOf("_") !== -1) {
        columnName = columnName.split("_")[0];
      }

      if (gridColumn) {
        if (gridColumn.child.isFlat) {
          filter = getColumnFilter(gridColumn.child.dataType, columnValue, "x");
        } else {
          filter = getColumnFilter(
            gridColumn.child.dataType,
            columnValue,
            "x/" + gridColumn.child.valueField
          );
        }
      }

      return `${columnName}/any(x:${filter})`;

    case "dateRange":
      return `${columnName} ge ${columnValue[0].toISOString()} and ${columnName} le ${columnValue[1].toISOString()}`;

    case "inList":
      return `(${columnValue
        .map((value: any) => `${columnName} eq ${value}`)
        .join(" or ")})`;

    default:
      return "";
  }
};

const isValidDate = (d: any) => {
  return d instanceof Date && !isNaN(d.getTime());
};