changes support api

Author: Lelia

pruebas.py

@@ -1,35 +1,79 @@
 import requests
+from requests.auth import AuthBase
+from typeform import exception
+from typeform.enumerator import ErrorEnum
+from typeform.clientauth import ClientAuth
+import json
 
 class Client(object):
-    BASE_URL = 'https://api.typeform.com/'
-    _VALID_VERSIONS = ['v1', ]
+    _VALID_VERSIONS = ['v1']
 
-    def __init__(self, api_key, version=None):
+    def __init__(self, api_key=None, access_token=None, version=None):
+        self.access_token = access_token
         self.api_key = api_key
         if version not in self._VALID_VERSIONS:
             self.version = self._VALID_VERSIONS[0]
+        if api_key:
+            self.auth = ClientAuth(api_key=api_key)
+            self.base_url = 'https://api.typeform.com/'+self._VALID_VERSIONS[0]
+        elif access_token:
+            self.auth = ClientAuth(access_token=access_token)
+            self.base_url = 'https://api.typeform.com'
+        else:
+            raise exception.CredentialRequired("You must provide either access_token or api_key")
 
-    def _get(self, endpoint, params=None):
-        return self._request('GET', endpoint, params)
-
-    def _request(self, method, endpoint, params=None, data=None):
-        url = '{0}{1}/{2}'.format(self.BASE_URL, self.version, endpoint)
-        print(url)
-        response = requests.request(method, url, params=params, json=data)
-        r = response.json()
-        if response.status_code in [403, 404]:
-            if 'message' in r:
-                raise Exception(r['message'])
+    def _get(self, endpoint, data=None):
+        return self._request('GET', endpoint, data=data)
+
+    def _put(self, endpoint, data=None):
+        return self._request('PUT', endpoint, data=data)
+
+    def _delete(self, endpoint, data=None):
+        return self._request('DELETE', endpoint, data=data)
+
+    def _request(self, method, endpoint, data=None):
+        url = '{0}/{1}'.format(self.base_url, endpoint)
+        response = requests.request(method, url, auth=self.auth, data=json.dumps(data))
+        return self._parse(response)
+
+    def _parse(self, response):
+        if not response.ok:
+            try:
+                data = response.json()
+                if 'description' in data and 'code' in data:
+                    message = data['description']
+                    code = data['code']
+            except:
+                code = response.status_code
+                message = ""
+            try:
+                error_enum = ErrorEnum(response.status_code)
+            except Exception:
+                raise exception.UnexpectedError('Error:{0}{1}.Message{2}'.format(code, response.status_code, message))
+            if error_enum == ErrorEnum.Forbidden:
+                raise exception.Forbidden(message)
+            if error_enum == ErrorEnum.Not_Found:
+                raise exception.Not_Found(message)
+            if error_enum == ErrorEnum.Payment_Required:
+                raise exception.Payment_Required(message)
+            if error_enum == ErrorEnum.Internal_Server_Error:
+                raise exception.Internal_Server_Error(message)
+            if error_enum == ErrorEnum.Service_Unavailable:
+                raise exception.Service_Unavailable(message)
+            if error_enum == ErrorEnum.Bad_Request:
+                raise exception.Bad_Request(message)
+            if error_enum == ErrorEnum.Unauthorized:
+                raise exception.Unauthorized(message)
             else:
-                if 'code' in r:
-                    raise Exception(r['description'])
-                raise Exception('Unexpected error.')
-        return r
+                raise exception.BaseError('Error: {0}{1}. Message {2}'.format(code, response.status_code, message))
+            return data
+        else:
+            return response
 
     def get_form_uid(self, url_form):
         """Returns addresses registered by the user.
         Args:
-            url_form:
+            url_form: String, Url from the form (the method needs the uid or form)
         Returns:
             A string.
         """
@@ -40,7 +84,7 @@ def get_form_uid(self, url_form):
     def get_form_information(self, uid=None, url=None):
         """Returns addresses registered by the user.
         Args:
-            typeform_uid:
+            uid: Unique ID for the form
         Returns:
             A dict.
         """
@@ -49,62 +93,87 @@ def get_form_information(self, uid=None, url=None):
                 raise Exception('You must provide either an UID or Form URL.')
             else:
                 uid = self.get_form_uid(url)
-        params = {'key': self.api_key}
-        return self._get('form/{}'.format(uid), params=params)
-
-    def get_form_stats(self, uid=None, url=None, form=None):
-        """Returns stats of form.
-        Args:
-            uid:
-            url:
-        Returns:
-            A dict.
-        """
-        if form is not None:
-            return form['stats']
-        return self.get_form_information(uid=uid, url=url)['stats']
+        return self._get('forms/{}'.format(uid)).json()
 
     def get_form_questions(self, uid=None, url=None, form=None):
         """Returns questions of form.
         Args:
-            uid:
-            url:
+            uid: Unique ID for the form
+            url: String, Url from the form (the method needs the uid or form)
         Returns:
             A dict.
         """
         if form is not None:
-            return form['questions']
-        return self.get_form_information(uid=uid, url=url)['questions']
+            return form['fields']
+        return self.get_form_information(uid=uid, url=url)['fields']
 
