herum-shared 0.1.25

package/fesm2022/herum-shared-services.mjs

@@ -0,0 +1,1107 @@
+import * as i1 from '@angular/common/http';
+import { HttpHeaders } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject, Subject, forkJoin } from 'rxjs';
+import { shareReplay, map, switchMap, tap } from 'rxjs/operators';
+import { StorageService } from 'herum-shared/static-services';
+import { selfIsTeacherExample, closedListExample, permissionsTemplatesExample } from 'herum-shared/objectsExample';
+import { HERUM_SHARED_CONFIG_TOKEN } from 'herum-shared/environment';
+import { toHash, buildPath, setHeaders, remainJustWantedValueInDictionary, getUrlFromFileData, getVersionPathParameter } from 'herum-shared/utils';
+import * as i2 from '@angular/router';
+import { regexExpressions, generalKeys, uploadsManagerKeys, skipToastHeader, assignmentMetadata, attributes, defaultGrade, defaultAuthorizationObject, resourceIdPlaceholder, resourcesFilesSuffixes, system } from 'herum-shared/constants';
+import * as i1$1 from 'herum-shared/herum-types';
+import { MicroResourceAuthorizationType } from 'herum-shared/herum-types';
+import { cloneDeep } from 'lodash';
+import { DOCUMENT } from '@angular/common';
+import { SYSTEM_TRACK_TEXT_CHANGES_SERVICE } from 'herum-shared/tokens';
+
+const NestedConditionSigniture = "filters";
+const defaultPagingDataFormat = "pageInfo { hasNextPage, hasPreviousPage, startCursor, endCursor }";
+const offsetPagingDataFormat = "pageInfo { hasNextPage, hasPreviousPage }";
+const DefaultQueryName = "DefaultQueryName";
+class GraphQLService {
+    httpClient;
+    environmentConfig;
+    constructor(httpClient, environmentConfig) {
+        this.httpClient = httpClient;
+        this.environmentConfig = environmentConfig;
+    }
+    executeQuery(gqlQuery, isListQuery = true, isOffsetPagination = false) {
+        let variablesObjectForBody;
+        let variablesStringForQuerySignature;
+        if (gqlQuery.variables) {
+            variablesObjectForBody = this.generateVariablesObjectForBody(gqlQuery.variables);
+            variablesStringForQuerySignature = this.generateVariablesStringForQuerySigniture(gqlQuery.variables, gqlQuery.queryName);
+        }
+        const query = this.generateQuery(gqlQuery.resolverName, gqlQuery.formatExample, gqlQuery.filters, gqlQuery.paging?.first, gqlQuery.paging?.after, gqlQuery.offsetPaging, gqlQuery.variables?.length > 0 ? variablesStringForQuerySignature : '', gqlQuery.order, gqlQuery.conditionPaths, gqlQuery.orderPaths, gqlQuery.offsetPagingPaths, isListQuery, isOffsetPagination).replace(regexExpressions.curlyBraces, '');
+        return this.httpClient.post(this.environmentConfig?.graphQLConfiguration?.serverBasePath, { query: query, variables: variablesObjectForBody }, { headers: gqlQuery.headers })
+            .pipe(shareReplay(1), map(res => {
+            return res.data ? res.data[gqlQuery.resolverName] : null;
+        }));
+    }
+    getFreeTextCondition(freeText, orConditionKeys) {
+        let filters = {
+            and: []
+        };
+        freeText.split(" ").forEach(substring => {
+            let orIteration = [];
+            orConditionKeys.forEach(orConditionKey => {
+                orIteration.push({
+                    [orConditionKey]: { contains: substring }
+                });
+            });
+            filters.and.push({ or: orIteration });
+        });
+        return filters;
+    }
+    generateFilterStringDynamically(ids, key, type) {
+        let filters = [];
+        let variables = [];
+        ids.forEach((id, index) => {
+            let newFilter = {};
+            newFilter[key] = {
+                eq: '$' + key + index
+            };
+            filters.push(newFilter);
+            variables.push({
+                name: key + index,
+                value: id,
+                type
+            });
+        });
+        return { filters, variables };
+    }
+    convertToResolverNameFormat(mongoCollectionName) {
+        return mongoCollectionName.charAt(0).toLowerCase() + mongoCollectionName.slice(1);
+    }
+    generateQuery(resolverName, formatExample, condition, first, after, offsetPaging, variablesStringForQuerySigniture, order, conditionPaths, orderPaths, offsetPagingPaths, isListQuery, isOffsetPagination) {
+        const conditionString = this.generateConditionString(condition);
+        const returnFormat = this.getKeysString(formatExample, conditionPaths, orderPaths, offsetPagingPaths);
+        let orderString = order ? `order:${this.generateOrderString(order)},` : '';
+        let pagingString = '';
+        if (isListQuery) {
+            pagingString = isOffsetPagination
+                ? (offsetPaging?.skip > -1 || offsetPaging?.take > -1 ? this.generateOffsetPagingString(offsetPaging) : '')
+                : (first || after ? this.generatePagingString(first, after) : '');
+        }
+        if (after)
+            pagingString += ',';
+        const resolverParameters = (orderString + pagingString + conditionString) == '' ? '' : '(' + orderString + pagingString + conditionString + ')';
+        if (pagingString != '')
+            pagingString += ',';
+        const elementsName = isOffsetPagination ? 'items' : 'nodes';
+        const query = `query ${variablesStringForQuerySigniture ? variablesStringForQuerySigniture : ''} { 
+      ${resolverName + resolverParameters} { ${isListQuery ? (isOffsetPagination ? offsetPagingDataFormat : defaultPagingDataFormat) + `,totalCount , ${elementsName} {` : ''} ${returnFormat} } ${isListQuery ? '}' : ''} }`;
+        return query;
+    }
+    generateConditionString(condition, isRecursiveCall = false) {
+        let conditionString = "";
+        if (!condition || (!condition.and || condition.and?.length == 0) && (!condition.or || condition.or?.length == 0))
+            return conditionString;
+        if (condition) {
+            conditionString = isRecursiveCall ? "" : "where: {";
+            if (condition?.and) {
+                let andString = "";
+                condition.and.forEach(filter => {
+                    (Object.keys(filter)[0] == 'or' || Object.keys(filter)[0] == 'and') ?
+                        andString += `{${this.generateConditionString(filter, true)}},` :
+                        andString += `{${this.getKeysString(filter, null, null, null, null, true)}},`;
+                });
+                andString = andString.slice(0, -1);
+                conditionString += `and: [${andString}]`;
+                conditionString += condition.or ? ',' : '';
+            }
+            if (condition?.or) {
+                let orString = "";
+                condition.or.forEach(filter => orString += `{${this.getKeysString(filter, null, null, null, null, true)}},`);
+                condition.or.forEach(filter => {
+                    (Object.keys(filter)[0] == 'or' || Object.keys(filter)[0] == 'and') ?
+                        orString += `{${this.generateConditionString(filter, true)}},` :
+                        orString += `{${this.getKeysString(filter, null, null, null, null, true)}},`;
+                });
+                orString = orString.slice(0, -1);
+                conditionString += `or: [${orString} ]`;
+            }
+            conditionString += isRecursiveCall ? "" : "}";
+        }
+        return conditionString;
+    }
+    generatePagingString(first, after) {
+        let result = '';
+        result += first ? `first:${first},` : '';
+        result += after ? ` after:"${after}"` : '';
+        return result;
+    }
+    generateOffsetPagingString(offsetPaging) {
+        const { skip, take } = offsetPaging;
+        let result = '';
+        result += skip > -1 ? `skip:${skip},` : '';
+        result += take > -1 ? ` take:${take}, ` : '';
+        return result;
+    }
+    getKeysString(obj, conditionPaths, orderPaths, offsetPagingPaths, parentKey = null, isConditionString = false) {
+        let result = '';
+        for (const key in obj) {
+            result += `${key}`;
+            if (((conditionPaths && conditionPaths[key]) || (orderPaths && orderPaths[key])) && !isConditionString) {
+                result += '(';
+                if (conditionPaths && conditionPaths[key])
+                    result += this.generateConditionString(conditionPaths[key]);
+                if (orderPaths && orderPaths[key])
+                    result += this.getKeysString(orderPaths[key], null, null, null, null, true);
+                if (offsetPagingPaths && offsetPagingPaths[key])
+                    result += (offsetPagingPaths[key].skip > -1 || offsetPagingPaths[key].take > -1) ? `,${this.generateOffsetPagingString(offsetPagingPaths[key])}` : '';
+                result += `)`;
+            }
+            if (offsetPagingPaths && offsetPagingPaths[key])
+                result += '{items';
+            if (obj[key]?.length > 0 && !isConditionString && obj[key] !== null && typeof obj[key] !== 'string') {
+                result += isConditionString ? `: { ${this.getKeysString(obj[key], conditionPaths, orderPaths, offsetPagingPaths, key, isConditionString)} }` :
+                    ` { ${this.getKeysString(obj[key][0], conditionPaths, orderPaths, key, isConditionString)} }`;
+            }
+            else if (typeof obj[key] === 'object' && obj[key] !== null && typeof obj[key] !== 'string')
+                result += isConditionString ? `: { ${this.getKeysString(obj[key], conditionPaths, orderPaths, offsetPagingPaths, key, isConditionString)} }` :
+                    ` { ${this.getKeysString(obj[key], conditionPaths, orderPaths, offsetPagingPaths, parentKey + '.' + key, isConditionString)} }`;
+            else if (typeof obj[key] === 'string' && obj[key] !== null && isConditionString)
+                result += (obj[key][0] == '$' || obj[key].includes('ASC') || obj[key].includes('DESC')) ? `: ${obj[key]}` : `: "${obj[key]}"`;
+            else if (typeof obj[key] === 'number' && obj[key] !== null && isConditionString)
+                result += `: ${JSON.stringify(obj[key])}`;
+            else if (typeof obj[key] === 'boolean' && obj[key] !== null && isConditionString)
+                result += `: ${obj[key]}`;
+            if (offsetPagingPaths && offsetPagingPaths[key])
+                result += '}';
+            result += ', ';
+        }
+        return result.slice(0, -2);
+    }
+    generateVariablesObjectForBody(variables) {
+        return variables.reduce((acc, obj) => {
+            acc[obj.name] = obj.value;
+            return acc;
+        }, {});
+    }
+    generateVariablesStringForQuerySigniture(variables, queryName) {
+        if (!queryName)
+            queryName = DefaultQueryName;
+        let result = (queryName ? queryName : DefaultQueryName) + '(';
+        variables.forEach(variable => {
+            result += "$" + variable.name + ":" + variable.type + ",";
+        });
+        result = result.slice(0, -1) + ")";
+        return result;
+    }
+    generateOrderString(order) {
+        let orderString = '{';
+        Object.keys(order).forEach((key, index, keys) => {
+            orderString += typeof order[key] === 'object' ?
+                `${key}:${this.generateOrderString(order[key])}` :
+                `${key}:${order[key]}`;
+            if (index < keys.length - 1)
+                orderString += ',';
+        });
+        return orderString + '}';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: GraphQLService, deps: [{ token: i1.HttpClient }, { token: HERUM_SHARED_CONFIG_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: GraphQLService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: GraphQLService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [HERUM_SHARED_CONFIG_TOKEN]
+                }] }] });
+
+const AuthStorageKey = 'AUTH_SESSION_ID';
+const headers = new HttpHeaders({ 'Content-Type': 'application/json' });
+class AuthService {
+    http;
+    router;
+    gql;
+    environmentConfig;
+    sessionId$ = new BehaviorSubject('');
+    isTeacher$ = new Subject();
+    constructor(http, router, gql, environmentConfig) {
+        this.http = http;
+        this.router = router;
+        this.gql = gql;
+        this.environmentConfig = environmentConfig;
+        let sessionId = StorageService.getItem(AuthStorageKey);
+        if (!sessionId)
+            return;
+        this.sessionId$.next(sessionId);
+    }
+    tryLogin(signInFormData) {
+        const personalId = signInFormData.personalId;
+        let loginFormat = {
+            identifier: personalId,
+            hash: toHash(this.generateStringForAuthenticationHash(personalId, signInFormData.militaryId))
+        };
+        return this.http.post(this.environmentConfig?.environment?.siteServerPath + this.environmentConfig?.authenticationPaths?.tryLogin, loginFormat)
+            .pipe(map((authenticationResponse) => this.handleNewSessionId(authenticationResponse)));
+    }
+    getUserIdentificationQuestions(personalId) {
+        return this.http.get(this.environmentConfig?.environment?.siteServerPath + `/Authentication/SecurityQuestions/${personalId}`);
+    }
+    signUp(signUpData) {
+        return this.http.post(this.environmentConfig?.environment?.siteServerPath + this.environmentConfig?.authenticationPaths?.signUp, signUpData)
+            .pipe(map((authenticationResponse) => this.handleNewSessionId(authenticationResponse)));
+    }
+    logout() {
+        this.clearSession();
+        this.router.navigate(['/login']);
+    }
+    clearSession() {
+        StorageService.deleteAll();
+        this.sessionId$.next('');
+    }
+    isValidSessionId(sessionId) {
+        let jSessionId = JSON.stringify(sessionId ?? '');
+        return this.http.post(this.environmentConfig?.environment?.siteServerPath + this.environmentConfig?.authenticationPaths?.isValidSessionId, jSessionId, { headers: headers });
+    }
+    isTeacher() {
+        let userQuery = {
+            resolverName: 'self',
+            formatExample: selfIsTeacherExample,
+            conditionPaths: { collegeStudyingLessons: { and: [{ lesson: { isDeleted: { eq: false } } }] } }
+        };
+        return this.gql.executeQuery(userQuery, false).pipe(map(user => {
+            const isTeacher = !(!user.collegeTeacherAssignments || user.collegeTeacherAssignments.length == 0) ||
+                !(!user.collegeTeachingLessons || user.collegeTeachingLessons.length == 0) ||
+                !(!user.collegeCheckingLessons || user.collegeCheckingLessons.length == 0) || user.isAdmin == true;
+            this.isTeacher$.next(isTeacher);
+            return isTeacher;
+        }));
+    }
+    setIdentificationQuestions(password, questions) {
+        return this.http.post(this.environmentConfig?.environment?.siteServerPath + '/Authentication/UpdateLoginData', {
+            password,
+            securityQuestions: questions.map(question => ({ ...question, answer: toHash(question.answer) }))
+        });
+    }
+    resetPassword(securityQuestions, personalId, newPassword) {
+        return this.http.post(this.environmentConfig?.environment?.siteServerPath + '/Authentication/ResetPassword', {
+            personalId: personalId,
+            answers: securityQuestions.map(question => ({ questionId: question._id, answer: toHash(question.answer) })),
+            newPassword: newPassword
+        });
+    }
+    securityCheck(securityQuestions, personalId) {
+        return this.http.post(this.environmentConfig?.environment?.siteServerPath + '/Authentication/SecurityCheck', {
+            personalId: personalId,
+            answers: securityQuestions.map(question => ({ questionId: question._id, answer: toHash(question.answer) }))
+        });
+    }
+    handleNewSessionId(authenticationResponse) {
+        if (authenticationResponse.sessionId?.length > 0)
+            this.updateSessionId(authenticationResponse.sessionId);
+        return authenticationResponse;
+    }
+    updateSessionId(newValue) {
+        this.sessionId$.next(newValue);
+        StorageService.setItem(AuthStorageKey, newValue);
+    }
+    generateStringForAuthenticationHash(personalId, militaryId) {
+        return personalId + militaryId;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: AuthService, deps: [{ token: i1.HttpClient }, { token: i2.Router }, { token: GraphQLService }, { token: HERUM_SHARED_CONFIG_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: AuthService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.Router }, { type: GraphQLService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [HERUM_SHARED_CONFIG_TOKEN]
+                }] }] });
+
+class CommonGraphqlRequestsService {
+    gql;
+    environmentConfig;
+    constructor(gql, environmentConfig) {
+        this.gql = gql;
+        this.environmentConfig = environmentConfig;
+    }
+    getGroupsByIds(ids, formatExample) {
+        let filterQuery = this.gql.generateFilterStringDynamically(ids, 'id', 'String');
+        let query = {
+            resolverName: this.gql.convertToResolverNameFormat(this.environmentConfig?.mongoUpdates?.Collections?.Groups),
+            formatExample: formatExample,
+            filters: {
+                or: filterQuery.filters
+            },
+            variables: filterQuery.variables
+        };
+        return this.gql.executeQuery(query).pipe(map(gqlGroups => gqlGroups?.nodes));
+    }
+    getClosedLists(names) {
+        let query = {
+            resolverName: this.gql.convertToResolverNameFormat(this.environmentConfig?.mongoUpdates?.Collections?.ClosedLists),
+            formatExample: closedListExample,
+            filters: { and: [{ isDeleted: { eq: false } }] },
+            variables: []
+        };
+        names?.forEach((name, i) => {
+            if (query.filters.or)
+                query.filters.or.push({
+                    name: {
+                        eq: '$name' + i
+                    },
+                });
+            else
+                query.filters.or = [{
+                        name: {
+                            eq: '$name' + i
+                        },
+                    }];
+            query.variables.push({
+                name: 'name' + i,
+                value: name,
+                type: 'String'
+            });
+        });
+        return this.gql.executeQuery(query).pipe(map(gqlResult => gqlResult.nodes));
+    }
+    getUsersByIds(usersIds, formatExample) {
+        let filterQuery = this.gql.generateFilterStringDynamically(usersIds, generalKeys.id, 'String');
+        let query = {
+            resolverName: this.gql.convertToResolverNameFormat(this.environmentConfig?.mongoUpdates?.Collections?.Users),
+            formatExample,
+            filters: {
+                or: filterQuery.filters
+            },
+            variables: filterQuery.variables
+        };
+        return this.gql.executeQuery(query).pipe(map(gqlResponse => gqlResponse?.nodes));
+    }
+    getPermissionsTemplates() {
+        let query = {
+            resolverName: 'permissionsTemplates',
+            formatExample: permissionsTemplatesExample,
+        };
+        return this.gql.executeQuery(query).pipe(map(gqlResponse => gqlResponse.nodes));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: CommonGraphqlRequestsService, deps: [{ token: GraphQLService }, { token: HERUM_SHARED_CONFIG_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: CommonGraphqlRequestsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: CommonGraphqlRequestsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: GraphQLService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [HERUM_SHARED_CONFIG_TOKEN]
+                }] }] });
+
+const innerUniqListItemKey = '_id';
+const emptyValueFlagForCreationUniqListItem = 'null';
+class DbActionsInnerIdManagerService {
+    determineIfInnerIdIsNeeded(value) {
+        if (!Array.isArray(value))
+            return;
+        if (value[0][innerUniqListItemKey])
+            value[0].id = value[0][innerUniqListItemKey] == emptyValueFlagForCreationUniqListItem ? null : value[0][innerUniqListItemKey];
+    }
+    deleteInnerIdFieldIfExist(itemToAttach, itemValue) {
+        if (itemValue.hasOwnProperty(innerUniqListItemKey)) {
+            itemToAttach[Object.keys(itemToAttach)[0]][generalKeys.id] =
+                itemToAttach[Object.keys(itemToAttach)[0]][innerUniqListItemKey] == emptyValueFlagForCreationUniqListItem ?
+                    null :
+                    itemToAttach[Object.keys(itemToAttach)[0]][innerUniqListItemKey];
+            delete itemToAttach[Object.keys(itemToAttach)[0]][innerUniqListItemKey];
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DbActionsInnerIdManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DbActionsInnerIdManagerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DbActionsInnerIdManagerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+const ATTACH = "Attach";
+class DbActionRequestsService {
+    http;
+    dbActionsInnerIdManagerService;
+    environmentConfig;
+    constructor(http, dbActionsInnerIdManagerService, environmentConfig) {
+        this.http = http;
+        this.dbActionsInnerIdManagerService = dbActionsInnerIdManagerService;
+        this.environmentConfig = environmentConfig;
+    }
+    getFileRequest(request, file) {
+        const formData = new FormData();
+        formData.append(generalKeys.newFileRequest, JSON.stringify(request));
+        formData.append(generalKeys.file, file);
+        return formData;
+    }
+    addOrUpdateAndAttachBulkWithFile(mongoCollectionName, fields, file, ids, uploadsManagerTitle, skipToast) {
+        let headers = this.setAddOrUpdateAndAttachBulkWithFileHeaders([uploadsManagerTitle, skipToast]);
+        return this.getMongoCollectionModelInfo(mongoCollectionName).pipe(switchMap((modelInfo) => {
+            if (fields.files)
+                delete fields.files;
+            const splittedFields = this.splitFieldByType(fields, modelInfo);
+            const request = {
+                DbBasicActionRequest: {
+                    data: splittedFields.keysToUpdate,
+                    ids
+                },
+                DbAttachmentActionRequests: this.getFormattedAttachments(ids, splittedFields.keysToAttach, splittedFields.keysToAttachInDifferentModel, modelInfo)
+            };
+            return this.http.put(buildPath([
+                this.environmentConfig?.environment?.siteServerPath,
+                mongoCollectionName,
+                this.environmentConfig?.mongoUpdates?.Methods?.AddOrUpdate,
+                this.environmentConfig?.mongoUpdates?.Submethods?.AndAttach,
+                this.environmentConfig?.mongoUpdates?.Options?.Bulk,
+                this.environmentConfig?.mongoUpdates?.Options?.SetFile
+            ]), this.getFileRequest(request, file), { responseType: 'text', reportProgress: !!file, headers });
+        }));
+    }
+    setAddOrUpdateAndAttachBulkWithFileHeaders(headerToSet) {
+        let headers = null;
+        const [uploadsManagerTitle, skipToast] = headerToSet;
+        if (uploadsManagerTitle)
+            headers = setHeaders(new HttpHeaders(), [{ key: uploadsManagerKeys.uploadsManagerTitleHeader, value: uploadsManagerTitle }], true);
+        if (skipToast)
+            headers = skipToastHeader;
+        return headers;
+    }
+    AndAttachBulk(mongoCollectionName, fields, ids, method, attachmentsToUpdate) {
+        if (ids.every(id => !id))
+            ids = undefined;
+        return this.getMongoCollectionModelInfo(mongoCollectionName).pipe(switchMap((modelInfo) => {
+            const splittedFields = this.splitFieldByType(fields, modelInfo);
+            const request = {
+                DbBasicActionRequest: {
+                    data: Object.assign(splittedFields.keysToUpdate, attachmentsToUpdate),
+                    ids
+                },
+                DbAttachmentActionRequests: this.getFormattedAttachments(ids, splittedFields.keysToAttach, splittedFields.keysToAttachInDifferentModel, modelInfo)
+            };
+            if (method == 'create')
+                delete request.DbBasicActionRequest.ids;
+            return this.http.request(method == 'create' ? 'post' : 'put', buildPath([
+                this.environmentConfig?.environment?.siteServerPath,
+                mongoCollectionName,
+                method == 'addOrUpdate' ? this.environmentConfig?.mongoUpdates?.Methods?.AddOrUpdate : this.environmentConfig?.mongoUpdates?.Methods?.Create,
+                this.environmentConfig?.mongoUpdates?.Submethods?.AndAttach,
+                this.environmentConfig?.mongoUpdates?.Options?.Bulk
+            ]), { body: request });
+        }));
+    }
+    basicBulk(mongoCollectionName, fields, ids, requestType, skipToast) {
+        return this.getMongoCollectionModelInfo(mongoCollectionName).pipe(switchMap((modelInfo) => {
+            const updatedFields = remainJustWantedValueInDictionary(generalKeys.id, fields);
+            const splitedFields = this.splitFieldByType(fields, modelInfo);
+            const requests = Object.entries(updatedFields).map(([field, value]) => {
+                const fieldModelInfo = splitedFields.keysToAttachInDifferentModel[field];
+                return fieldModelInfo?.sourceField ?
+                    this.buildMirrorSourceCollectionRequestsData(value, fieldModelInfo.sourceField, fieldModelInfo.innerPreviewModelName, ids[0], requestType, fieldModelInfo.attachedToType)
+                    : this.buildSourceCollectionRequestsData(ids, { [field]: value }, requestType, mongoCollectionName);
+            });
+            let headers = null;
+            if (skipToast)
+                headers = skipToastHeader;
+            return this.http.post(buildPath([
+                this.environmentConfig?.environment?.siteServerPath,
+                mongoCollectionName,
+                this.environmentConfig?.mongoUpdates?.Methods?.Basic,
+                this.environmentConfig?.mongoUpdates?.Options?.Bulk,
+            ]), { requests }, { headers });
+        }));
+    }
+    buildSourceCollectionRequestsData(mongoSourceCollectionIds, data, requestType, mongoSourceCollectionName) {
+        return {
+            ids: mongoSourceCollectionIds,
+            data,
+            requestType,
+            actOnType: mongoSourceCollectionName
+        };
+    }
+    buildMirrorSourceCollectionRequestsData(fieldValue, sourceField, innerPreviewModelName, mongoSourceCollectionId, requestType, attachedToType) {
+        return {
+            ids: this.arrayOfIdObjectsToIdsArray(fieldValue),
+            data: this.buildBasicBulkObjectData(sourceField, innerPreviewModelName, mongoSourceCollectionId),
+            requestType,
+            actOnType: attachedToType
+        };
+    }
+    arrayOfIdObjectsToIdsArray(array) {
+        return array.map(object => object.id);
+    }
+    buildBasicBulkObjectData(sourceField, innerPreviewModelName, mongoSourceCollectionId) {
+        const value = innerPreviewModelName ? { [innerPreviewModelName]: { id: mongoSourceCollectionId } } : { id: mongoSourceCollectionId };
+        return { [sourceField]: [value] };
+    }
+    deleteMongoDocument(mongoCollectionName, ids) {
+        return this.http.post(buildPath([
+            this.environmentConfig?.environment?.siteServerPath,
+            mongoCollectionName,
+            this.environmentConfig?.mongoUpdates?.Methods?.Delete,
+        ]), ids);
+    }
+    deletePreviewItemsFromList(mongoCollectionName, fields, ids) {
+        const request = {
+            ids,
+            data: fields
+        };
+        return this.http.put(buildPath([
+            this.environmentConfig?.environment?.siteServerPath,
+            mongoCollectionName,
+            this.environmentConfig?.mongoUpdates?.Methods?.ListItemDeletion
+        ]), request);
+    }
+    getFormattedAttachments(ids, objectsToAttach, keysToAttachInDifferentModel, modelInfo) {
+        let result = [];
+        Object.keys(objectsToAttach).forEach(keyToAttach => {
+            let attachments = {};
+            if (Array.isArray(objectsToAttach[keyToAttach]))
+                objectsToAttach[keyToAttach].forEach((itemToAttach) => {
+                    const itemKey = Object.keys(itemToAttach)[0];
+                    const itemValue = itemToAttach[itemKey];
+                    this.dbActionsInnerIdManagerService.deleteInnerIdFieldIfExist(itemToAttach, itemValue);
+                    if (itemValue.hasOwnProperty(generalKeys.id) && itemValue[generalKeys.id] !== null)
+                        delete itemToAttach[Object.keys(itemToAttach)[0]][generalKeys.id];
+                    Object.assign(attachments, itemToAttach);
+                });
+            else
+                attachments[objectsToAttach[keyToAttach]] = {};
+            objectsToAttach[keyToAttach].forEach((objectToAttach, index) => {
+                if (objectsToAttach[keyToAttach] && Object.keys(objectsToAttach[keyToAttach][index]) && attachments[Object.keys(objectsToAttach[keyToAttach][index])[0]])
+                    Object.keys(attachments[Object.keys(objectsToAttach[keyToAttach][index])[0]]).forEach(keyOfObjectToAttachData => {
+                        if (modelInfo[keyToAttach].innerPreviewModelName == keyOfObjectToAttachData || !modelInfo[keyToAttach].innerProperties.hasOwnProperty(keyOfObjectToAttachData))
+                            delete attachments[Object.keys(objectsToAttach[keyToAttach][index])[0]][keyOfObjectToAttachData];
+                    });
+            });
+            result.push({
+                field: keyToAttach.charAt(0).toUpperCase() + keyToAttach.slice(1),
+                attachments,
+                ids
+            });
+        });
+        Object.keys(keysToAttachInDifferentModel).forEach(field => {
+            const extensionValue = Object.values(DbActionsInconsistencyMap[field].extension)[0];
+            const updatedExtensionInfo = { [ids[0]]: extensionValue };
+            let request = {
+                field: keysToAttachInDifferentModel[field].sourceField,
+                attachments: updatedExtensionInfo,
+                ids: keysToAttachInDifferentModel[field].values.map(value => value.id),
+                attachedToType: keysToAttachInDifferentModel[field].attachedToType
+            };
+            result.push(request);
+        });
+        return result;
+    }
+    splitFieldByType(fields, modelInfo) {
+        return Object.entries(fields).reduce((acc, [key, value]) => {
+            if (modelInfo[key] && (modelInfo[key].attachedToType == null || modelInfo[key].sourceField == null || modelInfo[key].sourceField == undefined)) {
+                const group = modelInfo[key].propertyUpdateType === ATTACH ? 'keysToAttach' : 'keysToUpdate';
+                if (value !== null && value !== undefined && (!Array.isArray(value) || value.length > 0)) {
+                    acc[group] = {
+                        ...acc[group], [key]: modelInfo[key].propertyUpdateType === ATTACH ?
+                            value?.map(value => {
+                                return { [value.id + '']: value };
+                            }) :
+                            value
+                    };
+                    this.dbActionsInnerIdManagerService.determineIfInnerIdIsNeeded(value);
+                }
+            }
+            else {
+                if (modelInfo[DbActionsInconsistencyMap[key]?.backendNaming])
+                    acc.keysToAttachInDifferentModel = {
+                        ...acc.keysToAttachInDifferentModel, [key]: {
+                            attachedToType: modelInfo[DbActionsInconsistencyMap[key].backendNaming]?.attachedToType,
+                            sourceField: modelInfo[DbActionsInconsistencyMap[key].backendNaming]?.sourceField,
+                            innerPreviewModelName: modelInfo[DbActionsInconsistencyMap[key].backendNaming]?.innerPreviewModelName,
+                            values: fields[key]
+                        }
+                    };
+                else
+                    acc.keysToAttachInDifferentModel = {
+                        ...acc.keysToAttachInDifferentModel, [key]: {
+                            attachedToType: modelInfo[key]?.attachedToType,
+                            sourceField: modelInfo[key]?.sourceField,
+                            innerPreviewModelName: modelInfo[key]?.innerPreviewModelName,
+                            values: fields[key]
+                        }
+                    };
+            }
+            return acc;
+        }, { keysToAttach: {}, keysToUpdate: {}, keysToAttachInDifferentModel: {} });
+    }
+    getMongoCollectionModelInfo(mongoCollectionName) {
+        return this.http.get(buildPath([
+            this.environmentConfig?.environment?.siteServerPath,
+            mongoCollectionName,
+            this.environmentConfig?.mongoUpdates?.Methods?.ModelInfo
+        ]));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DbActionRequestsService, deps: [{ token: i1.HttpClient }, { token: DbActionsInnerIdManagerService }, { token: HERUM_SHARED_CONFIG_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DbActionRequestsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DbActionRequestsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: DbActionsInnerIdManagerService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [HERUM_SHARED_CONFIG_TOKEN]
+                }] }] });
+const DbActionsInconsistencyMap = {
+    groups: {
+        backendNaming: "members",
+        extension: {
+            "NEW_VALUE": {}
+        },
+    },
+    groupsPermissions: {
+        backendNaming: "permittedGroups",
+        extension: {
+            "NEW_VALUE": {
+                "permission": {
+                    "update": true
+                }
+            }
+        },
+    },
+    groupsViewPermissions: {
+        backendNaming: "permittedGroups",
+        extension: {
+            "NEW_VALUE": {
+                "permission": {
+                    "update": false
+                }
+            }
+        }
+    },
+    assignments: {
+        backendNaming: "assignments",
+        extension: {
+            "NEW_VALUE": {
+                "id": null,
+                assignmentMetadata
+            }
+        }
+    },
+    "collegeTeacherAssignments": {
+        backendNaming: "collegeTeacherAssignments",
+        extension: {
+            "NEW_VALUE": {
+                "id": null
+            }
+        }
+    },
+    "collegeStudentAssignments": {
+        backendNaming: "collegeStudentAssignments",
+        extension: {
+            "NEW_VALUE": {
+                "id": null
+            }
+        }
+    }
+};
+
+class GlobalKeyboardListenerService {
+    environmentConfig;
+    globalKeyboardEvents$ = new Subject();
+    connection;
+    constructor(environmentConfig) {
+        this.environmentConfig = environmentConfig;
+        this.initGlobalSocket();
+    }
+    initGlobalSocket() {
+        if (this.connection)
+            return;
+        this.connection = new WebSocket(this.environmentConfig?.environment?.keyboardEventsLocalSocketPath);
+        this.connection.onmessage = (webSocketMessage) => {
+            const event = JSON.parse(webSocketMessage.data);
+            if (event.state == 'UP')
+                this.globalKeyboardEvents$.next(event);
+        };
+    }
+    get globalKeysToChromeKeysNames() {
+        return {
+            'NUMPAD 0': 'Insert',
+            'NUMPAD 1': 'End',
+            'NUMPAD 2': 'ArrowDown',
+            'NUMPAD 3': 'PageDown',
+            'NUMPAD 4': 'ArrowLeft',
+            'NUMPAD 5': 'Clear',
+            'NUMPAD 6': 'ArrowRight',
+            'NUMPAD 7': 'Home',
+            'NUMPAD 8': '',
+            'NUMPAD 9': 'PageUp',
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: GlobalKeyboardListenerService, deps: [{ token: HERUM_SHARED_CONFIG_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: GlobalKeyboardListenerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: GlobalKeyboardListenerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [HERUM_SHARED_CONFIG_TOKEN]
+                }] }] });
+
+class KeyPressService {
+    shouldPreventMacroKeyPress(event, macroKeysPress) {
+        const eventTarget = event.target;
+        const targetMacroKeys = eventTarget.getAttribute(attributes.preventMacroKeysPressEvent)?.split(",").map(Number);
+        const targetHasPreventMacroKeyPress = targetMacroKeys?.some(targetMacroKey => macroKeysPress.includes(targetMacroKey));
+        return targetHasPreventMacroKeyPress || eventTarget.hasAttribute(attributes.contenteditable);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: KeyPressService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: KeyPressService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: KeyPressService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class LoaderManagerService {
+    loadersIds = [];
+    loadingDescription = '';
+    addLoader(loaderId, description) {
+        this.loadersIds.push(loaderId);
+        this.loadingDescription = description;
+    }
+    changeDescription(description) {
+        this.loadingDescription = description;
+    }
+    clear() {
+        this.loadersIds = [];
+        this.loadingDescription = '';
+    }
+    removeLoaderId(loaderIdToRemove) {
+        let indexToRemove = this.loadersIds.findIndex(loaderId => loaderId == loaderIdToRemove);
+        if (indexToRemove != -1)
+            this.loadersIds.splice(indexToRemove, 1);
+    }
+    get isFullScreenLoading() {
+        return this.loadersIds.length > 0;
+    }
+    ;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: LoaderManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: LoaderManagerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: LoaderManagerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+const freeTextAnswerField = 'FreeTextAnswer';
+const gradeField = 'Grade';
+const answerNotesField = 'AnswerNotes[]';
+const UserQuestionsDataPath = 'QuizData.UserQuestionsData';
+class MicroResourcesService {
+    http;
+    environmentConfig;
+    constructor(http, environmentConfig) {
+        this.http = http;
+        this.environmentConfig = environmentConfig;
+    }
+    getAssignmentUpdateTimings(selectedResource, openingTime, closingTime) {
+        return [{
+                propertyPath: this.buildQuestionPropertyPath(selectedResource.quiz.questions[0]?.id, freeTextAnswerField),
+                collectionItemType: '',
+                openingTime,
+                closingTime,
+                authorizationType: MicroResourceAuthorizationType.update
+            },
+            {
+                propertyPath: this.buildQuestionPropertyPath(selectedResource.quiz.questions[1]?.id, freeTextAnswerField),
+                collectionItemType: '',
+                openingTime,
+                closingTime,
+                authorizationType: MicroResourceAuthorizationType.update
+            }];
+    }
+    getPublishGradeTimings(selectedResource, openingTime = new Date(2999, 1, 1), closingTime) {
+        return [{
+                authorizationType: MicroResourceAuthorizationType.view,
+                closingTime: closingTime,
+                collectionItemType: "",
+                openingTime: openingTime,
+                propertyPath: this.buildQuestionPropertyPath(selectedResource.quiz.questions[0].id, gradeField)
+            }, {
+                authorizationType: MicroResourceAuthorizationType.view,
+                closingTime: closingTime,
+                collectionItemType: "",
+                openingTime: openingTime,
+                propertyPath: this.buildQuestionPropertyPath(selectedResource.quiz.questions[1].id, gradeField)
+            }, {
+                authorizationType: MicroResourceAuthorizationType.view,
+                closingTime: closingTime,
+                collectionItemType: "",
+                openingTime: openingTime,
+                propertyPath: this.buildQuestionPropertyPath(selectedResource.quiz.questions[0].id, answerNotesField)
+            }, {
+                authorizationType: MicroResourceAuthorizationType.view,
+                closingTime: closingTime,
+                collectionItemType: "",
+                openingTime: openingTime,
+                propertyPath: this.buildQuestionPropertyPath(selectedResource.quiz.questions[1].id, answerNotesField)
+            }, {
+                authorizationType: MicroResourceAuthorizationType.view,
+                closingTime: closingTime,
+                collectionItemType: "",
+                openingTime: openingTime,
+                propertyPath: `Grade`
+            }];
+    }
+    updateUserMicroResourceAuthorizationLocally(currentLesson, studentId, microResourceAuthorizations, selectedResource) {
+        currentLesson.students.find(student => student.student.id == studentId)
+            .resourceSubscriptions.find(resourceSubscription => resourceSubscription.resourcePreview.id == selectedResource.id)
+            .microResourceAuthorizations = microResourceAuthorizations;
+    }
+    updateUserMicroResourceVisibility(microResource, resource, lesson, user) {
+        let propertyPath;
+        propertyPath = this.resolvePropertyPath(microResource.propertyPath, resource.quiz.questions);
+        resource.microResourceAuthorizations = resource.microResourceAuthorizations.filter(microResourceAuthorization => microResourceAuthorization.propertyPath != "" &&
+            microResourceAuthorization.propertyPath != propertyPath);
+        resource.microResourceAuthorizations.push({
+            propertyPath: propertyPath,
+            collectionItemType: microResource.collectionItemType,
+            openingTime: microResource.openingTime,
+            closingTime: microResource.closingTime,
+            authorizationType: MicroResourceAuthorizationType.view
+        });
+        return this.updateUserMicroResourceAuthorization(user.student.id, lesson, resource, resource.microResourceAuthorizations);
+    }
+    updateUserMicroResourceAuthorization(studentId, lesson, resource, authorizations) {
+        return this.http.post(this.environmentConfig?.environment?.siteServerPath + '/Activity/UpdateAuthorizations', {
+            userIds: [studentId],
+            lessonId: lesson.id,
+            resourceId: resource.id,
+            authorizations
+        }).pipe(tap(() => {
+            this.updateUserMicroResourceAuthorizationLocally(lesson, studentId, authorizations, resource);
+        }));
+    }
+    resolvePropertyPath(path, questions) {
+        return typeof path === 'function' ? path(questions) : path;
+    }
+    isTimePass(date) {
+        if (!date)
+            return false;
+        return new Date(date).getTime() < new Date().getTime();
+    }
+    isAuthenticated(microResource) {
+        return this.isTimePass(microResource.openingTime) && !this.isTimePass(microResource.closingTime);
+    }
+    isQuestionAssignment(resourceSubscription, questionType) {
+        const question = resourceSubscription?.quizData?.userQuestionsData.find(userQuestionData => userQuestionData.questionType === questionType);
+        if (!question)
+            return false;
+        return !!resourceSubscription.microResourceAuthorizations?.find(microResourceAuthorization => microResourceAuthorization.propertyPath === this.buildQuestionPropertyPath(question.id, freeTextAnswerField));
+    }
+    isQuestionPendingForCheck(resourceSubscription, questionData) {
+        const microResourceAuthorizations = resourceSubscription.microResourceAuthorizations;
+        const questionId = questionData.id;
+        const questionClosingTime = microResourceAuthorizations?.find(microResourceAuthorization => microResourceAuthorization.propertyPath === this.buildQuestionPropertyPath(questionId, freeTextAnswerField) && microResourceAuthorization.authorizationType === MicroResourceAuthorizationType.update)?.closingTime;
+        const gradePublishOpeningTime = microResourceAuthorizations?.find(microResourceAuthorization => microResourceAuthorization.propertyPath === this.buildQuestionPropertyPath(questionId, gradeField))?.openingTime;
+        let isQuestionPendingForCheck = false;
+        if (questionClosingTime && questionData.grade === defaultGrade) {
+            isQuestionPendingForCheck = gradePublishOpeningTime ?
+                new Date(questionClosingTime).getTime() < new Date().getTime() && new Date().getTime() < new Date(gradePublishOpeningTime).getTime() :
+                new Date(questionClosingTime).getTime() < new Date().getTime();
+        }
+        return isQuestionPendingForCheck;
+    }
+    buildQuestionPropertyPath(id, field) {
+        return `${UserQuestionsDataPath}[${id}].${field}`;
+    }
+    hasFillAuthorizationClosingTimePassed(innerAuthorizations, resource) {
+        const fillAuthorizationPropertyPath = defaultAuthorizationObject.fill().propertyPath.replace(resourceIdPlaceholder, resource.id);
+        const fillAuthorization = innerAuthorizations?.find(auth => auth.propertyPath == fillAuthorizationPropertyPath && auth.authorizationType == MicroResourceAuthorizationType.fill);
+        return this.isTimePass(fillAuthorization?.closingTime);
+    }
+    isPublishGradeAuthenticated(innerAuthorizations, resource) {
+        const publishGradeInnerAuthorizations = this.getAuthorization(innerAuthorizations, defaultAuthorizationObject.resourceGrade(), MicroResourceAuthorizationType.view, resource);
+        return publishGradeInnerAuthorizations ? this.isAuthenticated(publishGradeInnerAuthorizations) : false;
+    }
+    getAuthorization(innerAuthorizations, defaultAuthorizationObject, MicroResourceAuthorizationType, resource) {
+        const fillAuthorizationPropertyPath = defaultAuthorizationObject.propertyPath.replace(resourceIdPlaceholder, resource.id);
+        return innerAuthorizations.find((innerAuthorization) => innerAuthorization.propertyPath === fillAuthorizationPropertyPath && innerAuthorization.authorizationType === MicroResourceAuthorizationType);
+    }
+    createMultiResourceDefaultAuthorizations(students, pageId, resourcesIds, defaultAuthorizations, authorizations) {
+        const updates = [];
+        let microAuthorizations = [];
+        if (authorizations)
+            microAuthorizations = authorizations;
+        else {
+            resourcesIds.forEach(resourceId => {
+                let defaultAuthorizationsCopy = cloneDeep(defaultAuthorizations);
+                defaultAuthorizationsCopy.forEach(authorization => authorization.propertyPath = authorization.propertyPath.replace(resourceIdPlaceholder, resourceId));
+                microAuthorizations.push(...defaultAuthorizationsCopy);
+            });
+        }
+        const parsedAuthorizations = microAuthorizations.map((authorization) => ({
+            propertyPath: authorization.propertyPath,
+            closingTime: authorization.closingTime,
+            openingTime: authorization.openingTime,
+            authorizationType: authorization.authorizationType,
+            lastUpDateTime: new Date(),
+            collectionItemType: authorization.collectionItemType
+        }));
+        students.forEach(student => {
+            updates.push({
+                userIds: [student.user?.id],
+                hadrachaPageId: pageId,
+                authorizations: [...(student.innerAuthorizations || []), ...parsedAuthorizations]
+            });
+        });
+        return forkJoin(updates.map(request => {
+            return this.http.post(this.environmentConfig?.environment?.siteServerPath + this.environmentConfig?.resourcePaths?.resourceUpdateAuthorizations, request);
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: MicroResourcesService, deps: [{ token: i1.HttpClient }, { token: HERUM_SHARED_CONFIG_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: MicroResourcesService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: MicroResourcesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [HERUM_SHARED_CONFIG_TOKEN]
+                }] }] });
+
+class ResourceDataBuilderService {
+    environmentConfig;
+    constructor(environmentConfig) {
+        this.environmentConfig = environmentConfig;
+    }
+    buildFilePath(resource) {
+        return getUrlFromFileData(resource.resourceFile, this.environmentConfig?.environment?.s3ServerPath) + this.getVersionPathParameter(resource);
+    }
+    buildDirectoryPath(resource) {
+        return getUrlFromFileData(resource.resourceFile, this.environmentConfig?.environment?.s3ServerPath) + resourcesFilesSuffixes[resource.resourceType] + this.getVersionPathParameter(resource);
+    }
+    getVersionPathParameter(resource) {
+        return getVersionPathParameter(new Date(resource.lastUpdateTime));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceDataBuilderService, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceDataBuilderService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceDataBuilderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined }] });
+
+class SystemStylingService {
+    document;
+    rendererFactory;
+    renderer = null;
+    constructor(document, rendererFactory) {
+        this.document = document;
+        this.rendererFactory = rendererFactory;
+        this.renderer = this.rendererFactory.createRenderer(null, null);
+    }
+    setHerumStyling() {
+        this.renderer.removeClass(document.body, "college-colors");
+        this.renderer.removeClass(document.body, "hadracha-colors");
+        this.renderer.addClass(document.body, "herum-colors");
+        this.setFavicon("/assets/college/pagesIcons/EchoIcon.svg");
+    }
+    setCollegeStyling() {
+        this.setCssVariable("--main-header-height", "0vh");
+        this.renderer.removeClass(document.body, "hadracha-colors");
+        this.renderer.removeClass(document.body, "herum-colors");
+        this.renderer.addClass(document.body, "college-colors");
+        this.setFavicon("/assets/college/pagesIcons/EchoIcon.svg");
+    }
+    setHadrachaStyling() {
+        this.renderer.removeClass(document.body, "college-colors");
+        this.renderer.removeClass(document.body, "herum-colors");
+        this.renderer.addClass(document.body, "hadracha-colors");
+        this.setFavicon("/assets/hadracha/general/hadracha-favicon.svg");
+    }
+    setCssVariable(name, value) {
+        document.documentElement.style.setProperty(name, value);
+    }
+    setFavicon(path) {
+        const link = this.document.querySelector("link[rel*='icon']");
+        link.type = 'image/x-icon';
+        link.rel = 'icon';
+        link.href = path;
+        this.document.head.appendChild(link);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: SystemStylingService, deps: [{ token: DOCUMENT }, { token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: SystemStylingService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: SystemStylingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.RendererFactory2 }] });
+function systemStylingFactory(systemName, systemStylingService) {
+    return () => {
+        switch (systemName) {
+            case system.college:
+                systemStylingService.setCollegeStyling();
+                break;
+            case system.herum:
+                systemStylingService.setHerumStyling();
+                break;
+            case system.hadracha:
+                systemStylingService.setHadrachaStyling();
+                break;
+            default:
+                throw new Error(`Unsupported system:${systemName}`);
+        }
+    };
+}
+
+class TrackTextChangesService {
+    systemContextTrackTextChangesService;
+    constructor(systemContextTrackTextChangesService) {
+        this.systemContextTrackTextChangesService = systemContextTrackTextChangesService;
+    }
+    getStyle() {
+        return this.systemContextTrackTextChangesService.getStyle();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: TrackTextChangesService, deps: [{ token: SYSTEM_TRACK_TEXT_CHANGES_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: TrackTextChangesService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: TrackTextChangesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1$1.ISystemTrackTextChangesService, decorators: [{
+                    type: Inject,
+                    args: [SYSTEM_TRACK_TEXT_CHANGES_SERVICE]
+                }] }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AuthService, CommonGraphqlRequestsService, DbActionRequestsService, DbActionsInnerIdManagerService, GlobalKeyboardListenerService, GraphQLService, KeyPressService, LoaderManagerService, MicroResourcesService, NestedConditionSigniture, ResourceDataBuilderService, SystemStylingService, TrackTextChangesService, emptyValueFlagForCreationUniqListItem, freeTextAnswerField, innerUniqListItemKey, systemStylingFactory };
+//# sourceMappingURL=herum-shared-services.mjs.map