feat: auto setting active linked enterprise

src/components/EnterpriseApp/EnterpriseAppContextProvider.jsx

@@ -1,10 +1,12 @@
-import React, { createContext, useMemo } from 'react';
+import React, { createContext, useContext, useMemo } from 'react';
 import PropTypes from 'prop-types';
+import { AppContext } from '@edx/frontend-platform/react';
 
 import { EnterpriseSubsidiesContext, useEnterpriseSubsidiesContext } from '../EnterpriseSubsidiesContext';
 import { SubsidyRequestsContext, useSubsidyRequestsContext } from '../subsidy-requests/SubsidyRequestsContext';
 import {
  useEnterpriseCurationContext,
+ useUpdateActiveEnterpriseForUser,
 } from './data/hooks';
 import EnterpriseAppSkeleton from './EnterpriseAppSkeleton';
 
@@ -49,6 +51,7 @@ const EnterpriseAppContextProvider = ({
  enablePortalLearnerCreditManagementScreen,
  children,
 }) => {
+ const { authenticatedUser } = useContext(AppContext);
  // subsidies for the enterprise customer
  const enterpriseSubsidiesContext = useEnterpriseSubsidiesContext({
  enterpriseId,
@@ -68,10 +71,16 @@ const EnterpriseAppContextProvider = ({
  curationTitleForCreation: enterpriseName,
  });
 
+ const { isLoading: isUpdatingActiveEnterprise } = useUpdateActiveEnterpriseForUser({
+ enterpriseId,
+ user: authenticatedUser,
+ });
+
  const isLoading = (
  subsidyRequestsContext.isLoading
  || enterpriseSubsidiesContext.isLoading
  || enterpriseCurationContext.isLoading
+ || isUpdatingActiveEnterprise
  );
 
  // [tech debt] consolidate the other context values (e.g., useSubsidyRequestsContext)

src/components/EnterpriseApp/EnterpriseAppContextProvider.test.jsx

@@ -23,31 +23,43 @@ describe('<EnterpriseAppContextProvider />', () => {
  isLoadingEnterpriseSubsidies: true,
  isLoadingSubsidyRequests: false,
  isLoadingEnterpriseCuration: false,
+ isLoadingUpdateActiveEnterpriseForUser: false,
  },
  {
  isLoadingEnterpriseSubsidies: false,
  isLoadingSubsidyRequests: true,
  isLoadingEnterpriseCuration: false,
+ isLoadingUpdateActiveEnterpriseForUser: false,
  },
  {
  isLoadingEnterpriseSubsidies: false,
  isLoadingSubsidyRequests: false,
  isLoadingEnterpriseCuration: true,
+ isLoadingUpdateActiveEnterpriseForUser: false,
  },
  {
  isLoadingEnterpriseSubsidies: true,
  isLoadingSubsidyRequests: true,
  isLoadingEnterpriseCuration: false,
+ isLoadingUpdateActiveEnterpriseForUser: false,
+ },
+ {
+ isLoadingEnterpriseSubsidies: false,
+ isLoadingSubsidyRequests: false,
+ isLoadingEnterpriseCuration: false,
+ isLoadingUpdateActiveEnterpriseForUser: true,
  },
  {
  isLoadingEnterpriseSubsidies: true,
  isLoadingSubsidyRequests: true,
  isLoadingEnterpriseCuration: true,
+ isLoadingUpdateActiveEnterpriseForUser: true,
  },
  ])('renders <EnterpriseAppSkeleton /> when: %s', async ({
  isLoadingEnterpriseSubsidies,
  isLoadingSubsidyRequests,
  isLoadingEnterpriseCuration,
+ isLoadingUpdateActiveEnterpriseForUser,
  }) => {
  const mockUseEnterpriseSubsidiesContext = jest.spyOn(enterpriseSubsidiesContext, 'useEnterpriseSubsidiesContext').mockReturnValue({
  isLoading: isLoadingEnterpriseSubsidies,
@@ -62,6 +74,11 @@ describe('<EnterpriseAppContextProvider />', () => {
  isLoading: isLoadingEnterpriseCuration,
  },
  );
+ const mockUseUpdateActiveEnterpriseForUser = jest.spyOn(hooks, 'useUpdateActiveEnterpriseForUser').mockReturnValue(
+ {
+ isLoading: isLoadingUpdateActiveEnterpriseForUser,
+ },
+ );
 
  render(
  <EnterpriseAppContextProvider
@@ -75,11 +92,17 @@ describe('<EnterpriseAppContextProvider />', () => {
  );
 
  await waitFor(() => {
+ expect(mockUseUpdateActiveEnterpriseForUser).toHaveBeenCalled();
  expect(mockUseSubsidyRequestsContext).toHaveBeenCalled();
  expect(mockUseEnterpriseSubsidiesContext).toHaveBeenCalled();
  expect(mockUseEnterpriseCurationContext).toHaveBeenCalled();
 
- if (isLoadingEnterpriseSubsidies || isLoadingSubsidyRequests || isLoadingEnterpriseCuration) {
+ if (
+ isLoadingEnterpriseSubsidies
+ || isLoadingSubsidyRequests
+ || isLoadingEnterpriseCuration
+ || isLoadingUpdateActiveEnterpriseForUser
+ ) {
  expect(screen.getByText('Loading...'));
  } else {
  expect(screen.getByText('children'));

src/components/EnterpriseApp/data/hooks/index.js

@@ -1,2 +1,3 @@
 export { default as useEnterpriseCuration } from './useEnterpriseCuration';
 export { default as useEnterpriseCurationContext } from './useEnterpriseCurationContext';
+export { default as useUpdateActiveEnterpriseForUser } from './useUpdateActiveEnterpriseForUser';

src/components/EnterpriseApp/data/hooks/useUpdateActiveEnterpriseForUser.js

@@ -0,0 +1,40 @@
+import { useState, useEffect, useCallback } from 'react';
+import { logError } from '@edx/frontend-platform/logging';
+
+import LmsApiService from '../../../../data/services/LmsApiService';
+
+const useUpdateActiveEnterpriseForUser = ({
+ enterpriseId,
+ user,
+}) => {
+ const [isLoading, setIsLoading] = useState(false);
+
+ const updateActiveEnterpriseAndRefreshJWT = useCallback(async (username, currentEnterpriseId) => {
+ setIsLoading(true);
+ try {
+ await LmsApiService.getActiveLinkedEnterprise(username).then(async (linkedEnterpriseId) => {
+ if (linkedEnterpriseId !== currentEnterpriseId) {
+ await LmsApiService.updateUserActiveEnterprise(currentEnterpriseId);
+ await LmsApiService.loginRefresh();
+ }
+ });
+ } catch (error) {
+ logError(error);
+ } finally {
+ setIsLoading(false);
+ }
+ }, []);
+
+ useEffect(() => {
+ if (!(enterpriseId && user)) {
+ return;
+ }
+ const { username } = user;
+ updateActiveEnterpriseAndRefreshJWT(username, enterpriseId);
+ }, [enterpriseId, user, updateActiveEnterpriseAndRefreshJWT]);
+ return {
+ isLoading,
+ };
+};
+
+export default useUpdateActiveEnterpriseForUser;

src/components/EnterpriseApp/data/hooks/useUpdateActiveEnterpriseForUser.test.js

@@ -0,0 +1,78 @@
+import { renderHook } from '@testing-library/react-hooks';
+import { useUpdateActiveEnterpriseForUser } from './index';
+import LmsApiService from '../../../../data/services/LmsApiService';
+
+jest.mock('../../../../data/services/LmsApiService');
+
+describe('useUpdateActiveEnterpriseForUser', () => {
+ const mockEnterpriseId = 'enterprise-uuid';
+ const mockCurrentActiveEnterpriseId = 'current-active-enterprise-uuid';
+ const mockUser = {
+ roles: [
+ 'enterprise_admin:random-enterprise-uuid',
+ `enterprise_learner:${mockCurrentActiveEnterpriseId}`,
+ `enterprise_learner:${mockEnterpriseId}`,
+ ],
+ };
+ beforeEach(() => {
+ LmsApiService.getActiveLinkedEnterprise.mockResolvedValue('someID');
+ });
+
+ afterEach(() => jest.clearAllMocks());
+
+ it("should update user's active enterprise if it differs from the current enterprise", async () => {
+ const { result, waitForNextUpdate } = renderHook(() => useUpdateActiveEnterpriseForUser({
+ enterpriseId: mockEnterpriseId,
+ user: mockUser,
+ }));
+ expect(result.current.isLoading).toBe(true);
+
+ await waitForNextUpdate();
+
+ expect(LmsApiService.updateUserActiveEnterprise).toHaveBeenCalledTimes(1);
+ expect(result.current.isLoading).toBe(false);
+ });
+
+ it.each([
+ {
+ enterpriseId: undefined,
+ user: mockUser,
+ },
+ {
+ enterpriseId: mockEnterpriseId,
+ user: undefined,
+ },
+ {
+ enterpriseId: mockEnterpriseId,
+ user: {
+ roles: [`enterprise_learner:${mockEnterpriseId}`],
+ },
+ },
+ ])('should do nothing if missing enterpriseId or user, or active enterprise is the same as current enterprise', async (
+ {
+ enterpriseId,
+ user,
+ },
+ ) => {
+ renderHook(() => useUpdateActiveEnterpriseForUser({
+ enterpriseId,
+ user,
+ }));
+
+ expect(LmsApiService.updateUserActiveEnterprise).toHaveBeenCalledTimes(0);
+ });
+
+ it('should handle errors', async () => {
+ LmsApiService.updateUserActiveEnterprise.mockRejectedValueOnce(Error('uh oh'));
+ const { result, waitForNextUpdate } = renderHook(() => useUpdateActiveEnterpriseForUser({
+ enterpriseId: mockEnterpriseId,
+ user: mockUser,
+ }));
+ expect(result.current.isLoading).toBe(true);
+
+ await waitForNextUpdate();
+
+ expect(LmsApiService.updateUserActiveEnterprise).toHaveBeenCalledTimes(1);
+ expect(result.current.isLoading).toBe(false);
+ });
+});

src/data/services/LmsApiService.js

@@ -1,5 +1,6 @@
 import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
 import { camelCaseObject } from '@edx/frontend-platform/utils';
+import Cookies from 'universal-cookie';
 
 import { configuration } from '../../config';
 import generateFormattedStatusUrl from './apiServiceUtils';
@@ -384,6 +385,57 @@ class LmsApiService {
  const url = `${LmsApiService.baseUrl}/enterprise/api/v1/analytics-summary/${enterpriseUUID}`;
  return LmsApiService.apiClient().post(url, formData);
  }
+
+ static updateUserActiveEnterprise = (enterpriseId) => {
+ const url = `${configuration.LMS_BASE_URL}/enterprise/select/active/`;
+ const formData = new FormData();
+ formData.append('enterprise', enterpriseId);
+
+ return LmsApiService.apiClient().post(
+ url,
+ formData,
+ );
+ };
+
+ static loginRefresh = async () => {
+ const loginRefreshUrl = `${configuration.LMS_BASE_URL}/login_refresh/`;
+
+ try {
+ return LmsApiService.apiClient().post(loginRefreshUrl);
+ } catch (error) {
+ const isUserUnauthenticated = error.response?.status === 401;
+ if (isUserUnauthenticated) {
+ // Clean up the cookie if it exists to eliminate any situation
+ // where the cookie is not expired but the jwt is expired.
+ const cookies = new Cookies();
+ cookies.remove(configuration.ACCESS_TOKEN_COOKIE_NAME);
+ }
+ return Promise.resolve();
+ }
+ };
+
+ static fetchEnterpriseLearnerData(options) {
+ const enterpriseLearnerUrl = `${configuration.LMS_BASE_URL}/enterprise/api/v1/enterprise-learner/`;
+ const queryParams = new URLSearchParams({
+ ...options,
+ page: 1,
+ });
+ const url = `${enterpriseLearnerUrl}?${queryParams.toString()}`;
+ return LmsApiService.apiClient().get(url);
+ }
+
+ static getActiveLinkedEnterprise(username) {
+ return this.fetchEnterpriseLearnerData({ username }).then((response) => {
+ const { data } = response;
+ const results = data?.results;
+ for (let i = 0; i < results.length; i++) {
+ if (results[i].active) {
+ return results[i].uuid;
+ }
+ }
+ return '';
+ });
+ }
 }
 
 export default LmsApiService;