rez_core 7.1.21 → 7.1.22

package/src/module/entity/filter/service/helpers/db-col.helper.ts

@@ -0,0 +1,245 @@
+import { BadRequestException } from '@nestjs/common';
+import { FilterCondition } from '../../dto/filter-request.dto';
+import { AttributeMetadata, WhereClause } from './filter2.types';
+
+/**
+ * DB_COL Helper Functions
+ *
+ * Handles all database column (regular table columns) filtering logic including:
+ * - DB_COL condition building for different data types
+ * - Text, number, date, select, year conditions
+ */
+
+/**
+ * Process DB_COL filter and add to clauses
+ */
+export function processDbColFilter(
+  filter: FilterCondition,
+  meta: AttributeMetadata,
+  dbColClauses: WhereClause[],
+): void {
+  const clause = buildDbColCondition(filter, meta);
+  if (clause) {
+    dbColClauses.push(clause);
+  }
+}
+
+/**
+ * Build condition for DB_COL attributes
+ */
+export function buildDbColCondition(
+  filter: FilterCondition,
+  meta: AttributeMetadata,
+): WhereClause | null {
+  if (!meta) return null;
+
+  const attr = filter.filter_attribute;
+  const val = filter.filter_value;
+  const op = filter.filter_operator;
+  const key = `param_${attr}_${Math.random().toString(36).substring(2, 8)}`;
+
+  switch (meta.element_type) {
+    case 'text':
+    case 'textarea':
+    case 'email':
+    case 'phone':
+    case 'password':
+    case 'url':
+    case 'label':
+      return buildTextCondition(attr, op, val, key);
+    case 'number':
+    case 'file-upload':
+    case 'decimal':
+      return buildNumberCondition(attr, op, val, key);
+    case 'date':
+    case 'datetime':
+      return buildDateCondition(attr, op, val, key);
+    case 'select':
+    case 'radio':
+    case 'multiselect':
+    case 'multicheckbox':
+    case 'checkbox':
+      return buildSelectCondition(attr, op, val, key);
+    case 'year':
+      return buildYearCondition(attr, op, val, key);
+    default:
+      return buildTextCondition(attr, op, val, key);
+  }
+}
+
+/**
+ * Build text condition (LIKE, =, !=, NULL)
+ */
+export function buildTextCondition(
+  attr: string,
+  op: string,
+  val: any,
+  key: string,
+): WhereClause | null {
+  switch (op) {
+    case 'contains':
+      return {
+        query: `LOWER(e.${attr}) LIKE :${key}`,
+        params: { [key]: `%${val ? val.toLowerCase() : ''}%` },
+      };
+    case 'equal':
+      return { query: `e.${attr} = :${key}`, params: { [key]: val } };
+    case 'not_equal':
+      return { query: `e.${attr} != :${key}`, params: { [key]: val } };
+    case 'empty':
+      return { query: `e.${attr} IS NULL`, params: {} };
+    case 'not_empty':
+      return { query: `e.${attr} IS NOT NULL`, params: {} };
+    default:
+      throw new BadRequestException(`Unsupported operator for text: ${op}`);
+  }
+}
+
+/**
+ * Build number condition (=, !=, >, <, >=, <=, NULL)
+ */
+export function buildNumberCondition(
+  attr: string,
+  op: string,
+  val: any,
+  key: string,
+): WhereClause | null {
+  switch (op) {
+    case 'equal':
+      return { query: `e.${attr} = :${key}`, params: { [key]: val } };
+    case 'not_equal':
+      return { query: `e.${attr} != :${key}`, params: { [key]: val } };
+    case 'greater_than':
+      return { query: `e.${attr} > :${key}`, params: { [key]: val } };
+    case 'less_than':
+      return { query: `e.${attr} < :${key}`, params: { [key]: val } };
+    case 'less_than_qual_to':
+      return { query: `e.${attr} <= :${key}`, params: { [key]: val } };
+    case 'greater_than_qual_to':
+      return { query: `e.${attr} >= :${key}`, params: { [key]: val } };
+    case 'empty':
+      return { query: `e.${attr} IS NULL`, params: {} };
+    case 'not_empty':
+      return { query: `e.${attr} IS NOT NULL`, params: {} };
+    default:
+      throw new BadRequestException(`Unsupported operator for number: ${op}`);
+  }
+}
+
+/**
+ * Build date condition (=, <, >, between, NULL)
+ */
+export function buildDateCondition(
+  attr: string,
+  op: string,
+  val: any,
+  key: string,
+): WhereClause | null {
+  const dateColumn = `DATE(e.${attr})`;
+
+  switch (op) {
+    case 'equal':
+    case 'is':
+      return { query: `${dateColumn} = :${key}`, params: { [key]: val } };
+    case 'before':
+    case 'is_before':
+      return { query: `${dateColumn} < :${key}`, params: { [key]: val } };
+    case 'after':
+    case 'is_after':
+      return { query: `${dateColumn} > :${key}`, params: { [key]: val } };
+    case 'is_on_or_before':
+      return { query: `${dateColumn} <= :${key}`, params: { [key]: val } };
+    case 'is_on_or_after':
+      return { query: `${dateColumn} >= :${key}`, params: { [key]: val } };
+    case 'between': {
+      let valArray =
+        typeof val === 'string' ? val.split(',').map((v) => v.trim()) : val;
+      if (!Array.isArray(valArray) || valArray.length !== 2) return null;
+      return {
+        query: `${dateColumn} BETWEEN :${key}_start AND :${key}_end`,
+        params: { [`${key}_start`]: valArray[0], [`${key}_end`]: valArray[1] },
+      };
+    }
+    case 'empty':
+      return { query: `e.${attr} IS NULL`, params: {} };
+    case 'not_empty':
+      return { query: `e.${attr} IS NOT NULL`, params: {} };
+    default:
+      throw new BadRequestException(`Unsupported operator for date: ${op}`);
+  }
+}
+
+/**
+ * Build select/multiselect condition (=, !=, IN, NOT IN, NULL)
+ */
+export function buildSelectCondition(
+  attr: string,
+  op: string,
+  val: any,
+  key: string,
+): WhereClause | null {
+  let arr: string[] = [];
+
+  if (Array.isArray(val)) {
+    arr = val.map((v) => String(v));
+  } else if (typeof val === 'string') {
+    arr = val.split(',').map((v) => v.trim());
+  } else {
+    arr = [String(val)];
+  }
+
+  if (arr.length === 0) return { query: '1=1', params: {} };
+
+  switch (op) {
+    case 'equal':
+      return {
+        query: `e.${attr}::text = ANY(:${key})`,
+        params: { [key]: `{${arr.join(',')}}` },
+      };
+    case 'not_equal':
+      return {
+        query: `NOT (e.${attr}::text = ANY(:${key}))`,
+        params: { [key]: `{${arr.join(',')}}` },
+      };
+    case 'contains':
+      return {
+        query: `e.${attr}::text LIKE :${key}`,
+        params: { [key]: `%${val}%` },
+      };
+    case 'not_contains':
+      return {
+        query: `e.${attr}::text NOT LIKE :${key}`,
+        params: { [key]: `%${val}%` },
+      };
+    case 'empty':
+      return { query: `e.${attr} IS NULL`, params: {} };
+    case 'not_empty':
+      return { query: `e.${attr} IS NOT NULL`, params: {} };
+    default:
+      throw new BadRequestException(`Unsupported operator: ${op}`);
+  }
+}
+
+/**
+ * Build year condition (=, !=, >, <)
+ */
+export function buildYearCondition(
+  attr: string,
+  op: string,
+  val: any,
+  key: string,
+): WhereClause | null {
+  const yearVal = parseInt(val, 10);
+  switch (op) {
+    case 'equal':
+      return { query: `e.${attr} = :${key}`, params: { [key]: yearVal } };
+    case 'not_equal':
+      return { query: `e.${attr} != :${key}`, params: { [key]: yearVal } };
+    case 'greater_than':
+      return { query: `e.${attr} > :${key}`, params: { [key]: yearVal } };
+    case 'less_than':
+      return { query: `e.${attr} < :${key}`, params: { [key]: yearVal } };
+    default:
+      throw new BadRequestException(`Unsupported operator for year: ${op}`);
+  }
+}

