From ee2d44b5fca3b3512b1620a0c7d7e7a5847a9716 Mon Sep 17 00:00:00 2001
From: Pramod Mahajan <pramodmahajan1411200@gmail.com>
Date: Wed, 30 Apr 2025 00:03:08 +0530
Subject: [PATCH] fixed useEmployeeRoles to return [] when employee has no
 roles and some changed  for fetching logic to use async/await

---
 src/hooks/useEmployees.js | 302 +++++++++++++++++---------------------
 1 file changed, 134 insertions(+), 168 deletions(-)

diff --git a/src/hooks/useEmployees.js b/src/hooks/useEmployees.js
index b48ac9bd..4a127fef 100644
--- a/src/hooks/useEmployees.js
+++ b/src/hooks/useEmployees.js
@@ -4,185 +4,159 @@ import { RolesRepository } from "../repositories/MastersRepository";
 import EmployeeRepository from "../repositories/EmployeeRepository";
 import ProjectRepository from "../repositories/ProjectRepository";
 
-
-export const useAllEmployees = () =>
-{
+export const useAllEmployees = () => {
   const [employeesList, setEmployeeList] = useState([]);
-  const [ loading, setLoading ] = useState( false )
-  const [ error, setError ] = useState() 
-  
-  const fetchData = async () =>
-  
-  {
-      try
-      {
-        let EmployeeList_cached = getCachedData( "AllEmployees" )
-        if ( ! EmployeeList_cached )
-        {
-          setLoading(true)
-          const response = await EmployeeRepository.getAllEmployeeList();
-          cacheData( "AllEmployees", response.data )
-          setEmployeeList(response.data)
-        } else
-        {
-          setEmployeeList( EmployeeList_cached )  
-          setLoading(false)
-        }   
-      } catch ( error )
-      {
-          console.error(error);
-        setError( "Failed to fetch data." ); 
-        setLoading(false)
-        
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState();
+
+  const fetchData = async () => {
+    try {
+      let EmployeeList_cached = getCachedData("AllEmployees");
+      if (!EmployeeList_cached) {
+        setLoading(true);
+        const response = await EmployeeRepository.getAllEmployeeList();
+        cacheData("AllEmployees", response.data);
+        setEmployeeList(response.data);
+      } else {
+        setEmployeeList(EmployeeList_cached);
+        setLoading(false);
       }
-  }
-  
+    } catch (error) {
+      setError("Failed to fetch data.");
+      setLoading(false);
+    }
+  };
 
-  useEffect( () =>
-  {
-    fetchData()
-  }, [] )
-  return {employeesList,loading,error}
-}
-
-export const useEmployees =(selectedProject)=>{
+  useEffect(() => {
+    fetchData();
+  }, []);
+  return { employeesList, loading, error };
+};
 
+export const useEmployees = (selectedProject) => {
   const [employees, setEmployeeList] = useState([]);
-  const[loading,setLoading] = useState(true)
+  const [loading, setLoading] = useState(true);
   const [projects, setProjects] = useState([]);
 
-   const fetchData = async (projectid) => {
-       try {
-             let EmployeeByProject_Cache = getCachedData("employeeListByProject")
-          if(!EmployeeByProject_Cache || !EmployeeByProject_Cache.projectId === projectid) {
-          
-            EmployeeRepository.getEmployeeListByproject(projectid)
-              .then((response) => {
-                setEmployeeList(response);
-                cacheData("employeeListByProject",{data:response,projectId:projectid});
-              })
-              .catch((error) => {
-                setError("Failed to fetch data.");
-              });
-            
-          }else{
-               setEmployeeList(EmployeeByProject_Cache.data)
-          
-         }
-         setLoading(false)
-       
-       } catch (err) {
-         setError("Failed to fetch data.");
-         setLoading(false)
-       }
-    };
-
-
-  useEffect(()=>{
-   if(selectedProject){
-    fetchData(selectedProject);
-   }
-  },[selectedProject])
-
-
-  return {employees,loading,projects,reCallAllEmployee}
-}
-
-export const useEmployeeRoles = (employeeId)=>{
-  const [loading,setLoading] = useState(true)
-  const[error, setError] =useState()
-  const [employeeRoles,setEmployeeRoles] = useState([])
-  const fetchData = async (employeeid) => {
-    
+  const fetchData = async (projectid) => {
     try {
-      RolesRepository.getEmployeeRoles(employeeid)
-        .then((response) => {
-          setEmployeeRoles(response.data);
-          cacheData("employeelist", response.data);
-        })
-        .catch((error) => {
-          setError("Failed to fetch data.");
-        });
+      let EmployeeByProject_Cache = getCachedData("employeeListByProject");
+      if (
+        !EmployeeByProject_Cache ||
+        !EmployeeByProject_Cache.projectId === projectid
+      ) {
+        EmployeeRepository.getEmployeeListByproject(projectid)
+          .then((response) => {
+            setEmployeeList(response);
+            cacheData("employeeListByProject", {
+              data: response,
+              projectId: projectid,
+            });
+          })
+          .catch((error) => {
+            setError("Failed to fetch data.");
+          });
+      } else {
+        setEmployeeList(EmployeeByProject_Cache.data);
+      }
+      setLoading(false);
     } catch (err) {
       setError("Failed to fetch data.");
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    if (selectedProject) {
+      fetchData(selectedProject);
+    }
+  }, [selectedProject]);
+
+  return { employees, loading, projects, reCallAllEmployee };
+};
+
+export const useEmployeeRoles = (employeeId) => {
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState();
+  const [employeeRoles, setEmployeeRoles] = useState([]);
+  const fetchData = async (employeeid) => {
+    try {
+      let response = await RolesRepository.getEmployeeRoles(employeeid);
+      setEmployeeRoles(response.data);
+      cacheData("employeelist", response.data);
+    } catch (err) {
+      setError("Failed to fetch data.");
+      setEmployeeRoles([]);
     } finally {
       setLoading(false);
     }
- };
+  };
 
+  useEffect(() => {
+    if (employeeId) {
+      fetchData(employeeId);
+    }
+  }, [employeeId]);
 
-  useEffect( () =>
-  {
-    if ( employeeId )
-    {
-       fetchData(employeeId);
-      
-   }
-},[employeeId])
+  return { employeeRoles, loading, error };
+};
 
-
-return {employeeRoles,loading,error}
-}
-
-
-export const useEmployeesByProject=(projectId)=>{
-  const [loading,setLoading] = useState(false)
-  const[error, setError] =useState()
-  const [employees,setEmployees] = useState([])
+export const useEmployeesByProject = (projectId) => {
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState();
+  const [employees, setEmployees] = useState([]);
 
   const fetchData = async () => {
     const Employees_cache = getCachedData("employeeListByProject");
-    if(!Employees_cache || Employees_cache.projectId !== projectId){
-           
-        setEmployees(true)
-        ProjectRepository.getEmployeesByProject(projectId)
-          .then( ( response ) =>
-          {
+    if (!Employees_cache || Employees_cache.projectId !== projectId) {
+      setEmployees(true);
+      ProjectRepository.getEmployeesByProject(projectId)
+        .then((response) => {
           setEmployees(response.data);
-          cacheData("employeeListByProject", { data: response.data, projectId })
-          setLoading(false)
+          cacheData("employeeListByProject", {
+            data: response.data,
+            projectId,
+          });
+          setLoading(false);
         })
         .catch((error) => {
           setError("Failed to fetch data.");
-          setLoading(false)
+          setLoading(false);
         });
-      
-      }else{
-        setEmployees(Employees_cache.data)
-        setLoading(false)
-      }
+    } else {
+      setEmployees(Employees_cache.data);
+      setLoading(false);
+    }
   };
 
+  useEffect(() => {
+    fetchData(projectId);
+  }, [projectId]);
 
- useEffect(()=>{
-  fetchData(projectId);
-},[projectId])
-
-return {employees,loading,error,recallProjectEmplloyee:fetchData}
-
-}
-
-
+  return { employees, loading, error, recallProjectEmplloyee: fetchData };
+};
 
 export const useEmployeesAllOrByProjectId = (projectId) => {
   const [employees, setEmployees] = useState([]);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState(null);
 
-  const fetchData = async () =>
-  {
-  
+  const fetchData = async () => {
     if (projectId) {
-      
       const Employees_cache = getCachedData("employeeListByProject");
 
       if (!Employees_cache || Employees_cache.projectId !== projectId) {
         setLoading(true);
-        setError(null); 
+        setError(null);
         try {
-          const response = await ProjectRepository.getEmployeesByProject(projectId);
+          const response = await ProjectRepository.getEmployeesByProject(
+            projectId
+          );
           setEmployees(response.data);
-          cacheData("employeeListByProject", { data: response.data, projectId });
+          cacheData("employeeListByProject", {
+            data: response.data,
+            projectId,
+          });
           setLoading(false);
         } catch (err) {
           setError("Failed to fetch data.");
@@ -193,7 +167,6 @@ export const useEmployeesAllOrByProjectId = (projectId) => {
         setLoading(false);
       }
     } else {
-      
       const employeesCache = getCachedData("allEmployeeList");
 
       if (!employeesCache) {
@@ -228,42 +201,35 @@ export const useEmployeesAllOrByProjectId = (projectId) => {
   };
 };
 
-
-
-
-
-export const useEmployeeProfile =(employeeId)=>{
-  const [loading,setLoading] = useState(true)
-  const[error, setError] =useState()
-  const [employee,setEmployees] = useState()
+export const useEmployeeProfile = (employeeId) => {
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState();
+  const [employee, setEmployees] = useState();
 
   const fetchData = async () => {
     const Employee_cache = getCachedData("employeeProfile");
-    if(!Employee_cache || Employee_cache.employeeId !== employeeId){
-
-        EmployeeRepository.getEmployeeProfile(employeeId)
+    if (!Employee_cache || Employee_cache.employeeId !== employeeId) {
+      EmployeeRepository.getEmployeeProfile(employeeId)
         .then((response) => {
           setEmployees(response.data);
-          cacheData("employeeProfile", { data: response.data, employeeId })
-          setLoading(false)
+          cacheData("employeeProfile", { data: response.data, employeeId });
+          setLoading(false);
         })
         .catch((error) => {
           setError("Failed to fetch data.");
-          setLoading(false)
+          setLoading(false);
         });
-      
-      }else{
-        setEmployees(Employee_cache.data)
-        setLoading(false)
-      }
- };
+    } else {
+      setEmployees(Employee_cache.data);
+      setLoading(false);
+    }
+  };
 
- useEffect(()=>{
-  if(employeeId){
-    fetchData(employeeId);
-  }
-},[employeeId])
+  useEffect(() => {
+    if (employeeId) {
+      fetchData(employeeId);
+    }
+  }, [employeeId]);
 
-return {employee,loading,error}
-
-}
\ No newline at end of file
+  return { employee, loading, error };
+};