Example #1
0
 def pre_processor(self, data):
     # Again, the API could return an empty string where it SHOULD return null or an empty object.
     if ParamValidator.is_empty(data['endUser']):
         del data['endUser']
     if ParamValidator.is_empty(data['transaction']):
         del data['transaction']
     return data
 def pre_processor(self, data):
     #  API might return empty string instead of dictionary object
     if ParamValidator.is_empty(data['settings']):
         del data['settings']
     #  API might return empty string instead of dictionary object
     if ParamValidator.is_empty(data['paymentOptions']):
             del data['paymentOptions']
     elif 'paymentOptions' in data and ParamValidator.not_empty(data['paymentOptions']):
         #  v2.x has NO fields.Dict implementation like fields.List, so we'll have to handle this ourselves
         list = []
         for i, item in data['paymentOptions'].items():
             list.append(item)
         data['paymentOptions'] = list
     #  API might return empty string instead of dictionary object
     if ParamValidator.is_empty(data['countryOptionList']):
         del data['countryOptionList']
     elif 'countryOptionList' in data and ParamValidator.not_empty(data['countryOptionList']):
         #  v2.x has NO fields.Dict implementation like fields.List, so we'll have to handle this ourselves
         list = []
         for i, item in data['countryOptionList'].items():
             list.append(item)
         data['countryOptionList'] = list
     #  API might return empty string instead of dictionary object
     if 'paymentProfiles' in data and ParamValidator.is_empty(data['paymentProfiles']):
         del data['paymentProfiles']
     elif 'paymentProfiles' in data and ParamValidator.not_empty(data['paymentProfiles']):
         #  v2.x has NO fields.Dict implementation like fields.List, so we'll have to handle this ourselves
         list = []
         for i, item in data['paymentProfiles'].items():
             list.append(item)
         data['paymentProfiles'] = list
     return data
Example #3
0
 def preprocess(self, data):
     # Fix EMPTY settings
     if ParamValidator.is_empty(data['settings']):
         del data['settings']
     if ParamValidator.is_empty(data['countryOptionList']):
         del data['countryOptionList']
     elif 'countryOptionList' in data and ParamValidator.not_empty(data['countryOptionList']):
         #  v2.x has NO fields.Dict implementation like fields.List, so we'll have to handle this ourselves
         list = []
         for i, item in data['countryOptionList'].items():
             list.append(item)
         data['countryOptionList'] = list
     return data
Example #4
0
    def _merge_stats_data_dict(self, innerdict):
        if ParamValidator.is_null(self.stats_data):
            innerdict[
                'statsData[object]'] = 'pythonsdk v' + PAYNL_CLIENT_VERSION
            return
        if ParamValidator.is_empty(self.stats_data.object):
            innerdict[
                'statsData[object]'] = 'pythonsdk v' + PAYNL_CLIENT_VERSION

        if ParamValidator.not_empty(self.stats_data.promotor_id):
            innerdict['statsData[promotorId]'] = self.stats_data.promotor_id
        if ParamValidator.not_empty(self.stats_data.info):
            innerdict['statsData[info]'] = self.stats_data.info
        if ParamValidator.not_empty(self.stats_data.tool):
            innerdict['statsData[tool]'] = self.stats_data.tool
        if ParamValidator.not_empty(self.stats_data.extra1):
            innerdict['statsData[extra1]'] = self.stats_data.extra1
        if ParamValidator.not_empty(self.stats_data.extra2):
            innerdict['statsData[extra2]'] = self.stats_data.extra2
        if ParamValidator.not_empty(self.stats_data.extra3):
            innerdict['statsData[extra3]'] = self.stats_data.extra3
        if ParamValidator.not_empty(self.stats_data.domain_id):
            innerdict['statsData[domainId]'] = self.stats_data.domain_id
        if ParamValidator.not_empty(self.stats_data.object):
            innerdict['statsData[object]'] = self.stats_data.object
Example #5
0
 def pre_processor(self, data):
     # Again, the API returns an empty string where it SHOULD return null or an empty list.
     if 'refundedTransactions' in data and ParamValidator.is_empty(
             data['refundedTransactions']):
         data['refundedTransactions'] = []
     elif 'refundedTransactions' in data and ParamValidator.not_empty(
             data['refundedTransactions']):
         #  v2.x has NO fields.Dict implementation like fields.List, so we'll have to handle this ourselves
         list = []
         for item in data['refundedTransactions']:
             list.append(item)
         data['refundedTransactions'] = list
     if 'failedTransactions' in data and ParamValidator.is_empty(
             data['failedTransactions']):
         data['failedTransactions'] = []
     elif 'failedTransactions' in data and ParamValidator.not_empty(
             data['failedTransactions']):
         #  v2.x has NO fields.Dict implementation like fields.List, so we'll have to handle this ourselves
         list = []
         for item in data['failedTransactions']:
             list.append(item)
         data['failedTransactions'] = list
     return data
