herum-shared 0.1.38 → 0.1.46

package/fesm2022/herum-shared-services.mjs

@@ -3,16 +3,16 @@ 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 { shareReplay, map, 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, getVersionPathParameter } from 'herum-shared/utils';
+import { toHash, buildPath, getVersionPathParameter } from 'herum-shared/utils';
 import * as i2 from '@angular/router';
-import { regexExpressions, generalKeys, uploadsManagerKeys, skipToastHeader, assignmentMetadata, attributes, defaultGrade, defaultAuthorizationObject, resourceIdPlaceholder, getPublishAuthorization, getMongoMethodsDisplayedNamesMap, resourcesFilesSuffixes, system } from 'herum-shared/constants';
-import * as i1$1 from 'herum-shared/herum-types';
-import { microResourceAuthorizationType } from 'herum-shared/herum-types';
+import { regexExpressions, generalKeys, attributes, defaultGrade, defaultAuthorizationObject, resourceIdPlaceholder, getPublishAuthorization, resourcesFilesSuffixes, system, toastsTemplates, toastContext, toastStatuses, toastStates } from 'herum-shared/constants';
+import { MicroResourceAuthorizationType } from 'herum-types/Resource';
 import { cloneDeep } from 'lodash';
+import { QuizStatus } from 'herum-types/Enums';
 import { DOCUMENT } from '@angular/common';
 import { SYSTEM_TRACK_TEXT_CHANGES_SERVICE } from 'herum-shared/tokens';
 
@@ -34,8 +34,8 @@ class GraphQLService {
             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 })
+        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, gqlQuery.useTotalCount).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;
         }));
