qubership-pipelines-common-library 2.0.1__py3-none-any.whl → 2.0.3__py3-none-any.whl

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/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/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/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/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")

qubership_pipelines_common_library/v2/jira/jira_update_ticket_command.py

@@ -0,0 +1,139 @@
+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 JiraUpdateTicket(ExecutionCommand):
+    """
+    Updates ticket fields and transitions status.
+
+    Input Parameters Structure (this structure is expected inside "input_params.params" block):
+    ```
+    {
+        "ticket": {
+            "fields: {                                                # REQUIRED: Dict structure that will be used as ticket-update-body, without transformations
+                "status": {"name": "Done"},                           # OPTIONAL: Next status name
+                "transition": {"name": "From Review to Done"},        # OPTIONAL: Transition 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
+                "description": "Ticket body",
+                "labels": ["Test_Label1"],
+            },
+            "id": "BUG-567",                                            # REQUIRED: Ticket ID
+            "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-update-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.id",
+            "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_key = self.context.input_param_get("params.ticket.id")
+        self.ticket_comment = self.context.input_param_get("params.ticket.comment")
+        self.ticket_fields = self.context.input_param_get("params.ticket.fields")
+        self.next_status_name = self.ticket_fields.pop('status', {}).get('name')
+        self.transition_name = self.ticket_fields.pop('transition', {}).get('name')
+
+        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 _execute(self):
+        self.context.logger.info("Running jira-update-ticket")
+        self.context.logger.info(f"Updating ticket {self.ticket_key}...")
+        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,
+        )
+
+        editmeta_fields = self.jira_client.get_editmeta_fields(self.ticket_key)
+        self.filtered_ticket_fields = JiraClient.filter_ticket_fields(self.ticket_fields, editmeta_fields)
+        self.context.logger.debug(f"Filtered ticket fields: {self.filtered_ticket_fields}")
+
+        update_ticket_response = self.jira_client.update_ticket(
+            self.ticket_key, self.filtered_ticket_fields,
+            retry_timeout_seconds=self.retry_timeout_seconds, retry_wait_seconds=self.retry_wait_seconds
+        )
+        if not update_ticket_response.ok:
+            self._exit(False, f"Can't update ticket. Response status: {update_ticket_response.status_code}")
+
+        if self.next_status_name:
+            self.context.logger.info(f"Updating ticket status to '{self.next_status_name}'...")
+            self._perform_status_transition()
+
+        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("Update ticket request executed. See output params for details")
+
+    def _perform_status_transition(self):
+
+        ticket_current_status = self.jira_client.get_ticket_fields(self.ticket_key, ["status"]).get("status", {}).get("name")
+        if str(self.next_status_name).strip().lower() == str(ticket_current_status).strip().lower():
+            self.context.logger.info(f"Ticket {self.ticket_key} already has '{self.next_status_name}' status. Skipping status transition.")
+
+        else:
+            transitions = self.jira_client.get_ticket_transitions(self.ticket_key)
+            if not transitions:
+                self._exit(False, f"Can't find ticket {self.ticket_key} transitions.")
+
+            transition = self.jira_client.find_applicable_transition(
+                transitions, self.next_status_name, self.transition_name
+            )
+            if transition is None:
+                self._exit(False, f"Can't find transition with next status '{self.next_status_name}'.")
+
+            ticket_transition_fields = JiraClient.filter_ticket_fields(self.ticket_fields, transition.get("fields"))
+            transition_response = self.jira_client.perform_ticket_transition(
+                self.ticket_key, transition.get("id"), ticket_transition_fields
+            )
+            if not transition_response.ok:
+                self._exit(False, f"Can't perform ticket status transition. Response status: {transition_response.status_code}")

qubership_pipelines_common_library/v2/jira/jira_utils.py

@@ -0,0 +1,19 @@
+from qubership_pipelines_common_library.v1.execution.exec_command import ExecutionCommand
+
+
+class JiraUtils:
+
+    @staticmethod
+    def add_ticket_comment(command: ExecutionCommand):
+        try:
+            command.context.logger.info(f"Adding comment to ticket {command.ticket_key}...")
+            add_ticket_comment_response = command.jira_client.add_ticket_comment(
+                command.ticket_key, command.ticket_comment,
+                retry_timeout_seconds=command.retry_timeout_seconds,
+                retry_wait_seconds=command.retry_wait_seconds
+            )
+            if not add_ticket_comment_response.ok:
+                command._exit(False, f"Can't add ticket comment. Response status: {add_ticket_comment_response.status_code}")
+            command.context.logger.info(f"Comment added to ticket {command.ticket_key}")
+        except Exception as e:
+            command._exit(False, f"Can't add ticket comment. Response exception: {str(e)}")

qubership_pipelines_common_library/v2/notifications/send_email_command.py

@@ -0,0 +1,150 @@
+import smtplib
+import socket
+import ssl
+
+from email.utils import formatdate
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from qubership_pipelines_common_library.v1.execution.exec_command import ExecutionCommand
+from qubership_pipelines_common_library.v1.utils.utils_string import UtilsString
+
+
+class SendEmail(ExecutionCommand):
+    """
+    This command sends email notification with optional attachments.
+
+    Input Parameters Structure (this structure is expected inside "input_params.params" block):
+    ```
+    {
+        "email_subject": "Report for 01.01.2026",                         # REQUIRED: E-mail subject
+        "email_body": "Following jobs were completed: ...",               # REQUIRED: E-mail message
+        "email_recipients": "user1@qubership.org,user2@qubership.org",    # REQUIRED: Comma-separated list of recipients
+        "email_body_type": "plain",                                       # OPTIONAL: Either "plain" or "html
+        "attachments": {                                                  # OPTIONAL: Dict with attachments
+            "unique_attachment_key": {
+                "name": "HTML_report.html",                               # REQUIRED: File name used for attachment
+                "content": "<html>...</html>",                            # REQUIRED: Text content put inside attachment
+                "mime_type": "text/html",
+            },
+            "another_attachment_key": {...}
+        }
+    }
+    ```
+
+    Systems Configuration (expected in "systems.email" block):
+    ```
+    {
+        "server": "your.mail.server.org",           # REQUIRED: E-mail host server
+        "port": "3025"                              # REQUIRED: E-mail port
+        "user": "your@email.bot"                    # REQUIRED: E-mail user
+        "password": "<email_password>"              # OPTIONAL: E-mail password
+        "use_ssl": "False"                          # OPTIONAL: SMTP connection will use SSL mode (default: False)
+        "use_tls": "False"                          # OPTIONAL: SMTP connection will use TLS mode (default: False)
+        "verify": "False"                           # OPTIONAL: SSL Certificate verification (default: False)
+        "timeout_seconds": "60"                     # OPTIONAL: SMTP connection timeout in seconds (default: 60)
+    }
+    ```
+
+    Command name: "send-email"
+    """
+
+    EMAIL_BODY_TYPE_PLAIN = "plain"
+    EMAIL_BODY_TYPE_HTML = "html"
+    EMAIL_BODY_TYPES = [EMAIL_BODY_TYPE_PLAIN, EMAIL_BODY_TYPE_HTML]
+    WAIT_TIMEOUT = 60
+
+    def _validate(self):
+        required_params = [
+            "paths.input.params",
+            "systems.email.server",
+            "systems.email.port",
+            "systems.email.user",
+            "params.email_subject",
+            "params.email_body",
+            "params.email_recipients",
+        ]
+        if not self.context.validate(required_params):
+            return False
+
+        self.email_server = self.context.input_param_get("systems.email.server")
+        self.email_port = self.context.input_param_get("systems.email.port")
+        self.email_user = self.context.input_param_get("systems.email.user")
+        self.email_password = self.context.input_param_get("systems.email.password")
+        self.email_password = self.context.input_param_get("systems.email.password")
+        self.timeout_seconds = max(1, int(self.context.input_param_get("systems.email.timeout_seconds", self.WAIT_TIMEOUT)))
+        self.use_ssl = UtilsString.convert_to_bool(self.context.input_param_get("systems.email.use_ssl", False))
+        self.use_tls = UtilsString.convert_to_bool(self.context.input_param_get("systems.email.use_tls", False))
+        self.verify = UtilsString.convert_to_bool(self.context.input_param_get("systems.email.verify", False))
+
+        self.email_subject = self.context.input_param_get("params.email_subject")
+        self.email_body = self.context.input_param_get("params.email_body")
+        self.email_recipients = [x.strip() for x in self.context.input_param_get("params.email_recipients").split(",")]
+
+        self.email_body_type = self.context.input_param_get("params.email_body_type", SendEmail.EMAIL_BODY_TYPE_PLAIN)
+        if self.email_body_type not in SendEmail.EMAIL_BODY_TYPES:
+            self.context.logger.error(f"Incorrect email_body_type value: {self.email_body_type}. Only '{SendEmail.EMAIL_BODY_TYPES}' are supported")
+            return False
+
+        self.attachments = []
+        for key, data in self.context.input_param_get("params.attachments", {}).items():
+            if not data.get("content") or not data.get("name"):
+                self.context.logger.error(f"Attachment with key [{key}] is missing content and/or name!")
+                return False
+            self.attachments.append({
+                "name": data.get("name"),
+                "mime_type": data.get("mime_type", "text/plain"),
+                "content": data.get("content")
+            })
+
+        return True
+
+    def _execute(self):
+        try:
+            msg = MIMEMultipart()
+            msg["From"] = self.email_user
+            msg["To"] = ", ".join(self.email_recipients)
+            msg["Subject"] = self.email_subject
+            msg["Date"] = formatdate(localtime=True)
+            msg.attach(MIMEText(self.email_body, self.email_body_type))
+
+            if self.attachments:
+                for attachment in self.attachments:
+                    part = MIMEText(attachment["content"], attachment["mime_type"])
+                    part.add_header('Content-Disposition', f'attachment; filename="{attachment["name"]}"')
+                    msg.attach(part)
+
+            self.context.logger.debug(f"Connecting to SMTP server: {self.email_server}:{self.email_port}"
+                                      f", using SSL: {self.use_ssl}, TLS: {self.use_tls}, verify: {self.verify}")
+            ssl_context = ssl.create_default_context() if self.verify else ssl._create_unverified_context()
+            if self.use_ssl:
+                smtp = smtplib.SMTP_SSL(self.email_server, self.email_port, timeout=self.timeout_seconds, context=ssl_context)
+            else:
+                smtp = smtplib.SMTP(self.email_server, self.email_port, timeout=self.timeout_seconds)
+
+            try:
+                if self.use_tls and not self.use_ssl:
+                    smtp.starttls(context=ssl_context)
+
+                if self.email_password:
+                    self.context.logger.debug("Authenticating with server...")
+                    smtp.login(self.email_user, self.email_password)
+
+                self.context.logger.debug("Sending email...")
+                smtp.send_message(msg)
+                self.context.logger.info(f"Email sent successfully to {len(self.email_recipients)} recipients: {self.email_recipients}")
+            finally:
+                try:
+                    smtp.quit()
+                except Exception:
+                    pass
+
+        except socket.gaierror as e:
+            self._exit(False, f"Invalid SMTP server. Cannot resolve hostname '{self.email_server}': {str(e)}")
+        except socket.timeout as e:
+            self._exit(False, f"Connection timeout to SMTP server: {str(e)}")
+        except smtplib.SMTPAuthenticationError as e:
+            self._exit(False, f"SMTP authentication failed: {str(e)}")
+        except smtplib.SMTPRecipientsRefused as e:
+            self._exit(False, f"Email recipients rejected - verify email addresses are valid and domain exists: {str(e)}. SMTP may reject domains like: @gmail.com and etc.")
+        except Exception as e:
+            self._exit(False, f"Failed to send email: {str(e)}")

qubership_pipelines_common_library/v2/notifications/send_webex_message_command.py

@@ -0,0 +1,131 @@
+import tempfile
+import os
+import traceback
+
+from qubership_pipelines_common_library.v1.execution.exec_command import ExecutionCommand
+from qubership_pipelines_common_library.v1.webex_client import WebexClient
+from webexpythonsdk.exceptions import ApiError
+from requests.exceptions import ProxyError
+
+
+class SendWebexMessage(ExecutionCommand):
+    """
+    This command sends Webex message with optional attachments.
+
+    Input Parameters Structure (this structure is expected inside "input_params.params" block):
+    ```
+    {
+        "webex_message": "Hello, world!",           # REQUIRED: Text message (Markdown format is supported)
+        "parent_id": "1234321",                     # OPTIONAL: The parent message to reply to
+        "attachments": {                            # OPTIONAL: Dict with attachments
+            "unique_attachment_key": {
+                "name": "HTML_report.html",         # REQUIRED: File name used for attachment
+                "content": "<html>...</html>",      # REQUIRED: Text content put inside attachment
+                "mime_type": "text/html",
+            },
+            "another_attachment_key": {...}
+        }
+    }
+    ```
+
+    Systems Configuration (expected in "systems.webex" block):
+    ```
+    {
+        "room_id": "...Y2lzY29zc...",               # REQUIRED: Webex unique room_id where message will be posted
+        "token": "your_bot_account_token"           # REQUIRED: Bot/Service account token that will be used to send message
+        "proxy": "https://127.0.0.1"                # OPTIONAL: Host to be used as a webex-proxy
+    }
+    ```
+
+    Output Parameters:
+        - params.message_id: Received `message_id` of sent message
+        - params.attachment_message_ids: dict of `attachment_name` -> `message_id`
+
+    Command name: "send-webex-message"
+    """
+
+    def _validate(self):
+        required_params = [
+            "paths.input.params",
+            "paths.output.params",
+            "systems.webex.room_id",
+            "systems.webex.token",
+            "params.webex_message",
+        ]
+        if not self.context.validate(required_params):
+            return False
+
+        self.webex_room_id = self.context.input_param_get("systems.webex.room_id")
+        self.webex_token = self.context.input_param_get("systems.webex.token")
+        self.webex_proxy = self.context.input_param_get("systems.webex.proxy")
+        self.webex_message = self.context.input_param_get("params.webex_message")
+        self.webex_parent_id = self.context.input_param_get("params.parent_id", "")
+
+        self.attachments = []
+        for key, data in self.context.input_param_get("params.attachments", {}).items():
+            if not data.get("content") or not data.get("name"):
+                self.context.logger.error(f"Attachment with key [{key}] is missing content and/or name!")
+                return False
+            self.attachments.append({
+                "name": data.get("name"),
+                "mime_type": data.get("mime_type"),
+                "content": data.get("content")
+            })
+
+        self.webex_client = WebexClient(
+            bot_token=self.webex_token,
+            proxies={"https": self.webex_proxy} if self.webex_proxy else None
+        )
+        return True
+
+    def _execute(self):
+        try:
+            response = self.webex_client.send_message(
+                room_id=self.webex_room_id,
+                parent_id=self.webex_parent_id,
+                markdown=self.webex_message
+            )
+            message_id = response.id if response else None
+            self.context.output_param_set("params.message_id", message_id)
+
+            if self.attachments:
+                attachment_message_ids = {}
+                for attachment in self.attachments:
+                    attachment_message_ids[attachment["name"]] = self._send_attachment(attachment)
+                self.context.output_param_set("params.attachment_message_ids", attachment_message_ids)
+
+            self.context.output_params_save()
+            self.context.logger.info("Webex message sent successfully.")
+
+        except ApiError as e:
+            self.context.logger.debug("Full traceback: %s", traceback.format_exc())
+            error_str = str(e)
+            if "404" in error_str or "Not Found" in error_str:
+                error_msg = f"Webex room not found - verify room_id '{self.webex_room_id}' exists. {error_str}"
+            elif "401" in error_str or "Unauthorized" in error_str:
+                error_msg = f"Webex authentication failed - verify token is valid: {error_str}"
+            else:
+                error_msg = f"Webex API error: {error_str}"
+            self._exit(False, error_msg)
+
+        except ProxyError as e:
+            self.context.logger.debug("Full traceback: %s", traceback.format_exc())
+            self._exit(False, f"Invalid proxy: {str(e)}")
+
+        except Exception as e:
+            self._exit(False, f"Failed to send Webex message: {e}\n{traceback.format_exc()}")
+
+    def _send_attachment(self, attachment: dict):
+        temp_dir = tempfile.gettempdir()
+        temp_file_path = os.path.join(temp_dir, attachment["name"])
+        with open(temp_file_path, "w") as temp_file:
+            temp_file.write(attachment["content"])
+            temp_file_path = temp_file.name
+        try:
+            attachment_response = self.webex_client.send_message(room_id=self.webex_room_id,
+                                                                 parent_id=self.webex_parent_id,
+                                                                 markdown=attachment["name"],
+                                                                 attachment_path=temp_file_path)
+            return attachment_response.id if attachment_response else None
+        finally:
+            os.remove(temp_file_path)

qubership_pipelines_common_library/v2/utils/crypto_utils.py

@@ -36,6 +36,8 @@ class CryptoUtils:
             }
         elif isinstance(data, list):
             return [CryptoUtils.mask_values(item, path) for item in data]
+        elif data is None or data == '':
+            return ""
         else:
             return "[MASKED]"
 

{qubership_pipelines_common_library-2.0.1.dist-info → qubership_pipelines_common_library-2.0.3.dist-info}/METADATA

@@ -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.dist-info → qubership_pipelines_common_library-2.0.3.dist-info}/RECORD

@@ -19,12 +19,12 @@ qubership_pipelines_common_library/v1/utils/__init__.py,sha256=QczIlSYNOtXMuMWSz
 qubership_pipelines_common_library/v1/utils/rest.py,sha256=OfYGPE2tM-vDUg__ytZKfpCeGVCDePSjXDHK61A2KDM,3069
 qubership_pipelines_common_library/v1/utils/utils.py,sha256=aMyUrJqlnRcFSjNtiyKa5TDJ31m2ABpljeQdnil3A20,1866
 qubership_pipelines_common_library/v1/utils/utils_aws.py,sha256=BPPnHBzPPXPqFijtAiw16sTPu1tFZjS95GkSMX_HdjA,808
-qubership_pipelines_common_library/v1/utils/utils_cli.py,sha256=URmspvyL2kzRyoaXJbxsVEEcy9n4l9ezuvFYVW4W1hk,4188
+qubership_pipelines_common_library/v1/utils/utils_cli.py,sha256=jkhBswmYqJHfszaYhWknCTxaBx0tEh42McFx5dP6EXQ,4931
 qubership_pipelines_common_library/v1/utils/utils_context.py,sha256=IlMFXGxS8zJw33Gu3SbOUcj88wquIkobBlWkdFbR7MA,3767
 qubership_pipelines_common_library/v1/utils/utils_dictionary.py,sha256=xe8ftnigzyCKWCZaUnI2Xu2ykYlOl1Nc9ATimXuCbgM,1366
 qubership_pipelines_common_library/v1/utils/utils_file.py,sha256=E4RhpeCRhUt-EQ_6pUz-QEKkH8JidJWwYxZmrAvpHBk,2905
 qubership_pipelines_common_library/v1/utils/utils_json.py,sha256=QczIlSYNOtXMuMWSznhV_BkXMM5KLn1wOogtlT2kcy0,598
-qubership_pipelines_common_library/v1/utils/utils_logging.py,sha256=2kPBjPyQfPOZ8_Zv4W-aBWBlZtN_mDCc3JWHzdW4BJo,1506
+qubership_pipelines_common_library/v1/utils/utils_logging.py,sha256=rVkx1OnyL9WmvLvvYij9Fn9tM16geqsCzeeVwObPhRw,1505
 qubership_pipelines_common_library/v1/utils/utils_string.py,sha256=Phx5ZXPRjhjg9AaSPx6WLX9zQvwJH1txslfnG3jJ43w,993
 qubership_pipelines_common_library/v1/webex_client.py,sha256=JU_0NgLu_p6zgaUi-ixgZeFMlJaTAvXwrU1oA607Bv0,2997
 qubership_pipelines_common_library/v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -63,14 +63,23 @@ qubership_pipelines_common_library/v2/jenkins/jenkins_client.py,sha256=h-EWIBYHx
 qubership_pipelines_common_library/v2/jenkins/jenkins_pipeline_data_importer.py,sha256=zWNejXoAw1y25Jf6cl6f7UhwnJsyEK87hw7MDdoL0Mk,1572
 qubership_pipelines_common_library/v2/jenkins/jenkins_run_pipeline_command.py,sha256=7ws_V2QO8QwpOKUtgl8PbcnhsUo_pHruue-if-79ee8,10136
 qubership_pipelines_common_library/v2/jenkins/safe_jenkins_client.py,sha256=PD1BaF4TbvzIy49g3EdxsliRyUp_zy6TFAuhBt29FEw,620
+qubership_pipelines_common_library/v2/jira/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qubership_pipelines_common_library/v2/jira/jira_add_ticket_comment_command.py,sha256=kHqrtYg519oVAAfH3iZJtlTWROduBAONplz2cv6qA5E,4844
+qubership_pipelines_common_library/v2/jira/jira_client.py,sha256=wXWQyJiI0ZTFslEjcddLgLxPQUA5BcoulUbAFKF2Cio,11079
+qubership_pipelines_common_library/v2/jira/jira_create_ticket_command.py,sha256=djPY_rH3rhjrhSNaC8SrDItBgGkGniUYXJXHe98pSi8,6741
+qubership_pipelines_common_library/v2/jira/jira_update_ticket_command.py,sha256=JpkS-n-CepqwWEVV_mIP6XTGwQl4fk8KH8V6bBJrAmA,7453
+qubership_pipelines_common_library/v2/jira/jira_utils.py,sha256=o6BLsPSKQjn-j0Ht8lGsF4_1PT9s7vgHvhMMxiMvt3Q,965
+qubership_pipelines_common_library/v2/notifications/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qubership_pipelines_common_library/v2/notifications/send_email_command.py,sha256=wlFdJaUyqROfVxBoSChdl4wjcxCJJ4t-vSQ-JCkjjd0,7665
+qubership_pipelines_common_library/v2/notifications/send_webex_message_command.py,sha256=NuFVCijo0bnnL80mWvf_RknjgX76ZzIOuqdtynZPHRk,5819
 qubership_pipelines_common_library/v2/podman/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubership_pipelines_common_library/v2/podman/podman_command.md,sha256=EKctWLIXZhoaxe579f-OgqFfjISk2UYgFD8JyzJeAVU,6500
 qubership_pipelines_common_library/v2/podman/podman_command.py,sha256=o78MYtieAD4rdOyRQEioQREhhw0e0Zqa1kNyygvOOSI,15541
 qubership_pipelines_common_library/v2/sops/sops_client.py,sha256=vB1czEqIQ6aRywkfvIQfqGZOTtPy39cnOExhfJbPw4s,4946
-qubership_pipelines_common_library/v2/utils/crypto_utils.py,sha256=zZ32IJY7WKzJEJNyZQVCPdWC4uujo6goR0MyzBAhn78,1504
+qubership_pipelines_common_library/v2/utils/crypto_utils.py,sha256=FkVmRZVYZRNg0SzpO43cQc_PXJNSiQHlvJzxRGpVrI4,1567
 qubership_pipelines_common_library/v2/utils/extension_utils.py,sha256=-OyT6xrIg-PdHHy2Y712rbOAB6Q7WXTqGwP7oVne4k4,965
 qubership_pipelines_common_library/v2/utils/retry_decorator.py,sha256=ItYYL7zam4LrpQrsihis_n6aFCAa32ZAOKKSmxkaENM,4391
-qubership_pipelines_common_library-2.0.1.dist-info/METADATA,sha256=leOGiAkgcUaDCECQTxt3p0jzG1vOSno68GLK4UXPr7U,3063
-qubership_pipelines_common_library-2.0.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-qubership_pipelines_common_library-2.0.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-qubership_pipelines_common_library-2.0.1.dist-info/RECORD,,
+qubership_pipelines_common_library-2.0.3.dist-info/METADATA,sha256=eGwWa2rTjnE2mv1U6lIp6W19-8FbwH7-T6qK9WYAPO8,3063
+qubership_pipelines_common_library-2.0.3.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+qubership_pipelines_common_library-2.0.3.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qubership_pipelines_common_library-2.0.3.dist-info/RECORD,,

{qubership_pipelines_common_library-2.0.1.dist-info → qubership_pipelines_common_library-2.0.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any