qubership-pipelines-common-library 2.0.1__tar.gz → 2.0.3__tar.gz

{qubership_pipelines_common_library-2.0.1 → qubership_pipelines_common_library-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubership-pipelines-common-library
-Version: 2.0.1
+Version: 2.0.3
 Summary: Qubership Pipelines common library
 License: Apache-2.0
 License-File: LICENSE
@@ -20,7 +20,7 @@ Requires-Dist: google-cloud-artifact-registry (>=1.16.1,<2.0.0)
 Requires-Dist: http-exceptions (>=0.2.10,<0.3.0)
 Requires-Dist: kubernetes (>=34.1.0,<35.0.0)
 Requires-Dist: minio (>=7.2.12,<8.0.0)
-Requires-Dist: python-gitlab (>=4.13.0,<5.0.0)
+Requires-Dist: python-gitlab (>=4.13.0,<6.0.0)
 Requires-Dist: python-jenkins (>=1.8.2,<2.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)

{qubership_pipelines_common_library-2.0.1 → qubership_pipelines_common_library-2.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qubership-pipelines-common-library"
-version = "2.0.1"
+version = "2.0.3"
 description = "Qubership Pipelines common library"
 authors = ["Qubership"]
 readme = "README.md"
@@ -16,7 +16,7 @@ urllib3 = "^2.2.3"
 python-jenkins = "^1.8.2"
 GitPython = "^3.1.43"
 http-exceptions = "^0.2.10"
-python-gitlab = "^4.13.0"
+python-gitlab = ">=4.13.0,<6.0.0"
 minio = "^7.2.12"
 kubernetes = "^34.1.0"
 webexpythonsdk = "2.0.1"
@@ -24,7 +24,6 @@ ghapi = "^1.0.6"
 boto3 = "^1.39.4"
 google-cloud-artifact-registry = "^1.16.1"
 rich = "^14.2.0"
-# jira = "3.10.5"
 
 [tool.poetry.group.test.dependencies]
 pytest = "^6.0.0"

{qubership_pipelines_common_library-2.0.1 → qubership_pipelines_common_library-2.0.3}/qubership_pipelines_common_library/v1/utils/utils_cli.py

@@ -1,14 +1,11 @@
 import logging
+import os
 import re
-
+import sys
 import click
-from rich import box
-from rich.logging import RichHandler
-from rich.panel import Panel
 
 from qubership_pipelines_common_library.v1.execution.exec_logger import ExecutionLogger
-from qubership_pipelines_common_library.v1.utils.utils_logging import rich_console, ExtendedReprHighlighter, \
-    LevelColorFilter
+from qubership_pipelines_common_library.v1.utils.utils_string import UtilsString
 
 DEFAULT_CONTEXT_FILE_PATH = 'context.yaml'
 
@@ -37,26 +34,34 @@ def utils_cli(func):
 
 def _configure_global_logger(global_logger: logging.Logger, log_level: str):
     """Configure the global logger with a specific log level and formatter."""
+    log_level_value = getattr(logging, log_level.upper(), logging.INFO)
     global_logger.setLevel(logging.DEBUG)
     if global_logger.hasHandlers():
         global_logger.handlers.clear()
     global_logger.propagate = True
-    rich_handler = RichHandler(
-        console=rich_console,
-        show_time=False,
-        show_level=False,
-        show_path=False,
-        enable_link_path=False,
-        rich_tracebacks=True,
-        tracebacks_show_locals=False,
-        markup=True,
-        highlighter=ExtendedReprHighlighter(),
-    )
-    rich_handler.addFilter(LevelColorFilter())
-    rich_handler.setFormatter(logging.Formatter(ExecutionLogger.LEVELNAME_COLORED_FORMAT))
-    log_level_value = getattr(logging, log_level.upper(), logging.INFO)
-    rich_handler.setLevel(log_level_value)
-    global_logger.addHandler(rich_handler)
+    if UtilsString.convert_to_bool(os.getenv('NO_RICH', False)):
+        stdout_handler = logging.StreamHandler(sys.stdout)
+        stdout_handler.setLevel(log_level_value)
+        stdout_handler.setFormatter(logging.Formatter(ExecutionLogger.DEFAULT_FORMAT))
+        global_logger.addHandler(stdout_handler)
+    else:
+        from rich.logging import RichHandler
+        from qubership_pipelines_common_library.v1.utils.utils_logging import rich_console, ExtendedReprHighlighter, LevelColorFilter
+        rich_handler = RichHandler(
+            console=rich_console,
+            show_time=False,
+            show_level=False,
+            show_path=False,
+            enable_link_path=False,
+            rich_tracebacks=True,
+            tracebacks_show_locals=False,
+            markup=True,
+            highlighter=ExtendedReprHighlighter(),
+        )
+        rich_handler.addFilter(LevelColorFilter())
+        rich_handler.setFormatter(logging.Formatter(ExecutionLogger.LEVELNAME_COLORED_FORMAT))
+        rich_handler.setLevel(log_level_value)
+        global_logger.addHandler(rich_handler)
 
 
 def _print_command_name():
@@ -67,10 +72,16 @@ def _print_command_name():
         logging.getLogger().warning("Can't find command name.")
         command_name = ""
 
-    command_panel = Panel(f"command_name = {command_name}", expand=False, padding=(0, 1), box=box.ROUNDED)
-    rich_console.print()
-    rich_console.print(command_panel)
-    rich_console.print()
+    if UtilsString.convert_to_bool(os.getenv('NO_RICH', False)):
+        logging.info(f"command_name = {command_name}")
+    else:
+        from rich import box
+        from rich.panel import Panel
+        from qubership_pipelines_common_library.v1.utils.utils_logging import rich_console
+        command_panel = Panel(f"command_name = {command_name}", expand=False, padding=(0, 1), box=box.ROUNDED)
+        rich_console.print()
+        rich_console.print(command_panel)
+        rich_console.print()
 
 
 def _transform_kwargs(kwargs):

{qubership_pipelines_common_library-2.0.1 → qubership_pipelines_common_library-2.0.3}/qubership_pipelines_common_library/v1/utils/utils_logging.py

@@ -18,7 +18,6 @@ soft_theme = Theme({
     "repr.str": "rgb(140,180,140)",
     "repr.tag_name": "rgb(200,170,220)",
     "repr.tag_value": "rgb(170,200,220)",
-
     "repr.time": "rgb(160,190,220) italic",
 })
 

qubership_pipelines_common_library-2.0.3/qubership_pipelines_common_library/v2/jira/jira_add_ticket_comment_command.py

@@ -0,0 +1,100 @@
+from qubership_pipelines_common_library.v1.execution.exec_command import ExecutionCommand
+from qubership_pipelines_common_library.v2.jira.jira_client import JiraClient, AuthType
+from qubership_pipelines_common_library.v2.jira.jira_utils import JiraUtils
+
+
+class JiraAddTicketComment(ExecutionCommand):
+    """
+    Adds comment to JIRA ticket and retrieves latest comments.
+
+    Input Parameters Structure (this structure is expected inside "input_params.params" block):
+    ```
+    {
+        "ticket": {
+            "id": "BUG-567",                    # REQUIRED: Ticket ID
+            "comment": "your comment body",     # REQUIRED: Comment body
+            "latest_comments_count": 50,        # OPTIONAL: Number of latest comments to fetch
+        },
+        "retry_timeout_seconds": 180,           # OPTIONAL: Timeout for JIRA client operations in seconds (default: 180)
+        "retry_wait_seconds": 1,                # OPTIONAL: Wait interval between retries in seconds (default: 1)
+    }
+    ```
+
+    Systems Configuration (expected in "systems.jira" block):
+    ```
+    {
+        "url": "https://your_cloud_jira.atlassian.net",         # REQUIRED: JIRA server URL
+        "username": "your_username_or_email",                   # REQUIRED: JIRA user login or email
+        "password": "<your_token>",                             # REQUIRED: JIRA user token
+        "auth_type": "basic"                                    # OPTIONAL: 'basic' or 'bearer'
+    }
+    ```
+
+    Command name: "jira-add-ticket-comment"
+    """
+
+    RETRY_TIMEOUT_SECONDS = 180  # default value, how many seconds to try
+    RETRY_WAIT_SECONDS = 1  # default value, how many seconds between tries
+    LATEST_COMMENTS_COUNT = 50 # default value, max amount of comments in response
+
+    def _validate(self):
+        names = [
+            "paths.input.params",
+            "paths.output.params",
+            "systems.jira.url",
+            "systems.jira.username",
+            "systems.jira.password",
+            "params.ticket.id",
+            "params.ticket.comment",
+        ]
+        if not self.context.validate(names):
+            return False
+
+        self.retry_timeout_seconds = int(self.context.input_param_get("params.retry_timeout_seconds", self.RETRY_TIMEOUT_SECONDS))
+        self.retry_wait_seconds = int(self.context.input_param_get("params.retry_wait_seconds", self.RETRY_WAIT_SECONDS))
+
+        self.jira_url = self.context.input_param_get("systems.jira.url").rstrip('/')
+        self.jira_username = self.context.input_param_get("systems.jira.username")
+        self.jira_password = self.context.input_param_get("systems.jira.password")
+        self.auth_type = self.context.input_param_get("systems.jira.auth_type", AuthType.BASIC)
+
+        self.ticket_key = self.context.input_param_get("params.ticket.id")
+        self.ticket_comment = self.context.input_param_get("params.ticket.comment")
+        self.latest_comments_count = int(self.context.input_param_get("params.ticket.latest_comments_count", self.LATEST_COMMENTS_COUNT))
+        return True
+
+    def _execute(self):
+        self.context.logger.info("Running jira-add-ticket-comment")
+        self.jira_client = JiraClient.create_jira_client(
+            self.jira_url, self.jira_username, self.jira_password, self.auth_type,
+            self.retry_timeout_seconds, self.retry_wait_seconds,
+        )
+
+        if self.ticket_comment:
+            JiraUtils.add_ticket_comment(self)
+
+        total_comments = 0
+        parsed_latest_comments = []
+        try:
+            self.latest_comments = self.jira_client.get_latest_ticket_comments(self.ticket_key, max_results=self.latest_comments_count)
+            total_comments = len(self.latest_comments)
+            parsed_latest_comments = [self._parse_comment(comment) for comment in self.latest_comments]
+        except Exception as e:
+            self.context.logger.warning(f"Can't get latest ticket comments. Response exception: {str(e)}")
+
+        self.context.output_param_set("params.ticket.id", self.ticket_key)
+        self.context.output_param_set("params.ticket.url", f"{self.jira_url}/browse/{self.ticket_key}")
+        self.context.output_param_set("params.ticket.total_comments", total_comments)
+        self.context.output_param_set("params.ticket.latest_comments", parsed_latest_comments)
+        self.context.output_params_save()
+        self.context.logger.info("Add ticket comment request executed. See output params for details")
+
+    @staticmethod
+    def _parse_comment(comment):
+        return {
+            "body": comment.get("body"),
+            "created": comment.get("created"),
+            "updated": comment.get("updated"),
+            "author": JiraClient.serialize_person_ref(comment.get("author", {})),
+            "updateAuthor": JiraClient.serialize_person_ref(comment.get("updateAuthor", {})),
+        }

qubership_pipelines_common_library-2.0.3/qubership_pipelines_common_library/v2/jira/jira_client.py

@@ -0,0 +1,215 @@
+import os
+import json
+import logging
+import requests
+
+from enum import StrEnum
+from typing import Any
+from requests import Response
+from requests.auth import HTTPBasicAuth
+from qubership_pipelines_common_library.v2.utils.retry_decorator import RetryDecorator
+
+
+class AuthType(StrEnum):
+    BASIC = 'basic'
+    BEARER = 'bearer'
+
+
+class JiraClient:
+
+    DEFAULT_FIELD_NAMES_FILTER = [
+        "fixVersions",
+        "resolution",
+        "priority",
+        "labels",
+        "versions",
+        "assignee",
+        "status",
+        "components",
+        "creator",
+        "reporter",
+        "issuetype",
+        "project",
+        "resolutiondate",
+        "created",
+        "updated",
+        "description",
+        "summary",
+        "customfield_10014", # Found in
+    ]
+
+    API_VERSION = "2"
+
+    @classmethod
+    @RetryDecorator(condition_func=lambda client: client is not None)
+    def create_jira_client(cls, host: str, user: str, password: str, auth_type: str,
+                           retry_timeout_seconds: int = 180, retry_wait_seconds: int = 1):
+        return cls(host, user, password, auth_type)
+
+    def __init__(self, host: str, user: str, password: str, auth_type: str = AuthType.BASIC):
+        self.host = host.rstrip("/")
+        self.user = user
+        self.password = password
+        self.session = requests.Session()
+        self.session.verify = os.getenv("PYTHONHTTPSVERIFY", "1") != "0"
+        if auth_type.lower() == AuthType.BEARER:
+            self.session.headers.update({"Authorization": f"Bearer {password}"})
+        else:
+            self.session.auth = HTTPBasicAuth(user, password)
+        self.headers = {"Accept": "application/json", "Content-Type": "application/json"}
+        self.session.headers.update(self.headers)
+        self.logger = logging.getLogger()
+        try:
+            self.server_info = self.get_server_info()
+            self.deployment_type = self.server_info.get("deploymentType", "Server")
+        except Exception as e:
+            self.logger.info(f"Could not get Jira instance version, assuming 'Server': {e}")
+            self.deployment_type = "Server"
+        self.logger.info(f"Jira Client configured for {self.host}, deployment type: {self.deployment_type}")
+
+    @property
+    def _is_cloud(self) -> bool:
+        return self.deployment_type == "Cloud"
+
+    def get_server_info(self) -> dict[str, Any]:
+        retry = 0
+        j = self._get_json("serverInfo")
+        while not j and retry < 3:
+            retry += 1
+            j = self._get_json("serverInfo")
+        return j
+
+    @RetryDecorator(condition_func=lambda response: response is not None and (response.ok or response.status_code == 400)) # do not retry BadRequest
+    def add_ticket_comment(self, ticket_id: str, comment: str, retry_timeout_seconds: int = 180, retry_wait_seconds: int = 1) -> Response:
+        response = self.session.post(
+            url=f"{self.host}/rest/api/{self.API_VERSION}/issue/{ticket_id}/comment",
+            data=json.dumps({"body": comment})
+        )
+        self.logger.debug(f"Add ticket (id={ticket_id}) comment response: status_code = {response.status_code}, body = {response.text}")
+        return response
+
+    def get_latest_ticket_comments(self, ticket_id: str, max_results: int = 50) -> list:
+        response = self.session.get(f"{self.host}/rest/api/{self.API_VERSION}/issue/{ticket_id}/comment?maxResults={max_results}&orderBy=-created")
+        self.logger.debug(f"Get ticket (id={ticket_id}) comments response: status_code = {response.status_code}, body = {response.text}")
+        response.raise_for_status()
+        return response.json().get("comments", [])
+
+    @RetryDecorator(condition_func=lambda response: response is not None and (response.ok or response.status_code == 400))
+    def create_ticket(self, ticket_fields: dict, retry_timeout_seconds: int = 180, retry_wait_seconds: int = 1) -> Response:
+        body = {"fields": ticket_fields}
+        response = self.session.post(f"{self.host}/rest/api/{self.API_VERSION}/issue", data=json.dumps(body))
+        self.logger.debug(f"Create ticket response: status_code = {response.status_code}, body = {response.text}")
+        return response
+
+    def get_createmeta_fields(self, project_key: str, issue_type_name: str) -> dict:
+        response = self.session.get(f"{self.host}/rest/api/{self.API_VERSION}/issue/createmeta/{project_key}/issuetypes?maxResults=100")
+        self.logger.debug(f"Get createmeta for project (id={project_key}) response: status_code = {response.status_code}, body = {response.text}")
+        if not response.ok:
+            self.logger.warning(f"Can't get issuetypes by projectKey = {project_key}. Response status = {response.status_code}")
+            return {}
+
+        issue_types = response.json().get("issueTypes" if self._is_cloud else "values", [])
+        issue_type_ids = [issue_type.get("id") for issue_type in issue_types if issue_type.get("name") == issue_type_name]
+        if not issue_type_ids:
+            self.logger.warning(f"Can't find issue type id by issue_type_name = {issue_type_name}")
+            return {}
+
+        response = self.session.get(f"{self.host}/rest/api/{self.API_VERSION}/issue/createmeta/{project_key}/issuetypes/{issue_type_ids[0]}?maxResults=100")
+        self.logger.debug(f"Get createmeta for issuetype (id={issue_type_ids[0]}) response: status_code = {response.status_code}, body = {response.text}")
+        if not response.ok:
+            self.logger.warning(f"Can't get createmeta by projectKey = {project_key} and issue_type_id = {issue_type_ids[0]}. Response status = {response.status_code}")
+            return {}
+
+        fields = response.json().get("fields" if self._is_cloud else "values", [])
+        return {field["fieldId"]: field for field in fields}
+
+    def get_ticket_fields(self, ticket_id: str, field_names_filter: list) -> dict:
+        response = self.session.get(f"{self.host}/rest/api/{self.API_VERSION}/issue/{ticket_id}?fields={','.join(field_names_filter)}")
+        self.logger.debug(f"Get ticket fields (id={ticket_id}) response: status_code = {response.status_code}, body = {response.text}")
+        if not response.ok:
+            self.logger.warning(f"Can't get ticket info by ticket_id = {ticket_id}. Response status = {response.status_code}")
+            return {}
+        return self._transform_ticket_fields(response.json().get("fields", {}))
+
+    def get_editmeta_fields(self, ticket_id: str) -> dict:
+        response = self.session.get(f"{self.host}/rest/api/{self.API_VERSION}/issue/{ticket_id}/editmeta")
+        self.logger.debug(f"Get editmeta for ticket (id={ticket_id}) response: status_code = {response.status_code}, body = {response.text}")
+        if not response.ok:
+            self.logger.warning(f"Can't get ticket {ticket_id} editmeta. Response status = {response.status_code}")
+            return {}
+        return response.json().get("fields", {})
+
+    @RetryDecorator(condition_func=lambda response: response is not None and (response.ok or response.status_code == 400))
+    def update_ticket(self, ticket_id: str, ticket_fields: dict,
+                      retry_timeout_seconds: int = 180, retry_wait_seconds: int = 1) -> Response:
+        body = {"fields": ticket_fields}
+        response = self.session.put(f"{self.host}/rest/api/{self.API_VERSION}/issue/{ticket_id}", data=json.dumps(body))
+        self.logger.debug(f"Update ticket (id={ticket_id}) response: status_code = {response.status_code}, body = {response.text}")
+        return response
+
+    def get_ticket_transitions(self, ticket_id: str):
+        response = self.session.get(f"{self.host}/rest/api/{self.API_VERSION}/issue/{ticket_id}/transitions?expand=transitions.fields")
+        self.logger.debug(f"Get ticket (id={ticket_id}) transitions response: status_code = {response.status_code}, body = {response.text}")
+        if not response.ok:
+            self.logger.warning(f"Ticket {ticket_id} transitions are not found in response. Response status = {response.status_code}")
+            return []
+        return response.json().get("transitions", [])
+
+    def find_applicable_transition(self, transitions: list, status_name: str, transition_name: str = ""):
+        transitions_by_next_status = [transition for transition in transitions if status_name.lower() == transition.get("to", {}).get("name", "").lower()]
+        if not transitions_by_next_status:
+            self.logger.error(f"Status '{status_name}' is not found in transitions.")
+            return None
+
+        if len(transitions_by_next_status) > 1:
+            self.logger.warning(f"Found more than one transition to status '{status_name}'")
+            if transition_name:
+                transitions_by_name = [transition for transition in transitions_by_next_status if transition_name.lower() == transition.get("name", "").lower()]
+                if transitions_by_name:
+                    return transitions_by_name[0]
+                else:
+                    self.logger.warning(f"Transition '{transition_name}' is not found in transitions. Will use first found transition by status '{status_name}'.")
+
+        return transitions_by_next_status[0]
+
+    def perform_ticket_transition(self, ticket_id: str, transition_id: str, transition_fields):
+        body = {"transition": {"id": transition_id}}
+        if transition_fields:
+            body["fields"] = transition_fields
+        response = self.session.post(f"{self.host}/rest/api/{self.API_VERSION}/issue/{ticket_id}/transitions", data=json.dumps(body))
+        self.logger.debug(f"Perform transition for ticket (id={ticket_id}) response: status_code = {response.status_code}, body = {response.text}")
+        return response
+
+    def _get_json(self, path: str, params: dict[str, Any] | None = None, use_post: bool = False) -> dict | list:
+        url = f"{self.host}/rest/api/{self.API_VERSION}/{path}"
+        response = (
+            self.session.post(url, data=json.dumps(params))
+            if use_post
+            else self.session.get(url, params=params)
+        )
+        return response.json()
+
+    @staticmethod
+    def filter_ticket_fields(ticket_fields: dict, meta_fields_filter: dict) -> dict:
+        return {field_key: field_value for field_key, field_value in ticket_fields.items() if field_key in meta_fields_filter.keys()}
+
+    @staticmethod
+    def _transform_ticket_fields(ticket_fields_json: dict):
+        filtered_fields = {}
+        for k, v in ticket_fields_json.items():
+            if isinstance(v, dict) and "emailAddress" in v:
+                filtered_fields[k] = JiraClient.serialize_person_ref(v)
+            else:
+                filtered_fields[k] = v
+        return filtered_fields
+
+    @staticmethod
+    def serialize_person_ref(person: dict) -> dict | None:
+        if person:
+            return {
+                "displayName": person.get("displayName", None),
+                "emailAddress": person.get("emailAddress", None),
+                "name": person.get("name", None),
+                "key": person.get("key", None),
+            }
+        return None

qubership_pipelines_common_library-2.0.3/qubership_pipelines_common_library/v2/jira/jira_create_ticket_command.py

@@ -0,0 +1,126 @@
+import re
+
+from qubership_pipelines_common_library.v1.execution.exec_command import ExecutionCommand
+from qubership_pipelines_common_library.v2.jira.jira_client import JiraClient, AuthType
+from qubership_pipelines_common_library.v2.jira.jira_utils import JiraUtils
+
+
+class JiraCreateTicket(ExecutionCommand):
+    """
+    Creates new issue/ticket in JIRA project.
+
+    Input Parameters Structure (this structure is expected inside "input_params.params" block):
+    ```
+    {
+        "ticket": {
+            "fields: {                                                  # REQUIRED: Dict structure that will be used as ticket-creation-body, without transformations
+                "project": {"key": "<YOUR_PROJECT_KEY>"},               # REQUIRED: Project Key
+                "issuetype": {"name": "Bug"},                           # REQUIRED: Issue type name
+                "priority": {"name": "High"},                           # OPTIONAL: Other ticket fields with different formats, depending on your Project configuration
+                "duedate": "2030-02-20",                                # OPTIONAL: Text-value fields need no dict wrappers
+                "summary": "[SOME_LABEL] Ticket Subject",
+                "description": "Ticket body",
+                "components": [{"name":"COMPONENT NAME"}],
+                "labels": ["Test_Label1"],
+            },
+            "comment": "your comment body",                             # OPTIONAL: Comment to add to created ticket
+            "field_names_filter": "summary,issuetype,creator,status",   # OPTIONAL: Comma-separated names of fields to extract from created ticket to output params
+        },
+        "retry_timeout_seconds": 180,           # OPTIONAL: Timeout for JIRA client operations in seconds (default: 180)
+        "retry_wait_seconds": 1,                # OPTIONAL: Wait interval between retries in seconds (default: 1)
+    }
+    ```
+
+    Systems Configuration (expected in "systems.jira" block):
+    ```
+    {
+        "url": "https://your_cloud_jira.atlassian.net",         # REQUIRED: JIRA server URL
+        "username": "your_username_or_email",                   # REQUIRED: JIRA user login or email
+        "password": "<your_token>",                             # REQUIRED: JIRA user token
+        "auth_type": "basic"                                    # OPTIONAL: 'basic' or 'bearer'
+    }
+    ```
+
+    Command name: "jira-create-ticket"
+    """
+    RETRY_TIMEOUT_SECONDS = 180  # default value, how many seconds to try
+    RETRY_WAIT_SECONDS = 1  # default value, how many seconds between tries
+
+    def _validate(self):
+        names = [
+            "paths.input.params",
+            "paths.output.params",
+            "systems.jira.url",
+            "systems.jira.username",
+            "systems.jira.password",
+            "params.ticket.fields",
+        ]
+        if not self.context.validate(names):
+            return False
+
+        self.retry_timeout_seconds = int(self.context.input_param_get("params.retry_timeout_seconds", self.RETRY_TIMEOUT_SECONDS))
+        self.retry_wait_seconds = int(self.context.input_param_get("params.retry_wait_seconds", self.RETRY_WAIT_SECONDS))
+
+        self.jira_url = self.context.input_param_get("systems.jira.url").rstrip('/')
+        self.jira_username = self.context.input_param_get("systems.jira.username")
+        self.jira_password = self.context.input_param_get("systems.jira.password")
+        self.auth_type = self.context.input_param_get("systems.jira.auth_type", AuthType.BASIC)
+
+        self.ticket_comment = self.context.input_param_get("params.ticket.comment")
+        self.ticket_fields = self.context.input_param_get("params.ticket.fields", {})
+        self.project_key = self.ticket_fields.get('project', {}).get('key')
+        self.issue_type_name = self.ticket_fields.get('issuetype', {}).get('name')
+
+        if not self.project_key or not self.issue_type_name:
+            self.context.logger.error("Can't find project.key and/or issuetype.name in input parameters")
+            return False
+
+        if not self._validate_mandatory_ticket_fields(self.ticket_fields):
+            return False
+
+        if field_names_filter := self.context.input_param_get("params.ticket.field_names_filter"):
+            self.field_names_filter = [x.strip() for x in re.split(r'[,;]+', field_names_filter)]
+        else:
+            self.field_names_filter = JiraClient.DEFAULT_FIELD_NAMES_FILTER
+
+        return True
+
+    def _validate_mandatory_ticket_fields(self, ticket_fields):
+        valid = True
+        for field_key in ["project", "issuetype", "summary"]:
+            if field_key not in ticket_fields:
+                valid = False
+                self.context.logger.error(f"Parameter '{field_key}' is mandatory but not found in ticket params map")
+        return valid
+
+    def _execute(self):
+        self.context.logger.info("Running jira-create-ticket")
+        self.context.logger.info(f"Creating ticket in project {self.project_key}, type {self.issue_type_name}")
+        self.jira_client = JiraClient.create_jira_client(
+            self.jira_url, self.jira_username, self.jira_password, self.auth_type,
+            self.retry_timeout_seconds, self.retry_wait_seconds,
+        )
+
+        createmeta_fields = self.jira_client.get_createmeta_fields(self.project_key, self.issue_type_name)
+        self.filtered_ticket_fields = JiraClient.filter_ticket_fields(self.ticket_fields, createmeta_fields)
+        self.context.logger.debug(f"Filtered ticket fields: {self.filtered_ticket_fields}")
+
+        create_ticket_response = self.jira_client.create_ticket(self.filtered_ticket_fields,
+                                                                retry_timeout_seconds=self.retry_timeout_seconds,
+                                                                retry_wait_seconds=self.retry_wait_seconds)
+        if not create_ticket_response.ok:
+            self._exit(False, f"Can't create ticket. Response status: {create_ticket_response.status_code}")
+        self.ticket_key = create_ticket_response.json().get('key')
+        self.context.logger.info(f"Ticket created successfully: {self.ticket_key}")
+
+        if self.ticket_comment:
+            JiraUtils.add_ticket_comment(self)
+
+        self.context.output_param_set("params.ticket.id", self.ticket_key)
+        self.context.output_param_set("params.ticket.url", f"{self.jira_url}/browse/{self.ticket_key}")
+
+        filtered_response_fields = self.jira_client.get_ticket_fields(self.ticket_key, self.field_names_filter)
+        self.context.output_param_set("params.ticket.fields", filtered_response_fields)
+
+        self.context.output_params_save()
+        self.context.logger.info("JIRA ticket creation completed successfully")