@mediusinc/mng-commons-data-api-class 5.0.0-rc.0

package/esm2022/tableview/tableview-crud.data-provider.mjs

@@ -0,0 +1,50 @@
+import { map } from 'rxjs/operators';
+import { FilterMatchMode, mapToDataList } from '@mediusinc/mng-commons/core';
+import { ModelUtil } from '@mediusinc/mng-commons/model';
+import { TableviewDataProviderInst } from '@mediusinc/mng-commons/tableview/api';
+export class TableviewCrudDataProviderInst extends TableviewDataProviderInst {
+    constructor(type, requestType, serviceType, idPropertyName, useGetAllForFetch = false) {
+        super(type, serviceType);
+        this.requestType = requestType;
+        this._toRequestMap = item => item;
+        this.withGetAll((params, service, locale) => service.getAllGet(params, undefined, locale).pipe(mapToDataList()));
+        if (useGetAllForFetch) {
+            const selectedIdPropertyName = idPropertyName ?? ModelUtil.findIdAttribute(type) ?? 'id';
+            this.withFetch((id, service) => {
+                return service
+                    .getAllGet({
+                    limit: 1,
+                    filters: {
+                        [selectedIdPropertyName]: {
+                            value: id,
+                            matchMode: FilterMatchMode.Equals
+                        }
+                    }
+                })
+                    .pipe(map(res => res.data[0]));
+            });
+        }
+        else {
+            this.withFetch((id, service, locale) => service.getByIdGet(id, undefined, locale));
+        }
+        this.withCreate((item, service) => service.createPost(this.toRequestMap(item)));
+        this.withUpdate((id, item, service) => service.updatePut(id, this.toRequestMap(item)));
+        this.withDelete((id, item, service) => service.removeDelete(id, item));
+    }
+    get toRequestMap() {
+        return this._toRequestMap;
+    }
+    withToRequestMap(fn) {
+        this._toRequestMap = fn;
+        return this;
+    }
+}
+export class TableviewCrudDataProvider extends TableviewCrudDataProviderInst {
+    static create(type, requestType, serviceType, idProperty, useGetAllForFetch = false) {
+        return TableviewCrudDataProvider.createUnsafe(type, requestType, serviceType, idProperty, useGetAllForFetch);
+    }
+    static createUnsafe(type, requestType, serviceType, idProperty, useGetAllForFetch = false) {
+        return new TableviewCrudDataProviderInst(type, requestType, serviceType, idProperty, useGetAllForFetch);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tableview-crud.data-provider.js","sourceRoot":"","sources":["../../../tableview/src/tableview-crud.data-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import {Type} from '@angular/core';\n\nimport {map} from 'rxjs/operators';\n\nimport {ICommonsCrudApiService, ICommonsGetAllApiService, QueryResult} from '@mediusinc/mng-commons-data-api-class';\nimport {ClassType, FilterMatchMode, ServiceClassType, mapToDataList} from '@mediusinc/mng-commons/core';\nimport {ModelUtil} from '@mediusinc/mng-commons/model';\nimport {TableviewDataProviderInst} from '@mediusinc/mng-commons/tableview/api';\n\nexport type ToRequestMapFnType<Model, RequestModel> = (item?: Model) => RequestModel;\n\nexport class TableviewCrudDataProviderInst<\n    Model,\n    RequestModel,\n    Service extends ICommonsCrudApiService<Model, RequestModel> & ICommonsGetAllApiService<QueryResult<Model>>,\n    Sorts = keyof Model,\n    Filters extends keyof any = keyof Model\n> extends TableviewDataProviderInst<Model, Service, Sorts, Filters, ClassType<Model>, ServiceClassType<Service>> {\n    private _toRequestMap: ToRequestMapFnType<Model, RequestModel> = item => item as RequestModel;\n\n    protected constructor(\n        type: ClassType<Model>,\n        protected requestType: ClassType<RequestModel>,\n        serviceType: Type<Service>,\n        idPropertyName?: string,\n        useGetAllForFetch = false\n    ) {\n        super(type, serviceType);\n        this.withGetAll((params, service, locale) => service.getAllGet(params, undefined, locale).pipe(mapToDataList()));\n\n        if (useGetAllForFetch) {\n            const selectedIdPropertyName = idPropertyName ?? ModelUtil.findIdAttribute(type) ?? 'id';\n            this.withFetch((id, service) => {\n                return service!\n                    .getAllGet({\n                        limit: 1,\n                        filters: {\n                            [selectedIdPropertyName]: {\n                                value: id,\n                                matchMode: FilterMatchMode.Equals\n                            }\n                        }\n                    })\n                    .pipe(map(res => res.data![0]));\n            });\n        } else {\n            this.withFetch((id, service, locale) => service!.getByIdGet!(id, undefined, locale));\n        }\n        this.withCreate((item, service) => service.createPost!(this.toRequestMap(item)));\n        this.withUpdate((id, item, service) => service.updatePut!(id, this.toRequestMap(item)));\n        this.withDelete((id, item, service) => service.removeDelete!(id, item));\n    }\n\n    public get toRequestMap() {\n        return this._toRequestMap;\n    }\n\n    public withToRequestMap(fn: ToRequestMapFnType<Model, RequestModel>) {\n        this._toRequestMap = fn;\n        return this;\n    }\n}\n\nexport class TableviewCrudDataProvider extends TableviewCrudDataProviderInst<any, any, any> {\n    public static create<\n        Model,\n        RequestModel,\n        Service extends ICommonsCrudApiService<Model, RequestModel> & ICommonsGetAllApiService<QueryResult<Model>>,\n        Sorts = keyof Model,\n        Filters extends keyof any = keyof Model\n    >(\n        type: ClassType<Model>,\n        requestType: ClassType<RequestModel>,\n        serviceType: Type<Service>,\n        idProperty?: keyof Model,\n        useGetAllForFetch = false\n    ): TableviewCrudDataProviderInst<Model, RequestModel, Service, Sorts, Filters> {\n        return TableviewCrudDataProvider.createUnsafe<Model, RequestModel, Service, Sorts, Filters>(type, requestType, serviceType, idProperty as string, useGetAllForFetch);\n    }\n\n    public static createUnsafe<\n        Model,\n        RequestModel,\n        Service extends ICommonsCrudApiService<Model, RequestModel> & ICommonsGetAllApiService<QueryResult<Model>>,\n        Sorts = keyof Model,\n        Filters extends keyof any = keyof Model\n    >(\n        type: ClassType<Model>,\n        requestType: ClassType<RequestModel>,\n        serviceType: Type<Service>,\n        idProperty?: string,\n        useGetAllForFetch = false\n    ): TableviewCrudDataProviderInst<Model, RequestModel, Service, Sorts, Filters> {\n        return new TableviewCrudDataProviderInst<Model, RequestModel, Service, Sorts, Filters>(type, requestType, serviceType, idProperty, useGetAllForFetch);\n    }\n}\n"]}

package/esm2022/v1/helpers/query-param-convert.mjs

@@ -0,0 +1,103 @@
+import { map } from 'rxjs/operators';
+import { CommonsInternalError, FilterMatchMode } from '@mediusinc/mng-commons/core';
+import { MediusQueryParamBuilder } from '../models/builders/query-param.builder';
+import { MediusFilterMatchType } from '../models/filter-match-type.model';
+/**
+ * Converts the given DataListParams object to an ObsoleteV1QueryParam object.
+ *
+ * @param {DataListParams} params - The object to convert.
+ * @param {QueryParamMap} map - The configuration object used to map sort and filter properties.
+ *
+ * @returns The converted ObsoleteV1QueryParam object if params is not null or undefined, otherwise returns undefined.
+ *
+ * @deprecated
+ */
+export function toV1QueryParam(params, map) {
+    if (!params)
+        return undefined;
+    const builder = MediusQueryParamBuilder.create();
+    if (params.offset !== undefined) {
+        builder.withItemsOffset(params.offset);
+    }
+    if (params.limit !== undefined) {
+        builder.withItemsPerPage(params.limit);
+    }
+    if (Array.isArray(params.sort)) {
+        params.sort.forEach(s => builder.withSort(map?.mapSort(s.property) ?? s.property, s.ascending));
+    }
+    if (typeof params.filters === 'object') {
+        Object.entries(params.filters).forEach(([key, value]) => {
+            const filter = value;
+            if (filter.value != null) {
+                const matchMode = filter.matchMode ? toV1FilterMatchType(filter.matchMode) : MediusFilterMatchType.Equals;
+                let value = undefined;
+                let valueTo = undefined;
+                if (matchMode === MediusFilterMatchType.FromTo) {
+                    if (Array.isArray(filter.value)) {
+                        if (filter.value.length > 0)
+                            value = filter.value[0];
+                        if (filter.value.length > 1)
+                            valueTo = filter.value[1];
+                    }
+                }
+                else {
+                    value = filter.value;
+                }
+                builder.withFilter(map?.mapFilter(key) ?? key, value, valueTo, matchMode, filter.caseSensitive);
+            }
+        });
+    }
+    return builder.build();
+}
+export function toV1FilterMatchType(match) {
+    switch (match) {
+        case FilterMatchMode.Equals:
+            return MediusFilterMatchType.Equals;
+        case FilterMatchMode.NotEquals:
+            return MediusFilterMatchType.NotEquals;
+        case FilterMatchMode.Contains:
+            return MediusFilterMatchType.Contains;
+        case FilterMatchMode.In:
+            return MediusFilterMatchType.In;
+        case FilterMatchMode.NotIn:
+            return MediusFilterMatchType.NotIn;
+        case FilterMatchMode.StartsWith:
+            return MediusFilterMatchType.StartsWith;
+        case FilterMatchMode.EndsWith:
+            return MediusFilterMatchType.EndsWith;
+        case FilterMatchMode.LessThan:
+            return MediusFilterMatchType.SmallerThan;
+        case FilterMatchMode.GreaterThan:
+            return MediusFilterMatchType.GreaterThan;
+        case FilterMatchMode.Between:
+            return MediusFilterMatchType.FromTo;
+        case FilterMatchMode.Exists:
+            return MediusFilterMatchType.Exists;
+        case FilterMatchMode.DoesNotExist:
+            return MediusFilterMatchType.DoesNotExist;
+        case FilterMatchMode.NotContains:
+        case FilterMatchMode.LessThanOrEqualTo:
+        case FilterMatchMode.GreaterThanOrEqualTo:
+        default:
+            throw new CommonsInternalError(`Filter match type '${match}' not supported.`);
+    }
+}
+/**
+ * Convert a query result from an obsolete API version 1 to a `DataListResult`
+ *
+ * @param {DataListParams} params - The data list parameters for the query
+ * @param {Service} service - The service object used to make the API call
+ * @param {function} apiOperation - The API operation function that returns an `Observable<MediusQueryResult<Item>>`
+ * @param {any} additionalParams - Additional parameters to pass to the API operation function (optional)
+ *
+ * @returns {Observable<DataListResult<Item>>} - An observable that emits a `DataListResult` object
+ *
+ * @deprecated
+ */
+export function executeV1GetAll(params, service, apiOperation, additionalParams) {
+    const queryParam = toV1QueryParam(params);
+    return apiOperation
+        .bind(service)(queryParam, ...(additionalParams ?? []))
+        .pipe(map(res => ({ data: res.pageData ?? [], totalCount: res.allDataCount })));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-param-convert.js","sourceRoot":"","sources":["../../../../v1/src/helpers/query-param-convert.ts"],"names":[],"mappings":"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","sourcesContent":["import {Observable} from 'rxjs';\nimport {map} from 'rxjs/operators';\n\nimport {CommonsInternalError, DataListFilter, DataListFilterValueType, DataListParams, DataListResult, FilterMatchMode} from '@mediusinc/mng-commons/core';\n\nimport {MediusQueryParamBuilder} from '../models/builders/query-param.builder';\nimport {MediusFilterMatchType} from '../models/filter-match-type.model';\nimport {MediusQueryParam} from '../models/query-param.model';\nimport {MediusQueryResult} from '../models/query-result.model';\nimport {QueryParamMap} from '../utils/query-param-map.util';\n\nexport function toV1QueryParam(): undefined;\nexport function toV1QueryParam<Sorts = string, Filters extends keyof any = string>(params: DataListParams<Sorts, Filters>, map?: QueryParamMap<Sorts, Filters>): MediusQueryParam;\nexport function toV1QueryParam<Sorts = string, Filters extends keyof any = string>(\n    params: DataListParams<Sorts, Filters> | undefined,\n    map?: QueryParamMap<Sorts, Filters>\n): MediusQueryParam | undefined;\n/**\n * Converts the given DataListParams object to an ObsoleteV1QueryParam object.\n *\n * @param {DataListParams} params - The object to convert.\n * @param {QueryParamMap} map - The configuration object used to map sort and filter properties.\n *\n * @returns The converted ObsoleteV1QueryParam object if params is not null or undefined, otherwise returns undefined.\n *\n * @deprecated\n */\nexport function toV1QueryParam<Sorts = string, Filters extends keyof any = string>(\n    params?: DataListParams<Sorts, Filters>,\n    map?: QueryParamMap<Sorts, Filters>\n): MediusQueryParam | undefined {\n    if (!params) return undefined;\n\n    const builder = MediusQueryParamBuilder.create();\n    if (params.offset !== undefined) {\n        builder.withItemsOffset(params.offset);\n    }\n    if (params.limit !== undefined) {\n        builder.withItemsPerPage(params.limit);\n    }\n    if (Array.isArray(params.sort)) {\n        params.sort.forEach(s => builder.withSort(map?.mapSort(s.property as string) ?? (s.property as string), s.ascending));\n    }\n    if (typeof params.filters === 'object') {\n        Object.entries(params.filters).forEach(([key, value]) => {\n            const filter = value as DataListFilter;\n            if (filter.value != null) {\n                const matchMode = filter.matchMode ? toV1FilterMatchType(filter.matchMode) : MediusFilterMatchType.Equals;\n                let value: DataListFilterValueType = undefined;\n                let valueTo: DataListFilterValueType = undefined;\n                if (matchMode === MediusFilterMatchType.FromTo) {\n                    if (Array.isArray(filter.value)) {\n                        if (filter.value.length > 0) value = filter.value[0];\n                        if (filter.value.length > 1) valueTo = filter.value[1];\n                    }\n                } else {\n                    value = filter.value;\n                }\n\n                builder.withFilter(map?.mapFilter(key) ?? key, value, valueTo, matchMode, filter.caseSensitive);\n            }\n        });\n    }\n\n    return builder.build();\n}\n\nexport function toV1FilterMatchType(match: string): MediusFilterMatchType {\n    switch (match) {\n        case FilterMatchMode.Equals:\n            return MediusFilterMatchType.Equals;\n        case FilterMatchMode.NotEquals:\n            return MediusFilterMatchType.NotEquals;\n        case FilterMatchMode.Contains:\n            return MediusFilterMatchType.Contains;\n        case FilterMatchMode.In:\n            return MediusFilterMatchType.In;\n        case FilterMatchMode.NotIn:\n            return MediusFilterMatchType.NotIn;\n        case FilterMatchMode.StartsWith:\n            return MediusFilterMatchType.StartsWith;\n        case FilterMatchMode.EndsWith:\n            return MediusFilterMatchType.EndsWith;\n        case FilterMatchMode.LessThan:\n            return MediusFilterMatchType.SmallerThan;\n        case FilterMatchMode.GreaterThan:\n            return MediusFilterMatchType.GreaterThan;\n        case FilterMatchMode.Between:\n            return MediusFilterMatchType.FromTo;\n        case FilterMatchMode.Exists:\n            return MediusFilterMatchType.Exists;\n        case FilterMatchMode.DoesNotExist:\n            return MediusFilterMatchType.DoesNotExist;\n        case FilterMatchMode.NotContains:\n        case FilterMatchMode.LessThanOrEqualTo:\n        case FilterMatchMode.GreaterThanOrEqualTo:\n        default:\n            throw new CommonsInternalError(`Filter match type '${match}' not supported.`);\n    }\n}\n\n/**\n * Convert a query result from an obsolete API version 1 to a `DataListResult`\n *\n * @param {DataListParams} params - The data list parameters for the query\n * @param {Service} service - The service object used to make the API call\n * @param {function} apiOperation - The API operation function that returns an `Observable<MediusQueryResult<Item>>`\n * @param {any} additionalParams - Additional parameters to pass to the API operation function (optional)\n *\n * @returns {Observable<DataListResult<Item>>} - An observable that emits a `DataListResult` object\n *\n * @deprecated\n */\nexport function executeV1GetAll<Item, Service>(\n    params: DataListParams,\n    service: Service,\n    apiOperation: (qp: MediusQueryParam, ...additionalParams: any) => Observable<MediusQueryResult<Item>>,\n    additionalParams?: any\n): Observable<DataListResult<Item>> {\n    const queryParam = toV1QueryParam(params);\n    return apiOperation\n        .bind(service)(queryParam, ...(additionalParams ?? []))\n        .pipe(map(res => ({data: res.pageData ?? [], totalCount: res.allDataCount})));\n}\n"]}

package/esm2022/v1/helpers/tableview-crud-create.mjs

@@ -0,0 +1,21 @@
+import { Injector, inject } from '@angular/core';
+import { TableviewDescriptor, TableviewInputBuilder } from '@mediusinc/mng-commons/tableview/api';
+import { TableviewCrudV1DataProvider } from '../tableview/tableview-crud.data-provider';
+/**
+ * Creates a tableview with the given class, service based on data API v1 (obsolete) and optional class/model configuration.
+ *
+ * @param {ClassType<Model>} type - The class representing the model.
+ * @param {ServiceClassType<Service>} service - The class type of the service implementing `IMngCrudObsoleteV1ApiService` and `IMngGetAllObsoleteV1ApiService`.
+ * @param {{ idProperty?: keyof Model; titleProperty?: keyof Model; i18nBaseKey?: ClassType<any> | string; }} [modelConfig] - Additional optional model configuration.
+ * @param {(builder: TableviewBuilder) => void} [buildFn] - The optional callback function to customize the tableview using the prepared builder.
+ *
+ * @returns {Tableview} - The built table view.
+ *
+ * @deprecated
+ */
+export function tableviewCrudV1(type, service, modelConfig, buildFn) {
+    const builder = new TableviewInputBuilder(TableviewDescriptor.fromClass(type, modelConfig?.idProperty, modelConfig?.titleProperty, modelConfig?.i18nBaseKey), TableviewCrudV1DataProvider.create(type, service, modelConfig?.idProperty), inject(Injector));
+    buildFn?.(builder);
+    return builder.build();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/v1/index.mjs

@@ -0,0 +1,21 @@
+// helpers
+export * from './helpers/query-param-convert';
+export * from './helpers/tableview-crud-create';
+// models
+export * from './models/builders/query-param.builder';
+export * from './models/filter-match-type.model';
+export * from './models/filter-param.model';
+export * from './models/query-mode.model';
+export * from './models/query-param.model';
+export * from './models/query-result.model';
+// services
+export * from './services/api.abstract.service';
+export * from './services/crud-api.abstract.service';
+export * from './services/get-all-api.abstract.service';
+// tableview
+export * from './tableview/tableview-crud.data-provider';
+// utils
+export * from './utils/query-param-map.util';
+// provider
+export * from './provide';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi92MS9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsVUFBVTtBQUNWLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxpQ0FBaUMsQ0FBQztBQUVoRCxTQUFTO0FBQ1QsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsNkJBQTZCLENBQUM7QUFFNUMsV0FBVztBQUNYLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLHlDQUF5QyxDQUFDO0FBRXhELFlBQVk7QUFDWixjQUFjLDBDQUEwQyxDQUFDO0FBRXpELFFBQVE7QUFDUixjQUFjLDhCQUE4QixDQUFDO0FBRTdDLFdBQVc7QUFDWCxjQUFjLFdBQVcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIGhlbHBlcnNcbmV4cG9ydCAqIGZyb20gJy4vaGVscGVycy9xdWVyeS1wYXJhbS1jb252ZXJ0JztcbmV4cG9ydCAqIGZyb20gJy4vaGVscGVycy90YWJsZXZpZXctY3J1ZC1jcmVhdGUnO1xuXG4vLyBtb2RlbHNcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL2J1aWxkZXJzL3F1ZXJ5LXBhcmFtLmJ1aWxkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvZmlsdGVyLW1hdGNoLXR5cGUubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvZmlsdGVyLXBhcmFtLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL3F1ZXJ5LW1vZGUubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvcXVlcnktcGFyYW0ubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvcXVlcnktcmVzdWx0Lm1vZGVsJztcblxuLy8gc2VydmljZXNcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvYXBpLmFic3RyYWN0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcy9jcnVkLWFwaS5hYnN0cmFjdC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvZ2V0LWFsbC1hcGkuYWJzdHJhY3Quc2VydmljZSc7XG5cbi8vIHRhYmxldmlld1xuZXhwb3J0ICogZnJvbSAnLi90YWJsZXZpZXcvdGFibGV2aWV3LWNydWQuZGF0YS1wcm92aWRlcic7XG5cbi8vIHV0aWxzXG5leHBvcnQgKiBmcm9tICcuL3V0aWxzL3F1ZXJ5LXBhcmFtLW1hcC51dGlsJztcblxuLy8gcHJvdmlkZXJcbmV4cG9ydCAqIGZyb20gJy4vcHJvdmlkZSc7XG4iXX0=

package/esm2022/v1/mediusinc-mng-commons-data-api-class-v1.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVkaXVzaW5jLW1uZy1jb21tb25zLWRhdGEtYXBpLWNsYXNzLXYxLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdjEvc3JjL21lZGl1c2luYy1tbmctY29tbW9ucy1kYXRhLWFwaS1jbGFzcy12MS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/v1/models/builders/query-param.builder.mjs

@@ -0,0 +1,83 @@
+import { MediusFilterMatchType } from '../filter-match-type.model';
+import { MediusFilterParam } from '../filter-param.model';
+import { MediusQueryMode } from '../query-mode.model';
+import { MediusQueryParam } from '../query-param.model';
+export class MediusQueryParamBuilder {
+    constructor(queryParam) {
+        this.queryParam = queryParam;
+    }
+    /**
+     * Creates a new instance of `MediusQueryParamBuilder` with the specified `itemsPerPage` and `itemsOffset` values.
+     *
+     * @param {number} [itemsPerPage=50] - The number of items per page.
+     * @param {number} [itemsOffset=0] - The offset value for the items.
+     *
+     * @returns {MediusQueryParamBuilder} A new instance of `MediusQueryParamBuilder`.
+     *
+     * @deprecated
+     */
+    static create(itemsPerPage = 50, itemsOffset = 0) {
+        const queryParam = new MediusQueryParam();
+        queryParam.itemsPerPage = itemsPerPage;
+        queryParam.itemsOffset = itemsOffset;
+        queryParam.queryMode = MediusQueryMode.All;
+        return new MediusQueryParamBuilder(queryParam);
+    }
+    /**
+     * Creates a new instance of MediusQueryParamBuilder based on an existing MediusQueryParam object.
+     *
+     * @param {MediusQueryParam} queryParam - The existing MediusQueryParam object to create from.
+     * @param {number} [itemsPerPage] - The number of items per page for the new instance. If not provided, default value is used.
+     * @param {number} [itemsOffset] - The offset for the new instance. If not provided, default value is used.
+     *
+     * @returns {MediusQueryParamBuilder} - A new instance of MediusQueryParamBuilder.
+     *
+     * @deprecated
+     */
+    static createFromExisting(queryParam, itemsPerPage, itemsOffset) {
+        queryParam.itemsPerPage = itemsPerPage ?? queryParam.itemsPerPage ?? 50;
+        queryParam.itemsOffset = itemsOffset ?? queryParam.itemsOffset ?? 0;
+        queryParam.queryMode = queryParam.queryMode ?? MediusQueryMode.All;
+        return new MediusQueryParamBuilder(queryParam);
+    }
+    withItemsPerPage(itemsPerPage) {
+        this.queryParam.itemsPerPage = itemsPerPage;
+        return this;
+    }
+    withItemsOffset(itemsOffset) {
+        this.queryParam.itemsOffset = itemsOffset;
+        return this;
+    }
+    withQueryMode(queryMode) {
+        this.queryParam.queryMode = queryMode;
+        return this;
+    }
+    withSort(property, asc = true) {
+        if (!this.queryParam.sortProperty || !this.queryParam.sortAsc) {
+            this.queryParam.sortProperty = [];
+            this.queryParam.sortAsc = [];
+        }
+        this.queryParam.sortProperty.push(property);
+        this.queryParam.sortAsc.push(asc);
+        return this;
+    }
+    withFilter(property, value, valueTo = undefined, matchType = MediusFilterMatchType.Contains, matchCaseSensitive = false) {
+        if (!this.queryParam.filterParams) {
+            this.queryParam.filterParams = [];
+        }
+        const filterParam = new MediusFilterParam();
+        filterParam.property = property;
+        filterParam.filterValue = value;
+        filterParam.filterValueTo = valueTo;
+        filterParam.filterMatchType = matchType;
+        filterParam.filterMatchCaseSensitive = matchCaseSensitive;
+        this.queryParam.filterParams.push(filterParam);
+        return this;
+    }
+    build() {
+        const queryParam = this.queryParam;
+        this.queryParam = new MediusQueryParam();
+        return queryParam;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-param.builder.js","sourceRoot":"","sources":["../../../../../v1/src/models/builders/query-param.builder.ts"],"names":[],"mappings":"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","sourcesContent":["import {MediusFilterMatchType} from '../filter-match-type.model';\nimport {MediusFilterParam} from '../filter-param.model';\nimport {MediusQueryMode} from '../query-mode.model';\nimport {MediusQueryParam} from '../query-param.model';\n\nexport class MediusQueryParamBuilder {\n    private constructor(private queryParam: MediusQueryParam) {}\n\n    /**\n     * Creates a new instance of `MediusQueryParamBuilder` with the specified `itemsPerPage` and `itemsOffset` values.\n     *\n     * @param {number} [itemsPerPage=50] - The number of items per page.\n     * @param {number} [itemsOffset=0] - The offset value for the items.\n     *\n     * @returns {MediusQueryParamBuilder} A new instance of `MediusQueryParamBuilder`.\n     *\n     * @deprecated\n     */\n    public static create(itemsPerPage = 50, itemsOffset = 0): MediusQueryParamBuilder {\n        const queryParam = new MediusQueryParam();\n        queryParam.itemsPerPage = itemsPerPage;\n        queryParam.itemsOffset = itemsOffset;\n        queryParam.queryMode = MediusQueryMode.All;\n        return new MediusQueryParamBuilder(queryParam);\n    }\n\n    /**\n     * Creates a new instance of MediusQueryParamBuilder based on an existing MediusQueryParam object.\n     *\n     * @param {MediusQueryParam} queryParam - The existing MediusQueryParam object to create from.\n     * @param {number} [itemsPerPage] - The number of items per page for the new instance. If not provided, default value is used.\n     * @param {number} [itemsOffset] - The offset for the new instance. If not provided, default value is used.\n     *\n     * @returns {MediusQueryParamBuilder} - A new instance of MediusQueryParamBuilder.\n     *\n     * @deprecated\n     */\n    public static createFromExisting(queryParam: MediusQueryParam, itemsPerPage?: number, itemsOffset?: number): MediusQueryParamBuilder {\n        queryParam.itemsPerPage = itemsPerPage ?? queryParam.itemsPerPage ?? 50;\n        queryParam.itemsOffset = itemsOffset ?? queryParam.itemsOffset ?? 0;\n        queryParam.queryMode = queryParam.queryMode ?? MediusQueryMode.All;\n        return new MediusQueryParamBuilder(queryParam);\n    }\n\n    public withItemsPerPage(itemsPerPage: number): MediusQueryParamBuilder {\n        this.queryParam.itemsPerPage = itemsPerPage;\n        return this;\n    }\n\n    public withItemsOffset(itemsOffset: number): MediusQueryParamBuilder {\n        this.queryParam.itemsOffset = itemsOffset;\n        return this;\n    }\n\n    public withQueryMode(queryMode: MediusQueryMode): MediusQueryParamBuilder {\n        this.queryParam.queryMode = queryMode;\n        return this;\n    }\n\n    public withSort(property: string, asc = true): MediusQueryParamBuilder {\n        if (!this.queryParam.sortProperty || !this.queryParam.sortAsc) {\n            this.queryParam.sortProperty = [];\n            this.queryParam.sortAsc = [];\n        }\n        this.queryParam.sortProperty.push(property);\n        this.queryParam.sortAsc.push(asc);\n        return this;\n    }\n\n    public withFilter(\n        property: string,\n        value: any,\n        valueTo: any = undefined,\n        matchType: MediusFilterMatchType = MediusFilterMatchType.Contains,\n        matchCaseSensitive = false\n    ): MediusQueryParamBuilder {\n        if (!this.queryParam.filterParams) {\n            this.queryParam.filterParams = [];\n        }\n        const filterParam = new MediusFilterParam();\n        filterParam.property = property;\n        filterParam.filterValue = value;\n        filterParam.filterValueTo = valueTo;\n        filterParam.filterMatchType = matchType;\n        filterParam.filterMatchCaseSensitive = matchCaseSensitive;\n        this.queryParam.filterParams.push(filterParam);\n        return this;\n    }\n\n    public build(): MediusQueryParam {\n        const queryParam = this.queryParam;\n        this.queryParam = new MediusQueryParam();\n        return queryParam;\n    }\n}\n"]}

package/esm2022/v1/models/filter-match-type.model.mjs

@@ -0,0 +1,27 @@
+/**
+ * Generated API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export var MediusFilterMatchType;
+(function (MediusFilterMatchType) {
+    MediusFilterMatchType["Equals"] = "EQUALS";
+    MediusFilterMatchType["NotEquals"] = "NOT_EQUALS";
+    MediusFilterMatchType["FromTo"] = "FROM_TO";
+    MediusFilterMatchType["Contains"] = "CONTAINS";
+    MediusFilterMatchType["StartsWith"] = "STARTS_WITH";
+    MediusFilterMatchType["EndsWith"] = "ENDS_WITH";
+    MediusFilterMatchType["In"] = "IN";
+    MediusFilterMatchType["NotIn"] = "NOT_IN";
+    MediusFilterMatchType["SmallerThan"] = "SMALLER_THAN";
+    MediusFilterMatchType["GreaterThan"] = "GREATER_THAN";
+    MediusFilterMatchType["Exists"] = "EXISTS";
+    MediusFilterMatchType["DoesNotExist"] = "DOES_NOT_EXIST";
+})(MediusFilterMatchType || (MediusFilterMatchType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLW1hdGNoLXR5cGUubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi92MS9zcmMvbW9kZWxzL2ZpbHRlci1tYXRjaC10eXBlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7O0dBVUc7QUFFSCxNQUFNLENBQU4sSUFBWSxxQkFhWDtBQWJELFdBQVkscUJBQXFCO0lBQzdCLDBDQUFpQixDQUFBO0lBQ2pCLGlEQUF3QixDQUFBO0lBQ3hCLDJDQUFrQixDQUFBO0lBQ2xCLDhDQUFxQixDQUFBO0lBQ3JCLG1EQUEwQixDQUFBO0lBQzFCLCtDQUFzQixDQUFBO0lBQ3RCLGtDQUFTLENBQUE7SUFDVCx5Q0FBZ0IsQ0FBQTtJQUNoQixxREFBNEIsQ0FBQTtJQUM1QixxREFBNEIsQ0FBQTtJQUM1QiwwQ0FBaUIsQ0FBQTtJQUNqQix3REFBK0IsQ0FBQTtBQUNuQyxDQUFDLEVBYlcscUJBQXFCLEtBQXJCLHFCQUFxQixRQWFoQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIEFQSVxuICogTm8gZGVzY3JpcHRpb24gcHJvdmlkZWQgKGdlbmVyYXRlZCBieSBPcGVuYXBpIEdlbmVyYXRvciBodHRwczovL2dpdGh1Yi5jb20vb3BlbmFwaXRvb2xzL29wZW5hcGktZ2VuZXJhdG9yKVxuICpcbiAqIFRoZSB2ZXJzaW9uIG9mIHRoZSBPcGVuQVBJIGRvY3VtZW50OiAxLjBcbiAqXG4gKlxuICogTk9URTogVGhpcyBjbGFzcyBpcyBhdXRvIGdlbmVyYXRlZCBieSBPcGVuQVBJIEdlbmVyYXRvciAoaHR0cHM6Ly9vcGVuYXBpLWdlbmVyYXRvci50ZWNoKS5cbiAqIGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaFxuICogRG8gbm90IGVkaXQgdGhlIGNsYXNzIG1hbnVhbGx5LlxuICovXG5cbmV4cG9ydCBlbnVtIE1lZGl1c0ZpbHRlck1hdGNoVHlwZSB7XG4gICAgRXF1YWxzID0gJ0VRVUFMUycsXG4gICAgTm90RXF1YWxzID0gJ05PVF9FUVVBTFMnLFxuICAgIEZyb21UbyA9ICdGUk9NX1RPJyxcbiAgICBDb250YWlucyA9ICdDT05UQUlOUycsXG4gICAgU3RhcnRzV2l0aCA9ICdTVEFSVFNfV0lUSCcsXG4gICAgRW5kc1dpdGggPSAnRU5EU19XSVRIJyxcbiAgICBJbiA9ICdJTicsXG4gICAgTm90SW4gPSAnTk9UX0lOJyxcbiAgICBTbWFsbGVyVGhhbiA9ICdTTUFMTEVSX1RIQU4nLFxuICAgIEdyZWF0ZXJUaGFuID0gJ0dSRUFURVJfVEhBTicsXG4gICAgRXhpc3RzID0gJ0VYSVNUUycsXG4gICAgRG9lc05vdEV4aXN0ID0gJ0RPRVNfTk9UX0VYSVNUJ1xufVxuIl19

package/esm2022/v1/models/filter-param.model.mjs

@@ -0,0 +1,33 @@
+export class MediusFilterParam {
+    static { this.attributeTypeMap = [
+        {
+            name: 'property',
+            baseName: 'property',
+            type: 'string'
+        },
+        {
+            name: 'filterValue',
+            baseName: 'filter_value',
+            type: 'object'
+        },
+        {
+            name: 'filterValueTo',
+            baseName: 'filter_value_to',
+            type: 'object'
+        },
+        {
+            name: 'filterMatchType',
+            baseName: 'filter_match_type',
+            type: 'FilterMatchType'
+        },
+        {
+            name: 'filterMatchCaseSensitive',
+            baseName: 'filter_match_case_sensitive',
+            type: 'boolean'
+        }
+    ]; }
+    static getAttributeTypeMap() {
+        return MediusFilterParam.attributeTypeMap;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/v1/models/query-mode.model.mjs

@@ -0,0 +1,18 @@
+/**
+ * Generated API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export var MediusQueryMode;
+(function (MediusQueryMode) {
+    MediusQueryMode["Count"] = "COUNT";
+    MediusQueryMode["Data"] = "DATA";
+    MediusQueryMode["All"] = "ALL";
+})(MediusQueryMode || (MediusQueryMode = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnktbW9kZS5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3YxL3NyYy9tb2RlbHMvcXVlcnktbW9kZS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7OztHQVVHO0FBRUgsTUFBTSxDQUFOLElBQVksZUFJWDtBQUpELFdBQVksZUFBZTtJQUN2QixrQ0FBZSxDQUFBO0lBQ2YsZ0NBQWEsQ0FBQTtJQUNiLDhCQUFXLENBQUE7QUFDZixDQUFDLEVBSlcsZUFBZSxLQUFmLGVBQWUsUUFJMUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBBUElcbiAqIE5vIGRlc2NyaXB0aW9uIHByb3ZpZGVkIChnZW5lcmF0ZWQgYnkgT3BlbmFwaSBHZW5lcmF0b3IgaHR0cHM6Ly9naXRodWIuY29tL29wZW5hcGl0b29scy9vcGVuYXBpLWdlbmVyYXRvcilcbiAqXG4gKiBUaGUgdmVyc2lvbiBvZiB0aGUgT3BlbkFQSSBkb2N1bWVudDogMS4wXG4gKlxuICpcbiAqIE5PVEU6IFRoaXMgY2xhc3MgaXMgYXV0byBnZW5lcmF0ZWQgYnkgT3BlbkFQSSBHZW5lcmF0b3IgKGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaCkuXG4gKiBodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2hcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuXG5leHBvcnQgZW51bSBNZWRpdXNRdWVyeU1vZGUge1xuICAgIENvdW50ID0gJ0NPVU5UJyxcbiAgICBEYXRhID0gJ0RBVEEnLFxuICAgIEFsbCA9ICdBTEwnXG59XG4iXX0=

package/esm2022/v1/models/query-param.model.mjs

@@ -0,0 +1,68 @@
+export class MediusQueryParam {
+    static { this.attributeTypeMap = [
+        {
+            name: 'sortProperty',
+            baseName: 'sort_property',
+            type: 'Array<string>'
+        },
+        {
+            name: 'sortAsc',
+            baseName: 'sort_asc',
+            type: 'Array<boolean>'
+        },
+        {
+            name: 'itemsOffset',
+            baseName: 'items_offset',
+            type: 'number'
+        },
+        {
+            name: 'itemsPerPage',
+            baseName: 'items_per_page',
+            type: 'number'
+        },
+        {
+            name: 'filterParams',
+            baseName: 'filter_params',
+            type: 'Array<FilterParam>'
+        },
+        {
+            name: 'filterAllParam',
+            baseName: 'filter_all_param',
+            type: 'string'
+        },
+        {
+            name: 'filterAllProperties',
+            baseName: 'filter_all_properties',
+            type: 'Array<string>'
+        },
+        {
+            name: 'validateProperties',
+            baseName: 'validate_properties',
+            type: 'Array<string>'
+        },
+        {
+            name: 'selectInTwoSteps',
+            baseName: 'select_in_two_steps',
+            type: 'boolean'
+        },
+        {
+            name: 'sortEnumByOrdinal',
+            baseName: 'sort_enum_by_ordinal',
+            type: 'boolean'
+        },
+        {
+            name: 'groupByProperties',
+            baseName: 'group_by_properties',
+            type: 'Array<string>'
+        },
+        {
+            name: 'queryMode',
+            baseName: 'query_mode',
+            type: 'QueryMode'
+        }
+    ]; }
+    static getAttributeTypeMap() {
+        return MediusQueryParam.attributeTypeMap;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/v1/models/query-result.model.mjs

@@ -0,0 +1,24 @@
+export class MediusQueryResult {
+    static fromArray(pageData, allDataCount) {
+        const mqr = new MediusQueryResult();
+        mqr.allDataCount = allDataCount ?? pageData.length;
+        mqr.pageData = pageData;
+        return mqr;
+    }
+    static { this.attributeTypeMap = [
+        {
+            name: 'allDataCount',
+            baseName: 'all_data_count',
+            type: 'number'
+        },
+        {
+            name: 'pageData',
+            baseName: 'page_data',
+            type: 'Array<T>'
+        }
+    ]; }
+    static getAttributeTypeMap() {
+        return MediusQueryResult.attributeTypeMap;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/v1/provide.mjs

@@ -0,0 +1,40 @@
+import { APP_INITIALIZER } from '@angular/core';
+import { of } from 'rxjs';
+import { ObjectSerializer } from '@mediusinc/mng-commons-data-api-class';
+import { CommonsFeatureTypeEnum, TypeRegistry } from '@mediusinc/mng-commons/core';
+import { MediusFilterMatchType } from './models/filter-match-type.model';
+import { MediusFilterParam } from './models/filter-param.model';
+import { MediusQueryMode } from './models/query-mode.model';
+import { MediusQueryParam } from './models/query-param.model';
+function initializeDataApiObsolete(config) {
+    return () => {
+        const typeRegistry = TypeRegistry.get();
+        typeRegistry.registerType(MediusFilterParam, 'FilterParam');
+        typeRegistry.registerType(MediusQueryParam, 'QueryParam');
+        typeRegistry.registerEnum(MediusFilterMatchType, 'FilterMatchType');
+        typeRegistry.registerEnum(MediusQueryMode, 'QueryMode');
+        ObjectSerializer.get().configure({ ...(config?.serialization ?? {}) });
+        return of(void 0);
+    };
+}
+/**
+ * Prepares providers for usage of the Obsolete Data API functionalities.
+ *
+ * @returns {CommonsFeature} The `CommonsFeature` object with the Data API Obsolete configuration.
+ *
+ * @deprecated.
+ */
+export function withDataApiV1() {
+    return {
+        type: CommonsFeatureTypeEnum.DataApiAsClassV1,
+        providers: [
+            {
+                provide: APP_INITIALIZER,
+                useFactory: initializeDataApiObsolete,
+                deps: [],
+                multi: true
+            }
+        ]
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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