namirasoft-node 1.4.131 → 1.4.133

package/src/BaseFilterItemBuilder.ts

@@ -1,192 +1,192 @@
-import { ErrorOperation, FilterItem, FilterItemOperator } from "namirasoft-core";
-
-export interface BaseFilterItemBuilder_JoinTable<WhereOptions>
-{
-    main: {
-        column: string;
-    };
-    secondary: {
-        column: string;
-    };
-    getExtraConditions?: (column: string) => WhereOptions[];
-}
-
-export type BaseFilterItemBuilder_Condition<WhereOptions> = {
-    condition: WhereOptions;
-    independant?: { not: boolean };
-};
-
-export abstract class BaseFilterItemBuilder<Table extends { getName: () => string; }, WhereOptions>
-{
-    public async build(table_main: Table, table_joins: { [table: string]: BaseFilterItemBuilder_JoinTable<WhereOptions> }, filters?: FilterItem[] | undefined): Promise<WhereOptions[]>
-    {
-        let ans: WhereOptions[] = [];
-        if (filters)
-        {
-            let conditions_in_select_main: { [table: string]: WhereOptions[] } = {};
-            function get_conditions_in_select_main(name: string)
-            {
-                if (!conditions_in_select_main[name])
-                    conditions_in_select_main[name] = [];
-                return conditions_in_select_main[name];
-            }
-            let processed: { [index: number]: boolean } = {};
-
-            let getCondition_IDInSelect = async (table: string, not: boolean, conditions: WhereOptions[]): Promise<WhereOptions> =>
-            {
-                let join = table_joins[table];
-                return this.getInSelect(table, not, join, conditions);
-            }
-
-            for (let i = 0; i < filters.length; i++)
-                if (!processed[i])
-                {
-                    const filter = filters[i];
-                    this.checkColumn(filter.table.name, filter.column.name);
-                    let is_table_main = table_main.getName() === filter.table.name;
-                    let column_name = this.getRealColumnName(filter.table.name, filter.column.name) ?? filter.column.name;
-
-                    let values = filter.values;
-
-                    if ([
-                        FilterItemOperator.all.equals.sign,
-                        FilterItemOperator.all.lessthan.sign,
-                        FilterItemOperator.all.lessthanequal.sign,
-                        FilterItemOperator.all.morethan.sign,
-                        FilterItemOperator.all.morethanequal.sign
-                    ].includes(filter.operator.sign))
-                        for (let v = 0; v < values.length; v++)
-                            this.checkValue(filter.table.name, filter.column.name, values[i]);
-
-                    if (filter.operator.count > 0)
-                        for (let j = i + 1; j < filters.length; j++)
-                        {
-                            const f = filters[j];
-                            if (filter.table.name == f.table.name)
-                                if (filter.column.name == f.column.name)
-                                    if (filter.not == f.not)
-                                        if (filter.operator.sign == f.operator.sign)
-                                        {
-                                            processed[j] = true;
-                                            values.push(...f.values);
-                                        }
-                        }
-
-                    let escapedValues = values.map(v => this.escapeValue(v));
-                    let getNumbers = () =>
-                    {
-                        let nums: number[] = values.map(x => parseFloat(x));
-                        if (nums.filter(x => isNaN(x)).length > 0)
-                            ErrorOperation.throwHTTP(400, `Invalid number values for: '${values.join(",")}'`);
-                        return nums;
-                    };
-                    let addCondition = async (res: BaseFilterItemBuilder_Condition<WhereOptions>) =>
-                    {
-                        let condition: WhereOptions = res.condition;
-                        if (is_table_main)
-                            ans.push(condition);
-                        else
-                        {
-                            let join = table_joins[filter.table.name];
-                            if (res.independant || join?.getExtraConditions)
-                                ans.push(await getCondition_IDInSelect(filter.table.name, res.independant?.not ?? false, [condition, ...(join?.getExtraConditions?.(filter.column.name) ?? [])]));
-                            else
-                                get_conditions_in_select_main(filter.table.name).push(condition);
-                        }
-                    };
-                    if (column_name === "*")
-                    {
-                        if (filter.operator !== FilterItemOperator.all.equals)
-                            ErrorOperation.throwHTTP(400, `Invalid operator for all columns (*).`);
-                        else
-                        {
-                            let columns = this.getAdvancedSearchColumns(filter.table.name);
-                            for (let i = 0; i < escapedValues.length; i++)
-                            {
-                                const value = escapedValues[i];
-                                let conditions = await this.getAdvancedSearchConditions(columns, value);
-                                ans.push(...conditions);
-                            }
-                        }
-                    }
-                    else if (filter.operator == FilterItemOperator.all.equals)
-                        await addCondition(this.getIn(column_name, filter.not, escapedValues));
-                    else if (filter.operator == FilterItemOperator.all.contains)
-                        for (const value of escapedValues)
-                            await addCondition(this.getLike(column_name, filter.not, value));
-                    else if (filter.operator == FilterItemOperator.all.regex)
-                        for (const value of escapedValues)
-                            await addCondition(this.getRegex(column_name, filter.not, value));
-                    else if (filter.operator == FilterItemOperator.all.empty)
-                        await addCondition(this.getEmpty(column_name, filter.not));
-                    else if (filter.operator == FilterItemOperator.all.exists)
-                        await addCondition(this.getExists(column_name, filter.not));
-                    else if (filter.operator == FilterItemOperator.all.includes)
-                        await addCondition(this.getIncludes(column_name, filter.not, escapedValues));
-                    else if (filter.operator == FilterItemOperator.all.startswith)
-                        for (const value of escapedValues)
-                            await addCondition(this.getStartsWith(column_name, filter.not, value));
-                    else if (filter.operator == FilterItemOperator.all.endswith)
-                        for (const value of escapedValues)
-                            await addCondition(this.getEndsWith(column_name, filter.not, value));
-                    else if (filter.operator == FilterItemOperator.all.lessthan)
-                    {
-                        if (filter.not)
-                            await addCondition(this.getGTE(column_name, Math.max(...getNumbers())));
-                        else
-                            await addCondition(this.getLT(column_name, Math.max(...getNumbers())));
-                    }
-                    else if (filter.operator == FilterItemOperator.all.lessthanequal)
-                    {
-                        if (filter.not)
-                            await addCondition(this.getGT(column_name, Math.max(...getNumbers())));
-                        else
-                            await addCondition(this.getLTE(column_name, Math.max(...getNumbers())));
-                    }
-                    else if (filter.operator == FilterItemOperator.all.morethan)
-                    {
-                        if (filter.not)
-                            await addCondition(this.getLTE(column_name, Math.max(...getNumbers())));
-                        else
-                            await addCondition(this.getGT(column_name, Math.max(...getNumbers())));
-                    }
-                    else if (filter.operator == FilterItemOperator.all.morethanequal)
-                    {
-                        if (filter.not)
-                            await addCondition(this.getLT(column_name, Math.max(...getNumbers())));
-                        else
-                            await addCondition(this.getGTE(column_name, Math.max(...getNumbers())));
-                    }
-                }
-            for (let table of Object.keys(conditions_in_select_main))
-            {
-                let conditions = conditions_in_select_main[table];
-                if (conditions.length > 0)
-                    ans.push(await getCondition_IDInSelect(table, false, conditions));
-            }
-        }
-        return ans;
-    }
-    public abstract checkColumn(table_name: string, column_name: string): void;
-    public abstract checkValue(table_name: string, column_name: string, value: string): void;
-    public abstract escapeValue(value: string): string;
-    public abstract getRealColumnName(table_name: string, column_name: string): string;
-    public abstract getAdvancedSearchColumns(table_name: string): string[];
-    public abstract getAdvancedSearchConditions(columns: string[], search: string): Promise<WhereOptions[]>;
-    public abstract getIn(column_name: string, not: boolean, values: string[]): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getLike(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getRegex(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
-    // Empty means the column exists but the value is undefined, null or ''
-    public abstract getEmpty(column_name: string, not: boolean): BaseFilterItemBuilder_Condition<WhereOptions>;
-    // Exist means the column does not exist or the value is undefined, null or ''
-    public abstract getExists(column_name: string, not: boolean): BaseFilterItemBuilder_Condition<WhereOptions>;
-    // Include is only used when there is a join and it means the column has one of the value
-    public abstract getIncludes(column_name: string, not: boolean, values: string[]): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getStartsWith(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getEndsWith(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getLT(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getLTE(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getGT(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getGTE(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getInSelect(table_name: string, not: boolean, join: BaseFilterItemBuilder_JoinTable<WhereOptions>, conditions: WhereOptions[]): Promise<WhereOptions>;
+import { ErrorOperation, FilterItem, FilterItemOperator } from "namirasoft-core";
+
+export interface BaseFilterItemBuilder_JoinTable<WhereOptions>
+{
+    main: {
+        column: string;
+    };
+    secondary: {
+        column: string;
+    };
+    getExtraConditions?: (column: string) => WhereOptions[];
+}
+
+export type BaseFilterItemBuilder_Condition<WhereOptions> = {
+    condition: WhereOptions;
+    independant?: { not: boolean };
+};
+
+export abstract class BaseFilterItemBuilder<Table extends { getName: () => string; }, WhereOptions>
+{
+    public async build(table_main: Table, table_joins: { [table: string]: BaseFilterItemBuilder_JoinTable<WhereOptions> }, filters?: FilterItem[] | undefined): Promise<WhereOptions[]>
+    {
+        let ans: WhereOptions[] = [];
+        if (filters)
+        {
+            let conditions_in_select_main: { [table: string]: WhereOptions[] } = {};
+            function get_conditions_in_select_main(name: string)
+            {
+                if (!conditions_in_select_main[name])
+                    conditions_in_select_main[name] = [];
+                return conditions_in_select_main[name];
+            }
+            let processed: { [index: number]: boolean } = {};
+
+            let getCondition_IDInSelect = async (table: string, not: boolean, conditions: WhereOptions[]): Promise<WhereOptions> =>
+            {
+                let join = table_joins[table];
+                return this.getInSelect(table, not, join, conditions);
+            }
+
+            for (let i = 0; i < filters.length; i++)
+                if (!processed[i])
+                {
+                    const filter = filters[i];
+                    this.checkColumn(filter.table.name, filter.column.name);
+                    let is_table_main = table_main.getName() === filter.table.name;
+                    let column_name = this.getRealColumnName(filter.table.name, filter.column.name) ?? filter.column.name;
+
+                    let values = filter.values;
+
+                    if ([
+                        FilterItemOperator.all.equals.sign,
+                        FilterItemOperator.all.lessthan.sign,
+                        FilterItemOperator.all.lessthanequal.sign,
+                        FilterItemOperator.all.morethan.sign,
+                        FilterItemOperator.all.morethanequal.sign
+                    ].includes(filter.operator.sign))
+                        for (let v = 0; v < values.length; v++)
+                            this.checkValue(filter.table.name, filter.column.name, values[i]);
+
+                    if (filter.operator.count > 0)
+                        for (let j = i + 1; j < filters.length; j++)
+                        {
+                            const f = filters[j];
+                            if (filter.table.name == f.table.name)
+                                if (filter.column.name == f.column.name)
+                                    if (filter.not == f.not)
+                                        if (filter.operator.sign == f.operator.sign)
+                                        {
+                                            processed[j] = true;
+                                            values.push(...f.values);
+                                        }
+                        }
+
+                    let escapedValues = values.map(v => this.escapeValue(v));
+                    let getNumbers = () =>
+                    {
+                        let nums: number[] = values.map(x => parseFloat(x));
+                        if (nums.filter(x => isNaN(x)).length > 0)
+                            ErrorOperation.throwHTTP(400, `Invalid number values for: '${values.join(",")}'`);
+                        return nums;
+                    };
+                    let addCondition = async (res: BaseFilterItemBuilder_Condition<WhereOptions>) =>
+                    {
+                        let condition: WhereOptions = res.condition;
+                        if (is_table_main)
+                            ans.push(condition);
+                        else
+                        {
+                            let join = table_joins[filter.table.name];
+                            if (res.independant || join?.getExtraConditions)
+                                ans.push(await getCondition_IDInSelect(filter.table.name, res.independant?.not ?? false, [condition, ...(join?.getExtraConditions?.(filter.column.name) ?? [])]));
+                            else
+                                get_conditions_in_select_main(filter.table.name).push(condition);
+                        }
+                    };
+                    if (column_name === "*")
+                    {
+                        if (filter.operator !== FilterItemOperator.all.equals)
+                            ErrorOperation.throwHTTP(400, `Invalid operator for all columns (*).`);
+                        else
+                        {
+                            let columns = this.getAdvancedSearchColumns(filter.table.name);
+                            for (let i = 0; i < escapedValues.length; i++)
+                            {
+                                const value = escapedValues[i];
+                                let conditions = await this.getAdvancedSearchConditions(columns, value);
+                                ans.push(...conditions);
+                            }
+                        }
+                    }
+                    else if (filter.operator == FilterItemOperator.all.equals)
+                        await addCondition(this.getIn(column_name, filter.not, escapedValues));
+                    else if (filter.operator == FilterItemOperator.all.contains)
+                        for (const value of escapedValues)
+                            await addCondition(this.getLike(column_name, filter.not, value));
+                    else if (filter.operator == FilterItemOperator.all.regex)
+                        for (const value of escapedValues)
+                            await addCondition(this.getRegex(column_name, filter.not, value));
+                    else if (filter.operator == FilterItemOperator.all.empty)
+                        await addCondition(this.getEmpty(column_name, filter.not));
+                    else if (filter.operator == FilterItemOperator.all.exists)
+                        await addCondition(this.getExists(column_name, filter.not));
+                    else if (filter.operator == FilterItemOperator.all.includes)
+                        await addCondition(this.getIncludes(column_name, filter.not, escapedValues));
+                    else if (filter.operator == FilterItemOperator.all.startswith)
+                        for (const value of escapedValues)
+                            await addCondition(this.getStartsWith(column_name, filter.not, value));
+                    else if (filter.operator == FilterItemOperator.all.endswith)
+                        for (const value of escapedValues)
+                            await addCondition(this.getEndsWith(column_name, filter.not, value));
+                    else if (filter.operator == FilterItemOperator.all.lessthan)
+                    {
+                        if (filter.not)
+                            await addCondition(this.getGTE(column_name, Math.max(...getNumbers())));
+                        else
+                            await addCondition(this.getLT(column_name, Math.max(...getNumbers())));
+                    }
+                    else if (filter.operator == FilterItemOperator.all.lessthanequal)
+                    {
+                        if (filter.not)
+                            await addCondition(this.getGT(column_name, Math.max(...getNumbers())));
+                        else
+                            await addCondition(this.getLTE(column_name, Math.max(...getNumbers())));
+                    }
+                    else if (filter.operator == FilterItemOperator.all.morethan)
+                    {
+                        if (filter.not)
+                            await addCondition(this.getLTE(column_name, Math.max(...getNumbers())));
+                        else
+                            await addCondition(this.getGT(column_name, Math.max(...getNumbers())));
+                    }
+                    else if (filter.operator == FilterItemOperator.all.morethanequal)
+                    {
+                        if (filter.not)
+                            await addCondition(this.getLT(column_name, Math.max(...getNumbers())));
+                        else
+                            await addCondition(this.getGTE(column_name, Math.max(...getNumbers())));
+                    }
+                }
+            for (let table of Object.keys(conditions_in_select_main))
+            {
+                let conditions = conditions_in_select_main[table];
+                if (conditions.length > 0)
+                    ans.push(await getCondition_IDInSelect(table, false, conditions));
+            }
+        }
+        return ans;
+    }
+    public abstract checkColumn(table_name: string, column_name: string): void;
+    public abstract checkValue(table_name: string, column_name: string, value: string): void;
+    public abstract escapeValue(value: string): string;
+    public abstract getRealColumnName(table_name: string, column_name: string): string;
+    public abstract getAdvancedSearchColumns(table_name: string): string[];
+    public abstract getAdvancedSearchConditions(columns: string[], search: string): Promise<WhereOptions[]>;
+    public abstract getIn(column_name: string, not: boolean, values: string[]): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getLike(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getRegex(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
+    // Empty means the column exists but the value is undefined, null or ''
+    public abstract getEmpty(column_name: string, not: boolean): BaseFilterItemBuilder_Condition<WhereOptions>;
+    // Exist means the column does not exist or the value is undefined, null or ''
+    public abstract getExists(column_name: string, not: boolean): BaseFilterItemBuilder_Condition<WhereOptions>;
+    // Include is only used when there is a join and it means the column has one of the value
+    public abstract getIncludes(column_name: string, not: boolean, values: string[]): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getStartsWith(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getEndsWith(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getLT(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getLTE(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getGT(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getGTE(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getInSelect(table_name: string, not: boolean, join: BaseFilterItemBuilder_JoinTable<WhereOptions>, conditions: WhereOptions[]): Promise<WhereOptions>;
 }

package/src/BaseFilterItemBuilderDatabase.ts

@@ -1,33 +1,33 @@
-import { BaseDatabase } from "./BaseDatabase";
-import { BaseFilterItemBuilder } from "./BaseFilterItemBuilder";
-import { BaseTable } from "./BaseTable";
-
-export abstract class BaseFilterItemBuilderDatabase<WhereOptions> extends BaseFilterItemBuilder<BaseTable<BaseDatabase, any>, WhereOptions>
-{
-    constructor(public database: BaseDatabase)
-    {
-        super();
-    }
-    public override checkColumn(table_name: string, column_name: string): void
-    {
-        let t = this.database.getTable<BaseTable<BaseDatabase, any>>(table_name);
-        if (column_name != "*")
-            t.checkColumn(column_name, false, null);
-    }
-    public checkValue(table_name: string, column_name: string, value: string)
-    {
-        let t = this.database.getTable<BaseTable<BaseDatabase, any>>(table_name);
-        if (column_name != "*")
-            t.checkValue(column_name, value);
-    }
-    public override getRealColumnName(table_name: string, column_name: string): string
-    {
-        let t = this.database.getTable<BaseTable<BaseDatabase, any>>(table_name);
-        return t.getRealColumnName(column_name);
-    }
-    public override getAdvancedSearchColumns(table_name: string): string[]
-    {
-        let t = this.database.getTable(table_name) as BaseTable<BaseDatabase, any>;
-        return t.getColumns(false, null, { searchable: true });
-    }
+import { BaseDatabase } from "./BaseDatabase";
+import { BaseFilterItemBuilder } from "./BaseFilterItemBuilder";
+import { BaseTable } from "./BaseTable";
+
+export abstract class BaseFilterItemBuilderDatabase<WhereOptions> extends BaseFilterItemBuilder<BaseTable<BaseDatabase, any>, WhereOptions>
+{
+    constructor(public database: BaseDatabase)
+    {
+        super();
+    }
+    public override checkColumn(table_name: string, column_name: string): void
+    {
+        let t = this.database.getTable<BaseTable<BaseDatabase, any>>(table_name);
+        if (column_name != "*")
+            t.checkColumn(column_name, false, null);
+    }
+    public checkValue(table_name: string, column_name: string, value: string)
+    {
+        let t = this.database.getTable<BaseTable<BaseDatabase, any>>(table_name);
+        if (column_name != "*")
+            t.checkValue(column_name, value);
+    }
+    public override getRealColumnName(table_name: string, column_name: string): string
+    {
+        let t = this.database.getTable<BaseTable<BaseDatabase, any>>(table_name);
+        return t.getRealColumnName(column_name);
+    }
+    public override getAdvancedSearchColumns(table_name: string): string[]
+    {
+        let t = this.database.getTable(table_name) as BaseTable<BaseDatabase, any>;
+        return t.getColumns(false, null, { searchable: true });
+    }
 }

package/src/BaseFilterItemBuilderObject.ts

@@ -1,96 +1,96 @@
-import { SearchOperation } from "namirasoft-core";
-import { BaseFilterItemBuilder, BaseFilterItemBuilder_JoinTable } from "./BaseFilterItemBuilder";
-
-export class BaseFilterItemBuilderObject extends BaseFilterItemBuilder<{ getName: () => string }, boolean>
-{
-    constructor(public object: any)
-    {
-        super();
-    }
-    public override checkColumn(): void
-    {
-    }
-    public override checkValue(): void
-    {
-    }
-    public override escapeValue(value: string)
-    {
-        return value;
-    }
-    public getRealColumnName(_: string, column_name: string): string
-    {
-        return column_name;
-    }
-    override getAdvancedSearchColumns(): string[]
-    {
-        return Object.keys(this.object);
-    }
-    override async getAdvancedSearchConditions(columns: string[], search: string): Promise<boolean[]>
-    {
-        let text = columns.map(c => this.object[c]).filter(v => v).join(" ");
-        return [SearchOperation.match(text, search)];
-    }
-    override getIn(column_name: string, not: boolean, values: string[])
-    {
-        let condition = values.includes(this.object[column_name] ?? null) !== not;
-        return { condition };
-    }
-    override getLike(column_name: string, not: boolean, value: string)
-    {
-        let condition = new RegExp(`.*${value}.*`).test(this.object[column_name] ?? "") !== not;
-        return { condition };
-    }
-    override getRegex(column_name: string, not: boolean, value: string)
-    {
-        let condition = new RegExp(value).test(this.object[column_name] ?? "") !== not;
-        return { condition };
-    }
-    override getEmpty(column_name: string, not: boolean)
-    {
-        let condition = ((this.object[column_name] ?? "") == "") !== not;
-        return { condition };
-    }
-    override getExists(column_name: string, not: boolean)
-    {
-        let condition = ((this.object[column_name]) != null) !== not;
-        return { condition };
-    }
-    override getIncludes(column_name: string, not: boolean, values: string[])
-    {
-        return this.getExists(column_name, not) && this.getIn(column_name, not, values);
-    }
-    override getStartsWith(column_name: string, not: boolean, value: string)
-    {
-        let condition = new RegExp(`${value}.*`).test(this.object[column_name] ?? "") !== not;
-        return { condition };
-    }
-    override getEndsWith(column_name: string, not: boolean, value: string)
-    {
-        let condition = new RegExp(`.*${value}`).test(this.object[column_name] ?? "") !== not;
-        return { condition };
-    }
-    override getLT(column_name: string, value: any)
-    {
-        let condition = (parseFloat(this.object[column_name] ?? "") < parseFloat(value));
-        return { condition };
-    }
-    override getLTE(column_name: string, value: any)
-    {
-        let condition = (parseFloat(this.object[column_name] ?? "") <= parseFloat(value));
-        return { condition };
-    }
-    override getGT(column_name: string, value: any)
-    {
-        let condition = (parseFloat(this.object[column_name] ?? "") > parseFloat(value));
-        return { condition };
-    }
-    override getGTE(column_name: string, value: any)
-    {
-        let condition = (parseFloat(this.object[column_name] ?? "") >= parseFloat(value));
-        return { condition };
-    }
-    override async getInSelect(_: string, not: boolean, __: BaseFilterItemBuilder_JoinTable<boolean>, conditions: boolean[]): Promise<boolean>
-    {
-        return conditions.some(c => !c) === not;
-    }
+import { SearchOperation } from "namirasoft-core";
+import { BaseFilterItemBuilder, BaseFilterItemBuilder_JoinTable } from "./BaseFilterItemBuilder";
+
+export class BaseFilterItemBuilderObject extends BaseFilterItemBuilder<{ getName: () => string }, boolean>
+{
+    constructor(public object: any)
+    {
+        super();
+    }
+    public override checkColumn(): void
+    {
+    }
+    public override checkValue(): void
+    {
+    }
+    public override escapeValue(value: string)
+    {
+        return value;
+    }
+    public getRealColumnName(_: string, column_name: string): string
+    {
+        return column_name;
+    }
+    override getAdvancedSearchColumns(): string[]
+    {
+        return Object.keys(this.object);
+    }
+    override async getAdvancedSearchConditions(columns: string[], search: string): Promise<boolean[]>
+    {
+        let text = columns.map(c => this.object[c]).filter(v => v).join(" ");
+        return [SearchOperation.match(text, search)];
+    }
+    override getIn(column_name: string, not: boolean, values: string[])
+    {
+        let condition = values.includes(this.object[column_name] ?? null) !== not;
+        return { condition };
+    }
+    override getLike(column_name: string, not: boolean, value: string)
+    {
+        let condition = new RegExp(`.*${value}.*`).test(this.object[column_name] ?? "") !== not;
+        return { condition };
+    }
+    override getRegex(column_name: string, not: boolean, value: string)
+    {
+        let condition = new RegExp(value).test(this.object[column_name] ?? "") !== not;
+        return { condition };
+    }
+    override getEmpty(column_name: string, not: boolean)
+    {
+        let condition = ((this.object[column_name] ?? "") == "") !== not;
+        return { condition };
+    }
+    override getExists(column_name: string, not: boolean)
+    {
+        let condition = ((this.object[column_name]) != null) !== not;
+        return { condition };
+    }
+    override getIncludes(column_name: string, not: boolean, values: string[])
+    {
+        return this.getExists(column_name, not) && this.getIn(column_name, not, values);
+    }
+    override getStartsWith(column_name: string, not: boolean, value: string)
+    {
+        let condition = new RegExp(`${value}.*`).test(this.object[column_name] ?? "") !== not;
+        return { condition };
+    }
+    override getEndsWith(column_name: string, not: boolean, value: string)
+    {
+        let condition = new RegExp(`.*${value}`).test(this.object[column_name] ?? "") !== not;
+        return { condition };
+    }
+    override getLT(column_name: string, value: any)
+    {
+        let condition = (parseFloat(this.object[column_name] ?? "") < parseFloat(value));
+        return { condition };
+    }
+    override getLTE(column_name: string, value: any)
+    {
+        let condition = (parseFloat(this.object[column_name] ?? "") <= parseFloat(value));
+        return { condition };
+    }
+    override getGT(column_name: string, value: any)
+    {
+        let condition = (parseFloat(this.object[column_name] ?? "") > parseFloat(value));
+        return { condition };
+    }
+    override getGTE(column_name: string, value: any)
+    {
+        let condition = (parseFloat(this.object[column_name] ?? "") >= parseFloat(value));
+        return { condition };
+    }
+    override async getInSelect(_: string, not: boolean, __: BaseFilterItemBuilder_JoinTable<boolean>, conditions: boolean[]): Promise<boolean>
+    {
+        return conditions.some(c => !c) === not;
+    }
 }