package/src/module/entity/filter/service/helpers/eav.helper.ts

@@ -0,0 +1,294 @@
+import { BadRequestException } from '@nestjs/common';
+import { FilterCondition } from '../../dto/filter-request.dto';
+import { AttributeMetadata, EavJoinInfo, WhereClause } from './filter2.types';
+
+/**
+ * EAV Helper Functions
+ *
+ * Handles all Entity-Attribute-Value related logic including:
+ * - EAV table mapping
+ * - EAV join generation
+ * - EAV condition building for different data types
+ */
+
+/**
+ * Get EAV table name based on element type
+ */
+export function getEavTableName(elementType: string): string {
+  const normalized = elementType?.toLowerCase().trim();
+  const mapping: Record<string, string> = {
+    'label': 'frm_eav_varchar',
+    'text': 'frm_eav_varchar',
+    'textarea': 'frm_eav_varchar',
+    'select': 'frm_eav_varchar',
+    'number': 'frm_eav_int',
+    'decimal': 'frm_eav_decimal',
+    'date': 'frm_eav_date',
+    'time': 'frm_eav_time',
+    'datetime': 'frm_eav_timestamp',
+    'file-upload': 'frm_eav_int',
+    'text-editor': 'frm_eav_text',
+    'phone': 'frm_eav_varchar',
+    'email': 'frm_eav_varchar',
+    'checkbox': 'frm_eav_boolean',
+    'multicheckbox': 'frm_eav_varchar',
+    'radio': 'frm_eav_varchar',
+    'password': 'frm_eav_varchar',
+    'url': 'frm_eav_varchar',
+    'json-editor': 'frm_eav_json',
+    'custom-chip-input': 'frm_eav_varchar',
+    'multiselect': 'frm_eav_text',
+  };
+  return mapping[normalized] || 'frm_eav_varchar';
+}
+
+/**
+ * Check if attribute is stored in EAV table
+ */
+export function isEavAttribute(metadata: AttributeMetadata): boolean {
+  return metadata?.storage_type?.toUpperCase() === 'EAV';
+}
+
+/**
+ * Process EAV filter and add to joins/clauses
+ */
+export function processEavFilter(
+  filter: FilterCondition,
+  meta: AttributeMetadata,
+  index: number,
+  eavJoins: EavJoinInfo[],
+  eavClauses: WhereClause[],
+): void {
+  const eavTableName = getEavTableName(meta.element_type);
+  const alias = `eav_${filter.filter_attribute}_${index}`;
+
+  // Add EAV join info
+  eavJoins.push({
+    alias,
+    tableName: eavTableName,
+    entityType: meta.mapped_entity_type,
+    attributeKey: filter.filter_attribute,
+  });
+
+  // Build EAV condition
+  const clause = buildEavCondition(filter, meta, alias);
+  if (clause) {
+    eavClauses.push(clause);
+  }
+}
+
+/**
+ * Build condition for EAV attributes
+ * Routes to appropriate builder based on element type
+ */
+export function buildEavCondition(
+  filter: FilterCondition,
+  meta: AttributeMetadata,
+  alias: string,
+): WhereClause | null {
+  if (!meta) return null;
+
+  const attr = filter.filter_attribute;
+  const val = filter.filter_value;
+  const op = filter.filter_operator;
+  const key = `param_${attr}_${Math.random().toString(36).substring(2, 8)}`;
+
+  switch (meta.element_type) {
+    case 'text':
+    case 'textarea':
+    case 'email':
+    case 'phone':
+    case 'password':
+    case 'url':
+    case 'label':
+    case 'text-editor':
+      return buildEavTextCondition(alias, op, val, key);
+    case 'number':
+    case 'file-upload':
+    case 'decimal':
+      return buildEavNumberCondition(alias, op, val, key);
+    case 'date':
+    case 'datetime':
+      return buildEavDateCondition(alias, op, val, key);
+    case 'checkbox':
+      return buildEavBooleanCondition(alias, op, val, key);
+    case 'select':
+    case 'radio':
+      return buildEavTextCondition(alias, op, val, key);
+    case 'multiselect':
+    case 'multicheckbox':
+      return buildEavMultiSelectCondition(alias, op, val, key);
+    default:
+      return buildEavTextCondition(alias, op, val, key);
+  }
+}
+
+/**
+ * Build EAV text condition
+ */
+export function buildEavTextCondition(
+  alias: string,
+  op: string,
+  val: any,
+  key: string,
+): WhereClause | null {
+  switch (op) {
+    case 'contains':
+      return {
+        query: `LOWER(${alias}.value) LIKE :${key}`,
+        params: { [key]: `%${val ? val.toLowerCase() : ''}%` },
+      };
+    case 'equal':
+      return { query: `${alias}.value = :${key}`, params: { [key]: val } };
+    case 'not_equal':
+      return { query: `${alias}.value != :${key}`, params: { [key]: val } };
+    case 'empty':
+      return { query: `${alias}.value IS NULL`, params: {} };
+    case 'not_empty':
+      return { query: `${alias}.value IS NOT NULL`, params: {} };
+    default:
+      throw new BadRequestException(`Unsupported EAV text operator: ${op}`);
+  }
+}
+
+/**
+ * Build EAV number condition
+ */
+export function buildEavNumberCondition(
+  alias: string,
+  op: string,
+  val: any,
+  key: string,
+): WhereClause | null {
+  switch (op) {
+    case 'equal':
+      return { query: `${alias}.value = :${key}`, params: { [key]: val } };
+    case 'not_equal':
+      return { query: `${alias}.value != :${key}`, params: { [key]: val } };
+    case 'greater_than':
+      return { query: `${alias}.value > :${key}`, params: { [key]: val } };
+    case 'less_than':
+      return { query: `${alias}.value < :${key}`, params: { [key]: val } };
+    case 'less_than_qual_to':
+      return { query: `${alias}.value <= :${key}`, params: { [key]: val } };
+    case 'greater_than_qual_to':
+      return { query: `${alias}.value >= :${key}`, params: { [key]: val } };
+    case 'empty':
+      return { query: `${alias}.value IS NULL`, params: {} };
+    case 'not_empty':
+      return { query: `${alias}.value IS NOT NULL`, params: {} };
+    default:
+      throw new BadRequestException(`Unsupported EAV number operator: ${op}`);
+  }
+}
+
+/**
+ * Build EAV date condition
+ */
+export function buildEavDateCondition(
+  alias: string,
+  op: string,
+  val: any,
+  key: string,
+): WhereClause | null {
+  const dateColumn = `DATE(${alias}.value)`;
+
+  switch (op) {
+    case 'equal':
+    case 'is':
+      return { query: `${dateColumn} = :${key}`, params: { [key]: val } };
+    case 'before':
+    case 'is_before':
+      return { query: `${dateColumn} < :${key}`, params: { [key]: val } };
+    case 'after':
+    case 'is_after':
+      return { query: `${dateColumn} > :${key}`, params: { [key]: val } };
+    case 'is_on_or_before':
+      return { query: `${dateColumn} <= :${key}`, params: { [key]: val } };
+    case 'is_on_or_after':
+      return { query: `${dateColumn} >= :${key}`, params: { [key]: val } };
+    case 'between': {
+      let valArray =
+        typeof val === 'string' ? val.split(',').map((v) => v.trim()) : val;
+      if (!Array.isArray(valArray) || valArray.length !== 2) return null;
+      return {
+        query: `${dateColumn} BETWEEN :${key}_start AND :${key}_end`,
+        params: { [`${key}_start`]: valArray[0], [`${key}_end`]: valArray[1] },
+      };
+    }
+    case 'empty':
+      return { query: `${alias}.value IS NULL`, params: {} };
+    case 'not_empty':
+      return { query: `${alias}.value IS NOT NULL`, params: {} };
+    default:
+      throw new BadRequestException(`Unsupported EAV date operator: ${op}`);
+  }
+}
+
+/**
+ * Build EAV boolean condition
+ */
+export function buildEavBooleanCondition(
+  alias: string,
+  op: string,
+  val: any,
+  key: string,
+): WhereClause | null {
+  switch (op) {
+    case 'equal':
+      return { query: `${alias}.value = :${key}`, params: { [key]: val } };
+    case 'not_equal':
+      return { query: `${alias}.value != :${key}`, params: { [key]: val } };
+    case 'empty':
+      return { query: `${alias}.value IS NULL`, params: {} };
+    case 'not_empty':
+      return { query: `${alias}.value IS NOT NULL`, params: {} };
+    default:
+      throw new BadRequestException(`Unsupported EAV boolean operator: ${op}`);
+  }
+}
+
+/**
+ * Build EAV multiselect condition
+ */
+export function buildEavMultiSelectCondition(
+  alias: string,
+  op: string,
+  val: any,
+  key: string,
+): WhereClause | null {
+  let arr: string[] = [];
+
+  if (Array.isArray(val)) {
+    arr = val.map((v) => String(v));
+  } else if (typeof val === 'string') {
+    arr = val.split(',').map((v) => v.trim());
+  } else {
+    return null;
+  }
+
+  if (arr.length === 0) return { query: '1=1', params: {} };
+
+  switch (op) {
+    case 'equal':
+    case 'contains':
+      return {
+        query: `${alias}.value LIKE :${key}`,
+        params: { [key]: `%${arr[0]}%` },
+      };
+    case 'not_equal':
+    case 'not_contains':
+      return {
+        query: `${alias}.value NOT LIKE :${key}`,
+        params: { [key]: `%${arr[0]}%` },
+      };
+    case 'empty':
+      return { query: `${alias}.value IS NULL`, params: {} };
+    case 'not_empty':
+      return { query: `${alias}.value IS NOT NULL`, params: {} };
+    default:
+      throw new BadRequestException(
+        `Unsupported EAV multiselect operator: ${op}`,
+      );
+  }
+}

