namirasoft-node 1.4.60 → 1.4.62

package/src/BaseEmailService.ts

@@ -1,39 +1,39 @@
-import nodemailer from 'nodemailer';
-import Mail, { AttachmentLike } from "nodemailer/lib/mailer";
-import { Readable } from "stream";
-
-export abstract class BaseEmailService 
-{
-    username: string;
-    constructor(username: string)
-    {
-        this.username = username;
-    }
-    protected abstract getTransform(): any;
-    send(from: string | null, to: string, subject: string, text: string, html?: string | Buffer | Readable | AttachmentLike | undefined, callback?: (err: Error | null, info: any) => void)
-    {
-        let transform = this.getTransform();
-        let transporter = nodemailer.createTransport(transform);
-
-        let mailOptions: Mail.Options = {
-            from: from ?? this.username,
-            to,
-            subject,
-            text,
-            html
-        };
-        if (html)
-            mailOptions.html = html;
-
-        transporter.sendMail(mailOptions, function (error, info)
-        {
-            if (callback)
-                callback(error, info);
-            else
-            {
-                if (error)
-                    console.log(error);
-            }
-        });
-    }
+import nodemailer from 'nodemailer';
+import Mail, { AttachmentLike } from "nodemailer/lib/mailer";
+import { Readable } from "stream";
+
+export abstract class BaseEmailService 
+{
+    username: string;
+    constructor(username: string)
+    {
+        this.username = username;
+    }
+    protected abstract getTransform(): any;
+    send(from: string | null, to: string, subject: string, text: string, html?: string | Buffer | Readable | AttachmentLike | undefined, callback?: (err: Error | null, info: any) => void)
+    {
+        let transform = this.getTransform();
+        let transporter = nodemailer.createTransport(transform);
+
+        let mailOptions: Mail.Options = {
+            from: from ?? this.username,
+            to,
+            subject,
+            text,
+            html
+        };
+        if (html)
+            mailOptions.html = html;
+
+        transporter.sendMail(mailOptions, function (error, info)
+        {
+            if (callback)
+                callback(error, info);
+            else
+            {
+                if (error)
+                    console.log(error);
+            }
+        });
+    }
 }

package/src/BaseFilterItemBuilder.ts

@@ -1,153 +1,170 @@
-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[] } = {};
-            Object.keys(table_joins).forEach(table => { conditions_in_select_main[table] = []; });
-            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 join = table_joins[filter.table.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 (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 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
-                        {
-                            if (res.independant || join.getExtraConditions)
-                                ans.push(await getCondition_IDInSelect(filter.table.name, res.independant?.not ?? false, [condition, ...(join.getExtraConditions?.(filter.column.name) ?? [])]));
-                            else
-                                conditions_in_select_main[filter.table.name].push(condition);
-                        }
-                    };
-                    if (filter.operator == FilterItemOperator.all.equals)
-                        await addCondition(this.getIn(column_name, filter.not, values));
-                    else if (filter.operator == FilterItemOperator.all.contains)
-                        for (const value of values)
-                            await addCondition(this.getLike(column_name, filter.not, value));
-                    else if (filter.operator == FilterItemOperator.all.regex)
-                        for (const value of values)
-                            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, values));
-                    else if (filter.operator == FilterItemOperator.all.startswith)
-                        for (const value of values)
-                            await addCondition(this.getStartsWith(column_name, filter.not, value));
-                    else if (filter.operator == FilterItemOperator.all.endswith)
-                        for (const value of values)
-                            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 getRealColumnName(table_name: string, column_name: string): string;
-    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>;
-    public abstract getEmpty(column_name: string, not: boolean): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getExists(column_name: string, not: boolean): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getIncludes(column_name: string, not: boolean, value: 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[] } = {};
+            Object.keys(table_joins).forEach(table => { conditions_in_select_main[table] = []; });
+            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 join = table_joins[filter.table.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 (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 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
+                        {
+                            if (res.independant || join.getExtraConditions)
+                                ans.push(await getCondition_IDInSelect(filter.table.name, res.independant?.not ?? false, [condition, ...(join.getExtraConditions?.(filter.column.name) ?? [])]));
+                            else
+                                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 < values.length; i++)
+                            {
+                                const value = values[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, values));
+                    else if (filter.operator == FilterItemOperator.all.contains)
+                        for (const value of values)
+                            await addCondition(this.getLike(column_name, filter.not, value));
+                    else if (filter.operator == FilterItemOperator.all.regex)
+                        for (const value of values)
+                            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, values));
+                    else if (filter.operator == FilterItemOperator.all.startswith)
+                        for (const value of values)
+                            await addCondition(this.getStartsWith(column_name, filter.not, value));
+                    else if (filter.operator == FilterItemOperator.all.endswith)
+                        for (const value of values)
+                            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 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>;
+    public abstract getEmpty(column_name: string, not: boolean): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getExists(column_name: string, not: boolean): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getIncludes(column_name: string, not: boolean, value: 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,21 +1,22 @@
-import { BaseTable } from "./BaseTable";
-import { BaseDatabase } from "./BaseDatabase";
-import { BaseFilterItemBuilder } from "./BaseFilterItemBuilder";
-
-export abstract class BaseFilterItemBuilderDatabase<WhereOptions> extends BaseFilterItemBuilder<BaseTable<BaseDatabase, any>, WhereOptions>
-{
-    constructor(public database: BaseDatabase)
-    {
-        super();
-    }
-    public checkColumn(table_name: string, column_name: string): void
-    {
-        let t = this.database.getTable<BaseTable<BaseDatabase, any>>(table_name);
-        t.checkColumn(column_name, false, null);
-    }
-    public getRealColumnName(table_name: string, column_name: string): string
-    {
-        let t = this.database.getTable<BaseTable<BaseDatabase, any>>(table_name);
-        return t.getRealColumnName(column_name);
-    }
+import { BaseTable } from "./BaseTable";
+import { BaseDatabase } from "./BaseDatabase";
+import { BaseFilterItemBuilder } from "./BaseFilterItemBuilder";
+
+export abstract class BaseFilterItemBuilderDatabase<WhereOptions> extends BaseFilterItemBuilder<BaseTable<BaseDatabase, any>, WhereOptions>
+{
+    constructor(public database: BaseDatabase)
+    {
+        super();
+    }
+    public 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 getRealColumnName(table_name: string, column_name: string): string
+    {
+        let t = this.database.getTable<BaseTable<BaseDatabase, any>>(table_name);
+        return t.getRealColumnName(column_name);
+    }
 }

package/src/BaseFilterItemBuilderObject.ts

@@ -1,79 +1,89 @@
-import { BaseFilterItemBuilder } from "./BaseFilterItemBuilder";
-
-export class BaseFilterItemBuilderObject extends BaseFilterItemBuilder<{ getName: () => string }, boolean>
-{
-    constructor(public object: any)
-    {
-        super();
-    }
-    public checkColumn(): void
-    {
-    }
-    public getRealColumnName(_: string, column_name: string): string
-    {
-        return column_name;
-    }
-    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(): Promise<boolean>
-    {
-        throw new Error('Not implemented');
-    }
+import { SearchOperation } from "namirasoft-core";
+import { BaseFilterItemBuilder } from "./BaseFilterItemBuilder";
+
+export class BaseFilterItemBuilderObject extends BaseFilterItemBuilder<{ getName: () => string }, boolean>
+{
+    constructor(public object: any)
+    {
+        super();
+    }
+    public checkColumn(): void
+    {
+    }
+    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(): Promise<boolean>
+    {
+        throw new Error('Not implemented');
+    }
 }