@netgrif/components-core 6.0.1

package/esm5/lib/utility/tests/mocks/mock-endpoint.js

@@ -0,0 +1,46 @@
+import { of } from 'rxjs';
+/**
+ * A utility class that mock any pageable endpoint that takes one parameter
+ */
+var MockEndpoint = /** @class */ (function () {
+    function MockEndpoint() {
+        /**
+         * The content that is queries by the requests.
+         */
+        this.content = [];
+    }
+    /**
+     * @param filter - a filtering argument. This mock ignores it.
+     * @param params - pagination configuration. The mock extracts the `size` and `page` property to format the result properly.
+     * @returns an `Observable` containing a properly formatted {@link Page} object.
+     *
+     * The `pagination` attributes are filled according to the request and the endpoints [content]{@link MockEndpoint#content}.
+     *
+     * If an empty {@link Page} should be returned the returned object has its `content` attribute set to some object
+     * (to match backend and resource service behavior).
+     * Otherwise the `content` attribute contains the corresponding subsection fo the [content]{@link MockEndpoint#content} array.
+     */
+    MockEndpoint.prototype.search = function (filter, params) {
+        var rp = this.getPagination(params);
+        var result = this.content.slice(rp.pageSize * rp.pageNumber, rp.pageSize * (rp.pageNumber + 1));
+        var resultPage = {
+            pagination: {
+                size: result.length,
+                totalElements: this.content.length,
+                totalPages: Math.ceil(this.content.length / rp.pageSize),
+                number: rp.pageNumber
+            }
+        };
+        Object.assign(resultPage, { content: result.length !== 0 ? result : {} });
+        return of(resultPage);
+    };
+    MockEndpoint.prototype.getPagination = function (params) {
+        return {
+            pageSize: parseInt(params.get('size'), 10),
+            pageNumber: parseInt(params.get('page'), 10)
+        };
+    };
+    return MockEndpoint;
+}());
+export { MockEndpoint };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/utility/tests/mocks/mock-sign-up.service.js

