@openstax/ts-utils 1.5.3 → 1.5.5

package/dist/esm/services/accountsGateway/index.d.ts

@@ -60,6 +60,12 @@ export declare type SearchUsersResponse = {
     } & JsonCompatibleStruct>;
     total_count: number;
 };
+export declare type MappedUserInfo<T> = {
+    data: T;
+    fullName: string;
+    platformUserId?: string;
+    uuid: string;
+};
 export declare const accountsGateway: <C extends string = "accounts">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
     accountsBase: import("../../config").ConfigValueProvider<string>;
     accountsAuthToken: import("../../config").ConfigValueProvider<string>;
@@ -70,7 +76,7 @@ export declare const accountsGateway: <C extends string = "accounts">(initialize
     linkUser: (body: LinkUserPayload) => Promise<LinkUserResponse>;
     mapUserUuids: <T>(userUuidsMap: {
         [uuid: string]: T;
-    }, logger: Logger, platformId?: string | undefined) => Promise<[string, T][]>;
+    }, logger: Logger, platformId?: string | undefined) => Promise<MappedUserInfo<T>[]>;
     searchUsers: (payload: SearchUsersPayload) => Promise<SearchUsersResponse>;
 };
 export declare type AccountsGateway = ReturnType<ReturnType<typeof accountsGateway>>;

package/dist/esm/services/accountsGateway/index.js

@@ -85,16 +85,23 @@ export const accountsGateway = (initializer) => (configProvider) => {
                 });
             }
             items.forEach((user) => {
-                const userId = platformId ? getPlatformUserId(user.external_ids, platformId) : user.full_name;
-                if (!userId) {
-                    const missing = platformId ? 'external_id matching the given platformId' : 'full_name';
+                const platformUserId = platformId ? getPlatformUserId(user.external_ids, platformId) : undefined;
+                if (platformId && !platformUserId) {
                     logger.logEvent(Level.Warn, {
-                        message: `Accounts user has no ${missing}`,
+                        message: 'Accounts user has no external_id matching the given platformId',
                         accountsUuid: user.uuid,
                         platformId,
                     });
                 }
-                results.push([userId || 'N/A', userUuidsMap[user.uuid]]);
+                if (!user.full_name) {
+                    logger.logEvent(Level.Warn, {
+                        message: 'Accounts user has no full_name',
+                        accountsUuid: user.uuid,
+                    });
+                }
+                results.push({
+                    data: userUuidsMap[user.uuid], fullName: user.full_name, platformUserId, uuid: user.uuid,
+                });
             });
         }));
         return results;

package/dist/esm/services/authProvider/index.d.ts

@@ -18,6 +18,11 @@ export interface ApiUser extends TokenUser {
         is_verified: boolean;
         is_guessed_preferred: boolean;
     }>;
+    applications: Array<{
+        id: number;
+        name: string;
+        roles: string[];
+    }>;
     external_ids: string[];
     is_not_gdpr_location: boolean;
     signed_contract_names: string[];

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

