Feature/get (#7)

* create project linting configuration
* Defining `get_entity` method to search for entities.
* Defining first exceptions for some cases.

Author: cmeissner

.flake8

@@ -0,0 +1,17 @@
+[flake8]
+ignore =
+    F401,
+    E501,
+exclude =
+    .git,
+    __pycache__,
+    tests/fixtures/*,
+    *.pyc,
+    venv,
+deps =
+    wheel,
+    flake8-colors,
+max-complexity = 10
+import-order-style = google
+application-import-names = flake8
+format = ${cyan}%(path)s${reset}:${yellow_bold}%(row)d${reset}:${green_bold}%(col)d${reset}: ${red_bold}%(code)s${reset} %(text)s

pyhpipam/controller/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+# (c) Christian Meißner 2020

pyhpipam/controller/sections.py

@@ -1,13 +1,11 @@
 # -*- coding: utf-8 -*-
 # (c) Christian Meißner 2020
 
-# pylint: disable=raise-missing-from
-# pylint: disable=super-with-arguments
-
+import json
 import requests
 
 from requests.auth import HTTPBasicAuth
-from pyhpipam.core.query import query
+from pyhpipam.core.exceptions import PyHPIPAMException
 
 GET = requests.get
 POST = requests.post
@@ -48,11 +46,67 @@ def __init__(
         if not self._api_encryption:
             self._login()
 
+    def _query(self, **kwargs):
+        """ sends queries to phpIPAM API in a generalistic manner
+
+        :param path: Path to the controler and possibly to function to use. Default is ```user```.
+        :param method: method to be used for the query (choice: ```GET```, ```POST```, ```PATCH```, ```OPTIONS```).
+        :param headers: Headers for request.
+        :param data: (optional) Dictionary Dictionary, list of tuples, bytes, or file-like object to send in the body of the :class:`Request`.
+        :param params: (optional) Dictionary list of tuples or bytes to send in the query string for the :class:`Request`.
+        :param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
+        :param token: (optional) Api token get from last login.
+        """
+
+        _api_path = kwargs.pop('path', 'user')
+        _api_headers = kwargs.pop('headers', {})
+        _method = kwargs.pop('method', 'GET')
+        _data = kwargs.pop('data', None)
+        _params = kwargs.pop('params', {})
+        _auth = kwargs.pop('auth', None)
+
+        if self._api_token:
+            _api_headers['token'] = self._api_token
+
+        _url = '{}/api/{}/{}'.format(self._api_url, self._api_appid, _api_path)
+
+        if _data is not None:
+            _data = json.dumps(_data)
+
+        resp = _method(
+            _url,
+            params=_params,
+            data=_data,
+            headers=_api_headers,
+            auth=_auth,
+            verify=self._api_ssl_verify,
+            timeout=self._api_timeout,
+        )
+
+        result = resp.json()
+
+        if result['code'] not in (200, 201) or not result['success']:
+            raise PyHPIPAMException(code=result['code'], message=result['message'])
+        else:
+            if 'data' in result:
+                return result['data']
+
     def _login(self):
         _auth = HTTPBasicAuth(self._api_username, self._api_password)
-        resp = query(url=self._api_url, app_id=self._api_appid, method=POST, auth=_auth, verify=self._api_ssl_verify)
+        resp = self._query(method=POST, auth=_auth)
 
-        self._token = resp['token']
+        self._api_token = resp['token']
 
     def get_token(self):
-        return self._token
+        return self._api_token
+
+    def get_entity(self, **kwargs):
+        _controller = kwargs.pop('controller', None)
+        _controller_path = kwargs.pop('controller_path', None)
+
+        if _controller_path is None and _controller:
+            _path = '{}'.format(_controller)
+        elif _controller and _controller_path:
+            _path = '{}/{}'.format(_controller, _controller_path)
+
+        return self._query(token=self._api_token, method=GET, path=_path)

pyhpipam/core/api.py

@@ -0,0 +1,38 @@
+# provides the main query methods.
+
+import json
+
+
+class PyHPIPAMException(Exception):
+
+    def __init__(self, *args, **kwargs):
+        self._code = kwargs.pop('code', None)
+        self._message = kwargs.pop('message', None)
+
+        if self._code == 500:
+            if self._message == 'Invalid username or password':
+                raise PyHPIPAMInvalidCredentials(self._message)
+        elif self._code == 400:
+            raise PyHPIPAMInvalidSyntax(message=self._message)
+        elif self._code == 404:
+            if self._message == 'Not Found':
+                raise EntityNotFoundException(self._message)
+
+        # super(PyHPIPAMException, self).__init__(*args, **kwargs)
+
+
+class PyHPIPAMInvalidCredentials(Exception):
+    def __init__(self, *args, **kwargs):
+        super(PyHPIPAMInvalidCredentials, self).__init__(*args, **kwargs)
+
+
+class EntityNotFoundException(Exception):
+    def __init__(self, *args, **kwargs):
+        super(EntityNotFoundException, self).__init__(*args, **kwargs)
+
+
+class PyHPIPAMInvalidSyntax(Exception):
+    def __init__(self, *args, **kwargs):
+        self._message = kwargs.pop('message', '')
+
+        super(PyHPIPAMInvalidSyntax, self).__init__(self._message, *args, **kwargs)

pyhpipam/core/exceptions.py

@@ -0,0 +1,5 @@
+wheel
+flake8
+flake8-colors
+requests
+inflection