flowtask 5.8.4__cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

flowtask/services/jira/__init__.py

@@ -0,0 +1,3 @@
+from .jira_actions import JiraActions
+
+__all__ = ('JiraActions', )

flowtask/services/jira/jira_actions.py

@@ -0,0 +1,191 @@
+from jira import JIRA, JIRAError
+import requests
+
+class JiraActions():
+    def __init__(self, server: str, email: str, token: str):
+        """
+            Init class JiraActions.
+
+            :param server: Server URL.
+            :param email: User Email.
+            :param token: API token of Jira.
+        """
+        try:
+            self.server = server
+            self.jira = JIRA(server=server, basic_auth=(email, token))
+        except JIRAError as e:
+            self.handle_jira_error(e, "Authenticating in Jira")
+
+    def create_issue(self, project_key: str, summary: str, description: str, issue_type: str = 'Bug'):
+        """
+            Creates a new Jira issue in the specified project.
+
+            :param project_key: Key of the project in which the ticket is to be created.
+            :param summary: Summary or title of the ticket.
+            :param description: Description of the ticket.
+            :param issue_type: Type of ticket (default 'Task').
+            :return: Returns the ticket created.
+        """
+        try:
+            issue_data = {
+                'project': {'key': project_key},
+                'summary': summary,
+                'description': description,
+                'issuetype': {'name': issue_type}
+            }
+            issue = self.jira.create_issue(fields=issue_data)
+            return issue
+        except JIRAError as e:
+            self.handle_jira_error(e, "Creating an issue")
+
+    def add_comment(self, issue_key: str, comment: str):
+        """
+            Adds a comment to a Jira issue.
+
+            :param issue_key: Key of the issue to add the comment to.
+            :param comment: The comment to be added.
+            :return: Returns the added comment or raises an exception in case of error.
+        """
+        try:
+            issue = self.jira.issue(issue_key)
+            return self.jira.add_comment(issue, comment)
+        except JIRAError as e:
+            self.handle_jira_error(e, "Adding a comment")
+
+    def transition_issue(self, issue_key: str, transition_name: str, comment: str = None):
+        """
+            Transitions a Jira issue to a new status based on the transition name.
+            If the transition name is invalid, provides a list of valid transitions for the issue.
+
+            :param issue_key: Key of the issue to transition.
+            :param transition_name: Name of the transition to perform (e.g., 'Start Progress', 'Close Issue').
+            :param comment: Optional comment to add during the transition.
+            :return: Returns the issue after the transition or raises an exception in case of error.
+        """
+        try:
+            # Get all possible transitions for the issue
+            transitions = self.jira.transitions(issue_key)
+
+            # Find the transition ID corresponding to the provided transition name
+            valid_transitions = [t['name'] for t in transitions]
+            transition_id = next((t['id'] for t in transitions if t['name'].lower() == transition_name.lower()), None)
+
+            if not transition_id:
+                valid_transitions_str = ', '.join(valid_transitions)
+                raise ValueError(
+                    f"Transition '{transition_name}' not found for issue {issue_key}. "
+                    f"Valid transitions are: {valid_transitions_str}"
+                )
+
+            # Perform the transition
+            self.jira.transition_issue(issue_key, transition_id, comment=comment)
+            return self.jira.issue(issue_key)
+
+        except JIRAError as e:
+            self.handle_jira_error(e, "transitioning an issue")
+
+    def assign_issue(self, issue_key: str, assignee: str):
+        """
+        Assigns a Jira issue to a specified user.
+
+        :param issue_key: Key of the issue to be assigned (e.g., 'PROJ-123').
+        :param assignee: Username or email of the user to whom the issue will be assigned.
+        :return: The updated issue after the assignment.
+        """
+        try:
+            # Assign the issue to the specified user
+            issue = self.jira.issue(issue_key)
+            self.jira.assign_issue(issue, assignee)
+            return issue
+        except JIRAError as e:
+            self.handle_jira_error(e, f"assigning the issue {issue_key} to {assignee}")
+
+    def add_worklog(self, issue_key: str, time_spent: str, comment: str = None, started: str = None):
+        """
+            Adds a worklog entry to a Jira issue.
+
+            :param issue_key: Key of the issue to which the worklog will be added.
+            :param time_spent: Time spent on the issue (e.g., '2h', '3d', '1w').
+            :param comment: Optional comment to add with the worklog.
+            :param started: Date and time the work started (optional, format: 'YYYY-MM-DDTHH:MM:SS.000+0000').
+            :return: The worklog entry that was added, or raises an exception in case of error.
+        """
+        try:
+            valid_units = ['h', 'd', 'w']
+            if not any(time_spent.endswith(unit) for unit in valid_units):
+                raise ValueError(f"Invalid time format: {time_spent}. Must end with one of {valid_units}.")
+            # Add the worklog to the issue
+            worklog = self.jira.add_worklog(
+                issue=issue_key,
+                timeSpent=time_spent,
+                comment=comment,
+                started=started
+            )
+            return worklog
+        except JIRAError as e:
+            self.handle_jira_error(e, "Adding a worklog")
+
+    def list_issues(self):
+        """
+            Return a list of Jira issues.
+
+            :return: The list of closed issues assigned to user.
+        """
+        try:
+            qry = 'assignee = currentUser() and status != Closed and status != CANCELLED and status != Done order by created asc'  # noqa
+            issues = self.jira.search_issues(qry)
+            return issues
+        except JIRAError as e:
+            self.handle_jira_error(e, "listing the issues")
+
+    def list_transitions(self, issue_key: str):
+        """
+            Return a list of a valid transitions of a issue.
+
+            :param issue_key: Key of the issue to transition.
+            :return: Returns the  list of a valid transitions of a issue.
+        """
+        try:
+            transitions = self.jira.transitions(issue_key)
+            valid_transitions = [t['name'] for t in transitions]
+            return valid_transitions
+        except JIRAError as e:
+            self.handle_jira_error(e, "listing the transitions")
+
+    @staticmethod
+    def handle_jira_error(e: Exception, action: str):
+        """
+            Handles errors and exceptions that occur during interactions with Jira.
+
+            This function captures exceptions thrown during Jira operations and raises appropriate
+            errors with relevant messages based on the type of exception (e.g., JIRAError, connection issues).
+
+            :param e: Exception object. This can be a JIRAError or other types of exceptions (e.g., connection errors).
+            :param action: A string describing the action that was being attempted when the error occurred
+                        (e.g., 'creating an issue', 'adding a comment').
+
+            :raises ValueError: If there is a validation error (e.g., incorrect data in Jira fields).
+            :raises PermissionError: If the user does not have sufficient permissions for the Jira operation.
+            :raises ConnectionError: If there is a problem connecting to the Jira server or if the requested resource was not found.
+            :raises TimeoutError: If the operation timed out while connecting to the Jira server.
+            :raises Exception: For any other unexpected errors that occur during the Jira operation.
+        """  # noqa
+        if isinstance(e, JIRAError):
+            if e.status_code == 400:
+                raise ValueError(f"Validation error while {action}, please, check the provided values.")
+            elif e.status_code == 403:
+                raise PermissionError(f"Insufficient permissions while {action}.")
+            elif e.status_code == 404:
+                raise ConnectionError(f"Resource not found while {action}.")
+            elif e.status_code in (500, 502):
+                raise Exception(f"Server error while {action}. The Jira server might be down.")
+            else:
+                raise Exception(f"Jira error while {action}: {e.text}")
+        elif isinstance(e, requests.ConnectionError):
+            raise ConnectionError(
+                f"Connection error: Unable to connect to the Jira server: {e}"
+            )
+        elif isinstance(e, requests.Timeout):
+            raise TimeoutError("Request timed out.")
+        else:
+            raise Exception(f"An unexpected error occurred while {action}: {str(e)}")