@@ -24,8 +24,10 @@ export declare const resolveAttemptInfo: (statements: XapiStatement[], options?:
     currentPreference?: "latest" | "oldest" | undefined;
 } | undefined) => ActivityState;
 export declare const loadStatementsForActivityAndFirstChildren: (gateway: LrsGateway, activityIRI: string, options?: {
+    anyUser?: boolean | undefined;
     attempt?: string | undefined;
     ensureSync?: boolean | undefined;
+    user?: string | undefined;
 } | undefined) => Promise<XapiStatement[]>;
 export declare const loadActivityAttemptInfo: (gateway: LrsGateway, activityIRI: string, options?: {
     currentAttempt?: string | undefined;

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

@@ -88,7 +88,7 @@ ${await response.text()}`);
                         throw new Error(`xAPI consistent through ${consistentThrough}; not in sync with current date ${date}.`);
                     }
                     return formatGetXapiStatementsResponse(responsePromise);
-                });
+                }, { retries: 4 });
             }
             else {
                 return formatGetXapiStatementsResponse(fetchXapiStatements(fetchParams));

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

@@ -1,4 +1,4 @@
-import { AccountsGateway } from '../accountsGateway';
+import { AccountsGateway, MappedUserInfo } from '../accountsGateway';
 import { AuthProvider } from '../authProvider';
 import { Logger } from '../logger';
 import { ActivityState } from './attempt-utils';
@@ -13,6 +13,7 @@ export interface Grade {
 }
 export declare const getRegistrationAttemptInfo: (lrs: LrsGateway, registration: string, options?: {
     anyUser?: boolean | undefined;
+    currentPreference?: "latest" | "oldest" | undefined;
     user?: string | undefined;
 } | undefined) => Promise<{
     [key: string]: ActivityState;
@@ -23,22 +24,34 @@ export declare const getScoreGrade: (score: {
     min?: number;
     max?: number;
 }, completed: boolean, userId: string, maxScore?: number | undefined) => Grade;
+export declare type Progress = {
+    scaled: number;
+    max?: number;
+    raw?: number;
+};
+export declare type GradeAndProgress = {
+    grade: Grade;
+    progress: Progress;
+};
 export declare const getCurrentGrade: (services: {
     lrs: LrsGateway;
     ltiAuthProvider: AuthProvider;
 }, registration: string, options?: {
-    incompleteAttemptCallback?: ((info: ActivityState) => Promise<Grade>) | undefined;
+    currentPreference?: "latest" | "oldest" | undefined;
+    incompleteAttemptCallback?: ((info: ActivityState) => Promise<GradeAndProgress>) | undefined;
     scoreMaximum?: number | undefined;
     userId?: string | undefined;
-} | undefined) => Promise<Grade | null>;
+} | undefined) => Promise<GradeAndProgress | null>;
+export declare type UserActivityInfo = MappedUserInfo<ActivityState>;
 export declare const getAssignmentGrades: (services: {
     accountsGateway: AccountsGateway;
     lrs: LrsGateway;
     logger: Logger;
 }, registration: string, options?: {
     anyUser?: boolean | undefined;
-    incompleteAttemptsCallback?: ((mappedInfo: [string, ActivityState][]) => Promise<Grade[]>) | undefined;
+    currentPreference?: "latest" | "oldest" | undefined;
+    incompleteAttemptsCallback?: ((mappedInfo: UserActivityInfo[]) => Promise<GradeAndProgress[]>) | undefined;
     platformId?: string | undefined;
     scoreMaximum?: number | undefined;
     user?: string | undefined;
-} | undefined) => Promise<Grade[]>;
+} | undefined) => Promise<GradeAndProgress[]>;

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

@@ -2,7 +2,8 @@ import partition from 'lodash/fp/partition';
 import { roundToPrecision } from '../..';
 import { resolveAttemptInfo } from './attempt-utils';
 export const getRegistrationAttemptInfo = async (lrs, registration, options) => {
-    const allStatements = await lrs.getAllXapiStatements({ ...options, registration, ensureSync: true });
+    const { currentPreference, ...xapiOptions } = options !== null && options !== void 0 ? options : {};
+    const allStatements = await lrs.getAllXapiStatements({ ...xapiOptions, registration, ensureSync: true });
     // Partition statements for each user
     const statementsPerUser = {};
     allStatements.forEach((statement) => {
@@ -14,7 +15,7 @@ export const getRegistrationAttemptInfo = async (lrs, registration, options) =>
     });
     const result = {};
     for (const [userUuid, userStatements] of Object.entries(statementsPerUser)) {
-        result[userUuid] = resolveAttemptInfo(userStatements, { currentPreference: 'oldest' });
+        result[userUuid] = resolveAttemptInfo(userStatements, { currentPreference });
     }
     return result;
 };
@@ -37,10 +38,17 @@ export const getScoreGrade = (score, completed, userId, maxScore) => {
         scoreGiven: roundToPrecision(scoreGiven, -2),
     };
 };
-const getInfoGrade = (info, userId, maxScore) => {
+// These methods assigns 0's to incomplete activities
+const getCompletedActivityStateGradeAndProgress = (state, 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);
+    return ({
+        grade: getScoreGrade(((_b = (_a = state.currentAttemptCompleted) === null || _a === void 0 ? void 0 : _a.result) === null || _b === void 0 ? void 0 : _b.score) || {}, !!state.currentAttemptCompleted, userId, maxScore),
+        progress: {
+            scaled: state.currentAttemptCompleted ? 1 : 0,
+        },
+    });
 };
+const getCompletedUserInfosGradeAndProgress = (infos, scoreMaximum) => infos.map(({ data, fullName, platformUserId }) => getCompletedActivityStateGradeAndProgress(data, platformUserId !== null && platformUserId !== void 0 ? platformUserId : fullName, scoreMaximum));
 export const getCurrentGrade = async (services, registration, options) => {
     var _a;
     const user = await services.ltiAuthProvider.getUser();
@@ -48,24 +56,24 @@ 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 scoreMaximum = options === null || options === void 0 ? void 0 : options.scoreMaximum;
-    const infoPerUser = await getRegistrationAttemptInfo(services.lrs, registration);
+    const { currentPreference, incompleteAttemptCallback, scoreMaximum } = options !== null && options !== void 0 ? options : {};
+    const infoPerUser = await getRegistrationAttemptInfo(services.lrs, registration, { currentPreference });
     const userInfo = infoPerUser[user.uuid];
     if (!userInfo) {
-        return getInfoGrade(resolveAttemptInfo([]), userId, scoreMaximum);
+        return getCompletedActivityStateGradeAndProgress(resolveAttemptInfo([]), userId, scoreMaximum);
     }
-    if (userInfo.currentAttemptCompleted || !(options === null || options === void 0 ? void 0 : options.incompleteAttemptCallback)) {
-        return getInfoGrade(userInfo, userId, scoreMaximum);
+    if (userInfo.currentAttemptCompleted || !incompleteAttemptCallback) {
+        return getCompletedActivityStateGradeAndProgress(userInfo, userId, scoreMaximum);
     }
-    return options.incompleteAttemptCallback(userInfo);
+    return incompleteAttemptCallback(userInfo);
 };
 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 { anyUser, currentPreference, incompleteAttemptsCallback, platformId, scoreMaximum, user } = options !== null && options !== void 0 ? options : {};
+    const infoPerUserUuid = await getRegistrationAttemptInfo(services.lrs, registration, { anyUser, currentPreference, user });
+    const mappedInfo = await services.accountsGateway.mapUserUuids(infoPerUserUuid, services.logger, platformId);
+    if (!incompleteAttemptsCallback) {
+        return getCompletedUserInfosGradeAndProgress(mappedInfo, scoreMaximum);
     }
-    const [incompleteInfo, completedInfo] = partition((info) => info[1].currentAttemptCompleted === undefined)(mappedInfo);
-    return gradeCompletedAttemptsOnly(completedInfo).concat(await options.incompleteAttemptsCallback(incompleteInfo));
+    const [incompleteInfo, completedInfo] = partition((info) => info.data.currentAttemptCompleted === undefined)(mappedInfo);
+    return getCompletedUserInfosGradeAndProgress(completedInfo, scoreMaximum).concat(await incompleteAttemptsCallback(incompleteInfo));
 };