fix: sentry issues

src/App.tsx

@@ -180,41 +180,49 @@ export default function App() {
         }
     }, [])
 
-    const serviceWorkerTimeout = (()=> {
-        const parsedTimeout = parseInt(window._env_.SERVICE_WORKER_TIMEOUT, 10)
-
+    const serviceWorkerTimeout = (() => {
+        const parsedTimeout = parseInt(window._env_.SERVICE_WORKER_TIMEOUT, 10);
+      
         if (parsedTimeout) {
-            return parsedTimeout
+          return parsedTimeout;
         }
-
-        return 1
-    })()
-
-    const {
+      
+        return 1;
+      })();
+      
+      const {
         needRefresh: [needRefresh],
         updateServiceWorker,
-    } = useRegisterSW({
+      } = useRegisterSW({
         onRegisteredSW(swUrl, r) {
-            console.log(`Service Worker at: ${swUrl}`)
-            r &&
-                setInterval(async () => {
-                    if (!(!r.installing && navigator)) return
-                    if ('connection' in navigator && !navigator.onLine) return
-                    const resp = await fetch(swUrl, {
-                        cache: 'no-store',
-                        headers: {
-                            cache: 'no-store',
-                            'cache-control': 'no-cache',
-                        },
-                    })
-
-                    if (resp?.status === 200) await r.update()
-                }, serviceWorkerTimeout * 1000 * 60)
+          console.log(`Service Worker at: ${swUrl}`);
+          if (r) {
+            setInterval(async () => {
+              if (!r.installing && navigator) {
+                if ('connection' in navigator && !navigator.onLine) return;
+
+                try {                                                                   //added try and catch for error handling
+                  const resp = await fetch(swUrl, {
+                    cache: 'no-store',
+                    headers: {
+                      cache: 'no-store',
+                      'cache-control': 'no-cache',
+                    },
+                  });
+
+                  if (resp?.status === 200) await r.update();
+                } catch (error) {
+                  console.error('Error updating service worker:', error);
+                }
+              }
+            }, serviceWorkerTimeout * 1000 * 60);
+          }
         },
         onRegisterError(error) {
-            console.log('SW registration error', error)
+          console.log('SW registration error', error);
         },
-    })
+      });
+
 
     function update() {
         updateServiceWorker(true)

src/components/ClusterNodes/ClusterTerminal.tsx

@@ -535,7 +535,7 @@ const ClusterTerminal = ({
             `user/terminal/get?namespace=${selectedNamespace.value}&shellName=${
                 selectedTerminalType.value
             }&terminalAccessId=${terminalAccessIdRef.current}&containerName=${
-                resourceData?.containers?.[0].containerName || ''
+                resourceData?.containers?.[0]?.containerName || '' //  this is the extra check for the case when we have no containers in the pod
             }`,
             terminalAccessIdRef.current,
             window?._env_?.CLUSTER_TERMINAL_CONNECTION_RETRY_COUNT || 7,

src/components/EnvironmentOverride/DeploymentTemplateOverride.tsx

@@ -92,12 +92,18 @@ export default function DeploymentTemplateOverride({
 
     useEffect(() => {
         const fetchOptionsList = async () => {
-            const { result } = await getOptions(+appId, +envId)
-            const _groupedData = groupDataByType(result)
-            setGroupedOptionsDataOverride(_groupedData)
-        }
-        fetchOptionsList()
-    }, [environments])
+          try {                                                     //adding try and catch block to handle error 
+            const { result } = await getOptions(+appId, +envId);
+            const _groupedData = groupDataByType(result);
+            setGroupedOptionsDataOverride(_groupedData);
+          } catch (error) {
+            console.error('Error fetching options:', error);
+            // You can also display an error message to the user or take any other necessary action
+          }
+        };
+
+        fetchOptionsList();
+      }, [environments]);
 
     useEffect(() => {
         dispatch({ type: DeploymentConfigStateActionTypes.reset })

src/components/app/Overview/Overview.tsx

@@ -306,7 +306,7 @@ export default function AppOverview({ appMetaInfo, getAppMetaInfoRes, filteredEn
                             {createdBy}
                         </div>
                     </div>
-                    {appType === 'app' && gitMaterials.length > 0 && (
+                    {appType === 'app' && gitMaterials && gitMaterials.length > 0 && (
                         <div>
                             <div className="fs-13 fw-4 lh-20 cn-7 mb-4">Code source</div>
                             <div className="flexbox-col dc__gap-4">

src/components/app/details/appConfig/AppConfig.tsx

@@ -175,7 +175,7 @@ export default function AppConfig({ appName, isJobView, filteredEnvIds }: AppCon
             setState((prevState) => {
                 return {
                     ...prevState,
-                    canDeleteApp: response.result.workflows.length === 0,
+                    canDeleteApp: response.result.workflows?.length === 0,//# here is the extra check
                     workflowsRes: response.result,
                 }
             })

src/components/app/details/appDetails/AppDetails.tsx

@@ -539,6 +539,7 @@ export const Details: React.FC<DetailsType> = ({
     }, [isPollingRequired])
 
     async function handleHibernate(e) {
+
         try {
             setHibernating(true)
             const isUnHibernateReq = ['hibernating', 'hibernated'].includes(

src/components/app/details/main.tsx

@@ -88,65 +88,88 @@ export default function AppDetailsPage({ isV2 }: AppDetailsProps) {
     }, [appId])
 
     const getSavedFilterData = async (groupId?: number): Promise<void> => {
-        setSelectedAppList([])
-        setAppListLoading(true)
-        setGroupFilterOptions([])
-        const { result } = await getEnvGroupList(+appId, FilterParentType.app)
-        if (result) {
-            const _groupFilterOption = []
-            let _selectedGroup
+        setSelectedAppList([]);
+        setAppListLoading(true);
+        setGroupFilterOptions([]);
+
+        try {
+          const { result } = await getEnvGroupList(+appId, FilterParentType.app);
+
+          if (result) {
+            const _groupFilterOption = [];
+            let _selectedGroup;
+
             for (const group of result) {
-                const processedGroupData = {
-                    value: group.id.toString(),
-                    label: group.name,
-                    // @ts-ignore
-                    appIds: group.resourceIds,
-                    description: group.description,
-                }
-                _groupFilterOption.push(processedGroupData)
-                if (groupId && groupId === group.id) {
-                    _selectedGroup = processedGroupData
-                }
+              const processedGroupData = {
+                value: group.id.toString(),
+                label: group.name,
+                // @ts-ignore
+                appIds: group.resourceIds,
+                description: group.description,
+              };
+
+              _groupFilterOption.push(processedGroupData);
+
+              if (groupId && groupId === group.id) {
+                _selectedGroup = processedGroupData;
+              }
             }
+
             if (_selectedGroup) {
-                const selectedAppsMap: Record<string, boolean> = {}
-                const groupAppIds = _selectedGroup?.appIds || []
-                for (const appId of groupAppIds) {
-                    selectedAppsMap[appId] = true
-                }
-                setSelectedAppList(appListOptions.filter((app) => selectedAppsMap[app.value]))
-                setSelectedGroupFilter([_selectedGroup])
+              const selectedAppsMap: Record<string, boolean> = {};
+              const groupAppIds = _selectedGroup?.appIds || [];
+
+              for (const appId of groupAppIds) {
+                selectedAppsMap[appId] = true;
+              }
+
+              setSelectedAppList(appListOptions.filter((app) => selectedAppsMap[app.value]));
+              setSelectedGroupFilter([_selectedGroup]);
             } else {
-                setSelectedAppList([])
-                setSelectedGroupFilter([])
+              setSelectedAppList([]);
+              setSelectedGroupFilter([]);
             }
-            _groupFilterOption.sort(sortOptionsByLabel)
-            setGroupFilterOptions(_groupFilterOption)
+
+            _groupFilterOption.sort(sortOptionsByLabel);
+            setGroupFilterOptions(_groupFilterOption);
+          }
+        } catch (error) {
+          console.error('Error fetching environment group list:', error);
+          // Handle the error appropriately, e.g., show an error message to the user
+        } finally {
+          setAppListLoading(false);
         }
-        setAppListLoading(false)
-    }
+      };
+      
 
-    const getAppListData = async (): Promise<void> => {
-        setSelectedAppList([])
-        setAppListLoading(true)
-        const { result } = await getAppOtherEnvironmentMin(appId)
-        if (result?.length) {
+      const getAppListData = async (): Promise<void> => {
+        setSelectedAppList([]);
+        setAppListLoading(true);                                                            
+        try {                                                   //added try and catch block for error handling
+          const { result } = await getAppOtherEnvironmentMin(appId);
+
+          if (result?.length) {
             setAppListOptions(
-                result
-                    .map((app): OptionType => {
-                        return {
-                            value: `${app.environmentId}`,
-                            label: app.environmentName,
-                        }
-                    })
-                    .sort(sortOptionsByLabel),
-            )
+              result
+                .map((app): OptionType => {
+                  return {
+                    value: `${app.environmentId}`,
+                    label: app.environmentName,
+                  };
+                })
+                .sort(sortOptionsByLabel)
+            );
+          }
+        } catch (error) {
+          console.error('Error fetching app list data:', error);
+          // You can also display an error message to the user or take any other necessary action
+        } finally {
+          setAppListLoading(false);
         }
-        setAppListLoading(false)
-    }
+      };
 
     const getAppMetaInfoRes = async (): Promise<AppMetaInfo> => {
-        try {
+        try {                                                     //added try and catch block
             const { result } = await getAppMetaInfo(Number(appId))
             if (result) {
                 setAppName(result.appName)

src/components/common/helpers/Helpers.tsx

@@ -1194,7 +1194,10 @@ export const getDeploymentAppType = (
     return allowedDeploymentTypes[0]
 }
 
-export const hasApproverAccess = (email: string, approverList: string[]): boolean => {
+export const hasApproverAccess = (email: string = '', approverList: string[]= []): boolean => {// added null check for email and approverList
+    if(!email ||!approverList) {
+        return false
+    }
     let hasAccess = false
     if (approverList?.length > 0) {
         for (const approver of approverList) {