@janiscommerce/app-tracking-shift 1.0.1 → 1.2.0

package/lib/OfflineData.js

@@ -5,21 +5,29 @@ import {setObject, getObject} from './utils/storage';
 
 class OfflineData {
 	get hasData() {
-		const offlineData = getObject(OFFLINE_DATA, {});
-		return Object.keys(offlineData).length > 0;
+		const offlineData = getObject(OFFLINE_DATA, []);
+		return offlineData.length > 0;
 	}
 
 	/**
 	 * Saves data to the offline data storage.
 	 *
-	 * @param {string} storageId - The ID of the storage to save the data to.
+	 * @param {string} id - The reference id of the data.
 	 * @param {Object} data - The data to save.
 	 */
 
-	save(storageId, data) {
+	save(id, data) {
 		try {
-			const offlineData = getObject(OFFLINE_DATA, {});
-			offlineData[storageId] = {...offlineData[storageId], ...data};
+			const offlineData = getObject(OFFLINE_DATA, []);
+			const foundIdx = offlineData.findIndex((item) => item.storageId === id);
+
+			if (foundIdx === -1) {
+				offlineData.push({storageId: id, ...data});
+			} else {
+				const storedData = offlineData[foundIdx];
+				offlineData[foundIdx] = {...storedData, ...data};
+			}
+
 			setObject(OFFLINE_DATA, offlineData);
 		} catch (error) {
 			throw new Error(error);
@@ -29,21 +37,37 @@ class OfflineData {
 	/**
 	 * Gets data from the offline data storage.
 	 *
-	 * @param {string | Array<string> | null} storageId - The ID of the storage to get the data from.
+	 * @param {string | Array<string> | null} id - The ID of the storage to get the data from.
 	 * @returns {Array<Object>} The data from the storage.
 	 */
 
-	get(storageId = null) {
+	get(id = null) {
 		try {
-			const offlineData = getObject(OFFLINE_DATA, {});
+			const offlineData = getObject(OFFLINE_DATA, []);
 
-			if (!isArray(storageId)) {
-				storageId = [storageId].filter(Boolean);
+			if (!isArray(id)) {
+				id = [id].filter(Boolean);
 			}
 
-			if (isEmptyArray(storageId)) return Object.values(offlineData);
+			if (isEmptyArray(id)) return offlineData;
 
-			return storageId.map((id) => offlineData[id]);
+			return offlineData.filter((item) => id.includes(item.storageId));
+		} catch (error) {
+			throw new Error(error);
+		}
+	}
+
+	/**
+	 * Gets the last record from the offline data storage.
+	 *
+	 * @returns {Object} The last record from the storage.
+	 */
+
+	getLastRecord() {
+		try {
+			const offlineData = this.get();
+			const [lastRecord] = offlineData.slice(-1);
+			return lastRecord;
 		} catch (error) {
 			throw new Error(error);
 		}
@@ -52,24 +76,22 @@ class OfflineData {
 	/**
 	 * Deletes data from the offline data storage.
 	 *
-	 * @param {string | Array<string>} storageId - The ID of the storage to delete the data from.
+	 * @param {string | Array<string>} id - The reference id of the data.
 	 */
 
-	delete(storageId) {
+	delete(id) {
 		try {
-			const offlineData = getObject(OFFLINE_DATA, {});
+			const offlineData = getObject(OFFLINE_DATA, []);
 
-			if (!isArray(storageId)) {
-				storageId = [storageId].filter(Boolean);
+			if (!isArray(id)) {
+				id = [id].filter(Boolean);
 			}
 
-			if (isEmptyArray(storageId)) return;
+			if (isEmptyArray(id)) return;
 
-			storageId.forEach((id) => {
-				delete offlineData[id];
-			});
+			const filteredData = offlineData.filter((item) => !id.includes(item.storageId));
 
-			setObject(OFFLINE_DATA, offlineData);
+			setObject(OFFLINE_DATA, filteredData);
 		} catch (error) {
 			throw new Error(error);
 		}

package/lib/Shift.js

@@ -1,10 +1,23 @@
-import TimeTracker from './db/TimeTrackerService';
 import StaffService from './StaffApiServices';
 import Storage from './db/StorageService';
 import Crashlytics from './utils/crashlytics';
 import ShiftWorklogs from './ShiftWorklogs';
-import {generateRandomId, isEmptyArray, isEmptyObject, isObject} from './utils/helpers';
-import {getObject, getShiftData, setObject} from './utils/storage';
+import errorParser from './utils/errorParser';
+import {
+	generateRandomId,
+	isEmptyArray,
+	isEmptyObject,
+	isNumber,
+	isObject,
+	isValidObject,
+} from './utils/helpers';
+import {
+	deleteStoredWorkLog,
+	getObject,
+	getShiftData,
+	getStaffAuthorizationData,
+	setObject,
+} from './utils/storage';
 import {
 	SHIFT_ID,
 	SHIFT_STATUS,
@@ -12,9 +25,8 @@ import {
 	CURRENT_WORKLOG_DATA,
 	CURRENT_WORKLOG_ID,
 	EXCLUDED_WORKLOG_TYPES,
-	ONE_HOUR_EXTENSION,
+	DEFAULT_REOPENING_EXTENSION_TIME,
 } from './constant';
-import TrackerRecords from './TrackerRecords';
 import Formatter from './Formatter';
 import OfflineData from './OfflineData';
 /**
@@ -24,10 +36,25 @@ import OfflineData from './OfflineData';
 
 class Shift {
 	/**
-	 * Open a work shift in the staff MS and record this event in the time tracking database.
-	 * @param {Object} params
-	 * @throws {Error} error
-	 * @returns {Promise<string>} shiftId => ID related to the shift that has just been opened for the user
+	 * @returns {boolean} hasStaffAuthorization => true if the user has staff MS authorization, false otherwise
+	 */
+
+	get hasStaffAuthorize() {
+		const {hasStaffAuthorization} = getStaffAuthorizationData();
+		return hasStaffAuthorization;
+	}
+
+	/**
+	 * @returns {boolean} hasPendingData => true if the user has pending data, false otherwise
+	 */
+
+	get hasPendingData() {
+		return OfflineData.hasData;
+	}
+
+	/**
+	 * Check if the staff MS is enabled
+	 * @returns {Promise<boolean>} true if the staff MS is enabled, false otherwise
 	 */
 
 	async checkStaffMSAuthorization() {
@@ -38,33 +65,42 @@ class Shift {
 
 			return enabledShiftAndWorkLog;
 		} catch (error) {
-			Crashlytics.recordError(error, 'Error checking staff MS authorization');
-			return Promise.reject(error);
+			const parsedError = errorParser(error);
+			Crashlytics.recordError(parsedError, 'Error checking staff MS authorization');
+			return Promise.reject(parsedError);
 		}
 	}
 
-	async open(params = {}) {
+	/**
+	 * Open a work shift in the staff MS and record this event in the time tracking database.
+	 * @param {Object} params
+	 * @throws {Error} error
+	 * @returns {Promise<string>} shiftId => ID related to the shift that has just been opened for the user
+	 */
+
+	async open() {
 		try {
-			Crashlytics.log('user open shift');
-			const {date} = params;
+			Crashlytics.log('openShift:');
+
+			this._requireStaffAuthorization();
+
 			const {result: shift} = await StaffService.openShift();
 			const {id: shiftId = ''} = shift || {};
 
 			const openShift = await this.getUserOpenShift({id: shiftId});
 
-			await this._startTracking({
-				id: shiftId,
-				date: date || openShift.startDate,
-			});
-
 			Storage.set(SHIFT_ID, shiftId);
 			Storage.set(SHIFT_STATUS, 'opened');
-			Storage.set(SHIFT_DATA, JSON.stringify(openShift));
+			setObject(SHIFT_DATA, openShift);
 
 			return shiftId;
 		} catch (error) {
-			Crashlytics.recordError(error, 'Error opening shift in staff service');
-			return Promise.reject(error);
+			const parsedError = errorParser(error);
+			Crashlytics.recordError(
+				parsedError,
+				'An error occurred while trying to open a shift for the user'
+			);
+			return Promise.reject(parsedError);
 		}
 	}
 
@@ -77,14 +113,17 @@ class Shift {
 
 	async finish(params = {}) {
 		try {
-			Crashlytics.log('user close shift');
+			Crashlytics.log('closeShift:');
+
+			this._requireStaffAuthorization();
+
 			const shiftIsExpired = this.isDateToCloseExceeded();
 
 			if (shiftIsExpired) {
 				await this.reOpen();
 			}
 
-			if (OfflineData.hasData) {
+			if (this.hasPendingData) {
 				await this.sendPendingWorkLogs();
 			}
 
@@ -94,20 +133,19 @@ class Shift {
 			const endDate = date || new Date().toISOString();
 			const shiftData = getShiftData();
 
-			await this._finishTracking({id: shiftId, date});
-
 			const updatedShiftData = {
 				...shiftData,
 				endDate,
 			};
 
 			Storage.set(SHIFT_STATUS, 'closed');
-			Storage.set(SHIFT_DATA, JSON.stringify(updatedShiftData));
+			setObject(SHIFT_DATA, updatedShiftData);
 
 			return shiftId;
 		} catch (error) {
-			Crashlytics.recordError(error, 'Error closing shift in staff service');
-			return Promise.reject(error);
+			const parsedError = errorParser(error);
+			Crashlytics.recordError(parsedError, 'An error occurred while trying to close user shift');
+			return Promise.reject(parsedError);
 		}
 	}
 
@@ -124,13 +162,22 @@ class Shift {
 
 	async openWorkLog(workLog = {}) {
 		try {
-			Crashlytics.log('user open shift worklog', workLog);
+			Crashlytics.log('openWorkLog:', workLog);
+
+			this._requireStaffAuthorization();
 
 			if (!isObject(workLog) || isEmptyObject(workLog)) return null;
+			const currentTime = new Date().toISOString();
+			const mustCloseLastWorkLog = this._isNeccesaryCloseLastWorkLog();
+
+			if (mustCloseLastWorkLog) {
+				const lastWorkLog = getObject(CURRENT_WORKLOG_DATA);
+
+				await this.finishWorkLog(lastWorkLog);
+			}
 
 			const {referenceId, name, type, suggestedTime = 0} = workLog;
 			const shiftId = Storage.getString(SHIFT_ID);
-			const startTime = new Date().toISOString();
 			const randomId = generateRandomId();
 
 			const workLogId = Formatter.formatWorkLogId(referenceId, randomId);
@@ -138,34 +185,24 @@ class Shift {
 			// TODO: uncomment this when resolve how to handle offline workLogs
 			// await ShiftWorklogs.open({
 			// 	referenceId,
-			// 	startDate: startTime,
+			// 	startDate: currentTime,
 			// });
 
-			const dataForTimeTracker = {
-				type,
-				name,
-				shiftId,
-				referenceId,
-			};
-
 			OfflineData.save(workLogId, {
 				referenceId,
-				startDate: startTime,
-			});
-
-			await this._startTracking({
-				id: workLogId,
-				date: startTime,
-				payload: dataForTimeTracker,
+				startDate: currentTime,
 			});
 
-			const suggestedFinishDate = new Date(startTime).getTime() + suggestedTime * 60 * 1000;
+			const suggestedFinishDate = new Date(currentTime).getTime() + suggestedTime * 60 * 1000;
 
 			const dataForStorage = {
-				...dataForTimeTracker,
+				type,
+				name,
+				shiftId,
+				referenceId,
 				suggestedFinishDate: new Date(suggestedFinishDate).toISOString(),
 				suggestedTime,
-				startDate: startTime,
+				startDate: currentTime,
 			};
 
 			if (!EXCLUDED_WORKLOG_TYPES.includes(referenceId)) {
@@ -177,8 +214,9 @@ class Shift {
 
 			return workLogId;
 		} catch (error) {
-			Crashlytics.recordError(error, 'Error opening shift worklog');
-			return Promise.reject(error);
+			const parsedError = errorParser(error);
+			Crashlytics.recordError(parsedError, 'An error occurred while trying to open user workLog');
+			return Promise.reject(parsedError);
 		}
 	}
 
@@ -186,62 +224,65 @@ class Shift {
 	 * Finish a work log in the staff MS and record this event in the time tracking database.
 	 * @param {Object} workLog
 	 * @param {string} workLog.referenceId => Reference ID related to the work log
-	 * @param {string} workLog.name => Name related to the work log
-	 * @param {string} workLog.type => Type related to the work log
 	 * @throws {Error} error
 	 * @returns {Promise<string>} workLogId => ID related to the work log that has just been closed for the user
 	 */
 
 	async finishWorkLog(workLog = {}) {
 		try {
-			Crashlytics.log('user close shift worklog', workLog);
+			Crashlytics.log('finishWorkLog:', workLog);
+
+			this._requireStaffAuthorization();
+
 			if (!isObject(workLog) || isEmptyObject(workLog)) return null;
 
-			const {referenceId, name, type} = workLog;
-			const shiftId = Storage.getString(SHIFT_ID);
+			const currentWorkLog = getObject(CURRENT_WORKLOG_DATA);
+			const {referenceId} = workLog;
+
+			if (!isValidObject(currentWorkLog)) {
+				throw new Error('There is no active worklog to close');
+			}
+
+			if (currentWorkLog?.referenceId !== referenceId) {
+				throw new Error(
+					'The worklog you are trying to close is different from the one that is currently open.'
+				);
+			}
+
 			const shiftStatus = Storage.getString(SHIFT_STATUS);
 			const endTime = new Date().toISOString();
 			const workLogId = Storage.getString(CURRENT_WORKLOG_ID);
-
 			// TODO: uncomment this when resolve how to handle offline workLogs
 			// await ShiftWorklogs.finish({
 			// 	referenceId,
 			// 	endDate: endTime,
 			// });
 
-			const dataForTimeTracker = {
-				type,
-				name,
-				shiftId,
-				referenceId,
-			};
-
 			OfflineData.save(workLogId, {
 				referenceId,
 				endDate: endTime,
 			});
 
-			await this._finishTracking({
-				id: workLogId,
-				date: endTime,
-				payload: dataForTimeTracker,
-			});
-
 			if (shiftStatus === 'paused') {
 				Storage.set(SHIFT_STATUS, 'opened');
 			}
 
-			this._deleteCurrentWorkLogData();
+			deleteStoredWorkLog();
 
 			return workLogId;
 		} catch (error) {
-			Crashlytics.recordError(error, 'Error closing shift worklog');
-			return Promise.reject(error);
+			const parsedError = errorParser(error);
+			Crashlytics.recordError(parsedError, 'An error occurred while trying to close user workLog');
+			return Promise.reject(parsedError);
 		}
 	}
 
 	async sendPendingWorkLogs() {
 		try {
+			Crashlytics.log('sendPendingWorkLogs:');
+
+			this._requireStaffAuthorization();
+
 			const storageData = OfflineData.get();
 			const formatedWorkLogs = Formatter.formatOfflineWorkLog(storageData);
 
@@ -273,7 +314,10 @@ class Shift {
 
 	async getUserOpenShift(params = {}) {
 		try {
-			Crashlytics.log('user get open shift', params);
+			Crashlytics.log('getUserOpenShift:', params);
+
+			this._requireStaffAuthorization();
+
 			const {userId, id, ...rest} = params;
 			const {result: shifts} = await StaffService.getShiftsList({
 				filters: {
@@ -287,8 +331,9 @@ class Shift {
 
 			return openShift || {};
 		} catch (error) {
-			Crashlytics.recordError(error, 'Error getting open shift in staff service');
-			return Promise.reject(error);
+			const parsedError = errorParser(error);
+			Crashlytics.recordError(parsedError, 'Error getting open shift in staff service');
+			return Promise.reject(parsedError);
 		}
 	}
 
@@ -301,7 +346,10 @@ class Shift {
 
 	async getWorkLogs(shiftId) {
 		try {
-			Crashlytics.log('user get work logs');
+			Crashlytics.log('getWorkLogs:');
+
+			this._requireStaffAuthorization();
+
 			const userShiftId = shiftId || Storage.getString(SHIFT_ID);
 
 			if (!userShiftId) throw new Error('Shift ID not found');
@@ -310,8 +358,12 @@ class Shift {
 
 			return Formatter.formatWorkLogsFromJanis(workLogs);
 		} catch (error) {
-			Crashlytics.recordError(error, 'Error getting work logs in staff service');
-			return Promise.reject(error);
+			const parsedError = errorParser(error);
+			Crashlytics.recordError(
+				parsedError,
+				'An error occurred while trying to get user workLogs from staff service'
+			);
+			return Promise.reject(parsedError);
 		}
 	}
 
@@ -323,7 +375,10 @@ class Shift {
 
 	async reOpen() {
 		try {
-			Crashlytics.log('user re open shift');
+			Crashlytics.log('reOpenShift:');
+
+			this._requireStaffAuthorization();
+
 			const shiftIsExpired = this.isDateMaxToCloseExceeded();
 
 			if (shiftIsExpired) {
@@ -334,8 +389,9 @@ class Shift {
 
 			return null;
 		} catch (error) {
-			Crashlytics.recordError(error, 'Error re opening shift');
-			return Promise.reject(error);
+			const parsedError = errorParser(error);
+			Crashlytics.recordError(parsedError, 'An error occurred while trying to re open user shift');
+			return Promise.reject(parsedError);
 		}
 	}
 
@@ -355,83 +411,6 @@ class Shift {
 		return new Date(dateMaxToClose).getTime() < currentDate.getTime();
 	}
 
-	/**
-	 * Gets a shift report based on the shift ID and its registered events.
-	 *
-	 * The report includes information about performed activities, start and end times,
-	 * total elapsed time, work time and pause time.
-	 *
-	 * @async
-	 * @function getReport
-	 * @throws {Error} If the `shiftId` is not found in storage.
-	 * @returns {Promise<{
-	 *   activities: Array<{
-	 *     id: string,
-	 *     name: string,
-	 *     type: string,
-	 *     startDate: string,
-	 *     endDate: string,
-	 *     duration: number
-	 *   }>,
-	 *   startDate: string,
-	 *   endDate: string,
-	 *   elapsedTime: number,
-	 *   workTime: number,
-	 *   pauseTime: number,
-	 *   isComplete: boolean,
-	 *   error: string | null
-	 * }>} Object with shift details.
-	 *
-	 * @property {Array} activities - List of activities registered during the shift.
-	 * @property {string} activities[].id - Unique identifier of the activity.
-	 * @property {string} activities[].name - Name or description of the activity.
-	 * @property {string} activities[].startDate - Start date and time of the activity.
-	 * @property {string} activities[].endDate - End date and time of the activity.
-	 * @property {number} activities[].duration - Duration of the activity in milliseconds.
-	 * @property {string} startDate - Start date and time of the shift.
-	 * @property {string} endDate - End date and time of the shift (can be empty if not finished).
-	 * @property {number} elapsedTime - Total elapsed time between shift start and end.
-	 * @property {number} workTime - Effective work time (total time minus pauses).
-	 * @property {number} pauseTime - Total time of registered pauses.
-	 * @property {boolean} isComplete - Indicates if the report was obtained completely without errors.
-	 * @property {string|null} error - Error message if the report is not complete, or null if there were no errors.
-	 */
-
-	async getReport() {
-		try {
-			Crashlytics.log('user get shift report');
-			const shiftId = Storage.getString(SHIFT_ID);
-
-			if (!shiftId) throw new Error('Shift ID is required');
-
-			const startDate = await TrackerRecords.getStartDateById(shiftId);
-			const endDate = await TrackerRecords.getEndDateById(shiftId);
-			const workLogs = await ShiftWorklogs.getShiftTrackedWorkLogs(shiftId);
-
-			const activities = Formatter.formatShiftActivities(workLogs);
-			const elapsedTime = TimeTracker.getElapsedTime({
-				startTime: startDate,
-				...(!!endDate && {endTime: endDate}),
-				format: false,
-			});
-
-			const pauseTime = activities.reduce((acc, activity) => acc + (activity?.duration || 0), 0);
-			const workTime = elapsedTime - pauseTime;
-
-			return {
-				activities,
-				startDate,
-				endDate,
-				elapsedTime,
-				workTime,
-				pauseTime,
-			};
-		} catch (reason) {
-			Crashlytics.recordError(reason, 'Error getting shift report');
-			return Promise.reject(reason);
-		}
-	}
-
 	/**
 	 * Fetch the work log types from the staff MS and prepare them for register an activity.
 	 * @throws {Error} error
@@ -440,13 +419,17 @@ class Shift {
 
 	async fetchWorklogTypes() {
 		try {
-			Crashlytics.log('user fetch worklog types');
+			Crashlytics.log('fetchWorklogTypes:');
+
+			this._requireStaffAuthorization();
+
 			const {result: workLogTypes = []} = await StaffService.getWorkLogTypes();
 
 			return Formatter.formatWorkLogTypes(workLogTypes);
 		} catch (error) {
-			Crashlytics.recordError(error, 'Error fetching worklog types in staff service');
-			return Promise.reject(error);
+			const parsedError = errorParser(error);
+			Crashlytics.recordError(parsedError, 'Error fetching worklog types from staff service');
+			return Promise.reject(parsedError);
 		}
 	}
 
@@ -458,14 +441,17 @@ class Shift {
 
 	async deleteShiftRegisters() {
 		try {
-			Crashlytics.log('user delete shift registers');
+			Crashlytics.log('deleteShiftRegisters:');
 			this._deleteShiftData();
-			this._deleteCurrentWorkLogData();
-			OfflineData.deleteAll();
-			return await TimeTracker.deleteAllEvents();
+			deleteStoredWorkLog();
+			return OfflineData.deleteAll();
 		} catch (error) {
-			Crashlytics.recordError(error, 'Error deleting registers from shift tracking database');
-			return Promise.reject(error);
+			const parsedError = errorParser(error);
+			Crashlytics.recordError(
+				parsedError,
+				'An error occurred while trying to delete shift storage data'
+			);
+			return Promise.reject(parsedError);
 		}
 	}
 
@@ -475,64 +461,57 @@ class Shift {
 		Storage.delete(SHIFT_DATA);
 	}
 
-	_deleteCurrentWorkLogData() {
-		Storage.delete(CURRENT_WORKLOG_ID);
-		Storage.delete(CURRENT_WORKLOG_DATA);
-	}
-
 	/**
 	 * @private
-	 * Start id tracking in the time tracking database.
-	 * @param {Object} params
-	 * @param {string} params.id => ID related to the shift
-	 * @param {string} params.date => Date related to the shift
-	 * @param {Object} params.payload => Payload related to the shift
+	 * Extend the shift closing date.
+	 * @throws {Error} error
+	 * @returns {Promise<null>} null
 	 */
 
-	async _startTracking(params) {
-		const {id, date, payload} = params;
-		await TimeTracker.addEvent({
-			id,
-			time: date || new Date().toISOString(),
-			type: 'start',
-			payload,
-		}).catch(() => null);
+	_extendShiftClosingDate() {
+		const shiftData = getObject(SHIFT_DATA);
+		const {dateToClose, reopeningExtensionTime} = shiftData; // reopeningExtensionTime is in minutes
+		let extensionTime = DEFAULT_REOPENING_EXTENSION_TIME;
+
+		if (reopeningExtensionTime && isNumber(reopeningExtensionTime)) {
+			extensionTime = reopeningExtensionTime * 60 * 1000; // Convert minutes to milliseconds
+		}
+
+		const updatedClosingDate = new Date(dateToClose).getTime() + extensionTime; // Add the extension time to the closing date
+
+		shiftData.dateToClose = new Date(updatedClosingDate).toISOString();
+
+		setObject(SHIFT_DATA, shiftData);
 	}
 
 	/**
 	 * @private
-	 * Finish id tracking in the time tracking database.
-	 * @param {Object} params
-	 * @param {string} params.id => ID related to the shift
-	 * @param {string} params.date => Date related to the shift
-	 * @param {Object} params.payload => Payload related to the shift
+	 * Validate if the user has staff MS authorization
+	 * @throws {Error} error
+	 * @returns {Promise<null>} null
 	 */
 
-	async _finishTracking(params) {
-		const {id, date, payload} = params;
-		await TimeTracker.addEvent({
-			id,
-			time: date || new Date().toISOString(),
-			type: 'finish',
-			payload,
-		}).catch(() => null);
+	_requireStaffAuthorization() {
+		if (this.hasStaffAuthorize) return;
+		throw new Error('Staff MS authorization is required');
 	}
 
 	/**
 	 * @private
-	 * Extend the shift closing date.
-	 * @throws {Error} error
-	 * @returns {Promise<null>} null
+	 * Validate if is neccesary close the last work log
+	 * @param {Object} newWorkLog
+	 * @param {string} newWorkLog.referenceId => Reference ID related to the new work log
+	 * @returns {boolean} true if is neccesary close the last work log, false otherwise
 	 */
 
-	_extendShiftClosingDate() {
-		const shiftData = getObject(SHIFT_DATA);
-		const {dateToClose} = shiftData;
-		const updatedClosingDate = new Date(dateToClose).getTime() + ONE_HOUR_EXTENSION;
+	_isNeccesaryCloseLastWorkLog() {
+		const lastWorkLog = OfflineData.getLastRecord();
+		if (!isValidObject(lastWorkLog)) return false;
 
-		shiftData.dateToClose = new Date(updatedClosingDate).toISOString();
+		const isLastWorkLogClosed = !!lastWorkLog?.endDate;
 
-		setObject(SHIFT_DATA, shiftData);
+		return !isLastWorkLogClosed;
 	}
 }
+
 export default new Shift();

package/lib/ShiftWorklogs.js

@@ -1,5 +1,4 @@
 import StaffApiServices from './StaffApiServices';
-import TrackerRecords from './TrackerRecords';
 import {isArray, isEmptyArray} from './utils/helpers';
 
 class ShiftWorklogs {
@@ -63,20 +62,6 @@ class ShiftWorklogs {
 		}
 	}
 
-	async getShiftTrackedWorkLogs(shiftId) {
-		try {
-			if (!shiftId) throw new Error(`Shift ID is required, but got ${shiftId}`);
-
-			const workLogEvents = await TrackerRecords.getClientShiftActivities(shiftId);
-			const shiftWorkLogs = workLogEvents.filter((e) => e?.payload?.shiftId === shiftId);
-			shiftWorkLogs.sort((a, b) => new Date(a?.time) - new Date(b?.time));
-
-			return shiftWorkLogs;
-		} catch (error) {
-			return Promise.reject(error);
-		}
-	}
-
 	async postPendingBatch(pendingWorkLogs = []) {
 		try {
 			if (!isArray(pendingWorkLogs) || isEmptyArray(pendingWorkLogs)) return null;

package/lib/constant/index.js

@@ -30,4 +30,4 @@ export const INTERNAL_WORKLOGS = {
 };
 
 // SHIFT CLOSE EXTENSION
-export const ONE_HOUR_EXTENSION = 60 * 60 * 1000; // 1 hour
+export const DEFAULT_REOPENING_EXTENSION_TIME = 60 * 60 * 1000; // 1 hour

package/lib/hooks/useMMKVObject/index.js

@@ -1,6 +1,7 @@
 import {useMMKVString} from 'react-native-mmkv';
 import {useMemo} from 'react';
 import Crashlytics from '../../utils/crashlytics';
+import errorParser from '../../utils/errorParser';
 
 export const useMMKVObject = (key, defaultValue = null) => {
 	const [raw] = useMMKVString(key);
@@ -10,7 +11,8 @@ export const useMMKVObject = (key, defaultValue = null) => {
 		try {
 			return JSON.parse(raw);
 		} catch (e) {
-			Crashlytics.recordError(e, `Invalid JSON in MMKV key: ${key}`);
+			const parsedError = errorParser(e);
+			Crashlytics.recordError(parsedError, `Invalid JSON in MMKV key: ${key}`);
 			return defaultValue;
 		}
 	}, [raw]);

package/lib/provider/ShiftTrackingProvider.js

@@ -6,7 +6,6 @@ import {
 	downloadWorkLogTypes,
 	isAuthorizedToUseStaffMS,
 	getShiftWorkLogsFromJanis,
-	saveWorkLogTimesInDB,
 } from '../utils/provider';
 import {
 	CURRENT_WORKLOG_DATA,
@@ -20,7 +19,6 @@ import {
 } from '../constant';
 import {useMMKVObject} from '../hooks/useMMKVObject';
 import {isValidObject, promiseWrapper} from '../utils/helpers';
-import Crashlytics from '../utils/crashlytics';
 import Storage from '../db/StorageService';
 
 const ShiftTrackingProvider = ({children, onError = null}) => {
@@ -129,7 +127,7 @@ const ShiftTrackingProvider = ({children, onError = null}) => {
 			return;
 		}
 
-		const {openWorkLogs, closedWorkLogs} = workLogs;
+		const {openWorkLogs} = workLogs;
 		const [currentWorkLog = {}] = openWorkLogs;
 		const isExcludedWork = EXCLUDED_WORKLOG_TYPES.includes(currentWorkLog?.referenceId);
 
@@ -142,14 +140,6 @@ const ShiftTrackingProvider = ({children, onError = null}) => {
 			Storage.set(SHIFT_STATUS, 'paused');
 		}
 
-		const promises = [currentWorkLog, ...closedWorkLogs].map((workLog) =>
-			saveWorkLogTimesInDB(workLog).catch((workLogError) => {
-				Crashlytics.recordError(workLogError, 'error trying to save work log times in db', workLog);
-			})
-		);
-
-		await Promise.all(promises);
-
 		setOpenShiftResult((prev) => ({
 			...prev,
 			getWorkLogs: false,

package/lib/utils/errorParser/index.js

@@ -0,0 +1,16 @@
+/**
+ * @description Parse the error to a readable format
+ * @param {Error} error - The error to parse
+ * @returns {Error} The parsed error
+ */
+
+const errorParser = (error = {}) => {
+	if (error instanceof Error) return error;
+
+	const {result = {}, message} = error;
+	const reportedError = result?.message || message;
+
+	return new Error(reportedError);
+};
+
+export default errorParser;

package/lib/utils/provider/downloadWorkLogTypes/index.js

@@ -4,6 +4,7 @@ import {WORKLOG_TYPES_DATA, WORKLOG_TYPES_EXPIRATION_TIME} from '../../../consta
 import Storage from '../../../db/StorageService';
 import Crashlytics from '../../crashlytics';
 import {isFunction} from '../../helpers';
+import errorParser from '../../errorParser';
 
 const downloadWorkLogTypes = async (onDownloadError) => {
 	try {
@@ -21,9 +22,10 @@ const downloadWorkLogTypes = async (onDownloadError) => {
 		Storage.set(WORKLOG_TYPES_DATA, JSON.stringify(data));
 		return null;
 	} catch (error) {
-		Crashlytics.recordError(error, 'Error downloading worklog types');
-		if (isFunction(onDownloadError)) onDownloadError(error);
-		return Promise.reject(error?.result || error);
+		const parsedError = errorParser(error);
+		Crashlytics.recordError(parsedError, 'Error downloading worklog types');
+		if (isFunction(onDownloadError)) onDownloadError(parsedError);
+		return Promise.reject(parsedError);
 	}
 };
 

package/lib/utils/provider/index.js

@@ -2,4 +2,3 @@ export {default as downloadWorkLogTypes} from './downloadWorkLogTypes';
 export {default as openShift} from './openShift';
 export {default as isAuthorizedToUseStaffMS} from './isAuthorizedToUseStaffMS';
 export {default as getShiftWorkLogsFromJanis} from './getShiftWorkLogsFromJanis';
-export {default as saveWorkLogTimesInDB} from './saveWorkLogTimesInDB';

package/lib/utils/provider/isAuthorizedToUseStaffMS/index.js

@@ -3,6 +3,7 @@ import {STAFF_AUTH, STAFF_MS_AUTHORIZATION_EXPIRATION_TIME} from '../../../const
 import Storage from '../../../db/StorageService';
 import Shift from '../../../Shift';
 import {getStaffAuthorizationData} from '../../storage';
+import errorParser from '../../errorParser';
 
 const isAuthorizedToUseStaffMS = async () => {
 	try {
@@ -24,7 +25,8 @@ const isAuthorizedToUseStaffMS = async () => {
 
 		return isAuthorized;
 	} catch (error) {
-		Crashlytics.recordError(error, 'Error checking staff MS authorization');
+		const parsedError = errorParser(error);
+		Crashlytics.recordError(parsedError, 'Error checking staff MS authorization');
 		const data = {
 			hasStaffAuthorization: false,
 			expirationTime: 0,
@@ -32,7 +34,7 @@ const isAuthorizedToUseStaffMS = async () => {
 		};
 		Storage.set(STAFF_AUTH, JSON.stringify(data));
 
-		return Promise.reject(error);
+		return Promise.reject(parsedError);
 	}
 };
 

package/lib/utils/provider/openShift/index.js

@@ -1,16 +1,11 @@
 import Storage from '../../../db/StorageService';
 import Crashlytics from '../../crashlytics';
-import {
-	SHIFT_ID,
-	SHIFT_STATUS,
-	SHIFT_DATA,
-	CURRENT_WORKLOG_ID,
-	CURRENT_WORKLOG_DATA,
-} from '../../../constant';
+import {SHIFT_ID, SHIFT_STATUS, SHIFT_DATA} from '../../../constant';
 import getUserId from '../../userInfo/getUserId';
 import Shift from '../../../Shift';
 import {isFunction} from '../../helpers';
-import TimeTracker from '../../../db/TimeTrackerService';
+import {deleteStoredWorkLog, setObject} from '../../storage';
+import errorParser from '../../errorParser';
 
 const openShift = async (onOpenShiftError) => {
 	try {
@@ -43,26 +38,20 @@ const openShift = async (onOpenShiftError) => {
 				getWorkLogs: false,
 			};
 
-		Storage.delete(CURRENT_WORKLOG_ID);
-		Storage.delete(CURRENT_WORKLOG_DATA);
+		deleteStoredWorkLog();
 		Storage.set(SHIFT_ID, currentShift.id);
 		Storage.set(SHIFT_STATUS, currentShift.status);
-		Storage.set(SHIFT_DATA, JSON.stringify(currentShift));
-
-		await TimeTracker.addEvent({
-			id: currentShift.id,
-			time: currentShift.startDate,
-			type: 'start',
-		}).catch(() => null);
+		setObject(SHIFT_DATA, currentShift);
 
 		return {
 			openShiftId: currentShift.id,
 			getWorkLogs: true,
 		};
 	} catch (error) {
-		Crashlytics.recordError(error, 'Error opening shift in staff service');
-		if (isFunction(onOpenShiftError)) onOpenShiftError(error);
-		return Promise.reject(error?.result || error);
+		const parsedError = errorParser(error);
+		Crashlytics.recordError(parsedError, 'Error opening shift in staff service');
+		if (isFunction(onOpenShiftError)) onOpenShiftError(parsedError);
+		return Promise.reject(parsedError);
 	}
 };
 

package/lib/utils/storage/deleteStoredWorkLog/index.js

@@ -0,0 +1,9 @@
+import {CURRENT_WORKLOG_DATA, CURRENT_WORKLOG_ID} from '../../../constant';
+import Storage from '../../../db/StorageService';
+
+const deleteStoredWorkLog = () => {
+	Storage.delete(CURRENT_WORKLOG_ID);
+	Storage.delete(CURRENT_WORKLOG_DATA);
+};
+
+export default deleteStoredWorkLog;

package/lib/utils/storage/getStaffAuthorizationData/index.js

@@ -1,6 +1,7 @@
 import Storage from '../../../db/StorageService';
 import {STAFF_AUTH} from '../../../constant';
 import Crashlytics from '../../crashlytics';
+import errorParser from '../../errorParser';
 
 const getStaffAuthorizationData = () => {
 	try {
@@ -13,7 +14,8 @@ const getStaffAuthorizationData = () => {
 			isExpired: expirationTime <= Date.now() || isExpired,
 		};
 	} catch (error) {
-		Crashlytics.recordError(error, 'Error getting staff authorization data');
+		const parsedError = errorParser(error);
+		Crashlytics.recordError(parsedError, 'Error getting staff authorization data');
 		return {
 			hasStaffAuthorization: false,
 			isExpired: true,

package/lib/utils/storage/getWorkLogTypesData/index.js

@@ -1,6 +1,7 @@
 import Storage from '../../../db/StorageService';
 import Crashlytics from '../../crashlytics';
 import {WORKLOG_TYPES_DATA} from '../../../constant';
+import errorParser from '../../errorParser';
 
 /**
  * @description Get the worklog types data from the storage
@@ -25,7 +26,8 @@ const getWorkLogTypesData = () => {
 			isExpired: expirationTime <= Date.now() || !workLogTypes.length,
 		};
 	} catch (error) {
-		Crashlytics.recordError(error, 'Error getting worklogs data');
+		const parsedError = errorParser(error);
+		Crashlytics.recordError(parsedError, 'Error getting worklogs data');
 		return {
 			workLogTypes: [],
 			expirationTime: 0,

package/lib/utils/storage/index.js

@@ -3,6 +3,7 @@ import Storage from '../../db/StorageService';
 export {default as getWorkLogTypesData} from './getWorkLogTypesData';
 export {default as getShiftData} from './getShiftData';
 export {default as getStaffAuthorizationData} from './getStaffAuthorizationData';
+export {default as deleteStoredWorkLog} from './deleteStoredWorkLog';
 
 export const setObject = (key, value) => {
 	const jsonValue = JSON.stringify(value);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@janiscommerce/app-tracking-shift",
-	"version": "1.0.1",
+	"version": "1.2.0",
 	"main": "lib/index.js",
 	"module": "lib/index.js",
 	"exports": {
@@ -47,7 +47,6 @@
 	"peerDependencies": {
 		"@janiscommerce/app-crashlytics": ">=2.1.0",
 		"@janiscommerce/app-request": ">=2.0.0",
-		"@janiscommerce/app-tracking-time": ">=2.2.1",
 		"react": ">=17.0.2 <19",
 		"react-dom": ">=17.0.2 <19",
 		"react-native": ">=0.67.5 <0.75"
@@ -55,8 +54,7 @@
 	"dependencies": {
 		"@janiscommerce/app-device-info": "^1.1.0",
 		"@janiscommerce/oauth-native": "^1.10.2",
-		"react-native-mmkv": "2.12.2",
-		"realm": "11.3.0"
+		"react-native-mmkv": "2.12.2"
 	},
 	"devDependencies": {
 		"@babel/core": "^7.0.0",
@@ -65,7 +63,6 @@
 		"@babel/preset-react": "^7.0.0",
 		"@janiscommerce/app-crashlytics": "^2.1.0",
 		"@janiscommerce/app-request": "^2.6.0",
-		"@janiscommerce/app-tracking-time": "^2.2.1",
 		"@testing-library/react": "^16.3.0",
 		"@testing-library/react-native": "^12.0.1",
 		"babel-jest": "^29.0.0",

package/lib/TrackerRecords.js

@@ -1,103 +0,0 @@
-import TimeTracker from './db/TimeTrackerService';
-import {reverseArray} from './utils/helpers';
-
-class TrackerRecords {
-	async getWorkLogsFromTimeTracker(filteredId) {
-		try {
-			if (!filteredId) throw new Error(`Excluding ID is required, but got ${filteredId}`);
-
-			const events = await this._filterEventsExcludingId(filteredId);
-
-			return events;
-		} catch (error) {
-			return Promise.reject(error);
-		}
-	}
-
-	async getClientShiftActivities(id) {
-		try {
-			const query = 'NOT (id CONTAINS[c] "picking" OR id CONTAINS[c] "delivery") AND id != $0';
-			const clientActivities = await TimeTracker.searchEventByQuery(query, id);
-
-			return clientActivities;
-		} catch (error) {
-			return Promise.reject(error);
-		}
-	}
-
-	async getStartDateById(id) {
-		try {
-			if (!id) throw new Error(`ID is required, but got ${id}`);
-
-			const startShiftEvent = await this._getStartEventById(id);
-
-			return startShiftEvent?.time;
-		} catch (error) {
-			return Promise.reject(error);
-		}
-	}
-
-	async getEndDateById(id) {
-		try {
-			if (!id) throw new Error(`ID is required, but got ${id}`);
-
-			const endShiftEvent = await this._getFinishEventById(id);
-
-			return endShiftEvent?.time;
-		} catch (error) {
-			return Promise.reject(error);
-		}
-	}
-
-	async _getStartEventById(id) {
-		try {
-			const startEvent = await this._filterEventByType(id, 'start');
-
-			const [firstEvent = {}] = startEvent;
-
-			return firstEvent;
-		} catch (error) {
-			return Promise.reject(error);
-		}
-	}
-
-	async _getFinishEventById(id) {
-		try {
-			const finishEvent = await this._filterEventByType(id, 'finish');
-
-			const [lastEvent = {}] = reverseArray(finishEvent);
-
-			return lastEvent;
-		} catch (error) {
-			return Promise.reject(error);
-		}
-	}
-
-	async _filterEventByType(id, type) {
-		try {
-			if (!id) throw new Error('id is required');
-			if (!type) throw new Error('type is required');
-
-			const events = await TimeTracker.searchEventByQuery('id == $0 AND type == $1', id, type);
-			console.log('events', events);
-
-			return events;
-		} catch (error) {
-			return Promise.reject(error);
-		}
-	}
-
-	async _filterEventsExcludingId(id) {
-		try {
-			if (!id) throw new Error('id is required');
-
-			const events = await TimeTracker.searchEventByQuery('id!= $0', id);
-
-			return events;
-		} catch (error) {
-			return Promise.reject(error);
-		}
-	}
-}
-
-export default new TrackerRecords();

package/lib/db/TimeTrackerService.js

@@ -1,5 +0,0 @@
-import EventTrackingService from '@janiscommerce/app-tracking-time';
-
-const TimeTrackerService = new EventTrackingService('shift-tracking');
-
-export default TimeTrackerService;

package/lib/utils/provider/saveWorkLogTimesInDB/index.js

@@ -1,38 +0,0 @@
-import TimeTracker from '../../../db/TimeTrackerService';
-import {isEmptyObject, isObject} from '../../helpers';
-
-const saveWorkLogTimesInDB = async (workLog = {}) => {
-	try {
-		if (!isObject(workLog) || isEmptyObject(workLog)) return false;
-
-		const {startDate, endDate, shiftId, id, referenceId, name} = workLog;
-
-		const dataForDB = {
-			shiftId,
-			referenceId,
-			name,
-		};
-
-		await TimeTracker.addEvent({
-			id,
-			type: 'start',
-			time: startDate,
-			payload: dataForDB,
-		});
-
-		if (endDate) {
-			await TimeTracker.addEvent({
-				id,
-				type: 'finish',
-				time: endDate,
-				payload: dataForDB,
-			});
-		}
-
-		return true;
-	} catch (error) {
-		return Promise.reject(error);
-	}
-};
-
-export default saveWorkLogTimesInDB;