fix: ensure redirects to active EnterpriseCustomerUser, where appropriate; otherwise, show 404 (#1327)

Author: adamstankiewicz

src/components/app/data/queries/utils.js

@@ -38,15 +38,7 @@ export function resolveBFFQuery(pathname) {
  * @param enterpriseSlug
  * @param authenticatedUser
  * @param queryEnterpriseLearnerConfig
- * @returns {
- * Promise<{
- * enterpriseCustomer,
- * activeEnterpriseCustomer,
- * allLinkedEnterpriseCustomerUsers,
- * staffEnterpriseCustomer,
- * enterpriseFeatures: *,
- * shouldUpdateActiveEnterpriseCustomerUser: *
- * }|*>}
+ * @returns {Promise<{ data: Types.EnterpriseLearnerData, isBFFData: boolean }>}
  */
 export async function getEnterpriseLearnerQueryData({
   requestUrl,

src/components/app/data/services/enterpriseCustomerUser.test.js

@@ -164,7 +164,7 @@ describe('fetchEnterpriseLearnerData', () => {
           enterpriseCustomer: expectedEnterpriseCustomer,
         }))
         .filter((ecu) => ecu.enterpriseCustomer),
-      staffEnterpriseCustomer: isStaffUser ? expectedEnterpriseCustomer : undefined,
+      staffEnterpriseCustomer: isStaffUser ? expectedEnterpriseCustomer : null,
       shouldUpdateActiveEnterpriseCustomerUser: false,
     });
   });

src/components/app/data/services/enterpriseCustomerUser.ts

