return (dispatch, getState) => {

const state = getState().progress;

const newLevel = state.lessons[0].levels.find(level =>

level.ids.find(id => id === levelId)

);

updateBrowserForLevelNavigation(state, newLevel.url, levelId);

dispatch(setCurrentLevelId(levelId));

};

if (action.type === INIT_PROGRESS) {

let lessons = action.lessons;

// Re-initializing with full set of lessons shouldn't blow away currentLessonId

const currentLessonId =

state.currentLessonId ||

(lessons.length === 1 ? lessons[0].id : undefined);

// extract fields we care about from action

return {

...state,

currentLevelId: action.currentLevelId,

deeperLearningCourse: action.deeperLearningCourse,

saveAnswersBeforeNavigation: action.saveAnswersBeforeNavigation,

lessons: processedLessons(lessons, action.deeperLearningCourse),

lessonGroups: action.lessonGroups,

peerReviewLessonInfo: action.peerReviewLessonInfo,

scriptId: action.scriptId,

scriptName: action.scriptName,

scriptDisplayName: action.scriptDisplayName,

unitTitle: action.unitTitle,

unitDescription: action.unitDescription,

unitStudentDescription: action.unitStudentDescription,

courseId: action.courseId,

courseVersionId: action.courseVersionId,

currentLessonId: currentLessonId,

hasFullProgress: action.isFullProgress,

isLessonExtras: action.isLessonExtras,

currentPageNumber: action.currentPageNumber,

};

}

if (action.type === SET_CURRENT_LEVEL_ID) {

return {

...state,

currentLevelId: action.levelId,

};

}

if (action.type === SET_UNIT_PROGRESS) {

return {

...state,

unitProgress: processServerStudentProgress(action.unitProgress),

unitProgressHasLoaded: true,

};

}

if (action.type === USE_DB_PROGRESS) {

return {

...state,

usingDbProgress: true,

};

}

if (action.type === CLEAR_RESULTS) {

return {

...state,

levelResults: initialState.levelResults,

};

}

if (action.type === OVERWRITE_RESULTS) {

return {

...state,

levelResults: action.levelResults,

};

}

if (action.type === MERGE_RESULTS) {

let newLevelResults = {};

const combinedLevels = Object.keys({

...state.levelResults,

...action.levelResults,

});

combinedLevels.forEach(key => {

newLevelResults[key] = mergeActivityResult(

state.levelResults[key],

action.levelResults[key]

);

});

return {

...state,

levelResults: newLevelResults,

};

}

if (action.type === MERGE_PEER_REVIEW_PROGRESS) {

return {

...state,

peerReviewLessonInfo: {

...state.peerReviewLessonInfo,

levels: state.peerReviewLessonInfo.levels.map((level, index) => ({

...level,

...action.peerReviewsPerformed[index],

})),

},

};

}

if (action.type === UPDATE_FOCUS_AREAS) {

return {

...state,

changeFocusAreaPath: action.changeFocusAreaPath,

focusAreaLessonIds: action.focusAreaLessonIds,

};

}

if (action.type === DISABLE_POST_MILESTONE) {

return {

...state,

postMilestoneDisabled: true,

};

}

if (action.type === SET_IS_AGE_13_REQUIRED) {

return {

...state,

isAge13Required: action.isAge13Required,

};

}

if (action.type === SET_IS_SUMMARY_VIEW) {

return {

...state,

isSummaryView: action.isSummaryView,

};

}

if (action.type === SET_IS_MINI_VIEW) {

return {

...state,

isMiniView: action.isMiniView,

};

}

if (action.type === SET_STUDENT_DEFAULTS_SUMMARY_VIEW) {

return {

...state,

studentDefaultsSummaryView: action.studentDefaultsSummaryView,

};

}

if (action.type === SET_VIEW_TYPE) {

const {viewType} = action;

return {

...state,

isSummaryView:

viewType === ViewType.Participant && state.studentDefaultsSummaryView,

};

}

if (action.type === SET_CURRENT_LESSON_ID) {

// if we already have a currentLessonId, that means we're on a puzzle page,

// and we want currentLessonId to remain the same (rather than reflecting

// the last lesson the user has made progress on).

if (state.currentLessonId) {

return state;

}

return {

...state,

currentLessonId: action.lessonId,

};

}

if (action.type === SET_UNIT_COMPLETED) {

return {

...state,

unitCompleted: true,

};

}

if (action.type === SET_LESSON_EXTRAS_ENABLED) {

return {

...state,

lessonExtrasEnabled: action.lessonExtrasEnabled,

};

}

return state;

