vobiz-python 0.1.0__py3-none-any.whl

vobiz/utils/location.py

@@ -0,0 +1,6 @@
+class Location:
+    def __init__(self, latitude, longitude, name, address):
+        self.latitude = latitude
+        self.longitude = longitude
+        self.name = name
+        self.address = address

vobiz/utils/signature_v3.py

@@ -0,0 +1,111 @@
+import sys
+from hmac import new as sign
+from hashlib import sha256
+from urllib.parse import urlparse, urlunparse, parse_qs
+from base64 import encodebytes as encode
+
+from .validators import *
+
+
+def string_format(value):
+    if isinstance(value, bytes):
+        return ''.join(chr(x) for x in bytearray(value))
+    if isinstance(value, (int, float, bool)):
+        return str(value)
+    if isinstance(value, list):
+        return [string_format(x) for x in value]
+    return value
+
+
+def get_map_from_query(query):
+    res_map = dict()
+    for key, value in parse_qs(query, keep_blank_values=True).items():
+        res_map[string_format(key)] = string_format(value)
+    return res_map
+
+
+def get_sorted_query_string(params):
+    keys = sorted(params.keys())
+    res_params = []
+    for key in keys:
+        value = params[key]
+        if isinstance(value, list):
+            res_params.append(
+                '&'.join(['{}={}'.format(string_format(key), val) for val in sorted(string_format(value))]))
+        else:
+            res_params.append('{}={}'.format(string_format(key), string_format(value)))
+    return '&'.join(res_params)
+
+
+def get_sorted_params_string(params):
+    keys = sorted(params.keys())
+    res_params = []
+    for key in keys:
+        value = params[key]
+        if isinstance(value, list):
+            res_params.append(
+                ''.join(['{}{}'.format(string_format(key), val) for val in sorted(string_format(value))]))
+        elif isinstance(value, dict):
+            res_params.append('{}{}'.format(string_format(key), get_sorted_params_string(value)))
+        else:
+            res_params.append('{}{}'.format(string_format(key), string_format(value)))
+    return ''.join(res_params)
+
+
+def construct_get_url(uri, params, empty_post_params=True):
+    parsed_uri = urlparse(uri.encode('utf-8'))
+    base_url = urlunparse((parsed_uri.scheme.decode('utf-8'),
+                           parsed_uri.netloc.decode('utf-8'),
+                           parsed_uri.path.decode('utf-8'), '', '',
+                           '')).encode('utf-8')
+
+    params.update(get_map_from_query(parsed_uri.query))
+    query_params = get_sorted_query_string(params)
+    if len(query_params) > 0 or not empty_post_params:
+        base_url = base_url + bytearray('?' + query_params, 'utf-8')
+    if len(query_params) > 0 and not empty_post_params:
+        base_url = base_url + bytearray('.', 'utf-8')
+    return base_url
+
+
+def construct_post_url(uri, params):
+    base_url = construct_get_url(uri, dict(), True if len(params) == 0 else False)
+    return base_url + bytearray(get_sorted_params_string(params), 'utf-8')
+
+
+def get_signature_v3(auth_token, base_url, nonce):
+    base_url = bytearray('{}.{}'.format(string_format(base_url), string_format(nonce)), 'utf-8')
+    try:
+        return encode(sign(auth_token, base_url, sha256).digest()).strip()
+    except TypeError:
+        return encode(sign(bytearray(auth_token, 'utf-8'), base_url, sha256).digest()).strip()
+
+
+@validate_args(
+    method=[all_of(of_type(str), is_in(('POST', 'GET'), case_sensitive=False))],
+    uri=[is_url()],
+    params=[optional(of_type(dict))],
+    nonce=[of_type(str)],
+    auth_token=[of_type(str)],
+    v3_signature=[of_type(str)],
+)
+def validate_v3_signature(method, uri, nonce, auth_token, v3_signature, params=None):
+    """
+    Validates V3 Signature received from Vobiz to your server.
+
+    :param method: Your callback method (GET or POST)
+    :param uri: Your callback URL
+    :param params: Params received in callback from Vobiz
+    :param nonce: X-Vobiz-Signature-V3-Nonce header
+    :param v3_signature: X-Vobiz-Signature-V3 header
+    :param auth_token: (Sub)Account auth token
+    :return: True if the request matches signature, False otherwise
+    """
+    if params is None:
+        params = dict()
+    auth_token = bytes(auth_token.encode('utf-8'))
+    nonce = bytes(nonce.encode('utf-8'))
+    v3_signature = bytes(v3_signature.encode('utf-8'))
+    base_url = construct_get_url(uri, params).decode('utf-8') if method == 'GET' else construct_post_url(uri, params).decode('utf-8')
+    signature = get_signature_v3(auth_token, base_url, nonce)
+    return signature in v3_signature.split(b',')

