@openstax/ts-utils 1.5.1 → 1.5.3

package/dist/esm/services/lrsGateway/xapiUtils.d.ts

@@ -1,6 +1,7 @@
 import { AccountsGateway } from '../accountsGateway';
 import { AuthProvider } from '../authProvider';
 import { Logger } from '../logger';
+import { ActivityState } from './attempt-utils';
 import { LrsGateway } from '.';
 export interface Grade {
     scoreGiven: number;
@@ -12,21 +13,32 @@ export interface Grade {
 }
 export declare const getRegistrationAttemptInfo: (lrs: LrsGateway, registration: string, options?: {
     anyUser?: boolean | undefined;
+    user?: string | undefined;
 } | undefined) => Promise<{
-    [key: string]: import("./attempt-utils").ActivityState;
+    [key: string]: ActivityState;
 }>;
+export declare const getScoreGrade: (score: {
+    scaled?: number;
+    raw?: number;
+    min?: number;
+    max?: number;
+}, completed: boolean, userId: string, maxScore?: number | undefined) => Grade;
 export declare const getCurrentGrade: (services: {
     lrs: LrsGateway;
     ltiAuthProvider: AuthProvider;
 }, registration: string, options?: {
+    incompleteAttemptCallback?: ((info: ActivityState) => Promise<Grade>) | undefined;
     scoreMaximum?: number | undefined;
     userId?: string | undefined;
 } | undefined) => Promise<Grade | null>;
-export declare const getAllGradesForAssignment: (services: {
+export declare const getAssignmentGrades: (services: {
     accountsGateway: AccountsGateway;
     lrs: LrsGateway;
     logger: Logger;
 }, registration: string, options?: {
+    anyUser?: boolean | undefined;
+    incompleteAttemptsCallback?: ((mappedInfo: [string, ActivityState][]) => Promise<Grade[]>) | undefined;
     platformId?: string | undefined;
     scoreMaximum?: number | undefined;
+    user?: string | undefined;
 } | undefined) => Promise<Grade[]>;

package/dist/esm/services/lrsGateway/xapiUtils.js

@@ -1,3 +1,4 @@
+import partition from 'lodash/fp/partition';
 import { roundToPrecision } from '../..';
 import { resolveAttemptInfo } from './attempt-utils';
 export const getRegistrationAttemptInfo = async (lrs, registration, options) => {
@@ -13,17 +14,15 @@ export const getRegistrationAttemptInfo = async (lrs, registration, options) =>
     });
     const result = {};
     for (const [userUuid, userStatements] of Object.entries(statementsPerUser)) {
-        result[userUuid] = resolveAttemptInfo(userStatements);
+        result[userUuid] = resolveAttemptInfo(userStatements, { currentPreference: 'oldest' });
     }
     return result;
 };
 // generates a payload that can be sent to the LMS, documentation here:
 // lti: http://www.imsglobal.org/spec/lti-ags/v2p0#score-publish-service
 // ltijs: https://cvmcosta.me/ltijs/#/grading
-const getInfoGrade = (info, userId, maxScore) => {
-    var _a;
-    const completed = info.currentAttemptCompleted;
-    const { raw, scaled, max } = ((_a = completed === null || completed === void 0 ? void 0 : completed.result) === null || _a === void 0 ? void 0 : _a.score) || {};
+export const getScoreGrade = (score, completed, userId, maxScore) => {
+    const { raw, scaled, max } = score;
     const scoreMaximum = maxScore !== null && maxScore !== void 0 ? maxScore : 100;
     const scoreGiven = raw && max
         ? scoreMaximum / max * raw
@@ -38,18 +37,35 @@ const getInfoGrade = (info, userId, maxScore) => {
         scoreGiven: roundToPrecision(scoreGiven, -2),
     };
 };
+const getInfoGrade = (info, userId, maxScore) => {
+    var _a, _b;
+    return getScoreGrade(((_b = (_a = info.currentAttemptCompleted) === null || _a === void 0 ? void 0 : _a.result) === null || _b === void 0 ? void 0 : _b.score) || {}, !!info.currentAttemptCompleted, userId, maxScore);
+};
 export const getCurrentGrade = async (services, registration, options) => {
     var _a;
     const user = await services.ltiAuthProvider.getUser();
     if (!user) {
         return null;
     }
+    const userId = (_a = options === null || options === void 0 ? void 0 : options.userId) !== null && _a !== void 0 ? _a : user.uuid;
+    const scoreMaximum = options === null || options === void 0 ? void 0 : options.scoreMaximum;
     const infoPerUser = await getRegistrationAttemptInfo(services.lrs, registration);
     const userInfo = infoPerUser[user.uuid];
-    return getInfoGrade(userInfo !== null && userInfo !== void 0 ? userInfo : resolveAttemptInfo([]), (_a = options === null || options === void 0 ? void 0 : options.userId) !== null && _a !== void 0 ? _a : user.uuid, options === null || options === void 0 ? void 0 : options.scoreMaximum);
+    if (!userInfo) {
+        return getInfoGrade(resolveAttemptInfo([]), userId, scoreMaximum);
+    }
+    if (userInfo.currentAttemptCompleted || !(options === null || options === void 0 ? void 0 : options.incompleteAttemptCallback)) {
+        return getInfoGrade(userInfo, userId, scoreMaximum);
+    }
+    return options.incompleteAttemptCallback(userInfo);
 };
-export const getAllGradesForAssignment = async (services, registration, options) => {
-    const infoPerUserUuid = await getRegistrationAttemptInfo(services.lrs, registration, { anyUser: true });
-    const mappedResults = await services.accountsGateway.mapUserUuids(infoPerUserUuid, services.logger, options === null || options === void 0 ? void 0 : options.platformId);
-    return mappedResults.map(([userId, userInfo]) => getInfoGrade(userInfo, userId, options === null || options === void 0 ? void 0 : options.scoreMaximum));
+export const getAssignmentGrades = async (services, registration, options) => {
+    const infoPerUserUuid = await getRegistrationAttemptInfo(services.lrs, registration, { anyUser: options === null || options === void 0 ? void 0 : options.anyUser, user: options === null || options === void 0 ? void 0 : options.user });
+    const mappedInfo = await services.accountsGateway.mapUserUuids(infoPerUserUuid, services.logger, options === null || options === void 0 ? void 0 : options.platformId);
+    const gradeCompletedAttemptsOnly = (results) => results.map(([userId, userInfo]) => getInfoGrade(userInfo, userId, options === null || options === void 0 ? void 0 : options.scoreMaximum));
+    if (!(options === null || options === void 0 ? void 0 : options.incompleteAttemptsCallback)) {
+        return gradeCompletedAttemptsOnly(mappedInfo);
+    }
+    const [incompleteInfo, completedInfo] = partition((info) => info[1].currentAttemptCompleted === undefined)(mappedInfo);
+    return gradeCompletedAttemptsOnly(completedInfo).concat(await options.incompleteAttemptsCallback(incompleteInfo));
 };