// The usual case

if (levelIds.length === 1) {

return levelIds[0];

}

// Return the level with the highest result

var attemptedIds = levelIds.filter(id => progressData[id]);

if (attemptedIds.length === 0) {

// None of them have been attempted, just return the first

return levelIds[0];

}

var bestId = attemptedIds[0];

var bestResult = progressData[bestId];

attemptedIds.forEach(function (id) {

var result = progressData[id];

if (result > bestResult) {

bestId = id;

bestResult = result;

}

});

return bestId;

let numLessonsWithLessonPlan = 0;

return lessons.map(lesson => {

let lessonNumber;

if (!isPlc && lesson.numberedLesson) {

numLessonsWithLessonPlan++;

lessonNumber = numLessonsWithLessonPlan;

}

return {

..._.omit(lesson, 'hidden'),

lessonNumber,

};

});

if (!state.scriptName) {

const message = `Could not request progress for user ID ${userId} from server: scriptName must be present in progress redux.`;

throw new Error(message);

}

// If we have a userId, we can clear any progress in redux and request all progress

// from the server.

if (userId) {

dispatch(clearResults());

}

return $.ajax({

url: `/api/user_progress/${state.scriptName}`,

method: 'GET',

data: {user_id: userId},

}).done(data => {

if (!data || _.isEmpty(data)) {

return;

}

if (data.isVerifiedInstructor) {

dispatch(setVerified());

}

// We are on an overview page if currentLevelId is undefined.

const onOverviewPage = !state.currentLevelId;

// Show lesson plan links and other teacher info if instructor and on unit overview page.

if (

(data.isInstructor || data.teacherViewingStudent) &&

!data.deeperLearningCourse &&

onOverviewPage

) {

// Default to summary view if teacher is viewing their student, otherwise default to detail view.

dispatch(setIsSummaryView(data.teacherViewingStudent));

}

if (data.focusAreaLessonIds) {

dispatch(

updateFocusArea(data.changeFocusAreaPath, data.focusAreaLessonIds)

);

}

dispatch(authorizeLockable(data.lockableAuthorized));

if (data.completed) {

dispatch(setScriptCompleted());

}

// Merge progress from server

if (data.progress) {

dispatch(setScriptProgress(data.progress));

// Note that we set the full progress object above in redux but also set

// a map containing just level results. This is the legacy code path and

// the goal is to eventually update all code paths to use unitProgress

// instead of levelResults.

const levelResults = _.mapValues(data.progress, getLevelResult);

dispatch(mergeResults(levelResults));

if (data.peerReviewsPerformed) {

dispatch(mergePeerReviewProgress(data.peerReviewsPerformed));

}

if (data.current_lesson) {

dispatch(setCurrentLessonId(data.current_lesson));

}

}

});

currentLevelId,

deeperLearningCourse,

saveAnswersBeforeNavigation,

lessons,

lessonGroups,

peerReviewLessonInfo,

scriptId,

scriptName,

scriptDisplayName,

unitTitle,

unitDescription,

unitStudentDescription,

courseId,

courseVersionId,

isFullProgress,

isLessonExtras,

