flittpayments 1.0.3__tar.gz

flittpayments-1.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 flittpayments
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flittpayments-1.0.3/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.2
+Name: flittpayments
+Version: 1.0.3
+Summary: Python SDK for Flitt clients.
+Home-page: https://github.com/flittpayments/python/
+Author: Dmitriy Miroshnikov
+License: MIT
+Classifier: Environment :: Web Environment
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: six
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+
+    Flitt python sdk. 
+    Docs   - https://https://docs.flitt.com/
+    README - https://https://github.com/flittpayments/python/blob/master/README.md
+  

flittpayments-1.0.3/README.md

@@ -0,0 +1,46 @@
+# flittpayments Python SDK client
+
+
+## Payment service provider
+A payment service provider (PSP) offers shops online services for accepting electronic payments by a variety of payment methods including credit card, bank-based payments such as direct debit, bank transfer, and real-time bank transfer based on online banking. Typically, they use a software as a service model and form a single payment gateway for their clients (merchants) to multiple payment methods. 
+[read more](https://en.wikipedia.org/wiki/Payment_service_provider)
+
+Requirements
+------------
+- Python (2.4, 2.7, 3.3, 3.4, 3.5, 3.6, 3.7)
+
+Dependencies
+------------
+- requests
+- six
+
+Installation
+------------
+```bash
+pip install flittpayments
+```
+### Simple start
+
+```python
+from flittpayments import Api, Checkout
+api = Api(merchant_id=1549901,
+          secret_key='test')
+checkout = Checkout(api=api)
+data = {
+    "currency": "USD",
+    "amount": 10000
+}
+url = checkout.url(data).get('checkout_url')
+```
+
+Tests
+-----------------
+First, install `tox` `<http://tox.readthedocs.org/en/latest/>`
+
+To run testing:
+
+```bash
+tox
+```
+
+This will run all tests, against all supported Python versions.

flittpayments-1.0.3/flittpayments/__init__.py

@@ -0,0 +1,6 @@
+from flittpayments.configuration import __version__, __api_url__
+from flittpayments.api import Api
+from flittpayments.checkout import Checkout
+from flittpayments.order import Order
+from flittpayments.payment import Payment, Pcidss
+from flittpayments.resources import Resource

flittpayments-1.0.3/flittpayments/api.py

@@ -0,0 +1,117 @@
+from __future__ import absolute_import, unicode_literals
+from flittpayments.configuration import (__api_url__, __protocol__, __r_type__)
+from flittpayments import exceptions
+
+import os
+import requests
+import logging
+import flittpayments.helpers as helper
+import flittpayments.utils as utils
+
+log = logging.getLogger(__name__)
+
+
+class Api(object):
+    user_agent = 'Python SDK'
+
+    def __init__(self, **kwargs):
+        """
+        :param kwargs: args
+        :arg merchant_id Merchant id numeric
+        :arg secret_key Secret key string
+        :arg request_type request type allowed json, xml, form
+        :arg api_domain api domain
+        :arg api_protocol allowed protocols 1.0, 2.0
+        """
+        self.merchant_id = kwargs.get('merchant_id', '')
+        self.secret_key = kwargs.get('secret_key', '')
+        self.request_type = kwargs.get('request_type', __r_type__)
+        if not self.merchant_id or not self.secret_key:
+            self.merchant_id = os.environ.get('CLOUDIPSP_MERCHANT_ID', '')
+            self.secret_key = os.environ.get('CLOUDIPSP_SECRETKEY', '')
+        domain = kwargs.get('api_domain', 'pay.flitt.com')
+        self.api_url = __api_url__.format(api_domain=domain)
+        self.api_protocol = kwargs.get('api_protocol', __protocol__)
+        if self.api_protocol not in ('1.0', '2.0'):
+            raise ValueError('Incorrect protocol version')
+        if self.api_protocol == '2.0' and self.request_type != 'json':
+            raise ValueError('In protocol \'2.0\' only json allowed')
+
+    def _headers(self):
+        """
+        :return: request headers
+        """
+        return {
+            'User-Agent': self.user_agent,
+            'Content-Type': helper.get_request_type(self.request_type),
+        }
+
+    def _request(self, url, method, data, headers):
+        """
+        :param url: request url
+        :param method: request method, POST default
+        :param data: request data
+        :param headers: request headers
+        :return: api response
+        """
+        log.debug('Request Type: %s' % self.request_type)
+        log.debug('URL: %s' % url)
+        log.debug('Data: %s' % str(data))
+        log.debug('Headers: %s' % str(headers))
+
+        response = requests.request(method, url, data=data, headers=headers)
+        return self._response(response, response.content.decode('utf-8'))
+
+    def _response(self, response, content):
+        """
+        :param response: api response
+        :param content: api response body
+        :return: if response header 200 or 201 return response data
+        """
+        status = response.status_code
+
+        log.debug('Status: %s' % str(status))
+        log.debug('Content: %s' % content)
+
+        if status in (200, 201):
+            return content
+
+        raise exceptions.ServiceError(
+            'Response code is: {status}'.format(status=status))
+
+    def post(self, url, data=list, headers=None):
+        """
+        :param url: endpoint api url
+        :param data: request data
+        :param headers: request headers
+        :return: request
+        """
+        log.debug('Protocol version: %s' % self.request_type)
+
+        if 'merchant_id' not in data:
+            data['merchant_id'] = self.merchant_id
+        if 'reservation_data' in data:
+            data['reservation_data'] = utils.to_b64(
+                data['reservation_data'])
+
+        if self.api_protocol == '2.0':
+            b64_data = utils.to_b64({'order': data})
+            data_v2 = {
+                'data': b64_data,
+                'version': self.api_protocol,
+                'signature': helper.get_signature(self.secret_key,
+                                                  b64_data,
+                                                  self.api_protocol)
+            }
+            data_string = utils.to_json({'request': data_v2})
+        else:
+            if 'signature' not in data:
+                data['signature'] = helper.get_signature(self.secret_key,
+                                                         data,
+                                                         self.api_protocol)
+            data_string = helper.get_data({'request': data}, self.request_type)
+
+        return self._request(
+            utils.join_url(self.api_url, url), 'POST',
+            data=data_string,
+            headers=utils.merge_dict(headers, self._headers()))

flittpayments-1.0.3/flittpayments/checkout.py

@@ -0,0 +1,137 @@
+from __future__ import absolute_import, unicode_literals
+from flittpayments.resources import Resource
+from datetime import datetime
+
+import flittpayments.helpers as helper
+
+
+class Checkout(Resource):
+    def url(self, data):
+        """
+        Method to generate checkout url
+        :param data: order data
+        :return: api response
+        """
+        path = '/checkout/url/'
+        params = self._required(data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+
+        return self.response(result)
+
+    def token(self, data):
+        """
+        Method to generate checkout token
+        :param data: order data
+        :return: api response
+        """
+        path = '/checkout/token/'
+        params = self._required(data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+
+        return self.response(result)
+
+    def verification(self, data):
+        """
+        Method to generate checkout verification url
+        :param data: order data
+        :return: api response
+        """
+        path = '/checkout/url/'
+        verification_data = {
+            'verification': 'Y',
+            'verification_type': data.get('verification_type', 'code')
+        }
+        data.update(verification_data)
+        params = self._required(data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+
+        return self.response(result)
+
+    def subscription(self, data):
+        """
+        Method to generate checkout url with calendar
+        :param data: order data
+        data = {
+            "currency": "UAH", -> currency ('UAH', 'GEL', 'USD')
+            "amount": 10000, -> amount of the order (int)
+            "recurring_data": {
+                "every": 1, -> frequency of the recurring order (int)
+                "amount": 10000, -> amount of the recurring order (int)
+                "period": 'month', -> period of the recurring order ('day', 'month', 'year')
+                "start_time": '2020-07-24', -> start date of the recurring order ('YYYY-MM-DD')
+                "readonly": 'y', -> possibility to change parameters of the recurring order by user ('y', 'n')
+                "state": 'y' -> default state of the recurring order after opening url of the order ('y', 'n')
+            }
+        }
+        :return: api response
+        """
+        if self.api.api_protocol != '2.0':
+            raise Exception('This method allowed only for v2.0')
+        path = '/checkout/url/'
+        recurring_data = data.get('recurring_data', '')
+        subscription_data = {
+            'subscription': 'Y',
+            'recurring_data': {
+                'start_time': recurring_data.get('start_time', ''),
+                'amount': recurring_data.get('amount', ''),
+                'every': recurring_data.get('every', ''),
+                'period': recurring_data.get('period', ''),
+                'readonly': recurring_data.get('readonly', ''),
+                'state': recurring_data.get('state', '')
+            }
+        }
+
+        helper.check_data(subscription_data['recurring_data'])
+        self._validate_recurring_data(subscription_data['recurring_data'])
+        subscription_data.update(data)
+        params = self._required(subscription_data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+
+        return self.response(result)
+
+    def subscription_stop(self, order_id):
+        """
+          Stop calendar payments
+        """
+        if self.api.api_protocol != '2.0':
+            raise Exception('This method allowed only for v2.0')
+        path = '/subscription/'
+        params = {'order_id': order_id, 'action': 'stop'}
+        result = self.api.post(path, data=params, headers=self.__headers__)
+
+        return self.response(result)
+
+    @staticmethod
+    def _validate_recurring_data(data):
+        """
+        Validation recurring data params
+        :param data: recurring data
+        :return: exception
+        """
+        try:
+            datetime.strptime(data['start_time'], '%Y-%m-%d')
+        except ValueError:
+            raise ValueError(
+                "Incorrect date format. 'Y-m-d' is allowed")
+        if data['period'] not in ('day', 'week', 'month'):
+            raise ValueError(
+                "Incorrect period. ('day','week','month') is allowed")
+
+    def _required(self, data):
+        """
+        Required data to send
+        :param data:
+        :return: parameters to send
+        """
+        self.order_id = data.get('order_id') or helper.generate_order_id()
+        order_desc = data.get('order_desc') or helper.get_desc(self.order_id)
+        params = {
+            'order_id': self.order_id,
+            'order_desc': order_desc,
+            'amount': data.get('amount', ''),
+            'currency': data.get('currency', '')
+        }
+        helper.check_data(params)
+        params.update(data)
+
+        return params

flittpayments-1.0.3/flittpayments/configuration.py

@@ -0,0 +1,5 @@
+__version__ = '1.0.3'
+__api_url__ = 'https://{api_domain}/api'
+__sign_sep__ = '|'
+__protocol__ = '1.0'
+__r_type__ = 'json'

flittpayments-1.0.3/flittpayments/exceptions.py

@@ -0,0 +1,45 @@
+from __future__ import absolute_import, unicode_literals
+
+
+class RequestError(Exception):
+    """
+    Some required param is missing.
+    """
+
+    def __init__(self, param):
+        self.param = param
+
+    def __str__(self):
+        return "Required parameter '%s' is missing." % self.param
+
+
+class ResponseError(Exception):
+    """
+    Handling api response error.
+    """
+
+    def __init__(self, response):
+        self.response = response
+
+    def __str__(self):
+        message = ''
+        if 'response_status' in self.response:
+            message += "Response status is %s." \
+                       % self.response.get('response_status', '')
+        if 'error_message' in self.response:
+            message += " Error message: %s." \
+                       % (self.response.get('error_message'))
+        if 'error_code' in self.response:
+            message += " Error code: %s." \
+                       % (self.response.get('error_code'))
+        if 'request_id' in self.response:
+            message += " Request id: %s." \
+                       % (self.response.get('request_id'))
+        message += " Check parameters"
+        return message
+
+
+class ServiceError(Exception):
+    """
+    If response code not in (200, 201).
+    """

flittpayments-1.0.3/flittpayments/helpers.py

@@ -0,0 +1,104 @@
+from __future__ import absolute_import, unicode_literals
+from hashlib import sha1
+from flittpayments.configuration import __sign_sep__ as sep
+from flittpayments.exceptions import RequestError
+
+import flittpayments.utils as utils
+import uuid
+
+
+def get_data(data, req_type):
+    """
+    :param data: data to prepare
+    :param req_type: request type
+    :return: prepared data
+    """
+    if req_type == 'json':
+        return utils.to_json(data)
+    if req_type == 'xml':
+        return utils.to_xml(data)
+    if req_type == 'form':
+        return utils.to_form(data.get('request'))
+
+
+def get_request_type(req_type):
+    """
+    :param req_type: request type
+    :return: post header
+    """
+    types = {
+        'json': 'application/json; charset=utf-8',
+        'xml': 'application/xml; charset=utf-8',
+        'form': 'application/x-www-form-urlencoded; charset=utf-8'
+    }
+    return types.get(req_type, types['json'])
+
+
+def get_signature(secret_key, params, protocol):
+    """
+    :param secret_key: merchant secret
+    :param params: post params
+    :param protocol: api protocol version
+    :return: signature string
+    """
+    if protocol == '2.0':
+        str_sign = sep.join([secret_key, params])
+        calc_sign = sha1(str_sign.encode('utf-8')).hexdigest()
+        return calc_sign
+    else:
+        data = [secret_key]
+        data.extend([str(params[key]) for key in sorted(iter(params.keys()))
+                     if params[key] != '' and not params[key] is None])
+        return sha1(sep.join(data).encode('utf-8')).hexdigest()
+
+
+def get_desc(order_id):
+    """
+    :param order_id: order id
+    :return: description string
+    """
+    return 'Pay for order #: %s' % order_id
+
+
+def generate_order_id():
+    """
+    :return: unic order id
+    """
+    return str(uuid.uuid4())
+
+
+def check_data(data):
+    """
+    :param data: required data
+    :return: checking required data not empty
+    """
+    for key, value in data.items():
+        if value == '' or None:
+            raise RequestError(key)
+        if key == 'amount':
+            try:
+                int(value)
+            except ValueError:
+                raise ValueError('Amount must numeric')
+
+
+def is_valid(data, secret_key, protocol):
+    if 'signature' in data:
+        result_signature = data['signature']
+        del data['signature']
+    else:
+        raise ValueError('Incorrect data')
+    if 'response_signature_string' in data:
+        del data['response_signature_string']
+    signature = get_signature(secret_key=secret_key,
+                              params=data,
+                              protocol=protocol)
+    return result_signature == signature
+
+
+def is_approved(data, secret_key, protocol):
+    if 'order_status' not in data:
+        raise ValueError('Incorrect data')
+    if not is_valid(data, secret_key, protocol):
+        raise Exception('Payment invalid')
+    return data.get('order_status') == 'approved'

flittpayments-1.0.3/flittpayments/order.py

@@ -0,0 +1,111 @@
+from __future__ import absolute_import, unicode_literals
+from flittpayments.resources import Resource
+
+import flittpayments.utils as utils
+import flittpayments.helpers as helper
+
+
+class Order(Resource):
+    def settlement(self, data):
+        """
+        Method for create split order
+        :param data: split order data
+        :return: api response
+        """
+        if self.api.api_protocol != '2.0':
+            raise Exception('This method allowed only for v2.0')
+        path = '/settlement/'
+        params = {
+            'order_type': data.get('order_type', 'settlement'),
+            'order_id': data.get('order_id') or helper.generate_order_id(),
+            'operation_id': data.get('operation_id', ''),
+            'receiver': data.get('receiver', [])
+        }
+        helper.check_data(params)
+        params.update(data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+
+        return self.response(result)
+
+    def capture(self, data):
+        """
+        Method for capturing order
+        :param data: capture order data
+        :return: api response
+        """
+        path = '/capture/order_id/'
+        params = {
+            'order_id': data.get('order_id', ''),
+            'amount': data.get('amount', ''),
+            'currency': data.get('currency', '')
+        }
+        helper.check_data(params)
+        params.update(data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+        return self.response(result)
+
+    def reverse(self, data):
+        """
+        Method to reverse order
+        :param data: reverse order data
+        :return: api response
+        """
+        path = '/reverse/order_id/'
+        params = {
+            'order_id': data.get('order_id', ''),
+            'amount': data.get('amount', ''),
+            'currency': data.get('currency', '')
+        }
+        helper.check_data(params)
+        params.update(data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+        return self.response(result)
+
+    def status(self, data):
+        """
+        Method for checking order status
+        :param data: order data
+        :return: api response
+        """
+        path = '/status/order_id/'
+        params = {
+            'order_id': data.get('order_id', '')
+        }
+        helper.check_data(params)
+        params.update(data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+        return self.response(result)
+
+    def transaction_list(self, data):
+        """
+        Method for getting order transaction list
+        :param data: order data
+        :return: api response
+        """
+        path = '/transaction_list/'
+        params = {
+            'order_id': data.get('order_id', '')
+        }
+        helper.check_data(params)
+        params.update(data)
+        """
+        only json allowed all other methods returns 500 error
+        """
+        self.api.request_type = 'json'
+        result = self.api.post(path, data=params, headers=self.__headers__)
+        return self.response(result)
+
+    def atol_logs(self, data):
+        """
+        Method for getting order atol logs
+        :param data: order data
+        :return: api response
+        """
+        path = '/get_atol_logs/'
+        params = {
+            'order_id': data.get('order_id', '')
+        }
+        helper.check_data(params)
+        params.update(data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+        return utils.from_json(result).get('response')

flittpayments-1.0.3/flittpayments/payment.py

@@ -0,0 +1,126 @@
+from __future__ import absolute_import, unicode_literals
+from flittpayments.resources import Resource
+from datetime import datetime
+
+import flittpayments.helpers as helper
+
+
+class Pcidss(Resource):
+    def step_one(self, data):
+        """
+        Accept purchase Pcidss step one
+        :param data: order data
+        :return: payment result or step two data
+        """
+        path = '/3dsecure_step1/'
+        self.order_id = data.get('order_id') or helper.generate_order_id()
+        order_desc = data.get('order_desc') or helper.get_desc(self.order_id)
+        params = {
+            'order_id': self.order_id,
+            'order_desc': order_desc,
+            'currency': data.get('currency', ''),
+            'amount': data.get('amount', ''),
+            'card_number': data.get('card_number', ''),
+            'cvv2': data.get('cvv2', ''),
+            'expiry_date': data.get('expiry_date', '')
+        }
+        helper.check_data(params)
+        params.update(data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+        return self.response(result)
+
+    def step_two(self, data):
+        """
+        Accept purchase Pcidss step two
+        :param data: order data
+        :return: payment result
+        """
+        path = '/3dsecure_step2/'
+        params = {
+            'order_id': data.get('order_id', ''),
+            'pares': data.get('pares', ''),
+            'md': data.get('md', '')
+        }
+        helper.check_data(params)
+        params.update(data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+        return self.response(result)
+
+
+class Payment(Resource):
+    def p2pcredit(self, data):
+        """
+        Method P2P card credit
+        :param data: order data
+        :return: api response
+        """
+        path = '/p2pcredit/'
+        self.order_id = data.get('order_id') or helper.generate_order_id()
+        order_desc = data.get('order_desc') or helper.get_desc(self.order_id)
+        params = {
+            'order_id': self.order_id,
+            'order_desc': order_desc,
+            'amount': data.get('amount', ''),
+            'currency': data.get('currency', '')
+        }
+        helper.check_data(params)
+        params.update(data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+        return self.response(result)
+
+    def reports(self, data):
+        """
+        Method to get payment reports from date range
+        :param data: date range
+        :return: api response
+        """
+        path = '/reports/'
+        params = {
+            'date_from': data.get('date_from', ''),
+            'date_to': data.get('date_to', '')
+        }
+        helper.check_data(params)
+        """
+        from api only one response if data invalid "General Decline"
+        """
+        self._validate_reports_date(params)
+        params.update(data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+        return self.response(result)
+
+    def recurring(self, data):
+        """
+        Method for recurring payment
+        :param data: order data
+        :return: api response
+        """
+        path = '/recurring/'
+        self.order_id = data.get('order_id') or helper.generate_order_id()
+        order_desc = data.get('order_desc') or helper.get_desc(self.order_id)
+        params = {
+            'order_id': self.order_id,
+            'order_desc': order_desc,
+            'amount': data.get('amount', ''),
+            'currency': data.get('currency', ''),
+            'rectoken': data.get('rectoken', '')
+        }
+        helper.check_data(params)
+        params.update(data)
+        result = self.api.post(path, data=params, headers=self.__headers__)
+        return self.response(result)
+
+    @staticmethod
+    def _validate_reports_date(date):
+        """
+        Validating date range
+        :param date: date
+        """
+        try:
+            date_from = datetime.strptime(
+                date['date_from'], '%d.%m.%Y %H:%M:%S')
+            date_to = datetime.strptime(
+                date['date_to'], '%d.%m.%Y %H:%M:%S')
+        except ValueError:
+            raise ValueError("Incorrect date format.")
+        if date_from > date_to:
+            raise ValueError("`date_from` can't be greater than `date_to`")

flittpayments-1.0.3/flittpayments/resources.py

@@ -0,0 +1,67 @@
+from __future__ import absolute_import, unicode_literals
+from flittpayments import utils
+from flittpayments import exceptions
+
+
+class Resource(object):
+    def __init__(self, api=None, headers=None):
+        self.__dict__['api'] = api
+
+        super(Resource, self).__setattr__('__data__', {})
+        super(Resource, self).__setattr__('__headers__', headers or {})
+        super(Resource, self).__setattr__('order_id', None)
+
+    def __str__(self):
+        return self.__data__.__str__()
+
+    def __repr__(self):
+        return self.__data__.__str__()
+
+    def __getattr__(self, name):
+        try:
+            return self.__data__[name]
+        except KeyError:
+            return super(Resource, self).__getattribute__(name)
+
+    def __setattr__(self, name, value):
+        try:
+            super(Resource, self).__setattr__(name, value)
+        except AttributeError:
+            self.__data__[name] = self.convert(name, value)
+
+    def __contains__(self, name):
+        return name in self.__data__
+
+    def get_url(self):
+        if 'checkout_url' in self.__data__:
+            return self.__getattr__('checkout_url')
+
+    def response(self, response):
+        """
+        :param response: api response
+        :return: result
+        """
+        try:
+            result = None
+            if self.api.request_type == 'json':
+                result = utils.from_json(response).get('response', '')
+            if self.api.request_type == 'xml':
+                result = utils.from_xml(response).get('response', '')
+            if self.api.request_type == 'form':
+                result = utils.from_form(response)
+            return self._get_result(result)
+        except KeyError:
+            raise ValueError('Undefined format error.')
+
+    def _get_result(self, result):
+        """
+        in some api param response_status not exist...
+        :param result: api result
+        :return: exception
+        """
+        if 'error_message' in result:
+            raise exceptions.ResponseError(result)
+        if 'data' in result and self.api.api_protocol == '2.0':
+            result['data'] = utils.from_b64(result['data'])
+        self.__data__ = result
+        return result

flittpayments-1.0.3/flittpayments/utils.py

@@ -0,0 +1,163 @@
+from __future__ import absolute_import, unicode_literals
+from collections import OrderedDict
+
+import re
+import json
+import base64
+import six.moves.urllib as urllib
+import xml.etree.cElementTree as ElementTree
+
+
+def to_b64(data):
+    """
+    Encoding data string base64 algorithm
+    """
+    return base64.b64encode(json.dumps(data).encode('utf-8')).decode('utf-8')
+
+
+def from_b64(data):
+    """
+    Encoding data string base64 algorithm
+    """
+    return base64.b64decode(json.dumps(data).encode('utf-8')).decode('utf-8')
+
+
+def to_xml(data, start='<?xml version="1.0" encoding="UTF-8"?>'):
+    """
+    :param data: params to convert to xml
+    :param start: start xml string
+    :return: xml string
+    """
+    data = OrderedDict(sorted(data.items()))
+    return start + _data2xml(data)
+
+
+def to_json(data):
+    """
+    to json string
+    :param data: params to convert to xml
+    :return: json string
+    """
+    return json.dumps(data)
+
+
+def to_form(data):
+    """
+    to form string
+    :param data: params to convert to form data
+    :return: encoded url string
+    """
+    data = OrderedDict(sorted(data.items()))
+    return urllib.parse.urlencode(data)
+
+
+def merge_dict(x, y):
+    """
+    :param x: firs dict
+    :param y: second dict
+    :return: merged dict
+    """
+    z = x.copy()
+    z.update(y)
+    return z
+
+
+def join_url(url, *paths):
+    """
+    :param url: api url
+    :param paths: endpoint
+    :return: full url
+    """
+    for path in paths:
+        url = re.sub(r'/?$', re.sub(r'^/?', '/', path), url)
+    return url
+
+
+def from_json(json_string):
+    """
+    :param json_string: json data string to encode
+    :return: data dict
+    """
+    return json.loads(json_string)
+
+
+def from_form(form_string):
+    """
+    :param form_string: form data string to encode
+    :return: data dict
+    """
+    return dict(urllib.parse.parse_qsl(form_string))
+
+
+def from_xml(xml):
+    """
+    :param xml: xml string to encode
+    :return: data dict
+    """
+    element = ElementTree.fromstring(xml)
+    return _xml_to_dict(element.tag, _parse(element), element.attrib)
+
+
+def _data2xml(d):
+    result_list = list()
+
+    if isinstance(d, list):
+        for sub_elem in d:
+            result_list.append(_data2xml(sub_elem))
+
+        return ''.join(d)
+
+    if isinstance(d, dict):
+        for tag_name, sub_obj in d.items():
+            result_list.append("<%s>" % tag_name)
+            result_list.append(_data2xml(sub_obj))
+            result_list.append("</%s>" % tag_name)
+
+        return ''.join(result_list)
+
+    return "%s" % d
+
+
+def _parse(node):
+    tree = {}
+    for c in node.getchildren():
+        c_tag = c.tag
+        c_attr = c.attrib
+        ctext = c.text.strip() if c.text is not None else ''
+        c_tree = _parse(c)
+
+        if not c_tree:
+            c_dict = _xml_to_dict(c_tag, ctext, c_attr)
+        else:
+            c_dict = _xml_to_dict(c_tag, c_tree, c_attr)
+        if c_tag not in tree:
+            tree.update(c_dict)
+            continue
+        atag = '@' + c_tag
+        atree = tree[c_tag]
+        if not isinstance(atree, list):
+            if not isinstance(atree, dict):
+                atree = {}
+            if atag in tree:
+                atree['#' + c_tag] = tree[atag]
+                del tree[atag]
+            tree[c_tag] = [atree]
+
+        if c_attr:
+            c_tree['#' + c_tag] = c_attr
+
+        tree[c_tag].append(c_tree)
+    return tree
+
+
+def _xml_to_dict(tag, value, attr=None):
+    ret = {tag: value}
+    if attr:
+        atag = '@' + tag
+        aattr = {}
+        for k, v in attr.items():
+            aattr[k] = v
+        ret[atag] = aattr
+        del atag
+        del aattr
+    return ret

flittpayments-1.0.3/flittpayments.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.2
+Name: flittpayments
+Version: 1.0.3
+Summary: Python SDK for Flitt clients.
+Home-page: https://github.com/flittpayments/python/
+Author: Dmitriy Miroshnikov
+License: MIT
+Classifier: Environment :: Web Environment
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: six
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+
+    Flitt python sdk. 
+    Docs   - https://https://docs.flitt.com/
+    README - https://https://github.com/flittpayments/python/blob/master/README.md
+  

flittpayments-1.0.3/flittpayments.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+setup.py
+flittpayments/__init__.py
+flittpayments/api.py
+flittpayments/checkout.py
+flittpayments/configuration.py
+flittpayments/exceptions.py
+flittpayments/helpers.py
+flittpayments/order.py
+flittpayments/payment.py
+flittpayments/resources.py
+flittpayments/utils.py
+flittpayments.egg-info/PKG-INFO
+flittpayments.egg-info/SOURCES.txt
+flittpayments.egg-info/dependency_links.txt
+flittpayments.egg-info/requires.txt
+flittpayments.egg-info/top_level.txt
+tests/tests_helper.py

flittpayments-1.0.3/flittpayments.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

flittpayments-1.0.3/flittpayments.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests
+six

flittpayments-1.0.3/flittpayments.egg-info/top_level.txt

@@ -0,0 +1 @@
+flittpayments

flittpayments-1.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

flittpayments-1.0.3/setup.py

@@ -0,0 +1,38 @@
+from setuptools import find_packages, setup
+
+from flittpayments.configuration import __version__
+
+desc = """
+    Flitt python sdk. 
+    Docs   - https://https://docs.flitt.com/
+    README - https://https://github.com/flittpayments/python/blob/master/README.md
+  """
+
+requires_list = [
+    'requests',
+    'six'
+]
+
+setup(
+    name='flittpayments',
+    version=__version__,
+    url='https://github.com/flittpayments/python/',
+    license='MIT',
+    description='Python SDK for Flitt clients.',
+    long_description=desc,
+    author='Dmitriy Miroshnikov',
+    packages=find_packages(where='.', exclude=('tests*',)),
+    install_requires=requires_list,
+    classifiers=[
+        'Environment :: Web Environment',
+        'Natural Language :: English',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.4',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+    ])

flittpayments-1.0.3/tests/tests_helper.py

@@ -0,0 +1,37 @@
+import os
+import json
+
+from unittest import TestCase
+from flittpayments import Api, Pcidss, helpers
+
+
+class TestCase(TestCase):
+    def get_api(self):
+        self.data = self.get_dummy_data()
+        return Api(merchant_id=self.data['merchant']['id'],
+                   secret_key=self.data['merchant']['secret'])
+
+    def get_dummy_data(self):
+        dummy_data = os.path.join(os.path.dirname(__file__),
+                                  'data',
+                                  'test_data.json')
+        with open(dummy_data) as f:
+            self.data = json.load(f)
+        return self.data
+
+    def create_order(self):
+        pcidss = Pcidss(api=self.get_api())
+        params = {
+            "preauth": "Y",
+            "required_rectoken": "Y"
+        }
+        params.update(self.data['payment_pcidss_non3ds'])
+        return pcidss.step_one(params)
+
+    def test_validate_order(self):
+        payment = self.create_order()
+        is_valid = helpers.is_valid(data=payment,
+                                    secret_key=self.data['merchant']['secret'],
+                                    protocol='1.0')
+        self.assertEqual(payment.get('response_status'), 'success')
+        self.assertEqual(is_valid, True)