BhawanSingh
/
va-tracker
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

solve the tracking stop issue and also timmer is run with alert window show changes in dashbpardlayout and useActiveApptracker hooks

This commit is contained in:
JaiPandey425 2025-12-04 17:20:41 +05:30
parent f5f94f016b
commit e4eb851bc1
6 changed files with 281 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/electron/api/axiosClient.ts
View File

@ -13,7 +13,7 @@ const httpsAgent = new https.Agent({
const api: AxiosInstance = axios.create({
// https://dreadingly-unfighting-pandora.ngrok-free.dev/
baseURL: 'https://dreadingly-unfighting-pandora.ngrok-free.dev/api/v1/va', // 🔁 your backend
baseURL: 'https://daniela-nonprofessed-boastfully.ngrok-free.app/api/v1/va', // 🔁 your backend
httpsAgent
// timeout: 10000,
});
@ -42,7 +42,7 @@ api.interceptors.request.use(
api.interceptors.response.use(
(response: AxiosResponse) => response.data,
async (error) => {
// console.error('[Axios Error]', error.message);
console.error('[Axios Error]', error.message);
if (error.response?.status === 401 || 403) {
console.warn('Token expired — trigger refresh logic if needed');
sendTokenExpired();

21
src/electron/ipc/ipcHandler.ts
View File

@ -405,11 +405,10 @@ ipcMain.handle("get-payslips", async (event, vaId: string) => {
console.log("get-payslips", vaId)
try {
const response = await api.get(`/paySlip/${vaId}`);
console.log(response.data , "Line 409")
return {
success: true,
data: response.data?.data || [],
data: response.data || [],
};
} catch (error: any) {
let message = "Unknown error occurred";
@ -439,10 +438,10 @@ ipcMain.handle("get-leave-list", async () => {
const res = await api.get("/leaves/all");
console.log("/leaves/all", res.data);
return {
success: true,
data: res.data,
};
return {
success: true,
data: res.data,
};
} catch (error: any) {
let message = "Unknown error occurred";
@ -468,10 +467,10 @@ ipcMain.handle("get-adjustments-list", async (event, vaId: string) => {
const res = await api.get(`/timesheet/adjustments/list?vaId=${vaId}`);
console.log("/timesheet/adjustments/list", res.data);
return {
success: true,
data: res.data,
};
return {
success: true,
data: res.data,
};
} catch (error: any) {
let message = "Unknown error occurred";

2
src/electron/utils/utilityFunctions.ts
View File

@ -68,7 +68,7 @@ export const handleLogin = async (credentials: { email: string, password: string
try {
console.log("➡️ Calling API...");
const response = await axios.post(
'https://dreadingly-unfighting-pandora.ngrok-free.dev/api/v1/va/login',
'https://daniela-nonprofessed-boastfully.ngrok-free.app/api/v1/va/login',
{ userDetails: { ...credentials } },
{ headers: { "ngrok-skip-browser-warning": 69420 }, httpsAgent }
);

128
src/ui/hooks/useActiveAppTracker.tsx
View File

@ -8,14 +8,12 @@ interface DailyHours {
remaining: string;
}
export const useActiveAppTracker = (
isTracking: boolean,
activeProjectLogId: string | null,
projectId: string | null,
projectName: string | null,
onLimitExceeded?: () => void // Callback when limit is reached
onLimitExceeded?: () => void
) => {
const dispatch = useDispatch();
const lastActiveRef = useRef<WindowInfo | null>(null);
@ -24,8 +22,9 @@ export const useActiveAppTracker = (
const intervalIdRef = useRef<number | null>(null);
const finalizeTrackingRef = useRef<(() => Promise<void>) | null>(null);
const limitCheckedRef = useRef<boolean>(false);
const isStoppingRef = useRef<boolean>(false); // ✅ Flag to prevent new requests
const canSend = !!(activeProjectLogId && projectId);
const canSend = !!(activeProjectLogId && projectId && !isStoppingRef.current);
// ✅ Parse time string to minutes
const parseTimeToMinutes = (timeStr: string): number => {
@ -53,7 +52,6 @@ export const useActiveAppTracker = (
exceeded: remainingMins <= 0
});
// If remaining time is 0 or negative, limit is exceeded
if (remainingMins <= 0) {
return true;
}
@ -61,6 +59,7 @@ export const useActiveAppTracker = (
return false;
};
// ✅ Send activity log (POST for new, PATCH for update)
const sendActivityLog = async (
projectLogId: string,
projectId: string,
@ -68,8 +67,14 @@ export const useActiveAppTracker = (
appName: string,
isNew: boolean
) => {
// ✅ CRITICAL: Block all requests when stopping
if (isStoppingRef.current) {
console.log("🚫 Stopping in progress — blocking activity log");
return null;
}
if (!canSend) {
console.log("🚫 Skipping API — missing activeProjectLogId or projectId");
console.log("🚫 Skipping API — missing required IDs");
return null;
}
@ -99,20 +104,18 @@ export const useActiveAppTracker = (
// Store the log ID for future updates
if (isNew && res?.data?._id) {
console.log("res?.data?._id", res?.data?._id)
lastLogIdRef.current = res.data._id;
console.log("💾 Stored log ID:", res.data._id);
}
// ✅ Check daily limit after every API call
if (res?.dailyHours) {
console.log("res?.data?.dailyHours", res?.dailyHours)
const limitExceeded = checkDailyLimit(res?.dailyHours);
const limitExceeded = checkDailyLimit(res.dailyHours);
if (limitExceeded && !limitCheckedRef.current) {
limitCheckedRef.current = true;
console.warn("🚨 Daily limit exceeded! Stopping tracking...");
console.warn("🚨 Daily limit exceeded!");
// Trigger stop tracking callback
if (onLimitExceeded) {
setTimeout(() => {
onLimitExceeded();
@ -128,54 +131,69 @@ export const useActiveAppTracker = (
}
};
// ✅ Final PATCH before stopping
// ✅ Stop the interval immediately
const stopInterval = useCallback(() => {
console.log("🛑 Stopping activity tracking interval...");
if (intervalIdRef.current) {
clearInterval(intervalIdRef.current);
intervalIdRef.current = null;
console.log("✅ Interval cleared");
}
}, []);
// ✅ Send final PATCH before stopping (called by handleStopTracking)
const sendFinalPatch = useCallback(async () => {
if (!canSend) {
console.log("🚫 Skipping final PATCH — no active project log ID");
console.log("=".repeat(60));
console.log("🛑 FINAL PATCH INITIATED");
console.log("=".repeat(60));
// ✅ STEP 1: Set stopping flag IMMEDIATELY
isStoppingRef.current = true;
console.log("🔒 Stopping flag set — no new requests allowed");
// ✅ STEP 2: Stop the interval IMMEDIATELY
stopInterval();
if (!activeProjectLogId || !projectId) {
console.log("⚠️ Skipping final PATCH — no active project log ID");
return;
}
console.log("=".repeat(60));
console.log("🛑 FINAL PATCH INITIATED - Recording last activity");
console.log("=".repeat(60));
// ✅ STEP 3: Send ONE final PATCH for the last active window
if (lastLogIdRef.current && lastTitleRef.current && lastActiveRef.current) {
try {
console.log("📊 Final Activity Details:");
console.log(` • Window Title: ${lastTitleRef.current}`);
console.log(` • App Name: ${lastActiveRef.current.owner.name}`);
console.log(` • Window: ${lastTitleRef.current}`);
console.log(` • App: ${lastActiveRef.current.owner.name}`);
console.log(` • Log ID: ${lastLogIdRef.current}`);
console.log(` • Project ID: ${projectId}`);
console.log(` • Project: ${projectId}`);
const result = await sendActivityLog(
activeProjectLogId!,
projectId!,
activeProjectLogId,
projectId,
lastTitleRef.current,
lastActiveRef.current.owner.name || "Unknown",
false // This is a PATCH (update), not a POST (new)
false // PATCH (update existing log)
);
console.log("✅ Final PATCH sent successfully!");
if (result?.dailyHours) {
console.log("📈 Final Daily Hours Summary:");
console.log(` • Today Total: ${result.dailyHours.todayTotal}`);
console.log(` • Daily Limit: ${result.dailyHours.dailyLimit}`);
console.log("📈 Final Daily Hours:");
console.log(` • Today: ${result.dailyHours.todayTotal}`);
console.log(` • Limit: ${result.dailyHours.dailyLimit}`);
console.log(` • Remaining: ${result.dailyHours.remaining}`);
}
} catch (error) {
console.error("❌ Final PATCH failed:", error);
throw error; // Re-throw to let caller handle
throw error;
}
} else {
console.log("ℹ️ No active window to finalize");
console.log(" • Last Log ID:", lastLogIdRef.current || "None");
console.log(" • Last Title:", lastTitleRef.current || "None");
console.log(" • Last Active Window:", lastActiveRef.current ? "Yes" : "No");
}
// Clean up all refs
// ✅ STEP 4: Clean up all refs
console.log("🧹 Cleaning up tracking references...");
lastActiveRef.current = null;
lastTitleRef.current = null;
@ -183,70 +201,88 @@ export const useActiveAppTracker = (
limitCheckedRef.current = false;
console.log("✅ Cleanup complete");
console.log("=".repeat(60));
}, [activeProjectLogId, projectId, canSend]);
}, [activeProjectLogId, projectId, stopInterval]);
// ✅ Update ref whenever sendFinalPatch changes
useEffect(() => {
finalizeTrackingRef.current = sendFinalPatch;
}, [sendFinalPatch]);
// ✅ Main tracking interval effect
useEffect(() => {
// Reset limit check when tracking starts
// Reset flags when tracking starts
if (isTracking) {
limitCheckedRef.current = false;
isStoppingRef.current = false;
console.log("🟢 Tracking started — flags reset");
}
if (!isTracking || !canSend) {
console.log("🟡 Tracking inactive or missing IDs — skipping tracker setup");
console.log("🟡 Tracking inactive — cleaning up");
stopInterval();
return;
}
console.log(`🟢 Starting active tracker for: ${projectName}`);
const fetchActiveApp = async () => {
// ✅ Double-check stopping flag before each fetch
if (isStoppingRef.current) {
console.log("🚫 Stopping in progress — skipping fetch");
return;
}
try {
const details = (await window.electron.getActiveAppDetails()) as WindowInfo;
if (!details || !details.id) return;
console.log("details" , details)
const title = details.title;
const appName = details.owner.name;
const prevTitle = lastTitleRef.current;
const hasChanged = !prevTitle || prevTitle !== title;
if (hasChanged) {
// PATCH previous window before creating new log
if (lastLogIdRef.current && prevTitle) {
console.log("🔄 Patching previous log:", prevTitle);
console.log("🔄 Updating previous window:", prevTitle);
await sendActivityLog(activeProjectLogId!, projectId!, prevTitle, appName, false);
}
console.log("🆕 New title detected → creating POST:", title);
// POST new window log
console.log("🆕 New window detected:", title);
await sendActivityLog(activeProjectLogId!, projectId!, title, appName, true);
// Update refs and Redux
lastActiveRef.current = details;
lastTitleRef.current = title;
dispatch(setActiveWindow({ window: details, projectId, projectName }));
} else {
console.log("⏸ Same window, skipping log");
console.log("⏸️ Same window, skipping");
}
} catch (error) {
console.error("Failed to fetch active app:", error);
console.error("❌ Failed to fetch active app:", error);
}
};
// Initial fetch
fetchActiveApp();
// Set up interval (every 5 seconds)
intervalIdRef.current = setInterval(fetchActiveApp, 5000);
// Cleanup on unmount
return () => {
console.log("🧹 Cleaning up tracker interval");
if (intervalIdRef.current) {
clearInterval(intervalIdRef.current);
intervalIdRef.current = null;
}
stopInterval();
};
}, [isTracking, activeProjectLogId]);
}, [isTracking, activeProjectLogId, projectId, projectName, dispatch, stopInterval]);
return {
finalizeTracking: finalizeTrackingRef.current,
stopInterval,
setIsStopping: (value: boolean) => {
isStoppingRef.current = value;
console.log(`🔒 Stopping flag manually set to: ${value}`);
}
};
};

333
src/ui/layout/DashboardLayout.tsx
View File

@ -135,155 +135,10 @@ const DashboardLayout = () => {
document.documentElement.setAttribute("data-theme", theme);
}, [theme]);
// Create a ref to store the stop function so it can be called from the hook
const stopTrackingRef = useRef<(() => Promise<void>) | null>(null);
const limitAlertShownRef = useRef(false);
// Define handleStopTracking FIRST
const handleStopTracking = useCallback(async () => {
if (loadingStop || loadingStart) return;
if (!selectedProject) {
console.warn("No selected project to stop");
return;
}
// Reset alert flag when stopping
limitAlertShownRef.current = false;
let currentStopTime = new Date().toISOString();
const projectId = selectedProject.projectId;
console.log(" Stop tracking initiated for:", selectedProject.projectName);
console.log(" Current elapsed time:", elapsedTime);
setIsStopping(true);
setLoadingStop(true);
handleSocketDisconnect();
// STEP 1: Clear timer FIRST to prevent further client-side updates
if (timerRef.current) {
clearInterval(timerRef.current);
timerRef.current = null;
console.log("Timer cleared");
}
// STEP 2: Send final PATCH with last active window data
if (stopTrackingRef.current) {
try {
console.log(" Sending final PATCH to record last activity...");
await stopTrackingRef.current();
console.log(" Final tracking data sent successfully");
} catch (error) {
console.error(" Error sending final tracking data:", error);
}
}
// STEP 3: Send LOGOUT to backend
try {
const payload = {
vaId: projectSummary.vaId,
projectId: projectId,
type: "LOGOUT",
time: currentStopTime
};
console.log("📡 Sending LOGOUT request:", payload);
const res = await window.electron.stopProjectTracking(payload);
console.log(" LOGOUT successful:", res);
} catch (error) {
console.error(" Failed to send LOGOUT:", error);
}
// STEP 4: Update Redux tracking state to stop tracking
console.log("🔄 Updating Redux state to stop tracking...");
dispatch(
stopTrackingReducer({
projectId,
})
);
// Allow React to process the state update
await new Promise(resolve => setTimeout(resolve, 50));
// STEP 5: Refresh project list to get updated work hours from server
try {
console.log("🔄 Refreshing project list...");
const projectListRes = await window.electron.getProjectList();
console.log("📊 Updated project list:", projectListRes);
if (projectListRes?.success && Array.isArray(projectListRes.data)) {
// Update projects data
dispatch(setProjectsDataSlice(projectListRes.data));
// Update project summary
dispatch(
setProjectSummarySlice({
totalProjects: projectListRes.totalProjects || 0,
activeProjects: projectListRes.activeProjects || 0,
awayProjects: projectListRes.awayProjects || 0,
totalWorkTime: projectListRes.totalWorkTime || "0h 0m 0s",
totalWorkMs: projectListRes.totalWorkMs || 0,
vaName: projectListRes.vaName || "",
vaId: projectListRes.vaId || "",
})
);
// Update selected project with fresh data
const updatedProject = projectListRes.data.find(
(p: Project) => p.projectId === projectId
);
if (updatedProject) {
dispatch(setSelectedProjectSlice(updatedProject));
// CRITICAL FIX: Use server time instead of client elapsedTime
const serverElapsedTime = parseTimeStringToSeconds(updatedProject.totalWorkTime);
console.log("🔄 Syncing client time with server time:", {
serverTime: updatedProject.totalWorkTime,
serverElapsedSeconds: serverElapsedTime,
previousClientTime: elapsedTime,
difference: serverElapsedTime - elapsedTime
});
// Force update the tracking map with server time
dispatch(
updateProjectTracking({
projectId: updatedProject.projectId,
data: {
elapsedTime: serverElapsedTime,
accumulatedTime: serverElapsedTime,
isTracking: false,
isPaused: false,
startTime: null,
endTime: Date.now(),
pauseStartTime: null,
totalPausedTime: 0
}
})
);
console.log("✅ Selected project updated with server time");
}
}
// STEP 6: Update UI (window restore)
await window.electron.toggleCloseBtn(true);
await window.electron.resizeWindow(500, 600);
toggleWindowSize.current = true;
} catch (error) {
console.error("❌ Error refreshing project list:", error);
} finally {
// Clear loading states
setLoadingStop(false);
setIsStopping(false);
console.log("🎉 TRACKING STOPPED SUCCESSFULLY");
}
}, [selectedProject, projectSummary, elapsedTime, dispatch]);
// NOW define handleLimitExceeded using the defined handleStopTracking
const handleLimitExceeded = useCallback(async () => {
console.log("🚨 LIMIT EXCEEDED - Showing alert (not stopping)");
@ -316,7 +171,7 @@ const DashboardLayout = () => {
}, [selectedProject]);
// Initialize useActiveAppTracker and store finalizeTracking in ref
const { finalizeTracking } = useActiveAppTracker(
const { finalizeTracking, setIsStopping: setIsStoppingInTracker } = useActiveAppTracker(
isTracking,
activeProjectLogId,
selectedProject?.projectId ?? null,
@ -324,6 +179,186 @@ const DashboardLayout = () => {
handleLimitExceeded
);
// Define handleStopTracking FIRST
const handleStopTracking = useCallback(async () => {
if (loadingStop || loadingStart) {
console.log("⏸️ Already processing, skipping...");
return;
}
if (!selectedProject) {
console.warn("⚠️ No selected project to stop");
return;
}
console.log("=".repeat(70));
console.log("🛑 STOP TRACKING INITIATED");
console.log("=".repeat(70));
console.log(`📦 Project: ${selectedProject.projectName}`);
console.log(`⏱️ Elapsed Time: ${elapsedTime}s`);
// Reset alert flag when stopping
limitAlertShownRef.current = false;
const currentStopTime = new Date().toISOString();
const projectId = selectedProject.projectId;
// ✅ CRITICAL: Set stopping flag IMMEDIATELY to block all new tab tracking
console.log("🔒 Setting stopping flag...");
if (setIsStoppingInTracker) {
setIsStoppingInTracker(true);
}
setIsStopping(true);
setLoadingStop(true);
handleSocketDisconnect();
// STEP 1: Clear local timer to prevent further client-side updates
console.log("⏹️ STEP 1: Clearing local timer...");
if (timerRef.current) {
clearInterval(timerRef.current);
timerRef.current = null;
console.log("✅ Timer cleared");
}
// STEP 2: Send final PATCH with last active window data
console.log("📤 STEP 2: Sending final activity tracking...");
if (stopTrackingRef.current) {
try {
await stopTrackingRef.current(); // This calls sendFinalPatch() in the hook
console.log("✅ Final activity tracking completed");
} catch (error) {
console.error("❌ Error during final tracking:", error);
}
} else {
console.log("⚠️ No tracking ref available");
}
// STEP 3: Send LOGOUT to backend
console.log("🚪 STEP 3: Sending LOGOUT request...");
try {
const payload = {
vaId: projectSummary.vaId,
projectId: projectId,
type: "LOGOUT",
time: currentStopTime
};
console.log("📡 Logout payload:", payload);
const res = await window.electron.stopProjectTracking(payload);
console.log("✅ LOGOUT successful:", res);
} catch (error) {
console.error("❌ LOGOUT failed:", error);
}
// STEP 4: Update Redux tracking state
console.log("🔄 STEP 4: Updating Redux state...");
dispatch(
stopTrackingReducer({
projectId,
})
);
// STEP 6: Update UI (restore window)
console.log("🪟 STEP 6: Restoring window...");
await window.electron.toggleCloseBtn(true);
await window.electron.resizeWindow(500, 600);
toggleWindowSize.current = true;
console.log("✅ Window restored");
// Allow React to process the state update
await new Promise(resolve => setTimeout(resolve, 50));
// STEP 5: Refresh project list to get updated work hours from server
console.log("📊 STEP 5: Refreshing project list...");
try {
const projectListRes = await window.electron.getProjectList();
console.log("✅ Project list fetched:", projectListRes);
if (projectListRes?.success && Array.isArray(projectListRes.data)) {
// Update projects data
dispatch(setProjectsDataSlice(projectListRes.data));
// Update project summary
dispatch(
setProjectSummarySlice({
totalProjects: projectListRes.totalProjects || 0,
activeProjects: projectListRes.activeProjects || 0,
awayProjects: projectListRes.awayProjects || 0,
totalWorkTime: projectListRes.totalWorkTime || "0h 0m 0s",
totalWorkMs: projectListRes.totalWorkMs || 0,
vaName: projectListRes.vaName || "",
vaId: projectListRes.vaId || "",
})
);
// Update selected project with fresh data from server
const updatedProject = projectListRes.data.find(
(p: Project) => p.projectId === projectId
);
if (updatedProject) {
dispatch(setSelectedProjectSlice(updatedProject));
// Sync client time with server time
const serverElapsedTime = parseTimeStringToSeconds(updatedProject.totalWorkTime);
console.log("🔄 Syncing with server time:", {
serverTime: updatedProject.totalWorkTime,
serverSeconds: serverElapsedTime,
clientSeconds: elapsedTime,
difference: serverElapsedTime - elapsedTime
});
// Force update the tracking map with server time
dispatch(
updateProjectTracking({
projectId: updatedProject.projectId,
data: {
elapsedTime: serverElapsedTime,
accumulatedTime: serverElapsedTime,
isTracking: false,
isPaused: false,
startTime: null,
endTime: Date.now(),
pauseStartTime: null,
totalPausedTime: 0
}
})
);
console.log("✅ Project synced with server");
}
}
} catch (error) {
console.error("❌ Error refreshing project list:", error);
} finally {
// Clear loading states
setLoadingStop(false);
setIsStopping(false);
// ✅ Reset stopping flag for next session
if (setIsStoppingInTracker) {
setIsStoppingInTracker(false);
}
console.log("=".repeat(70));
console.log("🎉 TRACKING STOPPED SUCCESSFULLY");
console.log("=".repeat(70));
}
}, [
selectedProject,
projectSummary,
elapsedTime,
dispatch,
loadingStop,
loadingStart,
setIsStoppingInTracker
]);
// Update the ref whenever finalizeTracking changes
useEffect(() => {
stopTrackingRef.current = finalizeTracking;
@ -362,7 +397,7 @@ const DashboardLayout = () => {
return () => {
console.log("🧹 Cleaning token-expired listener");
};
}, [isTracking, handleStopTracking]);
}, [isTracking]);
const handleLogout = async () => {
@ -585,7 +620,7 @@ const DashboardLayout = () => {
// socketRef.current?.emit("getVisibleApps", { token: await token, apps });
// });
socketRef.current.on("startSendAppsDetails", async ({projId}) => {
socketRef.current.on("startSendAppsDetails", async ({ projId }) => {
if (projId !== selectedProject?.projectId) return;
console.log("▶️ startSendAppsDetails received");
@ -609,7 +644,7 @@ const DashboardLayout = () => {
}, 5000);
});
socketRef.current.on("stopSendAppsDetails", async ({projId}) => {
socketRef.current.on("stopSendAppsDetails", async ({ projId }) => {
if (projId !== selectedProject?.projectId) return;
console.log("⏹ stopSendAppsDetails received");

2
src/ui/pages/PaySlips/PaysSlips.tsx
View File

@ -36,6 +36,8 @@ const PaysSlips = () => {
return;
}
console.log(response , "getPayslips")
// Extract payrolls array from first index
const payrolls = response[0]?.payrolls || [];