vobiz/utils/template.py

@@ -0,0 +1,50 @@
+from vobiz.utils.location import Location
+
+
+class Parameter:
+    def __init__(
+        self,
+        type,
+        text=None,
+        media=None,
+        payload=None,
+        currency=None,
+        date_time=None,
+        location=None,
+        parameter_name=None,
+    ):
+        self.type = type
+        self.text = text
+        self.media = media
+        self.payload = payload
+        self.currency = Currency(**currency) if currency else None
+        self.date_time = DateTime(**date_time) if date_time else None
+        self.location = location
+        self.parameter_name = parameter_name
+
+
+class Component:
+    def __init__(self, type, sub_type=None, index=None, parameters=None):
+        self.type = type
+        self.sub_type = sub_type
+        self.index = index
+        self.parameters = parameters if parameters is not None else []
+
+
+class Template:
+    def __init__(self, name, language, components=None):
+        self.name = name
+        self.language = language
+        self.components = components if components is not None else []
+
+
+class Currency:
+    def __init__(self, fallback_value, currency_code, amount_1000):
+        self.fallback_value = fallback_value
+        self.currency_code = currency_code
+        self.amount_1000 = amount_1000
+
+
+class DateTime:
+    def __init__(self, fallback_value):
+        self.fallback_value = fallback_value

vobiz/utils/validators.py

