herum-shared 0.1.25 → 0.1.28

package/fesm2022/herum-shared-services.mjs

@@ -7,11 +7,11 @@ 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 { toHash, buildPath, setHeaders, remainJustWantedValueInDictionary, 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 { 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 { 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';
@@ -824,43 +824,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 +882,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 +916,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) {
@@ -931,16 +931,16 @@ class MicroResourcesService {
     }
     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);
+        const publishGradeInnerAuthorizations = this.getAuthorization(innerAuthorizations, defaultAuthorizationObject.resourceGrade(), microResourceAuthorizationType.view, resource);
         return publishGradeInnerAuthorizations ? this.isAuthenticated(publishGradeInnerAuthorizations) : false;
     }
-    getAuthorization(innerAuthorizations, defaultAuthorizationObject, MicroResourceAuthorizationType, resource) {
+    getAuthorization(innerAuthorizations, defaultAuthorizationObject, microResourceAuthorizationType, resource) {
         const fillAuthorizationPropertyPath = defaultAuthorizationObject.propertyPath.replace(resourceIdPlaceholder, resource.id);
-        return innerAuthorizations.find((innerAuthorization) => innerAuthorization.propertyPath === fillAuthorizationPropertyPath && innerAuthorization.authorizationType === MicroResourceAuthorizationType);
+        return innerAuthorizations.find((innerAuthorization) => innerAuthorization.propertyPath === fillAuthorizationPropertyPath && innerAuthorization.authorizationType === microResourceAuthorizationType);
     }
     createMultiResourceDefaultAuthorizations(students, pageId, resourcesIds, defaultAuthorizations, authorizations) {
         const updates = [];
@@ -973,6 +973,44 @@ class MicroResourcesService {
             return this.http.post(this.environmentConfig?.environment?.siteServerPath + this.environmentConfig?.resourcePaths?.resourceUpdateAuthorizations, request);
         }));
     }
+    copyResourceStudentsAuthorizations(students, pageId, authSourceResourceId, authTargetResourceId, useDefaultGradePermissions) {
+        const updates = [];
+        students.forEach(student => {
+            let sourceResourceAuthorizations = student.innerAuthorizations.filter(innerAuthorization => innerAuthorization.propertyPath.includes(authSourceResourceId));
+            sourceResourceAuthorizations = cloneDeep(sourceResourceAuthorizations);
+            let targetResourceAuthorizations = sourceResourceAuthorizations.map(authorization => ({
+                ...authorization,
+                lastUpDateTime: new Date(),
+                propertyPath: authorization.propertyPath.replace(authSourceResourceId, authTargetResourceId)
+            }));
+            if (useDefaultGradePermissions) {
+                let defaultGradePermissions = cloneDeep(getPublishAuthorization());
+                defaultGradePermissions.forEach(authorization => authorization.propertyPath = authorization.propertyPath.replace(resourceIdPlaceholder, authTargetResourceId));
+                targetResourceAuthorizations = targetResourceAuthorizations.filter(authorization => !defaultGradePermissions.some(defaultGradePermission => defaultGradePermission.propertyPath == authorization.propertyPath));
+                targetResourceAuthorizations = [...targetResourceAuthorizations, ...defaultGradePermissions];
+            }
+            updates.push({
+                userIds: [student.user?.id],
+                hadrachaPageId: pageId,
+                authorizations: [...(student.innerAuthorizations || []), ...(targetResourceAuthorizations || [])]
+            });
+        });
+        return forkJoin(updates.map(request => this.http.post(this.environmentConfig?.environment?.siteServerPath + this.environmentConfig?.resourcePaths?.resourceUpdateAuthorizations, request)));
+    }
+    removeResourceAuthorizations(page, resourcesIdsToRemove) {
+        const updates = [];
+        resourcesIdsToRemove.forEach(resourceIdToRemove => {
+            page.students.forEach(student => {
+                let resourceAuthorizationsToKeep = student.innerAuthorizations.filter(innerAuthorization => innerAuthorization.propertyPath.includes(resourceIdToRemove));
+                updates.push({
+                    userIds: [student.user?.id],
+                    hadrachaPageId: page.id,
+                    authorizations: resourceAuthorizationsToKeep
+                });
+            });
+        });
+        return forkJoin(updates.map(request => 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' });
 }
@@ -986,21 +1024,90 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
                     args: [HERUM_SHARED_CONFIG_TOKEN]
                 }] }] });
 
