@opengis/gis 0.2.177 → 0.2.179

package/server/routes/registers/functions/getFilterSQLParametrized/formatValue.js

@@ -0,0 +1,312 @@
+import { pgClients } from "@opengis/fastify-table/utils.js";
+
+import getRangeQuery from "./getRangeQuery.js";
+
+const selectFilterTypes = [
+  "check",
+  "autocomplete",
+  "tags",
+  "avatar",
+  "radio",
+  "select",
+  "button",
+];
+const matchNullObj = {
+  null: "is null",
+  notnull: "is not null",
+};
+
+export default function formatValue(
+  {
+    table,
+    filter = {},
+    name,
+    value,
+    dataTypeID,
+    uid = "2",
+    args: argsParams,
+  },
+  pg = pgClients.client
+) {
+  const { sql, select, strict, options, optionsFromColumns, api } = filter;
+
+  const filterType = filter.type?.toLowerCase?.() || "text";
+
+  const args = Array.from(argsParams || []);
+
+  const sval =
+    typeof value === "string"
+      ? `%${decodeURIComponent(value.replace(/%/g, "%25")).replace(
+        /%/g,
+        "\\%"
+      )}%`
+      : undefined;
+
+  if (filterType === "text" && typeof value === "string" && filter?.columns) {
+    args.push(sval);
+    const columns = filter.columns.split(",");
+
+    const query = `(${columns
+      .map((el) => `"${el}"::text ilike $${args.length}`)
+      .join(" or ")})`;
+    return { op: "~", query, values: [sval] };
+  }
+
+  const fieldType =
+    pg?.pgType?.[dataTypeID] ||
+    pg?.pgType?.[{ date: 1114 }[filterType] || 25];
+
+  if (
+    !name ||
+    !value ||
+    (!dataTypeID && !sql && !options) ||
+    (!selectFilterTypes.includes(filterType) &&
+      options?.find?.((el) => el?.sql))
+  ) {
+    return {};
+  }
+
+  // my rows
+  if (value === "me" && uid) {
+    args.push(uid);
+    return { op: "=", query: `${name}::text = $${args.length}`, values: [uid] };
+  }
+
+  const matchNull = matchNullObj[value];
+
+  const includesNull =
+    !matchNull &&
+    value &&
+    value.includes(",") &&
+    (value.startsWith("null") ||
+      value.includes(",null") ||
+      value.startsWith("notnull") ||
+      value.includes(",notnull"));
+
+  const includesNull1 = includesNull
+    ? value
+      .split(",")
+      .map((el) => matchNullObj[el])
+      .filter(Boolean)
+    : undefined;
+
+  // skip if requested both: is null and not null
+  const includesNullQuery =
+    includesNull1 && includesNull1.length > 1 ? undefined : includesNull1?.[0];
+
+  // geometry
+  if (["geometry"].includes(fieldType || "")) {
+    if (matchNull) {
+      return { op: "nullable", query: `${name} ${matchNull}` };
+    }
+
+    const bbox = value?.[0]?.split?.("_");
+
+    if (bbox?.length !== 4) {
+      return {};
+    }
+
+    const query = ` ${name} && 'box(${bbox[0]} ${bbox[1]},${bbox[2]} ${bbox[3]})'::box2d `;
+    return { op: "&&", query };
+  }
+
+  const op = filterType === "text" && !strict ? "~" : "=";
+  // text
+  if (["text"].includes(filterType)) {
+    // with sql subquery
+    if (typeof sql === "string") {
+      args.push(value);
+      const querysql = sql
+        .replace(/= ?any\(\$1\)/g, `::text=any($${args.length}::text[])`)
+        .replace(/\$1/g, `$${args.length}`);
+      return { op: "=", query: querysql, values: [[value]] };
+    }
+
+    // default
+    if (!select) {
+      const value1 = op === "~" ? `%${value}%` : value;
+      args.push(value1);
+      const query = `${name}::text ${op === "~" ? "ilike" : "="} $${args.length
+        }`;
+      return {
+        op,
+        query,
+        values: [value1],
+      };
+    }
+  }
+
+  // nullable
+  if (matchNull) {
+    const query = `${name} ${matchNull}`;
+    return { op, query };
+  }
+
+  // boolean
+  if (fieldType === "boolean" && ["true", "false"].includes(value)) {
+    const query = `${name} IS ${value === "true" ? "TRUE" : "FALSE"}`;
+    return { op, query };
+  }
+
+  // boolean + nullable
+  const value1 = ["true", "false"].find((el) => value.includes(el));
+  const values = ["true", "false"].filter((el) => value.includes(el));
+
+  // boolean: true, false and null => skip
+  if (fieldType === "boolean" && values.length === 2 && !!includesNullQuery) {
+    return { op, query: "3=3" };
+  }
+
+  // boolean: both true and false => not null
+  if (fieldType === "boolean" && values.length === 2) {
+    return { op, query: `${name} is not null` };
+  }
+
+  // boolean: not null over any value
+  if (
+    fieldType === "boolean" &&
+    value1 &&
+    includesNullQuery === "is not null"
+  ) {
+    const query = `${name} ${includesNullQuery}`;
+    return { op, query };
+  }
+
+  // boolean: true or null
+  if (
+    fieldType === "boolean" &&
+    value1 &&
+    includesNullQuery === "is null" &&
+    value1 === "true"
+  ) {
+    return { op, query: `${name} IS NOT FALSE` };
+  }
+
+  // boolean: false or null
+  if (
+    fieldType === "boolean" &&
+    value1 &&
+    includesNullQuery === "is null" &&
+    value1 === "false"
+  ) {
+    return { op, query: `${name} IS NOT TRUE` };
+  }
+
+  // select / cls - any filter type w/ out sql subquery
+  if (
+    value &&
+    select &&
+    Array.isArray(options) &&
+    !options.find((el) => el?.sql)
+  ) {
+    const value1 = value.split(",");
+    // by id (checkbox)
+    if (options.find((el) => el?.id && value1.includes(el.id))) {
+      args.push(value1);
+      if (fieldType && fieldType.endsWith("[]")) {
+        const query = `EXISTS ( SELECT 1 FROM unnest(${name}) AS elem WHERE elem in (with q(id, name) as (${select}) select id from q where id = any($${args.length}) ) )`;
+        return {
+          op,
+          query,
+          values: [value1],
+        };
+      }
+
+      const query = `${name}::text in ( ( with q(id,name) as (${select}) select id from q where id = any($${args.length}) ) )`;
+      return {
+        op,
+        query,
+        values: [value1],
+      };
+    }
+    // by text
+    args.push(`%${value1[0]}%`);
+    return {
+      op,
+      query: `${name}::text in ( ( with q(id,name) as (${select}) select id from q where name::text ilike $${args.length} ) )`,
+      values: [`%${value1[0]}%`],
+    };
+  }
+
+  // date: 01.01.2024-31.12.2024 / number range: 100-500
+  if (["date", "datepicker", "range"].includes(filterType)) {
+    const { query, values } = getRangeQuery({
+      value,
+      name,
+      fieldType,
+      filterType,
+      sql,
+      args,
+    });
+    return { op: "between", query, values };
+  }
+
+  /* select query - from admin.cls / filter options */
+  if (selectFilterTypes.includes(filterType)) {
+    // multiple checks with predefined query
+    if (options?.find?.((el) => el?.sql)) {
+      const query =
+        options
+          .filter((el) => value.split(",").includes(el.id?.toString?.()))
+          .map((el) => el.sql || "false")
+          .join(" and ") || "false";
+      return { op: "=", query };
+    }
+
+    // with sql subquery
+    if (sql) {
+      args.push(value);
+      const querysql = sql
+        .replace(/= ?any\(\$1\)/g, `::text=any($${args.length}::text[])`)
+        .replace(/\$1/g, `$${args.length}`);
+      return { op: "=", query: querysql, values: [[value]] };
+    }
+
+    // if pseudo-suggest column contain commas
+    if (optionsFromColumns && options?.length) {
+      const optionValues = options.map((e) => e.id);
+      const vals = optionValues.filter((e) => value.includes(e));
+      args.push(vals);
+      return {
+        op: "=",
+        query: `${name}::text=any($${args.length}::text[])`,
+        values: vals,
+      };
+    }
+
+    // default
+    args.push(value);
+
+    if (fieldType?.includes("[]")) {
+      const query = `${name}::text[] && $${args.length}::text[]`;
+
+      return {
+        op: "=",
+        query,
+        values: [value.split(",")],
+      };
+    }
+
+    if (api && api.startsWith('/api/gis-suggest/')) {
+      const query = fieldType?.includes("[]") ? `EXISTS (
+        SELECT 1
+        FROM unnest(${name}) AS value
+        WHERE rtrim(
+          replace(replace(replace(encode(value::bytea, 'base64'), '+', ''), '-', ''), '/', ''),
+          '='
+        ) = ANY($${args.length})
+      )`
+        : `rtrim( replace( replace( replace( encode(${name}::bytea, 'base64'), '+', '' ), '-', '' ), '/', '' ), '=' )=any($${args.length})`;
+
+      return {
+        op: "=",
+        query,
+        values: [value.split(",")],
+      };
+    }
+
+    const query = `${name}::text=any($${args.length})`;
+    return { op: "=", query, values: [value.split(",")] };
+  }
+  return {};
+}