package/src/module/entity/filter/service/helpers/filter2.types.ts

@@ -0,0 +1,55 @@
+/**
+ * Filter2.0 Types and Interfaces
+ *
+ * Shared type definitions for Filter2Service and its helpers
+ */
+
+export interface FilterClauses {
+  dbColClauses: WhereClause[];
+  eavJoins: EavJoinInfo[];
+  eavClauses: WhereClause[];
+}
+
+export interface WhereClause {
+  query: string;
+  params: Record<string, any>;
+}
+
+export interface EavJoinInfo {
+  alias: string;
+  tableName: string;
+  entityType: string;
+  attributeKey: string;
+}
+
+export interface AttributeMetadata {
+  attribute_key: string;
+  element_type: string;
+  storage_type: string;
+  mapped_entity_type: string;
+  [key: string]: any;
+}
+
+export interface PaginationParams {
+  page: number;
+  size: number;
+}
+
+export interface PaginationResult {
+  total: number;
+  page: number;
+  size: number;
+  totalPages: number;
+  hasNextPage: boolean;
+  hasPreviousPage: boolean;
+}
+
+export interface FilterDataResult {
+  entity_list: any[];
+  pagination?: PaginationResult;
+}
+
+export interface FlatJsonQueryInfo {
+  jsonColumn: string; // e.g., 'json_data', 'entity_json'
+  tableName: string;  // e.g., 'entity_json'
+}