From 9e4505ce01fdf8ae08ae5997e64e47c9c9096e0c Mon Sep 17 00:00:00 2001 From: Gabriel Broadwin Nongsiej Date: Thu, 17 Jul 2025 18:18:31 +0530 Subject: [PATCH 1/6] Fixes for MLE signature for Request for HTTP Signature --- .../core/MerchantConfiguration.py | 117 +++++++++++++--- authenticationsdk/util/Cache.py | 93 ++++++++++++- authenticationsdk/util/CertificateUtility.py | 131 ++++++++++++++++++ .../util/GlobalLabelParameters.py | 2 + authenticationsdk/util/MLEUtility.py | 131 ++++++++---------- 5 files changed, 372 insertions(+), 102 deletions(-) create mode 100644 authenticationsdk/util/CertificateUtility.py diff --git a/authenticationsdk/core/MerchantConfiguration.py b/authenticationsdk/core/MerchantConfiguration.py index 202bab91..f9dc974d 100644 --- a/authenticationsdk/core/MerchantConfiguration.py +++ b/authenticationsdk/core/MerchantConfiguration.py @@ -1,4 +1,6 @@ +import copy from CyberSource.logging.log_configuration import LogConfiguration +from authenticationsdk.util.CertificateUtility import CertificateUtility from authenticationsdk.util.GlobalLabelParameters import * from wsgiref.handlers import format_date_time from datetime import datetime @@ -52,9 +54,12 @@ def __init__(self): self.__jwePEMFileDirectory = None self.useMLEGlobally = None self.mapToControlMLEonAPI = None - self.mleKeyAlias = None + self.mleKeyAlias = None + self.mleForRequestPublicCertPath = None + self.p12KeyFilePath = None self.logger = LogFactory.setup_logger(self.__class__.__name__) +#region Getters and Setters def set_merchant_keyid(self, value): if not (value.get('merchant_keyid') is None): self.merchant_keyid = value['merchant_keyid'] @@ -88,7 +93,7 @@ def set_use_metakey(self, value): self.use_metakey = value['use_metakey'] else: self.use_metakey = False - + def set_portfolio_id(self, value): if not (value.get('portfolio_id') is None): self.portfolio_id = value['portfolio_id'] @@ -138,7 +143,7 @@ def set_enable_client_cert(self, value): self.enable_client_cert = value['enable_client_cert'] else: self.enable_client_cert = False - + def set_client_cert_dir(self, value): if not (value.get('client_cert_dir') is None): self.client_cert_dir = value['client_cert_dir'] @@ -183,7 +188,7 @@ def set_jwePEMFileDirectory(self, value): def get_jwePEMFileDirectory(self): return self.__jwePEMFileDirectory - + def set_useMLEGlobally(self, value): if not (value.get('useMLEGlobally') is None): self.useMLEGlobally = value['useMLEGlobally'] @@ -192,7 +197,7 @@ def set_useMLEGlobally(self, value): def get_useMLEGlobally(self): return self.useMLEGlobally - + def set_mapToControlMLEonAPI(self, value): map_to_control_mle_on_api = value.get('mapToControlMLEonAPI') if map_to_control_mle_on_api is not None: @@ -203,7 +208,7 @@ def set_mapToControlMLEonAPI(self, value): def get_mapToControlMLEonAPI(self): return self.mapToControlMLEonAPI - + def set_mleKeyAlias(self, value): if value.get('mleKeyAlias') is not None and value.get('mleKeyAlias').strip(): self.mleKeyAlias = value['mleKeyAlias'].strip() @@ -213,6 +218,25 @@ def set_mleKeyAlias(self, value): def get_mleKeyAlias(self): return self.mleKeyAlias + def set_mleForRequestPublicCertPath(self, value): + if value.get('mleForRequestPublicCertPath') is not None and value.get('mleForRequestPublicCertPath').strip(): + self.mleForRequestPublicCertPath = value['mleForRequestPublicCertPath'].strip() + else: + self.mleForRequestPublicCertPath = None + + def get_mleForRequestPublicCertPath(self): + return self.mleForRequestPublicCertPath + + def set_p12KeyFilePath(self, value): + if value.get('p12KeyFilePath') is not None and value.get('p12KeyFilePath').strip(): + self.p12KeyFilePath = value['p12KeyFilePath'].strip() + else: + self.p12KeyFilePath = None + + def get_p12KeyFilePath(self): + return self.p12KeyFilePath + +#endregion # This method sets the Merchant Configuration Variables to its respective values after reading from cybs.properties def set_merchantconfig(self, val): @@ -247,6 +271,7 @@ def set_merchantconfig(self, val): self.set_jwePEMFileDirectory(val) self.set_useMLEGlobally(val) self.set_mapToControlMLEonAPI(val) + self.set_mleForRequestPublicCertPath(val) self.set_mleKeyAlias(val) # Returns the time in format as defined by RFC7231 @@ -281,12 +306,12 @@ def validate_merchant_details(self, details, mconfig = None): authenticationsdk.util.ExceptionAuth.validate_merchant_details_log(self.logger, GlobalLabelParameters.CLIENT_CERT_DIR_EMPTY, self.log_config) - + if self.ssl_client_cert is None or self.ssl_client_cert == "": authenticationsdk.util.ExceptionAuth.validate_merchant_details_log(self.logger, GlobalLabelParameters.SSL_CLIENT_CERT_EMPTY, self.log_config) - + if self.private_key is None or self.private_key == "": authenticationsdk.util.ExceptionAuth.validate_merchant_details_log(self.logger, GlobalLabelParameters.PRIVATE_KEY_EMPTY, @@ -302,7 +327,7 @@ def validate_merchant_details(self, details, mconfig = None): authenticationsdk.util.ExceptionAuth.validate_merchant_details_log(self.logger, GlobalLabelParameters.MERCHANTID_REQ, self.log_config) - + if self.merchant_keyid is None or self.merchant_keyid == "": authenticationsdk.util.ExceptionAuth.validate_merchant_details_log(self.logger, GlobalLabelParameters.MERCHANT_KEY_ID_REQ, @@ -318,7 +343,7 @@ def validate_merchant_details(self, details, mconfig = None): authenticationsdk.util.ExceptionAuth.validate_merchant_details_log(self.logger, GlobalLabelParameters.MERCHANTID_REQ, self.log_config) - + if self.key_alias is None or self.key_alias == "": self.key_alias = self.merchant_id authenticationsdk.util.ExceptionAuth.validate_default_values(self.logger, @@ -349,23 +374,26 @@ def validate_merchant_details(self, details, mconfig = None): GlobalLabelParameters.KEY_FILE_EMPTY, self.log_config) - elif self.authentication_type.lower() == GlobalLabelParameters.OAUTH.lower(): + if not self.check_key_file(): + authenticationsdk.util.ExceptionAuth.log_exception(self.logger, f"Error finding or accessing the Key Directory or Key File. Please review the values in the merchant configuration.", self.log_config) + + elif self.authentication_type.lower() == GlobalLabelParameters.OAUTH.lower(): if self.access_token is None or self.access_token == "": authenticationsdk.util.ExceptionAuth.validate_merchant_details_log(self.logger, GlobalLabelParameters.ACCESS_TOKEN_EMPTY, self.log_config) - + if self.ssl_client_cert is None or self.ssl_client_cert == "": authenticationsdk.util.ExceptionAuth.validate_merchant_details_log(self.logger, GlobalLabelParameters.REFRESH_TOKEN_EMPTY, self.log_config) - - elif self.authentication_type.lower() == GlobalLabelParameters.MUTUAL_AUTH.lower(): + + elif self.authentication_type.lower() == GlobalLabelParameters.MUTUAL_AUTH.lower(): if self.client_id is None or self.client_id == "": authenticationsdk.util.ExceptionAuth.validate_merchant_details_log(self.logger, GlobalLabelParameters.CLIENT_ID_EMPTY, self.log_config) - + if self.client_secret is None or self.client_secret == "": authenticationsdk.util.ExceptionAuth.validate_merchant_details_log(self.logger, GlobalLabelParameters.CLIENT_SECRET_EMPTY, @@ -374,6 +402,7 @@ def validate_merchant_details(self, details, mconfig = None): authenticationsdk.util.ExceptionAuth.validate_merchant_details_log(self.logger, GlobalLabelParameters.AUTH_ERROR, self.log_config) + # useMLEGlobally check for auth Type if self.useMLEGlobally is True or self.mapToControlMLEonAPI is not None: if self.useMLEGlobally is True and self.authentication_type.lower() != GlobalLabelParameters.JWT.lower(): @@ -388,14 +417,58 @@ def validate_merchant_details(self, details, mconfig = None): GlobalLabelParameters.MLE_AUTH_ERROR, self.log_config) + self.validate_MLE_configuration() + self.p12KeyFilePath = os.path.join(self.key_file_path, self.key_file_name) + GlobalLabelParameters.P12_PREFIX + log_items = GlobalLabelParameters.HIDE_MERCHANT_CONFIG_PROPS # This displays the logic for logging all cybs.json values + details_copy = copy.deepcopy(details) if self.log_config.enable_log is True: - for key, value in list(details.items()): + for key, value in list(details_copy.items()): if key in log_items: - del details[key] - - for keys, values in list(details.items()): - details[keys] = str(values) - - self.logger.info("Mconfig > " + str(ast.literal_eval(json.dumps(details)))) + del details_copy[key] + + for keys, values in list(details_copy.items()): + details_copy[keys] = str(values) + + self.logger.info("Mconfig > " + str(ast.literal_eval(json.dumps(details_copy)))) + + def check_key_file(self): + if not(self.key_file_name and self.key_file_name.strip()): + self.logger.error("Key Filename not provided. Assigning the value of Merchant ID") + if self.merchant_id and self.merchant_id.strip(): + self.key_file_name = self.merchant_id + + if not(self.key_file_path and self.key_file_path.strip()): + self.key_file_path = GlobalLabelParameters.DEFAULT_KEY_FILE_PATH + self.logger.error(f"Keys Directory not provided. Using Default Path: {self.key_file_path}") + + # Directory exists? + if not os.path.isdir(self.key_file_path): + self.logger.error(f"Keys Directory not found. Entered directory : {self.key_file_path}") + return False + + keyFilePath = os.path.join(self.key_file_path, self.key_file_name) + GlobalLabelParameters.P12_PREFIX + + # File exists? + if not os.path.isfile(keyFilePath): + self.logger.error(f"Key File not found. Check path/filename entered. Entered path/filename : {keyFilePath}") + return False + + self.logger.info(f"Entered value for Key File Path : {keyFilePath}") + + # Can file be opened for reading? + try: + with open(keyFilePath, 'rb'): + return True + except Exception: + self.logger.info(f"File cannot be accessed. Permission denied : {keyFilePath}") + return False + + def validate_MLE_configuration(self): + if self.mleForRequestPublicCertPath and self.mleForRequestPublicCertPath.strip(): + try: + CertificateUtility.validate_path_and_file(self.mleForRequestPublicCertPath, "mleForRequestPublicCertPath", self.log_config) + except Exception as err: + self.logger.error(err) + raise err diff --git a/authenticationsdk/util/Cache.py b/authenticationsdk/util/Cache.py index 37e4620a..6425e07c 100644 --- a/authenticationsdk/util/Cache.py +++ b/authenticationsdk/util/Cache.py @@ -2,7 +2,6 @@ import ssl from jwcrypto import jwk -from cryptography import x509 from cryptography.hazmat.primitives import serialization from cryptography.hazmat.backends import default_backend @@ -10,12 +9,19 @@ from typing_extensions import deprecated +from authenticationsdk.util.CertificateUtility import CertificateUtility from authenticationsdk.util.GlobalLabelParameters import * +import CyberSource.logging.log_factory as LogFactory +import threading +class CertInfo: + def __init__(self, mle_certificate, timestamp): + self.MLECertificate = mle_certificate + self.Timestamp = timestamp class FileCache: - _instance = None + logger = None def __new__(cls, *args, **kwargs): if not cls._instance: @@ -27,6 +33,8 @@ def __new__(cls, *args, **kwargs): def _initialize_cache(self): # Your cache initialization code here self.filecache = {} + self.mlecache = {} + self._cache_lock = threading.RLock() @deprecated("This method has been marked as Deprecated and will be removed in coming releases.") def get_private_key_from_pem(self, pem_file_path): @@ -34,14 +42,14 @@ def get_private_key_from_pem(self, pem_file_path): cert = pem_file.read() private_key = jwk.JWK.from_pem(cert.encode('utf-8')) return private_key - + def load_certificates(self, filepath, filename, password): return pkcs12.load_key_and_certificates( open(os.path.join(filepath, filename) + GlobalLabelParameters.P12_PREFIX, 'rb').read(), password=password.encode(), backend=default_backend() ) - + def get_cert_based_on_key_alias(self, certificate, additional_certificates, key_alias): target_cert = None @@ -67,7 +75,6 @@ def get_cert_based_on_key_alias(self, certificate, additional_certificates, key_ return target_cert - def update_cache(self, mconfig, filepath, filename): file_mod_time = os.stat(os.path.join(filepath, filename) + GlobalLabelParameters.P12_PREFIX).st_mtime private_key, certificate, additional_certificates = self.load_certificates(filepath, filename, mconfig.key_password) @@ -94,3 +101,79 @@ def get_cached_private_key_from_pem(self, file_path, cache_key): private_key = self.get_private_key_from_pem(file_path) self.filecache[str(cache_key)] = [private_key, file_mod_time] return self.filecache[str(cache_key)][0] + + def get_request_mle_cert_from_cache(self, merchant_config): + if FileCache.logger is None: + FileCache.logger = LogFactory.setup_logger(__name__, merchant_config.log_config) + logger = FileCache.logger + + merchant_id = merchant_config.merchant_id + certificate_identifier = None + certificate_file_path = None + + # Priority #1: Get cert from merchantConfig.mle_for_request_public_cert_path if certPath is provided + if merchant_config.mleForRequestPublicCertPath and merchant_config.mleForRequestPublicCertPath.strip(): + certificate_identifier = GlobalLabelParameters.MLE_CACHE_IDENTIFIER_FOR_CONFIG_CERT + certificate_file_path = merchant_config.mleForRequestPublicCertPath + # Priority #2: If mle_for_request_public_cert_path not provided, get mlecert from p12 if provided and jwt auth type + elif (GlobalLabelParameters.JWT.lower() == merchant_config.authentication_type.lower() and merchant_config.p12KeyFilePath): + certificate_identifier = GlobalLabelParameters.MLE_CACHE_IDENTIFIER_FOR_P12_CERT + certificate_file_path = merchant_config.p12KeyFilePath + # Priority #3: Get mlecert from default cert in SDK as per CAS or PROD env. + else: + logger.debug("The certificate to use for MLE for requests is not provided in the merchant configuration. Please ensure that the certificate path is provided.") + return None + + cache_key = f"{merchant_id}_{certificate_identifier}" + mle_certificate = self.get_mle_cert_based_on_cache_key(merchant_config, cache_key, certificate_file_path) + + CertificateUtility.validate_certificate_expiry(mle_certificate, merchant_config.key_alias, certificate_identifier, merchant_config.log_config) + + return mle_certificate + + def get_mle_cert_based_on_cache_key(self, merchant_config, cache_key, certificate_file_path): + with self._cache_lock: + cert_info = self.mlecache.get(cache_key) + + file_timestamp = os.path.getmtime(certificate_file_path) + if cert_info is None or cert_info.Timestamp != file_timestamp: + self.setup_mle_cache(merchant_config, cache_key, certificate_file_path) + cert_info = self.mlecache.get(cache_key) + + return cert_info.MLECertificate if cert_info else None + + def setup_mle_cache(self, merchant_config, cache_key, certificate_file_path): + if FileCache.logger is None: + FileCache.logger = LogFactory.setup_logger(__name__, merchant_config.log_config) + logger = FileCache.logger + + mle_certificate = None + + # Handle PEM certificate case + if cache_key.endswith(GlobalLabelParameters.MLE_CACHE_IDENTIFIER_FOR_CONFIG_CERT): + certificates = CertificateUtility.load_certificates_from_pem_file(certificate_file_path) + try: + mle_certificate = CertificateUtility.get_cert_based_on_key_alias(certificates, merchant_config.mleKeyAlias) + except Exception: + if mle_certificate is None: + file_name = os.path.basename(certificate_file_path) + logger.warning(f"No certificate found for the specified mle_key_alias '{merchant_config.mleKeyAlias}'. Using the first certificate from file {file_name} as the MLE request certificate.") + mle_certificate = certificates[0] # Take first certificate + + # Handle P12 certificate case + if cache_key.endswith(GlobalLabelParameters.MLE_CACHE_IDENTIFIER_FOR_P12_CERT): + try: + certificates = CertificateUtility.fetch_certificate_collection_from_p12_file(merchant_config.p12KeyFilePath, merchant_config.key_password) + mle_certificate = CertificateUtility.get_cert_based_on_key_alias(certificates, merchant_config.mleKeyAlias) + except Exception: + file_name = os.path.basename(merchant_config.p12KeyFilePath) + logger.error(f"No certificate found for the specified mle_key_alias '{merchant_config.mleKeyAlias}' in file {file_name}.") + raise ValueError(f"No certificate found for the specified mle_key_alias '{merchant_config.mleKeyAlias}' in file {file_name}.") + + # Save to cache (thread-safe) + cert_info = CertInfo( + mle_certificate, + os.path.getmtime(certificate_file_path) + ) + with self._cache_lock: + self.mlecache[cache_key] = cert_info \ No newline at end of file diff --git a/authenticationsdk/util/CertificateUtility.py b/authenticationsdk/util/CertificateUtility.py new file mode 100644 index 00000000..8934dff1 --- /dev/null +++ b/authenticationsdk/util/CertificateUtility.py @@ -0,0 +1,131 @@ +import os +import re +from datetime import datetime, timezone +from cryptography import x509 +from cryptography.hazmat.backends import default_backend +from cryptography.x509.oid import NameOID +from authenticationsdk.util.GlobalLabelParameters import GlobalLabelParameters +import CyberSource.logging.log_factory as LogFactory +from CyberSource.logging.log_configuration import LogConfiguration +from cryptography.hazmat.primitives.serialization import pkcs12 + +class CertificateUtility: + logger = None + + @staticmethod + def validate_path_and_file(file_path, path_type, log_config): + if CertificateUtility.logger is None: + CertificateUtility.logger = LogFactory.setup_logger(__name__, log_config) + logger = CertificateUtility.logger + + if not file_path or not file_path.strip(): + logger.error(f"{path_type} path cannot be null or empty.") + raise ValueError(f"{path_type} path cannot be null or empty.") + + # Normalize Windows-style paths that start with a slash before the drive letter + normalized_path = file_path + if os.sep == '\\' and re.match(r'^/[A-Za-z]:.*', normalized_path): + normalized_path = normalized_path[1:] + + path = normalized_path + + if not os.path.exists(path): + logger.error(f"{path_type} does not exist: {path}") + raise IOError(f"{path_type} does not exist: {path}") + + if os.path.isdir(path): + logger.error(f"{path_type} does not have valid file: {path}") + raise IOError(f"{path_type} does not have valid file: {path}") + + try: + with open(path, "rb"): + return path + except Exception: + logger.error(f"{path_type} is not readable: {path}") + raise IOError(f"{path_type} is not readable: {path}") + + @staticmethod + def validate_certificate_expiry(certificate, key_alias, mle_cache_key_identifier, log_config): + if CertificateUtility.logger is None: + CertificateUtility.logger = LogFactory.setup_logger(__name__, log_config) + logger = CertificateUtility.logger + + warning_message_for_no_expiry_date = "Certificate does not have expiry date" + warning_message_for_certificate_expiring_soon = "Certificate with alias {} is going to expire on {}. Please update the certificate before then." + warning_message_for_expired_certificate = "Certificate with alias {} is expired as of {}. Please update the certificate." + + if GlobalLabelParameters.MLE_CACHE_IDENTIFIER_FOR_CONFIG_CERT == mle_cache_key_identifier: + warning_message_for_no_expiry_date = "Certificate for MLE Requests does not have expiry date from mleForRequestPublicCertPath in merchant configuration." + warning_message_for_certificate_expiring_soon = "Certificate for MLE Requests with alias {} is going to expire on {}. Please update the certificate provided in mleForRequestPublicCertPath in merchant configuration before then." + warning_message_for_expired_certificate = "Certificate for MLE Requests with alias {} is expired as of {}. Please update the certificate provided in mleForRequestPublicCertPath in merchant configuration." + + if GlobalLabelParameters.MLE_CACHE_IDENTIFIER_FOR_P12_CERT == mle_cache_key_identifier: + warning_message_for_no_expiry_date = "Certificate for MLE Requests does not have expiry date in the P12 file." + warning_message_for_certificate_expiring_soon = "Certificate for MLE Requests with alias {} is going to expire on {}. Please update the P12 file before then." + warning_message_for_expired_certificate = "Certificate for MLE Requests with alias {} is expired as of {}. Please update the P12 file." + + # cryptography.x509.Certificate uses .not_valid_after for the expiry date, returns a datetime object + not_after = certificate.not_valid_after_utc + if not_after is None: + logger.warning(warning_message_for_no_expiry_date) + else: + now = datetime.now(timezone.utc) + if not_after < now: + logger.warning(warning_message_for_expired_certificate.format(key_alias, not_after)) + else: + time_to_expire = not_after - now + if time_to_expire.days < GlobalLabelParameters.CERTIFICATE_EXPIRY_DATE_WARNING_DAYS: + logger.warning(warning_message_for_certificate_expiring_soon.format(key_alias, not_after)) + + @staticmethod + def load_certificates_from_pem_file(certificate_file_path): + """ + Load all certificates from a PEM file and return as a list of cryptography.x509.Certificate objects. + """ + certificates = [] + with open(certificate_file_path, 'rb') as f: + pem_data = f.read() + + # Split the file into individual PEM certificates + for cert in pem_data.split(b'-----END CERTIFICATE-----'): + if b'-----BEGIN CERTIFICATE-----' in cert: + cert_block = cert + b'-----END CERTIFICATE-----' + certificate = x509.load_pem_x509_certificate(cert_block, default_backend()) + certificates.append(certificate) + return certificates + + @staticmethod + def get_cert_based_on_key_alias(certs, key_alias): + for cert in certs: + # Extract the Common Name (CN) from the certificate subject + common_names = cert.subject.get_attributes_for_oid(NameOID.COMMON_NAME) + if common_names: + cn = common_names[0].value + if cn.lower() == key_alias.lower(): + return cert + raise Exception(f"ERROR : Certificate with alias {key_alias} not found.") + + @staticmethod + def fetch_certificate_collection_from_p12_file(p12_file_path, key_password): + """ + Loads all certificates from a PKCS#12 (.p12/.pfx) file. + + Returns: + List of cryptography.x509.Certificate objects. + """ + with open(p12_file_path, "rb") as f: + p12_data = f.read() + + # key_password should be bytes or None + if key_password is not None: + key_password_bytes = key_password.encode() + else: + key_password_bytes = None + + private_key, cert, additional_certs = pkcs12.load_key_and_certificates(p12_data, key_password_bytes) + certs = [] + if cert is not None: + certs.append(cert) + if additional_certs is not None: + certs.extend(additional_certs) + return certs diff --git a/authenticationsdk/util/GlobalLabelParameters.py b/authenticationsdk/util/GlobalLabelParameters.py index 568958b0..fd80faac 100644 --- a/authenticationsdk/util/GlobalLabelParameters.py +++ b/authenticationsdk/util/GlobalLabelParameters.py @@ -97,3 +97,5 @@ class GlobalLabelParameters: CERTIFICATE_EXPIRY_DATE_WARNING_DAYS = 90 MESSAGE_BEFORE_MLE_REQUEST = "Request before MLE: " MESSAGE_AFTER_MLE_REQUEST = "Request after MLE: " + MLE_CACHE_IDENTIFIER_FOR_CONFIG_CERT = "mleCertFromMerchantConfig" + MLE_CACHE_IDENTIFIER_FOR_P12_CERT = "mleCertFromP12" diff --git a/authenticationsdk/util/MLEUtility.py b/authenticationsdk/util/MLEUtility.py index 45e72a3e..10258640 100644 --- a/authenticationsdk/util/MLEUtility.py +++ b/authenticationsdk/util/MLEUtility.py @@ -1,15 +1,17 @@ import json import time -from datetime import datetime, timezone -from cryptography import x509 -from jwcrypto import jwk, jwe +from cryptography.hazmat.primitives import serialization +from cryptography.x509.oid import NameOID +from jwcrypto import jwe, jwk from authenticationsdk.util.Cache import FileCache from authenticationsdk.util.GlobalLabelParameters import GlobalLabelParameters import CyberSource.logging.log_factory as LogFactory class MLEUtility: + logger = None + class MLEException(Exception): def __init__(self, message, errors=None): super().__init__(message) @@ -17,7 +19,6 @@ def __init__(self, message, errors=None): @staticmethod def check_is_mle_for_api(merchant_config, is_mle_supported_by_cybs_for_api, operation_ids): - is_mle_for_api = False if is_mle_supported_by_cybs_for_api and merchant_config.get_useMLEGlobally(): is_mle_for_api = True @@ -32,101 +33,81 @@ def check_is_mle_for_api(merchant_config, is_mle_supported_by_cybs_for_api, oper @staticmethod def encrypt_request_payload(merchant_config, request_body): - if request_body is None or request_body == "": - return request_body + if MLEUtility.logger is None: + MLEUtility.logger = LogFactory.setup_logger(__name__, merchant_config.log_config) + logger = MLEUtility.logger - logger = LogFactory.setup_logger(__name__, merchant_config.log_config) - - if merchant_config.log_config.enable_log: - logger.debug(f"{GlobalLabelParameters.MESSAGE_BEFORE_MLE_REQUEST}{request_body}") + if request_body is None: + return None - cert = MLEUtility.get_mle_certificate(merchant_config, logger) + payload = str(request_body) + logger.debug(GlobalLabelParameters.MESSAGE_BEFORE_MLE_REQUEST + ' ' + payload) - try: - serialized_jwe_token = MLEUtility.generate_token(cert, request_body, merchant_config.log_config, logger) - mleRequest = MLEUtility.create_json_object(serialized_jwe_token) - if merchant_config.log_config.enable_log: - logger.debug(f"{GlobalLabelParameters.MESSAGE_AFTER_MLE_REQUEST}{mleRequest}") - return mleRequest + mle_certificate = MLEUtility.get_mle_certificate(merchant_config) - except Exception as e: - if merchant_config.log_config.enable_log: - logger.error(f"Error encrypting request payload.") - raise MLEUtility.MLEException(f"Error encrypting request payload.") + # Special case: MLE Certificate is not currently available for HTTP Signature + if (mle_certificate is None and merchant_config.authentication_type.lower() == GlobalLabelParameters.HTTP.lower()): + logger.debug("The certificate to use for MLE for requests is not provided in the merchant configuration. Please ensure that the certificate path is provided.") + logger.debug("Currently, MLE for requests using HTTP Signature as authentication is not supported by Cybersource. By default, the SDK will fall back to non-encrypted requests.") + return request_body - @staticmethod - def generate_token(cert, request_body, log_config, logger): - public_key = cert.public_key() - serial_number = MLEUtility.extract_serial_number(cert, log_config, logger) + serial_number = MLEUtility.get_serial_number_from_certificate(mle_certificate, merchant_config) + payload_bytes = payload.encode('utf-8') + + # Extract the public RSA key from the certificate + public_key = mle_certificate.public_key() # cryptography.x509.Certificate object - jwk_key = jwk.JWK.from_pyca(public_key) - payload = request_body.encode('utf-8') + # Convert public key to jwk + rsa_pem = public_key.public_bytes(encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo) + jwk_key = jwk.JWK.from_pem(rsa_pem) - header = { + # Prepare JWE headers + headers = { "alg": "RSA-OAEP-256", "enc": "A256GCM", - "cty": "JWT", "kid": serial_number, "iat": int(time.time()) } - jwe_token = jwe.JWE(plaintext=payload, protected=json.dumps(header)) + # Create the JWE object and encrypt + jwe_token = jwe.JWE(plaintext=payload_bytes, protected=json.dumps(headers)) jwe_token.add_recipient(jwk_key) - return jwe_token.serialize(compact=True) + mle_request = MLEUtility.create_json_object(jwe_token.serialize(compact=True)) + logger.debug(GlobalLabelParameters.MESSAGE_AFTER_MLE_REQUEST + ' ' + str(mle_request)) + + return mle_request @staticmethod - def get_mle_certificate(merchant_config, logger): + def get_mle_certificate(merchant_config): cache_obj = FileCache() - try: - cert_data = cache_obj.grab_file(merchant_config, merchant_config.key_file_path, merchant_config.key_file_name) - mle_certificate_x509 = cert_data[3] - if mle_certificate_x509 is not None: - MLEUtility.validate_certificate_expiry(mle_certificate_x509, merchant_config.get_mleKeyAlias(), merchant_config.log_config, logger) - return mle_certificate_x509 - else: - if merchant_config.log_config.enable_log: - logger.error(f"No certificate found for MLE for given mleKeyAlias {merchant_config.get_mleKeyAlias()} in p12 file {merchant_config.key_file_name}.p12") - raise MLEUtility.MLEException(f"No certificate found for MLE for given mleKeyAlias {merchant_config.get_mleKeyAlias()} in p12 file {merchant_config.key_file_name}.p12") - except KeyError: - if merchant_config.log_config.enable_log: - logger.error(f"No certificate found for MLE for given mleKeyAlias {merchant_config.get_mleKeyAlias()} in p12 file {merchant_config.key_file_name}.p12") - raise MLEUtility.MLEException(f"No certificate found for MLE for given mleKeyAlias {merchant_config.get_mleKeyAlias()} in p12 file {merchant_config.key_file_name}.p12") - except Exception as e: - if merchant_config.log_config.enable_log: - logger.error(f"Unable to load certificate: {str(e)}") - raise MLEUtility.MLEException(f"Unable to load PEM file: {str(e)}") + mle_certificate = cache_obj.get_request_mle_cert_from_cache(merchant_config) + return mle_certificate @staticmethod - def extract_serial_number(x509_certificate, log_config, logger): - serial_number = None + def get_serial_number_from_certificate(certificate, merchant_config): + if MLEUtility.logger is None: + MLEUtility.logger = LogFactory.setup_logger(__name__, merchant_config.log_config) + logger = MLEUtility.logger + + if certificate is None: + raise ValueError("MLE certificate is null") - for attribute in x509_certificate.subject: - if attribute.oid == x509.NameOID.SERIAL_NUMBER: + # Get subject and look for 'serialNumber' + subject = certificate.subject + serial_number = None + for attribute in subject: + if attribute.oid == NameOID.SERIAL_NUMBER: serial_number = attribute.value break - if serial_number is None: - if log_config.enable_log: - logger.warning("Serial number not found in MLE certificate for alias.") - serial_number = str(x509_certificate.serial_number) + + if not serial_number: + logger.warning(f"Serial number not found in MLE certificate for alias {merchant_config.mle_key_alias} in {merchant_config.p12_keyfilepath}.p12") + # Use the hex serial number from the certificate as fallback + return format(certificate.serial_number, 'x') + return serial_number @staticmethod def create_json_object(jwe_token): - return json.dumps({"encryptedRequest": jwe_token}) - - @staticmethod - def validate_certificate_expiry(certificate, key_alias, log_config, logger): - try: - if certificate.not_valid_after_utc < datetime.now(timezone.utc): - if log_config.enable_log: - logger.warning(f"Certificate with MLE alias {key_alias} is expired as of {certificate.not_valid_after_utc}. Please update p12 file.") - # raise Exception(f"Certificate with MLE alias {key_alias} is expired.") - else: - time_to_expire = (certificate.not_valid_after_utc - datetime.now(timezone.utc)).total_seconds() - if time_to_expire < GlobalLabelParameters.CERTIFICATE_EXPIRY_DATE_WARNING_DAYS * 24 * 60 * 60: - if log_config.enable_log: - logger.warning(f"Certificate for MLE with alias {key_alias} is going to expire on {certificate.not_valid_after_utc}. Please update p12 file before that.") - except Exception as e: - if log_config.enable_log: - logger.error(f"Error while checking certificate expiry: {str(e)}") \ No newline at end of file + return json.dumps({"encryptedRequest": jwe_token}) \ No newline at end of file From 92b053e54546e52720c840e778f884423fe97fb4 Mon Sep 17 00:00:00 2001 From: gnongsie Date: Tue, 22 Jul 2025 16:01:31 +0530 Subject: [PATCH 2/6] Fixes for thread safety --- authenticationsdk/core/Authorization.py | 1 - authenticationsdk/jwt/Token.py | 118 +++---------------- authenticationsdk/util/Cache.py | 106 ++++++++--------- authenticationsdk/util/CertificateUtility.py | 2 +- 4 files changed, 64 insertions(+), 163 deletions(-) diff --git a/authenticationsdk/core/Authorization.py b/authenticationsdk/core/Authorization.py index 1e49b1ab..e3ceb301 100644 --- a/authenticationsdk/core/Authorization.py +++ b/authenticationsdk/core/Authorization.py @@ -45,7 +45,6 @@ def get_token(self, mconfig, date_time, logger = None): return sig_token # JWT-Call elif authentication_type.upper() == GlobalLabelParameters.JWT.upper(): - jwt_sig_token = JwtSignatureToken() jwt_sig_token.jwt_signature_token(mconfig, date_time) sig_token_jwt = jwt_sig_token.get_token() diff --git a/authenticationsdk/jwt/Token.py b/authenticationsdk/jwt/Token.py index 070ac7a2..c4325d8e 100644 --- a/authenticationsdk/jwt/Token.py +++ b/authenticationsdk/jwt/Token.py @@ -23,33 +23,24 @@ def get_token(self): def set_token(self): token = "" - if self.jwt_method.upper() == GlobalLabelParameters.GET: - token = self.token_for_get() - elif self.jwt_method.upper() == GlobalLabelParameters.POST: - token = self.token_for_post() - elif self.jwt_method.upper() == GlobalLabelParameters.PUT: - token = self.token_for_put() - elif self.jwt_method.upper() == GlobalLabelParameters.DELETE: - token = self.token_for_delete() - elif self.jwt_method.upper() == GlobalLabelParameters.PATCH: - token = self.token_for_patch() + if self.jwt_method.upper() == GlobalLabelParameters.GET or self.jwt_method.upper() == GlobalLabelParameters.DELETE: + token = self.token_for_get_and_delete() + elif self.jwt_method.upper() == GlobalLabelParameters.POST or self.jwt_method.upper() == GlobalLabelParameters.PUT or self.jwt_method.upper() == GlobalLabelParameters.PATCH: + token = self.token_for_post_and_put_and_patch() return token # This function has the logic to generate token when the Jwt_method is get - def token_for_get(self): - + def token_for_get_and_delete(self): # Setting the jwt body for JWT-get jwt_body = {GlobalLabelParameters.JWT_TIME: self.date} # reading the p12 file from cache memory cache_obj = FileCache() - cache_memory = cache_obj.grab_file(self.merchant_config, self.merchant_config.key_file_path, - self.merchant_config.key_file_name) - der_cert_string = cache_memory[0] - private_key = cache_memory[1] + cache_memory = cache_obj.fetch_cached_certificate(self.merchant_config, self.merchant_config.p12KeyFilePath, self.merchant_config.key_password) + der_cert_string = cache_memory.certificate + private_key = cache_memory.private_key # setting the headers -merchant_id and the public key - headers_jwt = { - GlobalLabelParameters.MERCHANT_ID: str(self.merchant_config.key_alias)} + headers_jwt = {GlobalLabelParameters.MERCHANT_ID: str(self.merchant_config.key_alias)} public_key_list = ([]) public_key_list.append(der_cert_string.decode("utf-8")) public_key_headers = {GlobalLabelParameters.PUBLIC_KEY: public_key_list} @@ -61,99 +52,20 @@ def token_for_get(self): return encoded_jwt - def token_for_post(self): - + def token_for_post_and_put_and_patch(self): digest_payload_obj = DigestAndPayload() digest = digest_payload_obj.string_digest_generation( self.merchant_config.request_json_path_data) # Setting the jwt body for JWT-post - jwt_body = {GlobalLabelParameters.JWT_DIGEST: digest.decode("utf-8"), GlobalLabelParameters.JWT_ALGORITHM: "SHA-256", - GlobalLabelParameters.JWT_TIME: self.date} - # reading the p12 file from cache memory - cache_obj = FileCache() - cache_memory = cache_obj.grab_file(self.merchant_config, self.merchant_config.key_file_path, - self.merchant_config.key_file_name) - der_cert_string = cache_memory[0] - private_key = cache_memory[1] - # setting the headers -merchant_id and the public key - headers_jwt = { - GlobalLabelParameters.MERCHANT_ID: str(self.merchant_config.key_alias)} - public_key_list = ([]) - public_key_list.append(der_cert_string.decode("utf-8")) - public_key_headers = {GlobalLabelParameters.PUBLIC_KEY: public_key_list} - headers_jwt.update(public_key_headers) - # generating the token of jwt - encoded_jwt = jwt.encode(jwt_body, private_key, algorithm='RS256', headers=headers_jwt) - - return encoded_jwt - - def token_for_put(self): - - digest_payload_obj = DigestAndPayload() - digest = digest_payload_obj.string_digest_generation( - self.merchant_config.request_json_path_data) - # Setting the jwt body for JWT-post - jwt_body = {GlobalLabelParameters.JWT_DIGEST: digest.decode("utf-8"), GlobalLabelParameters.JWT_ALGORITHM: "SHA-256", - GlobalLabelParameters.JWT_TIME: self.date} - # reading the p12 file from cache memory - cache_obj = FileCache() - cache_memory = cache_obj.grab_file(self.merchant_config, self.merchant_config.key_file_path, - self.merchant_config.key_file_name) - der_cert_string = cache_memory[0] - private_key = cache_memory[1] - # setting the headers -merchant_id and the public key - headers_jwt = { - GlobalLabelParameters.MERCHANT_ID: str(self.merchant_config.key_alias)} - public_key_list = ([]) - public_key_list.append(der_cert_string.decode("utf-8")) - public_key_headers = {GlobalLabelParameters.PUBLIC_KEY: public_key_list} - headers_jwt.update(public_key_headers) - # generating the token of jwt - encoded_jwt = jwt.encode(jwt_body, private_key, algorithm='RS256', headers=headers_jwt) - - return encoded_jwt - - def token_for_patch(self): - - digest_payload_obj = DigestAndPayload() - digest = digest_payload_obj.string_digest_generation( - self.merchant_config.request_json_path_data) - # Setting the jwt body for JWT-post - jwt_body = {GlobalLabelParameters.JWT_DIGEST: digest.decode("utf-8"), - GlobalLabelParameters.JWT_ALGORITHM: "SHA-256", - GlobalLabelParameters.JWT_TIME: self.date} - # reading the p12 file from cache memory - cache_obj = FileCache() - cache_memory = cache_obj.grab_file(self.merchant_config, self.merchant_config.key_file_path, - self.merchant_config.key_file_name) - der_cert_string = cache_memory[0] - private_key = cache_memory[1] - # setting the headers -merchant_id and the public key - headers_jwt = { - GlobalLabelParameters.MERCHANT_ID: str(self.merchant_config.key_alias)} - public_key_list = ([]) - public_key_list.append(der_cert_string.decode("utf-8")) - public_key_headers = {GlobalLabelParameters.PUBLIC_KEY: public_key_list} - headers_jwt.update(public_key_headers) - # generating the token of jwt - encoded_jwt = jwt.encode(jwt_body, private_key, algorithm='RS256', headers=headers_jwt) - - return encoded_jwt - - def token_for_delete(self): - - # Setting the jwt body for JWT-get - jwt_body = {GlobalLabelParameters.JWT_TIME: self.date} + jwt_body = {GlobalLabelParameters.JWT_DIGEST: digest.decode("utf-8"), GlobalLabelParameters.JWT_ALGORITHM: "SHA-256", GlobalLabelParameters.JWT_TIME: self.date} # reading the p12 file from cache memory cache_obj = FileCache() - cache_memory = cache_obj.grab_file(self.merchant_config, self.merchant_config.key_file_path, - self.merchant_config.key_file_name) - der_cert_string = cache_memory[0] - private_key = cache_memory[1] + cache_memory = cache_obj.fetch_cached_certificate(self.merchant_config, self.merchant_config.p12KeyFilePath, self.merchant_config.key_password) + der_cert_string = cache_memory.certificate + private_key = cache_memory.private_key # setting the headers -merchant_id and the public key - headers_jwt = { - GlobalLabelParameters.MERCHANT_ID: str(self.merchant_config.key_alias)} + headers_jwt = {GlobalLabelParameters.MERCHANT_ID: str(self.merchant_config.key_alias)} public_key_list = ([]) public_key_list.append(der_cert_string.decode("utf-8")) public_key_headers = {GlobalLabelParameters.PUBLIC_KEY: public_key_list} diff --git a/authenticationsdk/util/Cache.py b/authenticationsdk/util/Cache.py index 6425e07c..4def6039 100644 --- a/authenticationsdk/util/Cache.py +++ b/authenticationsdk/util/Cache.py @@ -1,8 +1,10 @@ import base64 import ssl +import threading from jwcrypto import jwk +from cryptography import x509 from cryptography.hazmat.primitives import serialization from cryptography.hazmat.backends import default_backend from cryptography.hazmat.primitives.serialization import pkcs12 @@ -15,9 +17,10 @@ import threading class CertInfo: - def __init__(self, mle_certificate, timestamp): - self.MLECertificate = mle_certificate - self.Timestamp = timestamp + def __init__(self, certificate, timestamp, private_key): + self.certificate = certificate + self.timestamp = timestamp + self.private_key = private_key class FileCache: _instance = None @@ -33,8 +36,38 @@ def __new__(cls, *args, **kwargs): def _initialize_cache(self): # Your cache initialization code here self.filecache = {} + self._p12_cache_lock = threading.RLock() self.mlecache = {} - self._cache_lock = threading.RLock() + self._mle_cache_lock = threading.RLock() + + def fetch_cached_certificate(self, merchant_config, p12_file_path, key_password): + try: + file_last_modified_time = os.stat(p12_file_path).st_mtime + filename_without_ext = os.path.splitext(os.path.basename(p12_file_path))[0] + if filename_without_ext not in self.filecache or file_last_modified_time != self.filecache[filename_without_ext].timestamp: + self.update_cache(merchant_config, p12_file_path, key_password) + return self.filecache[filename_without_ext] + except Exception: + raise ValueError(f"ERROR : KeyPassword provided: {key_password} is incorrect.") + + def update_cache(self, merchant_config, p12_file_path, key_password): + file_last_modified_time = os.stat(p12_file_path).st_mtime + filename_without_ext = os.path.splitext(os.path.basename(p12_file_path))[0] + private_key, certificate_list = CertificateUtility.fetch_certificate_collection_from_p12_file(p12_file_path, key_password) + + jwt_certificate = CertificateUtility.get_cert_based_on_key_alias(certificate_list, merchant_config.key_alias) + jwt_certificate_pem = jwt_certificate.public_bytes(serialization.Encoding.PEM) + jwt_certificate_pem_unicode_str = jwt_certificate_pem.decode('utf-8') + jwt_certificate_der_format = base64.b64encode(ssl.PEM_cert_to_DER_cert(jwt_certificate_pem_unicode_str)) + + certificate_information = CertInfo( + jwt_certificate_der_format, + file_last_modified_time, + private_key + ) + + with self._p12_cache_lock: + self.filecache[str(filename_without_ext)] = certificate_information @deprecated("This method has been marked as Deprecated and will be removed in coming releases.") def get_private_key_from_pem(self, pem_file_path): @@ -50,50 +83,6 @@ def load_certificates(self, filepath, filename, password): backend=default_backend() ) - def get_cert_based_on_key_alias(self, certificate, additional_certificates, key_alias): - target_cert = None - - # Check the main certificate - for attribute in certificate.subject: - if attribute.oid.dotted_string == '2.5.4.3': # OID for CN - cn_value = attribute.value - if cn_value == key_alias: - target_cert = certificate - break - - # Check the additional certificates if not found in the main certificate - if not target_cert: - for cert in additional_certificates: - for attribute in cert.subject: - if attribute.oid.dotted_string == '2.5.4.3': # OID for CN - cn_value = attribute.value - if cn_value == key_alias: - target_cert = cert - break - if target_cert: - break - - return target_cert - - def update_cache(self, mconfig, filepath, filename): - file_mod_time = os.stat(os.path.join(filepath, filename) + GlobalLabelParameters.P12_PREFIX).st_mtime - private_key, certificate, additional_certificates = self.load_certificates(filepath, filename, mconfig.key_password) - - jwt_cert= self.get_cert_based_on_key_alias(certificate, additional_certificates, mconfig.key_alias) - jwt_cert_pem = jwt_cert.public_bytes(serialization.Encoding.PEM) - jwt_cert_pem_str = jwt_cert_pem.decode('utf-8') - jwt_der_cert_string = base64.b64encode(ssl.PEM_cert_to_DER_cert(jwt_cert_pem_str)) - - mle_cert = self.get_cert_based_on_key_alias(certificate, additional_certificates, mconfig.get_mleKeyAlias()) - - self.filecache[str(filename)] = [jwt_der_cert_string, private_key, file_mod_time, mle_cert] - - def grab_file(self, mconfig, filepath, filename): - file_mod_time = os.stat(os.path.join(filepath, filename) + GlobalLabelParameters.P12_PREFIX).st_mtime - if filename not in self.filecache or file_mod_time != self.filecache[filename][2]: - self.update_cache(mconfig, filepath, filename) - return self.filecache[filename] - @deprecated("This method has been marked as Deprecated and will be removed in coming releases.") def get_cached_private_key_from_pem(self, file_path, cache_key): file_mod_time = os.stat(file_path).st_mtime @@ -132,15 +121,14 @@ def get_request_mle_cert_from_cache(self, merchant_config): return mle_certificate def get_mle_cert_based_on_cache_key(self, merchant_config, cache_key, certificate_file_path): - with self._cache_lock: - cert_info = self.mlecache.get(cache_key) + cert_info = self.mlecache.get(cache_key) - file_timestamp = os.path.getmtime(certificate_file_path) - if cert_info is None or cert_info.Timestamp != file_timestamp: - self.setup_mle_cache(merchant_config, cache_key, certificate_file_path) - cert_info = self.mlecache.get(cache_key) + file_timestamp = os.path.getmtime(certificate_file_path) + if cert_info is None or cert_info.timestamp != file_timestamp: + self.setup_mle_cache(merchant_config, cache_key, certificate_file_path) + cert_info = self.mlecache.get(cache_key) - return cert_info.MLECertificate if cert_info else None + return cert_info.certificate if cert_info else None def setup_mle_cache(self, merchant_config, cache_key, certificate_file_path): if FileCache.logger is None: @@ -148,6 +136,7 @@ def setup_mle_cache(self, merchant_config, cache_key, certificate_file_path): logger = FileCache.logger mle_certificate = None + private_key = None # Handle PEM certificate case if cache_key.endswith(GlobalLabelParameters.MLE_CACHE_IDENTIFIER_FOR_CONFIG_CERT): @@ -163,7 +152,7 @@ def setup_mle_cache(self, merchant_config, cache_key, certificate_file_path): # Handle P12 certificate case if cache_key.endswith(GlobalLabelParameters.MLE_CACHE_IDENTIFIER_FOR_P12_CERT): try: - certificates = CertificateUtility.fetch_certificate_collection_from_p12_file(merchant_config.p12KeyFilePath, merchant_config.key_password) + private_key, certificates = CertificateUtility.fetch_certificate_collection_from_p12_file(merchant_config.p12KeyFilePath, merchant_config.key_password) mle_certificate = CertificateUtility.get_cert_based_on_key_alias(certificates, merchant_config.mleKeyAlias) except Exception: file_name = os.path.basename(merchant_config.p12KeyFilePath) @@ -173,7 +162,8 @@ def setup_mle_cache(self, merchant_config, cache_key, certificate_file_path): # Save to cache (thread-safe) cert_info = CertInfo( mle_certificate, - os.path.getmtime(certificate_file_path) + os.path.getmtime(certificate_file_path), + private_key ) - with self._cache_lock: + with self._mle_cache_lock: self.mlecache[cache_key] = cert_info \ No newline at end of file diff --git a/authenticationsdk/util/CertificateUtility.py b/authenticationsdk/util/CertificateUtility.py index 8934dff1..c2dbb5ca 100644 --- a/authenticationsdk/util/CertificateUtility.py +++ b/authenticationsdk/util/CertificateUtility.py @@ -128,4 +128,4 @@ def fetch_certificate_collection_from_p12_file(p12_file_path, key_password): certs.append(cert) if additional_certs is not None: certs.extend(additional_certs) - return certs + return private_key, certs From 8ee7d1ee48938180b16a5d38f716e9c97a6faa27 Mon Sep 17 00:00:00 2001 From: gnongsie Date: Wed, 23 Jul 2025 20:18:12 +0530 Subject: [PATCH 3/6] Fixed name for method to clarify functionality --- authenticationsdk/jwt/Token.py | 4 ++-- authenticationsdk/util/Cache.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/authenticationsdk/jwt/Token.py b/authenticationsdk/jwt/Token.py index c4325d8e..38fb87af 100644 --- a/authenticationsdk/jwt/Token.py +++ b/authenticationsdk/jwt/Token.py @@ -36,7 +36,7 @@ def token_for_get_and_delete(self): jwt_body = {GlobalLabelParameters.JWT_TIME: self.date} # reading the p12 file from cache memory cache_obj = FileCache() - cache_memory = cache_obj.fetch_cached_certificate(self.merchant_config, self.merchant_config.p12KeyFilePath, self.merchant_config.key_password) + cache_memory = cache_obj.fetch_cached_p12_certificate(self.merchant_config, self.merchant_config.p12KeyFilePath, self.merchant_config.key_password) der_cert_string = cache_memory.certificate private_key = cache_memory.private_key # setting the headers -merchant_id and the public key @@ -61,7 +61,7 @@ def token_for_post_and_put_and_patch(self): jwt_body = {GlobalLabelParameters.JWT_DIGEST: digest.decode("utf-8"), GlobalLabelParameters.JWT_ALGORITHM: "SHA-256", GlobalLabelParameters.JWT_TIME: self.date} # reading the p12 file from cache memory cache_obj = FileCache() - cache_memory = cache_obj.fetch_cached_certificate(self.merchant_config, self.merchant_config.p12KeyFilePath, self.merchant_config.key_password) + cache_memory = cache_obj.fetch_cached_p12_certificate(self.merchant_config, self.merchant_config.p12KeyFilePath, self.merchant_config.key_password) der_cert_string = cache_memory.certificate private_key = cache_memory.private_key # setting the headers -merchant_id and the public key diff --git a/authenticationsdk/util/Cache.py b/authenticationsdk/util/Cache.py index 4def6039..3320290b 100644 --- a/authenticationsdk/util/Cache.py +++ b/authenticationsdk/util/Cache.py @@ -40,7 +40,7 @@ def _initialize_cache(self): self.mlecache = {} self._mle_cache_lock = threading.RLock() - def fetch_cached_certificate(self, merchant_config, p12_file_path, key_password): + def fetch_cached_p12_certificate(self, merchant_config, p12_file_path, key_password): try: file_last_modified_time = os.stat(p12_file_path).st_mtime filename_without_ext = os.path.splitext(os.path.basename(p12_file_path))[0] From e01160ddc70963b84824081639a5bc9af03490c4 Mon Sep 17 00:00:00 2001 From: mahmishr Date: Mon, 18 Aug 2025 09:59:57 +0530 Subject: [PATCH 4/6] incorporated changes from feature/add-mle-flag --- .../core/MerchantConfiguration.py | 41 +++++++++++++++++-- authenticationsdk/util/MLEUtility.py | 13 ++++-- .../cybersource-python-template/api.mustache | 4 +- 3 files changed, 48 insertions(+), 10 deletions(-) diff --git a/authenticationsdk/core/MerchantConfiguration.py b/authenticationsdk/core/MerchantConfiguration.py index 202bab91..50b5601e 100644 --- a/authenticationsdk/core/MerchantConfiguration.py +++ b/authenticationsdk/core/MerchantConfiguration.py @@ -51,6 +51,8 @@ def __init__(self): self.log_config = None self.__jwePEMFileDirectory = None self.useMLEGlobally = None + self.enableRequestMLEForOptionalApisGlobally = None + self.disableRequestMLEForMandatoryApisGlobally = None self.mapToControlMLEonAPI = None self.mleKeyAlias = None self.logger = LogFactory.setup_logger(self.__class__.__name__) @@ -187,12 +189,34 @@ def get_jwePEMFileDirectory(self): def set_useMLEGlobally(self, value): if not (value.get('useMLEGlobally') is None): self.useMLEGlobally = value['useMLEGlobally'] - else: - self.useMLEGlobally = False def get_useMLEGlobally(self): return self.useMLEGlobally + def set_enableRequestMLEForOptionalApisGlobally(self, value): + enable_mle = value.get('enableRequestMLEForOptionalApisGlobally') + use_mle = value.get('useMLEGlobally') + + if enable_mle is not None and use_mle is not None and enable_mle != use_mle: + raise ValueError("useMLEGlobally and enableRequestMLEForOptionalApisGlobally must have the same value.") + + self.enableRequestMLEForOptionalApisGlobally = ( + enable_mle if enable_mle is not None else (use_mle if use_mle is not None else False) + ) + + def get_enableRequestMLEForOptionalApisGlobally(self): + return self.enableRequestMLEForOptionalApisGlobally + + + def set_disableRequestMLEForMandatoryApisGlobally(self, value): + self.disableRequestMLEForMandatoryApisGlobally = ( + value.get('disableRequestMLEForMandatoryApisGlobally') + or False + ) + + def get_disableRequestMLEForMandatoryApisGlobally(self): + return self.disableRequestMLEForMandatoryApisGlobally + def set_mapToControlMLEonAPI(self, value): map_to_control_mle_on_api = value.get('mapToControlMLEonAPI') if map_to_control_mle_on_api is not None: @@ -246,6 +270,8 @@ def set_merchantconfig(self, val): self.set_log_configuration(val) self.set_jwePEMFileDirectory(val) self.set_useMLEGlobally(val) + self.set_enableRequestMLEForOptionalApisGlobally(val) + self.set_disableRequestMLEForMandatoryApisGlobally(val) self.set_mapToControlMLEonAPI(val) self.set_mleKeyAlias(val) @@ -374,9 +400,16 @@ def validate_merchant_details(self, details, mconfig = None): authenticationsdk.util.ExceptionAuth.validate_merchant_details_log(self.logger, GlobalLabelParameters.AUTH_ERROR, self.log_config) + + use_mle = self.useMLEGlobally + enable_mle = self.enableRequestMLEForOptionalApisGlobally + + if use_mle is not None and enable_mle is not None and use_mle != enable_mle: + raise ValueError("useMLEGlobally and enableRequestMLEForOptionalApisGlobally must have the same value.") + # useMLEGlobally check for auth Type - if self.useMLEGlobally is True or self.mapToControlMLEonAPI is not None: - if self.useMLEGlobally is True and self.authentication_type.lower() != GlobalLabelParameters.JWT.lower(): + if self.enableRequestMLEForOptionalApisGlobally is True or self.mapToControlMLEonAPI is not None: + if self.enableRequestMLEForOptionalApisGlobally is True and self.authentication_type.lower() != GlobalLabelParameters.JWT.lower(): authenticationsdk.util.ExceptionAuth.validate_merchant_details_log(self.logger, GlobalLabelParameters.MLE_AUTH_ERROR, self.log_config) diff --git a/authenticationsdk/util/MLEUtility.py b/authenticationsdk/util/MLEUtility.py index 45e72a3e..25a64663 100644 --- a/authenticationsdk/util/MLEUtility.py +++ b/authenticationsdk/util/MLEUtility.py @@ -16,11 +16,16 @@ def __init__(self, message, errors=None): self.errors = errors @staticmethod - def check_is_mle_for_api(merchant_config, is_mle_supported_by_cybs_for_api, operation_ids): - + def check_is_mle_for_api(merchant_config, inbound_mle_status, operation_ids): is_mle_for_api = False - if is_mle_supported_by_cybs_for_api and merchant_config.get_useMLEGlobally(): + + if str(inbound_mle_status).lower() == "optional" and merchant_config.get_enableRequestMLEForOptionalApisGlobally(): is_mle_for_api = True + + if str(inbound_mle_status).lower() == "mandatory": + is_mle_for_api = not merchant_config.get_disableRequestMLEForMandatoryApisGlobally() + + operation_array = [op_id.strip() for op_id in operation_ids.split(",")] map_to_control_mle = merchant_config.get_mapToControlMLEonAPI() if map_to_control_mle is not None and map_to_control_mle: @@ -36,7 +41,7 @@ def encrypt_request_payload(merchant_config, request_body): return request_body logger = LogFactory.setup_logger(__name__, merchant_config.log_config) - + if merchant_config.log_config.enable_log: logger.debug(f"{GlobalLabelParameters.MESSAGE_BEFORE_MLE_REQUEST}{request_body}") diff --git a/generator/cybersource-python-template/api.mustache b/generator/cybersource-python-template/api.mustache index 0154a40b..d0e0a1a3 100644 --- a/generator/cybersource-python-template/api.mustache +++ b/generator/cybersource-python-template/api.mustache @@ -210,8 +210,8 @@ class {{classname}}(object): header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" {{/bodyParam}} - is_mle_supported_by_cybs_for_api = {{#vendorExtensions.x-devcenter-metaData.isMLEsupported}}True{{/vendorExtensions.x-devcenter-metaData.isMLEsupported}}{{^vendorExtensions.x-devcenter-metaData.isMLEsupported}}False{{/vendorExtensions.x-devcenter-metaData.isMLEsupported}} - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "{{operationId}},{{operationId}}_with_http_info"): + inbound_mle_status = "{{#vendorExtensions.x-devcenter-metaData.inboundMLEStatus}}{{vendorExtensions.x-devcenter-metaData.inboundMLEStatus}}{{/vendorExtensions.x-devcenter-metaData.inboundMLEStatus}}{{^vendorExtensions.x-devcenter-metaData.inboundMLEStatus}}false{{/vendorExtensions.x-devcenter-metaData.inboundMLEStatus}}" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "{{operationId}},{{operationId}}_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting From 59ac3dfd2ae2513c50361d9caf87e459c9010231 Mon Sep 17 00:00:00 2001 From: mahmishr Date: Mon, 18 Aug 2025 10:18:01 +0530 Subject: [PATCH 5/6] auto gen code --- CyberSource/api/batches_api.py | 16 +++++----- CyberSource/api/billing_agreements_api.py | 12 +++---- CyberSource/api/bin_lookup_api.py | 4 +-- CyberSource/api/capture_api.py | 4 +-- CyberSource/api/chargeback_details_api.py | 4 +-- CyberSource/api/chargeback_summaries_api.py | 4 +-- CyberSource/api/conversion_details_api.py | 4 +-- CyberSource/api/create_new_webhooks_api.py | 12 +++---- CyberSource/api/credit_api.py | 4 +-- CyberSource/api/customer_api.py | 16 +++++----- .../api/customer_payment_instrument_api.py | 20 ++++++------ .../api/customer_shipping_address_api.py | 20 ++++++------ CyberSource/api/decision_manager_api.py | 20 ++++++------ CyberSource/api/device_de_association_api.py | 8 ++--- CyberSource/api/device_search_api.py | 8 ++--- CyberSource/api/download_dtd_api.py | 4 +-- CyberSource/api/download_xsd_api.py | 4 +-- CyberSource/api/emv_tag_details_api.py | 8 ++--- CyberSource/api/flex_api_api.py | 4 +-- CyberSource/api/instrument_identifier_api.py | 24 +++++++------- .../interchange_clearing_level_details_api.py | 4 +-- CyberSource/api/invoice_settings_api.py | 8 ++--- CyberSource/api/invoices_api.py | 24 +++++++------- CyberSource/api/manage_webhooks_api.py | 28 ++++++++-------- CyberSource/api/merchant_boarding_api.py | 8 ++--- CyberSource/api/microform_integration_api.py | 4 +-- CyberSource/api/net_fundings_api.py | 4 +-- .../api/notification_of_changes_api.py | 4 +-- CyberSource/api/orders_api.py | 8 ++--- CyberSource/api/payer_authentication_api.py | 12 +++---- .../api/payment_batch_summaries_api.py | 4 +-- CyberSource/api/payment_instrument_api.py | 16 +++++----- CyberSource/api/payment_links_api.py | 16 +++++----- CyberSource/api/payment_tokens_api.py | 4 +-- CyberSource/api/payments_api.py | 24 +++++++------- CyberSource/api/payouts_api.py | 4 +-- CyberSource/api/plans_api.py | 32 +++++++++---------- .../api/purchase_and_refund_details_api.py | 4 +-- CyberSource/api/push_funds_api.py | 4 +-- CyberSource/api/refund_api.py | 8 ++--- CyberSource/api/report_definitions_api.py | 8 ++--- CyberSource/api/report_downloads_api.py | 4 +-- CyberSource/api/report_subscriptions_api.py | 20 ++++++------ CyberSource/api/reports_api.py | 12 +++---- CyberSource/api/retrieval_details_api.py | 4 +-- CyberSource/api/retrieval_summaries_api.py | 4 +-- CyberSource/api/reversal_api.py | 8 ++--- CyberSource/api/search_transactions_api.py | 8 ++--- CyberSource/api/secure_file_share_api.py | 8 ++--- CyberSource/api/subscriptions_api.py | 32 +++++++++---------- .../api/subscriptions_follow_ons_api.py | 8 ++--- CyberSource/api/taxes_api.py | 8 ++--- CyberSource/api/token_api.py | 8 ++--- CyberSource/api/tokenized_card_api.py | 12 +++---- CyberSource/api/transaction_batches_api.py | 16 +++++----- CyberSource/api/transaction_details_api.py | 4 +-- CyberSource/api/transient_token_data_api.py | 8 ++--- .../unified_checkout_capture_context_api.py | 4 +-- CyberSource/api/user_management_api.py | 4 +-- CyberSource/api/user_management_search_api.py | 4 +-- CyberSource/api/verification_api.py | 8 ++--- CyberSource/api/void_api.py | 20 ++++++------ 62 files changed, 316 insertions(+), 316 deletions(-) diff --git a/CyberSource/api/batches_api.py b/CyberSource/api/batches_api.py index 332224e0..d44d6c6c 100644 --- a/CyberSource/api/batches_api.py +++ b/CyberSource/api/batches_api.py @@ -149,8 +149,8 @@ def get_batch_report_with_http_info(self, batch_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_batch_report,get_batch_report_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_batch_report,get_batch_report_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -272,8 +272,8 @@ def get_batch_status_with_http_info(self, batch_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_batch_status,get_batch_status_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_batch_status,get_batch_status_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -401,8 +401,8 @@ def get_batches_list_with_http_info(self, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_batches_list,get_batches_list_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_batches_list,get_batches_list_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -520,8 +520,8 @@ def post_batch_with_http_info(self, body, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'body', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "post_batch,post_batch_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "post_batch,post_batch_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/billing_agreements_api.py b/CyberSource/api/billing_agreements_api.py index 2696b56e..62a6e50d 100644 --- a/CyberSource/api/billing_agreements_api.py +++ b/CyberSource/api/billing_agreements_api.py @@ -155,8 +155,8 @@ def billing_agreements_de_registration_with_http_info(self, modify_billing_agree body_params = sdkTracker.insert_developer_id_tracker(body_params, 'modify_billing_agreement', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "billing_agreements_de_registration,billing_agreements_de_registration_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "billing_agreements_de_registration,billing_agreements_de_registration_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -284,8 +284,8 @@ def billing_agreements_intimation_with_http_info(self, intimate_billing_agreemen body_params = sdkTracker.insert_developer_id_tracker(body_params, 'intimate_billing_agreement', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "billing_agreements_intimation,billing_agreements_intimation_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "billing_agreements_intimation,billing_agreements_intimation_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -403,8 +403,8 @@ def billing_agreements_registration_with_http_info(self, create_billing_agreemen body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_billing_agreement', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "billing_agreements_registration,billing_agreements_registration_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "billing_agreements_registration,billing_agreements_registration_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/bin_lookup_api.py b/CyberSource/api/bin_lookup_api.py index c229ddc2..34bfbfef 100644 --- a/CyberSource/api/bin_lookup_api.py +++ b/CyberSource/api/bin_lookup_api.py @@ -148,8 +148,8 @@ def get_account_info_with_http_info(self, create_bin_lookup_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_bin_lookup_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_account_info,get_account_info_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_account_info,get_account_info_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/capture_api.py b/CyberSource/api/capture_api.py index f537af3e..8d8cd028 100644 --- a/CyberSource/api/capture_api.py +++ b/CyberSource/api/capture_api.py @@ -155,8 +155,8 @@ def capture_payment_with_http_info(self, capture_payment_request, id, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'capture_payment_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "capture_payment,capture_payment_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "capture_payment,capture_payment_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/chargeback_details_api.py b/CyberSource/api/chargeback_details_api.py index c3d9177a..24a50c3d 100644 --- a/CyberSource/api/chargeback_details_api.py +++ b/CyberSource/api/chargeback_details_api.py @@ -161,8 +161,8 @@ def get_chargeback_details_with_http_info(self, start_time, end_time, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_chargeback_details,get_chargeback_details_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_chargeback_details,get_chargeback_details_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/chargeback_summaries_api.py b/CyberSource/api/chargeback_summaries_api.py index 4961ba10..6c309804 100644 --- a/CyberSource/api/chargeback_summaries_api.py +++ b/CyberSource/api/chargeback_summaries_api.py @@ -161,8 +161,8 @@ def get_chargeback_summaries_with_http_info(self, start_time, end_time, **kwargs body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_chargeback_summaries,get_chargeback_summaries_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_chargeback_summaries,get_chargeback_summaries_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/conversion_details_api.py b/CyberSource/api/conversion_details_api.py index b7f213bd..61332df4 100644 --- a/CyberSource/api/conversion_details_api.py +++ b/CyberSource/api/conversion_details_api.py @@ -161,8 +161,8 @@ def get_conversion_detail_with_http_info(self, start_time, end_time, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_conversion_detail,get_conversion_detail_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_conversion_detail,get_conversion_detail_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/create_new_webhooks_api.py b/CyberSource/api/create_new_webhooks_api.py index ac8d2d38..9ceedce6 100644 --- a/CyberSource/api/create_new_webhooks_api.py +++ b/CyberSource/api/create_new_webhooks_api.py @@ -149,8 +149,8 @@ def find_products_to_subscribe_with_http_info(self, organization_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "find_products_to_subscribe,find_products_to_subscribe_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "find_products_to_subscribe,find_products_to_subscribe_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -263,8 +263,8 @@ def notification_subscriptions_v2_webhooks_post_with_http_info(self, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_webhook', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "notification_subscriptions_v2_webhooks_post,notification_subscriptions_v2_webhooks_post_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "notification_subscriptions_v2_webhooks_post,notification_subscriptions_v2_webhooks_post_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -399,8 +399,8 @@ def save_sym_egress_key_with_http_info(self, v_c_sender_organization_id, v_c_per body_params = sdkTracker.insert_developer_id_tracker(body_params, 'save_sym_egress_key', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "save_sym_egress_key,save_sym_egress_key_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "save_sym_egress_key,save_sym_egress_key_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/credit_api.py b/CyberSource/api/credit_api.py index d2ccd77c..9278b6b2 100644 --- a/CyberSource/api/credit_api.py +++ b/CyberSource/api/credit_api.py @@ -145,8 +145,8 @@ def create_credit_with_http_info(self, create_credit_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_credit_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_credit,create_credit_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_credit,create_credit_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/customer_api.py b/CyberSource/api/customer_api.py index 2952ead8..9d4791d2 100644 --- a/CyberSource/api/customer_api.py +++ b/CyberSource/api/customer_api.py @@ -153,8 +153,8 @@ def delete_customer_with_http_info(self, customer_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "delete_customer,delete_customer_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "delete_customer,delete_customer_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -280,8 +280,8 @@ def get_customer_with_http_info(self, customer_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_customer,get_customer_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_customer,get_customer_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -417,8 +417,8 @@ def patch_customer_with_http_info(self, customer_id, patch_customer_request, **k body_params = sdkTracker.insert_developer_id_tracker(body_params, 'patch_customer_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "patch_customer,patch_customer_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "patch_customer,patch_customer_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -540,8 +540,8 @@ def post_customer_with_http_info(self, post_customer_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'post_customer_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "post_customer,post_customer_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "post_customer,post_customer_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/customer_payment_instrument_api.py b/CyberSource/api/customer_payment_instrument_api.py index 37be2b2b..e871d5bd 100644 --- a/CyberSource/api/customer_payment_instrument_api.py +++ b/CyberSource/api/customer_payment_instrument_api.py @@ -163,8 +163,8 @@ def delete_customer_payment_instrument_with_http_info(self, customer_id, payment body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "delete_customer_payment_instrument,delete_customer_payment_instrument_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "delete_customer_payment_instrument,delete_customer_payment_instrument_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -300,8 +300,8 @@ def get_customer_payment_instrument_with_http_info(self, customer_id, payment_in body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_customer_payment_instrument,get_customer_payment_instrument_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_customer_payment_instrument,get_customer_payment_instrument_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -435,8 +435,8 @@ def get_customer_payment_instruments_list_with_http_info(self, customer_id, **kw body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_customer_payment_instruments_list,get_customer_payment_instruments_list_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_customer_payment_instruments_list,get_customer_payment_instruments_list_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -582,8 +582,8 @@ def patch_customers_payment_instrument_with_http_info(self, customer_id, payment body_params = sdkTracker.insert_developer_id_tracker(body_params, 'patch_customer_payment_instrument_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "patch_customers_payment_instrument,patch_customers_payment_instrument_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "patch_customers_payment_instrument,patch_customers_payment_instrument_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -715,8 +715,8 @@ def post_customer_payment_instrument_with_http_info(self, customer_id, post_cust body_params = sdkTracker.insert_developer_id_tracker(body_params, 'post_customer_payment_instrument_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "post_customer_payment_instrument,post_customer_payment_instrument_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "post_customer_payment_instrument,post_customer_payment_instrument_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/customer_shipping_address_api.py b/CyberSource/api/customer_shipping_address_api.py index c524482d..cce46b26 100644 --- a/CyberSource/api/customer_shipping_address_api.py +++ b/CyberSource/api/customer_shipping_address_api.py @@ -163,8 +163,8 @@ def delete_customer_shipping_address_with_http_info(self, customer_id, shipping_ body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "delete_customer_shipping_address,delete_customer_shipping_address_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "delete_customer_shipping_address,delete_customer_shipping_address_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -300,8 +300,8 @@ def get_customer_shipping_address_with_http_info(self, customer_id, shipping_add body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_customer_shipping_address,get_customer_shipping_address_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_customer_shipping_address,get_customer_shipping_address_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -435,8 +435,8 @@ def get_customer_shipping_addresses_list_with_http_info(self, customer_id, **kwa body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_customer_shipping_addresses_list,get_customer_shipping_addresses_list_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_customer_shipping_addresses_list,get_customer_shipping_addresses_list_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -582,8 +582,8 @@ def patch_customers_shipping_address_with_http_info(self, customer_id, shipping_ body_params = sdkTracker.insert_developer_id_tracker(body_params, 'patch_customer_shipping_address_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "patch_customers_shipping_address,patch_customers_shipping_address_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "patch_customers_shipping_address,patch_customers_shipping_address_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -715,8 +715,8 @@ def post_customer_shipping_address_with_http_info(self, customer_id, post_custom body_params = sdkTracker.insert_developer_id_tracker(body_params, 'post_customer_shipping_address_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "post_customer_shipping_address,post_customer_shipping_address_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "post_customer_shipping_address,post_customer_shipping_address_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/decision_manager_api.py b/CyberSource/api/decision_manager_api.py index b3430da5..96d2cfbe 100644 --- a/CyberSource/api/decision_manager_api.py +++ b/CyberSource/api/decision_manager_api.py @@ -155,8 +155,8 @@ def action_decision_manager_case_with_http_info(self, id, case_management_action body_params = sdkTracker.insert_developer_id_tracker(body_params, 'case_management_actions_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "action_decision_manager_case,action_decision_manager_case_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "action_decision_manager_case,action_decision_manager_case_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -284,8 +284,8 @@ def add_negative_with_http_info(self, type, add_negative_list_request, **kwargs) body_params = sdkTracker.insert_developer_id_tracker(body_params, 'add_negative_list_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "add_negative,add_negative_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "add_negative,add_negative_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -413,8 +413,8 @@ def comment_decision_manager_case_with_http_info(self, id, case_management_comme body_params = sdkTracker.insert_developer_id_tracker(body_params, 'case_management_comments_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "comment_decision_manager_case,comment_decision_manager_case_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "comment_decision_manager_case,comment_decision_manager_case_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -532,8 +532,8 @@ def create_bundled_decision_manager_case_with_http_info(self, create_bundled_dec body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_bundled_decision_manager_case_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_bundled_decision_manager_case,create_bundled_decision_manager_case_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_bundled_decision_manager_case,create_bundled_decision_manager_case_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -661,8 +661,8 @@ def fraud_update_with_http_info(self, id, fraud_marking_action_request, **kwargs body_params = sdkTracker.insert_developer_id_tracker(body_params, 'fraud_marking_action_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "fraud_update,fraud_update_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "fraud_update,fraud_update_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/device_de_association_api.py b/CyberSource/api/device_de_association_api.py index 0093d1e9..2a1f961a 100644 --- a/CyberSource/api/device_de_association_api.py +++ b/CyberSource/api/device_de_association_api.py @@ -145,8 +145,8 @@ def delete_terminal_association_with_http_info(self, de_association_request_body body_params = sdkTracker.insert_developer_id_tracker(body_params, 'de_association_request_body', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "delete_terminal_association,delete_terminal_association_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "delete_terminal_association,delete_terminal_association_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -264,8 +264,8 @@ def post_de_associate_v3_terminal_with_http_info(self, device_de_associate_v3_re body_params = sdkTracker.insert_developer_id_tracker(body_params, 'device_de_associate_v3_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "post_de_associate_v3_terminal,post_de_associate_v3_terminal_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "post_de_associate_v3_terminal,post_de_associate_v3_terminal_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/device_search_api.py b/CyberSource/api/device_search_api.py index 784d784f..e6644b99 100644 --- a/CyberSource/api/device_search_api.py +++ b/CyberSource/api/device_search_api.py @@ -145,8 +145,8 @@ def post_search_query_with_http_info(self, post_device_search_request, **kwargs) body_params = sdkTracker.insert_developer_id_tracker(body_params, 'post_device_search_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "post_search_query,post_search_query_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "post_search_query,post_search_query_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -264,8 +264,8 @@ def post_search_query_v3_with_http_info(self, post_device_search_request_v3, **k body_params = sdkTracker.insert_developer_id_tracker(body_params, 'post_device_search_request_v3', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "post_search_query_v3,post_search_query_v3_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "post_search_query_v3,post_search_query_v3_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/download_dtd_api.py b/CyberSource/api/download_dtd_api.py index 96dbf71f..03af1078 100644 --- a/CyberSource/api/download_dtd_api.py +++ b/CyberSource/api/download_dtd_api.py @@ -149,8 +149,8 @@ def get_dtdv2_with_http_info(self, report_definition_name_version, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_dtdv2,get_dtdv2_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_dtdv2,get_dtdv2_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/download_xsd_api.py b/CyberSource/api/download_xsd_api.py index 955fc215..6f573d32 100644 --- a/CyberSource/api/download_xsd_api.py +++ b/CyberSource/api/download_xsd_api.py @@ -149,8 +149,8 @@ def get_xsdv2_with_http_info(self, report_definition_name_version, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_xsdv2,get_xsdv2_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_xsdv2,get_xsdv2_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/emv_tag_details_api.py b/CyberSource/api/emv_tag_details_api.py index cdb3a551..382124b1 100644 --- a/CyberSource/api/emv_tag_details_api.py +++ b/CyberSource/api/emv_tag_details_api.py @@ -138,8 +138,8 @@ def get_emv_tags_with_http_info(self, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_emv_tags,get_emv_tags_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_emv_tags,get_emv_tags_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -257,8 +257,8 @@ def parse_emv_tags_with_http_info(self, body, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'body', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "parse_emv_tags,parse_emv_tags_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "parse_emv_tags,parse_emv_tags_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/flex_api_api.py b/CyberSource/api/flex_api_api.py index e1188a21..a5e74408 100644 --- a/CyberSource/api/flex_api_api.py +++ b/CyberSource/api/flex_api_api.py @@ -145,8 +145,8 @@ def generate_flex_api_capture_context_with_http_info(self, generate_flex_api_cap body_params = sdkTracker.insert_developer_id_tracker(body_params, 'generate_flex_api_capture_context_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "generate_flex_api_capture_context,generate_flex_api_capture_context_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "generate_flex_api_capture_context,generate_flex_api_capture_context_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/instrument_identifier_api.py b/CyberSource/api/instrument_identifier_api.py index d40f73db..9bae3f9b 100644 --- a/CyberSource/api/instrument_identifier_api.py +++ b/CyberSource/api/instrument_identifier_api.py @@ -153,8 +153,8 @@ def delete_instrument_identifier_with_http_info(self, instrument_identifier_id, body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "delete_instrument_identifier,delete_instrument_identifier_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "delete_instrument_identifier,delete_instrument_identifier_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -284,8 +284,8 @@ def get_instrument_identifier_with_http_info(self, instrument_identifier_id, **k body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_instrument_identifier,get_instrument_identifier_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_instrument_identifier,get_instrument_identifier_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -423,8 +423,8 @@ def get_instrument_identifier_payment_instruments_list_with_http_info(self, inst body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_instrument_identifier_payment_instruments_list,get_instrument_identifier_payment_instruments_list_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_instrument_identifier_payment_instruments_list,get_instrument_identifier_payment_instruments_list_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -564,8 +564,8 @@ def patch_instrument_identifier_with_http_info(self, instrument_identifier_id, p body_params = sdkTracker.insert_developer_id_tracker(body_params, 'patch_instrument_identifier_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "patch_instrument_identifier,patch_instrument_identifier_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "patch_instrument_identifier,patch_instrument_identifier_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -691,8 +691,8 @@ def post_instrument_identifier_with_http_info(self, post_instrument_identifier_r body_params = sdkTracker.insert_developer_id_tracker(body_params, 'post_instrument_identifier_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "post_instrument_identifier,post_instrument_identifier_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "post_instrument_identifier,post_instrument_identifier_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -824,8 +824,8 @@ def post_instrument_identifier_enrollment_with_http_info(self, instrument_identi body_params = sdkTracker.insert_developer_id_tracker(body_params, 'post_instrument_identifier_enrollment_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "post_instrument_identifier_enrollment,post_instrument_identifier_enrollment_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "post_instrument_identifier_enrollment,post_instrument_identifier_enrollment_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/interchange_clearing_level_details_api.py b/CyberSource/api/interchange_clearing_level_details_api.py index 59c5e801..e7423619 100644 --- a/CyberSource/api/interchange_clearing_level_details_api.py +++ b/CyberSource/api/interchange_clearing_level_details_api.py @@ -161,8 +161,8 @@ def get_interchange_clearing_level_details_with_http_info(self, start_time, end_ body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_interchange_clearing_level_details,get_interchange_clearing_level_details_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_interchange_clearing_level_details,get_interchange_clearing_level_details_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/invoice_settings_api.py b/CyberSource/api/invoice_settings_api.py index 474e370c..54bb5ad9 100644 --- a/CyberSource/api/invoice_settings_api.py +++ b/CyberSource/api/invoice_settings_api.py @@ -138,8 +138,8 @@ def get_invoice_settings_with_http_info(self, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_invoice_settings,get_invoice_settings_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_invoice_settings,get_invoice_settings_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -257,8 +257,8 @@ def update_invoice_settings_with_http_info(self, invoice_settings_request, **kwa body_params = sdkTracker.insert_developer_id_tracker(body_params, 'invoice_settings_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "update_invoice_settings,update_invoice_settings_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "update_invoice_settings,update_invoice_settings_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/invoices_api.py b/CyberSource/api/invoices_api.py index 00fcb070..1f7a99c8 100644 --- a/CyberSource/api/invoices_api.py +++ b/CyberSource/api/invoices_api.py @@ -145,8 +145,8 @@ def create_invoice_with_http_info(self, create_invoice_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_invoice_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_invoice,create_invoice_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_invoice,create_invoice_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -280,8 +280,8 @@ def get_all_invoices_with_http_info(self, offset, limit, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_all_invoices,get_all_invoices_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_all_invoices,get_all_invoices_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -403,8 +403,8 @@ def get_invoice_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_invoice,get_invoice_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_invoice,get_invoice_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -526,8 +526,8 @@ def perform_cancel_action_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "perform_cancel_action,perform_cancel_action_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "perform_cancel_action,perform_cancel_action_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -649,8 +649,8 @@ def perform_send_action_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "perform_send_action,perform_send_action_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "perform_send_action,perform_send_action_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -778,8 +778,8 @@ def update_invoice_with_http_info(self, id, update_invoice_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'update_invoice_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "update_invoice,update_invoice_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "update_invoice,update_invoice_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/manage_webhooks_api.py b/CyberSource/api/manage_webhooks_api.py index fdb7a5d6..fa1cda06 100644 --- a/CyberSource/api/manage_webhooks_api.py +++ b/CyberSource/api/manage_webhooks_api.py @@ -149,8 +149,8 @@ def delete_webhook_subscription_with_http_info(self, webhook_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "delete_webhook_subscription,delete_webhook_subscription_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "delete_webhook_subscription,delete_webhook_subscription_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -272,8 +272,8 @@ def get_webhook_subscription_by_id_with_http_info(self, webhook_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_webhook_subscription_by_id,get_webhook_subscription_by_id_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_webhook_subscription_by_id,get_webhook_subscription_by_id_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -402,8 +402,8 @@ def get_webhook_subscriptions_by_org_with_http_info(self, organization_id, **kwa body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_webhook_subscriptions_by_org,get_webhook_subscriptions_by_org_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_webhook_subscriptions_by_org,get_webhook_subscriptions_by_org_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -525,8 +525,8 @@ def notification_subscriptions_v1_webhooks_webhook_id_post_with_http_info(self, body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "notification_subscriptions_v1_webhooks_webhook_id_post,notification_subscriptions_v1_webhooks_webhook_id_post_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "notification_subscriptions_v1_webhooks_webhook_id_post,notification_subscriptions_v1_webhooks_webhook_id_post_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -649,8 +649,8 @@ def notification_subscriptions_v2_webhooks_webhook_id_patch_with_http_info(self, body_params = sdkTracker.insert_developer_id_tracker(body_params, 'update_webhook', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "notification_subscriptions_v2_webhooks_webhook_id_patch,notification_subscriptions_v2_webhooks_webhook_id_patch_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "notification_subscriptions_v2_webhooks_webhook_id_patch,notification_subscriptions_v2_webhooks_webhook_id_patch_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -773,8 +773,8 @@ def notification_subscriptions_v2_webhooks_webhook_id_status_put_with_http_info( body_params = sdkTracker.insert_developer_id_tracker(body_params, 'update_status', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "notification_subscriptions_v2_webhooks_webhook_id_status_put,notification_subscriptions_v2_webhooks_webhook_id_status_put_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "notification_subscriptions_v2_webhooks_webhook_id_status_put,notification_subscriptions_v2_webhooks_webhook_id_status_put_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -914,8 +914,8 @@ def save_asym_egress_key_with_http_info(self, v_c_sender_organization_id, v_c_pe body_params = sdkTracker.insert_developer_id_tracker(body_params, 'save_asym_egress_key', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "save_asym_egress_key,save_asym_egress_key_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "save_asym_egress_key,save_asym_egress_key_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/merchant_boarding_api.py b/CyberSource/api/merchant_boarding_api.py index 29293534..84c51df7 100644 --- a/CyberSource/api/merchant_boarding_api.py +++ b/CyberSource/api/merchant_boarding_api.py @@ -149,8 +149,8 @@ def get_registration_with_http_info(self, registration_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_registration,get_registration_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_registration,get_registration_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -272,8 +272,8 @@ def post_registration_with_http_info(self, post_registration_body, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'post_registration_body', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "post_registration,post_registration_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "post_registration,post_registration_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/microform_integration_api.py b/CyberSource/api/microform_integration_api.py index 95079508..5b9fc775 100644 --- a/CyberSource/api/microform_integration_api.py +++ b/CyberSource/api/microform_integration_api.py @@ -145,8 +145,8 @@ def generate_capture_context_with_http_info(self, generate_capture_context_reque body_params = sdkTracker.insert_developer_id_tracker(body_params, 'generate_capture_context_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "generate_capture_context,generate_capture_context_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "generate_capture_context,generate_capture_context_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/net_fundings_api.py b/CyberSource/api/net_fundings_api.py index 76c0cfd2..110b32ee 100644 --- a/CyberSource/api/net_fundings_api.py +++ b/CyberSource/api/net_fundings_api.py @@ -165,8 +165,8 @@ def get_net_funding_details_with_http_info(self, start_time, end_time, **kwargs) body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_net_funding_details,get_net_funding_details_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_net_funding_details,get_net_funding_details_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/notification_of_changes_api.py b/CyberSource/api/notification_of_changes_api.py index 14375d1a..206fd2d8 100644 --- a/CyberSource/api/notification_of_changes_api.py +++ b/CyberSource/api/notification_of_changes_api.py @@ -157,8 +157,8 @@ def get_notification_of_change_report_with_http_info(self, start_time, end_time, body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_notification_of_change_report,get_notification_of_change_report_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_notification_of_change_report,get_notification_of_change_report_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/orders_api.py b/CyberSource/api/orders_api.py index 1d994d14..59758ea1 100644 --- a/CyberSource/api/orders_api.py +++ b/CyberSource/api/orders_api.py @@ -145,8 +145,8 @@ def create_order_with_http_info(self, create_order_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_order_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_order,create_order_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_order,create_order_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -274,8 +274,8 @@ def update_order_with_http_info(self, id, update_order_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'update_order_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "update_order,update_order_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "update_order,update_order_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/payer_authentication_api.py b/CyberSource/api/payer_authentication_api.py index 3f1c3e51..41641fee 100644 --- a/CyberSource/api/payer_authentication_api.py +++ b/CyberSource/api/payer_authentication_api.py @@ -145,8 +145,8 @@ def check_payer_auth_enrollment_with_http_info(self, check_payer_auth_enrollment body_params = sdkTracker.insert_developer_id_tracker(body_params, 'check_payer_auth_enrollment_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "check_payer_auth_enrollment,check_payer_auth_enrollment_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "check_payer_auth_enrollment,check_payer_auth_enrollment_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -264,8 +264,8 @@ def payer_auth_setup_with_http_info(self, payer_auth_setup_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'payer_auth_setup_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "payer_auth_setup,payer_auth_setup_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "payer_auth_setup,payer_auth_setup_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -383,8 +383,8 @@ def validate_authentication_results_with_http_info(self, validate_request, **kwa body_params = sdkTracker.insert_developer_id_tracker(body_params, 'validate_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "validate_authentication_results,validate_authentication_results_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "validate_authentication_results,validate_authentication_results_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/payment_batch_summaries_api.py b/CyberSource/api/payment_batch_summaries_api.py index c6b63c8c..595e85d1 100644 --- a/CyberSource/api/payment_batch_summaries_api.py +++ b/CyberSource/api/payment_batch_summaries_api.py @@ -173,8 +173,8 @@ def get_payment_batch_summary_with_http_info(self, start_time, end_time, **kwarg body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_payment_batch_summary,get_payment_batch_summary_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_payment_batch_summary,get_payment_batch_summary_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/payment_instrument_api.py b/CyberSource/api/payment_instrument_api.py index 01421314..07542064 100644 --- a/CyberSource/api/payment_instrument_api.py +++ b/CyberSource/api/payment_instrument_api.py @@ -153,8 +153,8 @@ def delete_payment_instrument_with_http_info(self, payment_instrument_id, **kwar body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "delete_payment_instrument,delete_payment_instrument_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "delete_payment_instrument,delete_payment_instrument_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -284,8 +284,8 @@ def get_payment_instrument_with_http_info(self, payment_instrument_id, **kwargs) body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_payment_instrument,get_payment_instrument_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_payment_instrument,get_payment_instrument_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -425,8 +425,8 @@ def patch_payment_instrument_with_http_info(self, payment_instrument_id, patch_p body_params = sdkTracker.insert_developer_id_tracker(body_params, 'patch_payment_instrument_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "patch_payment_instrument,patch_payment_instrument_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "patch_payment_instrument,patch_payment_instrument_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -552,8 +552,8 @@ def post_payment_instrument_with_http_info(self, post_payment_instrument_request body_params = sdkTracker.insert_developer_id_tracker(body_params, 'post_payment_instrument_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "post_payment_instrument,post_payment_instrument_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "post_payment_instrument,post_payment_instrument_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/payment_links_api.py b/CyberSource/api/payment_links_api.py index 48d2d1d9..b1008152 100644 --- a/CyberSource/api/payment_links_api.py +++ b/CyberSource/api/payment_links_api.py @@ -145,8 +145,8 @@ def create_payment_link_with_http_info(self, create_payment_link_request, **kwar body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_payment_link_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_payment_link,create_payment_link_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_payment_link,create_payment_link_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -280,8 +280,8 @@ def get_all_payment_links_with_http_info(self, offset, limit, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_all_payment_links,get_all_payment_links_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_all_payment_links,get_all_payment_links_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -403,8 +403,8 @@ def get_payment_link_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_payment_link,get_payment_link_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_payment_link,get_payment_link_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -532,8 +532,8 @@ def update_payment_link_with_http_info(self, id, update_payment_link_request, ** body_params = sdkTracker.insert_developer_id_tracker(body_params, 'update_payment_link_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "update_payment_link,update_payment_link_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "update_payment_link,update_payment_link_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/payment_tokens_api.py b/CyberSource/api/payment_tokens_api.py index 96fc8465..461b8ac2 100644 --- a/CyberSource/api/payment_tokens_api.py +++ b/CyberSource/api/payment_tokens_api.py @@ -145,8 +145,8 @@ def retrieve_or_delete_payment_token_with_http_info(self, request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "retrieve_or_delete_payment_token,retrieve_or_delete_payment_token_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "retrieve_or_delete_payment_token,retrieve_or_delete_payment_token_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/payments_api.py b/CyberSource/api/payments_api.py index 45b3d69a..2fac9acb 100644 --- a/CyberSource/api/payments_api.py +++ b/CyberSource/api/payments_api.py @@ -155,8 +155,8 @@ def create_order_request_with_http_info(self, order_payment_request, id, **kwarg body_params = sdkTracker.insert_developer_id_tracker(body_params, 'order_payment_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_order_request,create_order_request_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_order_request,create_order_request_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -274,8 +274,8 @@ def create_payment_with_http_info(self, create_payment_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_payment_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_payment,create_payment_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_payment,create_payment_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -393,8 +393,8 @@ def create_session_request_with_http_info(self, create_session_req, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_session_req', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_session_request,create_session_request_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_session_request,create_session_request_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -522,8 +522,8 @@ def increment_auth_with_http_info(self, id, increment_auth_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'increment_auth_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "increment_auth,increment_auth_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "increment_auth,increment_auth_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -651,8 +651,8 @@ def refresh_payment_status_with_http_info(self, id, refresh_payment_status_reque body_params = sdkTracker.insert_developer_id_tracker(body_params, 'refresh_payment_status_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "refresh_payment_status,refresh_payment_status_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "refresh_payment_status,refresh_payment_status_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -780,8 +780,8 @@ def update_session_req_with_http_info(self, create_session_request, id, **kwargs body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_session_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "update_session_req,update_session_req_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "update_session_req,update_session_req_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/payouts_api.py b/CyberSource/api/payouts_api.py index 07e2445b..dad0e8b6 100644 --- a/CyberSource/api/payouts_api.py +++ b/CyberSource/api/payouts_api.py @@ -145,8 +145,8 @@ def oct_create_payment_with_http_info(self, oct_create_payment_request, **kwargs body_params = sdkTracker.insert_developer_id_tracker(body_params, 'oct_create_payment_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "oct_create_payment,oct_create_payment_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "oct_create_payment,oct_create_payment_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/plans_api.py b/CyberSource/api/plans_api.py index 3db85285..1aa0dadf 100644 --- a/CyberSource/api/plans_api.py +++ b/CyberSource/api/plans_api.py @@ -149,8 +149,8 @@ def activate_plan_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "activate_plan,activate_plan_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "activate_plan,activate_plan_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -268,8 +268,8 @@ def create_plan_with_http_info(self, create_plan_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_plan_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_plan,create_plan_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_plan,create_plan_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -391,8 +391,8 @@ def deactivate_plan_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "deactivate_plan,deactivate_plan_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "deactivate_plan,deactivate_plan_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -514,8 +514,8 @@ def delete_plan_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "delete_plan,delete_plan_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "delete_plan,delete_plan_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -637,8 +637,8 @@ def get_plan_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_plan,get_plan_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_plan,get_plan_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -749,8 +749,8 @@ def get_plan_code_with_http_info(self, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_plan_code,get_plan_code_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_plan_code,get_plan_code_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -882,8 +882,8 @@ def get_plans_with_http_info(self, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_plans,get_plans_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_plans,get_plans_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -1011,8 +1011,8 @@ def update_plan_with_http_info(self, id, update_plan_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'update_plan_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "update_plan,update_plan_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "update_plan,update_plan_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/purchase_and_refund_details_api.py b/CyberSource/api/purchase_and_refund_details_api.py index 32db6cfb..e1f7615a 100644 --- a/CyberSource/api/purchase_and_refund_details_api.py +++ b/CyberSource/api/purchase_and_refund_details_api.py @@ -181,8 +181,8 @@ def get_purchase_and_refund_details_with_http_info(self, start_time, end_time, * body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_purchase_and_refund_details,get_purchase_and_refund_details_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_purchase_and_refund_details,get_purchase_and_refund_details_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/push_funds_api.py b/CyberSource/api/push_funds_api.py index 208fd018..d01f4d6b 100644 --- a/CyberSource/api/push_funds_api.py +++ b/CyberSource/api/push_funds_api.py @@ -199,8 +199,8 @@ def create_push_funds_transfer_with_http_info(self, push_funds_request, content_ body_params = sdkTracker.insert_developer_id_tracker(body_params, 'push_funds_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_push_funds_transfer,create_push_funds_transfer_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_push_funds_transfer,create_push_funds_transfer_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/refund_api.py b/CyberSource/api/refund_api.py index bef40923..905e9c06 100644 --- a/CyberSource/api/refund_api.py +++ b/CyberSource/api/refund_api.py @@ -155,8 +155,8 @@ def refund_capture_with_http_info(self, refund_capture_request, id, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'refund_capture_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "refund_capture,refund_capture_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "refund_capture,refund_capture_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -284,8 +284,8 @@ def refund_payment_with_http_info(self, refund_payment_request, id, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'refund_payment_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "refund_payment,refund_payment_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "refund_payment,refund_payment_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/report_definitions_api.py b/CyberSource/api/report_definitions_api.py index e10a878c..bc28bf5c 100644 --- a/CyberSource/api/report_definitions_api.py +++ b/CyberSource/api/report_definitions_api.py @@ -161,8 +161,8 @@ def get_resource_info_by_report_definition_with_http_info(self, report_definitio body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_resource_info_by_report_definition,get_resource_info_by_report_definition_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_resource_info_by_report_definition,get_resource_info_by_report_definition_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -282,8 +282,8 @@ def get_resource_v2_info_with_http_info(self, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_resource_v2_info,get_resource_v2_info_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_resource_v2_info,get_resource_v2_info_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/report_downloads_api.py b/CyberSource/api/report_downloads_api.py index 624a77b7..da3e216d 100644 --- a/CyberSource/api/report_downloads_api.py +++ b/CyberSource/api/report_downloads_api.py @@ -161,8 +161,8 @@ def download_report_with_http_info(self, report_date, report_name, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "download_report,download_report_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "download_report,download_report_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/report_subscriptions_api.py b/CyberSource/api/report_subscriptions_api.py index a2b449c2..9ab27e48 100644 --- a/CyberSource/api/report_subscriptions_api.py +++ b/CyberSource/api/report_subscriptions_api.py @@ -149,8 +149,8 @@ def create_standard_or_classic_subscription_with_http_info(self, predefined_subs body_params = sdkTracker.insert_developer_id_tracker(body_params, 'predefined_subscription_request_bean', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_standard_or_classic_subscription,create_standard_or_classic_subscription_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_standard_or_classic_subscription,create_standard_or_classic_subscription_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -272,8 +272,8 @@ def create_subscription_with_http_info(self, create_report_subscription_request, body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_report_subscription_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_subscription,create_subscription_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_subscription,create_subscription_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -399,8 +399,8 @@ def delete_subscription_with_http_info(self, report_name, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "delete_subscription,delete_subscription_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "delete_subscription,delete_subscription_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -516,8 +516,8 @@ def get_all_subscriptions_with_http_info(self, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_all_subscriptions,get_all_subscriptions_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_all_subscriptions,get_all_subscriptions_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -643,8 +643,8 @@ def get_subscription_with_http_info(self, report_name, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_subscription,get_subscription_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_subscription,get_subscription_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/reports_api.py b/CyberSource/api/reports_api.py index 120d5ec2..5b3de1ef 100644 --- a/CyberSource/api/reports_api.py +++ b/CyberSource/api/reports_api.py @@ -149,8 +149,8 @@ def create_report_with_http_info(self, create_adhoc_report_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_adhoc_report_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_report,create_report_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_report,create_report_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -276,8 +276,8 @@ def get_report_by_report_id_with_http_info(self, report_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_report_by_report_id,get_report_by_report_id_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_report_by_report_id,get_report_by_report_id_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -440,8 +440,8 @@ def search_reports_with_http_info(self, start_time, end_time, time_query_type, * body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "search_reports,search_reports_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "search_reports,search_reports_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/retrieval_details_api.py b/CyberSource/api/retrieval_details_api.py index 7922a3f7..45a88a3b 100644 --- a/CyberSource/api/retrieval_details_api.py +++ b/CyberSource/api/retrieval_details_api.py @@ -161,8 +161,8 @@ def get_retrieval_details_with_http_info(self, start_time, end_time, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_retrieval_details,get_retrieval_details_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_retrieval_details,get_retrieval_details_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/retrieval_summaries_api.py b/CyberSource/api/retrieval_summaries_api.py index aa15de46..d74c864f 100644 --- a/CyberSource/api/retrieval_summaries_api.py +++ b/CyberSource/api/retrieval_summaries_api.py @@ -161,8 +161,8 @@ def get_retrieval_summary_with_http_info(self, start_time, end_time, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_retrieval_summary,get_retrieval_summary_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_retrieval_summary,get_retrieval_summary_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/reversal_api.py b/CyberSource/api/reversal_api.py index addb1e42..87e402ae 100644 --- a/CyberSource/api/reversal_api.py +++ b/CyberSource/api/reversal_api.py @@ -155,8 +155,8 @@ def auth_reversal_with_http_info(self, id, auth_reversal_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'auth_reversal_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "auth_reversal,auth_reversal_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "auth_reversal,auth_reversal_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -274,8 +274,8 @@ def mit_reversal_with_http_info(self, mit_reversal_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'mit_reversal_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "mit_reversal,mit_reversal_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "mit_reversal,mit_reversal_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/search_transactions_api.py b/CyberSource/api/search_transactions_api.py index bd1409e9..86245ea6 100644 --- a/CyberSource/api/search_transactions_api.py +++ b/CyberSource/api/search_transactions_api.py @@ -145,8 +145,8 @@ def create_search_with_http_info(self, create_search_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_search_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_search,create_search_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_search,create_search_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -268,8 +268,8 @@ def get_search_with_http_info(self, search_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_search,get_search_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_search,get_search_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/secure_file_share_api.py b/CyberSource/api/secure_file_share_api.py index 61248b8d..b52f319d 100644 --- a/CyberSource/api/secure_file_share_api.py +++ b/CyberSource/api/secure_file_share_api.py @@ -153,8 +153,8 @@ def get_file_with_http_info(self, file_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_file,get_file_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_file,get_file_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -292,8 +292,8 @@ def get_file_detail_with_http_info(self, start_date, end_date, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_file_detail,get_file_detail_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_file_detail,get_file_detail_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/subscriptions_api.py b/CyberSource/api/subscriptions_api.py index fdec6531..3968915e 100644 --- a/CyberSource/api/subscriptions_api.py +++ b/CyberSource/api/subscriptions_api.py @@ -153,8 +153,8 @@ def activate_subscription_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "activate_subscription,activate_subscription_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "activate_subscription,activate_subscription_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -276,8 +276,8 @@ def cancel_subscription_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "cancel_subscription,cancel_subscription_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "cancel_subscription,cancel_subscription_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -395,8 +395,8 @@ def create_subscription_with_http_info(self, create_subscription_request, **kwar body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_subscription_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_subscription,create_subscription_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_subscription,create_subscription_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -524,8 +524,8 @@ def get_all_subscriptions_with_http_info(self, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_all_subscriptions,get_all_subscriptions_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_all_subscriptions,get_all_subscriptions_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -647,8 +647,8 @@ def get_subscription_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_subscription,get_subscription_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_subscription,get_subscription_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -759,8 +759,8 @@ def get_subscription_code_with_http_info(self, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_subscription_code,get_subscription_code_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_subscription_code,get_subscription_code_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -882,8 +882,8 @@ def suspend_subscription_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "suspend_subscription,suspend_subscription_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "suspend_subscription,suspend_subscription_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -1011,8 +1011,8 @@ def update_subscription_with_http_info(self, id, update_subscription, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'update_subscription', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "update_subscription,update_subscription_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "update_subscription,update_subscription_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/subscriptions_follow_ons_api.py b/CyberSource/api/subscriptions_follow_ons_api.py index 67be5fb7..0a44ec24 100644 --- a/CyberSource/api/subscriptions_follow_ons_api.py +++ b/CyberSource/api/subscriptions_follow_ons_api.py @@ -155,8 +155,8 @@ def create_follow_on_subscription_with_http_info(self, request_id, create_subscr body_params = sdkTracker.insert_developer_id_tracker(body_params, 'create_subscription_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "create_follow_on_subscription,create_follow_on_subscription_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "create_follow_on_subscription,create_follow_on_subscription_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -278,8 +278,8 @@ def get_follow_on_subscription_with_http_info(self, request_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_follow_on_subscription,get_follow_on_subscription_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_follow_on_subscription,get_follow_on_subscription_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/taxes_api.py b/CyberSource/api/taxes_api.py index 5a058ba7..439e649f 100644 --- a/CyberSource/api/taxes_api.py +++ b/CyberSource/api/taxes_api.py @@ -145,8 +145,8 @@ def calculate_tax_with_http_info(self, tax_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'tax_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "calculate_tax,calculate_tax_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "calculate_tax,calculate_tax_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -274,8 +274,8 @@ def void_tax_with_http_info(self, void_tax_request, id, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'void_tax_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "void_tax,void_tax_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "void_tax,void_tax_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/token_api.py b/CyberSource/api/token_api.py index c2a5a22f..6c488afb 100644 --- a/CyberSource/api/token_api.py +++ b/CyberSource/api/token_api.py @@ -169,8 +169,8 @@ def get_card_art_asset_with_http_info(self, instrument_identifier_id, token_prov body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_card_art_asset,get_card_art_asset_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_card_art_asset,get_card_art_asset_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -302,8 +302,8 @@ def post_token_payment_credentials_with_http_info(self, token_id, post_payment_c body_params = sdkTracker.insert_developer_id_tracker(body_params, 'post_payment_credentials_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "post_token_payment_credentials,post_token_payment_credentials_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "post_token_payment_credentials,post_token_payment_credentials_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/tokenized_card_api.py b/CyberSource/api/tokenized_card_api.py index a47b693b..c6c0ffa1 100644 --- a/CyberSource/api/tokenized_card_api.py +++ b/CyberSource/api/tokenized_card_api.py @@ -153,8 +153,8 @@ def delete_tokenized_card_with_http_info(self, tokenized_card_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "delete_tokenized_card,delete_tokenized_card_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "delete_tokenized_card,delete_tokenized_card_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -280,8 +280,8 @@ def get_tokenized_card_with_http_info(self, tokenized_card_id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_tokenized_card,get_tokenized_card_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_tokenized_card,get_tokenized_card_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -403,8 +403,8 @@ def post_tokenized_card_with_http_info(self, tokenizedcard_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'tokenizedcard_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "post_tokenized_card,post_tokenized_card_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "post_tokenized_card,post_tokenized_card_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/transaction_batches_api.py b/CyberSource/api/transaction_batches_api.py index 84317a81..90939d2e 100644 --- a/CyberSource/api/transaction_batches_api.py +++ b/CyberSource/api/transaction_batches_api.py @@ -157,8 +157,8 @@ def get_transaction_batch_details_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_transaction_batch_details,get_transaction_batch_details_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_transaction_batch_details,get_transaction_batch_details_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -280,8 +280,8 @@ def get_transaction_batch_id_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_transaction_batch_id,get_transaction_batch_id_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_transaction_batch_id,get_transaction_batch_id_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -411,8 +411,8 @@ def get_transaction_batches_with_http_info(self, start_time, end_time, **kwargs) body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_transaction_batches,get_transaction_batches_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_transaction_batches,get_transaction_batches_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -533,8 +533,8 @@ def upload_transaction_batch_with_http_info(self, file, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "upload_transaction_batch,upload_transaction_batch_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "upload_transaction_batch,upload_transaction_batch_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/transaction_details_api.py b/CyberSource/api/transaction_details_api.py index b30fa9ce..0d23742b 100644 --- a/CyberSource/api/transaction_details_api.py +++ b/CyberSource/api/transaction_details_api.py @@ -149,8 +149,8 @@ def get_transaction_with_http_info(self, id, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_transaction,get_transaction_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_transaction,get_transaction_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/transient_token_data_api.py b/CyberSource/api/transient_token_data_api.py index aaedbdd2..a612defa 100644 --- a/CyberSource/api/transient_token_data_api.py +++ b/CyberSource/api/transient_token_data_api.py @@ -149,8 +149,8 @@ def get_payment_credentials_for_transient_token_with_http_info(self, payment_cre body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_payment_credentials_for_transient_token,get_payment_credentials_for_transient_token_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_payment_credentials_for_transient_token,get_payment_credentials_for_transient_token_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -272,8 +272,8 @@ def get_transaction_for_transient_token_with_http_info(self, transient_token, ** body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_transaction_for_transient_token,get_transaction_for_transient_token_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_transaction_for_transient_token,get_transaction_for_transient_token_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/unified_checkout_capture_context_api.py b/CyberSource/api/unified_checkout_capture_context_api.py index 75711b76..6d9c733c 100644 --- a/CyberSource/api/unified_checkout_capture_context_api.py +++ b/CyberSource/api/unified_checkout_capture_context_api.py @@ -145,8 +145,8 @@ def generate_unified_checkout_capture_context_with_http_info(self, generate_unif body_params = sdkTracker.insert_developer_id_tracker(body_params, 'generate_unified_checkout_capture_context_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "generate_unified_checkout_capture_context,generate_unified_checkout_capture_context_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "generate_unified_checkout_capture_context,generate_unified_checkout_capture_context_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/user_management_api.py b/CyberSource/api/user_management_api.py index ff83f553..481b4d82 100644 --- a/CyberSource/api/user_management_api.py +++ b/CyberSource/api/user_management_api.py @@ -155,8 +155,8 @@ def get_users_with_http_info(self, **kwargs): body_params = file_post_body_and_delimiter[0] header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "get_users,get_users_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "get_users,get_users_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/user_management_search_api.py b/CyberSource/api/user_management_search_api.py index e2841ea3..1f5ca7f2 100644 --- a/CyberSource/api/user_management_search_api.py +++ b/CyberSource/api/user_management_search_api.py @@ -145,8 +145,8 @@ def search_users_with_http_info(self, search_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'search_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "search_users,search_users_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "search_users,search_users_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/verification_api.py b/CyberSource/api/verification_api.py index bbcd5485..78dbf70c 100644 --- a/CyberSource/api/verification_api.py +++ b/CyberSource/api/verification_api.py @@ -145,8 +145,8 @@ def validate_export_compliance_with_http_info(self, validate_export_compliance_r body_params = sdkTracker.insert_developer_id_tracker(body_params, 'validate_export_compliance_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "validate_export_compliance,validate_export_compliance_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "validate_export_compliance,validate_export_compliance_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -264,8 +264,8 @@ def verify_customer_address_with_http_info(self, verify_customer_address_request body_params = sdkTracker.insert_developer_id_tracker(body_params, 'verify_customer_address_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = False - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "verify_customer_address,verify_customer_address_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "verify_customer_address,verify_customer_address_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting diff --git a/CyberSource/api/void_api.py b/CyberSource/api/void_api.py index 4d2c9686..7842b933 100644 --- a/CyberSource/api/void_api.py +++ b/CyberSource/api/void_api.py @@ -145,8 +145,8 @@ def mit_void_with_http_info(self, mit_void_request, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'mit_void_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "mit_void,mit_void_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "mit_void,mit_void_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -274,8 +274,8 @@ def void_capture_with_http_info(self, void_capture_request, id, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'void_capture_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "void_capture,void_capture_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "void_capture,void_capture_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -403,8 +403,8 @@ def void_credit_with_http_info(self, void_credit_request, id, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'void_credit_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "void_credit,void_credit_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "void_credit,void_credit_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -532,8 +532,8 @@ def void_payment_with_http_info(self, void_payment_request, id, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'void_payment_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "void_payment,void_payment_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "void_payment,void_payment_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting @@ -661,8 +661,8 @@ def void_refund_with_http_info(self, void_refund_request, id, **kwargs): body_params = sdkTracker.insert_developer_id_tracker(body_params, 'void_refund_request', self.api_client.mconfig.run_environment, self.api_client.mconfig.defaultDeveloperId) body_params = process_body(body_params) - is_mle_supported_by_cybs_for_api = True - if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, is_mle_supported_by_cybs_for_api, "void_refund,void_refund_with_http_info"): + inbound_mle_status = "false" + if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "void_refund,void_refund_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params) # Authentication setting From 6b3b6f7be00c11ba7d2153d08ec3b21c1f27b00a Mon Sep 17 00:00:00 2001 From: mahmishr Date: Tue, 19 Aug 2025 12:42:06 +0530 Subject: [PATCH 6/6] Update api.mustache --- generator/cybersource-python-template/api.mustache | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/generator/cybersource-python-template/api.mustache b/generator/cybersource-python-template/api.mustache index d0e0a1a3..07ca200d 100644 --- a/generator/cybersource-python-template/api.mustache +++ b/generator/cybersource-python-template/api.mustache @@ -210,7 +210,7 @@ class {{classname}}(object): header_params['Content-Type'] = f"multipart/form-data; boundary={file_post_body_and_delimiter[1]}" {{/bodyParam}} - inbound_mle_status = "{{#vendorExtensions.x-devcenter-metaData.inboundMLEStatus}}{{vendorExtensions.x-devcenter-metaData.inboundMLEStatus}}{{/vendorExtensions.x-devcenter-metaData.inboundMLEStatus}}{{^vendorExtensions.x-devcenter-metaData.inboundMLEStatus}}false{{/vendorExtensions.x-devcenter-metaData.inboundMLEStatus}}" + inbound_mle_status = "{{#vendorExtensions.x-devcenter-metaData.mleForRequest}}{{vendorExtensions.x-devcenter-metaData.mleForRequest}}{{/vendorExtensions.x-devcenter-metaData.mleForRequest}}{{^vendorExtensions.x-devcenter-metaData.mleForRequest}}false{{/vendorExtensions.x-devcenter-metaData.mleForRequest}}" if MLEUtility.check_is_mle_for_api(self.api_client.mconfig, inbound_mle_status, "{{operationId}},{{operationId}}_with_http_info"): body_params = MLEUtility.encrypt_request_payload(self.api_client.mconfig, body_params)