@elite.framework/ng.core 2.0.18 → 2.0.19

package/fesm2022/elite.framework-ng.core-services.mjs

@@ -114,6 +114,11 @@ class BaseService {
         url: this.buildUrl(id),
         body: input,
     }, { apiName: this.apiName });
+    patch = (id, input) => this.restService.request({
+        method: 'PATCH',
+        url: this.buildUrl(id),
+        body: input,
+    }, { apiName: this.apiName });
     delete = (id) => this.restService.request({
         method: 'DELETE',
         url: this.buildUrl(id),
@@ -834,7 +839,9 @@ class QueryParser {
         const params = {
             filters: [],
             orderBy: [],
-            groupBy: []
+            groupBy: [],
+            select: [],
+            aggregates: []
         };
         if (!queryString)
             return params;
@@ -847,7 +854,13 @@ class QueryParser {
                 this.parseOrderBy(part.substring('$orderby='.length), params);
             }
             else if (part.startsWith('$groupby=')) {
-                params.groupBy = part.substring('$groupby='.length).split(',').map(f => f.trim());
+                this.parseGroupBy(part.substring('$groupby='.length), params);
+            }
+            else if (part.startsWith('$select=')) {
+                this.parseSelect(part.substring('$select='.length), params);
+            }
+            else if (part.startsWith('$aggregate=')) {
+                this.parseAggregate(part.substring('$aggregate='.length), params);
             }
             else if (part.startsWith('$top=')) {
                 params.top = Number(part.substring('$top='.length));
@@ -858,6 +871,9 @@ class QueryParser {
             else if (part.startsWith('$expand=')) {
                 params.expand = part.substring('$expand='.length).split(',').map(f => f.trim());
             }
+            else if (part.startsWith('$count=')) {
+                params.includeCount = part.substring('$count='.length).toLowerCase() === 'true';
+            }
         }
         return params;
     }
@@ -872,7 +888,16 @@ class QueryParser {
             parts.push(`$orderby=${encodeURIComponent(orderByStr)}`);
         }
         if (params.groupBy?.length) {
-            parts.push(`$groupby=${encodeURIComponent(params.groupBy.join(','))}`);
+            const groupByStr = this.buildGroupByString(params.groupBy);
+            parts.push(`$groupby=${encodeURIComponent(groupByStr)}`);
+        }
+        if (params.select?.length) {
+            const selectStr = this.buildSelectString(params.select);
+            parts.push(`$select=${encodeURIComponent(selectStr)}`);
+        }
+        if (params.aggregates?.length) {
+            const aggregateStr = this.buildAggregateString(params.aggregates);
+            parts.push(`$aggregate=${encodeURIComponent(aggregateStr)}`);
         }
         if (params.top !== undefined) {
             parts.push(`$top=${params.top}`);
@@ -883,6 +908,9 @@ class QueryParser {
         if (params.expand?.length) {
             parts.push(`$expand=${encodeURIComponent(params.expand.join(','))}`);
         }
+        if (params.includeCount !== undefined) {
+            parts.push(`$count=${params.includeCount}`);
+        }
         return parts.join('&');
     }
     static buildFilterString(filters) {
@@ -909,9 +937,71 @@ class QueryParser {
             }
         }).join(' ');
     }
+    static buildGroupByString(groupBy) {
+        return groupBy
+            .sort((a, b) => (a.order || 0) - (b.order || 0))
+            .map(group => {
+            let groupStr = group.propertyName;
+            // Add display name if provided
+            if (group.displayName) {
+                groupStr += ` as ${group.displayName}`;
+            }
+            // Add metadata for UI
+            const metadata = [];
+            if (group.showTotal !== undefined) {
+                metadata.push(`showTotal:${group.showTotal}`);
+            }
+            if (group.totalBackground) {
+                metadata.push(`totalBg:${group.totalBackground}`);
+            }
+            if (group.groupHeaderBackground) {
+                metadata.push(`headerBg:${group.groupHeaderBackground}`);
+            }
+            if (metadata.length > 0) {
+                groupStr += `(${metadata.join(';')})`;
+            }
+            return groupStr;
+        })
+            .join(',');
+    }
+    static buildSelectString(select) {
+        return select
+            .sort((a, b) => (a.order || 0) - (b.order || 0))
+            .map(item => {
+            let selectStr = item.propertyName;
+            // Add display name if provided
+            if (item.displayName) {
+                selectStr += ` as ${item.displayName}`;
+            }
+            // Add aggregate function if provided
+            if (item.aggregateFunction) {
+                selectStr += ` with ${item.aggregateFunction}`;
+            }
+            // Add visibility metadata
+            const metadata = [];
+            if (item.isVisible !== undefined) {
+                metadata.push(`visible:${item.isVisible}`);
+            }
+            if (metadata.length > 0) {
+                selectStr += `(${metadata.join(';')})`;
+            }
+            return selectStr;
+        })
+            .join(',');
+    }
+    static buildAggregateString(aggregates) {
+        return aggregates
+            .map(agg => {
+            let aggStr = `${agg.aggregateFunction}(${agg.propertyName})`;
+            if (agg.alias) {
+                aggStr += ` as ${agg.alias}`;
+            }
+            return aggStr;
+        })
+            .join(',');
+    }
     static parseFilter(filterString, params) {
         const decodedString = decodeURIComponent(filterString);
-        // Handle individual conditions and groups
         const groups = [];
         // Split by top-level AND/OR operators
         const topLevelPattern = /(?:^|\s)(and|or)\s+(?=(?:[^()]*\([^()]*\))*[^()]*$)/gi;
@@ -945,19 +1035,18 @@ class QueryParser {
             }
             if (conditions.length > 0) {
                 const group = {
-                    logicalOperator: 'and', // Default for conditions within group
+                    logicalOperator: 'and',
                     conditions: conditions
                 };
                 // For groups after the first, set the groupLogicalOperator
                 if (index > 0) {
                     group.groupLogicalOperator = segment.operator?.toLowerCase() || 'and';
                 }
-                // If it's a single condition group, we can detect OR operators within
+                // Detect the logical operator used within the group
                 if (conditions.length === 1 && segment.condition.includes(' or ')) {
                     group.logicalOperator = 'or';
                 }
                 else if (conditions.length > 1) {
-                    // Detect the logical operator used within the group
                     group.logicalOperator = segment.condition.toLowerCase().includes(' or ') ? 'or' : 'and';
                 }
                 groups.push(group);
@@ -967,8 +1056,8 @@ class QueryParser {
     }
     static parseConditions(conditionString) {
         const conditions = [];
-        // Split by AND/OR but be careful not to split within quotes or parentheses
-        const pattern = /(\w+)\s+(eq|ne|gt|ge|lt|le|contains|startswith|endswith)\s+('[^']*'|\d+|true|false)/gi;
+        // Enhanced pattern to handle more operators and complex values
+        const pattern = /(\w+(?:\.\w+)*)\s+(eq|ne|gt|ge|lt|le|contains|startswith|endswith|in|notin)\s+('[^']*'|\[[^\]]*\]|\d+|true|false|null)/gi;
         let match;
         while ((match = pattern.exec(conditionString)) !== null) {
             const [, field, operator, rawValue] = match;
@@ -976,6 +1065,13 @@ class QueryParser {
             if (rawValue.startsWith("'") && rawValue.endsWith("'")) {
                 value = rawValue.slice(1, -1).replace(/''/g, "'");
             }
+            else if (rawValue.startsWith('[') && rawValue.endsWith(']')) {
+                // Handle array values for IN/NOT IN operators
+                value = rawValue.slice(1, -1).split(',').map(v => {
+                    const trimmed = v.trim().replace(/^'|'$/g, '');
+                    return isNaN(Number(trimmed)) ? trimmed : Number(trimmed);
+                });
+            }
             else if (!isNaN(Number(rawValue))) {
                 value = Number(rawValue);
             }
@@ -985,6 +1081,9 @@ class QueryParser {
             else if (rawValue.toLowerCase() === 'false') {
                 value = false;
             }
+            else if (rawValue.toLowerCase() === 'null') {
+                value = null;
+            }
             conditions.push({
                 field: field.trim(),
                 operator: operator.trim().toLowerCase(),
@@ -1006,6 +1105,173 @@ class QueryParser {
             });
         }
     }
+    static parseGroupBy(groupByString, params) {
+        const decodedString = decodeURIComponent(groupByString);
+        const groups = decodedString.split(',');
+        params.groupBy = groups.map((groupStr, index) => {
+            const group = {
+                propertyName: '',
+                order: index
+            };
+            // Check for metadata in parentheses
+            const metadataMatch = groupStr.match(/^(.*?)\((.*)\)$/);
+            let baseStr = groupStr;
+            let metadataStr = '';
+            if (metadataMatch) {
+                baseStr = metadataMatch[1];
+                metadataStr = metadataMatch[2];
+            }
+            // Check for display name alias
+            const aliasMatch = baseStr.match(/^(.*?)\s+as\s+(.*)$/);
+            if (aliasMatch) {
+                group.propertyName = aliasMatch[1].trim();
+                group.displayName = aliasMatch[2].trim();
+            }
+            else {
+                group.propertyName = baseStr.trim();
+            }
+            // Parse metadata
+            if (metadataStr) {
+                const metadataParts = metadataStr.split(';');
+                metadataParts.forEach(part => {
+                    const [key, value] = part.split(':');
+                    switch (key) {
+                        case 'showTotal':
+                            group.showTotal = value.toLowerCase() === 'true';
+                            break;
+                        case 'totalBg':
+                            group.totalBackground = value;
+                            break;
+                        case 'headerBg':
+                            group.groupHeaderBackground = value;
+                            break;
+                    }
+                });
+            }
+            return group;
+        });
+    }
+    static parseSelect(selectString, params) {
+        const decodedString = decodeURIComponent(selectString);
+        const items = decodedString.split(',');
+        params.select = items.map((itemStr, index) => {
+            const item = {
+                propertyName: '',
+                isVisible: true,
+                order: index
+            };
+            // Check for metadata in parentheses
+            const metadataMatch = itemStr.match(/^(.*?)\((.*)\)$/);
+            let baseStr = itemStr;
+            let metadataStr = '';
+            if (metadataMatch) {
+                baseStr = metadataMatch[1];
+                metadataStr = metadataMatch[2];
+            }
+            // Check for display name alias and aggregate function
+            const aliasMatch = baseStr.match(/^(.*?)(?:\s+as\s+(.*?))?(?:\s+with\s+(\w+))?$/);
+            if (aliasMatch) {
+                item.propertyName = aliasMatch[1].trim();
+                if (aliasMatch[2]) {
+                    item.displayName = aliasMatch[2].trim();
+                }
+                if (aliasMatch[3]) {
+                    item.aggregateFunction = aliasMatch[3].trim();
+                }
+            }
+            else {
+                item.propertyName = baseStr.trim();
+            }
+            // Parse metadata
+            if (metadataStr) {
+                const metadataParts = metadataStr.split(';');
+                metadataParts.forEach(part => {
+                    const [key, value] = part.split(':');
+                    if (key === 'visible') {
+                        item.isVisible = value.toLowerCase() === 'true';
+                    }
+                });
+            }
+            return item;
+        });
+    }
+    static parseAggregate(aggregateString, params) {
+        const decodedString = decodeURIComponent(aggregateString);
+        const aggregates = decodedString.split(',');
+        params.aggregates = aggregates.map(aggStr => {
+            const agg = {
+                propertyName: '',
+                aggregateFunction: ''
+            };
+            // Match pattern: function(property) as alias
+            const match = aggStr.match(/^(\w+)\((\w+)\)(?:\s+as\s+(\w+))?$/);
+            if (match) {
+                agg.aggregateFunction = match[1];
+                agg.propertyName = match[2];
+                if (match[3]) {
+                    agg.alias = match[3];
+                }
+            }
+            return agg;
+        });
+    }
+    // Helper method to convert QueryParameters to ODataQueryParameters (C# equivalent)
+    static toODataQueryParameters(params) {
+        return {
+            Filters: params.filters.map(group => ({
+                LogicalOperator: group.logicalOperator,
+                GroupLogicalOperator: group.groupLogicalOperator,
+                Conditions: group.conditions.map(cond => ({
+                    Field: cond.field,
+                    Operator: cond.operator,
+                    Value: cond.value
+                }))
+            })),
+            OrderBy: params.orderBy?.map(order => ({
+                Field: order.field,
+                Direction: order.direction
+            })) || [],
+            GroupBy: params.groupBy?.map(group => ({
+                PropertyName: group.propertyName,
+                DisplayName: group.displayName,
+                ShowTotal: group.showTotal ?? true,
+                TotalBackground: group.totalBackground,
+                GroupHeaderBackground: group.groupHeaderBackground,
+                Order: group.order
+            })) || [],
+            Select: params.select?.map(sel => ({
+                PropertyName: sel.propertyName,
+                DisplayName: sel.displayName,
+                AggregateFunction: sel.aggregateFunction,
+                IsVisible: sel.isVisible ?? true,
+                Order: sel.order
+            })) || [],
+            Aggregates: params.aggregates?.map(agg => ({
+                PropertyName: agg.propertyName,
+                AggregateFunction: agg.aggregateFunction,
+                Alias: agg.alias
+            })) || [],
+            Top: params.top,
+            Skip: params.skip,
+            Expand: params.expand,
+            IncludeCount: params.includeCount
+        };
+    }
+    // Helper method to create query parameters from UI model
+    static fromUIModel(model) {
+        const params = {
+            filters: model.advancedFilters || [],
+            orderBy: model.sorting || [],
+            groupBy: model.grouping || [],
+            select: model.columns || [],
+            aggregates: model.aggregates || [],
+            top: model.pagination?.top,
+            skip: model.pagination?.skip,
+            expand: model.expand,
+            includeCount: model.pagination?.includeCount
+        };
+        return params;
+    }
 }
 
 /**