project source files added

Author: paulakimenko

devmateclient/__init__.py

@@ -0,0 +1,5 @@
+from .client import Client
+from .version import version, version_info
+
+__version__ = version
+__title__ = 'devmateclient'

devmateclient/api/__init__.py

@@ -0,0 +1,2 @@
+from .customers import CustomersApiMixin
+from .licenses import LicensesApiMixin

devmateclient/api/customers.py

@@ -0,0 +1,133 @@
+import logging
+
+from ..errors import IllegalArgumentError
+
+PATH = '/v2/customers'
+LICENSES_PATH = '/licenses'
+
+log = logging.getLogger(__name__)
+
+
+class CustomersApiMixin(object):
+    def get_customer_by_id(self, customer_id, with_meta=None):
+        """
+        Get existing DevMate customer by given id, or error if input params are incorrect, or customer doesn't exist
+        :param customer_id: `int` target customer id in DevMate
+        :param with_meta: `bool` set True to return object with meta info in tuple
+        :return: customer object in `dict`, or `tuple` with customer and meta info
+        """
+        log.debug('Get customer by id %s, with meta : %s', customer_id, with_meta)
+
+        if customer_id is None or customer_id <= 0:
+            raise IllegalArgumentError('Id should not be negative or 0. Given : {}'.format(customer_id))
+
+        return self._dm_get(path='{}/{}'.format(PATH, customer_id), with_meta=with_meta)
+
+    def get_customers(self,
+                      with_email=None,
+                      with_first_name=None,
+                      with_last_name=None,
+                      with_company=None,
+                      with_phone=None,
+                      with_address=None,
+                      with_key=None,
+                      with_identifier=None,
+                      with_invoice=None,
+                      with_order_id=None,
+                      with_activation_id=None,
+                      with_limit=None,
+                      with_offset=None,
+                      with_licenses=None,
+                      with_meta=None):
+        """
+        Get existing DevMate customers by given filter params, or error if input params are incorrect
+        :param with_email: `str` filter customer list by given email (contains)
+        :param with_first_name: `str` filter customer list by given first name (contains)
+        :param with_last_name: `str` filter customer list by given last name (contains)
+        :param with_company: `str` filter customer list by given company name (contains)
+        :param with_phone: `str` or `int` filter customer list by given phone number (contains)
+        :param with_address: `str` filter customer list by given address (contains)
+        :param with_key: `str` or `int` filter customer list by given activation key (equals)
+        :param with_identifier: `str` or `int` filter customer list by given identifier, e.g. MAC address (contains)
+        :param with_invoice: `str` or `int` filter customer list by given invoice (contains)
+        :param with_order_id: `int` filter customer list by given order id (equals)
+        :param with_activation_id: `int` filter customer list by given activation id (equals)
+        :param with_limit: `int` max count of customers per page
+        :param with_offset: `int` offset
+        :param with_licenses: `bool` set True to include licenses to customer object
+        :param with_meta: `bool` set True to return object with meta info in tuple
+        :return: `list` of customer objects in `dict`, or `tuple` with customers and meta info
+        """
+        params = {
+            'filter[email]': with_email,
+            'filter[first_name]': with_first_name,
+            'filter[last_name]': with_last_name,
+            'filter[company]': with_company,
+            'filter[phone]': with_phone,
+            'filter[address]': with_address,
+            'filter[key]': with_key,
+            'filter[identifier]': with_identifier,
+            'filter[order_id]': with_order_id,
+            'filter[activation_id]': with_activation_id,
+            'filter[invoice]': with_invoice,
+            'offset': with_offset,
+            'limit': with_limit,
+            'with': 'licenses' if with_licenses else None
+        }
+
+        log.debug('Get customers with params %s, with meta : %s', params, with_meta)
+
+        not_none_params = dict((k, v) for k, v in params.items() if v is not None)
+
+        return self._dm_get(path=PATH, params=not_none_params, with_meta=with_meta)
+
+    def create_customer(self, customer, with_meta=None):
+        """
+        Create new customer in DevMate, or error if input params are incorrect
+        :param customer: customer data in `dict`, 'email' field should be set in `dict`
+        :param with_meta: `bool` set True to return object with meta info in tuple
+        :return: created customer object in `dict`, or `tuple` with customer and meta info
+        """
+        log.debug('Create customer with details %s, with meta : %s', customer, with_meta)
+
+        if 'email' not in customer or customer['email'] is None:
+            raise IllegalArgumentError('"email" field should be set for the customer')
+
+        return self._dm_post(path=PATH, json={'data': customer}, with_meta=with_meta)
+
+    def update_customer(self, customer, with_meta=None):
+        """
+        Update existing customer in DevMate, or error if input params are incorrect, or customer doesn't exist
+        :param customer: updated customer data in `dict`, 'id' field should be set in `dict`
+        :param with_meta: `bool` set True to return object with meta info in tuple
+        :return: created customer object in `dict`, or `tuple` with customer and meta info
+        """
+        log.debug('Update customer with details %s, with meta : %s', customer, with_meta)
+
+        if 'id' not in customer or customer['id'] is None:
+            raise IllegalArgumentError('Current customer "id" field should be set for the customer')
+
+        return self._dm_put(path='{}/{}'.format(PATH, customer['id']), json={'data': customer}, with_meta=with_meta)
+
+    def create_license_for_customer(self, customer_id, _license, with_meta=None):
+        """
+        Create new license for existing customer in DevMate by license type id,
+        or error if input params are incorrect, or customer doesn't exist
+        :param customer_id: `int` id of customer in DevMate
+        :param _license: license object in `dict`, 'license_type_id' field should be set in `dict`
+        :param with_meta: `bool` set True to return object with meta info in tuple
+        :return: created license object in `dict`, or `tuple` with license and meta info
+        """
+        log.debug('Create license for customer %s with details %s, with meta : %s', customer_id, _license, with_meta)
+
+        if customer_id is None or customer_id <= 0:
+            raise IllegalArgumentError('Id should not be negative or 0. Given : {}'.format(customer_id))
+
+        if 'license_type_id' not in _license or _license['license_type_id'] is None:
+            raise IllegalArgumentError('Current customer "license_type_id" field should be set for the customer')
+
+        return self._dm_post(
+            path='{}/{}{}'.format(PATH, customer_id, LICENSES_PATH),
+            json={'data': _license},
+            with_meta=with_meta
+        )