@@ -0,0 +1,31 @@
+import { of } from 'rxjs';
+/**
+ * Mock the {@link SignUpService}. By default all responses are successful. Responses can be customised.
+ */
+var MockSignUpService = /** @class */ (function () {
+    function MockSignUpService() {
+        this.signupResponse = of({ success: 'success' });
+        this.inviteResponse = of({ success: 'success' });
+        this.resetPasswordResponse = of({ success: 'success' });
+        this.recoverPasswordResponse = of({ success: 'success' });
+        this.verifyResponse = of({ success: 'success' });
+    }
+    MockSignUpService.prototype.signup = function (newUser) {
+        return this.signupResponse;
+    };
+    MockSignUpService.prototype.invite = function (invitation) {
+        return this.inviteResponse;
+    };
+    MockSignUpService.prototype.resetPassword = function (email) {
+        return this.resetPasswordResponse;
+    };
+    MockSignUpService.prototype.recoverPassword = function (token, password) {
+        return this.recoverPasswordResponse;
+    };
+    MockSignUpService.prototype.verify = function (token) {
+        return this.verifyResponse;
+    };
+    return MockSignUpService;
+}());
+export { MockSignUpService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/utility/tests/mocks/mock-user-autocomplete-value.js

@@ -0,0 +1,15 @@
+import { UserAutocomplete } from '../../../search/models/category/user-autocomplete';
+/**
+ * @param userName name of the mock user value
+ * @param userId id of the mock user value
+ * @param normalUser if not the user is the special ME user option
+ */
+export function mockUserAutocompleteValue(userName, normalUser, userId) {
+    if (normalUser === void 0) { normalUser = true; }
+    return {
+        text: userName,
+        value: [normalUser ? userId : UserAutocomplete.USER_ME_TEMPLATE],
+        icon: normalUser ? UserAutocomplete.USER_ICON : UserAutocomplete.USER_ME_ICON
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9jay11c2VyLWF1dG9jb21wbGV0ZS12YWx1ZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi91dGlsaXR5L3Rlc3RzL21vY2tzL21vY2stdXNlci1hdXRvY29tcGxldGUtdmFsdWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFDLGdCQUFnQixFQUFDLE1BQU0sbURBQW1ELENBQUM7QUFFbkY7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSx5QkFBeUIsQ0FBQyxRQUFnQixFQUFFLFVBQWlCLEVBQUUsTUFBZTtJQUFsQywyQkFBQSxFQUFBLGlCQUFpQjtJQUV6RSxPQUFPO1FBQ0gsSUFBSSxFQUFFLFFBQVE7UUFDZCxLQUFLLEVBQUUsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsZ0JBQWdCLENBQUMsZ0JBQWdCLENBQUM7UUFDaEUsSUFBSSxFQUFFLFVBQVUsQ0FBQyxDQUFDLENBQUMsZ0JBQWdCLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxnQkFBZ0IsQ0FBQyxZQUFZO0tBQ2hGLENBQUM7QUFDTixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtTZWFyY2hBdXRvY29tcGxldGVPcHRpb259IGZyb20gJy4uLy4uLy4uL3NlYXJjaC9tb2RlbHMvY2F0ZWdvcnkvc2VhcmNoLWF1dG9jb21wbGV0ZS1vcHRpb24nO1xuaW1wb3J0IHtVc2VyQXV0b2NvbXBsZXRlfSBmcm9tICcuLi8uLi8uLi9zZWFyY2gvbW9kZWxzL2NhdGVnb3J5L3VzZXItYXV0b2NvbXBsZXRlJztcblxuLyoqXG4gKiBAcGFyYW0gdXNlck5hbWUgbmFtZSBvZiB0aGUgbW9jayB1c2VyIHZhbHVlXG4gKiBAcGFyYW0gdXNlcklkIGlkIG9mIHRoZSBtb2NrIHVzZXIgdmFsdWVcbiAqIEBwYXJhbSBub3JtYWxVc2VyIGlmIG5vdCB0aGUgdXNlciBpcyB0aGUgc3BlY2lhbCBNRSB1c2VyIG9wdGlvblxuICovXG5leHBvcnQgZnVuY3Rpb24gbW9ja1VzZXJBdXRvY29tcGxldGVWYWx1ZSh1c2VyTmFtZTogc3RyaW5nLCBub3JtYWxVc2VyID0gdHJ1ZSwgdXNlcklkPzogc3RyaW5nKVxuICAgIDogU2VhcmNoQXV0b2NvbXBsZXRlT3B0aW9uPEFycmF5PHN0cmluZz4+IHtcbiAgICByZXR1cm4ge1xuICAgICAgICB0ZXh0OiB1c2VyTmFtZSxcbiAgICAgICAgdmFsdWU6IFtub3JtYWxVc2VyID8gdXNlcklkIDogVXNlckF1dG9jb21wbGV0ZS5VU0VSX01FX1RFTVBMQVRFXSxcbiAgICAgICAgaWNvbjogbm9ybWFsVXNlciA/IFVzZXJBdXRvY29tcGxldGUuVVNFUl9JQ09OIDogVXNlckF1dG9jb21wbGV0ZS5VU0VSX01FX0lDT05cbiAgICB9O1xufVxuIl19

package/esm5/lib/utility/tests/mocks/mock-user-preference.service.js

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import * as i0 from "@angular/core";
+var MockUserPreferenceService = /** @class */ (function () {
+    function MockUserPreferenceService() {
+    }
+    MockUserPreferenceService.prototype.setTaskFilters = function (viewId, value) {
+    };
+    MockUserPreferenceService.prototype.getTaskFilters = function (viewId) {
+        return [];
+    };
+    MockUserPreferenceService.prototype.setCaseFilters = function (viewId, value) {
+    };
+    MockUserPreferenceService.prototype.getCaseFilters = function (viewId) {
+        return [];
+    };
+    MockUserPreferenceService.prototype.setHeaders = function (viewId, value) {
+    };
+    MockUserPreferenceService.prototype.getHeaders = function (viewId) {
+        return undefined;
+    };
+    MockUserPreferenceService.prototype.setLocale = function (locale) {
+    };
+    MockUserPreferenceService.prototype.getLocale = function () {
+        return undefined;
+    };
+    Object.defineProperty(MockUserPreferenceService.prototype, "drawerWidth", {
+        get: function () {
+            return undefined;
+        },
+        set: function (drawerWidth) {
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MockUserPreferenceService.prototype, "preferencesChanged$", {
+        get: function () {
+            return of();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MockUserPreferenceService.ɵprov = i0.ɵɵdefineInjectable({ factory: function MockUserPreferenceService_Factory() { return new MockUserPreferenceService(); }, token: MockUserPreferenceService, providedIn: "root" });
+    MockUserPreferenceService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    MockUserPreferenceService.ctorParameters = function () { return []; };
+    return MockUserPreferenceService;
+}());
+export { MockUserPreferenceService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/utility/tests/mocks/mock-user-resource.service.js

@@ -0,0 +1,52 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+var MockUserResourceService = /** @class */ (function () {
+    function MockUserResourceService() {
+    }
+    MockUserResourceService.prototype.getPreferences = function () {
+        return of({
+            headers: {},
+            caseFilters: {},
+            taskFilters: {},
+            other: {}
+        });
+    };
+    MockUserResourceService.prototype.setPreferences = function () {
+        return of({ success: '' });
+    };
+    MockUserResourceService.prototype.getLoggedUser = function () {
+        return of({ email: 'mail', id: 'id', name: 'name', surname: 'surname', fullName: 'name surname',
+            groups: [], authorities: [], nextGroups: [], processRoles: [] });
+    };
+    // methods not yet mocked by this mock
+    MockUserResourceService.prototype.assignAuthority = function () {
+        throw new Error('Method not yet mocked - assignAuthority');
+    };
+    MockUserResourceService.prototype.assignRoles = function () {
+        throw new Error('Method not yet mocked - assignRoles');
+    };
+    MockUserResourceService.prototype.getAllAuthorities = function () {
+        throw new Error('Method not yet mocked - getAllAuthorities');
+    };
+    MockUserResourceService.prototype.getAll = function () {
+        throw new Error('Method not yet mocked - getAll');
+    };
+    MockUserResourceService.prototype.getAllWithRole = function () {
+        throw new Error('Method not yet mocked - getAllWithRole');
+    };
+    MockUserResourceService.prototype.getUser = function () {
+        throw new Error('Method not yet mocked - getUser');
+    };
+    MockUserResourceService.prototype.search = function () {
+        throw new Error('Method not yet mocked - search');
+    };
+    MockUserResourceService.prototype.updateUser = function () {
+        throw new Error('Method not yet mocked - updateUser');
+    };
+    MockUserResourceService.decorators = [
+        { type: Injectable }
+    ];
+    return MockUserResourceService;
+}());
+export { MockUserResourceService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/utility/tests/search-category-mock-dependencies.js

@@ -0,0 +1,21 @@
+import { OperatorService } from '../../search/operator-service/operator.service';
+import { of } from 'rxjs';
+import { CategoryFactory } from '../../search/category-factory/category-factory';
+import { SearchIndexResolverService } from '../../search/search-keyword-resolver-service/search-index-resolver.service';
+import { CategoryResolverService } from '../../search/category-factory/category-resolver.service';
+import { OperatorResolverService } from '../../search/operator-service/operator-resolver.service';
+var opResolver = new OperatorResolverService();
+var opService = new OperatorService(opResolver);
+export var createMockDependencies = function (allowedNets$, operatorService, userResourceService) {
+    if (allowedNets$ === void 0) { allowedNets$ = of([]); }
+    if (userResourceService === void 0) { userResourceService = { getAll: function () { return of({ content: [], pagination: {} }); } }; }
+    var searchIndexResolver = new SearchIndexResolverService();
+    var allowedNetsService = { allowedNets$: allowedNets$ };
+    return {
+        categoryFactory: new CategoryFactory(operatorService !== null && operatorService !== void 0 ? operatorService : opService, null, searchIndexResolver, new CategoryResolverService(), allowedNetsService, userResourceService),
+        searchIndexResolver: searchIndexResolver,
+        userResourceService: userResourceService,
+        allowedNetsService: allowedNetsService
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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