namirasoft-core 1.4.12 → 1.4.13

package/src/RegexTemplate.ts

@@ -1,8 +1,8 @@
-export class RegexTemplate
-{
-    static Date: RegExp = /^(?!0000)[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])$/gm;
-    static Time: RegExp = /^([01]\d|2[0-3]):([0-5]\d)$/gm;
-    static Duration: RegExp = /^(\d+d\s)?([01]\d|2[0-3]):([0-5]\d)$/gm;
-    static Email: RegExp = /^[\w\._-]+@([\w]+\.)+\w{2,}$/gm;
-    static IP: RegExp = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/gm;
+export class RegexTemplate
+{
+    static Date: RegExp = /^(?!0000)[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])$/gm;
+    static Time: RegExp = /^([01]\d|2[0-3]):([0-5]\d)$/gm;
+    static Duration: RegExp = /^(\d+d\s)?([01]\d|2[0-3]):([0-5]\d)$/gm;
+    static Email: RegExp = /^[\w\._-]+@([\w]+\.)+\w{2,}$/gm;
+    static IP: RegExp = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/gm;
 }

package/src/SearchOperation.ts

@@ -1,30 +1,30 @@
-export class SearchOperation
-{
-    static getTokens(search: string): string[]
-    {
-        return search.split(' ').filter(x => x.trim()).map(x => x.toLowerCase());
-    }
-    static match(value: string, search: string, tokens: string[] = []): boolean
-    {
-        if (search)
-        {
-            if (tokens.length == 0)
-                tokens = search.split(' ').filter(x => x.trim()).map(x => x.toLowerCase());
-            let name = value.toLowerCase();
-            for (let i = 0; i < tokens.length; i++)
-                if (!name.toLowerCase().includes(tokens[i]))
-                    return false;
-        }
-        return true;
-    }
-    static filter<T>(array: T[], getValue: (item: T) => string, search: string): T[]
-    {
-        let ans = array;
-        if (search)
-        {
-            let tokens = this.getTokens(search);
-            ans = ans.filter((item) => SearchOperation.match(getValue(item), search, tokens));
-        }
-        return ans;
-    }
+export class SearchOperation
+{
+    static getTokens(search: string): string[]
+    {
+        return search.split(' ').filter(x => x.trim()).map(x => x.toLowerCase());
+    }
+    static match(value: string, search: string, tokens: string[] = []): boolean
+    {
+        if (search)
+        {
+            if (tokens.length == 0)
+                tokens = search.split(' ').filter(x => x.trim()).map(x => x.toLowerCase());
+            let name = value.toLowerCase();
+            for (let i = 0; i < tokens.length; i++)
+                if (!name.toLowerCase().includes(tokens[i]))
+                    return false;
+        }
+        return true;
+    }
+    static filter<T>(array: T[], getValue: (item: T) => string, search: string): T[]
+    {
+        let ans = array;
+        if (search)
+        {
+            let tokens = this.getTokens(search);
+            ans = ans.filter((item) => SearchOperation.match(getValue(item), search, tokens));
+        }
+        return ans;
+    }
 }

package/src/SortItem.ts

@@ -0,0 +1,89 @@
+import { BaseMetaColumn } from "./BaseMetaColumn";
+import { BaseMetaTable } from "./BaseMetaTable";
+import { EncodingOperation } from "./EncodingOperation";
+import { ErrorOperation } from "./ErrorOperation";
+
+export class SortItem
+{
+    public table: { name: string; text: string; };
+    public column: { name: string; text: string; };
+    public ascending: boolean;
+    public static encode(sorts: SortItem[] | null): string
+    {
+        let value = this.stringify(sorts);
+        return EncodingOperation.Base64Encode(value);
+    }
+    public static decode(value: string): SortItem[] | null
+    {
+        let encoded = EncodingOperation.Base64Decode(value);
+        return this.parse(encoded);
+    }
+    public static stringify(sorts: SortItem[] | null): string
+    {
+        if (sorts)
+            return sorts.map(x => x.getCommand()).join(";");
+        return "";
+    }
+    public static parse(item: string | null): SortItem[]
+    {
+        let ans: SortItem[] = [];
+        if (item)
+        {
+            let index = 0;
+            let items = item.split(/(?<!\\);/);
+            let thereIsMore = (): boolean =>
+            {
+                return index < items.length;
+            };
+            let next = (name: string): string =>
+            {
+                if (thereIsMore())
+                    return items[index++];
+                throw ErrorOperation.getHTTP(400, `Next value is required for '${name}'. Must be separated by ;`);
+            };
+            while (thereIsMore())
+            {
+                let value_table = next("Table");
+                let table = new BaseMetaTable(value_table, value_table);
+
+                let value_column = next("Column");
+                let column = new BaseMetaColumn(value_column, value_column, "", false)
+
+                let value_asc = next("Asending").toLowerCase();
+                let asc = value_asc != "asc"
+                if (value_asc != "asc" && value_asc != "desc")
+                    ErrorOperation.throwHTTP(400, `Invalid value '${value_asc}' for SortItem.Asending, Only 'Asc' and 'Desc' are allowed.`);
+
+                ans.push(new SortItem(table, column, asc));
+            }
+        }
+        return ans;
+    }
+    constructor(table: { name: string; text: string; }, column: { name: string; text: string; }, ascending: boolean)
+    {
+        this.table = table;
+        this.column = column;
+        this.ascending = ascending;
+    }
+    getCommand()
+    {
+        return [this.table.name, this.column.name, this.ascending ? "asc" : "desc"].join(";");
+    }
+    toString()
+    {
+        let ans = [];
+        if (this.table.text)
+            ans.push(this.table.text);
+        else
+            ans.push(this.table.name);
+        if (this.column.text)
+            ans.push(this.column.text);
+        else
+            ans.push(this.column.name);
+        if (this.ascending)
+            ans.push("Ascending");
+        else
+            ans.push("Descending");
+        return ans.filter(x => x).join(" ");
+    }
+}

package/src/StringOperation.ts

@@ -1,19 +1,19 @@
-export class StringOperation
-{
-    static format(string: string, ...args: string[]): string
-    {
-        return string.replace(/{(\d+)}/g, (match, index) =>
-        {
-            const arg = args[index];
-            return typeof arg !== 'undefined' ? arg : match;
-        });
-    }
-    static repair(value: string): string
-    {
-        if (value == null)
-            value = '';
-        value = value.replace(/\s\s+/gm, ' ');
-        value = value.trim();
-        return value;
-    }
+export class StringOperation
+{
+    static format(string: string, ...args: string[]): string
+    {
+        return string.replace(/{(\d+)}/g, (match, index) =>
+        {
+            const arg = args[index];
+            return typeof arg !== 'undefined' ? arg : match;
+        });
+    }
+    static repair(value: string): string
+    {
+        if (value == null)
+            value = '';
+        value = value.replace(/\s\s+/gm, ' ');
+        value = value.trim();
+        return value;
+    }
 }