devmateclient/api/licenses.py

@@ -0,0 +1,18 @@
+import logging
+
+PATH = '/v2/licenses'
+RESET_ACTIVATION_PATH = '/reset_first_activation'
+
+log = logging.getLogger(__name__)
+
+
+class LicensesApiMixin(object):
+    def reset_first_activation(self, activation_key):
+        """
+        Reset first license activation by given activation key. Raise error if license with given key doesn't exist
+        :param activation_key: `str` or `int` license activation key
+        :return: `void`
+        """
+        log.debug('Reset first activation by activation key %s', activation_key)
+
+        self._dm_post(path='{}/{}{}'.format(PATH, activation_key, RESET_ACTIVATION_PATH), with_meta=False)

devmateclient/client.py

@@ -0,0 +1,119 @@
+import logging
+
+import requests
+
+from . import api
+from . import errors
+
+BASE_URL = 'https://public-api.devmate.com'
+
+log = logging.getLogger(__name__)
+
+
+class Client(requests.Session, api.CustomersApiMixin, api.LicensesApiMixin):
+    """
+    DevMate Public API client.
+    To initialize this you have to set auth_token, which can be generated in Settings -> API Integration.
+    You can change auth token in runtime with auth_token property.
+    """
+    def __init__(self, auth_token):
+        super(Client, self).__init__()
+        self._auth_token = auth_token
+        self._base_url = BASE_URL
+
+    @property
+    def auth_token(self):
+        return self._auth_token
+
+    @auth_token.setter
+    def auth_token(self, auth_token):
+        self._auth_token = auth_token
+
+    def _url(self, path):
+        return '{base_url}{path}'.format(base_url=self._base_url, path=path)
+
+    def _add_auth_header(self, req_kwargs):
+        if self._auth_token is not None:
+            log.debug('Add auth token %s to header with request params %s', self._auth_token, req_kwargs)
+
+            token_header = {'Authorization': 'Token {}'.format(self._auth_token)}
+
+            if not req_kwargs.get('headers'):
+                req_kwargs['headers'] = token_header
+            else:
+                req_kwargs['headers'].update(token_header)
+
+    @staticmethod
+    def _check_dm_errors(response):
+        log.debug('Check errors for response %s', response)
+
+        if 200 <= response.status_code < 300:
+            return
+        elif response.status_code == 400:
+            error = errors.IncorrectParamsError(response)
+        elif response.status_code == 404:
+            error = errors.NotFoundError(response)
+        elif response.status_code == 409:
+            error = errors.ConflictError(response)
+        elif 400 <= response.status_code < 500:
+            error = errors.DevMateClientError(response)
+        elif 500 <= response.status_code < 600:
+            error = errors.DevMateServerError(response)
+        else:
+            error = errors.DevMateRequestError(response)
+
+        try:
+            json = response.json()
+            error.dm_errors = json['errors']
+        except Exception:
+            error.dm_errors = []
+
+        raise error
+
+    @staticmethod
+    def _is_application_json(headers):
+        return 'Content-Type' in headers and headers['Content-Type'] == 'application/json'
+
+    def _extract_data(self, response, with_meta):
+        log.debug('Extract data from response %s, with meta : %s', response, with_meta)
+
+        if not self._is_application_json(response.headers):
+            log.debug('Response doesn\'t contain JSON, return response %s', response)
+            return response
+
+        try:
+            json = response.json()
+
+            if 'data' not in json:
+                log.debug('Return whole JSON %s', json)
+                return json
+
+            if with_meta:
+                data = json['data']
+                meta = json['meta'] if 'meta' in json else None
+                log.debug('Return JSON data %s and meta %s', data, meta)
+                return data, meta
+            else:
+                data = json['data']
+                log.debug('Return JSON data %s', data)
+                return data
+        except Exception as e:
+            log.debug('Error on parsing json %s, return response', e, response)
+            return response
+
+    def _dm_request(self, method, path, with_meta, **kwargs):
+        url = self._url(path)
+        self._add_auth_header(kwargs)
+        log.debug('Send %s request to %s with args %s', method, url, kwargs)
+        response = self.request(method=method, url=url, **kwargs)
+        self._check_dm_errors(response)
+        return self._extract_data(response, with_meta=with_meta)
+
+    def _dm_get(self, path, with_meta, **kwargs):
+        return self._dm_request('GET', path, with_meta, **kwargs)
+
+    def _dm_post(self, path, with_meta, **kwargs):
+        return self._dm_request('POST', path, with_meta, **kwargs)
+
+    def _dm_put(self, path, with_meta, **kwargs):
+        return self._dm_request('PUT', path, with_meta, **kwargs)

