@larisarozin/dodone-shared 1.0.0

package/dist/utils/ApiClient.js

@@ -0,0 +1,608 @@
+"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.ApiClient = void 0;
+exports.createApiClient = createApiClient;
+exports.apiCall = apiCall;
+class ApiClient {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Private helper to process ResponseBase for endpoints that don't return data
+     * @param response - The fetch response
+     * @param route - API route for error messaging
+     * @returns Promise with the parsed ResponseBase
+     */
+    processNoDataResponse(response, route) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const baseResponse = yield response.json();
+            if (!baseResponse.success) {
+                console.error(`Error with ${route}:`, baseResponse.message);
+                throw new Error(baseResponse.message || `Failed to process ${route}`);
+            }
+            return baseResponse.success;
+        });
+    }
+    /**
+     * Private helper to process DataResponse for endpoints that return data
+     * @param response - The fetch response
+     * @param route - API route for error messaging
+     * @returns Promise with the unpacked data
+     */
+    processDataResponse(response, route) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataResponse = yield response.json();
+            if (!dataResponse.success) {
+                console.error(`Error with ${route}:`, dataResponse.message);
+                throw new Error(dataResponse.message || `Failed to process ${route}`);
+            }
+            return dataResponse.data;
+        });
+    }
+    /**
+     * Makes an authenticated GET request with standardized error handling
+     * Always processes DataResponse wrapper
+     * @param route - API route (will be concatenated with baseUrl)
+     * @param options - Additional fetch options
+     * @returns Promise with the response data
+     */
+    get(route_1) {
+        return __awaiter(this, arguments, void 0, function* (route, options = {}, processDataResponse = true) {
+            const response = yield fetch(this.config.baseUrl + route, Object.assign(Object.assign({}, options), { headers: Object.assign({ Authorization: `Bearer ${this.config.token}` }, options.headers) }));
+            if (!response.ok) {
+                console.error(`Error fetching ${route}:`, response.statusText);
+                throw new Error(`Failed to fetch ${route}`);
+            }
+            if (processDataResponse)
+                return this.processDataResponse(response, route);
+            else
+                return response.json(); // Skip DataResponse processing if specified
+        });
+    }
+    /**
+     * Makes an authenticated POST request with standardized error handling
+     * Always processes DataResponse wrapper
+     */
+    post(route_1, body_1) {
+        return __awaiter(this, arguments, void 0, function* (route, body, options = {}, processDataResponse = true) {
+            const response = yield fetch(this.config.baseUrl + route, Object.assign(Object.assign({ method: 'POST' }, options), { headers: Object.assign({ 'Content-Type': 'application/json', Authorization: `Bearer ${this.config.token}` }, options.headers), body: body ? JSON.stringify(body) : undefined }));
+            if (!response.ok) {
+                console.error(`Error posting to ${route}:`, response.statusText);
+                throw new Error(`Failed to post to ${route}`);
+            }
+            if (processDataResponse)
+                return this.processDataResponse(response, route);
+            else
+                return response.json(); // Skip DataResponse processing if specified
+        });
+    }
+    postMultimedia(route_1, body_1) {
+        return __awaiter(this, arguments, void 0, function* (route, body, options = {}) {
+            const response = yield fetch(this.config.baseUrl + route, Object.assign(Object.assign({ method: 'POST' }, options), { headers: Object.assign({ Authorization: `Bearer ${this.config.token}` }, options.headers), body: body }));
+            if (!response.ok) {
+                console.error(`Error posting to ${route}:`, response.statusText);
+                throw new Error(`Failed to post to ${route}`);
+            }
+            return response.json();
+        });
+    }
+    postNoData(route_1, body_1) {
+        return __awaiter(this, arguments, void 0, function* (route, body, options = {}) {
+            const response = yield fetch(this.config.baseUrl + route, Object.assign(Object.assign({ method: 'POST' }, options), { headers: Object.assign({ 'Content-Type': 'application/json', Authorization: `Bearer ${this.config.token}` }, options.headers), body: body ? JSON.stringify(body) : undefined }));
+            if (!response.ok) {
+                console.error(`Error posting to ${route}:`, response.statusText);
+                throw new Error(`Failed to post to ${route}`);
+            }
+            return this.processNoDataResponse(response, route);
+        });
+    }
+    postDontProcess(route_1, body_1) {
+        return __awaiter(this, arguments, void 0, function* (route, body, options = {}) {
+            const response = yield fetch(this.config.baseUrl + route, Object.assign(Object.assign({ method: 'POST' }, options), { headers: Object.assign({ 'Content-Type': 'application/json', Authorization: `Bearer ${this.config.token}` }, options.headers), body: body ? JSON.stringify(body) : undefined }));
+            if (!response.ok) {
+                console.error(`Error posting to ${route}:`, response.statusText);
+                throw new Error(`Failed to post to ${route}`);
+            }
+            return response.json();
+        });
+    }
+    /**
+     * Makes an authenticated PUT request with standardized error handling
+     * Always processes DataResponse wrapper
+     */
+    put(route_1, body_1) {
+        return __awaiter(this, arguments, void 0, function* (route, body, options = {}, processDataResponse = true) {
+            const response = yield fetch(this.config.baseUrl + route, Object.assign(Object.assign({ method: 'PUT' }, options), { headers: Object.assign({ 'Content-Type': 'application/json', Authorization: `Bearer ${this.config.token}` }, options.headers), body: body ? JSON.stringify(body) : undefined }));
+            if (!response.ok) {
+                console.error(`Error updating ${route}:`, response.statusText);
+                throw new Error(`Failed to update ${route}`);
+            }
+            if (processDataResponse)
+                return this.processDataResponse(response, route);
+            else
+                return response.json(); // Skip DataResponse processing if specified
+        });
+    }
+    /**
+     * Makes an authenticated DELETE request with standardized error handling
+     * Always processes ResponseBase (no data returned)
+     */
+    delete(route_1) {
+        return __awaiter(this, arguments, void 0, function* (route, options = {}, processResponse = true) {
+            const response = yield fetch(this.config.baseUrl + route, Object.assign(Object.assign({ method: 'DELETE' }, options), { headers: Object.assign({ Authorization: `Bearer ${this.config.token}` }, options.headers) }));
+            if (!response.ok) {
+                console.error(`Error deleting ${route}:`, response.statusText);
+                throw new Error(`Failed to delete ${route}`);
+            }
+            if (processResponse) {
+                return this.processNoDataResponse(response, route);
+            }
+            else {
+                return response.json();
+            }
+        });
+    }
+    /**
+     * Generic paged list request
+     */
+    getPagedList(endpoint, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.post(endpoint, request, {}, false);
+        });
+    }
+    getPagedListDetails(endpoint, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.post(endpoint, request, {}, false);
+        });
+    }
+    getPagedTaskItemList(endpoint, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.post(endpoint, request, {}, false);
+        });
+    }
+    getPagedTaskItemListDetails(endpoint, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.post(endpoint, request, {}, false);
+        });
+    }
+    getPagedTaskCommentList(endpoint, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.post(endpoint, request, {}, false);
+        });
+    }
+    getPagedAllowanceHistoriesList(endpoint, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.post(endpoint, request, {}, false);
+        });
+    }
+    getPagedAllowanceHistoryTaskItemsList(endpoint, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.post(endpoint, request, {}, false);
+        });
+    }
+    get clientConfig() {
+        return this.config;
+    }
+    get allowanceHistories() {
+        if (!this._allowanceHistories) {
+            this._allowanceHistories = new AllowanceHistories(this);
+        }
+        return this._allowanceHistories;
+    }
+    get avatar() {
+        if (!this._avatar) {
+            this._avatar = new Avatar(this);
+        }
+        return this._avatar;
+    }
+    get notifications() {
+        if (!this._notifications) {
+            this._notifications = new Notifications(this);
+        }
+        return this._notifications;
+    }
+    get teams() {
+        if (!this._teams) {
+            this._teams = new Teams(this);
+        }
+        return this._teams;
+    }
+    get tasks() {
+        if (!this._tasks) {
+            this._tasks = new Tasks(this);
+        }
+        return this._tasks;
+    }
+    get comments() {
+        if (!this._comments) {
+            this._comments = new TaskComments(this);
+        }
+        return this._comments;
+    }
+    get auth() {
+        if (!this._auth) {
+            this._auth = new Auth(this);
+        }
+        return this._auth;
+    }
+}
+exports.ApiClient = ApiClient;
+/**
+ * Auth API operations class
+ */
+class Auth {
+    constructor(client) {
+        this.client = client;
+    }
+    login(username, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.post('/api/auth/login', { username, password });
+            return response.token;
+        });
+    }
+    logout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.post('/api/auth/logout');
+        });
+    }
+    register(registerRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.post('/api/auth/register', registerRequest, {}, false);
+            return response;
+        });
+    }
+    forgotPassword(forgotPasswordRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.postDontProcess('/api/auth/forgot-password', forgotPasswordRequest);
+            return response;
+        });
+    }
+    resetPassword(resetPasswordRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.postDontProcess('/api/auth/reset-password', resetPasswordRequest);
+            return response;
+        });
+    }
+    sendPasswordResetEmail(sendPasswordResetEmailRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.postDontProcess('/api/auth/send-password-reset-email', sendPasswordResetEmailRequest);
+            return response;
+        });
+    }
+}
+/**
+ * Teams API operations class
+ */
+class Teams {
+    constructor(client) {
+        this.client = client;
+    }
+    getTeamDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.get('/api/team/', {}, false);
+        });
+    }
+    updateTeamDetails(teamUpdateRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.put(`/api/team/`, teamUpdateRequest, {}, false);
+        });
+    }
+    getTeamMembers(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.getPagedListDetails('/api/team/members', request);
+        });
+    }
+    getTeamAllowanceIntervals() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.get('/api/team/allowance-intervals', {}, false);
+        });
+    }
+    getTeamAllowanceInterval(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.get(`/api/team/allowance-intervals/${id}`, {}, false);
+        });
+    }
+    createTeamAllowanceInterval(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.post('/api/team/allowance-intervals', request, {}, false);
+        });
+    }
+    updateTeamAllowanceInterval(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.put(`/api/team/allowance-intervals/`, request, {}, false);
+        });
+    }
+    deleteTeamAllowanceInterval(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.delete(`/api/team/allowance-intervals/${id}`, {}, false);
+        });
+    }
+}
+/**
+ * Notifications API operations class
+ */
+class Notifications {
+    constructor(client) {
+        this.client = client;
+    }
+    registerDevice(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.postNoData('/api/userdeviceregistration/register-device', request);
+        });
+    }
+    unregisterDevice(fcmToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.postNoData('/api/userdeviceregistration/unregister-device', { fcmToken });
+        });
+    }
+    updateUserNotificationPreferences(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.put('/api/user/update-notification-preferences/bulk', request, {}, false);
+        });
+    }
+    createUserNotificationPreferences(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.postDontProcess('/api/user/create-notification-preferences/bulk', request);
+        });
+    }
+    getUserNotificationPreferences() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.get(`/api/user/notification-preferences/`, {}, false);
+        });
+    }
+}
+/**
+ * Avatar API operations class
+ */
+class Avatar {
+    constructor(client) {
+        this.client = client;
+    }
+    uploadAvatar(formData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.postMultimedia(`/api/avatar/upload`, formData);
+            return {
+                success: response.success,
+                fileName: response.data
+            };
+        });
+    }
+    deleteAvatar() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.delete(`/api/avatar/`);
+        });
+    }
+    getAvatarUrl(fileName) {
+        return `${this.client.clientConfig.baseUrl}/api/avatar/${fileName}`;
+    }
+    getAvatar(fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(this.getAvatarUrl(fileName), {
+                headers: {
+                    Authorization: `Bearer ${this.client.clientConfig.token}`,
+                },
+            });
+            if (!response.ok) {
+                return null;
+            }
+            const blob = yield response.blob();
+            return new File([blob], fileName, { type: blob.type });
+        });
+    }
+}
+/**
+ * Task Comments API operations class
+ */
+class TaskComments {
+    constructor(client) {
+        this.client = client;
+    }
+    create(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.post('/api/taskcomment/add', request, {}, false);
+        });
+    }
+    update(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.put(`/api/taskcomment/update`, request, {}, false);
+        });
+    }
+    delete(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.delete(`/api/taskcomment/delete/${id}`, {}, false);
+        });
+    }
+    getList(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.getPagedTaskCommentList('/api/taskcomment/paged-list', request);
+        });
+    }
+}
+/**
+ * Allowance Histories API operations class
+ */
+class AllowanceHistories {
+    constructor(client) {
+        this.client = client;
+    }
+    getPagedList(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.getPagedAllowanceHistoriesList('/api/allowancehistory/paged-list', request);
+        });
+    }
+    getPagedTaskItemsList(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.getPagedAllowanceHistoryTaskItemsList('/api/allowancehistory/paged-task-items-list', request);
+        });
+    }
+    approveAllowance(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.postDontProcess('/api/allowancehistory/approve', request);
+        });
+    }
+    claimAllowance(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.postDontProcess('/api/allowancehistory/claim', request);
+        });
+    }
+}
+/**
+ * Tasks API operations class
+ */
+class Tasks {
+    constructor(client) {
+        this.client = client;
+    }
+    create(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.post('/api/taskitem', data);
+        });
+    }
+    update(id, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.put(`/api/taskitem/${id}`, data);
+        });
+    }
+    copy(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.post(`/api/taskitem/copy/${id}`);
+        });
+    }
+    copyList(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.postNoData(`/api/taskitem/copy-list`, body);
+        });
+    }
+    delete(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.delete(`/api/taskitem/${id}`);
+        });
+    }
+    deleteList(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.postNoData(`/api/taskitem/delete-list`, body);
+        });
+    }
+    pin(id, pinning) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.post(`/api/taskitem/pin/${id}/${pinning}`);
+        });
+    }
+    pinList(pinning, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.post(`/api/taskitem/pin-list/${pinning}`, body);
+        });
+    }
+    setActive(id, active) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.post(`/api/taskitem/set-active/${id}/${active}`);
+        });
+    }
+    setActiveList(activating, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.post(`/api/taskitem/set-active-list/${activating}`, body);
+        });
+    }
+    setComplete(id, completing) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.post(`/api/taskitem/set-complete/${id}/${completing}`);
+        });
+    }
+    setCompleteList(completing, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.post(`/api/taskitem/set-complete-list/${completing}`, body);
+        });
+    }
+    archive(id, archiving) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.post(`/api/taskitem/archive/${id}/${archiving}`);
+        });
+    }
+    archiveList(archiving, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.postNoData(`/api/taskitem/archive-list/${archiving}`, body);
+        });
+    }
+    approveBonus(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.postNoData('/api/taskitem/approve-bonus', request);
+        });
+    }
+    approveTaskItemAllowance(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.postNoData('/api/taskitem/approve-allowance', request);
+        });
+    }
+    claimBonus(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.postNoData(`/api/taskitem/claim-bonus/${id}`);
+        });
+    }
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.get(`/api/taskitem/${id}`);
+        });
+    }
+    getDetails(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.get(`/api/taskitem/details/${id}`);
+        });
+    }
+    getTaskDetails(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.get(`/api/taskitem/get-task-details/${id}`, {}, false);
+        });
+    }
+    updateTaskDetails(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.post(`/api/taskitem/update-task-details`, request, {}, false);
+        });
+    }
+    getPagedList(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.getPagedTaskItemList('/api/taskitem/paged-list', request);
+        });
+    }
+    getPagedListDetails(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.getPagedTaskItemListDetails('/api/taskitem/paged-list-details', request);
+        });
+    }
+}
+/**
+ * Functional approach - creates an API client instance
+ * @param baseUrl - Base URL for the API
+ * @param token - Authentication token
+ * @returns ApiClient instance
+ */
+function createApiClient(baseUrl, token) {
+    return new ApiClient({ baseUrl, token });
+}
+/**
+ * Hook-friendly function for making authenticated API calls
+ * @param baseUrl - Base URL for the API
+ * @param token - Authentication token
+ * @param route - API route to call
+ * @param options - Additional fetch options
+ * @returns Promise with the response data
+ */
+function apiCall(baseUrl_1, token_1, route_1) {
+    return __awaiter(this, arguments, void 0, function* (baseUrl, token, route, options = {}) {
+        const client = createApiClient(baseUrl, token);
+        return client.get(route, options);
+    });
+}