@@ -74,13 +74,13 @@ Promise<Types.EnterpriseLearnerData> {
     const { enterpriseFeatures } = enterpriseCustomerUsersResponse;
     // Transform enterprise customer user results
     const transformedEnterpriseCustomersUsers = enterpriseCustomersUsers
+      .filter(enterpriseCustomerUser => !!enterpriseCustomerUser.enterpriseCustomer.enableLearnerPortal)
       .map(
         enterpriseCustomerUser => ({
           ...enterpriseCustomerUser,
           enterpriseCustomer: transformEnterpriseCustomer(enterpriseCustomerUser.enterpriseCustomer),
         }),
-      )
-      .filter(enterpriseCustomerUser => !!enterpriseCustomerUser.enterpriseCustomer);
+      );
 
     const activeLinkedEnterpriseCustomerUser = transformedEnterpriseCustomersUsers.find(
       enterpriseCustomerUser => enterpriseCustomerUser.active,
@@ -91,17 +91,17 @@ Promise<Types.EnterpriseLearnerData> {
     // Find enterprise customer metadata for the currently viewed
     // enterprise slug in the page route params.
     const foundEnterpriseCustomerUserForCurrentSlug = transformedEnterpriseCustomersUsers.find(
-      enterpriseCustomerUser => enterpriseCustomerUser.enterpriseCustomer?.slug === enterpriseSlug,
+      enterpriseCustomerUser => enterpriseCustomerUser.enterpriseCustomer.slug === enterpriseSlug,
     );
 
     // If no enterprise customer is found (i.e., authenticated user not explicitly
     // linked), but the authenticated user is staff, attempt to retrieve enterprise
     // customer metadata from the `/enterprise-customer` LMS API.
-    let staffEnterpriseCustomer;
+    let staffEnterpriseCustomer: Types.EnterpriseCustomer | null = null;
     if (getAuthenticatedUser().administrator && enterpriseSlug && !foundEnterpriseCustomerUserForCurrentSlug) {
-      const originalStaffEnterpriseCustomer = await fetchEnterpriseCustomerForSlug(enterpriseSlug);
-      if (originalStaffEnterpriseCustomer) {
-        staffEnterpriseCustomer = transformEnterpriseCustomer(originalStaffEnterpriseCustomer);
+      const staffEnterpriseCustomerResult = await fetchEnterpriseCustomerForSlug(enterpriseSlug);
+      if (staffEnterpriseCustomerResult?.enableLearnerPortal) {
+        staffEnterpriseCustomer = transformEnterpriseCustomer(staffEnterpriseCustomerResult);
       }
     }
 

src/components/app/data/utils.js

@@ -272,12 +272,6 @@ export function getAssignmentsByState(assignments = []) {
  * @returns
  */
 export function transformEnterpriseCustomer(enterpriseCustomer) {
-  // If the learner portal is not enabled for the displayed enterprise customer, return null. This
-  // results in the enterprise learner portal not being accessible for the user, showing a 404 page.
-  // This logic needs to be maintained for individuals checks against the enterprise customer for staff users
-  if (!enterpriseCustomer.enableLearnerPortal) {
-    return null;
-  }
   // Otherwise, learner portal is enabled, so transform the enterprise customer data.
   const disableSearch = !!(
     !enterpriseCustomer.enableIntegratedCustomerLearnerPortalSearch

src/components/app/routes/data/utils.js

@@ -273,8 +273,10 @@ export async function ensureActiveEnterpriseCustomerUser({
     allLinkedEnterpriseCustomerUsers,
   } = enterpriseLearnerData;
   const {
+    staffEnterpriseCustomer,
     shouldUpdateActiveEnterpriseCustomerUser,
   } = enterpriseLearnerData;
+
   const matchedBFFQuery = resolveBFFQuery(requestUrl.pathname);
   // If the enterprise slug in the URL matches the active enterprise customer user's slug OR no
   // active enterprise customer exists, return early.
@@ -310,9 +312,8 @@ export async function ensureActiveEnterpriseCustomerUser({
     try {
       await updateUserActiveEnterprise({ enterpriseCustomer: nextActiveEnterpriseCustomer });
     } catch (error) {
-      logError(`Unable to update active enterprise customer: ${nextActiveEnterpriseCustomer}
-      for user ${authenticatedUser.userId}
-      ${error.message}`);
+      error.message = `Unable to update active enterprise customer: ${nextActiveEnterpriseCustomer} for user ${authenticatedUser.userId}: ${error.message}`;
+      logError(error);
       return {
         enterpriseCustomer,
         allLinkedEnterpriseCustomerUsers,
@@ -345,13 +346,21 @@ export async function ensureActiveEnterpriseCustomerUser({
     };
   }
 
+  if (staffEnterpriseCustomer) {
+    return {
+      enterpriseCustomer: staffEnterpriseCustomer,
+      allLinkedEnterpriseCustomerUsers,
+    };
+  }
+
   // Given the user has an active ECU, but the current route has no slug, redirect to the slug of the active ECU.
-  if (activeEnterpriseCustomer && !enterpriseSlug) {
+  if (activeEnterpriseCustomer && activeEnterpriseCustomer.slug !== enterpriseSlug) {
     throw redirect(generatePath('/:enterpriseSlug/*', {
       enterpriseSlug: activeEnterpriseCustomer.slug,
       '*': requestUrl.pathname.split('/').filter(pathPart => !!pathPart).slice(1).join('/'),
     }));
   }
+
   return {
     enterpriseCustomer,
     allLinkedEnterpriseCustomerUsers,

src/components/app/routes/data/utils.test.js

@@ -16,14 +16,6 @@ jest.mock('../../data', () => ({
 }));
 
 describe('transformEnterpriseCustomer', () => {
-  it('returns null with disabled learner portal', () => {
-    const enterpriseCustomer = {
-      enableLearnerPortal: false,
-    };
-    const result = transformEnterpriseCustomer(enterpriseCustomer);
-    expect(result).toBeNull();
-  });
-
   it.each([
     {
       identityProvider: undefined,

src/components/app/routes/loaders/rootLoader.ts

@@ -39,7 +39,7 @@ const makeRootLoader: Types.MakeRouteLoaderFunctionWithQueryClient = function ma
     });
 
     // User has no active, linked enterprise customer and no staff-only customer metadata exists; return early.
-    if (!enterpriseLearnerData.enterpriseCustomer) {
+    if (!enterpriseLearnerData.enterpriseCustomer && !enterpriseLearnerData.activeEnterpriseCustomer) {
       return null;
     }