devmateclient/consts.py

@@ -0,0 +1,15 @@
+class LicenseStatus(object):
+    NOT_USED = 1
+    ACTIVE = 2
+    EXPIRED = 3
+    BLOCKED = 4
+    RETURNED = 5
+
+
+class HistoryRecordType(object):
+    ACTIVATION = 1
+    CREATING = 2
+    EXPIRING = 3
+    BLOCKING = 4
+    RETURNING = 5
+    RESETTING = 6

devmateclient/errors.py

@@ -0,0 +1,60 @@
+class DevMateError(Exception):
+    """
+    Base DevMate error.
+    """
+    pass
+
+
+class IllegalArgumentError(DevMateError):
+    """
+    Raised if Illegal Argument passed to the function before request executed.
+    """
+    pass
+
+
+class DevMateRequestError(DevMateError):
+    """
+    Base DevMate request error. Raised if request has been failed.
+    Has dm_errors property with request error explanation.
+    """
+    dm_errors = []
+
+
+class DevMateClientError(DevMateRequestError):
+    """
+    DevMate request error for Client errors (status code 400 - 499).
+    Has dm_errors property with request error explanation.
+    """
+    pass
+
+
+class DevMateServerError(DevMateRequestError):
+    """
+    DevMate request error for Server errors (status code 500 - 599).
+    Has dm_errors property with request error explanation.
+    """
+    pass
+
+
+class IncorrectParamsError(DevMateClientError):
+    """
+    DevMate request error for status code 400. Raised if incorrect params have been given.
+    Has dm_errors property with request error explanation.
+    """
+    pass
+
+
+class NotFoundError(DevMateClientError):
+    """
+    DevMate request error for status code 404. Raised if resource hasn't been found.
+    Has dm_errors property with request error explanation.
+    """
+    pass
+
+
+class ConflictError(DevMateClientError):
+    """
+    DevMate request error for status code 409. Raised if already existed unique param has been given.
+    Has dm_errors property with request error explanation.
+    """
+    pass

devmateclient/version.py

@@ -0,0 +1,2 @@
+version = "1.0.0"
+version_info = tuple([int(d) for d in version.split("-")[0].split(".")])

tests/__init__.py

@@ -0,0 +1,19 @@
+import json
+import unittest
+
+import devmateclient
+
+APPLICATION_JSON = 'application/json'
+
+
+def request_as_json(pretty_request):
+    return json.loads(pretty_request.body.decode("utf-8"))
+
+
+class BaseApiTest(unittest.TestCase):
+    def setUp(self):
+        self.token = 'TEST_TOKEN'
+        self.client = devmateclient.Client(self.token)
+
+    def tearDown(self):
+        self.client.close()