@@ -75,7 +75,7 @@ class GraphQLService {
     convertToResolverNameFormat(mongoCollectionName) {
         return mongoCollectionName.charAt(0).toLowerCase() + mongoCollectionName.slice(1);
     }
-    generateQuery(resolverName, formatExample, condition, first, after, offsetPaging, variablesStringForQuerySigniture, order, conditionPaths, orderPaths, offsetPagingPaths, isListQuery, isOffsetPagination) {
+    generateQuery(resolverName, formatExample, condition, first, after, offsetPaging, variablesStringForQuerySigniture, order, conditionPaths, orderPaths, offsetPagingPaths, isListQuery, isOffsetPagination, useTotalCount) {
         const conditionString = this.generateConditionString(condition);
         const returnFormat = this.getKeysString(formatExample, conditionPaths, orderPaths, offsetPagingPaths);
         let orderString = order ? `order:${this.generateOrderString(order)},` : '';
@@ -92,7 +92,7 @@ class GraphQLService {
             pagingString += ',';
         const elementsName = isOffsetPagination ? 'items' : 'nodes';
         const query = `query ${variablesStringForQuerySigniture ? variablesStringForQuerySigniture : ''} { 
-      ${resolverName + resolverParameters} { ${isListQuery ? (isOffsetPagination ? offsetPagingDataFormat : defaultPagingDataFormat) + `,totalCount , ${elementsName} {` : ''} ${returnFormat} } ${isListQuery ? '}' : ''} }`;
+      ${resolverName + resolverParameters} { ${isListQuery ? (isOffsetPagination ? offsetPagingDataFormat : defaultPagingDataFormat) + `,${useTotalCount ? 'totalCount ,' : ''} ${elementsName} {` : ''} ${returnFormat} } ${isListQuery ? '}' : ''} }`;
         return query;
     }
     generateConditionString(condition, isRecursiveCall = false) {
@@ -371,7 +371,7 @@ class CommonGraphqlRequestsService {
         let filterQuery = this.gql.generateFilterStringDynamically(usersIds, generalKeys.id, 'String');
         let query = {
             resolverName: this.gql.convertToResolverNameFormat(this.environmentConfig?.mongoUpdates?.Collections?.Users),
-            formatExample,
+            formatExample: formatExample,
             filters: {
                 or: filterQuery.filters
             },
@@ -427,290 +427,41 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
                 }]
         }] });
 
-const ATTACH = "Attach";
-class DbActionRequestsService {
+const oneSecondInMilliseconds = 1000;
+class GlobalErrorHandler {
     http;
-    dbActionsInnerIdManagerService;
     environmentConfig;
-    constructor(http, dbActionsInnerIdManagerService, environmentConfig) {
+    lastErrorKey = '';
+    lastErrorAt = 0;
+    constructor(http, 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' });
+    handleError(error) {
+        const currentKey = error?.message;
+        const now = Date.now();
+        if (currentKey == this.lastErrorKey && (now - this.lastErrorAt) < oneSecondInMilliseconds)
+            return;
+        this.lastErrorAt = now;
+        this.lastErrorKey = currentKey;
+        console.error(error);
+        this.http.post(this.environmentConfig?.environment?.userAction, {
+            system: this.environmentConfig?.environment?.systemIdentifier,
+            level: "Error",
+            application: "CLIENT ERROR",
+            message: error.message,
+            stack: error.stack,
+        }).subscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: GlobalErrorHandler, 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: GlobalErrorHandler });
 }
-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: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: GlobalErrorHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { 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;
@@ -824,43 +575,43 @@ class MicroResourcesService {
                 collectionItemType: '',
                 openingTime,
                 closingTime,
-                authorizationType: microResourceAuthorizationType.update
+                authorizationType: MicroResourceAuthorizationType.update
             },
             {
                 propertyPath: this.buildQuestionPropertyPath(selectedResource.quiz.questions[1]?.id, freeTextAnswerField),
                 collectionItemType: '',
                 openingTime,
                 closingTime,
-                authorizationType: microResourceAuthorizationType.update
+                authorizationType: MicroResourceAuthorizationType.update
             }];
     }
     getPublishGradeTimings(selectedResource, openingTime = new Date(2999, 1, 1), closingTime) {
         return [{
-                authorizationType: microResourceAuthorizationType.view,
+                authorizationType: MicroResourceAuthorizationType.view,
                 closingTime: closingTime,
                 collectionItemType: "",
                 openingTime: openingTime,
                 propertyPath: this.buildQuestionPropertyPath(selectedResource.quiz.questions[0].id, gradeField)
             }, {
-                authorizationType: microResourceAuthorizationType.view,
+                authorizationType: MicroResourceAuthorizationType.view,
                 closingTime: closingTime,
                 collectionItemType: "",
                 openingTime: openingTime,
                 propertyPath: this.buildQuestionPropertyPath(selectedResource.quiz.questions[1].id, gradeField)
             }, {
-                authorizationType: microResourceAuthorizationType.view,
+                authorizationType: MicroResourceAuthorizationType.view,
                 closingTime: closingTime,
                 collectionItemType: "",
                 openingTime: openingTime,
                 propertyPath: this.buildQuestionPropertyPath(selectedResource.quiz.questions[0].id, answerNotesField)
             }, {
-                authorizationType: microResourceAuthorizationType.view,
+                authorizationType: MicroResourceAuthorizationType.view,
                 closingTime: closingTime,
                 collectionItemType: "",
                 openingTime: openingTime,
                 propertyPath: this.buildQuestionPropertyPath(selectedResource.quiz.questions[1].id, answerNotesField)
             }, {
-                authorizationType: microResourceAuthorizationType.view,
+                authorizationType: MicroResourceAuthorizationType.view,
                 closingTime: closingTime,
                 collectionItemType: "",
                 openingTime: openingTime,
@@ -882,7 +633,7 @@ class MicroResourcesService {
             collectionItemType: microResource.collectionItemType,
             openingTime: microResource.openingTime,
             closingTime: microResource.closingTime,
-            authorizationType: microResourceAuthorizationType.view
+            authorizationType: MicroResourceAuthorizationType.view
         });
         return this.updateUserMicroResourceAuthorization(user.student.id, lesson, resource, resource.microResourceAuthorizations);
     }
@@ -916,7 +667,7 @@ class MicroResourcesService {
     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 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) {
@@ -929,26 +680,26 @@ class MicroResourcesService {
     buildQuestionPropertyPath(id, field) {
         return `${UserQuestionsDataPath}[${id}].${field}`;
     }
+    isPublishGradeAuthenticated(innerAuthorizations, resource) {
+        const publishGradeInnerAuthorizations = this.getAuthorization(innerAuthorizations, defaultAuthorizationObject.resourceGrade(), MicroResourceAuthorizationType.view, resource);
+        return publishGradeInnerAuthorizations ? this.isAuthenticated(publishGradeInnerAuthorizations) : false;
+    }
     hasFillAuthorizationClosingTimePassed(innerAuthorizations, resource) {
         const fillAuthorizationPropertyPath = defaultAuthorizationObject.fill().propertyPath.replace(resourceIdPlaceholder, resource.id);
-        const fillAuthorization = innerAuthorizations?.find(auth => auth.propertyPath == fillAuthorizationPropertyPath && auth.authorizationType == microResourceAuthorizationType.fill);
+        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);
+        const authorizationPropertyPath = defaultAuthorizationObject.propertyPath.replace(resourceIdPlaceholder, resource.id);
+        return innerAuthorizations.find((innerAuthorization) => innerAuthorization.propertyPath === authorizationPropertyPath && innerAuthorization.authorizationType === microResourceAuthorizationType);
     }
-    createMultiResourceDefaultAuthorizations(students, pageId, resourcesIds, defaultAuthorizations, authorizations) {
+    createMultiResourceDefaultAuthorizations(students, pageId, resourcesIdsToDefaultAuthorizations, authorizations) {
         const updates = [];
         let microAuthorizations = [];
         if (authorizations)
             microAuthorizations = authorizations;
         else {
-            resourcesIds.forEach(resourceId => {
+            Object.entries(resourcesIdsToDefaultAuthorizations).forEach(([resourceId, defaultAuthorizations]) => {
                 let defaultAuthorizationsCopy = cloneDeep(defaultAuthorizations);
                 defaultAuthorizationsCopy.forEach(authorization => authorization.propertyPath = authorization.propertyPath.replace(resourceIdPlaceholder, resourceId));
                 microAuthorizations.push(...defaultAuthorizationsCopy);
@@ -1001,7 +752,7 @@ class MicroResourcesService {
         const updates = [];
         resourcesIdsToRemove.forEach(resourceIdToRemove => {
             page.students.forEach(student => {
-                let resourceAuthorizationsToKeep = student.innerAuthorizations.filter(innerAuthorization => innerAuthorization.propertyPath.includes(resourceIdToRemove));
+                let resourceAuthorizationsToKeep = student.innerAuthorizations.filter(innerAuthorization => !innerAuthorization.propertyPath.includes(resourceIdToRemove));
                 updates.push({
                     userIds: [student.user?.id],
                     hadrachaPageId: page.id,
@@ -1011,6 +762,19 @@ class MicroResourcesService {
         });
         return forkJoin(updates.map(request => this.http.post(this.environmentConfig?.environment?.siteServerPath + this.environmentConfig?.resourcePaths?.resourceUpdateAuthorizations, request)));
     }
+    getGradeDisplayText(gradeData) {
+        if (gradeData.gradeStatus === QuizStatus.checked) {
+            if (gradeData.isBinary) {
+                if (gradeData.isPassedGrade)
+                    return 'עובר';
+                return 'נכשל';
+            }
+            return gradeData.grade.toFixed(0);
+        }
+        if (gradeData.gradeStatus === QuizStatus.submittedToCheck)
+            return 'בבדיקה';
+        return 'לא הוגש';
+    }
     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' });
 }
@@ -1026,19 +790,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
 
 class UtilsService {
     environmentConfig;
-    constructor(environmentConfig) {
+    http;
+    constructor(environmentConfig, http) {
         this.environmentConfig = environmentConfig;
+        this.http = http;
     }
-    getDisplayedNameForMongoMethodByUserActivity(urlRequest) {
-        let mongoMethodDisplayedName;
-        const mongoMethodsDisplayedNamesMap = getMongoMethodsDisplayedNamesMap(this.environmentConfig?.mongoUpdates, this.environmentConfig?.authenticationPaths);
-        Object.entries(mongoMethodsDisplayedNamesMap).forEach(([mongoMethod, displayedName]) => {
-            const urlParts = urlRequest?.split('/');
-            const matchedMethod = urlParts?.find(urlPart => urlPart === mongoMethod);
-            if (matchedMethod)
-                mongoMethodDisplayedName = displayedName;
-        });
-        return mongoMethodDisplayedName;
+    ;
+    getModelInfo(model) {
+        return this.http.get(`${this.environmentConfig?.environment?.siteServerPath}/${model}/${this.environmentConfig?.mongoUpdates?.Methods?.ModelInfo}`);
     }
     getUrlFromFileData(fileData) {
         if (!fileData?.key || !fileData?.bucket)
@@ -1049,14 +808,14 @@ class UtilsService {
     fetchFiles(fileId, resourceType, bucket) {
         if (!fileId)
             return Promise.reject();
-        const bucketPath = bucket ? bucket : this.environmentConfig?.buckets[resourceType];
+        const bucketPath = bucket ? bucket : this.environmentConfig?.buckets?.[resourceType];
         if (fileId && fileId[0] != '/' && bucketPath[bucketPath.length - 1] != '/')
             fileId = "/" + fileId;
         const path = this.environmentConfig?.environment?.s3ServerPath + bucketPath + fileId;
         return fetch(path);
     }
     async initAudioFile(fileId, bucketName, signal) {
-        const audioBucketName = bucketName ? (bucketName + "/") : this.environmentConfig?.buckets.Audio;
+        const audioBucketName = bucketName ? (bucketName + "/") : this.environmentConfig?.buckets?.Audio;
         return fetch(this.environmentConfig?.environment?.s3ServerPath + audioBucketName + fileId, { signal: signal })
             .then(async (response) => {
             const arrayBuffer = await response.arrayBuffer();
@@ -1080,7 +839,7 @@ class UtilsService {
             }
         });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: UtilsService, deps: [{ token: HERUM_SHARED_CONFIG_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: UtilsService, deps: [{ token: HERUM_SHARED_CONFIG_TOKEN }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: UtilsService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: UtilsService, decorators: [{
@@ -1091,7 +850,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [HERUM_SHARED_CONFIG_TOKEN]
-                }] }] });
+                }] }, { type: i1.HttpClient }] });
 
 class ResourceDataBuilderService {
     utilsService;
@@ -1185,6 +944,66 @@ function systemStylingFactory(systemName, systemStylingService) {
     };
 }
 
+class ToastsService {
+    toast$ = new BehaviorSubject(undefined);
+    toastId = 0;
+    toastsTemplates = toastsTemplates;
+    findErrorMessageByStatusCode(statusCode, mongoMethodDisplayedName) {
+        if (!toastContext.statusCodes[statusCode])
+            statusCode = 'genericError';
+        return toastContext.statusCodes[statusCode](mongoMethodDisplayedName);
+    }
+    showErrorToast(toastContextKey) {
+        if (!this.toastsTemplates[toastContextKey])
+            return;
+        let content = this.toastsTemplates[toastContextKey][toastStatuses.error];
+        let title = this.toastsTemplates[toastContextKey].title;
+        this.showToast(title, content, toastStatuses.error);
+    }
+    showSuccessToast(toastContextKey) {
+        if (!this.toastsTemplates[toastContextKey])
+            return;
+        let content = this.toastsTemplates[toastContextKey][toastStatuses.success];
+        let title = this.toastsTemplates[toastContextKey].title;
+        this.showToast(title, content, toastStatuses.success);
+    }
+    showInformationToast(toastContextKey) {
+        if (!this.toastsTemplates[toastContextKey])
+            return;
+        let content = this.toastsTemplates[toastContextKey][toastStatuses.information];
+        let title = this.toastsTemplates[toastContextKey].title;
+        this.showToast(title, content, toastStatuses.information);
+    }
+    showOnDemandToast(toastContextKey, status, toastStorageKey) {
+        if (!this.toastsTemplates[toastContextKey])
+            return;
+        if (this.hasToastAlreadyShownAndShouldShowOnce(toastStorageKey))
+            return;
+        let content = this.toastsTemplates[toastContextKey][status];
+        let title = this.toastsTemplates[toastContextKey].title;
+        this.showToast(title, content, status);
+    }
+    hasToastAlreadyShownAndShouldShowOnce(toastStorageKey) {
+        if (!toastStorageKey)
+            return false;
+        if (StorageService.getItem(toastStorageKey))
+            return true;
+        StorageService.setItem(toastStorageKey, toastStorageKey);
+        return false;
+    }
+    showToast(title, content, status) {
+        this.toast$.next({ title, content, status, id: ++this.toastId, state: toastStates.preEnter });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ToastsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ToastsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ToastsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
 class TrackTextChangesService {
     systemContextTrackTextChangesService;
     constructor(systemContextTrackTextChangesService) {
@@ -1201,14 +1020,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: i1$1.ISystemTrackTextChangesService, decorators: [{
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [SYSTEM_TRACK_TEXT_CHANGES_SERVICE]
                 }] }] });
 
+/**
+ * @file Automatically generated by barrelsby.
+ */
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AuthService, CommonGraphqlRequestsService, DbActionRequestsService, DbActionsInnerIdManagerService, GlobalKeyboardListenerService, GraphQLService, KeyPressService, LoaderManagerService, MicroResourcesService, NestedConditionSigniture, ResourceDataBuilderService, SystemStylingService, TrackTextChangesService, UtilsService, emptyValueFlagForCreationUniqListItem, freeTextAnswerField, innerUniqListItemKey, systemStylingFactory };
+export { AuthService, CommonGraphqlRequestsService, DbActionsInnerIdManagerService, GlobalErrorHandler, GlobalKeyboardListenerService, GraphQLService, KeyPressService, LoaderManagerService, MicroResourcesService, NestedConditionSigniture, ResourceDataBuilderService, SystemStylingService, ToastsService, TrackTextChangesService, UtilsService, emptyValueFlagForCreationUniqListItem, freeTextAnswerField, innerUniqListItemKey, systemStylingFactory };
 //# sourceMappingURL=herum-shared-services.mjs.map