@@ -0,0 +1,280 @@
+# -*- coding: utf-8 -*-
+import functools
+import importlib
+import inspect
+import re
+
+import decorator
+
+from vobiz.exceptions import ValidationError
+
+
+def regex(regex):
+    rexp = re.compile(regex)
+
+    def f(name, value):
+        if not rexp.match(value):
+            return None, [
+                '{} should match format {} (actual value: {})'.format(
+                    name, regex, value)
+            ]
+
+        return value, []
+
+    return f
+
+
+def all_of(*validators):
+    def f(name, value):
+        for validator in validators:
+            value, errs = validator(name, value)
+            if errs:
+                return None, errs
+        return value, []
+
+    return f
+
+
+def one_of(*validators):
+    def f(name, value):
+        for validator in validators:
+            new_val, errs = validator(name, value)
+            if errs:
+                continue
+            else:
+                return new_val, []
+        return None, '{} did not satisfy any of the required types'.format(
+            name)
+
+    return f
+
+
+def check(checker, message=None):
+    def f(name, value):
+        inr = checker(value)
+        msg = message or '{} should be in range'.format(name)
+        if inr:
+            return value, []
+        else:
+            return None, ['{} (actual value: {})'.format(msg, value)]
+
+    return f
+
+
+def is_in(iterable, message=None, case_sensitive=True, case_type='upper'):
+    def f(name, value):
+        actual_value = value
+        if not case_sensitive:
+            if case_type == 'upper':
+                value = str(value).upper()
+            elif case_type == 'lower':
+                value = str(value).lower()
+            elif case_type == 'title':
+                value = str(value).title()
+
+        msg = message or '{} should be in {}'.format(name, iterable)
+        if value in iterable:
+            return value, []
+        else:
+            return None, ['{} (actual value: {})'.format(msg, actual_value)]
+    return f
+
+
+def multi_is_in(iterable, message=None, case_sensitive=True, make_lower_case=False, separator=','):
+    def f(name, value):
+        actual_value = value
+        if not case_sensitive:
+            if make_lower_case:
+                value = str(value).lower()
+            else:
+                value = str(value).upper()
+        msg = message or '{} should be among {}. multiple values should be COMMA(,) separated'.format(name, iterable)
+        for val in value.split(separator):
+            if val not in iterable:
+                return None, ['{} (actual value: {})'.format(msg, actual_value)]
+        return value, []
+
+    return f
+
+
+def optional(*validators):
+    def f(name, value):
+        if value is None:
+            return None, []
+        return all_of(*validators)(name, value)
+
+    return f
+
+
+def required(validate):
+    def f(name, value):
+        if not value:
+            return None, '{} is required (current value: None)'.format(name)
+        return validate(name, value)
+
+    return f
+
+
+def of_type(*args):
+    def f(name, value):
+        if value is None:
+            return None, ['{name} cannot be None'.format(name=name)]
+        for typ in args:
+            if isinstance(typ, str):
+                parts = typ.split('.')
+                typ = getattr(
+                    importlib.import_module('.'.join(parts[:-1])), parts[-1])
+            try:
+                value = typ(value)
+                return value, []
+            except ValueError:
+                pass
+        return None, [
+            '{name} should be of type: {types}'.format(
+                name=name, types=[arg.__name__ for arg in args])
+        ]
+
+    return f
+
+
+def of_type_exact(*args):
+    def f(name, value):
+        for typ in args:
+            if isinstance(typ, str):
+                parts = typ.split('.')
+                typ = getattr(
+                    importlib.import_module('.'.join(parts[:-1])), parts[-1])
+            if not isinstance(value, typ):
+                continue
+            return value, []
+        return None, [
+            '{name} should be of type: {types}'.format(
+                name=name,
+                types=[getattr(arg, '__name__', str(arg)) for arg in args])
+        ]
+
+    return f
+
+
+def is_iterable(validator, sep=None):
+    def f(name, value):
+        try:
+            l = []
+            v, e = validator(name, value)
+            if v and not e:
+                raise TypeError()  # hack
+            for i, item in enumerate(iter(value)):
+                val, errs = validator('{}[{}]'.format(name, i), item)
+                if errs:
+                    return None, errs
+                l.append(val)
+            ret = (l, []) if not sep else (sep.join(l), [])
+            return ret
+        except TypeError:
+            val, errs = validator(name, value)
+            if errs:
+                return None, errs
+            return ([val], []) if not sep else (val, [])
+
+    return required(f)
+
+
+def multiple_valid_integers():
+    def f(name, value):
+        if isinstance(value, str):
+            values = value.split('<')
+            for i in values:
+                try:
+                    int(i)
+                except ValueError:
+                    return None, ['{} destination value must be integer'.format(name)]
+            return value, []
+        return value, []
+    return f
+
+
+def validate_args(**to_validate):
+    def outer(wrapped):
+        @functools.wraps(wrapped)
+        def wrapper(self, *args, **kwargs):
+            params = inspect.getcallargs(wrapped, *args, **kwargs)
+            for arg_name, validators in to_validate.items():
+                for validator in validators:
+                    params[arg_name], errs = validator(arg_name,
+                                                       params.get(
+                                                           arg_name, None))
+                    if errs:
+                        raise ValidationError(errs)
+            return wrapped(**params)
+
+        return decorator.decorate(wrapped, wrapper)
+
+    return outer
+
+
+def validate_list_items(instance_type):
+    def f(arg_name, value):
+        if not isinstance(value, list):
+            return [], ["{} must be a list".format(arg_name)]
+
+        errors = []
+        validated_items = []
+        for idx, item in enumerate(value):
+            flag = 0
+            if isinstance(item, dict):
+                try:
+                    instance_type(**item)
+                except Exception as exception:
+                    errors.append(str(exception))
+                    flag = 1
+            else:
+                err = "Invalid item at index {} in {}: should be of type {}".format(idx, arg_name, instance_type.__name__)
+                if not isinstance(item, instance_type):
+                    errors.append(err)
+                    flag = 1
+
+            if not flag:
+                validated_items.append(item)
+
+        return validated_items, errors
+
+    return f
+
+
+def validate_dict_items(instance_type):
+    def validator(arg_name, value):
+        if not isinstance(value, dict):
+            return None, ["{} must be a dictionary".format(arg_name)]
+
+        errors = []
+        try:
+            instance_type(**value)
+        except TypeError as e:
+            errors.append(str(e))
+
+        if errors:
+            return None, errors
+        return value, []
+
+    return validator
+
+
+# Type validator helpers — Python 3 only, no six dependency
+is_valid_date = functools.partial(of_type, str)
+is_phonenumber = functools.partial(of_type, str)
+is_subaccount_id = functools.partial(all_of, of_type(str),
+                                     regex(r'^SA[A-Z0-9]{18}$'))
+is_mainaccount_id = functools.partial(all_of, of_type(str),
+                                      regex(r'^MA[A-Z0-9]{18}$'))
+is_account_id = functools.partial(all_of, of_type(str),
+                                      regex(r'^(M|S)A[A-Z0-9]{18}$'))
+is_subaccount = functools.partial(
+    one_of, of_type_exact('vobiz.resources.accounts.Subaccount'),
+    is_subaccount_id())
+is_url = functools.partial(
+    all_of, of_type(str),
+    regex(
+        r'(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+|None)'
+    ))
+is_proper_date_format = functools.partial(all_of, of_type_exact(str),
+                                          regex(r'^\d{4}-\d{2}-\d{2} \d{2}:\d{2}(:\d{2}(\.\d{1,6})?)?$'))

vobiz/version.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+__version__ = '0.1.0'