@larisarozin/dodone-shared 1.0.0

package/dist/hooks/useTeam.d.ts

@@ -0,0 +1,24 @@
+import type { User } from "../types/User";
+import { PagedListRequest, PagedListResponse } from "../utils/paging";
+import { TeamDetailsResponse, TeamDetailsUpdateRequest, TeamAllowanceIntervalResponse, TeamAllowanceIntervalCreateRequest, TeamAllowanceIntervalUpdateRequest } from "../types/Team";
+export declare function useTeam(request: PagedListRequest): {
+    teamMembersList: PagedListResponse<User> | undefined;
+    loadingTeamMembers: boolean;
+    refreshTeamMembers: (request: PagedListRequest) => void;
+    teamDetails: TeamDetailsResponse | null;
+    loadingTeamDetails: boolean;
+    updatingTeamDetails: boolean;
+    fetchTeamDetails: () => Promise<any>;
+    updateTeamDetails: (teamUpdateRequest: TeamDetailsUpdateRequest) => Promise<import("..").DataResponse<TeamDetailsResponse> | null>;
+    allowanceIntervals: TeamAllowanceIntervalResponse[];
+    loadingAllowanceIntervals: boolean;
+    creatingAllowanceInterval: boolean;
+    updatingAllowanceInterval: boolean;
+    deletingAllowanceInterval: boolean;
+    fetchingAllowanceInterval: boolean;
+    fetchAllowanceIntervals: () => Promise<import("../types/Team").TeamAllowanceIntervalListResponse | null>;
+    fetchAllowanceInterval: (id: number) => Promise<TeamAllowanceIntervalResponse | null>;
+    createAllowanceInterval: (request: TeamAllowanceIntervalCreateRequest) => Promise<TeamAllowanceIntervalResponse | null>;
+    updateAllowanceInterval: (request: TeamAllowanceIntervalUpdateRequest) => Promise<TeamAllowanceIntervalResponse | null>;
+    deleteAllowanceInterval: (id: number) => Promise<boolean>;
+};

package/dist/hooks/useTeam.js

