facebook_business/adobjects/serverside/normalize.py

# coding=utf-8
# Copyright 2014 Facebook, Inc.

# You are hereby granted a non-exclusive, worldwide, royalty-free license to
# use, copy, modify, and distribute this software in source code or binary
# form for use in connection with the web services and APIs provided by
# Facebook.

# As with any software that integrates with the Facebook platform, your use
# of this software is subject to the Facebook Developer Principles and
# Policies [http://developers.facebook.com/policy/]. This copyright 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.

import datetime
import hashlib
import pycountry
import re

# defined regex for normalization of data
location_excluded_chars = re.compile(r"[0-9.\s\-()]")
isocode_included_chars = re.compile(r"[^a-z]")
email_pattern = re.compile(r".+@.+\..+")
md5_pattern = re.compile(r"^[a-f0-9]{32}$")
sha256_pattern = re.compile(r"^[a-f0-9]{64}$")
year_pattern = re.compile(r"^[0-9]{4}$")

class Normalize(object):


    @staticmethod
    def normalize_field(field, data):
        return Normalize.normalize(field, data, True)

    @staticmethod
    def normalize_field_skip_hashing(field, data):
        return Normalize.normalize(field, data, False)

    @staticmethod
    def normalize(field, data, hash_field):
        """Computes the normalized value for the given field type and data.

        :param field: The field name that is being normalized.
        :param data: The data that is being normalized.
        :return: Normalized value.
        :rtype: str
        """
        if field is None:
            raise TypeError('Field Type must be passed for Normalization')
        if data is None or len(data) == 0:
            return None

        normalized_data = data.lower().strip()
        if Normalize.is_already_hashed(normalized_data):
            return normalized_data

        if field == "em":
            normalized_data = Normalize.validate_email(normalized_data)

        elif field == "ct":
            # Remove numbers, space and period character
            normalized_data = location_excluded_chars.sub("", normalized_data)

        elif field == "zp":
            normalized_data = re.sub(r"\s","", normalized_data)
            normalized_data = normalized_data.split("-")[0]

        elif field == "st":
            # Remove numbers, space and period character
            normalized_data = location_excluded_chars.sub("", normalized_data)

        elif field == "country":
            # Remove any non-alpha characters from the data
            normalized_data = isocode_included_chars.sub("", normalized_data)
            if not Normalize.is_valid_country_code(normalized_data):
                raise TypeError("Invalid format for country:'" + data + "'.Please follow ISO 2-letter ISO 3166-1 standard for representing country. eg: us")

        elif field == "currency":
             # Remove any non-alpha characters from the data
            normalized_data = isocode_included_chars.sub("", normalized_data)
            if len(normalized_data) != 3:
                raise TypeError("Invalid format for currency:'" + data + "'.Please follow ISO 3-letter ISO 4217 standard for representing currency. Eg: usd")

        elif field == "ph":
            # Remove spaces and parenthesis within phone number
            normalized_data = re.sub(r"[\s\-()]", "", normalized_data)

            # Removes the starting + and leading two 0's
            normalized_data = re.sub(r"^\+?0{0,2}", "", normalized_data)

            international_number = Normalize.get_international_number(normalized_data)

            if international_number is None:
                raise ValueError("Invalid format for phone number:'" + normalized_data + "'. Please check passed phone number.")
            else:
                normalized_data = international_number

        elif field == "f5first" or field == "f5last":
            normalized_data = normalized_data[:5]

        elif field == "fi":
            normalized_data = normalized_data[:1]

        elif field == "dobd":
            if len(normalized_data) == 1:
                normalized_data = '0' + normalized_data

            try:
                dobd_int = int(normalized_data)
                if dobd_int < 1 or dobd_int > 31:
                    raise ValueError
            except ValueError:
                raise ValueError("Invalid format for dobd: '%s'. Day should be specified in 'DD' format." % data)

        elif field == "dobm":
            if len(normalized_data) == 1:
                normalized_data = '0' + normalized_data

            try:
                dobm_int = int(normalized_data)
                if dobm_int < 1 or dobm_int > 12:
                    raise ValueError
            except ValueError:
                raise ValueError("Invalid format for dobm: '%s'. Month should be specified in 'MM' format." % data)

        elif field == "doby":
            if not year_pattern.match(normalized_data):
                raise ValueError("Invalid format for doby: '%s'. Year should be specified in 'YYYY' format." % data)

        if hash_field:
            normalized_data = Normalize.hash_sha_256(normalized_data)

        return normalized_data

    """
    Validates the email field for RFC 5322
    :param token: The email token that is being validates.
    :return: validated email value.
    :rtype: str
    """
    @staticmethod
    def validate_email(email):
        result = email_pattern.match(email)
        if result is None:
            raise TypeError('Invalid email format for the passed email:' + email + '.Please check the passed email format.')
        return email

    """
    Checks if the given data is already hashed by MD5 or SHA256 Hash
    :param data: The token that is being checked for hashed.
    :return: boolean representing the {md5/sha256} hash state of the token.
    :rtype: bool
    """
    @staticmethod
    def is_already_hashed(data):
        md5_match = md5_pattern.match(data)
        sha256_match = sha256_pattern.match(data)
        if md5_match is None and sha256_match is None:
            return False
        return True

    @staticmethod
    def hash_sha_256(input):
        if input is None:
            return None
        input = input.encode('utf-8')
        return hashlib.sha256(input).hexdigest()

    @staticmethod
    def get_international_number(phone_number):

        # Removes the + and leading two 0's
        phone_number = re.sub(r"^\+?0{0,2}", "", phone_number)

        if phone_number.startswith('0'):
            return None

        # International Phone number with country calling code.
        international_number_regex = re.compile(r'^\d{1,4}\(?\d{2,3}\)?\d{4,}$')

        matched_groups = international_number_regex.match(phone_number)
        if matched_groups is None:
            return None

        return matched_groups.group()

    """
    Checks if the given country code is present in the ISO list
    :param country code: The code that is being checked for presence.
    :return: boolean indicating whether country code is valid.
    :rtype: bool
    """
    @staticmethod
    def is_valid_country_code(country_code):
        country_data = pycountry.countries.get(alpha_2=country_code.upper())
        return country_data is not None