@elite.framework/ng.core 2.0.17 → 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),
@@ -829,9 +834,449 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
+class QueryParser {
+    static parse(queryString) {
+        const params = {
+            filters: [],
+            orderBy: [],
+            groupBy: [],
+            select: [],
+            aggregates: []
+        };
+        if (!queryString)
+            return params;
+        const queryParts = queryString.split('&');
+        for (const part of queryParts) {
+            if (part.startsWith('$filter=')) {
+                this.parseFilter(part.substring('$filter='.length), params);
+            }
+            else if (part.startsWith('$orderby=')) {
+                this.parseOrderBy(part.substring('$orderby='.length), params);
+            }
+            else if (part.startsWith('$groupby=')) {
+                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));
+            }
+            else if (part.startsWith('$skip=')) {
+                params.skip = Number(part.substring('$skip='.length));
+            }
+            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;
+    }
+    static toString(params) {
+        const parts = [];
+        if (params.filters?.length) {
+            const filterStr = this.buildFilterString(params.filters);
+            parts.push(`$filter=${encodeURIComponent(filterStr)}`);
+        }
+        if (params.orderBy?.length) {
+            const orderByStr = params.orderBy.map(o => `${o.field} ${o.direction}`).join(',');
+            parts.push(`$orderby=${encodeURIComponent(orderByStr)}`);
+        }
+        if (params.groupBy?.length) {
+            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}`);
+        }
+        if (params.skip !== undefined) {
+            parts.push(`$skip=${params.skip}`);
+        }
+        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) {
+        return filters.map((group, index) => {
+            const groupStr = group.conditions
+                .map(condition => {
+                let val = condition.value;
+                if (typeof val === 'string') {
+                    val = `'${val.replace(/'/g, "''")}'`;
+                }
+                else if (typeof val === 'boolean') {
+                    val = val ? 'true' : 'false';
+                }
+                return `${condition.field} ${condition.operator} ${val}`;
+            })
+                .join(` ${group.logicalOperator} `);
+            // For the first group, no groupLogicalOperator is needed
+            if (index === 0) {
+                return group.conditions.length > 1 ? `(${groupStr})` : groupStr;
+            }
+            else {
+                const joinOp = group.groupLogicalOperator || 'and';
+                return group.conditions.length > 1 ? `${joinOp} (${groupStr})` : `${joinOp} ${groupStr}`;
+            }
+        }).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);
+        const groups = [];
+        // Split by top-level AND/OR operators
+        const topLevelPattern = /(?:^|\s)(and|or)\s+(?=(?:[^()]*\([^()]*\))*[^()]*$)/gi;
+        const segments = [];
+        let lastIndex = 0;
+        let match;
+        while ((match = topLevelPattern.exec(decodedString)) !== null) {
+            const operator = match[1];
+            const segment = decodedString.substring(lastIndex, match.index).trim();
+            if (segment) {
+                segments.push({ condition: segment, operator });
+            }
+            lastIndex = match.index + match[0].length;
+        }
+        // Add the last segment
+        const lastSegment = decodedString.substring(lastIndex).trim();
+        if (lastSegment) {
+            segments.push({ condition: lastSegment, operator: undefined });
+        }
+        // Parse each segment
+        segments.forEach((segment, index) => {
+            let conditions = [];
+            // Check if it's a group with parentheses
+            if (segment.condition.startsWith('(') && segment.condition.endsWith(')')) {
+                const innerCondition = segment.condition.slice(1, -1).trim();
+                conditions = this.parseConditions(innerCondition);
+            }
+            else {
+                // Individual condition
+                conditions = this.parseConditions(segment.condition);
+            }
+            if (conditions.length > 0) {
+                const group = {
+                    logicalOperator: 'and',
+                    conditions: conditions
+                };
+                // For groups after the first, set the groupLogicalOperator
+                if (index > 0) {
+                    group.groupLogicalOperator = segment.operator?.toLowerCase() || 'and';
+                }
+                // Detect the logical operator used within the group
+                if (conditions.length === 1 && segment.condition.includes(' or ')) {
+                    group.logicalOperator = 'or';
+                }
+                else if (conditions.length > 1) {
+                    group.logicalOperator = segment.condition.toLowerCase().includes(' or ') ? 'or' : 'and';
+                }
+                groups.push(group);
+            }
+        });
+        params.filters = groups;
+    }
+    static parseConditions(conditionString) {
+        const conditions = [];
+        // 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;
+            let value = rawValue.trim();
+            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);
+            }
+            else if (rawValue.toLowerCase() === 'true') {
+                value = true;
+            }
+            else if (rawValue.toLowerCase() === 'false') {
+                value = false;
+            }
+            else if (rawValue.toLowerCase() === 'null') {
+                value = null;
+            }
+            conditions.push({
+                field: field.trim(),
+                operator: operator.trim().toLowerCase(),
+                value
+            });
+        }
+        return conditions;
+    }
+    static parseOrderBy(orderByString, params) {
+        const decodedString = decodeURIComponent(orderByString);
+        const clauses = decodedString.split(',');
+        for (const clause of clauses) {
+            const parts = clause.trim().split(/\s+/);
+            const field = parts[0];
+            const direction = parts[1]?.toLowerCase() || 'asc';
+            params.orderBy?.push({
+                field,
+                direction
+            });
+        }
+    }
+    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;
+    }
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { BaseService, GenericService, IdParserService, LogLevel, LoggerService, NgxPermissionsGuard, PermissionsService, REQUEST, RestService, SsrCookieService, SwalService, isUndefinedOrEmptyString, ngxPermissionsGuard };
+export { BaseService, GenericService, IdParserService, LogLevel, LoggerService, NgxPermissionsGuard, PermissionsService, QueryParser, REQUEST, RestService, SsrCookieService, SwalService, isUndefinedOrEmptyString, ngxPermissionsGuard };
 //# sourceMappingURL=elite.framework-ng.core-services.mjs.map