@openstax/ts-utils 1.33.1 → 1.34.1

package/dist/esm/services/fileServer/s3FileServer.js

@@ -62,8 +62,7 @@ export const s3FileServer = (initializer) => (configProvider) => {
         const Conditions = [
             { acl: 'private' },
             { bucket },
-            ['starts-with', '$key', prefix],
-            ['starts-with', '$Content-Type', ''],
+            ['starts-with', '$key', prefix]
         ];
         const defaultFields = {
             acl: 'private',

package/dist/esm/services/lrsGateway/attempt-utils.d.ts

@@ -1,6 +1,8 @@
 import { LrsGateway, UXapiStatement } from '.';
 export type ActivityState = {
     attempts: number;
+    bestCompletedAttempt?: UXapiStatement;
+    bestCompletedAttemptCompleted?: UXapiStatement;
     completedAttempts: number;
     currentAttempt?: UXapiStatement;
     currentAttemptCompleted?: UXapiStatement;

package/dist/esm/services/lrsGateway/attempt-utils.js

@@ -38,7 +38,14 @@ export const resolveAttemptInfo = (statements, options) => {
     // TODO optimize. i'm 100% that this could all be done in one iteration but i'm not messing around with that for now.
     const attempts = resolveAttempts(statements, options);
     /* attempts that have a completed statement */
-    const completedAttempts = attempts.filter(attempt => !!resolveCompletedForAttempt(statements, attempt, options === null || options === void 0 ? void 0 : options.activityIRI));
+    const resolveAttemptsWithCompleted = (statements, attempts, activityIRI) => attempts.reduce((acc, attempt) => {
+        const completed = resolveCompletedForAttempt(statements, attempt, activityIRI);
+        if (completed)
+            acc.push({ attempt, completed });
+        return acc;
+    }, []);
+    const completedPairs = resolveAttemptsWithCompleted(statements, attempts, options === null || options === void 0 ? void 0 : options.activityIRI);
+    const completedAttempts = completedPairs.map(p => p.attempt);
     /* the last attempt sorted by timestamp */
     const currentAttempt = (options === null || options === void 0 ? void 0 : options.currentAttempt)
         ? attempts.find(attempt => attempt.id === options.currentAttempt)
@@ -52,23 +59,41 @@ export const resolveAttemptInfo = (statements, options) => {
             && ((_a = statement.context) === null || _a === void 0 ? void 0 : _a.registration) === currentAttempt.id;
     }) : [];
     const currentAttemptCompleted = currentAttempt && resolveCompletedForAttempt(statements, currentAttempt, options === null || options === void 0 ? void 0 : options.activityIRI);
-    const mostRecentAttemptWithCompleted = completedAttempts.reduce((current, attempt) => current && isAfter(parseISO(current.timestamp), parseISO(attempt.timestamp)) ? current : attempt, completedAttempts[0]);
-    const mostRecentAttemptWithCompletedCompleted = mostRecentAttemptWithCompleted
-        && resolveCompletedForAttempt(statements, mostRecentAttemptWithCompleted, options === null || options === void 0 ? void 0 : options.activityIRI);
+    const mostRecentPair = completedPairs.reduce((cur, pair) => {
+        if (!cur)
+            return pair;
+        return isAfter(parseISO(cur.attempt.timestamp), parseISO(pair.attempt.timestamp)) ? cur : pair;
+    }, undefined);
     /*
      * the structure allows for the possibility of multiple incomplete attempts.
      * the implementation can choose at its discretion to ignore the currentAttempt
      * and instead make a new one, for instance if the implementation desires
      * an attempt timeout feature
      */
+    const hasScaledScore = (p) => {
+        var _a;
+        return p.completed.result !== undefined &&
+            typeof ((_a = p.completed.result.score) === null || _a === void 0 ? void 0 : _a.scaled) === 'number';
+    };
+    // Filter to only scored pairs with scaled.
+    const scoredPairs = completedPairs.filter(hasScaledScore);
+    const bestPair = scoredPairs.reduce((best, pair) => {
+        if (!best)
+            return pair;
+        return pair.completed.result.score.scaled > best.completed.result.score.scaled
+            ? pair
+            : best;
+    }, undefined);
     return {
         attempts: attempts.length,
+        bestCompletedAttempt: bestPair === null || bestPair === void 0 ? void 0 : bestPair.attempt,
+        bestCompletedAttemptCompleted: bestPair === null || bestPair === void 0 ? void 0 : bestPair.completed,
         completedAttempts: completedAttempts.length,
         currentAttempt,
-        currentAttemptCompleted: currentAttemptCompleted,
+        currentAttemptCompleted,
         currentAttemptStatements,
-        mostRecentAttemptWithCompleted,
-        mostRecentAttemptWithCompletedCompleted,
+        mostRecentAttemptWithCompleted: mostRecentPair === null || mostRecentPair === void 0 ? void 0 : mostRecentPair.attempt,
+        mostRecentAttemptWithCompletedCompleted: mostRecentPair === null || mostRecentPair === void 0 ? void 0 : mostRecentPair.completed,
     };
 };
 /*

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

@@ -44,6 +44,8 @@ export type GradeAndProgress = {
     progress: Progress;
     name?: string;
 };
+export type UserActivityInfo = MappedUserInfo<ActivityState>;
+export declare const getCompletedUserInfosGradeAndProgress: (infos: UserActivityInfo[], scoreMaximum?: number, gradePreference?: "current" | "best") => GradeAndProgress[];
 export declare const getCurrentGrade: (services: {
     lrs: LrsGateway;
     ltiAuthProvider: AuthProvider;
@@ -53,8 +55,8 @@ export declare const getCurrentGrade: (services: {
     name?: string;
     scoreMaximum?: number;
     userId?: string;
+    gradePreference?: "current" | "best";
 }) => Promise<GradeAndProgress | null>;
-export type UserActivityInfo = MappedUserInfo<ActivityState>;
 export declare const getAssignmentGrades: (services: {
     accountsGateway: AccountsGateway;
     lrs: LrsGateway;
@@ -65,4 +67,5 @@ export declare const getAssignmentGrades: (services: {
     platformId?: string;
     scoreMaximum?: number;
     user?: string;
+    gradePreference?: "current" | "best";
 }) => Promise<GradeAndProgress[]>;

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

@@ -51,23 +51,41 @@ export const getScoreGrade = (score, options) => {
     };
 };
 // These methods assign 0's to incomplete activities
-const getCompletedActivityStateGradeAndProgress = ({ name, scoreMaximum, state, userId }) => {
-    var _a, _b, _c, _d;
-    return ({
-        grade: getScoreGrade(((_b = (_a = state.currentAttemptCompleted) === null || _a === void 0 ? void 0 : _a.result) === null || _b === void 0 ? void 0 : _b.score) || {}, {
+const pickAttemptAndCompleted = (state, gradePreference) => {
+    if (gradePreference === 'best' && state.bestCompletedAttempt) {
+        return {
+            attempt: state.bestCompletedAttempt,
+            completed: state.bestCompletedAttemptCompleted,
+        };
+    }
+    // return current attempt if gradePreference is current
+    return {
+        attempt: state.currentAttempt,
+        completed: state.currentAttemptCompleted,
+    };
+};
+const getCompletedActivityStateGradeAndProgress = ({ name, scoreMaximum, state, userId, gradePreference = 'current' }) => {
+    var _a;
+    const { attempt, completed } = pickAttemptAndCompleted(state, gradePreference);
+    return {
+        grade: getScoreGrade(((_a = completed === null || completed === void 0 ? void 0 : completed.result) === null || _a === void 0 ? void 0 : _a.score) || {}, {
             maxScore: scoreMaximum,
-            startedAt: (_c = state.currentAttempt) === null || _c === void 0 ? void 0 : _c.timestamp,
-            submittedAt: (_d = state.currentAttemptCompleted) === null || _d === void 0 ? void 0 : _d.timestamp,
+            startedAt: attempt === null || attempt === void 0 ? void 0 : attempt.timestamp,
+            submittedAt: completed === null || completed === void 0 ? void 0 : completed.timestamp,
             userId,
         }),
         progress: {
-            scaled: state.currentAttemptCompleted ? 1 : 0,
+            scaled: completed ? 1 : 0,
         },
         name,
-    });
+    };
 };
-const getCompletedUserInfosGradeAndProgress = (infos, scoreMaximum) => infos.map(({ data, fullName, platformUserId }) => getCompletedActivityStateGradeAndProgress({
-    name: fullName, scoreMaximum, userId: platformUserId, state: data
+export const getCompletedUserInfosGradeAndProgress = (infos, scoreMaximum, gradePreference) => infos.map(({ data, fullName, platformUserId }) => getCompletedActivityStateGradeAndProgress({
+    name: fullName,
+    scoreMaximum,
+    userId: platformUserId,
+    state: data,
+    gradePreference,
 }));
 export const getCurrentGrade = async (services, registration, options) => {
     var _a;
@@ -76,24 +94,41 @@ export const getCurrentGrade = async (services, registration, options) => {
         return null;
     }
     const userId = (_a = options === null || options === void 0 ? void 0 : options.userId) !== null && _a !== void 0 ? _a : user.uuid;
-    const { currentPreference, incompleteAttemptCallback, name, scoreMaximum } = options !== null && options !== void 0 ? options : {};
+    const { currentPreference, incompleteAttemptCallback, name, scoreMaximum, gradePreference, } = options !== null && options !== void 0 ? options : {};
     const infoPerUser = await getRegistrationAttemptInfo(services.lrs, registration, { currentPreference });
     const userInfo = infoPerUser[user.uuid];
     if (!userInfo) {
-        return getCompletedActivityStateGradeAndProgress({ name, scoreMaximum, state: resolveAttemptInfo([]), userId });
+        return getCompletedActivityStateGradeAndProgress({
+            name,
+            scoreMaximum,
+            state: resolveAttemptInfo([]),
+            userId,
+            gradePreference,
+        });
     }
     if (userInfo.currentAttemptCompleted || !incompleteAttemptCallback) {
-        return getCompletedActivityStateGradeAndProgress({ name, scoreMaximum, state: userInfo, userId });
+        return getCompletedActivityStateGradeAndProgress({
+            name,
+            scoreMaximum,
+            state: userInfo,
+            userId,
+            gradePreference,
+        });
     }
     return incompleteAttemptCallback(userInfo);
 };
 export const getAssignmentGrades = async (services, assignmentIRI, registration, options) => {
-    const { anyUser, currentPreference, incompleteAttemptsCallback, platformId, scoreMaximum, user } = options !== null && options !== void 0 ? options : {};
+    const { anyUser, currentPreference, incompleteAttemptsCallback, platformId, scoreMaximum, user, gradePreference = 'current', } = options !== null && options !== void 0 ? options : {};
     const infoPerUserUuid = await getRegistrationAttemptInfo(services.lrs, registration, { activity: assignmentIRI, anyUser, currentPreference, user });
     const mappedInfo = await services.accountsGateway.mapUserUuids(infoPerUserUuid, platformId);
+    // If no custom callback, just return graded results based on preference
     if (!incompleteAttemptsCallback) {
-        return getCompletedUserInfosGradeAndProgress(mappedInfo, scoreMaximum);
+        return getCompletedUserInfosGradeAndProgress(mappedInfo, scoreMaximum, gradePreference);
     }
-    const [incompleteInfo, completedInfo] = partition((info) => info.data.currentAttemptCompleted === undefined)(mappedInfo);
-    return getCompletedUserInfosGradeAndProgress(completedInfo, scoreMaximum).concat(await incompleteAttemptsCallback(incompleteInfo));
+    // Partition based on whether the chosen preference has a completed attempt
+    const [incompleteInfo, completedInfo] = partition((info) => {
+        const { completed } = pickAttemptAndCompleted(info.data, gradePreference);
+        return completed === undefined;
+    })(mappedInfo);
+    return getCompletedUserInfosGradeAndProgress(completedInfo, scoreMaximum, gradePreference).concat(await incompleteAttemptsCallback(incompleteInfo));
 };