Example #6
0
    def perform_request(self, request: RequestBase, method: str = 'POST'):
        """
        Performs the actual call to the API and fill the responses.

        This method will basically verify the given :class:`paynlsdk.api.requestbase.RequestBase` class,
        perform the call to the API, interpret the result and fill the request's
        :ivar:`paynlsdk.api.requestbase.RequestBase.response`.
        Interpreting the result is done by evaluating the returned JSON using marshmallow.
        When validation is complete, the request class will internally set the response, which is always an instance
        of a :class:`paynlsdk.api.responsebase.ResponseBase` instance

        .. seealso::
            :class:`paynlsdk.api.requestbase.RequestBase` and all it's derived classes

            :class:`paynlsdk.api.responsebase.ResponseBase` and all it's derived classes

        :param request: the generic request to perform
        :type request: paynlsdk.api.requestbase.RequestBase
        :param method: HTTP method (stick to POST!)
        :type method: str
        :return: void
        :rtype: void
        :raise paynlsdk.exceptions.ErrorException: generic error occurred
        :raise paynlsdk.exceptions.SchemaException: error occurred during result parsing (schema load/validation failure)
        """
        headers = {
            'Accept': 'application/json',
            'User-Agent': self.user_agent()
        }
        if APIAuthentication.use_http_auth:
            headers['Authorization'] = 'Basic {auth}'.format(
                auth=self.get_auth())

        # Lazy loader for api credentials.
        if request.requires_api_token() and ParamValidator.is_empty(request.api_token)\
                and ParamValidator.not_empty(APIAuthentication.api_token):
            request.api_token = APIAuthentication.api_token
        if request.requires_service_id() and ParamValidator.is_empty(request.service_id)\
                and ParamValidator.not_empty(APIAuthentication.service_id):
            request.service_id = APIAuthentication.service_id

        # Build url
        url = "{0}/{1}".format(PAYNL_END_POINT, request.get_url())
        parameters = request.get_parameters()
        if APIAuthentication.use_http_auth and 'token' in parameters:
            del parameters['token']

        if self.print_debug:
            print("Calling {} using {}".format(url, method))
            print("HTTP Headers: {}".format(json.dumps(headers)))
            print("Params: {}".format(json.dumps(parameters)))

        if method.upper() == 'GET':
            response = requests.get(url,
                                    verify=True,
                                    headers=headers,
                                    params=parameters)
        else:
            response = requests.post(url,
                                     verify=True,
                                     headers=headers,
                                     data=parameters)

        if response.status_code not in self.__supported_status_codes:
            response.raise_for_status()

        if self.print_debug:
            print("Response object: {}".format(response))
            print("Raw response: {}".format(response.text))

        # Now the we have a response, let the request class handle the response.
        request.raw_response = response.text

        if self.print_debug:
            print(type(request.response))

        if request.response.is_error():
            raise ErrorException(request.response.request)