package/server/routes/registers/functions/getFilterSQLParametrized/getFilterQuery.js

@@ -0,0 +1,126 @@
+/* eslint-disable no-continue */
+
+import { pgClients } from "@opengis/fastify-table/utils.js";
+
+import formatValue from "./formatValue.js";
+
+/**
+ * @param {Number} opt.json - (1|0) 1 - Результат - Object, 0 - String
+ * @param {String} opt.query - запит до таблиці
+ * @param {String} opt.hash - інформація з хешу по запиту
+ */
+
+function getFilterQuery(
+  {
+    filter: filterStr = "",
+    table = "",
+    tableSQL = [],
+    fields,
+    filterList,
+    uid,
+    objectId,
+    args,
+  },
+  pg = pgClients.client
+) {
+  // if (!filterStr) return null; // filter list API
+  const mainOperators = ["=", "~", ">", "<"];
+  const filterQueryArray =
+    decodeURIComponent(
+      filterStr
+        ?.replace?.(/%/g, "%25")
+        ?.replace?.(/%/g, "\\%")
+        ?.replace?.(/(^,)|(,$)/g, "")
+    )
+      ?.replace?.(/'/g, "''")
+      ?.split?.(/[;|]/) || [];
+  // default filter value form checkboxes, autocomplete or sql-defined only - if not called from card
+  const filterDefaultQueryArray = !objectId
+    ? filterList
+      ?.filter?.(
+        (el) =>
+          el.name &&
+          !filterStr?.includes?.(`${el.name}=`) &&
+          el.default &&
+          (el.options || el.sql)
+      )
+      ?.map?.((el) => `${el.name}=${el.default}`) || []
+    : [];
+
+  // concat default + request filters
+  const arr = filterQueryArray.concat(filterDefaultQueryArray).filter(Boolean);
+
+  const resultList = [];
+
+  for (let i = 0; i < arr.length; i += 1) {
+    const item = arr[i];
+    if (!item) {
+      continue;
+    }
+    const splitby = mainOperators?.find((el) => item.indexOf(el) !== -1) || "=";
+    const [name] = item.split(splitby);
+
+    // skip already added filter
+    if (resultList.find((el) => el.name === name)) {
+      continue;
+    }
+
+    // filter
+    const filter = filterList?.find?.((el) => el.type && el.name === name) || {
+      type: "text",
+    };
+
+    // find all value
+    const value = arr
+      .filter((el) => el.split(splitby)?.[0] === name)
+      .map((el) => el.substring((name?.length || 0) + 1))
+      .join(",");
+
+    // find field and skip not exists
+    const { dataTypeID } =
+      fields?.find((el) => el.name === name) ||
+      {};
+
+    // format query
+    const {
+      op,
+      query,
+      values: filterValues,
+    } = formatValue(
+      {
+        table,
+        filter,
+        name,
+        value,
+        dataTypeID,
+        uid,
+        args,
+      },
+      pg
+    ) || {};
+
+    if (!query) {
+      continue;
+    }
+
+    if (
+      args &&
+      filterValues &&
+      Array.isArray(filterValues) &&
+      filterValues.length
+    ) {
+      filterValues.forEach((val) => args.push(val));
+    }
+
+    resultList.push({
+      name,
+      value,
+      values: filterValues,
+      query,
+      operator: op,
+    });
+  }
+  return resultList;
+}
+
+export default getFilterQuery;