@@ -0,0 +1,255 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTeam = useTeam;
+const react_1 = require("react");
+const useConfig_1 = require("../config/useConfig");
+const useAuth_1 = require("./auth/useAuth");
+const ApiClient_1 = require("../utils/ApiClient");
+function useTeam(request) {
+    const { token } = (0, useAuth_1.useAuth)();
+    const { baseUrl } = (0, useConfig_1.useConfig)();
+    const [pagedListRequest, setPagedListRequest] = (0, react_1.useState)(request);
+    const [teamMembersList, setPagedTeam] = (0, react_1.useState)();
+    const [loadingTeamMembers, setLoading] = (0, react_1.useState)(true);
+    const [teamDetails, setTeamDetails] = (0, react_1.useState)(null);
+    const [loadingTeamDetails, setLoadingTeamDetails] = (0, react_1.useState)(false);
+    const [updatingTeamDetails, setUpdatingTeamDetails] = (0, react_1.useState)(false);
+    const [allowanceIntervals, setAllowanceIntervals] = (0, react_1.useState)([]);
+    const [loadingAllowanceIntervals, setLoadingAllowanceIntervals] = (0, react_1.useState)(false);
+    const [creatingAllowanceInterval, setCreatingAllowanceInterval] = (0, react_1.useState)(false);
+    const [updatingAllowanceInterval, setUpdatingAllowanceInterval] = (0, react_1.useState)(false);
+    const [deletingAllowanceInterval, setDeletingAllowanceInterval] = (0, react_1.useState)(false);
+    const [fetchingAllowanceInterval, setFetchingAllowanceInterval] = (0, react_1.useState)(false);
+    const fetchTeamMembers = (0, react_1.useCallback)((requestToUse) => __awaiter(this, void 0, void 0, function* () {
+        const requestToFetch = requestToUse || pagedListRequest;
+        if (!token) {
+            setLoading(false);
+            return;
+        }
+        if (!requestToFetch) {
+            console.error("No request available for fetching team members");
+            setLoading(false);
+            return;
+        }
+        setLoading(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const data = yield apiClient.teams.getTeamMembers(requestToFetch);
+            if (!data || data.success === false) {
+                console.error("Failed to fetch team members:", (data === null || data === void 0 ? void 0 : data.message) || "Unknown error");
+                setLoading(false);
+                return;
+            }
+            setPagedTeam(data);
+        }
+        catch (error) {
+            console.error("Error fetching team members:", error);
+        }
+        finally {
+            setLoading(false);
+        }
+    }), [token, baseUrl]);
+    function refreshTeamMembers(request) {
+        setPagedListRequest(request);
+        // Pass the request directly to fetchTeam to avoid state timing issues
+        fetchTeamMembers(request);
+    }
+    const fetchTeamDetails = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+        if (!token) {
+            return;
+        }
+        setLoadingTeamDetails(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const data = yield apiClient.teams.getTeamDetails();
+            if (!data || data.success === false) {
+                console.error("Failed to fetch team details:", (data === null || data === void 0 ? void 0 : data.message) || "Unknown error");
+                return null;
+            }
+            setTeamDetails(data);
+            return data;
+        }
+        catch (error) {
+            console.error("Error fetching team details:", error);
+            return null;
+        }
+        finally {
+            setLoadingTeamDetails(false);
+        }
+    }), [token, baseUrl]);
+    const updateTeamDetails = (0, react_1.useCallback)((teamUpdateRequest) => __awaiter(this, void 0, void 0, function* () {
+        if (!token) {
+            return null;
+        }
+        setUpdatingTeamDetails(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const response = yield apiClient.teams.updateTeamDetails(teamUpdateRequest);
+            if (!response || response.success === false) {
+                console.error("Failed to update team details:", (response === null || response === void 0 ? void 0 : response.message) || "Unknown error");
+                return null;
+            }
+            // Update local state with the updated team details
+            if (response.data) {
+                // Convert TeamResponse to TeamDetailsResponse format for consistency
+                const updatedTeamDetails = Object.assign({}, response.data);
+                setTeamDetails(updatedTeamDetails);
+            }
+            return response;
+        }
+        catch (error) {
+            console.error("Error updating team details:", error);
+            return null;
+        }
+        finally {
+            setUpdatingTeamDetails(false);
+        }
+    }), [token, baseUrl]);
+    const fetchAllowanceIntervals = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+        if (!token) {
+            return null;
+        }
+        setLoadingAllowanceIntervals(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const data = yield apiClient.teams.getTeamAllowanceIntervals();
+            setAllowanceIntervals(data.allowanceIntervals || []);
+            return data;
+        }
+        catch (error) {
+            console.error("Error fetching allowance intervals:", error);
+            return null;
+        }
+        finally {
+            setLoadingAllowanceIntervals(false);
+        }
+    }), [token, baseUrl]);
+    const fetchAllowanceInterval = (0, react_1.useCallback)((id) => __awaiter(this, void 0, void 0, function* () {
+        if (!token) {
+            return null;
+        }
+        setFetchingAllowanceInterval(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const data = yield apiClient.teams.getTeamAllowanceInterval(id);
+            return data;
+        }
+        catch (error) {
+            console.error("Error fetching allowance interval:", error);
+            return null;
+        }
+        finally {
+            setFetchingAllowanceInterval(false);
+        }
+    }), [token, baseUrl]);
+    const createAllowanceInterval = (0, react_1.useCallback)((request) => __awaiter(this, void 0, void 0, function* () {
+        if (!token) {
+            return null;
+        }
+        setCreatingAllowanceInterval(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const response = yield apiClient.teams.createTeamAllowanceInterval(request);
+            // Refresh the allowance intervals list after creation
+            yield fetchAllowanceIntervals();
+            return response;
+        }
+        catch (error) {
+            console.error("Error creating allowance interval:", error);
+            return null;
+        }
+        finally {
+            setCreatingAllowanceInterval(false);
+        }
+    }), [token, baseUrl, fetchAllowanceIntervals]);
+    const updateAllowanceInterval = (0, react_1.useCallback)((request) => __awaiter(this, void 0, void 0, function* () {
+        if (!token) {
+            return null;
+        }
+        setUpdatingAllowanceInterval(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const response = yield apiClient.teams.updateTeamAllowanceInterval(request);
+            // Update the local state with the updated allowance interval
+            setAllowanceIntervals(prev => prev.map(interval => interval.id === request.id ? response : interval));
+            return response;
+        }
+        catch (error) {
+            console.error("Error updating allowance interval:", error);
+            return null;
+        }
+        finally {
+            setUpdatingAllowanceInterval(false);
+        }
+    }), [token, baseUrl]);
+    const deleteAllowanceInterval = (0, react_1.useCallback)((id) => __awaiter(this, void 0, void 0, function* () {
+        if (!token) {
+            return false;
+        }
+        setDeletingAllowanceInterval(true);
+        try {
+            const apiClient = (0, ApiClient_1.createApiClient)(baseUrl, token);
+            const success = yield apiClient.teams.deleteTeamAllowanceInterval(id);
+            if (!success) {
+                console.error("Failed to delete allowance interval");
+                return false;
+            }
+            // Remove the deleted interval from local state
+            setAllowanceIntervals(prev => prev.filter(interval => interval.id !== id));
+            return true;
+        }
+        catch (error) {
+            console.error("Error deleting allowance interval:", error);
+            return false;
+        }
+        finally {
+            setDeletingAllowanceInterval(false);
+        }
+    }), [token, baseUrl]);
+    (0, react_1.useEffect)(() => {
+        if (!token) {
+            return;
+        }
+        // Only fetch on initial load if we have a valid request
+        fetchTeamDetails();
+        fetchAllowanceIntervals();
+        if (pagedListRequest) {
+            fetchTeamMembers(pagedListRequest);
+        }
+    }, [fetchTeamDetails, fetchAllowanceIntervals, fetchTeamMembers, pagedListRequest]);
+    return {
+        teamMembersList,
+        loadingTeamMembers,
+        refreshTeamMembers,
+        teamDetails,
+        loadingTeamDetails,
+        updatingTeamDetails,
+        fetchTeamDetails,
+        updateTeamDetails,
+        allowanceIntervals,
+        loadingAllowanceIntervals,
+        creatingAllowanceInterval,
+        updatingAllowanceInterval,
+        deletingAllowanceInterval,
+        fetchingAllowanceInterval,
+        fetchAllowanceIntervals,
+        fetchAllowanceInterval,
+        createAllowanceInterval,
+        updateAllowanceInterval,
+        deleteAllowanceInterval
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+export * from './types/User';
+export * from './types/TaskItem';
+export * from './types/ApiResponse';
+export * from './api/routes';
+export * from './hooks/auth/useAuth';
+export * from './hooks/auth/AuthState';
+export * from './hooks/auth/AuthProvider';
+export * from './hooks/auth/AuthContext';
+export * from './hooks/useTeam';
+export * from './hooks/useTaskItems';
+export * from './hooks/useTaskGroups';
+export * from './hooks/useTaskKinds';
+export * from './hooks/useTaskCategories';
+export * from './hooks/useTaskComments';
+export * from './hooks/useGrades';
+export * from './hooks/useAllowanceHistories';
+export * from './hooks/useAllowanceHistoryTaskItems';
+export * from './hooks/useNotificationPreferences';
+export * from './config/ConfigContext';
+export * from './config/ConfigProvider';
+export * from './config/useConfig';
+export * from './utils/storage';
+export * from './utils/ApiClient';
+export * from './utils/paging';
+export * from './types/DeviceRegistration';
+export * from './types/AllowanceHistory';
+export * from './types/UserNotificationPreferences';
+export * from './types/AllowanceInterval';
+export * from './types/Team';

package/dist/index.js

@@ -0,0 +1,50 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/User"), exports);
+__exportStar(require("./types/TaskItem"), exports);
+__exportStar(require("./types/ApiResponse"), exports);
+__exportStar(require("./api/routes"), exports);
+__exportStar(require("./hooks/auth/useAuth"), exports);
+__exportStar(require("./hooks/auth/AuthState"), exports);
+__exportStar(require("./hooks/auth/AuthProvider"), exports);
+__exportStar(require("./hooks/auth/AuthContext"), exports);
+__exportStar(require("./hooks/useTeam"), exports);
+__exportStar(require("./hooks/useTaskItems"), exports);
+__exportStar(require("./hooks/useTaskGroups"), exports);
+__exportStar(require("./hooks/useTaskKinds"), exports);
+__exportStar(require("./hooks/useTaskCategories"), exports);
+__exportStar(require("./hooks/useTaskComments"), exports);
+__exportStar(require("./hooks/useGrades"), exports);
+__exportStar(require("./hooks/useAllowanceHistories"), exports);
+__exportStar(require("./hooks/useAllowanceHistoryTaskItems"), exports);
+__exportStar(require("./hooks/useNotificationPreferences"), exports);
+__exportStar(require("./config/ConfigContext"), exports);
+__exportStar(require("./config/ConfigProvider"), exports);
+__exportStar(require("./config/useConfig"), exports);
+__exportStar(require("./utils/storage"), exports);
+__exportStar(require("./utils/ApiClient"), exports);
+__exportStar(require("./utils/paging"), exports);
+__exportStar(require("./types/DeviceRegistration"), exports);
+__exportStar(require("./types/AllowanceHistory"), exports);
+__exportStar(require("./types/UserNotificationPreferences"), exports);
+__exportStar(require("./types/AllowanceInterval"), exports);
+__exportStar(require("./types/Team"), exports);

package/dist/types/AllowanceHistory.d.ts

@@ -0,0 +1,66 @@
+import { PagingRequest } from "../utils/paging";
+import { AllowanceDayOfWeek, AllowanceIntervalType } from "./AllowanceInterval";
+export interface AllowanceHistoryResponse {
+    id: number;
+    teamId: number;
+    userId?: number;
+    teamAllowanceIntervalId: number;
+    teamAllowanceIntervalName: string;
+    allowanceIntervalType: AllowanceIntervalType;
+    allowanceIntervalValue: number;
+    allowanceStartDayOfWeek?: AllowanceDayOfWeek;
+    allowanceStartMonthOfYear?: number;
+    calculatedStartAt: string;
+    actualStartAt: string;
+    calculatedEndAt: string;
+    totalCredits: number;
+    gpa: number;
+    calculatedAmount: number;
+    approvedAmount?: number;
+    isApproved: boolean;
+    isRejected: boolean;
+    comment?: string;
+    createdAt: string;
+    createdBy?: number;
+    updatedAt?: string;
+    updatedBy?: number;
+    approvedAt?: string;
+    approvedBy?: number;
+    claimedAt?: string;
+}
+export interface AllowanceHistoryApprovalRequest {
+    id: number;
+    approvedAmount?: number;
+    comment?: string;
+}
+export interface AllowanceHistoryClaimRequest {
+    id: number;
+}
+export interface AllowanceHistoryTaskItemResponse {
+    id: number;
+    allowanceHistoryId: number;
+    taskItemId: number;
+    credits: number;
+    gradeId: number;
+    percentComplete: number;
+    completedAt?: string;
+    completedBy?: number;
+    assignedTo: number;
+    assignedBy: number;
+    assignedAt?: string;
+    gradedAt?: string;
+    gradedBy?: number;
+    createdAt: string;
+    updatedAt?: string;
+}
+export interface PagedAllowanceHistoriesListRequest {
+    teamId: number;
+    userId?: number;
+    startAt?: string;
+    endAt?: string;
+    paging: PagingRequest;
+}
+export interface PagedAllowanceHistoryTaskItemsListRequest {
+    allowanceHistoryId: number;
+    paging: PagingRequest;
+}

package/dist/types/AllowanceHistory.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/AllowanceInterval.d.ts

@@ -0,0 +1,29 @@
+export declare enum AllowanceIntervalType {
+    Weekly = 1,
+    Monthly = 2,
+    Quarterly = 3,
+    SchoolYear = 4
+}
+export declare enum AllowanceDayOfWeek {
+    Sunday = 0,
+    Monday = 1,
+    Tuesday = 2,
+    Wednesday = 3,
+    Thursday = 4,
+    Friday = 5,
+    Saturday = 6
+}
+export declare enum AllowanceMonthOfYear {
+    January = 1,
+    February = 2,
+    March = 3,
+    April = 4,
+    May = 5,
+    June = 6,
+    July = 7,
+    August = 8,
+    September = 9,
+    October = 10,
+    November = 11,
+    December = 12
+}

package/dist/types/AllowanceInterval.js

@@ -0,0 +1,40 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllowanceMonthOfYear = exports.AllowanceDayOfWeek = exports.AllowanceIntervalType = void 0;
+var AllowanceIntervalType;
+(function (AllowanceIntervalType) {
+    AllowanceIntervalType[AllowanceIntervalType["Weekly"] = 1] = "Weekly";
+    AllowanceIntervalType[AllowanceIntervalType["Monthly"] = 2] = "Monthly";
+    AllowanceIntervalType[AllowanceIntervalType["Quarterly"] = 3] = "Quarterly";
+    AllowanceIntervalType[AllowanceIntervalType["SchoolYear"] = 4] = "SchoolYear";
+})(AllowanceIntervalType || (exports.AllowanceIntervalType = AllowanceIntervalType = {}));
+var AllowanceDayOfWeek;
+(function (AllowanceDayOfWeek) {
+    AllowanceDayOfWeek[AllowanceDayOfWeek["Sunday"] = 0] = "Sunday";
+    AllowanceDayOfWeek[AllowanceDayOfWeek["Monday"] = 1] = "Monday";
+    AllowanceDayOfWeek[AllowanceDayOfWeek["Tuesday"] = 2] = "Tuesday";
+    AllowanceDayOfWeek[AllowanceDayOfWeek["Wednesday"] = 3] = "Wednesday";
+    AllowanceDayOfWeek[AllowanceDayOfWeek["Thursday"] = 4] = "Thursday";
+    AllowanceDayOfWeek[AllowanceDayOfWeek["Friday"] = 5] = "Friday";
+    AllowanceDayOfWeek[AllowanceDayOfWeek["Saturday"] = 6] = "Saturday";
+})(AllowanceDayOfWeek || (exports.AllowanceDayOfWeek = AllowanceDayOfWeek = {}));
+var AllowanceMonthOfYear;
+(function (AllowanceMonthOfYear) {
+    AllowanceMonthOfYear[AllowanceMonthOfYear["January"] = 1] = "January";
+    AllowanceMonthOfYear[AllowanceMonthOfYear["February"] = 2] = "February";
+    AllowanceMonthOfYear[AllowanceMonthOfYear["March"] = 3] = "March";
+    AllowanceMonthOfYear[AllowanceMonthOfYear["April"] = 4] = "April";
+    AllowanceMonthOfYear[AllowanceMonthOfYear["May"] = 5] = "May";
+    AllowanceMonthOfYear[AllowanceMonthOfYear["June"] = 6] = "June";
+    AllowanceMonthOfYear[AllowanceMonthOfYear["July"] = 7] = "July";
+    AllowanceMonthOfYear[AllowanceMonthOfYear["August"] = 8] = "August";
+    AllowanceMonthOfYear[AllowanceMonthOfYear["September"] = 9] = "September";
+    AllowanceMonthOfYear[AllowanceMonthOfYear["October"] = 10] = "October";
+    AllowanceMonthOfYear[AllowanceMonthOfYear["November"] = 11] = "November";
+    AllowanceMonthOfYear[AllowanceMonthOfYear["December"] = 12] = "December";
+})(AllowanceMonthOfYear || (exports.AllowanceMonthOfYear = AllowanceMonthOfYear = {}));

package/dist/types/ApiResponse.d.ts

@@ -0,0 +1,7 @@
+export interface ResponseBase {
+    success: boolean;
+    message?: string;
+}
+export interface DataResponse<T> extends ResponseBase {
+    data: T;
+}

package/dist/types/ApiResponse.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/DeviceRegistration.d.ts

@@ -0,0 +1,6 @@
+export interface DeviceRegistrationRequest {
+    deviceId: string;
+    fcmToken: string;
+    platform: "ios" | "android" | "windows" | "macos" | "web";
+    timezone: string;
+}

package/dist/types/DeviceRegistration.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Larisa Rozin
+ * dodone-shared - Task Management, Allowance & Bonus Tracking Application Package
+ * All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });