devsecops-engine-tools 1.40.1__tar.gz → 1.42.0__tar.gz

{devsecops_engine_tools-1.40.1 → devsecops_engine_tools-1.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: devsecops-engine-tools
-Version: 1.40.1
+Version: 1.42.0
 Summary: Tool for DevSecOps strategy
 Home-page: https://github.com/bancolombia/devsecops-engine-tools
 Author: Bancolombia DevSecOps Team

{devsecops_engine_tools-1.40.1 → devsecops_engine_tools-1.42.0}/devsecops_engine_tools/engine_risk/src/domain/usecases/break_build.py

@@ -26,6 +26,7 @@ class BreakBuild:
         report_list: "list[Report]",
         all_report: "list[Report]",
         threshold: any,
+        policy_excluded: int,
     ):
         self.devops_platform_gateway = devops_platform_gateway
         self.printer_table_gateway = printer_table_gateway
@@ -35,6 +36,7 @@ class BreakBuild:
         self.report_list = report_list
         self.all_report = all_report
         self.threshold = threshold
+        self.policy_excluded = policy_excluded
         self.break_build = False
         self.warning_build = False
         self.report_breaker = []
@@ -50,11 +52,9 @@ class BreakBuild:
         }
 
     def process(self):
-        self._remediation_rate_control(self.all_report)
         new_report_list, applied_exclusions = self._apply_exclusions(self.report_list)
-        if self.break_build:
-            self.report_breaker.extend(copy.deepcopy(new_report_list))
         self._tag_blacklist_control(new_report_list)
+        self._remediation_rate_control(self.all_report, new_report_list)
         self._risk_score_control(new_report_list)
         all_exclusions = list(self.vm_exclusions) + list(applied_exclusions)
         self._print_exclusions(self._map_applied_exclusion(all_exclusions))
@@ -118,10 +118,19 @@ class BreakBuild:
         else:
             print(self.devops_platform_gateway.result_pipeline("succeeded"))
 
-    def _remediation_rate_control(self, all_report: "list[Report]"):
+    def _remediation_rate_control(
+        self, all_report: "list[Report]", new_report_list: "list[Report]"
+    ):
         mitigated = sum(1 for report in all_report if report.mitigated)
-        total = len(all_report)
-        print(f"Mitigated count: {mitigated}   Total count: {total}")
+        white_list = sum(
+            1
+            for report in all_report
+            if "white_list" in report.tags and not report.mitigated
+        )
+        total = len(all_report) - self.policy_excluded - white_list
+        print(
+            f"Mitigated count: {mitigated}   Total count: {len(all_report)}   Policy excluded: {self.policy_excluded + white_list}"
+        )
         remediation_rate_value = self._get_percentage(mitigated / total)
 
         risk_threshold = self._get_remediation_rate_threshold(total)
@@ -150,10 +159,18 @@ class BreakBuild:
                 )
             )
             self.break_build = True
+            [
+                setattr(report, "reason", "Remediation Rate")
+                for report in new_report_list
+            ]
+            self.report_breaker.extend(copy.deepcopy(new_report_list))
 
     def _get_remediation_rate_threshold(self, total):
         remediation_rate = self.threshold["REMEDIATION_RATE"]
-        for key in sorted(remediation_rate.keys(), key=lambda x: int(x) if x.isdigit() else float('inf')):
+        for key in sorted(
+            remediation_rate.keys(),
+            key=lambda x: int(x) if x.isdigit() else float("inf"),
+        ):
             if key.isdigit() and total <= int(key):
                 return remediation_rate[key]
         return remediation_rate["other"]
@@ -209,7 +226,6 @@ class BreakBuild:
                         applied_exclusions.append(exclusion_copy)
                         break
             if not exclude:
-                report.reason = "Remediation Rate"
                 filtered_reports.append(report)
 
         return filtered_reports, applied_exclusions
@@ -217,21 +233,22 @@ class BreakBuild:
     def _tag_blacklist_control(self, report_list: "list[Report]"):
         remote_config = self.remote_config
         if report_list:
-            tag_blacklist = set(remote_config["TAG_BLACKLIST"])
-            tag_age_threshold = self.threshold["TAG_MAX_AGE"]
+            tag_blacklist = set(remote_config["TAG_BLACKLIST_EXCLUSION_DAYS"].keys())
 
             filtered_reports_above_threshold = [
                 (report, tag)
                 for report in report_list
                 for tag in report.tags
-                if tag in tag_blacklist and report.age >= tag_age_threshold
+                if tag in tag_blacklist
+                and report.age >= remote_config["TAG_BLACKLIST_EXCLUSION_DAYS"][tag]
             ]
 
             filtered_reports_below_threshold = [
                 (report, tag)
                 for report in report_list
                 for tag in report.tags
-                if tag in tag_blacklist and report.age < tag_age_threshold
+                if tag in tag_blacklist
+                and report.age < remote_config["TAG_BLACKLIST_EXCLUSION_DAYS"][tag]
             ]
 
             for report, tag in filtered_reports_above_threshold:
@@ -239,7 +256,7 @@ class BreakBuild:
                 print(
                     self.devops_platform_gateway.message(
                         "error",
-                        f"Report {report.vm_id} with tag {tag} is blacklisted and age {report.age} is above threshold {tag_age_threshold}",
+                        f"Report {report.vm_id} with tag '{tag}' is blacklisted and age {report.age} is above threshold {remote_config['TAG_BLACKLIST_EXCLUSION_DAYS'][tag]}",
                     )
                 )
 
@@ -247,9 +264,10 @@ class BreakBuild:
                 print(
                     self.devops_platform_gateway.message(
                         "warning",
-                        f"Report {report.vm_id} with tag {tag} is blacklisted but age {report.age} is below threshold {tag_age_threshold}",
+                        f"Report {report.vm_id} with tag '{tag}' is blacklisted but age {report.age} is below threshold {remote_config['TAG_BLACKLIST_EXCLUSION_DAYS'][tag]}",
                     )
                 )
+                self.policy_excluded += 1
 
             if filtered_reports_above_threshold:
                 self.break_build = True

{devsecops_engine_tools-1.40.1 → devsecops_engine_tools-1.42.0}/devsecops_engine_tools/engine_risk/src/domain/usecases/get_exclusions.py

@@ -1,6 +1,7 @@
 from devsecops_engine_tools.engine_core.src.domain.model.exclusions import (
     Exclusions,
 )
+from datetime import datetime, timedelta
 
 
 class GetExclusions:
@@ -12,6 +13,7 @@ class GetExclusions:
         risk_config,
         risk_exclusions,
         services,
+        active_findings,
     ):
         self.devops_platform_gateway = devops_platform_gateway
         self.dict_args = dict_args
@@ -19,10 +21,13 @@ class GetExclusions:
         self.risk_config = risk_config
         self.risk_exclusions = risk_exclusions
         self.services = services
+        self.active_findings = active_findings
 
     def process(self):
         core_config = self.devops_platform_gateway.get_remote_config(
-            self.dict_args["remote_config_repo"], "engine_core/ConfigTool.json", self.dict_args["remote_config_branch"]
+            self.dict_args["remote_config_repo"],
+            "engine_core/ConfigTool.json",
+            self.dict_args["remote_config_branch"],
         )
         unique_tags = self._get_unique_tags()
         exclusions = []
@@ -35,14 +40,19 @@ class GetExclusions:
                     )
                 )
 
-        return exclusions
+        new_vuln_exclusions, len_new_vuln_exclusions = self._get_exclusions_new_vuln()
+        exclusions.extend(new_vuln_exclusions)
+
+        return exclusions, len_new_vuln_exclusions
 
     def _get_risk_exclusions(self):
         return self._get_exclusions(self.risk_exclusions, "RISK")
 
     def _get_exclusions_by_practice(self, core_config, practice, path):
         exclusions_config = self.devops_platform_gateway.get_remote_config(
-            self.dict_args["remote_config_repo"], path, self.dict_args["remote_config_branch"]
+            self.dict_args["remote_config_repo"],
+            path,
+            self.dict_args["remote_config_branch"],
         )
         tool = core_config[practice.upper()]["TOOL"]
         return self._get_exclusions(exclusions_config, tool)
@@ -69,3 +79,26 @@ class GetExclusions:
             tags = finding.tags
             unique_tags.update(tags)
         return list(unique_tags)
+
+    def _get_exclusions_new_vuln(self):
+        cutoff_date = datetime.now() - timedelta(days=5)
+        exclusions = []
+        for finding in self.active_findings:
+            if finding.publish_date:
+                try:
+                    finding_publish_date = datetime.strptime(
+                        finding.publish_date, "%Y-%m-%d"
+                    )
+                except ValueError:
+                    continue
+                if finding_publish_date >= cutoff_date and hasattr(finding, "id"):
+                    exclusion_data = finding.__dict__.copy()
+                    exclusion_data["create_date"] = finding_publish_date.strftime(
+                        "%d%m%Y"
+                    )
+                    exclusion_data["expired_date"] = (
+                        finding_publish_date + timedelta(days=5)
+                    ).strftime("%d%m%Y")
+                    exclusion_data["reason"] = "New vulnerability in the industry"
+                    exclusions.append(Exclusions(**exclusion_data))
+        return exclusions, len(exclusions)

{devsecops_engine_tools-1.40.1 → devsecops_engine_tools-1.42.0}/devsecops_engine_tools/engine_risk/src/domain/usecases/handle_filters.py

@@ -49,11 +49,13 @@ class HandleFilters:
     def filter_tags_days(self, devops_platform_gateway, remote_config, findings):
         tag_exclusion_days = remote_config["TAG_EXCLUSION_DAYS"]
         filtered_findings = []
+        filtered = 0
 
         for finding in findings:
             exclude = False
             for tag in finding.tags:
                 if tag in tag_exclusion_days and finding.age < tag_exclusion_days[tag]:
+                    filtered += 1
                     exclude = True
                     print(
                         devops_platform_gateway.message(
@@ -65,7 +67,7 @@ class HandleFilters:
             if not exclude:
                 filtered_findings.append(finding)
 
-        return filtered_findings
+        return filtered_findings, filtered
 
     def _get_active_findings(self, findings):
         return list(

{devsecops_engine_tools-1.40.1 → devsecops_engine_tools-1.42.0}/devsecops_engine_tools/engine_risk/src/infrastructure/entry_points/entry_point_risk.py

@@ -31,10 +31,14 @@ def init_engine_risk(
     vm_exclusions,
 ):
     remote_config = devops_platform_gateway.get_remote_config(
-        dict_args["remote_config_repo"], "engine_risk/ConfigTool.json", dict_args["remote_config_branch"]
+        dict_args["remote_config_repo"],
+        "engine_risk/ConfigTool.json",
+        dict_args["remote_config_branch"],
     )
     risk_exclusions = devops_platform_gateway.get_remote_config(
-        dict_args["remote_config_repo"], "engine_risk/Exclusions.json", dict_args["remote_config_branch"]
+        dict_args["remote_config_repo"],
+        "engine_risk/Exclusions.json",
+        dict_args["remote_config_branch"],
     )
     pipeline_name = devops_platform_gateway.get_variable("pipeline_name")
 
@@ -49,7 +53,7 @@ def init_engine_risk(
 
     unique_findings = handle_filters.filter_duplicated(active_findings)
 
-    filtered_findings = handle_filters.filter_tags_days(
+    filtered_findings, len_tag_filtered = handle_filters.filter_tags_days(
         devops_platform_gateway, remote_config, unique_findings
     )
 
@@ -62,8 +66,11 @@ def init_engine_risk(
         remote_config,
         risk_exclusions,
         services,
+        active_findings,
     )
-    exclusions = get_exclusions.process()
+    exclusions, len_new_vuln = get_exclusions.process()
+
+    policy_excluded = len_tag_filtered + len_new_vuln
 
     threshold = CheckThreshold(
         pipeline_name, remote_config["THRESHOLD"], risk_exclusions
@@ -78,6 +85,7 @@ def init_engine_risk(
         data_added,
         findings,
         threshold,
+        policy_excluded,
     )
 
     return break_build.process()

{devsecops_engine_tools-1.40.1 → devsecops_engine_tools-1.42.0}/devsecops_engine_tools/engine_utilities/defect_dojo/applications/defect_dojo.py

@@ -3,9 +3,6 @@ from devsecops_engine_tools.engine_utilities.utils.logger_info import MyLogger
 from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.import_scan import (
     ImportScanRestConsumer,
 )
-from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.reimport_scan import (
-    ReimportScanRestConsumer,
-)
 from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.product_type import (
     ProductTypeRestConsumer,
 )
@@ -51,16 +48,12 @@ class DefectDojo:
             rest_scan_configuration = ScanConfigrationRestConsumer(
                 request, session=SessionManager()
             )
-            rest_reimport_scan = ReimportScanRestConsumer(
-                request, session=SessionManager()
-            )
             uc = ImportScanUserCase(
                 rest_import_scan,
                 rest_product_type,
                 rest_product,
                 rest_scan_configuration,
                 rest_engagement=rest_engagement,
-                rest_reimport_scan=rest_reimport_scan
             )
             return uc.execute(request)
         except ApiError as e:

{devsecops_engine_tools-1.40.1 → devsecops_engine_tools-1.42.0}/devsecops_engine_tools/engine_utilities/defect_dojo/domain/models/finding.py

@@ -77,7 +77,7 @@ class Finding(FromDictMixin):
     sast_source_line = None
     sast_source_file_path = None
     nb_occurences = None
-    publish_date = None
+    publish_date: str = ""
     planned_remediation_date = None
     planned_remediation_version = None
     effort_for_fixing = None

{devsecops_engine_tools-1.40.1 → devsecops_engine_tools-1.42.0}/devsecops_engine_tools/engine_utilities/defect_dojo/domain/user_case/import_scan.py

@@ -5,7 +5,6 @@ from devsecops_engine_tools.engine_utilities.settings import SETTING_LOGGER
 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.infraestructure.driver_adapters.import_scan import ImportScanRestConsumer
-from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.reimport_scan import ReimportScanRestConsumer 
 from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.product_type import ProductTypeRestConsumer
 from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.product import ProductRestConsumer
 from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.scan_configurations import (
@@ -26,14 +25,12 @@ class ImportScanUserCase:
         rest_product: ProductRestConsumer,
         rest_scan_configuration: ScanConfigrationRestConsumer,
         rest_engagement: EngagementRestConsumer,
-        rest_reimport_scan: ReimportScanRestConsumer,
     ):
         self.__rest_import_scan = rest_import_scan
         self.__rest_product_type = rest_product_type
         self.__rest_product = rest_product
         self.__rest_scan_configurations = rest_scan_configuration
         self.__rest_engagement = rest_engagement
-        self.__rest_reimport_scan = rest_reimport_scan
 
 
     def get_file_type(self, path_file):
@@ -49,7 +46,6 @@ class ImportScanUserCase:
 
     def import_scan(self, request, api_scan_bool):
         response = None
-
         if api_scan_bool:
             response = self.__rest_import_scan.import_scan_api(request)
             logger.info(f"End process Succesfull!!!: {response}")
@@ -70,31 +66,6 @@ class ImportScanUserCase:
         response.url = f"{request.host_defect_dojo}/engagement/{str(response.engagement_id)}/finding/open"
         return response
     
-    def reimport_scan(self, request, api_scan_bool):
-        response = None
-
-        if api_scan_bool:
-            logger.debug(f"reimport scan :{self.__rest_reimport_scan}")
-            response = self.__rest_reimport_scan.reimport_scan(request)
-            logger.info(f"End process Succesfull!!!: {response}")
-        else:
-            try:
-                logger.debug(f"reimport scan file :{self.__rest_reimport_scan}")
-                file_type = self.get_file_type(request.file)
-                if file_type is None:
-                    raise ApiError("File format not allowed")
-
-                with open(request.file, "rb") as file:
-                    logger.info(f"read {file_type} file successful !!!")
-                    files = [("file", (request.file, file, file_type))]
-                    response = self.__rest_reimport_scan.reimport_scan(request, files)
-
-            except Exception as e:
-                raise ApiError(e)
-
-        response.url = f"{request.host_defect_dojo}/engagement/{str(response.engagement_id)}/finding/open"
-        return response
-
     def execute(self, request: ImportScanRequest) -> ImportScanRequest:
         product_id = None
 
@@ -162,8 +133,4 @@ class ImportScanUserCase:
                 engagement = self.__rest_engagement.post_engagement(request.engagement_name, product_id)
                 logger.debug(f"Egagement created: {engagement.name} whit product id {engagement.product}")
 
-        if request.reimport_scan is True:
-            logger.debug("reimport scan flow")
-            return self.reimport_scan(request, api_scan_bool)
-        else:
-            return self.import_scan(request, api_scan_bool)
+        return self.import_scan(request, api_scan_bool)

{devsecops_engine_tools-1.40.1 → devsecops_engine_tools-1.42.0}/devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/import_scan.py

@@ -16,7 +16,6 @@ class ImportScanRestConsumer:
         self.__session = session._instance
 
     def import_scan_api(self, request: ImportScanRequest) -> ImportScanRequest:
-        url = f"{self.__host}/api/v2/import-scan/"
         data = {
             "scan_date": request.scan_date,
             "minimum_severity": request.minimum_severity,
@@ -24,14 +23,12 @@ class ImportScanRestConsumer:
             "verified": request.verified,
             "scan_type": request.scan_type,
             "endpoint_to_add": request.endpoint_to_add,
-            # "file": request.file,
             "product_type_name": request.product_type_name,
             "product_name": request.product_name,
             "engagement_name": request.engagement_name,
             "engagement_end_date": request.engagement_end_date,
             "source_code_management_uri": request.source_code_management_uri,
             "engagement": str(request.engagement) if request.engagement != 0 else "",
-            "auto_create_context": "false",
             "deduplication_on_engagement": request.deduplication_on_engagement,
             "lead": request.lead,
             "tags": ",".join(request.tags) if request.tags else "",
@@ -49,6 +46,15 @@ class ImportScanRestConsumer:
             "service": request.service,
             "group_by": request.group_by,
         }
+
+        if request.reimport_scan:
+            url = f"{self.__host}/api/v2/reimport-scan/"
+            data["auto_create_context"] = "true"
+
+        else:
+            url = f"{self.__host}/api/v2/import-scan/"
+            data["auto_create_context"] = "false"
+
         multipart_data = MultipartEncoder(fields=data)
 
         headers = {"Authorization": f"Token {self.__token}", "Content-Type": multipart_data.content_type}
@@ -65,8 +71,7 @@ class ImportScanRestConsumer:
         return response
 
     def import_scan(self, request: ImportScanRequest, files) -> ImportScanRequest:
-        url = f"{self.__host}/api/v2/import-scan/"
-        payload = {
+        data = {
             "scan_date": request.scan_date,
             "minimum_severity": request.minimum_severity,
             "active": request.active,
@@ -80,7 +85,6 @@ class ImportScanRestConsumer:
             "engagement_end_date": request.engagement_end_date,
             "source_code_management_uri": request.source_code_management_uri,
             "engagement": request.engagement if request.engagement != 0 else "",
-            "auto_create_context": "false",
             "deduplication_on_engagement": request.deduplication_on_engagement,
             "lead": request.lead,
             "tags": request.tags,
@@ -98,12 +102,23 @@ class ImportScanRestConsumer:
             "service": request.service,
             "group_by": request.group_by,
         }
+        if request.reimport_scan is True:
+            url = f"{self.__host}/api/v2/reimport-scan/"
+            data["auto_create_context"] = "true"
+            data["test_title"] = request.test_title
+        else:
+            url = f"{self.__host}/api/v2/import-scan/"
+            data["auto_create_context"] = "false"
 
         headers = {"Authorization": f"Token {self.__token}"}
         try:
-            response = self.__session.post(url, headers=headers, data=payload, files=files, verify=VERIFY_CERTIFICATE)
+            response = self.__session.post(url,
+                                           headers=headers,
+                                           data=data,
+                                           files=files,
+                                           verify=VERIFY_CERTIFICATE)
             if response.status_code != 201:
-                logger.error(payload)
+                logger.error(data)
                 logger.error(response.json())
                 logger.error(response)
                 raise ApiError(response.json())

devsecops_engine_tools-1.42.0/devsecops_engine_tools/version.py

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

{devsecops_engine_tools-1.40.1 → devsecops_engine_tools-1.42.0}/devsecops_engine_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: devsecops-engine-tools
-Version: 1.40.1
+Version: 1.42.0
 Summary: Tool for DevSecOps strategy
 Home-page: https://github.com/bancolombia/devsecops-engine-tools
 Author: Bancolombia DevSecOps Team

{devsecops_engine_tools-1.40.1 → devsecops_engine_tools-1.42.0}/devsecops_engine_tools.egg-info/SOURCES.txt

@@ -306,7 +306,6 @@ devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapt
 devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/import_scan.py
 devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/product.py
 devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/product_type.py
-devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/reimport_scan.py
 devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/scan_configurations.py
 devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/settings/__init__.py
 devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/settings/settings.py

devsecops_engine_tools-1.40.1/devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/reimport_scan.py

@@ -1,74 +0,0 @@
-from devsecops_engine_tools.engine_utilities.utils.api_error import ApiError
-from devsecops_engine_tools.engine_utilities.defect_dojo.domain.request_objects.import_scan import ImportScanRequest
-from devsecops_engine_tools.engine_utilities.utils.logger_info import MyLogger
-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.settings import SETTING_LOGGER
-
-logger = MyLogger.__call__(**SETTING_LOGGER).get_logger()
-
-
-class ReimportScanRestConsumer:
-
-    def __init__(self, request: ImportScanRequest, session: SessionManager):
-        self.__token = request.token_defect_dojo
-        self.__host = request.host_defect_dojo
-        self.__session = session._instance
-
-    def reimport_scan(self, request: ImportScanRequest, files) -> ImportScanRequest:
-        url = f"{self.__host}/api/v2/reimport-scan/"
-        logger.debug(f"URL: {url}")
-        payload = {
-            "scan_date": request.scan_date,
-            "minimum_severity": request.minimum_severity,
-            "active": request.active,
-            "verified": request.verified,
-            "scan_type": request.scan_type,
-            "endpoint_to_add": request.endpoint_to_add,
-            "file": files,
-            "product_type_name": request.product_type_name,
-            "product_name": request.product_name,
-            "engagement_name": request.engagement_name,
-            "engagement_end_date": request.engagement_end_date,
-            "source_code_management_uri": request.source_code_management_uri,
-            "auto_create_context": "true",
-            "deduplication_on_engagement": request.deduplication_on_engagement,
-            "lead": request.lead,
-            "push_to_jira": request.push_to_jira,
-            "environment": request.environment,
-            "build_id": request.build_id,
-            "branch_tag": request.branch_tag,
-            "commit_hash": request.commit_hash,
-            "api_scan_configuration": str(request.api_scan_configuration)
-            if request.api_scan_configuration != 0
-            else "",
-            "service": request.service,
-            "group_by": request.group_by,
-            "create_finding_groups_for_all_findings": request.create_finding_groups_for_all_findings,
-            "do_not_reactive"
-            "scan_type": request.scan_type,
-            "close_old_findings": request.close_old_findings,
-            "close_old_findings_product_scope": request.close_old_findings_product_scope,
-            "version": request.version,
-            "tags": request.tags,
-            "test_title": request.test_title,
-        }
-
-        headers = {"Authorization": f"Token {self.__token}"}
-        try:
-            response = self.__session.post(
-                url,
-                headers=headers,
-                data=payload,
-                files=files,
-                verify=VERIFY_CERTIFICATE
-            )
-            if response.status_code != 201:
-                logger.error(response.json())
-                raise ApiError(response.json())
-            logger.info(f"Sucessfull {response}")
-            response = ImportScanRequest.from_dict(response.json())
-        except Exception as e:
-            logger.error(f"from dict import Scan: {response.json()}")
-            raise ApiError(e)
-        return response

devsecops_engine_tools-1.40.1/devsecops_engine_tools/version.py

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