-    def get_form_metadata(self, uid=None, url=None, form=None):
-        """Returns metadata of form.
+    def get_form_metadata(self, since, until, uid=None, url=None, form=None):
+        """Returns metadata of form (include answers).
         Args:
-            uid:
-            url:
+            uid: String, ID from the form
+            url: String, Url from the form (the method needs the uid or form)
+            form: String, A form
+            since: String,  The since parameter is a string that uses ISO 8601 format,
+            Coordinated Universal Time (UTC), with "T" as a delimiter between the date and time.
+            July 10, 2017 at 12:00 a.m. UTC is expressed as 2017-07-10T00:00:00.
+            If you want to retrieve responses for yesterday, 2017-07-09, the value for your since query parameter
+            would be 2017-07-09T00:00:00
+            until: String, The until parameter is a string that uses ISO 8601 format,
+            Coordinated Universal Time (UTC), with "T" as a delimiter between the date and time.
+            July 10, 2017 at 12:00 a.m. UTC is expressed as 2017-07-10T00:00:00.
+            If you want to retrieve responses for yesterday, 2017-07-09, the value for your since query parameter
+            would be 2017-07-09T00:00:00
         Returns:
             A dict.
         """
         if form is not None:
             return form['responses']
-        return self.get_form_information(uid=uid, url=url)['responses']
+        data = {
+            'since': since,
+            'until': until,
+        }
+        return self._get(endpoint="forms/{0}/responses".format(uid), data=data).json()['items']
 
-    def get_form_answers(self, uid=None, url=None, form=None):
-        """Returns answers of form.
-        Args:
-            uid:
-            url:
-        Returns:
-            A list.
-        """
-        if form is None:
-            form = self.get_form_information(uid=uid, url=url)
-        return [answers['answers'] for answers in form['responses']]
 
     def get_forms(self):
         """Returns all forms
         Args:
         Returns:
             A dict.
         """
-        params = {'key': self.api_key}
-        return self._get('forms?key={0}'.format(self.api_key), params=params)
+        return self._get(endpoint='forms').json()
+
+    def create_webhook(self, url_webhook, tag_webhook, uid):
+        """
+        :param url_webhook: String URL webhook request
+        :param tag_webhook: String
+        :param uid: String, Unique ID for the form
+        :return: dict
+        """
+        if self.access_token is not None:
+            data = {'url':url_webhook, 'enabled':True}
+            return self._put(endpoint='forms/{1}/webhooks/{0}'.format(tag_webhook, uid), data=data).json()
+        else:
+            raise exception.TokenRequired("You need an access token for this method")
+
+    def view_webhook(self, tag_webhook, uid):
+        """
+        :param tag_webhook: String
+        :param uid: String, Unique ID for the form
+        :return:
+        """
+        if self.access_token is not None:
+            return self._get(endpoint='forms/{1}/webhooks/{0}'.format(tag_webhook, uid)).json()
+        else:
+            raise exception.TokenRequired("You need an access token for this method")
+
+    def delete_webhook(self, tag_webhook, uid):
+        """
+        :param tag_webhook: String
+        :param uid: String, Unique ID for the form
+        :return:
+        """
+        if self.access_token is not None:
+            return self._delete(endpoint='forms/{1}/webhooks/{0}'.format(tag_webhook, uid)).ok
+        else:
+            raise exception.TokenRequired("You need an access token for this method")

pruebas2.py

@@ -0,0 +1,21 @@
+import requests
+from typeform import exception
+
+class ClientAuth(requests.auth.AuthBase):
+
+    def __init__(self, access_token=None, api_key=None):
+        if access_token:
+            self.access_token = access_token
+            self.api_key = None
+        elif api_key:
+            self.api_key = api_key
+            self.access_token = None
+        else:
+            raise exception.CredentialRequired("You must provide either access_token or api_key")
+
+    def __call__(self, r):
+        if self.access_token is not None:
+            r.headers['Authorization'] = 'bearer {0}'.format(self.access_token)
+        elif self.api_key is not None:
+            r.prepare_url(r.url, {'key': self.api_key})
+        return r

typeform/client.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class ErrorEnum(Enum):
+    Forbidden = 403
+    Not_Found = 404
+    Payment_Required = 402
+    Internal_Server_Error = 500
+    Service_Unavailable = 503
+    Bad_Request = 400
+    Unauthorized = 401

typeform/clientauth.py

@@ -0,0 +1,32 @@
+class BaseError(Exception):
+    pass
+
+class CredentialRequired(BaseError):
+    pass
+
+class UnexpectedError(BaseError):
+    pass
+
+class Forbidden (BaseError):
+    pass
+
+class Not_Found (BaseError):
+    pass
+
+class Payment_Required (BaseError):
+    pass
+
+class Internal_Server_Error (BaseError):
+    pass
+
+class Service_Unavailable (BaseError):
+    pass
+
+class Bad_Request (BaseError):
+    pass
+
+class Unauthorized (BaseError):
+    pass
+
+class TokenRequired(BaseError):
+    pass