-class ResourceDataBuilderService {
+class UtilsService {
     environmentConfig;
     constructor(environmentConfig) {
         this.environmentConfig = environmentConfig;
     }
+    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;
+    }
+    getUrlFromFileData(fileData) {
+        if (!fileData?.key || !fileData?.bucket)
+            return;
+        const fileDataKeyWithoutTrailingSlash = fileData.key.endsWith('/') ? fileData.key.slice(0, -1) : fileData.key;
+        return buildPath([this.environmentConfig?.environment?.s3ServerPath + fileData.bucket, fileDataKeyWithoutTrailingSlash]);
+    }
+    fetchFiles(fileId, resourceType, bucket) {
+        if (!fileId)
+            return Promise.reject();
+        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;
+        return fetch(this.environmentConfig?.environment?.s3ServerPath + audioBucketName + fileId, { signal: signal })
+            .then(async (response) => {
+            const arrayBuffer = await response.arrayBuffer();
+            if (arrayBuffer.byteLength === 0) {
+                const blob = await response.blob();
+                const reader = new FileReader();
+                reader.onload = () => {
+                    const arrayBuffer = reader.result;
+                    const file = new File([arrayBuffer], fileId, {
+                        type: 'audio/mp3',
+                    });
+                    return file;
+                };
+                reader.readAsArrayBuffer(blob);
+            }
+            else {
+                const file = new File([arrayBuffer], fileId, {
+                    type: 'audio/mpeg',
+                });
+                return file;
+            }
+        });
+    }
+    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 ɵ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: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [HERUM_SHARED_CONFIG_TOKEN]
+                }] }] });
+
+class ResourceDataBuilderService {
+    utilsService;
+    constructor(utilsService) {
+        this.utilsService = utilsService;
+    }
     buildFilePath(resource) {
-        return getUrlFromFileData(resource.resourceFile, this.environmentConfig?.environment?.s3ServerPath) + this.getVersionPathParameter(resource);
+        return this.utilsService.getUrlFromFileData(resource.resourceFile) + this.getVersionPathParameter(resource);
     }
     buildDirectoryPath(resource) {
-        return getUrlFromFileData(resource.resourceFile, this.environmentConfig?.environment?.s3ServerPath) + resourcesFilesSuffixes[resource.resourceType] + this.getVersionPathParameter(resource);
+        return this.utilsService.getUrlFromFileData(resource.resourceFile) + 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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceDataBuilderService, deps: [{ token: UtilsService }], 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: [{
@@ -1008,7 +1115,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: undefined }] });
+        }], ctorParameters: () => [{ type: UtilsService }] });
 
 class SystemStylingService {
     document;
@@ -1103,5 +1210,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { AuthService, CommonGraphqlRequestsService, DbActionRequestsService, DbActionsInnerIdManagerService, GlobalKeyboardListenerService, GraphQLService, KeyPressService, LoaderManagerService, MicroResourcesService, NestedConditionSigniture, ResourceDataBuilderService, SystemStylingService, TrackTextChangesService, emptyValueFlagForCreationUniqListItem, freeTextAnswerField, innerUniqListItemKey, systemStylingFactory };
+export { AuthService, CommonGraphqlRequestsService, DbActionRequestsService, DbActionsInnerIdManagerService, GlobalKeyboardListenerService, GraphQLService, KeyPressService, LoaderManagerService, MicroResourcesService, NestedConditionSigniture, ResourceDataBuilderService, SystemStylingService, TrackTextChangesService, UtilsService, emptyValueFlagForCreationUniqListItem, freeTextAnswerField, innerUniqListItemKey, systemStylingFactory };
 //# sourceMappingURL=herum-shared-services.mjs.map