flowtask/services/tasks/__init__.py

@@ -0,0 +1,13 @@
+"""
+Tasks.
+
+Task-based management, creation and execution of tasks.
+"""
+from .service import TaskService
+from .launcher import TaskLauncher
+from .manager import TaskManager
+from .tasks import launch_task
+
+__all__ = (
+    "TaskManager", "TaskService", "TaskLauncher", "launch_task",
+)

flowtask/services/tasks/launcher.py

@@ -0,0 +1,213 @@
+"""
+TaskService.
+
+Work with managing tasks, creation, deleting, listing, etc.
+"""
+import uuid
+from navigator_session import get_session
+from navigator.views import BaseView
+from navigator.responses import JSONResponse
+from navigator.conf import AUTH_SESSION_OBJECT
+from querysource.types import strtobool
+from ...exceptions import (
+    TaskNotFound,
+    DataNotFound,
+    TaskFailed,
+    FileError,
+    FileNotFound,
+)
+from .tasks import launch_task
+
+
+def is_boolean(value: str) -> bool:
+    if isinstance(value, bool):
+        return value
+    try:
+        return strtobool(value)
+    except ValueError:
+        return False
+
+
+class TaskLauncher(BaseView):
+    _logger_name = "TaskLauncher"
+
+    def get_user(self, session, idx: str = "user_id") -> int:
+        if not session:
+            self.error(response={"error": "Unauthorized"}, status=403)
+        try:
+            if AUTH_SESSION_OBJECT in session:
+                return session[AUTH_SESSION_OBJECT][idx]
+            else:
+                return session[idx]
+        except KeyError:
+            self.error(
+                response={
+                    "error": "Unauthorized",
+                    "message": "Hint: maybe you need to pass an Authorization token.",
+                },
+                status=403,
+            )
+
+    async def post(self):
+        """
+        POST Method.
+        description: Executing a Task
+        tags:
+        - tasks
+        - DataIntegration
+        consumes:
+        - application/json
+        produces:
+        - application/json
+        responses:
+            "200":
+                description: Existing Task was updated or executed.
+            "201":
+                description: New Task was inserted
+            "202":
+                description: Task was accepted to run
+            "400":
+                description: Task Failed to execute
+            "403":
+                description: Forbidden Call
+            "404":
+                description: No Data was found
+            "406":
+                description: Query Error
+            "409":
+                description: Conflict, a constraint was violated
+        """
+        # get the URL parameters
+        params = self.get_args()
+        # get post Data
+        data = await self.post_data()
+        # Default launch a task on Queue
+        longrunner = True
+        ## Getting User Information:
+        try:
+            usr = await get_session(self.request)
+            user = self.get_user(usr)
+        except (TypeError, ValueError):
+            user = None
+        self.logger.notice(f"Task User: {user}")
+        try:
+            program = params["program"]
+            del params["program"]
+        except KeyError:
+            # we need a program
+            try:
+                program = data["program"]
+            except KeyError:
+                headers = {
+                    "X-STATUS": "Error",
+                    "X-MESSAGE": "Resource Error: We need a Program Name",
+                }
+                msg = {
+                    "state": "Failed",
+                    "message": "Error: we need a program name",
+                    "status": 400,
+                }
+                return self.error(response=msg, headers=headers, status=400)
+        try:
+            task_id = params["task_id"]
+            del params["task_id"]
+        except KeyError:
+            # we need a Task ID
+            try:
+                task_id = data["task_id"]
+            except KeyError:
+                headers = {
+                    "X-STATUS": "Error",
+                    "X-MESSAGE": "Resource Error: We need a Task Name",
+                }
+                msg = {
+                    "state": "Failed",
+                    "message": "Error: we need a Task ID",
+                    "status": 400,
+                }
+                return self.error(response=msg, headers=headers, status=400)
+        try:
+            try:
+                longrunner = is_boolean(data["long_running"])
+                del data["long_running"]
+            except KeyError:
+                pass
+            try:
+                longrunner = is_boolean(params["long_running"])
+                del params["long_running"]
+            except KeyError:
+                pass
+            try:
+                no_worker = is_boolean(data["no_worker"])
+                del data["no_worker"]
+            except KeyError:
+                no_worker = False
+            self.logger.debug(
+                f"Long Runner: {longrunner}, No Using Workers: {no_worker}"
+            )
+            try:
+                priority = data["priority"]
+                del data["priority"]
+            except KeyError:
+                priority = "low"
+            # cannot update or insert a Task, we need to Run that task
+            result = {}
+            args = {}
+            if isinstance(params, dict):
+                args = params
+            if data:
+                args = {**args, **data}
+            task_uuid = uuid.uuid4()
+            uid, action, result = await launch_task(
+                program_slug=program,
+                task_id=task_id,
+                loop=self._loop,
+                task_uuid=task_uuid,
+                queued=longrunner,
+                no_worker=no_worker,
+                priority=priority,
+                userid=user,
+                **args,
+            )
+            if isinstance(result, BaseException):
+                state = 400
+                result = f"{result!s}"
+            elif action == "Queued":
+                state = 202
+            else:
+                state = 200
+            response = {
+                "message": f"Task {program}.{task_id} was {action}",
+                "task": f"{program}.{task_id}",
+                "task_execution": task_uuid,
+                "result": result,
+                "task_uuid": uid,
+            }
+            headers = {
+                "X-STATUS": "Task OK",
+                "X-MESSAGE": f"Execution of Task {program}.{task_id} on {action}",
+            }
+            try:
+                return JSONResponse(response, status=state, headers=headers)
+            except Exception as e:
+                print("ERROR: ", e)
+        except DataNotFound as err:
+            error = f"Error: Data not found {program}.{task_id}"
+            msg = {"message": error, "error": 404}
+            return self.error(response=msg, exception=err, status=404)
+        except TaskNotFound as err:
+            error = f"Error: Task not found {program}.{task_id}"
+            msg = {"message": error}
+            return self.error(response=msg, exception=err, status=401)
+        except TaskFailed as err:
+            error = f"Error on Task {program}.{task_id} Failed"
+            msg = {"message": error}
+            return self.error(response=msg, exception=err, status=406)
+        except (FileNotFound, FileError) as err:
+            error = f"Error on Task {program}.{task_id} File Not Found: {err}"
+            msg = {"message": error}
+            return self.error(response=msg, exception=err, status=404)
+        except Exception as err:
+            error = f"Uncaught exception on Task {program}.{task_id}"
+            msg = {"message": error}
+            return self.critical(reason=msg, exception=err, status=500)