currentPageNumber,

}) => ({

type: INIT_PROGRESS,

currentLevelId,

deeperLearningCourse,

saveAnswersBeforeNavigation,

lessons,

lessonGroups,

peerReviewLessonInfo,

scriptId,

scriptName,

scriptDisplayName,

unitTitle,

unitDescription,

unitStudentDescription,

courseId,

courseVersionId,

isFullProgress,

isLessonExtras,

currentPageNumber,

type: UPDATE_FOCUS_AREAS,

changeFocusAreaPath,

focusAreaLessonIds,

_.pick(lesson, [

'name',

'id',

'lockable',

'lessonNumber',

'lessonStartUrl',

'lesson_plan_html_url',

'lesson_feedback_url',

'student_lesson_plan_html_url',

'description_student',

'description_teacher',

...lessonFromLesson(state.peerReviewLessonInfo),

// add some fields that are missing for this lesson but required for lessonType

id: PEER_REVIEW_ID,

lockable: false,

isFocusArea: false,

state.peerReviewLessonInfo.levels.map((level, index) => ({

// These aren't true levels (i.e. we won't have an entry in levelResults),

// so always use a specific id that won't collide with real levels

...level,

id: PEER_REVIEW_ID.toString(),

isLocked: level.locked,

status: level.status || LevelStatus.not_tried,

levelNumber: index + 1,

{levelResults, unitProgress, levelPairing = {}, currentLevelId},

level,

isLockable

) => {

const normalizedLevel = processedLevel(level);

if (level.ids) {

// make sure we're using the id with best progress

normalizedLevel.id = bestResultLevelId(level.ids, levelResults);

}

// default values

let status = LevelStatus.not_tried;

let locked = isLockable;

let teacherFeedbackReviewState = null;

let levelProgress = unitProgress[normalizedLevel.id];

if (levelProgress?.pages) {

levelProgress = levelProgress.pages[normalizedLevel.pageNumber - 1];

}

if (levelProgress) {

// if we have levelProgress, overwrite default values

status = levelProgress.status;

locked = levelProgress.locked;

teacherFeedbackReviewState = levelProgress.teacherFeedbackReviewState;

} else if (level.kind !== LevelKind.assessment) {

// if we don't have levelProgress, get the status from `levelResults`.

// however, `levelResults` doesn't track per-page results for multi-page

// assessments, so for assessments we leave default values.

//

// note: if we're not using levelProgress, `isLocked` will always be false.

status = activityCssClass(levelResults[normalizedLevel.id]);

}

const isCurrent =

normalizedLevel.id === currentLevelId ||

!!level.ids?.includes[currentLevelId];

return {

...normalizedLevel,

status: status,

isCurrentLevel: isCurrent,

paired: levelPairing[level.activeId],

isLocked: locked,

teacherFeedbackReviewState: teacherFeedbackReviewState,

};

lessons,

levelResults,

unitProgress,

levelPairing,

currentLevelId,

}) =>

lessons.map(lesson =>

lesson.levels.map(level => {

let statusLevel = levelWithProgress(

{levelResults, unitProgress, levelPairing, currentLevelId},

level,

lesson.lockable

);

if (statusLevel.sublevels) {

statusLevel.sublevels = level.sublevels.map(sublevel =>

levelWithProgress(

{levelResults, unitProgress, levelPairing, currentLevelId},

sublevel,

lesson.lockable

)

);

}

return statusLevel;

})

const lesson = state.lessons?.find(lesson => lesson.id === lessonId);

return lesson.levels.map(level =>

levelWithProgress(state, level, lesson.lockable)

);

state.lessonExtrasEnabled

? state.lessons.find(lesson => lesson.id === lessonId)

.lesson_extras_level_url

let byGroup = {};

const allLevels = levelsByLesson(state);

state.lessonGroups.forEach(lessonGroup => {

byGroup[lessonGroup.display_name] = {

lessonGroup: {

id: lessonGroup.id,

userFacing: lessonGroup.user_facing,

displayName: lessonGroup.display_name,

description: lessonGroup.description,

bigQuestions: lessonGroup.big_questions,

},

lessons: [],

levelsByLesson: [],

};

});

state.lessons.forEach((lesson, index) => {

const group = lesson.lesson_group_display_name;

const lessonAtIndex = lessonFromLessonAtIndex(state, index);

let lessonLevels = allLevels[index];

if (!includeBonusLevels) {

lessonLevels = lessonLevels.filter(level => !level.bonus);

}

if (byGroup[group]) {

byGroup[group].lessons.push(lessonAtIndex);

byGroup[group].levelsByLesson.push(lessonLevels);

}

});

// Peer reviews get their own group, but these levels/lesson are stored

// separately from our other levels/lessons in redux (since they're slightly

// different)

if (state.peerReviewLessonInfo) {

byGroup[state.peerReviewLessonInfo.lesson_group_display_name] = {

group: state.peerReviewLessonInfo.lesson_group_display_name,

lessonGroup: {

id: null, //Peer reviews do not have descriptions or big questions so they won't need an id to track clicks

displayName: state.peerReviewLessonInfo.lesson_group_display_name,

description: null,

bigQuestions: null,

},

lessons: [peerReviewLesson(state)],

levelsByLesson: [peerReviewLevels(state)],

};

}

// We want to return an array of categories

return _.values(byGroup);

const progressions = [];

if (levels.length === 0) {

return progressions;

}

let currentProgression = {

start: 0,

name: levels[0].progression || levels[0].name,

displayName: levels[0].progressionDisplayName || levels[0].name,

levels: [levels[0]],

};

levels.slice(1).forEach((level, index) => {

const progressionName = level.progression || level.name;

if (progressionName === currentProgression.name) {

currentProgression.levels.push(level);

} else {

progressions.push(currentProgression);

currentProgression = {

// + 1 because we sliced off the first element

start: index + 1,

name: level.progression || level.name,

displayName: level.progressionDisplayName || level.name,

levels: [level],

};

}

});

progressions.push(currentProgression);

return progressions;