feat: sync quartzOrganizations thunks to new API layer for new quartz organizations routes (#5251)

Author: wdoconnell

src/identity/components/GlobalHeader/GlobalHeader.tsx

@@ -45,8 +45,10 @@ export const GlobalHeader: FC = () => {
   const [activeAccount, setActiveAccount] = useState(emptyAccount)
 
   useEffect(() => {
-    dispatch(getQuartzOrganizationsThunk())
-  }, [dispatch])
+    if (activeAccount.id !== emptyAccount.id) {
+      dispatch(getQuartzOrganizationsThunk(activeAccount.id))
+    }
+  }, [dispatch, activeAccount.id])
 
   useEffect(() => {
     if (accountsList[0].id !== 0) {

src/identity/quartzOrganizations/actions/thunks/index.ts

@@ -1,7 +1,10 @@
 import {Dispatch} from 'react'
 
 // API
-import {fetchQuartzOrgs, updateDefaultQuartzOrg} from 'src/identity/apis/auth'
+import {
+  fetchOrgsByAccountID,
+  updateDefaultOrgByAccountID,
+} from 'src/identity/apis/auth'
 
 // Actions
 import {
@@ -13,73 +16,92 @@ import {
 import {PublishNotificationAction} from 'src/shared/actions/notifications'
 
 // Types
-import {GetState, RemoteDataState} from 'src/types'
+import {AppThunk, GetState, RemoteDataState} from 'src/types'
 import {OrganizationSummaries} from 'src/client/unityRoutes'
-
 type Actions = QuartzOrganizationActions | PublishNotificationAction
 type DefaultOrg = OrganizationSummaries[number]
 
-class OrgNotFoundError extends Error {
+interface UpdateOrgParams {
+  accountId: number
+  newDefaultOrg: DefaultOrg
+}
+
+// Utils
+import {reportErrorThroughHoneyBadger} from 'src/shared/utils/errors'
+
+export enum OrganizationThunkErrors {
+  DefaultOrgStateError = 'DefaultOrgStateError',
+  DefaultOrgNetworkError = 'DefaultOrgNetworkError',
+}
+
+export class DefaultOrgStateError extends Error {
   constructor(message) {
     super(message)
-    this.name = 'DefaultOrgNotFoundError'
+    this.name = OrganizationThunkErrors.DefaultOrgStateError
   }
 }
 
-// Error Reporting
-import {reportErrorThroughHoneyBadger} from 'src/shared/utils/errors'
+export class DefaultOrgNetworkError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = OrganizationThunkErrors.DefaultOrgNetworkError
+  }
+}
 
-export const getQuartzOrganizationsThunk = () => async (
+// Thunks
+export const getQuartzOrganizationsThunk = (accountId: number) => async (
   dispatch: Dispatch<Actions>,
   getState: GetState
 ) => {
   try {
     dispatch(setQuartzOrganizationsStatus(RemoteDataState.Loading))
-    const quartzOrganizations = await fetchQuartzOrgs()
+
+    const quartzOrganizations = await fetchOrgsByAccountID(accountId)
 
     dispatch(setQuartzOrganizations(quartzOrganizations))
   } catch (err) {
-    dispatch(setQuartzOrganizationsStatus(RemoteDataState.Error))
-
     reportErrorThroughHoneyBadger(err, {
       name: 'Failed to fetch /quartz/orgs/',
       context: {state: getState()},
     })
   }
 }
 
-export const updateDefaultOrgThunk = (newDefaultOrg: DefaultOrg) => async (
+export const updateDefaultOrgThunk = ({
+  accountId,
+  newDefaultOrg,
+}: UpdateOrgParams): AppThunk<Promise<void>> => async (
   dispatch: Dispatch<Actions>,
   getState: GetState
-) => {
+): Promise<void> => {
   try {
     dispatch(setQuartzOrganizationsStatus(RemoteDataState.Loading))
 
-    await updateDefaultQuartzOrg(newDefaultOrg.id)
+    await updateDefaultOrgByAccountID({
+      accountNum: accountId,
+      orgId: newDefaultOrg.id,
+    })
 
     dispatch(setQuartzDefaultOrg(newDefaultOrg.id))
 
     const state = getState()
     const orgStatus = state.identity.currentIdentity.status
 
     if (orgStatus === RemoteDataState.Error) {
-      const defaultOrgErrMsg =
-        'quartzOrganizations state does not contain requested default organization'
-
-      reportErrorThroughHoneyBadger(new OrgNotFoundError(defaultOrgErrMsg), {
-        name: defaultOrgErrMsg,
-        context: {
-          org: newDefaultOrg,
-          state: getState(),
-        },
-      })
+      throw new DefaultOrgStateError(
+        OrganizationThunkErrors.DefaultOrgStateError
+      )
     }
   } catch (err) {
-    dispatch(setQuartzOrganizationsStatus(RemoteDataState.Error))
-
     reportErrorThroughHoneyBadger(err, {
-      name: 'Failed to update /quartz/orgs/default',
-      context: {state: getState()},
+      name: err.name,
+      context: {
+        message: err.message,
+        org: newDefaultOrg,
+        state: getState(),
+      },
     })
+
+    throw Error(err)
   }
 }