@janiscommerce/app-tracking-shift 1.0.1

package/lib/StaffApiServices.js

@@ -0,0 +1,151 @@
+import Request from './utils/request';
+
+class StaffApiServices {
+	constructor() {
+		this.service = 'staff';
+	}
+
+	/**
+	 * Opens an user's shift
+	 * @returns {Promise<Object>} - Response from the API
+	 */
+
+	async openShift() {
+		try {
+			return await Request.post({
+				service: this.service,
+				namespace: 'shift-open',
+			});
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+
+	/**
+	 * Closes current user's shift
+	 * @returns {Promise<Object>} - Response from the API
+	 */
+
+	async closeShift() {
+		try {
+			return await Request.post({
+				service: this.service,
+				namespace: 'shift-close',
+			});
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+
+	/**
+	 * Posts work logs to the API
+	 * @param {Object|Array<Object>} workLogs - Work log object or array of work log objects
+	 * @param {string} workLogs.workLogTypeRefId - Reference ID of the work log type
+	 * @param {Date} workLogs.startDate - Start date and time of the work log
+	 * @param {Date} workLogs.endDate - End date and time of the work log
+	 * @returns {Promise<Object>} - Response from the API
+	 * @example
+	 * // Single work log object
+	 * postWorklog({
+	 *   workLogTypeRefId: "123",
+	 *   startDate: new Date("2024-01-01T09:00:00"),
+	 *   endDate: new Date("2024-01-01T17:00:00")
+	 * });
+	 *
+	 * // Array of work log objects
+	 * postWorklog([
+	 *   {
+	 *     workLogTypeRefId: "123",
+	 *     startDate: new Date("2024-01-01T09:00:00"),
+	 *     endDate: new Date("2024-01-01T12:00:00")
+	 *   },
+	 *   {
+	 *     workLogTypeRefId: "456",
+	 *     startDate: new Date("2024-01-01T13:00:00"),
+	 *     endDate: new Date("2024-01-01T17:00:00")
+	 *   }
+	 * ]);
+	 */
+	async postWorklog(workLogs) {
+		try {
+			if (!Array.isArray(workLogs)) {
+				workLogs = [workLogs];
+			}
+
+			return await Request.post({
+				service: this.service,
+				namespace: 'work-log',
+				body: [...workLogs],
+			});
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+
+	async getShiftsList(params) {
+		const {filters, sort} = params || {};
+		try {
+			return await Request.list({
+				service: this.service,
+				namespace: 'shift',
+				queryParams: {
+					...(filters && {filters}),
+					...(sort && {sort}),
+				},
+			});
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+
+	async getWorkLogTypes() {
+		try {
+			return await Request.list({
+				service: this.service,
+				namespace: 'work-log-type',
+				headers: {
+					pageSize: 100,
+				},
+				queryParams: {
+					filters: {
+						status: 'active',
+						type: ['work', 'pause', 'problem'],
+						isInternal: 'false',
+					},
+				},
+			});
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+
+	async getSetting(setting) {
+		try {
+			return await Request.get({
+				service: this.service,
+				namespace: 'setting',
+				pathParams: [setting],
+			});
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+
+	async getWorkLogsList(params) {
+		const {filters, sort} = params || {};
+		try {
+			return await Request.list({
+				service: this.service,
+				namespace: 'work-log',
+				queryParams: {
+					...(filters && {filters}),
+					...(sort && {sort}),
+				},
+			});
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+}
+
+export default new StaffApiServices();

package/lib/TrackerRecords.js

@@ -0,0 +1,103 @@
+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/components/WithShiftTracking/index.js

@@ -0,0 +1,36 @@
+import React from 'react';
+import {useShiftTracking} from '../../context/ShiftTrackingContext';
+
+/**
+ * @param {React.Component} WrappedComponent - The component to wrap
+ * @param {Object} options - The options for the component
+ * @param {React.Component} options.pausedShiftComponent - The component to render when the shift is paused
+ * @returns {React.Component} - The wrapped component
+ *
+ * @example
+ * const MyComponent = () => {
+ *   return <div>My Component</div>;
+ * };
+ *
+ * export default WithShiftTracking(MyComponent, {
+ *   pausedShiftComponent: <div>Paused Shift</div>,
+ * });
+ */
+
+const WithShiftTracking = (WrappedComponent, options = {}) => {
+	const {pausedShiftComponent} = options;
+
+	return (props) => {
+		const shiftTrackingData = useShiftTracking();
+		const showPause = shiftTrackingData?.shiftStatus === 'paused' && pausedShiftComponent;
+
+		return (
+			<>
+				{showPause && pausedShiftComponent}
+				<WrappedComponent {...props} shiftData={shiftTrackingData} />
+			</>
+		);
+	};
+};
+
+export default WithShiftTracking;

package/lib/constant/index.js

@@ -0,0 +1,33 @@
+// STORAGE KEYS
+export const SHIFT_ID = 'shift.id';
+export const SHIFT_STATUS = 'shift.status';
+export const SHIFT_DATA = 'shift.data';
+export const WORKLOG_TYPES_DATA = 'worklogTypes.data';
+export const CURRENT_WORKLOG_ID = 'worklog.id';
+export const CURRENT_WORKLOG_DATA = 'worklog.data';
+export const STAFF_AUTH = 'staff.authorization';
+export const OFFLINE_DATA = 'offline.data';
+
+// EXPIRATION TIMES
+export const WORKLOG_TYPES_EXPIRATION_TIME = 4 * 60 * 60 * 1000; // 4 hours
+export const STAFF_MS_AUTHORIZATION_EXPIRATION_TIME = 24 * 60 * 60 * 1000; // 24 hour
+
+// EXCLUDED WORKLOG TYPES
+export const EXCLUDED_WORKLOG_TYPES = ['default-picking-work', 'default-delivery-work'];
+
+// INTERNAL DEFAULT WORKLOGS
+export const INTERNAL_WORKLOGS = {
+	PICKING_WORK: {
+		referenceId: 'default-picking-work',
+		type: 'work',
+		name: 'Default picking work',
+	},
+	DELIVERY_WORK: {
+		referenceId: 'default-delivery-work',
+		type: 'work',
+		name: 'Default delivery work',
+	},
+};
+
+// SHIFT CLOSE EXTENSION
+export const ONE_HOUR_EXTENSION = 60 * 60 * 1000; // 1 hour

package/lib/context/ShiftTrackingContext.js

@@ -0,0 +1,7 @@
+import React from 'react';
+
+const ShiftTrackingContext = React.createContext();
+
+export const useShiftTracking = () => React.useContext(ShiftTrackingContext);
+
+export default ShiftTrackingContext;

package/lib/db/StorageService.js

@@ -0,0 +1,5 @@
+import {MMKV} from 'react-native-mmkv';
+
+const Storage = new MMKV();
+
+export default Storage;

package/lib/db/TimeTrackerService.js

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

package/lib/hooks/useMMKVObject/index.js

@@ -0,0 +1,19 @@
+import {useMMKVString} from 'react-native-mmkv';
+import {useMemo} from 'react';
+import Crashlytics from '../../utils/crashlytics';
+
+export const useMMKVObject = (key, defaultValue = null) => {
+	const [raw] = useMMKVString(key);
+
+	const storageValue = useMemo(() => {
+		if (!raw) return defaultValue;
+		try {
+			return JSON.parse(raw);
+		} catch (e) {
+			Crashlytics.recordError(e, `Invalid JSON in MMKV key: ${key}`);
+			return defaultValue;
+		}
+	}, [raw]);
+
+	return [storageValue];
+};

package/lib/index.js

@@ -0,0 +1,7 @@
+import Shift from './Shift';
+import ShiftTrackingProvider from './provider/ShiftTrackingProvider';
+import {useShiftTracking} from './context/ShiftTrackingContext';
+import WithShiftTracking from './components/WithShiftTracking';
+import {INTERNAL_WORKLOGS} from './constant';
+
+export {Shift, ShiftTrackingProvider, useShiftTracking, WithShiftTracking, INTERNAL_WORKLOGS};

package/lib/provider/ShiftTrackingProvider.js

@@ -0,0 +1,174 @@
+import React, {useEffect, useMemo, useState} from 'react';
+import {useMMKVString} from 'react-native-mmkv';
+import ShiftTrackingContext from '../context/ShiftTrackingContext';
+import {
+	openShift,
+	downloadWorkLogTypes,
+	isAuthorizedToUseStaffMS,
+	getShiftWorkLogsFromJanis,
+	saveWorkLogTimesInDB,
+} from '../utils/provider';
+import {
+	CURRENT_WORKLOG_DATA,
+	CURRENT_WORKLOG_ID,
+	EXCLUDED_WORKLOG_TYPES,
+	SHIFT_DATA,
+	SHIFT_ID,
+	SHIFT_STATUS,
+	STAFF_AUTH,
+	WORKLOG_TYPES_DATA,
+} 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}) => {
+	const [shiftStatus] = useMMKVString(SHIFT_STATUS);
+	const [shiftId] = useMMKVString(SHIFT_ID);
+	const [shiftData] = useMMKVObject(SHIFT_DATA, {});
+
+	const [currentWorkLogId] = useMMKVString(CURRENT_WORKLOG_ID);
+	const [workLogData] = useMMKVObject(WORKLOG_TYPES_DATA, {});
+	const [currentWorkLogData] = useMMKVObject(CURRENT_WORKLOG_DATA, {});
+
+	const [staffAuthData] = useMMKVObject(STAFF_AUTH, {});
+
+	const [error, setError] = useState(null);
+	const [openShiftResult, setOpenShiftResult] = useState({
+		id: null,
+		getWorkLogs: false,
+	});
+	const [isShiftLoading, setIsShiftLoading] = useState(false);
+
+	const {workLogTypes = []} = workLogData;
+	const {hasStaffAuthorization = false} = staffAuthData;
+
+	const contextValues = useMemo(() => {
+		return {
+			shiftId,
+			shiftStatus,
+			shiftData,
+			workLogTypes,
+			currentWorkLogData,
+			currentWorkLogId,
+			hasStaffAuthorization,
+			error,
+			isShiftLoading,
+		};
+	}, [
+		shiftId,
+		shiftStatus,
+		shiftData,
+		workLogTypes,
+		currentWorkLogData,
+		currentWorkLogId,
+		error,
+		hasStaffAuthorization,
+		isShiftLoading,
+	]);
+
+	const handleShiftTrackingInit = async () => {
+		setIsShiftLoading(true);
+		const [isAuthorized, authError] = await promiseWrapper(isAuthorizedToUseStaffMS());
+
+		if (authError) {
+			setIsShiftLoading(false);
+			setError({
+				message: authError?.message,
+				type: 'staffMSAuthorization',
+			});
+			return;
+		}
+
+		if (!isAuthorized) {
+			setIsShiftLoading(false);
+			return;
+		}
+
+		const [shiftResult, openError] = await promiseWrapper(openShift(onError));
+
+		if (openError) {
+			setIsShiftLoading(false);
+			setError({
+				message: openError?.message,
+				type: 'openShift',
+			});
+			return;
+		}
+
+		const {openShiftId, getWorkLogs} = shiftResult;
+
+		setOpenShiftResult((prev) => ({
+			...prev,
+			id: openShiftId,
+			getWorkLogs,
+		}));
+
+		const [, downloadError] = await promiseWrapper(downloadWorkLogTypes(onError));
+
+		setIsShiftLoading(false);
+		if (downloadError) {
+			setError({
+				message: downloadError?.message,
+				type: 'downloadWorkLogTypes',
+			});
+		}
+	};
+
+	const getShiftWorkLogsHistory = async () => {
+		const [workLogs, workLogsError] = await promiseWrapper(
+			getShiftWorkLogsFromJanis(openShiftResult.id)
+		);
+
+		if (workLogsError) {
+			setError({
+				message: workLogsError?.message,
+				type: 'getWorkLogsFromJanis',
+			});
+			return;
+		}
+
+		const {openWorkLogs, closedWorkLogs} = workLogs;
+		const [currentWorkLog = {}] = openWorkLogs;
+		const isExcludedWork = EXCLUDED_WORKLOG_TYPES.includes(currentWorkLog?.referenceId);
+
+		if (isValidObject(currentWorkLog)) {
+			Storage.set(CURRENT_WORKLOG_ID, currentWorkLog.id);
+			Storage.set(CURRENT_WORKLOG_DATA, JSON.stringify(currentWorkLog));
+		}
+
+		if (isValidObject(currentWorkLog) && !isExcludedWork) {
+			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,
+		}));
+	};
+
+	useEffect(() => {
+		handleShiftTrackingInit();
+	}, []);
+
+	useEffect(() => {
+		if (openShiftResult?.id && openShiftResult?.getWorkLogs) {
+			getShiftWorkLogsHistory();
+		}
+	}, [openShiftResult]);
+
+	return (
+		<ShiftTrackingContext.Provider value={contextValues}>{children}</ShiftTrackingContext.Provider>
+	);
+};
+
+export default ShiftTrackingProvider;

package/lib/utils/crashlytics/index.js

@@ -0,0 +1,5 @@
+import CrashlyticsClass from '@janiscommerce/app-crashlytics';
+
+const Crashlytics = new CrashlyticsClass();
+
+export default Crashlytics;

package/lib/utils/helpers/index.js

@@ -0,0 +1,20 @@
+export const generateRandomId = () => Math.random().toString(32).slice(2);
+
+export const isFunction = (fn) => !!({}.toString.call(fn) === '[object Function]');
+
+export const isObject = (obj) => !!(obj && obj.constructor === Object);
+
+export const isEmptyObject = (obj) => isObject(obj) && !Object.keys(obj).length;
+
+export const promiseWrapper = (promise) =>
+	promise.then((data) => [data, null]).catch((error) => Promise.resolve([null, error]));
+
+export const isArray = (arr) => Array.isArray(arr);
+
+export const isEmptyArray = (arr) => isArray(arr) && !arr.length;
+
+export const reverseArray = (arr) => arr.slice().reverse();
+
+export const isNumber = (num) => typeof num === 'number' && !Number.isNaN(Number(num));
+
+export const isValidObject = (obj) => isObject(obj) && !!Object.keys(obj).length;

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

@@ -0,0 +1,30 @@
+import Shift from '../../../Shift';
+import {getWorkLogTypesData} from '../../storage';
+import {WORKLOG_TYPES_DATA, WORKLOG_TYPES_EXPIRATION_TIME} from '../../../constant';
+import Storage from '../../../db/StorageService';
+import Crashlytics from '../../crashlytics';
+import {isFunction} from '../../helpers';
+
+const downloadWorkLogTypes = async (onDownloadError) => {
+	try {
+		const {isExpired} = getWorkLogTypesData();
+
+		if (!isExpired) return null;
+
+		const workLogTypes = await Shift.fetchWorklogTypes();
+
+		const data = {
+			workLogTypes,
+			expirationTime: Date.now() + WORKLOG_TYPES_EXPIRATION_TIME,
+		};
+
+		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);
+	}
+};
+
+export default downloadWorkLogTypes;

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

@@ -0,0 +1,18 @@
+import Formatter from '../../../Formatter';
+import Shift from '../../../Shift';
+
+const getShiftWorkLogsFromJanis = async (shiftId) => {
+	try {
+		const formattedWorkLogs = await Shift.getWorkLogs(shiftId);
+		const [openWorkLogs, closedWorkLogs] = Formatter.splitWorkLogsByStatus(formattedWorkLogs);
+
+		return {
+			openWorkLogs,
+			closedWorkLogs,
+		};
+	} catch (error) {
+		return Promise.reject(error);
+	}
+};
+
+export default getShiftWorkLogsFromJanis;

package/lib/utils/provider/index.js

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,39 @@
+import Crashlytics from '../../crashlytics';
+import {STAFF_AUTH, STAFF_MS_AUTHORIZATION_EXPIRATION_TIME} from '../../../constant';
+import Storage from '../../../db/StorageService';
+import Shift from '../../../Shift';
+import {getStaffAuthorizationData} from '../../storage';
+
+const isAuthorizedToUseStaffMS = async () => {
+	try {
+		Crashlytics.log('checking staff MS authorization');
+		const {hasStaffAuthorization, isExpired} = getStaffAuthorizationData();
+
+		if (hasStaffAuthorization && !isExpired) return true;
+		if (!hasStaffAuthorization && !isExpired) return false;
+
+		const isAuthorized = await Shift.checkStaffMSAuthorization();
+
+		const data = {
+			hasStaffAuthorization: isAuthorized,
+			expirationTime: Date.now() + STAFF_MS_AUTHORIZATION_EXPIRATION_TIME,
+			isExpired: false,
+		};
+
+		Storage.set(STAFF_AUTH, JSON.stringify(data));
+
+		return isAuthorized;
+	} catch (error) {
+		Crashlytics.recordError(error, 'Error checking staff MS authorization');
+		const data = {
+			hasStaffAuthorization: false,
+			expirationTime: 0,
+			isExpired: true,
+		};
+		Storage.set(STAFF_AUTH, JSON.stringify(data));
+
+		return Promise.reject(error);
+	}
+};
+
+export default isAuthorizedToUseStaffMS;