@ever-gauzy/plugin-integration-plane-api 0.1.0

package/dist/modules/workspace/workspace.service.js

@@ -0,0 +1,1266 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceService = void 0;
+const common_1 = require("@nestjs/common");
+const qs_1 = __importDefault(require("qs"));
+const plugin_integration_plane_models_1 = require("@ever-gauzy/plugin-integration-plane-models");
+const api_fetch_service_1 = require("../api-fetch/api-fetch.service");
+const config_1 = require("../../config");
+const config_2 = require("../../config");
+const project_service_1 = require("../project/project.service");
+const issues_service_1 = require("../issues/issues.service");
+const activity_service_1 = require("../activity/activity.service");
+const issue_links_service_1 = require("../issue-links/issue-links.service");
+const subscription_service_1 = require("../subscription/subscription.service");
+const draft_issues_service_1 = require("../issues/draft-issues/draft-issues.service");
+const employee_properties_service_1 = require("../employee-properties/employee-properties.service");
+const cycles_service_1 = require("../cycles/cycles.service");
+const project_module_service_1 = require("../project-module/project-module.service");
+const view_service_1 = require("../views/view.service");
+const dashboard_service_1 = require("../dashboard/dashboard.service");
+const widget_service_1 = require("../dashboard/widget.service");
+const notification_service_1 = require("../notification/notification.service");
+let WorkspaceService = class WorkspaceService extends api_fetch_service_1.ApiFetchService {
+    constructor(_projectService, _issueService, _cycleService, _projectModuleService, _issueViewService, _activityService, _issueLinkService, _subscriptionService, _draftIssueService, _employeePropertiesService, _dashboardService, _widgetService, _notificationService, _serverFetchService) {
+        super(_serverFetchService['_httpService']);
+        this._projectService = _projectService;
+        this._issueService = _issueService;
+        this._cycleService = _cycleService;
+        this._projectModuleService = _projectModuleService;
+        this._issueViewService = _issueViewService;
+        this._activityService = _activityService;
+        this._issueLinkService = _issueLinkService;
+        this._subscriptionService = _subscriptionService;
+        this._draftIssueService = _draftIssueService;
+        this._employeePropertiesService = _employeePropertiesService;
+        this._dashboardService = _dashboardService;
+        this._widgetService = _widgetService;
+        this._notificationService = _notificationService;
+        this._serverFetchService = _serverFetchService;
+    }
+    /**--------------------------------------------------------------
+     * This function handlers should be updated after implementing authentication
+     *--------------------------------------------------------------/
+    /**
+     * @description - Get dashboard widgets for given workspace
+     * @param {string} dashboard_type - query that define which widget filter should be fetched
+     * @returns - A promise that resolves when dashboard widgets are fetched
+     * @memberof WorkspaceService
+     */
+    async getDashboard(dashboard_type) {
+        var _a, _b, _c, _d;
+        try {
+            let externalDashboard = await this._dashboardService.findDashboardByIdentifier(dashboard_type);
+            if (!externalDashboard) {
+                externalDashboard = await this._dashboardService.create({
+                    name: 'home',
+                    identifier: 'home',
+                    description: 'Default home dashboard for plane',
+                    organizationId: (0, config_1.getCurrentOrganizationSlug)()
+                });
+            }
+            let transformedWidgets = (0, config_1.widgetTransformer)(externalDashboard.widgets);
+            if (externalDashboard.widgets.length === 0) {
+                const widgets = config_1.DEFAULT_DASHBOARD_WIDGETS;
+                try {
+                    transformedWidgets = (await Promise.all(widgets.map(async (widget) => {
+                        return await this._widgetService.create({
+                            name: widget.key,
+                            isVisible: widget.is_visible,
+                            options: widget.widget_filters,
+                            dashboardId: externalDashboard.id,
+                            organizationId: externalDashboard.organizationId
+                        });
+                    }))).flat();
+                }
+                catch (error) {
+                    this.logger.error(`Failed to create widget: ${((_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || error.message}`, error.stack);
+                    throw new common_1.BadRequestException(error.response);
+                }
+            }
+            // If found, return the serialized dashboard
+            return {
+                dashboard: (0, config_1.dashboardTransformer)(externalDashboard),
+                widgets: transformedWidgets
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to get dashboard: ${((_d = (_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.message) || error.message}`, error.stack);
+            throw new common_1.BadRequestException(error.response);
+        }
+    }
+    /**
+     * Fetches data for various dashboard widgets based on the widget type.
+     *
+     * This function retrieves data for different types of dashboard widgets such as recent collaborators,
+     * created issues, assigned issues, recent projects, issues by state, and issues by priority.
+     *
+     * @param {DashboardWigetQueryEnum} widget - The widget type to query data for.
+     * @returns {Promise<any>} A promise that resolves to the data for the requested widget.
+     * @throws {BadRequestException} If an error occurs during data retrieval.
+     */
+    async findDashboardWidgetsData(widget, target_date, issue_type) {
+        // Mapping object for each widget type and its corresponding handler function
+        const widgetHandlers = {
+            [plugin_integration_plane_models_1.DashboardWigetQueryEnum.COLLABORATORS]: this.findRecentCollaborators.bind(this),
+            [plugin_integration_plane_models_1.DashboardWigetQueryEnum.CREATED_ISSUES]: async () => {
+                const issues = await this.findMyCreatedIssues(target_date, issue_type);
+                return { issues: issues.slice(0, 5), count: issues.length };
+            },
+            [plugin_integration_plane_models_1.DashboardWigetQueryEnum.ASSIGNED_ISSUES]: async () => {
+                const issues = await this.findMyAssignedIssues(target_date, issue_type);
+                return { issues: issues.slice(0, 5), count: issues.length };
+            },
+            [plugin_integration_plane_models_1.DashboardWigetQueryEnum.RECENT_ACTIVITY]: async () => {
+                return this.findRecentIssueActivity(8);
+            },
+            [plugin_integration_plane_models_1.DashboardWigetQueryEnum.RECENT_PROJECTS]: this.findRecentProjects.bind(this),
+            [plugin_integration_plane_models_1.DashboardWigetQueryEnum.ISSUES_BY_STATE]: async () => {
+                return this.finAssignedByState(target_date);
+            },
+            [plugin_integration_plane_models_1.DashboardWigetQueryEnum.ISSUES_BY_PRIORITY]: async () => {
+                return this.findAssignedByPriority(target_date);
+            },
+            [plugin_integration_plane_models_1.DashboardWigetQueryEnum.OVERVIEW]: async () => {
+                return await this.findOverViewWidgetStats();
+            }
+        };
+        // Execute the corresponding handler if the widget type exists in the mapping
+        if (widget in widgetHandlers) {
+            return widgetHandlers[widget]();
+        }
+    }
+    /**--------------------------------------------------------------
+     * This function handlers should be updated after implementing authentication and User features
+     *--------------------------------------------------------------*/
+    /**
+     * @description - Get member (from connected user) info for a workspace
+     * @returns - A promise that resolves after getting member informations
+     * @memberof WorkspaceController
+     */
+    async getMembersMe() {
+        const employeeId = (0, config_1.currentEmployeeId)();
+        const tenantId = (0, config_1.currentTenantId)();
+        try {
+            let memberSetting = await this._employeePropertiesService.findOneByOptions({
+                employeeId: employeeId,
+                entity: plugin_integration_plane_models_1.BaseEntityEnum.Tenant,
+                entityId: tenantId,
+                settingType: plugin_integration_plane_models_1.EmployeeSettingTypeEnum.TASK_VIEWS
+            });
+            if (!memberSetting) {
+                // Create default settings if none exist
+                memberSetting = await this.createDefaultSettings(tenantId, employeeId);
+            }
+            return (0, config_1.memberPropertiesSerializer)(memberSetting, employeeId);
+        }
+        catch (error) {
+            this.logger.warn('Failed to retrieve settings, creating new ones...');
+            try {
+                // Create default settings in case of error
+                const memberSetting = await this.createDefaultSettings(tenantId, employeeId);
+                return (0, config_1.memberPropertiesSerializer)(memberSetting, employeeId);
+            }
+            catch (creationError) {
+                this.logger.error('Failed to create new view properties', creationError instanceof Error
+                    ? creationError.stack
+                    : String(creationError));
+                throw new common_1.BadRequestException('Failed to find or create new view properties');
+            }
+        }
+    }
+    async createDefaultSettings(tenantId, employeeId) {
+        const settingViewProps = Object.assign(Object.assign({}, config_1.MEMBER_DEFAULT_VIEW_PROPS), { issue_props: {
+                created: true,
+                assigned: true,
+                all_issues: true,
+                subscribed: true
+            } });
+        await this._employeePropertiesService.create({
+            entity: plugin_integration_plane_models_1.BaseEntityEnum.Tenant,
+            entityId: tenantId,
+            settingType: plugin_integration_plane_models_1.EmployeeSettingTypeEnum.TASK_VIEWS,
+            data: settingViewProps,
+            defaultData: settingViewProps,
+            employee: { id: employeeId },
+            employeeId
+        });
+        // Retourner les paramètres après la création
+        return await this._employeePropertiesService.findOneByOptions({
+            employeeId,
+            entity: plugin_integration_plane_models_1.BaseEntityEnum.Tenant,
+            entityId: tenantId,
+            settingType: plugin_integration_plane_models_1.EmployeeSettingTypeEnum.TASK_VIEWS
+        });
+    }
+    /**
+     * @description - Get Organization members
+     * @returns A promise that resolves after get organization members
+     * @memberof WorkspaceService
+     */
+    async getWorkspaceMembers() {
+        try {
+            const organizationId = (0, config_1.getCurrentOrganizationSlug)();
+            const tenantId = (0, config_1.currentTenantId)();
+            const query = qs_1.default.stringify((0, config_2.getEmployeeMembersQuery)(organizationId, tenantId));
+            const response = (await this.apiFetch({
+                method: 'GET',
+                path: '/employee/members',
+                query
+            })).data;
+            return (0, config_2.employeeMembersTransformer)(response.items, organizationId);
+        }
+        catch (error) {
+            this.logger.error('Error while retrieving workspace members', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Retrieves the most recent collaborators from the workspace members.
+     *
+     * The function fetches all workspace members and and returns the first members found. The result includes each collaborator's
+     * user ID and active issue count (which needs to be calculated accordingly).
+     *
+     * @returns {Promise<IRecentCollaborator[]>} A promise that resolves to an array of recent collaborators.
+     * @throws {BadRequestException} If there is an error while fetching the workspace members.
+     */
+    async findRecentCollaborators() {
+        try {
+            const employees = await this.getWorkspaceMembers();
+            const collaborators = await Promise.all(employees.map(async (employee) => {
+                const tasks = await this._issueService.findExternalByEmployee(employee.member.id, ['taskStatus']);
+                const { startedIssues, unstartedIssues } = (0, config_1.getTaskCounts)(tasks);
+                return {
+                    user_id: employee.member.id,
+                    active_issue_count: startedIssues + unstartedIssues
+                };
+            }));
+            return collaborators.sort((a, b) => b.active_issue_count - a.active_issue_count);
+        }
+        catch (error) {
+            this.logger.error('Failed to find recent collaborators', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Retrieves statistics for the overview widget related to assigned, completed,
+     * created, and overdue issues.
+     *
+     * The method fetches the user's assigned issues, completed issues, and created issues.
+     * It also filters assigned issues to determine how many are overdue (i.e., with a due date
+     * or target date that is earlier than today).
+     *
+     * @returns {Promise<Object>} An object containing the following issue counts:
+     * - `assigned_issues_count`: The number of issues assigned to the user.
+     * - `pending_issues_count`: The number of overdue issues assigned to the user.
+     * - `completed_issues_count`: The number of issues the user has completed.
+     * - `created_issues_count`: The number of issues created by the user.
+     *
+     * @throws {Error} If any of the asynchronous operations fail.
+     */
+    async findOverViewWidgetStats() {
+        const today = new Date();
+        const assigned = await this.findMyAssignedIssues();
+        const completed = await this.findMyAssignedIssues(undefined, plugin_integration_plane_models_1.DashboardIssueTypeEnum.COMPLETED);
+        const created = await this.findMyCreatedIssues();
+        const overdue = assigned.filter((task) => {
+            if ('dueDate' in task) {
+                const taskDueDate = new Date(task.dueDate);
+                return taskDueDate < today;
+            }
+            else if ('target_date' in task) {
+                const issueTargetDate = new Date(task.target_date);
+                return issueTargetDate < today;
+            }
+            return true;
+        });
+        return {
+            assigned_issues_count: assigned.length,
+            pending_issues_count: overdue.length,
+            completed_issues_count: completed.length,
+            created_issues_count: created.length
+        };
+    }
+    /**
+     * Retrieves the issues assigned to the current employee.
+     *
+     * The function calls the issue service to fetch all issues assigned to the employee
+     */
+    async findMyAssignedIssues(target_date, issue_type, employee) {
+        const employeeId = employee || (0, config_1.currentEmployeeId)();
+        return this.getIssues(employeeId, 'employeeId', target_date, issue_type);
+    }
+    async findMyCreatedIssues(target_date, issue_type) {
+        const userId = (0, config_1.currentUserId)();
+        return this.getIssues(userId, 'creatorId', target_date, issue_type);
+    }
+    /**
+     * Retrieves the count of tasks assigned to the current employee, grouped by their state.
+     *
+     * Sends a GET request to fetch tasks assigned to the authenticated employee.
+     * Tasks are then categorized into states (backlog, unstarted, started, completed, and cancelled).
+     *
+     * @returns {Promise<{ state: string, count: number }[]>} A promise that resolves to an array of objects representing task states and their respective counts.
+     * @throws {BadRequestException} If an error occurs during the fetch.
+     */
+    async finAssignedByState(target_date) {
+        var _a, _b, _c;
+        try {
+            let tasks = await this._issueService.findExternalByEmployee((0, config_1.currentEmployeeId)(), ['taskStatus']);
+            if (target_date) {
+                const { dueDateFrom, dueDateTo } = (0, config_1.widgetTargetDateTransformer)(target_date);
+                tasks = await this._issueService.findByStartAndDueDate({
+                    dueDateFrom,
+                    dueDateTo,
+                    relations: ['members'],
+                    employeeId: (_a = (0, config_1.currentEmployeeId)()) !== null && _a !== void 0 ? _a : undefined
+                });
+            }
+            // Get task counts based on their states
+            const { backlogIssues, completedIssues, startedIssues, unstartedIssues } = (0, config_1.getTaskCounts)(tasks);
+            // Return the task counts grouped by state
+            return [
+                { state: 'backlog', count: backlogIssues },
+                { state: 'unstarted', count: unstartedIssues },
+                { state: 'started', count: startedIssues },
+                { state: 'completed', count: completedIssues },
+                { state: 'cancelled', count: 0 } // Assuming 0 cancelled issues as not specified
+            ];
+        }
+        catch (error) {
+            this.logger.error(`Failed to get assigned issues by state: ${((_c = (_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.message) || error.message}`, error.stack);
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Retrieves tasks assigned to the authenticated employee and categorizes them by priority.
+     *
+     * This function fetches tasks for the authenticated employee and returns the count
+     * of tasks grouped by their priority (urgent, high, medium, low, none).
+     *
+     * @returns {Promise<Array<{ priority: string; count: number }>>} A promise that resolves to an array of objects containing the priority and the count of tasks for each priority level.
+     * @throws {BadRequestException} If an error occurs during task retrieval.
+     */
+    async findAssignedByPriority(target_date) {
+        var _a, _b, _c;
+        try {
+            let tasks = await this._issueService.findExternalByEmployee((0, config_1.currentEmployeeId)(), ['taskStatus']);
+            if (target_date) {
+                const { dueDateFrom, dueDateTo } = (0, config_1.widgetTargetDateTransformer)(target_date);
+                tasks = await this._issueService.findByStartAndDueDate({
+                    dueDateFrom,
+                    dueDateTo,
+                    relations: ['members'],
+                    employeeId: (_a = (0, config_1.currentEmployeeId)()) !== null && _a !== void 0 ? _a : undefined
+                });
+            }
+            // Get the tasks counts grouped by priority
+            return (0, config_1.issuesByPriority)(tasks);
+        }
+        catch (error) {
+            this.logger.error(`Failed to find assigned issues by priority: ${((_c = (_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.message) || error.message}`, error.stack);
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /*************  ✨ Windsurf Command ⭐  *************/
+    /**
+     * Retrieves all projects for the authenticated employee.
+     *
+     * This function fetches all projects with no specific filters and returns an array of projects.
+     *
+     * @returns {Promise<IProject[]>} A promise that resolves to an array of projects.
+     * @throws {BadRequestException} If an error occurs during project retrieval.
+     */
+    /*******  e3fe4c94-518f-42c5-ad1c-6ca918f83028  *******/
+    async findProjects() {
+        try {
+            return await this._projectService.getProjects([
+                'members.employee.user.role',
+                'organizationSprints',
+                'modules'
+            ]);
+        }
+        catch (error) {
+            this.logger.error('Failed to find projects', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Retrieves the most recent project IDs.
+     *
+     * This function fetches all projects and returns the IDs of the first 5 recent projects.
+     *
+     * @returns {Promise<ID[]>} A promise that resolves to an array of the most recent project IDs.
+     * @throws {BadRequestException} If an error occurs during project retrieval.
+     */
+    async findRecentProjects() {
+        try {
+            // Fetch all projects
+            const projects = await this._projectService.getExternalProjects([]);
+            // Return the first 5 project IDs
+            return projects.map((project) => project.id).slice(0, 4);
+        }
+        catch (error) {
+            this.logger.error('Failed to find recent projects', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Retrieves the recent activity logs for issues, transformed and filtered based on the user's activity.
+     * The method fetches activity logs, resolves associated tasks, and includes details about the issue,
+     * actor, project, workspace, and cycle if applicable.
+     *
+     * @param {number} [length] - Optional limit for the number of recent activities to return.
+     * @returns {Promise<any[]>} A promise that resolves with a list of transformed issue activities.
+     *
+     * @throws {BadRequestException} If an error occurs during the retrieval or processing of activity logs.
+     */
+    async findRecentIssueActivity(length, employeeId) {
+        try {
+            const activityLogs = await this._activityService.findAll({
+                entity: plugin_integration_plane_models_1.BaseEntityEnum.Task,
+                employeeId: (0, config_1.currentEmployeeId)() || employeeId
+            });
+            // Collect all the IDs of parents mentioned in the logs
+            const parentIds = new Set();
+            activityLogs === null || activityLogs === void 0 ? void 0 : activityLogs.forEach((log) => {
+                var _a, _b, _c;
+                if ((_a = log.updatedFields) === null || _a === void 0 ? void 0 : _a.includes('parentId')) {
+                    (_b = log.updatedValues) === null || _b === void 0 ? void 0 : _b.forEach((value) => {
+                        if ('parentId' in value && value.parentId) {
+                            parentIds.add(value.parentId);
+                        }
+                    });
+                    (_c = log.previousValues) === null || _c === void 0 ? void 0 : _c.forEach((value) => {
+                        if ('parentId' in value && value.parentId) {
+                            parentIds.add(value.parentId);
+                        }
+                    });
+                }
+            });
+            // Load all the parent tasks
+            const parentTasks = new Map();
+            if (parentIds.size > 0) {
+                const parents = await this._issueService.findAllExternal({
+                    issues: Array.from(parentIds).join(',')
+                });
+                parents.items.forEach((parent) => {
+                    parentTasks.set(parent.id, parent);
+                });
+            }
+            const issueActivities = await Promise.all((activityLogs !== null && activityLogs !== void 0 ? activityLogs : []).map(async (activityLog) => {
+                var _a, _b, _c;
+                const task = await this._issueService.getExternalIssue(activityLog.entityId, [
+                    'project.members.employee.user.role',
+                    'organizationSprint',
+                    'taskSprintHistories.toSprint'
+                ]);
+                const projectMembers = task.project.members.map((member) => member.employee);
+                if (task.projectId) {
+                    const { actor, issue, project, workspace } = await this._issueService.getIssueCommentDetails(task.id, task.projectId, activityLog.employeeId, task, task.project);
+                    // Check if updatedValues contains organizationSprintId
+                    const updatedSprintObj = (_a = activityLog.updatedValues) === null || _a === void 0 ? void 0 : _a.find((value) => 'organizationSprintId' in value);
+                    let updatedSprint = null;
+                    if (updatedSprintObj &&
+                        updatedSprintObj.organizationSprintId) {
+                        updatedSprint = ((_c = (_b = task.taskSprintHistories.find((sprint) => sprint.toSprintId ===
+                            updatedSprintObj.organizationSprintId)) === null || _b === void 0 ? void 0 : _b.toSprint) !== null && _c !== void 0 ? _c : null);
+                    }
+                    const transformedActivityLogs = (0, config_1.issueActivityLogTransformer)(activityLog, issue, actor, project, workspace, updatedSprint
+                        ? updatedSprint
+                        : task.organizationSprint, projectMembers.filter((employee) => employee.userId ===
+                        activityLog.createdByUserId)[0], projectMembers, parentTasks);
+                    return Array.isArray(transformedActivityLogs)
+                        ? transformedActivityLogs
+                        : [transformedActivityLogs];
+                }
+            }));
+            // TODO: Include also links activities and filter both by createdAt to return most recent activities.
+            const activities = issueActivities.flat().filter(Boolean);
+            if (length) {
+                return activities.slice(0, length);
+            }
+            return activities;
+        }
+        catch (error) {
+            this.logger.error('Failed to find recent issue activity', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Fetches and filters issues based on a target date and issue type.
+     */
+    async getIssues(id, idField, target_date, issue_type) {
+        var _a, _b;
+        try {
+            let tasks;
+            const dateRangesRelations = [
+                'taskStatus',
+                'linkedIssues.taskTo',
+                'linkedIssues.taskFrom'
+            ];
+            const relations = [
+                'members.user',
+                'createdByUser',
+                'project.members.employee.user.role',
+                ...dateRangesRelations
+            ];
+            // If a target date is provided, fetch tasks by date
+            if (target_date) {
+                const { dueDateFrom, dueDateTo } = (0, config_1.widgetTargetDateTransformer)(target_date);
+                // Pass the appropriate field to the method based on idField
+                if (idField === 'employeeId') {
+                    tasks = await this._issueService.findByStartAndDueDate({
+                        dueDateFrom,
+                        dueDateTo,
+                        relations: dateRangesRelations,
+                        employeeId: id // Explicitly specify employeeId
+                    });
+                }
+                else {
+                    tasks = await this._issueService.findByStartAndDueDate({
+                        dueDateFrom,
+                        dueDateTo,
+                        relations: dateRangesRelations,
+                        createdByUserId: id // Explicitly specify creatorId
+                    });
+                }
+                // Apply additional filtering based on issue_type
+                if (issue_type) {
+                    const today = new Date();
+                    tasks = tasks.filter((task) => {
+                        if ('dueDate' in task) {
+                            // Logic for ITask
+                            const taskDueDate = new Date(task.dueDate);
+                            if (issue_type === plugin_integration_plane_models_1.DashboardIssueTypeEnum.UPCOMING) {
+                                return taskDueDate > today; // Only keep tasks due after today
+                            }
+                            else if (issue_type === plugin_integration_plane_models_1.DashboardIssueTypeEnum.OVERDUE) {
+                                return taskDueDate < today; // Only keep tasks due before today
+                            }
+                        }
+                        else if ('target_date' in task) {
+                            // Logic for IIssue
+                            const issueTargetDate = new Date(task.target_date);
+                            if (issue_type === plugin_integration_plane_models_1.DashboardIssueTypeEnum.UPCOMING) {
+                                return issueTargetDate > today; // Only keep issues with target_date after today
+                            }
+                            else if (issue_type === plugin_integration_plane_models_1.DashboardIssueTypeEnum.OVERDUE) {
+                                return issueTargetDate < today; // Only keep issues with target_date before today
+                            }
+                        }
+                        return true; // Default: no filtering for other issue types
+                    });
+                }
+            }
+            else {
+                // Fetch all tasks based on idField
+                if (idField === 'employeeId') {
+                    tasks = await this._issueService.findByEmployee(id, relations); // Directly pass the employeeId
+                }
+                else {
+                    tasks = await this._issueService.findAll({ createdByUserId: id }, relations); // Directly pass the creatorId
+                }
+            }
+            // Filter and transform tasks based on issue type
+            return this.filterAndTransformTasks(tasks, issue_type);
+        }
+        catch (error) {
+            this.logger.error(`Failed to get issues: ${((_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || error.message}`, error.stack);
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Filters and transforms the tasks based on issue type.
+     */
+    filterAndTransformTasks(tasks, issue_type) {
+        const isCompleted = issue_type === plugin_integration_plane_models_1.DashboardIssueTypeEnum.COMPLETED;
+        return tasks
+            .filter((task) => {
+            const status = 'status' in task
+                ? task.status
+                : 'state__group' in task
+                    ? task.state__group
+                    : null;
+            return isCompleted
+                ? status === plugin_integration_plane_models_1.TaskStatusEnum.COMPLETED ||
+                    status === plugin_integration_plane_models_1.TaskStatusEnum.DONE
+                : status !== plugin_integration_plane_models_1.TaskStatusEnum.COMPLETED &&
+                    status !== plugin_integration_plane_models_1.TaskStatusEnum.DONE;
+        })
+            .map((task) => ('status' in task ? (0, config_1.issueTransformer)(task) : task));
+    }
+    /**
+     * Retrieves a summary of the user's work statistics, including task distribution
+     * by state and priority, as well as counts for created, assigned, and completed issues.
+     *
+     * @returns {Promise<IUserStatsResponse>} A promise that resolves with the user's work summary.
+     *
+     * @throws {BadRequestException} If an error occurs during the retrieval of work statistics.
+     */
+    async findUserWorkSummary(employeeId) {
+        var _a, _b;
+        try {
+            const assignedIssues = await this._issueService.findExternalByEmployee(employeeId, [
+                'taskStatus'
+            ]);
+            const subscribedIssues = await this.findUserSubscribedIssues([]);
+            const { completedIssues, backlogIssues, startedIssues, unstartedIssues } = (0, config_1.getTaskCounts)(assignedIssues);
+            const createdIssues = await this.findMyCreatedIssues();
+            return {
+                state_distribution: [
+                    { state_group: 'backlog', state_count: backlogIssues },
+                    { state_group: 'unstarted', state_count: unstartedIssues },
+                    { state_group: 'started', state_count: startedIssues },
+                    { state_group: 'completed', state_count: completedIssues }
+                ],
+                priority_distribution: (0, config_1.userIssuesByPriority)(assignedIssues),
+                created_issues: createdIssues.length,
+                assigned_issues: assignedIssues.length,
+                completed_issues: completedIssues,
+                pending_issues: backlogIssues + startedIssues + unstartedIssues,
+                subscribed_issues: subscribedIssues.length || 0,
+                present_cycles: [],
+                upcoming_cycles: []
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to find user work summary: ${((_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || error.message}`, error.stack);
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Retrieves the user's recent activity
+     *
+     * @returns {Promise<Object>} A promise that resolves with a structured response containing user activity details.
+     */
+    async findUserRecentActivity(per_page, employeeId) {
+        try {
+            const activities = await this.findRecentIssueActivity(per_page, employeeId);
+            return {
+                grouped_by: null,
+                sub_grouped_by: null,
+                total_count: 165,
+                next_cursor: '10:1:0',
+                prev_cursor: '10:-1:1',
+                next_page_results: true,
+                prev_page_results: false,
+                count: 10,
+                total_pages: 17,
+                total_results: 165,
+                extra_stats: null,
+                results: activities
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to find user recent activity: ${error === null || error === void 0 ? void 0 : error.message}`, error.stack);
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Retrieves the project data associated with the currently connected user.
+     * This method fetches projects linked to the employee and user ID, then transforms
+     * the data using the `userWorkProjectsTransformer`.
+     *
+     * @returns {Promise<IUserProjectsDataResponse>} A promise that resolves with the user's projects data.
+     * @throws {BadRequestException} If an error occurs during the data retrieval or transformation process.
+     *
+     */
+    async findUserProjectsData(employeeId) {
+        try {
+            const userId = (0, config_1.currentUserId)();
+            const userProjects = await this._projectService.getExternalProjectsByEmployee(employeeId, ['members.employee.user', 'tasks.members']);
+            return (0, config_1.userWorkProjectsTransformer)(userProjects, employeeId, userId);
+        }
+        catch (error) {
+            this.logger.error(`Failed to find user projects data: ${error === null || error === void 0 ? void 0 : error.message}`, error.stack);
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Retrieves and groups issues assigned to a user based on the specified grouping option.
+     * This method fetches issues assigned to the current employee and organizes them into groups,
+     * such as by state or other criteria provided in the options.
+     *
+     * @param {IIssueFindInput} options - The input options specifying the grouping criteria.
+     *
+     * @returns A promise that resolves to an array of grouped issues.
+     * Each group is structured based on the specified grouping option.
+     *
+     * @throws {BadRequestException} Throws if an error occurs during issue retrieval or processing.
+     */
+    async findUserGroupedIssueAssigned(options) {
+        var _a;
+        try {
+            const { assignees, created_by, group_by, order_by, subscriber } = options;
+            let assignedIssues = [];
+            const relations = ['taskStatus'];
+            if (assignees) {
+                assignedIssues =
+                    await this._issueService.findExternalByEmployee((0, config_1.issueFilterSplitter)(assignees)[0], relations, order_by);
+            }
+            else if (created_by) {
+                const createdTasks = await this._issueService.findAllExternal({
+                    created_by: (_a = (0, config_1.currentUserId)()) !== null && _a !== void 0 ? _a : undefined
+                }, relations, order_by);
+                assignedIssues = createdTasks.items;
+            }
+            else if (subscriber) {
+                assignedIssues = await this.findUserSubscribedIssues(relations, order_by);
+            }
+            else {
+                assignedIssues = (await this._issueService.findAllExternal({}, relations, order_by)).items.filter((task) => task.projectId);
+            }
+            const issuesWithLinks = await Promise.all((assignedIssues !== null && assignedIssues !== void 0 ? assignedIssues : []).map(async (issue) => {
+                const issueLinks = await this._issueLinkService.findAll(plugin_integration_plane_models_1.BaseEntityEnum.Task, issue.id);
+                const transformedIssueLinks = (0, config_1.issueLinkTransformer)(issueLinks);
+                return {
+                    issue,
+                    issueLinks: transformedIssueLinks
+                };
+            }));
+            if (group_by === plugin_integration_plane_models_1.IssueGroupByEnum.STATE_GROUP) {
+                return (0, config_1.groupIssuesByStateGroup)(issuesWithLinks);
+            }
+            if (group_by === plugin_integration_plane_models_1.IssueGroupByEnum.PRIORITY) {
+                return (0, config_1.groupIssuesByPriority)(issuesWithLinks);
+            }
+            if (group_by === plugin_integration_plane_models_1.IssueGroupByEnum.PROJECT_ID) {
+                return (0, config_1.groupIssuesByProjectId)(issuesWithLinks);
+            }
+            if (group_by === plugin_integration_plane_models_1.IssueGroupByEnum.LABEL_ID) {
+                return (0, config_1.groupIssuesByLabel)(issuesWithLinks);
+            }
+            return (0, config_1.userWorkNonGroupedIssues)(issuesWithLinks);
+        }
+        catch (error) {
+            this.logger.error('Failed to find user grouped issue assigned', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    async findUserSubscribedIssues(relations, order_by) {
+        var _a;
+        const tasks = await this._issueService.findAllExternal({}, relations, order_by);
+        const subscriptions = await this._subscriptionService.findAll({
+            entity: plugin_integration_plane_models_1.BaseEntityEnum.Task,
+            userId: (_a = (0, config_1.currentUserId)()) !== null && _a !== void 0 ? _a : undefined
+        });
+        const subscribedTaskIds = subscriptions.map((subscription) => subscription.entityId);
+        return tasks.items.filter((task) => subscribedTaskIds.includes(task.id));
+    }
+    /**
+     * Fetches all workspace states associated with projects in the workspace.
+     * This method retrieves all projects in the workspace, then queries each project's states,
+     * consolidating them into a single array.
+     *
+     * @returns A promise resolving to an array of workspace states.
+     * Each state corresponds to a specific project within the workspace.
+     *
+     * @throws {BadRequestException} Throws if an error occurs during project or state retrieval.
+     */
+    async findWorkspaceStates() {
+        try {
+            const projects = await this._projectService.getExternalProjects([
+                'statuses'
+            ]);
+            const states = projects.map((project) => project.statuses);
+            return (0, config_1.getStatesTransformer)(states.flat());
+        }
+        catch (error) {
+            this.logger.error('Failed to find workspace states', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Fetches all workspace modules associated with projects in the workspace.
+     * This method retrieves all projects within the workspace and then queries
+     * each project's modules, consolidating them into a single array.
+     *
+     * @returns {Promise<IModule[]>} A promise resolving to an array of project modules.
+     * Each module corresponds to a specific project within the workspace.
+     *
+     * @throws {BadRequestException} Throws if an error occurs during project or module retrieval.
+     */
+    async findWorkspaceModules() {
+        try {
+            const projects = await this._projectService.getExternalProjects([
+                'modules'
+            ]);
+            const modules = projects.map((project) => project.modules).flat();
+            const transformedModules = (0, config_1.modulesTransformer)(Array.isArray(modules) ? modules : [modules]);
+            return Array.isArray(transformedModules)
+                ? transformedModules
+                : [transformedModules];
+        }
+        catch (error) {
+            this.logger.error('Failed to find workspace modules', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Fetches all cycles associated with projects in the workspace.
+     * This method retrieves all projects within the workspace and then queries
+     * each project's cycles, consolidating them into a single array.
+     *
+     * @returns {Promise<ICycle[]>} A promise resolving to an array of cycles.
+     * Each cycle corresponds to a specific project within the workspace.
+     *
+     * @throws {BadRequestException} Throws if an error occurs during project or cycle retrieval.
+     */
+    async findWorkspaceCycles() {
+        try {
+            const projects = await this._projectService.getExternalProjects([
+                'organizationSprints'
+            ]);
+            const cycles = projects
+                .map((project) => project.organizationSprints)
+                .flat();
+            const transformedSprints = (0, config_1.cycleTransformer)(Array.isArray(cycles) ? cycles : [cycles]);
+            return Array.isArray(transformedSprints)
+                ? transformedSprints
+                : [transformedSprints];
+        }
+        catch (error) {
+            this.logger.error('Failed to find workspace cycles', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Retrieves all labels associated with the projects in the workspace.
+     * This method fetches all projects along with their tags and transforms the tags
+     * into issue labels, consolidating them into a single array.
+     *
+     * @returns {Promise<IIssueLabel[]>} A promise resolving to an array of issue labels (`IIssueLabel[]`),
+     * each associated with a specific project in the workspace.
+     *
+     * @throws {BadRequestException} Throws if an error occurs during project or label retrieval.
+     */
+    async findWorkspaceLabels() {
+        try {
+            const projects = await this._projectService.getExternalProjects([
+                'tags'
+            ]);
+            const labels = projects
+                .map((project) => {
+                const transformed = (0, config_1.issueLabelsTransformer)(project.tags, project.id);
+                return Array.isArray(transformed)
+                    ? transformed
+                    : [transformed];
+            })
+                .flat();
+            return labels;
+        }
+        catch (error) {
+            this.logger.error('Failed to find workspace labels', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /*
+    |--------------------------------------------------------------------------
+    | DRAFT ISSUES
+    |--------------------------------------------------------------------------
+    */
+    /**
+     * Creates a new draft issue.
+     * @param {IIssueCreateInput} input - The input data required to create a draft issue.
+     * @returns {Promise<IIssue>} A promise that resolves to the newly created draft issue.
+     */
+    async createDraftIssue(input) {
+        return await this._draftIssueService.create(input);
+    }
+    /**
+     * Updates an issue with the given ID and input data, ensuring it remains a draft.
+     *
+     * @param {ID} id - The unique identifier of the issue to update.
+     * @param {IIssueUpdateInput} input - The data to update the issue with.
+     * @returns {Promise<IIssue>} A promise that resolves to the updated issue.
+     */
+    async updateDraftIssue(id, input) {
+        return await this._draftIssueService.update(id, input);
+    }
+    /**
+     * Retrieves all draft issues.
+     *
+     * @returns {Promise<any>} A promise that resolves to a list of transformed issues.
+     */
+    async findDraftIssues() {
+        return await this._draftIssueService.findAll();
+    }
+    async draftToIssue(id, input) {
+        return await this._draftIssueService.dratfToIssue(id, input);
+    }
+    /*
+    |--------------------------------------------------------------------------
+    | GLOBAL SEARCH
+    |--------------------------------------------------------------------------
+    */
+    /**
+     * Finds global entities based on search criteria across various domains.
+     *
+     * @param {IGlabalEntitiesFindInput} options - Search options, including project ID and search term.
+     * @returns {Promise<IGlobalEntitiesResponse>} A response containing filtered results across multiple entities.
+     * @throws {BadRequestException} Throws if the operation fails.
+     */
+    async findGlobalEntitiesBySearch(options) {
+        var _a, _b;
+        try {
+            // Retrieve and serialize projects
+            const projects = await this._projectService.getExternalProjects([]);
+            const serializedProjects = (0, config_1.getProjectsResponse)(projects);
+            // Retrieve and serialize tasks (issues)
+            const issues = await this._issueService.findAllExternal(options.project_id ? { projectId: options.project_id } : {}, ['project', 'tenant']);
+            const serializedIssues = issues.items.map((task) => (0, config_1.issueTransformer)(task));
+            // Retrieve and serialize cycles
+            const cycles = await this._cycleService.findAll(options.project_id);
+            const serializedCycles = Array.isArray(cycles) ? cycles : [cycles];
+            // Retrieve and serialize project modules
+            const modules = await this._projectModuleService.getAllModulesByProject(options.project_id);
+            const serializedModules = Array.isArray(modules)
+                ? modules
+                : [modules];
+            // Retrieve and serialize views
+            const views = await this._issueViewService.findAll(options.project_id);
+            const serializedViews = Array.isArray(views) ? views : [views];
+            const searchTerm = options.search.toLowerCase();
+            return {
+                results: {
+                    workspace: [], // TODO : Integrate workspaces APIs
+                    project: this.filterByName(searchTerm, serializedProjects),
+                    issue: this.filterByName(searchTerm, serializedIssues),
+                    cycle: this.filterByName(searchTerm, serializedCycles),
+                    module: this.filterByName(searchTerm, serializedModules),
+                    issue_view: this.filterByName(searchTerm, serializedViews),
+                    page: [] // Placeholder for future integration
+                }
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to find global entities by search: ${((_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || error.message}`, error.stack);
+            throw new common_1.BadRequestException(error.response);
+        }
+    }
+    /**
+     * Filters entities based on a search term in a specified key.
+     * @param searchTerm The term to search for.
+     * @param entities The array of entities to filter.
+     * @param key The key in each entity object where the search will be performed. Default is 'name'.
+     * @returns Filtered array of entities.
+     */
+    filterByName(searchTerm, entities, key = 'name') {
+        return entities.filter((entity) => { var _a; return (_a = entity[key]) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes(searchTerm.toLowerCase()); });
+    }
+    /**
+     * Performs an entity search based on the provided options.
+     *
+     * Currently, this function supports the `user_mention` query type, which retrieves
+     * project members and maps their details into a simplified format for user mentions.
+     *
+     * @param {IEntitySearchFindInput} options - The search options containing `project_id`
+     * and `query_type`.
+     * @returns {Promise<any>} A promise resolving to an object containing the user mention details.
+     * @throws {BadRequestException} Throws a BadRequestException if an error occurs during the process.
+     */
+    async entitySearch(options) {
+        const { project_id, query_type } = options;
+        try {
+            let members = [];
+            if (query_type === 'user_mention') {
+                if ((0, config_1.isNotEmpty)(project_id)) {
+                    const project = await this._projectService.getProject(project_id, ['members.employee.user']);
+                    members = project.members || [];
+                }
+                else {
+                    const projects = await this._projectService.getProjects(['members.employee.user'], 'objects');
+                    members = projects.flatMap((project) => project.members || []);
+                }
+            }
+            return {
+                user_mention: members
+                    .filter((member) => member != null && typeof member !== 'string')
+                    .map(({ member__display_name, member__id, member__avatar }) => ({
+                    member__display_name,
+                    member__id,
+                    member__avatar_url: member__avatar
+                }))
+            };
+        }
+        catch (error) {
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /*
+    |--------------------------------------------------------------------------
+    | VIEWS
+    |--------------------------------------------------------------------------
+    */
+    /**
+     * Retrieves issues based on the provided options and the referer.
+     *
+     * If a `viewId` can be extracted from the referer, the function retrieves all issues
+     * associated with a specific project using the `_issueService`. If no `viewId` is found,
+     * the function fetches issues grouped by user assignment.
+     *
+     * @async
+     * @param {IIssueFindInput} options - The search options for filtering issues.
+     * @param {string} referer - The referer URL, used to extract a workspace view ID.
+     * @returns A promise resolving to the issues, either grouped by user
+     * assignment or retrieved by project.
+     * @throws {BadRequestException} Throws a BadRequestException if an error occurs during
+     * the process.
+     */
+    async findViewIssues(options, referer) {
+        var _a, _b;
+        try {
+            // Extract the view ID from the referer if it exists
+            const viewId = (0, config_1.extractWorkspaceViewIdFromReferer)(referer);
+            if (!viewId) {
+                return this.findUserGroupedIssueAssigned(options);
+            }
+            return this._issueService.getAllIssuesByProject(undefined, options, referer);
+        }
+        catch (error) {
+            this.logger.error(`Failed to find view issues: ${((_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || error.message}`, error.stack);
+            throw new common_1.BadRequestException(error.response);
+        }
+    }
+    /*
+    |--------------------------------------------------------------------------
+    | NOTIFICATIONS SERVICES
+    |--------------------------------------------------------------------------
+    */
+    /**
+     * Fetches the notifications for the current user.
+     *
+     * @async
+     * @returns {Promise<INotificationResponse>} A promise that resolves to the notification response.
+     */
+    async findUserNotification() {
+        try {
+            const employeeId = (0, config_1.currentEmployeeId)();
+            const userNotifications = await this._notificationService.findAll({
+                receiverId: employeeId !== null && employeeId !== void 0 ? employeeId : undefined,
+                entity: plugin_integration_plane_models_1.BaseEntityEnum.Task
+            });
+            const notifications = await Promise.all((userNotifications !== null && userNotifications !== void 0 ? userNotifications : []).map(async (notification) => {
+                const task = await this._issueService.getExternalIssue(notification.entityId, ['members', 'project.members.employee.user']);
+                const tranformedNotification = (0, config_1.notificationTranformer)(notification, task);
+                return Array.isArray(tranformedNotification)
+                    ? tranformedNotification
+                    : [tranformedNotification];
+            }));
+            const results = notifications.flat();
+            return {
+                grouped_by: undefined,
+                sub_grouped_by: undefined,
+                total_count: results.length,
+                next_cursor: '300:1:0',
+                prev_cursor: '300:-1:1',
+                next_page_results: false,
+                prev_page_results: false,
+                count: results.length,
+                total_pages: 1,
+                total_results: results.length,
+                extra_stats: null,
+                results
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to find user notifications: ${error === null || error === void 0 ? void 0 : error.message}`, error.stack);
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Fetches the unread notifications for the current user.
+     *
+     * @async
+     * @returns {Promise<IUnreadNotificationResponse>} A promise that resolves to the unread notification data.
+     */
+    async findUnreadNotifications() {
+        try {
+            const receiverId = (0, config_1.currentEmployeeId)();
+            const userNotifications = await this._notificationService.findAll({
+                receiverId: receiverId !== null && receiverId !== void 0 ? receiverId : undefined,
+                entity: plugin_integration_plane_models_1.BaseEntityEnum.Task,
+                isRead: false
+            });
+            return (0, config_1.unreadNotificationData)(userNotifications);
+        }
+        catch (error) {
+            this.logger.error('Failed to find unread notifications', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Updates a notification to be on hold until a specified date.
+     *
+     * @async
+     * @param {ID} id - The ID of the notification to update.
+     * @param {INotification} input - The input object containing the snoozed_till date.
+     * @returns {Promise<any>} A promise that resolves to the result of the update operation.
+     */
+    async holdNotification(id, input) {
+        var _a;
+        return await this._notificationService.update(id, {
+            onHoldUntil: (_a = input.snoozed_till) !== null && _a !== void 0 ? _a : undefined
+        });
+    }
+    /**
+     * Marks all notifications as read.
+     *
+     * @async
+     * @returns {Promise<any>} A promise that resolves to the response data.
+     */
+    async markAllAsRead() {
+        return await this._notificationService.markAllAsRead();
+    }
+    /**
+     * Archives a notification.
+     *
+     * @async
+     * @param {ID} id - The ID of the notification to archive.
+     * @returns {Promise<any>} A promise that resolves to the result of the archive operation.
+     */
+    async archiveNotification(id) {
+        return this._toggleNotificationStatus(id, 'isArchived', true);
+    }
+    /**
+     * Unarchives a notification.
+     *
+     * @async
+     * @param {ID} id - The ID of the notification to unarchive.
+     * @returns {Promise<any>} A promise that resolves to the result of the unarchive operation.
+     */
+    async unArchiveNotification(id) {
+        return this._toggleNotificationStatus(id, 'isArchived', false);
+    }
+    /**
+     * Marks a notification as read and returns the updated notification.
+     *
+     * @async
+     * @param {ID} id - The ID of the notification to mark as read.
+     * @returns {Promise<INotification>} A promise that resolves to the updated notification.
+     */
+    async readNotification(id) {
+        return this._toggleNotificationStatus(id, 'isRead', true);
+    }
+    /**
+     * Marks a notification as unread and returns the updated notification.
+     *
+     * @async
+     * @param {ID} id - The ID of the notification to mark as read.
+     * @returns {Promise<INotification>} A promise that resolves to the updated notification.
+     */
+    async unreadNotification(id) {
+        return this._toggleNotificationStatus(id, 'isRead', false);
+    }
+    /**
+     * Toggles the status of a notification.
+     *
+     * @private
+     * @async
+     * @param {ID} id - The ID of the notification to toggle.
+     * @param {'isRead' | 'isArchived'} statusKey - The key of the status to toggle.
+     * @param {boolean} statusValue - The value of the status to toggle.
+     * @returns {Promise<INotification>} A promise that resolves to the updated notification.
+     */
+    async _toggleNotificationStatus(id, statusKey, statusValue) {
+        try {
+            const timestampKey = statusKey === 'isRead' ? 'readAt' : 'archivedAt';
+            await this._notificationService.update(id, {
+                [statusKey]: statusValue,
+                [timestampKey]: statusValue ? new Date() : null
+            });
+            const updatedNotification = await this._notificationService.findOne(id);
+            const task = await this._issueService.getExternalIssue(updatedNotification.entityId, ['members', 'project.members.employee.user']);
+            const transformedNotification = (0, config_1.notificationTranformer)(updatedNotification, task);
+            return Array.isArray(transformedNotification)
+                ? transformedNotification[0]
+                : transformedNotification;
+        }
+        catch (error) {
+            this.logger.error('Failed to toggle notification status', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /*
+    |--------------------------------------------------------------------------
+    | QUICK LINKS SERVICES
+    |--------------------------------------------------------------------------
+    */
+    /**
+     * Creates a quick link, an issue link that is not associated with any issue.
+     *
+     * @param input - The input data for creating the quick link.
+     * @returns The created quick link.
+     * @throws {BadRequestException} If the API returns an array of links instead of a single link.
+     */
+    async createQuickLink(input) {
+        const link = await this._issueLinkService.create(input, (0, config_1.getCurrentOrganizationSlug)(), 'organization');
+        return (0, config_1.issueLinkTransformer)(link);
+    }
+    /**
+     * Updates a quick link in the workspace.
+     *
+     * @param linkId - The ID of the quick link to update.
+     * @param input - The updated data for the quick link.
+     * @returns The updated quick link.
+     */
+    async updateQuickLink(linkId, input) {
+        const link = await this._issueLinkService.update(linkId, '', (0, config_1.getCurrentOrganizationSlug)(), input, plugin_integration_plane_models_1.BaseEntityEnum.Organization);
+        return (0, config_1.issueLinkTransformer)(link);
+    }
+    /**
+     * Finds all quick links in the workspace.
+     * @returns {Promise<IIssueLink[]>} A promise resolved to an array of quick links.
+     */
+    async findQuickLinks() {
+        const quickLinks = await this._issueLinkService.findWorkspaceQuickLinks();
+        const transformed = (0, config_1.issueLinkTransformer)(quickLinks);
+        // Ensure the result is always an array
+        return Array.isArray(transformed) ? transformed : [transformed];
+    }
+    /**
+     * Deletes a quick link from the workspace.
+     *
+     * @param id - The ID of the quick link to delete.
+     * @returns A promise resolving to the deleted result.
+     */
+    deleteQuickLink(id) {
+        return this._issueLinkService.delete(id);
+    }
+};
+exports.WorkspaceService = WorkspaceService;
+exports.WorkspaceService = WorkspaceService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)((0, common_1.forwardRef)(() => project_service_1.ProjectService))),
+    __metadata("design:paramtypes", [project_service_1.ProjectService,
+        issues_service_1.IssuesService,
+        cycles_service_1.CyclesService,
+        project_module_service_1.ProjectModuleService,
+        view_service_1.IssueViewService,
+        activity_service_1.ActivityService,
+        issue_links_service_1.IssueLinksService,
+        subscription_service_1.SubscriptionService,
+        draft_issues_service_1.DraftIssuesService,
+        employee_properties_service_1.EmployeePropertiesService,
+        dashboard_service_1.DashboardService,
+        widget_service_1.WidgetService,
+        notification_service_1.NotificationService,
+        api_fetch_service_1.ApiFetchService])
+], WorkspaceService);
+//# sourceMappingURL=workspace.service.js.map