Improve access control behavior (#39)

Fixes TNL-7175: Redirect to course home if a user is not unenrolled and the course is private.

- Require authentication to use the app while course blocks api requires it
- Gracefully handle course blocks api request failures allowing app to proceed to it redirection logic

Notable changes:

- selectors related to sequences are more resilient to missing models. In the case the course blocks api returns successfully but empty (in this case of enrolled but course not yet started).
- `fetchCourse` thunk handles failures for fetchCourseMeta and fetchCourseBlocks separately using `Promise.allSettled` instead of `Promise.all`
- `denied` is a new `courseStatus`
- Access denied redirect is done using a component at a new route `redirect/course-home/:courseId`

Now handles cases

- User is unauthenticated > redirect to login
- User is authenticated but not enrolled > redirects to lms course home
- When an enrolled user attempts to access courseware before the course start date they will load the sequence (but unable to load the vertical block). This behavior should be fixed in an update to edx-platform

src/data/slice.js

@@ -4,6 +4,7 @@ import { createSlice } from '@reduxjs/toolkit';
 export const LOADING = 'loading';
 export const LOADED = 'loaded';
 export const FAILED = 'failed';
+export const DENIED = 'denied';
 
 const slice = createSlice({
   name: 'courseware',
@@ -26,6 +27,10 @@ const slice = createSlice({
       state.courseId = payload.courseId;
       state.courseStatus = FAILED;
     },
+    fetchCourseDenied: (state, { payload }) => {
+      state.courseId = payload.courseId;
+      state.courseStatus = DENIED;
+    },
     fetchSequenceRequest: (state, { payload }) => {
       state.sequenceId = payload.sequenceId;
       state.sequenceStatus = LOADING;
@@ -45,6 +50,7 @@ export const {
   fetchCourseRequest,
   fetchCourseSuccess,
   fetchCourseFailure,
+  fetchCourseDenied,
   fetchSequenceRequest,
   fetchSequenceSuccess,
   fetchSequenceFailure,

src/data/thunks.js

@@ -5,12 +5,13 @@ import {
   getSequenceMetadata,
 } from './api';
 import {
-  addModelsMap, updateModel, updateModels, updateModelsMap,
+  addModelsMap, updateModel, updateModels, updateModelsMap, addModel,
 } from '../model-store';
 import {
   fetchCourseRequest,
   fetchCourseSuccess,
   fetchCourseFailure,
+  fetchCourseDenied,
   fetchSequenceRequest,
   fetchSequenceSuccess,
   fetchSequenceFailure,
@@ -19,39 +20,66 @@ import {
 export function fetchCourse(courseId) {
   return async (dispatch) => {
     dispatch(fetchCourseRequest({ courseId }));
-    Promise.all([
-      getCourseBlocks(courseId),
+    Promise.allSettled([
       getCourseMetadata(courseId),
-    ]).then(([
-      {
-        courses, sections, sequences, units,
-      },
-      course,
-    ]) => {
-      dispatch(addModelsMap({
-        modelType: 'courses',
-        modelsMap: courses,
-      }));
-      dispatch(updateModel({
-        modelType: 'courses',
-        model: course,
-      }));
-      dispatch(addModelsMap({
-        modelType: 'sections',
-        modelsMap: sections,
-      }));
-      // We update for sequences and units because the sequence metadata may have come back first.
-      dispatch(updateModelsMap({
-        modelType: 'sequences',
-        modelsMap: sequences,
-      }));
-      dispatch(updateModelsMap({
-        modelType: 'units',
-        modelsMap: units,
-      }));
-      dispatch(fetchCourseSuccess({ courseId }));
-    }).catch((error) => {
-      logError(error);
+      getCourseBlocks(courseId),
+    ]).then(([courseMetadataResult, courseBlocksResult]) => {
+      if (courseMetadataResult.status === 'fulfilled') {
+        dispatch(addModel({
+          modelType: 'courses',
+          model: courseMetadataResult.value,
+        }));
+      }
+
+      if (courseBlocksResult.status === 'fulfilled') {
+        const {
+          courses, sections, sequences, units,
+        } = courseBlocksResult.value;
+
+        dispatch(updateModelsMap({
+          modelType: 'courses',
+          modelsMap: courses,
+        }));
+        dispatch(addModelsMap({
+          modelType: 'sections',
+          modelsMap: sections,
+        }));
+        // We update for sequences and units because the sequence metadata may have come back first.
+        dispatch(updateModelsMap({
+          modelType: 'sequences',
+          modelsMap: sequences,
+        }));
+        dispatch(updateModelsMap({
+          modelType: 'units',
+          modelsMap: units,
+        }));
+      }
+
+      const fetchedMetadata = courseMetadataResult.status === 'fulfilled';
+      const fetchedBlocks = courseBlocksResult.status === 'fulfilled';
+
+      // Log errors for each request if needed. Course block failures may occur
+      // even if the course metadata request is successful
+      if (!fetchedBlocks) {
+        logError(courseBlocksResult.reason);
+      }
+      if (!fetchedMetadata) {
+        logError(courseMetadataResult.reason);
+      }
+
+      if (fetchedMetadata) {
+        if (courseMetadataResult.value.userHasAccess && fetchedBlocks) {
+          // User has access
+          dispatch(fetchCourseSuccess({ courseId }));
+          return;
+        }
+        // User either doesn't have access or only has partial access
+        // (can't access course blocks)
+        dispatch(fetchCourseDenied({ courseId }));
+        return;
+      }
+
+      // Definitely an error happening
       dispatch(fetchCourseFailure({ courseId }));
     });
   };