Example #7
0
 def _merge_end_user_dict(self, innerdict):
     if ParamValidator.is_null(self.end_user):
         return
     if ParamValidator.not_empty(self.end_user.access_code):
         innerdict['enduser[accessCode]'] = self.end_user.access_code
     if ParamValidator.not_empty(self.end_user.language):
         innerdict['enduser[language]'] = self.end_user.language
     if ParamValidator.not_empty(self.end_user.initials):
         innerdict['enduser[initials]'] = self.end_user.initials
     if ParamValidator.not_empty(self.end_user.last_name):
         innerdict['enduser[lastName]'] = self.end_user.last_name
     if ParamValidator.not_empty(self.end_user.gender):
         innerdict['enduser[gender]'] = self.end_user.gender
     if ParamValidator.not_empty(self.end_user.dob):
         innerdict['enduser[dob]'] = self.end_user.dob.strftime('%d-%m-%Y')
     if ParamValidator.not_empty(self.end_user.phone_number):
         innerdict['enduser[phoneNumber]'] = self.end_user.phone_number
     if ParamValidator.not_empty(self.end_user.email_address):
         innerdict['enduser[emailAddress]'] = self.end_user.email_address
     if ParamValidator.not_empty(self.end_user.bank_account):
         innerdict['enduser[bankAccount]'] = self.end_user.bank_account
     if ParamValidator.not_empty(self.end_user.iban):
         innerdict['enduser[iban]'] = self.end_user.iban
     if ParamValidator.not_empty(self.end_user.bic):
         innerdict['enduser[bic]'] = self.end_user.bic
     if self.end_user.send_confirm_email:
         innerdict['enduser[sendConfirmMail]'] = 1
     else:
         innerdict['enduser[sendConfirmMail]'] = 0
     if ParamValidator.not_empty(self.end_user.customer_reference):
         innerdict[
             'enduser[customerReference]'] = self.end_user.customer_reference
     if ParamValidator.not_empty(self.end_user.customer_trust):
         innerdict['enduser[customerTrust]'] = self.end_user.customer_trust
     if not ParamValidator.is_null(self.end_user.address):
         if not ParamValidator.is_empty(self.end_user.address.street_name):
             innerdict[
                 'enduser[address][streetName]'] = self.end_user.address.street_name
         if not ParamValidator.is_empty(
                 self.end_user.address.street_number):
             innerdict[
                 'enduser[address][streetNumber]'] = self.end_user.address.street_number
         if not ParamValidator.is_empty(
                 self.end_user.address.street_number_extension):
             innerdict[
                 'enduser[address][streetNumberExtension]'] = self.end_user.address.street_number_extension
         if not ParamValidator.is_empty(self.end_user.address.zip_code):
             innerdict[
                 'enduser[address][zipCode]'] = self.end_user.address.zip_code
         if not ParamValidator.is_empty(self.end_user.address.city):
             innerdict[
                 'enduser[address][city]'] = self.end_user.address.city
         if not ParamValidator.is_empty(self.end_user.address.region_code):
             innerdict[
                 'enduser[address][regionCode]'] = self.end_user.address.region_code
         if not ParamValidator.is_empty(self.end_user.address.country_code):
             innerdict[
                 'enduser[address][countryCode]'] = self.end_user.address.country_code
     if not ParamValidator.is_null(self.end_user.invoice_address):
         if not ParamValidator.is_empty(
                 self.end_user.invoice_address.initials):
             innerdict[
                 'enduser[invoiceAddress][initials]'] = self.end_user.invoice_address.initials
         if not ParamValidator.is_empty(
                 self.end_user.invoice_address.last_name):
             innerdict[
                 'enduser[invoiceAddress][lastName]'] = self.end_user.invoice_address.last_name
         if not ParamValidator.is_empty(
                 self.end_user.invoice_address.gender):
             innerdict[
                 'enduser[invoiceAddress][gender]'] = self.end_user.invoice_address.gender
         if not ParamValidator.is_empty(
                 self.end_user.invoice_address.street_name):
             innerdict[
                 'enduser[invoiceAddress][streetName]'] = self.end_user.invoice_address.street_name
         if not ParamValidator.is_empty(
                 self.end_user.invoice_address.street_number):
             innerdict[
                 'enduser[invoiceAddress][streetNumber]'] = self.end_user.invoice_address.street_number
         if not ParamValidator.is_empty(
                 self.end_user.invoice_address.street_number_extension):
             innerdict[
                 'enduser[invoiceAddress][streetNumberExtension]'] = self.end_user.invoice_address.street_number_extension
         if not ParamValidator.is_empty(
                 self.end_user.invoice_address.zip_code):
             innerdict[
                 'enduser[invoiceAddress][zipCode]'] = self.end_user.invoice_address.zip_code
         if not ParamValidator.is_empty(self.end_user.invoice_address.city):
             innerdict[
                 'enduser[invoiceAddress][city]'] = self.end_user.invoice_address.city
         if not ParamValidator.is_empty(
                 self.end_user.invoice_address.region_code):
             innerdict[
                 'enduser[invoiceAddress][regionCode]'] = self.end_user.invoice_address.region_code
         if not ParamValidator.is_empty(
                 self.end_user.invoice_address.country_code):
             innerdict[
                 'enduser[invoiceAddress][countryCode]'] = self.end_user.invoice_address.country_code
     if not ParamValidator.is_null(self.end_user.company):
         if not ParamValidator.is_empty(self.end_user.company.name):
             innerdict[
                 'enduser[company][name]'] = self.end_user.company.name
         if not ParamValidator.is_empty(self.end_user.company.coc_number):
             innerdict[
                 'enduser[company][cocNumber]'] = self.end_user.company.coc_number
         if not ParamValidator.is_empty(self.end_user.company.vat_number):
             innerdict[
                 'enduser[company][vatNumber]'] = self.end_user.company.vat_number
         if not ParamValidator.is_empty(self.end_user.company.country_code):
             innerdict[
                 'enduser[company][countryCode]'] = self.end_user.company.country_code