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

package/dist/modules/issues/issues.service.js

@@ -0,0 +1,1052 @@
+"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.IssuesService = 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 config_1 = require("../../config");
+const api_fetch_service_1 = require("../api-fetch/api-fetch.service");
+const states_service_1 = require("../states/states.service");
+const comments_service_1 = require("../comments/comments.service");
+const project_service_1 = require("../project/project.service");
+const reactions_service_1 = require("../reactions/reactions.service");
+const issue_relations_service_1 = require("../issue-relations/issue-relations.service");
+const issue_links_service_1 = require("../issue-links/issue-links.service");
+const activity_service_1 = require("../activity/activity.service");
+const issue_labels_service_1 = require("./issue-labels/issue-labels.service");
+const subscription_service_1 = require("../subscription/subscription.service");
+const mention_service_1 = require("../mention/mention.service");
+let IssuesService = class IssuesService extends api_fetch_service_1.ApiFetchService {
+    constructor(_projectService, _stateSerive, _issueLabelService, _commentService, _reactionService, _issueLinkService, _issueRelationService, _activityService, _subscriptionService, _mentionService, _serverFetchService) {
+        super(_serverFetchService['_httpService']);
+        this._projectService = _projectService;
+        this._stateSerive = _stateSerive;
+        this._issueLabelService = _issueLabelService;
+        this._commentService = _commentService;
+        this._reactionService = _reactionService;
+        this._issueLinkService = _issueLinkService;
+        this._issueRelationService = _issueRelationService;
+        this._activityService = _activityService;
+        this._subscriptionService = _subscriptionService;
+        this._mentionService = _mentionService;
+        this._serverFetchService = _serverFetchService;
+        this.path = '/tasks';
+    }
+    /**
+     * @description - Get remode API issue
+     * @param {ID} id - The issue ID
+     * @returns - A promise that resolved after getting issue
+     * @memberof IssuesService
+     */
+    async getExternalIssue(id, relations, isDraft) {
+        const query = qs_1.default.stringify((0, config_1.getTaskQuery)(undefined, {}, relations, undefined, isDraft));
+        return (await this.apiFetch({
+            path: `${this.path}/${id}`,
+            method: 'GET',
+            query
+        })).data;
+    }
+    /**
+     * Retrieves all tasks from an external source with optional filters.
+     *
+     * Sends a GET request to an external API to fetch tasks based on the provided options.
+     *
+     * @param {ITask} options - Optional task filters or configurations to customize the query.
+     * @returns {Promise<IPagination<ITask>>} A promise that resolves to an array of tasks.
+     * @throws {BadRequestException} If an error occurs during the fetch.
+     */
+    async findAllExternal(options, relations, orderByField, isDraft = false) {
+        try {
+            const query = qs_1.default.stringify((0, config_1.getTaskQuery)(undefined, options, relations, orderByField, isDraft));
+            return (await this.apiFetch({
+                method: 'GET',
+                path: this.path,
+                query
+            })).data;
+        }
+        catch (error) {
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Retrieves tasks assigned to a specific employee from an external source.
+     *
+     * Sends a GET request to fetch tasks for the specified employee ID.
+     *
+     * @param {ID} employeeId - The ID of the employee for whom the tasks are being retrieved.
+     * @returns {Promise<ITask[]>} A promise that resolves to an array of tasks assigned to the specified employee.
+     * @throws {BadRequestException} If an error occurs during the fetch.
+     */
+    async findExternalByEmployee(employeeId, relations, orderByField) {
+        try {
+            // Build query for task retrieval
+            const query = qs_1.default.stringify((0, config_1.getTaskQuery)(undefined, {}, relations, orderByField, false));
+            // Fetch tasks for the authenticated employee
+            const tasks = (await this.apiFetch({
+                method: 'GET',
+                path: `${this.path}/employee/${employeeId}`,
+                query
+            })).data;
+            return tasks;
+        }
+        catch (error) {
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Retrieves tasks based on the provided start and due date filters.
+     *
+     * This method builds a query dynamically based on the provided `ITaskDateFilterInput` options.
+     * It sends a GET request to fetch tasks filtered by the specified
+     * start and due date ranges or other applicable criteria.
+     *
+     * @param {ITaskDateFilterInput} options - The filtering options including start date, due date, and other possible filters.
+     * @returns {Promise<ITask[]>} A promise that resolves with an array of tasks that match the filtering criteria.
+     * @throws {BadRequestException} Throws an error if the API request fails or if the options are invalid.
+     */
+    async findByStartAndDueDate(options) {
+        try {
+            // Build query for task retrieval
+            const query = qs_1.default.stringify((0, config_1.getFilteredByDatesTaskQuery)(options));
+            const tasks = (await this.apiFetch({
+                method: 'GET',
+                path: `${this.path}/filter-by-date`,
+                query
+            })).data;
+            return tasks.items;
+        }
+        catch (error) {
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * @description - Find issue by Id
+     * @param {ID} id - The issue ID to search
+     * @returns - A promise that resolves after issue fetched
+     * @memberof IssuesService
+     */
+    async findOne(id, isDraft) {
+        var _a, _b, _c;
+        try {
+            const issue = await this.getExternalIssue(id, [
+                'tags',
+                'members.user',
+                'createdByUser',
+                'project.members.employee.user.role',
+                'organizationSprint',
+                'modules'
+            ], isDraft);
+            if (!issue) {
+                throw new common_1.BadRequestException('Issue not found');
+            }
+            // Find Issue Reactions
+            const reactions = await this.findIssueReactions({
+                entityId: id,
+                entity: plugin_integration_plane_models_1.ReactionEntityEnum.Task
+            }, issue.projectId, isDraft);
+            //Check current user subscription.
+            const subscriptions = await this._subscriptionService.findAll({
+                entity: plugin_integration_plane_models_1.BaseEntityEnum.Task,
+                entityId: issue.id,
+                userId: (_a = (0, config_1.currentUserId)()) !== null && _a !== void 0 ? _a : undefined
+            });
+            const isSubscribed = subscriptions && subscriptions.length > 0;
+            // Find issue links
+            const links = await this.findIssueLinks(id, issue.projectId, issue);
+            return (0, config_1.issueTransformer)(issue, reactions, links, isSubscribed);
+        }
+        catch (error) {
+            this.logger.error(`Failed to find issue: ${((_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);
+        }
+    }
+    /**
+     * @description - Create issue
+     * @param {IIssueCreateInput} input - data for creating new issue
+     * @returns - A promise that resolves after issue created
+     * @memberof IssuesService
+     */
+    async create(input) {
+        var _a, _b;
+        try {
+            const { state_id } = input;
+            // Set default status
+            let state = { name: plugin_integration_plane_models_1.TaskStatusEnum.BACKLOG };
+            if (state_id && state_id.length > 0) {
+                state = await this._stateSerive.getOne(input.state_id);
+            }
+            const body = (0, config_1.createIssueInputTransformer)(input, state.name);
+            const issue = (await this.apiFetch({
+                method: 'POST',
+                path: this.path,
+                body
+            })).data;
+            return (0, config_1.issueTransformer)(issue);
+        }
+        catch (error) {
+            this.logger.error(`Failed to create issue: ${((_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);
+        }
+    }
+    /**
+     * @description - Update issue
+     * @param {IIssueCreateInput} input - data for updating issue
+     * @param {ID} id - The issue ID to be updated
+     * @returns - A promise that resolves after issue updated
+     * @memberof IssuesService
+     */
+    async update(id, input, isDraft) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        try {
+            // Extract modules to be added and removed from the input
+            const { modules: added_modules = [], removed_modules = [], module_ids = [] } = input;
+            // Fetch the state only if a state_id is provided
+            let state;
+            try {
+                if (input.state_id) {
+                    state = await this._stateSerive.getOne(input.state_id);
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Failed to fetch state: ${((_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}`);
+            }
+            // Retrieve the existing issue and external issue details simultaneously
+            const [issue, externalIssue] = await Promise.all([
+                this.findOne(id, isDraft),
+                this.getExternalIssue(id, undefined, isDraft)
+            ]);
+            if (!issue) {
+                throw new common_1.BadRequestException('Issue not found');
+            }
+            // Find labels
+            const labelResult = await this._issueLabelService.getProjectIssueLabels(issue.project_id);
+            const labels = Array.isArray(labelResult)
+                ? labelResult
+                : [labelResult];
+            // Find project
+            const project = await this._projectService.getExternalProject(issue.project_id, ['modules', 'members.employee']);
+            // Calculate the final set of modules after additions and removals
+            const existingModules = ((_c = externalIssue === null || externalIssue === void 0 ? void 0 : externalIssue.modules) === null || _c === void 0 ? void 0 : _c.map((module) => module.id)) || [];
+            const modules = new Set([
+                ...existingModules,
+                ...added_modules.concat(module_ids)
+            ]);
+            removed_modules.forEach((module) => modules.delete(module)); // Remove the modules marked for deletion
+            // Transform the input data for the update request
+            const body = (0, config_1.updateIssueInputTransformer)(input, state === null || state === void 0 ? void 0 : state.name, (_d = project.members) === null || _d === void 0 ? void 0 : _d.map((member) => member.employee), labels, Array.from(modules), project.modules);
+            const task = (await this.apiFetch({
+                path: `${this.path}/${id}`,
+                method: 'PUT',
+                body: Object.assign(Object.assign({}, body), { title: (_e = input.name) !== null && _e !== void 0 ? _e : issue.name, status: (state === null || state === void 0 ? void 0 : state.name) || externalIssue.status })
+            })).data;
+            const updatedTask = await this.getExternalIssue(task.id, undefined);
+            return (0, config_1.issueTransformer)(updatedTask);
+        }
+        catch (error) {
+            this.logger.error(`Failed to update issue: ${((_g = (_f = error === null || error === void 0 ? void 0 : error.response) === null || _f === void 0 ? void 0 : _f.data) === null || _g === void 0 ? void 0 : _g.message) || error.message}`, error.stack);
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Updates the parent-child relationship between a parent task and multiple sub-tasks.
+     *
+     * @param {ID} id - The ID of the parent task.
+     * @param {Pick<IIssueUpdateInput, 'sub_issue_ids'>} input - Object containing the IDs of the sub-tasks (`sub_issue_ids`).
+     * @returns {Promise<ITask[]>} - A promise that resolves to an array of updated tasks
+     * @throws {BadRequestException} - Throws an exception in case of an update error.
+     */
+    async updateRelationnalIssueParent(id, input) {
+        var _a, _b;
+        try {
+            const { sub_issue_ids } = input;
+            const tasks = [];
+            const subIssues = await Promise.all((sub_issue_ids !== null && sub_issue_ids !== void 0 ? sub_issue_ids : []).map(async (issueId) => {
+                const issue = await this.getExternalIssue(issueId, undefined, false);
+                await this.apiFetch({
+                    path: `${this.path}/${issueId}`,
+                    method: 'PUT',
+                    body: Object.assign(Object.assign({}, issue), { parentId: id })
+                });
+                tasks.push(issue);
+                return (0, config_1.issueTransformer)(issue);
+            }));
+            const stateDistribution = (0, config_1.getTaskDistribution)(tasks);
+            return {
+                sub_issues: subIssues,
+                state_distribution: stateDistribution
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to update relational issue parent: ${((_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 all issues related to a specific project, with optional filters and grouping.
+     *
+     * This function fetches issues based on the project ID, using optional parameters such as
+     * filter options and the referer to detect if the request comes from a view page.
+     * Depending on the `group_by` option, the issues are grouped accordingly before being returned.
+     *
+     * @param {ID} projectId - The ID of the project for which to retrieve issues.
+     * @param {IIssueFindInput} [options] - Optional filters and grouping options for the query.
+     * @param {string} [referer] - The referer URL, used to extract the view ID if the request is from a view page.
+     * @returns {Promise<any>} A promise that resolves to the grouped or non-grouped issues.
+     * @throws {BadRequestException} If there is an error during the API fetch or data processing.
+     */
+    async getAllIssuesByProject(projectId, options, referer) {
+        var _a;
+        try {
+            // Extract the view ID from the referer if it exists
+            const viewId = (_a = (0, config_1.extractViewIdFromReferer)(referer)) !== null && _a !== void 0 ? _a : (0, config_1.extractWorkspaceViewIdFromReferer)(referer);
+            // Destructure options for group_by and module if provided
+            const { group_by, sub_group_by, mentions, module, priority, start_date, target_date, type } = options;
+            // Create the query string based on the provided options and projectId
+            const query = qs_1.default.stringify((0, config_1.getTaskQuery)(projectId, options, undefined, undefined, false));
+            let path = '';
+            // If a module is specified, modify the path accordingly
+            if (module && !module.includes(',')) {
+                path = 'module';
+            }
+            // Fetch tasks from the API, using the viewId if available, otherwise default to module or the base path
+            const tasks = (await this.apiFetch({
+                method: 'GET',
+                path: !viewId
+                    ? `${this.path}/${path}` // Use module path if no viewId
+                    : `${this.path}/view/${viewId}`, // Use view path if viewId is present
+                query
+            })).data;
+            // Extract the issues from the API response
+            let issues = tasks.items;
+            // Optional filter tasks by priority criteria
+            if (priority) {
+                const priorities = (0, config_1.issueFilterSplitter)(priority);
+                issues = (0, config_1.filterIssuesByPriorityNames)(issues, priorities);
+            }
+            // Optional filter tasks by type (Active or Backlog)
+            if (type) {
+                issues = (0, config_1.filterIssuesByActiveType)(issues, type);
+            }
+            // Optional filter tasks by start_date string
+            if (start_date) {
+                issues = (0, config_1.filterTasksByDateCriteria)(issues, 'startDate', start_date);
+            }
+            // Optional filter tasks by start_date string
+            if (target_date) {
+                issues = (0, config_1.filterTasksByDateCriteria)(issues, 'dueDate', target_date);
+            }
+            if (mentions) {
+                const mentionIds = (0, config_1.issueFilterSplitter)(mentions);
+                try {
+                    const [taskParentMentionedUsers, taskMentionedUsers] = await Promise.all([
+                        this._mentionService.findAll({
+                            parentEntityType: plugin_integration_plane_models_1.BaseEntityEnum.Task
+                        }),
+                        this._mentionService.findAll({
+                            entity: plugin_integration_plane_models_1.BaseEntityEnum.Task
+                        })
+                    ]);
+                    const taskIds = new Set([
+                        ...taskMentionedUsers.map((mention) => mention.entityId),
+                        ...taskParentMentionedUsers.map((mention) => mention.parentEntityId)
+                    ]);
+                    const mentionedUserIds = new Set([
+                        ...taskMentionedUsers.map((mention) => mention.mentionedUserId),
+                        ...taskParentMentionedUsers.map((mention) => mention.mentionedUserId)
+                    ]);
+                    // Filtrage des issues
+                    issues = issues.filter((task) => taskIds.has(task.id) &&
+                        task.members.some((member) => mentionIds.includes(member.id) &&
+                            mentionedUserIds.has(member.userId)));
+                }
+                catch (error) {
+                    this.logger.error('Error filtering issues by mentions', error instanceof Error ? error.stack : String(error));
+                }
+            }
+            // Group the issues based on the group_by option, or return non-grouped issues by default
+            const issuesWithLinks = await Promise.all((issues !== null && issues !== void 0 ? issues : []).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
+                };
+            }));
+            const project = await this._projectService.getExternalProject(projectId, ['members.employee']);
+            const employees = project.members.map((member) => member.employee);
+            switch (group_by) {
+                case plugin_integration_plane_models_1.IssueGroupByEnum.STATE:
+                    return (0, config_1.groupIssuesByStateId)(issuesWithLinks, sub_group_by, employees); // Group issues by their state
+                case plugin_integration_plane_models_1.IssueGroupByEnum.TARGET_DATE:
+                    return (0, config_1.groupIssuesByTargetDate)(issues); // Group issues by their target date
+                case plugin_integration_plane_models_1.IssueGroupByEnum.PRIORITY:
+                    return (0, config_1.groupIssuesByPriority)(issuesWithLinks, sub_group_by, employees); // Group issues by their priority
+                case plugin_integration_plane_models_1.IssueGroupByEnum.CYCLE_ID:
+                    return (0, config_1.groupIssuesByCycleId)(issuesWithLinks, sub_group_by, employees); // Group issues by their cycle
+                case plugin_integration_plane_models_1.IssueGroupByEnum.MODULE_ID:
+                    return (0, config_1.groupIssuesByModule)(issuesWithLinks, sub_group_by, employees); // Group issues by their modules
+                case plugin_integration_plane_models_1.IssueGroupByEnum.LABEL_ID:
+                    return (0, config_1.groupIssuesByLabel)(issuesWithLinks, sub_group_by, employees); // Group issues by their labels
+                case plugin_integration_plane_models_1.IssueGroupByEnum.ASSIGNEE_ID:
+                    return (0, config_1.groupIssuesByAssignee)(issuesWithLinks, sub_group_by, employees); // Group issues by their assignees
+                case plugin_integration_plane_models_1.IssueGroupByEnum.CREATED_BY:
+                    return (0, config_1.groupIssuesByCreatorId)(issuesWithLinks, sub_group_by, employees); // Group issues by their creator
+                default:
+                    return (0, config_1.nonGroupedIssues)(issues); // Return issues as they are if no group_by is specified
+            }
+        }
+        catch (error) {
+            this.logger.error(`Failed to get all issues by project: ${error === null || error === void 0 ? void 0 : error.message}`, error.stack);
+            throw new common_1.BadRequestException();
+        }
+    }
+    /**
+     * @description Find issu children
+     * @param {ID} id - Issue ID to search
+     * @returns A promise that resolves after found issue children
+     * @memberof IssuesService
+     */
+    async findIssueChildren(id) {
+        try {
+            const sub_issues = [];
+            const issue = await this.getExternalIssue(id, ['children.taskStatus', 'children.members'], false);
+            if (!issue) {
+                throw new common_1.BadRequestException('Issue could not be found');
+            }
+            if (issue.children.length > 0) {
+                const children = issue.children;
+                children.forEach((task) => sub_issues.push((0, config_1.issueTransformer)(task)));
+            }
+            const stateDistribution = (0, config_1.getTaskDistribution)(issue.children);
+            return { sub_issues, state_distribution: stateDistribution };
+        }
+        catch (error) {
+            this.logger.error('Failed to find issue children', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException();
+        }
+    }
+    /**
+     * Retrieves all tasks with optional filters and options.
+     *
+     * Sends a GET request to fetch tasks with the provided query options, and
+     * transforms each task into the issue format. Returns a list of transformed tasks.
+     *
+     * @param {ITask} [options] - Optional filters or configurations for fetching tasks.
+     * @returns {Promise<IIssue[]>} A promise that resolves to a list of transformed issues.
+     * @throws {BadRequestException} If an error occurs during the fetch.
+     */
+    async findAll(options, relations, isDraft = false) {
+        var _a;
+        try {
+            const query = qs_1.default.stringify((0, config_1.getTaskQuery)(undefined, options, relations, undefined, isDraft));
+            const tasks = (await this.apiFetch({
+                method: 'GET',
+                path: this.path,
+                query
+            })).data;
+            return (_a = tasks.items) === null || _a === void 0 ? void 0 : _a.map((task) => (0, config_1.issueTransformer)(task));
+        }
+        catch (error) {
+            this.logger.error('Failed to find all issues', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * Retrieves tasks assigned to a specific employee.
+     *
+     * Sends a GET request to fetch tasks based on the provided employee ID,
+     * applies a transformation to each task, and returns the transformed list.
+     *
+     * @param {ID} employeeId - The ID of the employee whose tasks are to be fetched.
+     * @returns {Promise<ITask[]>} A promise that resolves to a list of transformed tasks.
+     * @throws {BadRequestException} If an error occurs during the fetch.
+     */
+    async findByEmployee(employeeId, relations) {
+        var _a, _b;
+        try {
+            const tasks = await this.findExternalByEmployee(employeeId, relations);
+            return tasks.map((task) => (0, config_1.issueTransformer)(task));
+        }
+        catch (error) {
+            this.logger.error(`Failed to find issues by employee: ${((_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);
+        }
+    }
+    /**
+     * @description Create issue relations.
+     * @param {ID} taskToId Issue ID for whom to create main relations.
+     * @param {ICreateIssueRelationInput} input - Body request data for creating main and inversed relations.
+     * @returns A promise resolved to created and transformed main relations.
+     * @memberof IssuesService
+     */
+    async createIssueRelations(taskToId, input) {
+        try {
+            const { issues, relation_type } = input;
+            return await this._issueRelationService.create(taskToId, issues, relation_type);
+        }
+        catch (error) {
+            this.logger.error('Failed to create issue relations', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * @description Delete main and inverse relations
+     * @param {ID} id - Main Issue ID for delete the main relation
+     * @param {IDeleteRelationInput} input - Body Request data for related issue and relation type
+     * @returns - Delete Result
+     * @memberof IssuesService
+     */
+    async deleteIssueRelation(id, input) {
+        var _a, _b;
+        try {
+            return await this._issueRelationService.delete(id, input);
+        }
+        catch (error) {
+            this.logger.error(`Failed to delete issue relation: ${((_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);
+        }
+    }
+    /**
+     * @description Find issue relation (Issues associates)
+     * @param {ID} id - Issue ID
+     * @returns A promise resolved to fetched issue relations
+     * @memberof IssuesService
+     */
+    async findIssueRelations(id) {
+        try {
+            return await this._issueRelationService.findRelationsByIssueId(id);
+        }
+        catch (error) {
+            this.logger.error('Failed to find issue relations', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException();
+        }
+    }
+    /**
+     * @description Delete issue
+     * @param {ID} id - The issue ID to be deleted
+     * @returns A promise resolved to delete result
+     * @memberof IssuesService
+     */
+    async delete(id) {
+        return (await this.apiFetch({
+            method: 'DELETE',
+            path: `${this.path}/${id}/soft`
+        })).data;
+    }
+    /**
+     * @description Create issue comment
+     * @param {ID} entityId - Issue ID for creating comment
+     * @param {ID} projectId - Project ID for returning project data
+     * @param {ICreateCommentInput} input - Body request
+     * @returns A promise resolved to comment created and returned related data
+     * @memberof IssuesService
+     */
+    async createComment(entityId, projectId, input) {
+        var _a;
+        try {
+            const task = await this.getExternalIssue(entityId, ['project.members.employee.user.role', 'project.organization'], false);
+            const projectMembers = task.project.members.map((member) => member.employee);
+            // Create comment
+            const comment = await this._commentService.create(Object.assign(Object.assign({}, input), { entityName: task.title }), plugin_integration_plane_models_1.BaseEntityEnum.Task, entityId, projectMembers);
+            const { issue, project, workspace } = await this.getIssueCommentDetails(entityId, task.projectId, (_a = comment.employee) === null || _a === void 0 ? void 0 : _a.id, task, task.project);
+            const transformedComment = (0, config_1.issueCommentTrasnsformer)(comment, issue, project, workspace, [], // On creation, comment has no reaction yet
+            project.members
+                .map((member) => member.employee)
+                .filter((employee) => employee.userId === comment.createdByUserId)[0]);
+            return Array.isArray(transformedComment)
+                ? transformedComment[0]
+                : transformedComment;
+        }
+        catch (error) {
+            this.logger.error('Failed to create comment', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException();
+        }
+    }
+    /**
+     * @description Update issue comment
+     * @param {ID} id - Comment ID to be updated
+     * @param {ID} projectId - Project ID for find details
+     * @param {ICreateCommentInput} input - Body Request data
+     * @param {ID} entityId
+     * @returns A promise resolved to updated comment and details
+     * @memberof IssuesService
+     */
+    async updateComment(id, projectId, input, entityId) {
+        var _a, _b;
+        try {
+            // Update comment
+            const options = {
+                entity: plugin_integration_plane_models_1.BaseEntityEnum.Task,
+                entityId
+            };
+            const comment = await this._commentService.update(id, options, input);
+            const updatedComment = await this._commentService.findOne(id, options);
+            const { issue, project, workspace } = await this.getIssueCommentDetails(updatedComment.entityId, projectId, updatedComment.employeeId);
+            const reactions = await this._commentService.findCommentReactions({
+                entityId: updatedComment.id,
+                entity: plugin_integration_plane_models_1.ReactionEntityEnum.Comment
+            }, projectId);
+            const transformedComment = (0, config_1.issueCommentTrasnsformer)(updatedComment, issue, project, workspace, reactions, project.members
+                .map((member) => member.employee)
+                .filter((employee) => employee.userId === comment.createdByUserId)[0]);
+            return Array.isArray(transformedComment)
+                ? transformedComment[0]
+                : transformedComment;
+        }
+        catch (error) {
+            this.logger.error(`Failed to update comment: ${((_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);
+        }
+    }
+    /**
+     * @description Delete issue comment
+     * @param {ID} id -The issue comment ID to be deleted
+     * @returns A promise resolved to delete result
+     * @memberof IssuesService
+     */
+    async deleteComment(id) {
+        return await this._commentService.delete(id);
+    }
+    /**
+     * @description Get issues comments
+     * @param {Partial<ICommentFindInput>} options Option filters
+     * @param {ID} projectId - Project ID
+     * @returns A promise resolved after fetch comments
+     * @memberof IssuesService
+     */
+    async getIssueComments(options, projectId) {
+        try {
+            const comments = await this._commentService.findAll(options);
+            const task = await this.getExternalIssue(options.entityId, ['project.members.employee.user.role', 'project.organization'], false);
+            const projectMembers = task.project.members.map((member) => member.employee);
+            const issueComments = await Promise.all((comments !== null && comments !== void 0 ? comments : []).map(async (comment) => {
+                const reactions = await this._commentService.findCommentReactions({
+                    entityId: comment.id,
+                    entity: plugin_integration_plane_models_1.ReactionEntityEnum.Comment
+                }, projectId);
+                const { issue, project, workspace } = await this.getIssueCommentDetails(options.entityId, projectId, comment.employeeId, task, task.project);
+                const transformedComment = (0, config_1.issueCommentTrasnsformer)(comment, issue, project, workspace, reactions, projectMembers.filter((employee) => employee.userId === comment.createdByUserId)[0]);
+                return Array.isArray(transformedComment)
+                    ? transformedComment[0]
+                    : transformedComment;
+            }));
+            return issueComments;
+        }
+        catch (error) {
+            this.logger.error('Failed to get issue comments', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    async findIssueActivity(id, projectId) {
+        try {
+            const activityLogs = await this._activityService.findAll({
+                entity: plugin_integration_plane_models_1.BaseEntityEnum.Task,
+                entityId: id
+            });
+            const task = await this.getExternalIssue(id, [
+                'project.members.employee.user.role',
+                'project.organization',
+                'organizationSprint',
+                'taskSprintHistories.toSprint',
+                'parent'
+            ], false);
+            const projectEmployees = task.project.members.map((member) => member.employee);
+            // 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.findAllExternal({
+                    issues: Array.from(parentIds).join(',')
+                }, ['project']);
+                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 { actor, issue, project, workspace } = await this.getIssueCommentDetails(id, 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, projectEmployees.filter((employee) => employee.userId === activityLog.createdByUserId)[0], projectEmployees, parentTasks);
+                return Array.isArray(transformedActivityLogs)
+                    ? transformedActivityLogs
+                    : [transformedActivityLogs];
+            }));
+            // Find links for logs
+            const links = await this._issueLinkService.findAll(plugin_integration_plane_models_1.BaseEntityEnum.Task, id);
+            const linkActivities = await Promise.all((links !== null && links !== void 0 ? links : []).map(async (link) => {
+                const logs = await this._activityService.findAll({
+                    entity: plugin_integration_plane_models_1.BaseEntityEnum.ResourceLink,
+                    entityId: link.id
+                });
+                const activities = await Promise.all((logs !== null && logs !== void 0 ? logs : []).map(async (log) => {
+                    const { actor, issue, project, workspace } = await this.getIssueCommentDetails(id, projectId, log.employeeId, task, task.project);
+                    return (0, config_1.issueLinksActivities)(logs, link, issue, actor, project, workspace, projectEmployees.filter((employee) => employee.userId === log.createdByUserId)[0]);
+                }));
+                return activities;
+            }));
+            // Find issue relations activities logs
+            const issueRelations = await this._issueRelationService.findAllByIssueId(id, true);
+            const issueRelationsActivities = await Promise.all((issueRelations !== null && issueRelations !== void 0 ? issueRelations : []).map(async (issueRelation) => {
+                const logs = await this._activityService.findAll({
+                    entity: plugin_integration_plane_models_1.BaseEntityEnum.TaskLinkedIssue,
+                    entityId: issueRelation.id
+                });
+                const activities = await Promise.all((logs !== null && logs !== void 0 ? logs : []).map(async (log) => {
+                    const { actor, issue, project, workspace } = await this.getIssueCommentDetails(id, projectId, log.employeeId, task, task.project);
+                    return (0, config_1.issueRelationActivities)(logs, issueRelation, issue, actor, project, workspace, projectEmployees.filter((employee) => employee.userId === log.createdByUserId)[0]);
+                }));
+                return activities;
+            }));
+            // Combined activities
+            const flattenedActivities = issueActivities
+                .flat()
+                .concat(linkActivities.flat(2))
+                .concat(issueRelationsActivities.flat(2));
+            return flattenedActivities.filter(Boolean);
+        }
+        catch (error) {
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * @description Create Reaction to issue
+     * @param {ID} entityId - Issue ID for whom create reaction
+     * @param {ID} projectId - The project ID for returning project data
+     * @param {ICreateReactionInput} input - Body request data
+     * @returns A promise resolved to created and transformed reaction
+     * @memberof IssuesService
+     */
+    async createReaction(entityId, projectId, input) {
+        try {
+            const task = await this.getExternalIssue(entityId, ['project.members.employee.user.role', 'project.organization'], false);
+            // Create reaction
+            const reaction = await this._reactionService.create(input, plugin_integration_plane_models_1.ReactionEntityEnum.Task, entityId);
+            // Reaction details
+            const { project, workspace } = await this.getIssueCommentDetails(entityId, projectId, reaction.employeeId, task, task.project);
+            // Transform Reaction
+            const transformedReaction = (0, config_1.reactionTransformer)(reaction, project, workspace);
+            return Array.isArray(transformedReaction)
+                ? transformedReaction[0]
+                : transformedReaction;
+        }
+        catch (error) {
+            this.logger.error('Failed to create reaction', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * @description Find issue reactions with associated data
+     * @param {Partial<IReaction>} options Find options filter
+     * @param {ID} projectId - Project ID for returning data
+     * @returns A promise resolved to found and transformed reactions
+     * @memberof IssuesService
+     */
+    async findIssueReactions(options, projectId, isDraft) {
+        var _a, _b;
+        try {
+            const task = await this.getExternalIssue(options.entityId, ['project.members.employee.user.role', 'project.organization'], isDraft);
+            const reactions = await this._reactionService.findAll(options);
+            const issueReactions = await Promise.all((reactions !== null && reactions !== void 0 ? reactions : []).map(async (reaction) => {
+                const { project, workspace } = await this.getIssueCommentDetails(options.entityId, projectId, reaction.employeeId, task, task.project);
+                const transformedReaction = (0, config_1.reactionTransformer)(reaction, project, workspace);
+                return Array.isArray(transformedReaction)
+                    ? transformedReaction[0]
+                    : transformedReaction;
+            }));
+            return issueReactions;
+        }
+        catch (error) {
+            this.logger.error(`Failed to find issue reactions: ${((_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);
+        }
+    }
+    /**
+     * @description Delete Issue Reaction By Emoji.
+     * @param {string} reaction - Emoji
+     * @param {ID} entityId - Issue ID from whom to delete reaction
+     * @returns A promise resolved to deleted result
+     * @memberof IssuesService
+     */
+    async deleteIssueReactionByEmoji(reaction, entityId) {
+        return await this._reactionService.deleteByEmoji(reaction, plugin_integration_plane_models_1.ReactionEntityEnum.Task, entityId);
+    }
+    /**
+     * @description Get issue activity and comments
+     * @param {ID} id - Issue ID
+     * @param {ID} projectId - Project ID
+     * @param {IssueActivityTypeEnum} activity_type Activity type
+     * @returns A promise resolved after got comments or Activity Logs
+     * @memberof IssuesService
+     */
+    async findActivity(id, projectId, activity_type) {
+        try {
+            if (activity_type === plugin_integration_plane_models_1.IssueActivityTypeEnum.COMMENT) {
+                return await this.getIssueComments({ entityId: id, entity: plugin_integration_plane_models_1.BaseEntityEnum.Task }, projectId);
+            }
+            return await this.findIssueActivity(id, projectId);
+        }
+        catch (error) {
+            this.logger.error(`Failed to find activity: ${error === null || error === void 0 ? void 0 : error.message}`, error.stack);
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * @description Get Issue comment and reaction details
+     * @param {ID} id - Issue ID
+     * @param {ID} projectId - Project ID
+     * @param {ID} employeeId Creator ID for returning actor details
+     * @param {ITask} originalTask Optional task to avoid multiple API calls
+     * @param {IOrganizationProject} originalProject Optional project to avoid multiple API calls
+     * @returns - A promise resolced afet got details
+     * @memberof IssuesService
+     */
+    async getIssueCommentDetails(id, projectId, employeeId, originalTask, originalProject) {
+        var _a, _b;
+        try {
+            let task = originalTask;
+            let project = originalProject;
+            // remote issue to find creator member if no task provided
+            if (!task) {
+                task = await this.getExternalIssue(id, undefined, false);
+            }
+            // Commented issue
+            const issue = (0, config_1.issueTransformer)(task);
+            // Find project if none is provided
+            if (!originalProject && projectId) {
+                project =
+                    await this._projectService.getExternalProject(projectId);
+            }
+            // Workspace details
+            const organization = project === null || project === void 0 ? void 0 : project.organization;
+            const workspace = {
+                name: organization === null || organization === void 0 ? void 0 : organization.name,
+                id: organization === null || organization === void 0 ? void 0 : organization.id,
+                slug: organization === null || organization === void 0 ? void 0 : organization.id
+            };
+            // Find actor by userId
+            const actor = (_b = (_a = project === null || project === void 0 ? void 0 : project.members) === null || _a === void 0 ? void 0 : _a.find((member) => member.employeeId === employeeId)) === null || _b === void 0 ? void 0 : _b.employee;
+            return { issue, project, workspace, actor };
+        }
+        catch (error) {
+            this.logger.error('Failed to get issue comment details', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * @description Create Issue Link
+     * @param {ID} id - Issue ID for whom create link
+     * @param {ID} projectId - The project ID for returning project data
+     * @param {ICreateIssueLink} input - Body request data
+     * @returns A promise resolved to created and transformed link
+     * @memberof IssuesService
+     */
+    async createLink(id, projectId, input) {
+        try {
+            // Create link
+            const link = await this._issueLinkService.create(input, id);
+            const task = await this.getExternalIssue(id, [
+                'tags',
+                'members.user',
+                'createdByUser',
+                'project.members.employee.user.role',
+                'organizationSprint'
+            ]);
+            // Link Details
+            const { actor, project } = await this.getIssueCommentDetails(id, projectId, link.employeeId, task, task.project);
+            // Transform Link
+            const transformedLink = (0, config_1.issueLinkTransformer)(link, actor, project);
+            return Array.isArray(transformedLink)
+                ? transformedLink[0]
+                : transformedLink;
+        }
+        catch (error) {
+            this.logger.error('Failed to create link', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * @description Update Issue Link
+     * @param {ID} id - Link ID to update update
+     * @param {ID} issueId - Issue ID for whom update link
+     * @param {ID} projectId - The project ID for returning project data
+     * @param {ICreateIssueLink} input - Body request data
+     * @returns A promise resolved to created and transformed link
+     * @memberof IssuesService
+     */
+    async updateLink(id, issueId, projectId, input) {
+        try {
+            // Update link
+            const link = await this._issueLinkService.update(id, issueId, '', input, plugin_integration_plane_models_1.BaseEntityEnum.Task);
+            // Link Details
+            const { actor, project } = await this.getIssueCommentDetails(issueId, projectId, link.employeeId);
+            // Transform Link
+            const transformedLink = (0, config_1.issueLinkTransformer)(link, actor, project);
+            return Array.isArray(transformedLink)
+                ? transformedLink[0]
+                : transformedLink;
+        }
+        catch (error) {
+            this.logger.error('Failed to update link', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+    /**
+     * @description Find issue links with associated data
+     * @param {ID} id - Issue ID
+     * @param {ID} projectId - Project ID for returning data
+     * @returns A promise resolved to found and transformed links
+     * @memberof IssuesService
+     */
+    async findIssueLinks(id, projectId, issue) {
+        var _a, _b;
+        try {
+            const links = await this._issueLinkService.findAll(plugin_integration_plane_models_1.BaseEntityEnum.Task, id);
+            const issueLinks = await Promise.all((links !== null && links !== void 0 ? links : []).map(async (link) => {
+                const { actor, project } = await this.getIssueCommentDetails(id, projectId, link.employeeId, issue, issue.project);
+                const transformedLink = (0, config_1.issueLinkTransformer)(link, actor, project);
+                return Array.isArray(transformedLink)
+                    ? transformedLink[0]
+                    : transformedLink;
+            }));
+            return issueLinks;
+        }
+        catch (error) {
+            this.logger.error(`Failed to find issue links: ${((_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);
+        }
+    }
+    /**
+     * @description Find issues by view with view filters
+     * @param {ID} viewId - The view ID for whom to search issues
+     * @param {*} query - View filters
+     * @returns A promise resolved to found and tranformed issues
+     * @memberof IssuesService
+     */
+    async findViewIssues(viewId, query) {
+        var _a, _b, _c;
+        try {
+            const issues = (await this.apiFetch({
+                method: 'GET',
+                path: `${this.path}/view/${viewId}`,
+                query
+            })).data;
+            return (_a = issues.items) === null || _a === void 0 ? void 0 : _a.map((issue) => (0, config_1.issueTransformer)(issue));
+        }
+        catch (error) {
+            this.logger.error(`Failed to find view issues: ${((_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);
+        }
+    }
+    /**
+     * @description Delete Issue Link.
+     * @param {ID} id - Issue Link ID to delete
+     * @returns A promise resolved to deleted result
+     * @memberof IssuesService
+     */
+    async deleteLink(id) {
+        return await this._issueLinkService.delete(id);
+    }
+    /**
+     * Subscribes to a specific issue within a project and returns the subscription details.
+     *
+     * @param {ID} issueId - The ID of the issue to subscribe to.
+     * @param {ID} projectId - The ID of the project where the issue exists.
+     * @returns {Promise<ISubscriber | ISubscriber[]>} A promise that resolves to the transformed subscription data, either a single subscriber or a list of subscribers.
+     */
+    async subscribe(issueId, projectId) {
+        const subscription = await this._subscriptionService.create(issueId);
+        return (0, config_1.subscriptionTransformer)(subscription, projectId);
+    }
+    /**
+     * Unsubscribes the default user from a task subscription based on the provided issue ID.
+     *
+     * @param {ID} issueId - The unique identifier of the issue/task to unsubscribe from.
+     * @returns {Promise<any>} A promise that resolves to the response of the unsubscribe operation.
+     * @throws {BadRequestException} If the unsubscription fails or encounters an error.
+     */
+    async unsubscribe(issueId) {
+        var _a;
+        return await this._subscriptionService.unsubscribe({
+            entity: plugin_integration_plane_models_1.BaseEntityEnum.Task,
+            entityId: issueId,
+            userId: (_a = (0, config_1.currentUserId)()) !== null && _a !== void 0 ? _a : undefined
+        });
+    }
+    /**
+     * Get issue meta
+     * @param {ID} issueId - Issue ID
+     * @returns {Promise<{ sequence_id: number; project_identifier: string }>} A promise that resolves to the issue meta
+     * @throws {BadRequestException} If the issue is not found
+     */
+    async getIssueMeta(issueId) {
+        try {
+            const issue = await this.getExternalIssue(issueId, ['project']);
+            if (!issue) {
+                throw new common_1.BadRequestException('Issue not found');
+            }
+            return {
+                sequence_id: issue.number,
+                project_identifier: issue.project.code
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to get issue meta', error instanceof Error ? error.stack : String(error));
+            throw new common_1.BadRequestException(error);
+        }
+    }
+};
+exports.IssuesService = IssuesService;
+exports.IssuesService = IssuesService = __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,
+        states_service_1.StatesService,
+        issue_labels_service_1.IssueLabelsService,
+        comments_service_1.CommentsService,
+        reactions_service_1.ReactionsService,
+        issue_links_service_1.IssueLinksService,
+        issue_relations_service_1.IssueRelationsService,
+        activity_service_1.ActivityService,
+        subscription_service_1.SubscriptionService,
+        mention_service_1.MentionService,
+        api_fetch_service_1.ApiFetchService])
+], IssuesService);
+//# sourceMappingURL=issues.service.js.map