devsecops-engine-tools 1.27.1__tar.gz → 1.28.1__tar.gz

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: devsecops-engine-tools
-Version: 1.27.1
+Version: 1.28.1
 Summary: Tool for DevSecOps strategy
 Home-page: https://github.com/bancolombia/devsecops-engine-tools
 Author: Bancolombia DevSecOps Team
@@ -99,7 +99,7 @@ devsecops-engine-tools --platform_devops ["local","azure","github"] --remote_con
    ┃   ┗ 📜ConfigTool.json
    ┃   ┗ 📜Exclusions.json
 ```
-
+For more information visit [here](https://github.com/bancolombia/devsecops-engine-tools/blob/trunk/example_remote_config_local/README.md)
 #### Tools available for the modules (Configuration engine_core/ConfigTool.json)
 
 

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/devsecops_engine_tools/engine_core/src/domain/model/vulnerability_management.py

@@ -18,3 +18,6 @@ class VulnerabilityManagement:
     branch_tag: str
     commit_hash: str
     environment: str
+    vm_product_type_name: str
+    vm_product_name: str
+    vm_product_description: str

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/devsecops_engine_tools/engine_core/src/domain/usecases/handle_scan.py

@@ -196,6 +196,9 @@ class HandleScan:
                             self.devops_platform_gateway.get_variable("branch_tag"),
                             self.devops_platform_gateway.get_variable("commit_hash"),
                             env,
+                            self.devops_platform_gateway.get_variable("vm_product_type_name"),
+                            self.devops_platform_gateway.get_variable("vm_product_name"),
+                            self.devops_platform_gateway.get_variable("vm_product_description"),
                         )
                     )
 

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/azure/azure_devops.py

@@ -7,6 +7,7 @@ from devsecops_engine_tools.engine_utilities.azuredevops.models.AzurePredefinedV
     SystemVariables,
     ReleaseVariables,
     AgentVariables,
+    VMVariables
 )
 from devsecops_engine_tools.engine_utilities.azuredevops.infrastructure.azure_devops_api import (
     AzureDevopsApi,
@@ -95,6 +96,9 @@ class AzureDevops(DevopsPlatformGateway):
                 "target_branch": SystemVariables.System_TargetBranchName,
                 "source_branch": SystemVariables.System_SourceBranch,
                 "repository_provider": BuildVariables.Build_Repository_Provider,
+                "vm_product_type_name": VMVariables.Vm_Product_Type_Name,
+                "vm_product_name": VMVariables.Vm_Product_Name,
+                "vm_product_description": VMVariables.Vm_Product_Description,
             }
             try:
                 return variable_map.get(variable).value()

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/defect_dojo/defect_dojo.py

@@ -30,6 +30,7 @@ from functools import partial
 
 from devsecops_engine_tools.engine_utilities.utils.logger_info import MyLogger
 from devsecops_engine_tools.engine_utilities import settings
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.serializers.import_scan import ImportScanSerializer
 import time
 import concurrent.futures
 
@@ -87,44 +88,17 @@ class DefectDojoPlatform(VulnerabilityManagementGateway):
                 tags = vulnerability_management.dict_args["tool"]
                 if vulnerability_management.dict_args["tool"] == "engine_iac":
                     tags = f"{vulnerability_management.dict_args['tool']}_{'_'.join(vulnerability_management.dict_args['platform'])}"
-                request: ImportScanRequest = Connect.cmdb(
-                    cmdb_mapping={
-                        "product_type_name": "nombreevc",
-                        "product_name": "nombreapp",
-                        "tag_product": "nombreentorno",
-                        "product_description": "arearesponsableti",
-                        "codigo_app": "CodigoApp",
-                    },
-                    compact_remote_config_url=f'{vulnerability_management.base_compact_remote_config_url}{vulnerability_management.config_tool["VULNERABILITY_MANAGER"]["DEFECT_DOJO"]["CMDB_MAPPING_PATH"]}',
-                    personal_access_token=vulnerability_management.access_token,
-                    token_cmdb=token_cmdb,
-                    host_cmdb=vulnerability_management.config_tool[
-                        "VULNERABILITY_MANAGER"
-                    ]["DEFECT_DOJO"]["HOST_CMDB"],
-                    expression=vulnerability_management.config_tool[
-                        "VULNERABILITY_MANAGER"
-                    ]["DEFECT_DOJO"]["REGEX_EXPRESSION_CMDB"],
-                    token_defect_dojo=token_dd,
-                    host_defect_dojo=vulnerability_management.config_tool[
-                        "VULNERABILITY_MANAGER"
-                    ]["DEFECT_DOJO"]["HOST_DEFECT_DOJO"],
-                    scan_type=scan_type_mapping[vulnerability_management.scan_type],
-                    engagement_name=vulnerability_management.input_core.scope_pipeline,
-                    service=vulnerability_management.input_core.scope_pipeline,
-                    file=vulnerability_management.input_core.path_file_results,
-                    version=vulnerability_management.version,
-                    build_id=vulnerability_management.build_id,
-                    source_code_management_uri=vulnerability_management.source_code_management_uri,
-                    branch_tag=vulnerability_management.branch_tag,
-                    commit_hash=vulnerability_management.commit_hash,
-                    environment=(
-                        enviroment_mapping[vulnerability_management.environment.lower()]
-                        if vulnerability_management.environment is not None
-                        and vulnerability_management.environment.lower()
-                        in enviroment_mapping
-                        else enviroment_mapping["default"]
-                    ),
-                    tags=tags,
+
+                use_cmdb = vulnerability_management.config_tool["VULNERABILITY_MANAGER"]["DEFECT_DOJO"]["CMDB"]["USE_CMDB"]
+
+                request = self._build_request_importscan(
+                    vulnerability_management,
+                    token_cmdb,
+                    token_dd,
+                    scan_type_mapping,
+                    enviroment_mapping,
+                    tags,
+                    use_cmdb
                 )
 
                 def request_func():
@@ -170,7 +144,7 @@ class DefectDojoPlatform(VulnerabilityManagementGateway):
                     request={
                         "name": Connect.get_code_app(
                             service,
-                            config_tool["VULNERABILITY_MANAGER"]["DEFECT_DOJO"][
+                            config_tool["VULNERABILITY_MANAGER"]["DEFECT_DOJO"]["CMDB"][
                                 "REGEX_EXPRESSION_CMDB"
                             ],
                         ),
@@ -387,6 +361,74 @@ class DefectDojoPlatform(VulnerabilityManagementGateway):
                     ex
                 )
             )
+        
+    def _build_request_importscan(
+        self,
+        vulnerability_management: VulnerabilityManagement,
+        token_cmdb,
+        token_dd,
+        scan_type_mapping,
+        enviroment_mapping,
+        tags,
+        use_cmdb: bool
+    ):
+        common_fields = {
+            "scan_type": scan_type_mapping[vulnerability_management.scan_type],
+            "file": vulnerability_management.input_core.path_file_results,
+            "engagement_name": vulnerability_management.input_core.scope_pipeline,
+            "source_code_management_uri": vulnerability_management.source_code_management_uri,
+            "tags": tags,
+            "version": vulnerability_management.version,
+            "build_id": vulnerability_management.build_id,
+            "branch_tag": vulnerability_management.branch_tag,
+            "commit_hash": vulnerability_management.commit_hash,
+            "service": vulnerability_management.input_core.scope_pipeline,
+            "environment": (
+                enviroment_mapping[vulnerability_management.environment.lower()]
+                if vulnerability_management.environment is not None
+                and vulnerability_management.environment.lower()
+                in enviroment_mapping
+                else enviroment_mapping["default"]
+            ),
+            "token_defect_dojo": token_dd,
+            "host_defect_dojo": vulnerability_management.config_tool[
+                "VULNERABILITY_MANAGER"
+            ]["DEFECT_DOJO"]["HOST_DEFECT_DOJO"],
+            "expression": vulnerability_management.config_tool[
+                "VULNERABILITY_MANAGER"
+            ]["DEFECT_DOJO"]["CMDB"]["REGEX_EXPRESSION_CMDB"],
+        }
+
+        if use_cmdb:
+            cmdb_mapping = vulnerability_management.config_tool["VULNERABILITY_MANAGER"]["DEFECT_DOJO"]["CMDB"]["CMDB_MAPPING"]
+            return Connect.cmdb(
+                cmdb_mapping={
+                    "product_type_name": cmdb_mapping["PRODUCT_TYPE_NAME"],
+                    "product_name": cmdb_mapping["PRODUCT_NAME"],
+                    "tag_product": cmdb_mapping["TAG_PRODUCT"],
+                    "product_description": cmdb_mapping["PRODUCT_DESCRIPTION"],
+                    "codigo_app": cmdb_mapping["CODIGO_APP"],
+                },
+                compact_remote_config_url=f'{vulnerability_management.base_compact_remote_config_url}{vulnerability_management.config_tool["VULNERABILITY_MANAGER"]["DEFECT_DOJO"]["CMDB"]["CMDB_MAPPING_PATH"]}',
+                personal_access_token=vulnerability_management.access_token,
+                token_cmdb=token_cmdb,
+                host_cmdb=vulnerability_management.config_tool[
+                    "VULNERABILITY_MANAGER"
+                ]["DEFECT_DOJO"]["CMDB"]["HOST_CMDB"],
+                cmdb_request_response=vulnerability_management.config_tool["VULNERABILITY_MANAGER"]["DEFECT_DOJO"]["CMDB"]["CMDB_REQUEST_RESPONSE"],
+                **common_fields,
+            )
+        else:
+            request: ImportScanRequest = ImportScanSerializer().load(
+                {
+                    "product_type_name":vulnerability_management.vm_product_type_name,
+                    "product_name": vulnerability_management.vm_product_name,
+                    "product_description":vulnerability_management.vm_product_description,
+                    "code_app":vulnerability_management.vm_product_name,
+                    **common_fields,
+                }
+            )
+            return request
 
     def _process_component(self, component_sbom, session_manager, engagement):
         request = {

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/github/github_actions.py

@@ -6,7 +6,8 @@ from devsecops_engine_tools.engine_utilities.github.models.GithubPredefinedVaria
     BuildVariables,
     SystemVariables,
     ReleaseVariables,
-    AgentVariables
+    AgentVariables,
+    VMVariables
 )
 from devsecops_engine_tools.engine_utilities.github.infrastructure.github_api import (
     GithubApi,
@@ -85,6 +86,9 @@ class GithubActions(DevopsPlatformGateway):
             "target_branch": SystemVariables.github_event_base_ref,
             "source_branch": SystemVariables.github_ref,
             "repository_provider": BuildVariables.GitHub,
+            "vm_product_type_name": VMVariables.Vm_Product_Type_Name,
+            "vm_product_name": VMVariables.Vm_Product_Name,
+            "vm_product_description": VMVariables.Vm_Product_Description,
         }
         try:
             return variable_map.get(variable).value()

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/runtime_local/runtime_local.py

@@ -21,7 +21,7 @@ class RuntimeLocal(DevopsPlatformGateway):
     def get_remote_config(self, repository, path, branch=""):
         remote_config_path = f"{repository}/{path}"
 
-        with open(remote_config_path) as f:
+        with open(remote_config_path, 'r', encoding='utf-8') as f:
             return json.load(f)
 
     def message(self, type, message):
@@ -66,6 +66,9 @@ class RuntimeLocal(DevopsPlatformGateway):
             "temp_directory" : "DET_TEMP_DIRECTORY",
             "target_branch" : "DET_TARGET_BRANCH",
             "source_branch" : "DET_SOURCE_BRANCH",
-            "repository_provider" : "DET_REPOSITORY_PROVIDER"
+            "repository_provider" : "DET_REPOSITORY_PROVIDER",
+            "vm_product_type_name" : "DET_VM_PRODUCT_TYPE_NAME",
+            "vm_product_name" : "DET_VM_PRODUCT_NAME",
+            "vm_product_description" : "DET_VM_PRODUCT_DESCRIPTION",
         }
         return os.environ.get(env_variables[variable], None)

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/devsecops_engine_tools/engine_sca/engine_dependencies/src/infrastructure/driven_adapters/xray_tool/xray_manager_scan.py

@@ -29,7 +29,11 @@ class XrayScan(ToolGateway):
         if installed.returncode == 1:
             command = ["chmod", "+x", prefix]
             try:
-                url = f"https://releases.jfrog.io/artifactory/jfrog-cli/v2-jf/{version}/jfrog-cli-linux-amd64/jf"
+                architecture = platform.machine()
+                if architecture == "aarch64":
+                    url = f"https://releases.jfrog.io/artifactory/jfrog-cli/v2-jf/{version}/jfrog-cli-linux-arm64/jf"
+                else:
+                    url = f"https://releases.jfrog.io/artifactory/jfrog-cli/v2-jf/{version}/jfrog-cli-linux-amd64/jf"
                 response = requests.get(url, allow_redirects=True)
                 with open(prefix, "wb") as archivo:
                     archivo.write(response.content)

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/devsecops_engine_tools/engine_utilities/azuredevops/models/AzurePredefinedVariables.py

@@ -63,3 +63,8 @@ class AgentVariables(BaseEnum):
     Agent_WorkFolder = "Agent.WorkFolder"
     Agent_TempDirectory = "Agent.TempDirectory"
     Agent_OS = "Agent.OS"
+
+class VMVariables(BaseEnum):
+    Vm_Product_Type_Name = "Vm.Product.Type.Name"
+    Vm_Product_Name = "Vm.Product.Name"
+    Vm_Product_Description = "Vm.Product.Description"

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/devsecops_engine_tools/engine_utilities/defect_dojo/domain/request_objects/import_scan.py

@@ -40,6 +40,7 @@ class ImportScanRequest:
     code_app: str = ""
     token_cmdb: str = ""
     host_cmdb: str = ""
+    cmdb_request_response: dict = None
     token_defect_dojo: str = ""
     host_defect_dojo: str = ""
     # *** config map ***

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/devsecops_engine_tools/engine_utilities/defect_dojo/domain/serializers/import_scan.py

@@ -198,16 +198,17 @@ class ImportScanSerializer(Schema):
     service = fields.Str(required=False)
     group_by = fields.Str(required=False)
     test_title = fields.Str(required=False)
-    description_product = fields.Str(required=False)
+    product_description = fields.Str(required=False)
     create_finding_groups_for_all_findings = fields.Str(required=False)
     tools_configuration = fields.Int(required=False, load_default=1)
     code_app = fields.Str(required=False)
     # defect-dojo credential
-    token_cmdb = fields.Str(required=True)
-    host_cmdb = fields.Url(required=True)
+    token_cmdb = fields.Str(required=False)
+    host_cmdb = fields.Url(required=False)
+    cmdb_request_response = fields.Dict(required=False)
     token_defect_dojo = fields.Str(required=True)
     host_defect_dojo = fields.Str(required=True)
-    cmdb_mapping = fields.Dict(required=True)
+    cmdb_mapping = fields.Dict(required=False)
     product_type_name_mapping = fields.Dict(required=False)
     # Config remote credential
     compact_remote_config_url = fields.Str(required=False)

devsecops_engine_tools-1.28.1/devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/cmdb.py

@@ -0,0 +1,107 @@
+import json
+import ast
+from devsecops_engine_tools.engine_utilities.utils.api_error import ApiError
+from devsecops_engine_tools.engine_utilities.utils.logger_info import MyLogger
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.models.cmdb import Cmdb
+from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.settings.settings import VERIFY_CERTIFICATE
+from devsecops_engine_tools.engine_utilities.utils.session_manager import SessionManager
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.request_objects.import_scan import ImportScanRequest
+from devsecops_engine_tools.engine_utilities.settings import SETTING_LOGGER
+
+logger = MyLogger.__call__(**SETTING_LOGGER).get_logger()
+
+
+class CmdbRestConsumer:
+    def __init__(self, token: str, host: str, mapping_cmdb: dict, session: SessionManager) -> None:
+        self.__token = token
+        self.__host = host
+        self.__mapping_cmdb = mapping_cmdb
+        self.__session = session._instance
+
+    def get_product_info(self, request: ImportScanRequest) -> Cmdb:
+        method = request.cmdb_request_response.get("METHOD")
+        headers = self.prepare_headers(request.cmdb_request_response.get("HEADERS"))
+        response_format = request.cmdb_request_response.get("RESPONSE")
+
+        if method not in ["GET", "POST"]:
+            raise ValueError(f"Unsupported method: {method}")
+        
+        return self.handle_request(method, headers, request, response_format)
+
+    def handle_request(self, method, headers, request: ImportScanRequest, response_format) -> Cmdb:
+        cmdb_object = self.initialize_cmdb_object(request)
+
+        try:
+            if method == "GET":
+                params = self.replace_placeholders(
+                    request.cmdb_request_response.get("PARAMS", {}),
+                    request.code_app
+                )
+                response = self.__session.get(self.__host, headers=headers, params=params, verify=VERIFY_CERTIFICATE)
+            elif method == "POST":
+                body = self.replace_placeholders(
+                    request.cmdb_request_response.get("BODY", {}),
+                    request.code_app
+                )
+                body_json = json.dumps(body)
+                response = self.__session.post(self.__host, headers=headers, data=body_json, verify=VERIFY_CERTIFICATE)
+
+            return self.process_response(response, response_format, cmdb_object, request.code_app)
+        except Exception as e:
+            logger.warning(e)
+            return cmdb_object
+
+    def process_response(self, response, response_format, cmdb_object, code_app) -> Cmdb:
+        if response.status_code != 200:
+            logger.warning(response)
+            raise ApiError(f"Error querying cmdb: {response.reason}")
+        
+        if response.json() == []:
+            logger.warning(f"Engagement: {code_app} not found")
+            return cmdb_object  # Producto es Orphan
+
+        data = self.get_nested_data(response, response_format)
+        data_map = self.mapping_cmdb(data)
+        logger.info(data_map)
+        cmdb_object = Cmdb.from_dict(data_map)
+        cmdb_object.codigo_app = code_app
+        return cmdb_object
+
+    def initialize_cmdb_object(self, request: ImportScanRequest) -> Cmdb:
+        return Cmdb(
+            product_type_name="ORPHAN_PRODUCT_TYPE",
+            product_name=f"{request.code_app}_Product",
+            tag_product="ORPHAN",
+            product_description="Orphan Product Description",
+            codigo_app=str(request.code_app),
+        )
+
+    def mapping_cmdb(self, data: dict) -> dict:
+        return {key: data.get(value, "") for key, value in self.__mapping_cmdb.items()}
+
+    def get_nested_data(self, response, keys: list) -> dict:
+        data = response.json()
+        for key in keys:
+            if isinstance(data, dict) and key in data:
+                data = data[key]
+            elif isinstance(data, list) and isinstance(key, int):
+                key = key if key >=0 else len(data) + key
+                if 0 <= key < len(data):
+                    data = data[key]
+                else:
+                    raise KeyError(f"Index '{key}' out of range in the current context.")
+            else:
+                raise KeyError(f"Key '{key}' not found or invalid in the current context.")
+        return data
+
+    def prepare_headers(self, headers: dict) -> dict:
+        return {key: (self.__token if value == 'tokenvalue' else value) for key, value in headers.items()}
+        
+    def replace_placeholders(self, data, replacements):
+        data = str(data)
+        data = data.replace("codappvalue", replacements)
+        try:
+            return ast.literal_eval(data)
+        except (SyntaxError, ValueError) as e:
+            raise ValueError(f"Error converting string to dictionary: {e}")
+

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/devsecops_engine_tools/engine_utilities/github/models/GithubPredefinedVariables.py

@@ -54,3 +54,9 @@ class AgentVariables(BaseEnum):
     github_workspace = "github.workspace"
     runner_os = "runner.os"
     runner_tool_cache = "runner.tool.cache"
+
+
+class VMVariables(BaseEnum):
+    Vm_Product_Type_Name = "Vm.Product.Type.Name"
+    Vm_Product_Name = "Vm.Product.Name"
+    Vm_Product_Description = "Vm.Product.Description"

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/devsecops_engine_tools/engine_utilities/sonarqube/src/domain/usecases/report_sonar.py

@@ -99,7 +99,10 @@ class ReportSonar:
             build_id = self.devops_platform_gateway.get_variable("build_id"),
             branch_tag = branch,
             commit_hash = self.devops_platform_gateway.get_variable("commit_hash"),
-            environment = environment
+            environment = environment,
+            vm_product_type_name = self.devops_platform_gateway.get_variable("vm_product_type_name"),
+            vm_product_name = self.devops_platform_gateway.get_variable("vm_product_name"),
+            vm_product_description = self.devops_platform_gateway.get_variable("vm_product_description"),
         )
 
         for project_key in project_keys:

devsecops_engine_tools-1.28.1/devsecops_engine_tools/version.py

@@ -0,0 +1 @@
+version = '1.28.1'

{devsecops_engine_tools-1.27.1 → devsecops_engine_tools-1.28.1}/devsecops_engine_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: devsecops-engine-tools
-Version: 1.27.1
+Version: 1.28.1
 Summary: Tool for DevSecOps strategy
 Home-page: https://github.com/bancolombia/devsecops-engine-tools
 Author: Bancolombia DevSecOps Team
@@ -99,7 +99,7 @@ devsecops-engine-tools --platform_devops ["local","azure","github"] --remote_con
    ┃   ┗ 📜ConfigTool.json
    ┃   ┗ 📜Exclusions.json
 ```
-
+For more information visit [here](https://github.com/bancolombia/devsecops-engine-tools/blob/trunk/example_remote_config_local/README.md)
 #### Tools available for the modules (Configuration engine_core/ConfigTool.json)
 
 

devsecops_engine_tools-1.27.1/devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/cmdb.py

@@ -1,56 +0,0 @@
-import json
-from devsecops_engine_tools.engine_utilities.utils.api_error import ApiError
-from devsecops_engine_tools.engine_utilities.utils.logger_info import MyLogger
-from devsecops_engine_tools.engine_utilities.defect_dojo.domain.models.cmdb import Cmdb
-from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.settings.settings import VERIFY_CERTIFICATE
-from devsecops_engine_tools.engine_utilities.utils.session_manager import SessionManager
-from devsecops_engine_tools.engine_utilities.defect_dojo.domain.request_objects.import_scan import ImportScanRequest
-from devsecops_engine_tools.engine_utilities.settings import SETTING_LOGGER
-
-logger = MyLogger.__call__(**SETTING_LOGGER).get_logger()
-
-
-class CmdbRestConsumer:
-    def __init__(self, token: str, host: str, mapping_cmdb: dict, session: SessionManager) -> None:
-        self.__token = token
-        self.__host = host
-        self.__mapping_cmdb = mapping_cmdb
-        self.__session = session._instance
-
-    def get_product_info(self, request: ImportScanRequest) -> Cmdb:
-        data = json.dumps({"codapp": request.code_app})
-        headers = {"tokenkey": self.__token, "Content-Type": "application/json"}
-        logger.info("Search info of name product")
-        cmdb_object = Cmdb(
-                    product_type_name="ORPHAN_PRODUCT_TYPE",
-                    product_name=f"{request.code_app}_Product",
-                    tag_product="ORPHAN",
-                    product_description="Orphan Product Description",
-                    codigo_app=str(request.code_app),
-                )
-        try:
-            response = self.__session.post(self.__host, headers=headers, data=data, verify=VERIFY_CERTIFICATE)
-            if response.status_code != 200:
-                logger.warning(response)
-                raise ApiError(f"Error querying cmdb: {response.reason}")
-
-            if response.json() == []:
-                e = f"Engagement: {request.code_app} not found"
-                logger.warning(e)
-                # Producto is Orphan
-                return cmdb_object
-
-            data = response.json()[-1]
-            data_map = self.mapping_cmdb(data)
-            logger.info(data_map)
-            cmdb_object = Cmdb.from_dict(data_map)
-        except Exception as e:
-            logger.warning(e)
-            return cmdb_object
-        return cmdb_object
-
-    def mapping_cmdb(self, data):
-        data_map = {}
-        for key, value in self.__mapping_cmdb.items():
-            data_map[key] = data[value] if value in data else ""
-        return data_map

devsecops_engine_tools-1.27.1/devsecops_engine_tools/version.py

@@ -1 +0,0 @@
-version = '1.27.1'