def normalize_phone(cls, phone_number, country=None):
"""Return the canonical phone number for a given phone number and country.
Assumes a US phone number if no country is given.
"""
errmsg = _('Does not seem to be a valid phone number')
if len(phone_number) < 1:
return ValueError(_("Phone number too short."))
if not country and phone_number[0] != '+':
# Assume US phone number
country = 'US'
try:
pn = phonenumbers.parse(phone_number, country)
except NumberParseException:
pn = cls._try_plus_phonenumber(phone_number, errmsg)
if not phonenumbers.is_valid_number(pn):
# Sometimes a foreign number can look like a valid US number, but it's not
# e.g. 48794987216 - Parses ok, but not is_valid_number. Adding + fixes.
pn = cls._try_plus_phonenumber(phone_number, errmsg)
if not phonenumbers.is_valid_number(pn):
raise ValueError(errmsg)
return phonenumbers.format_number(pn, phonenumbers.PhoneNumberFormat.E164)
def test_is_valid_number(self):
p = phonenumbers.parse('+1123456789')
self.assertFalse(phonenumbers.is_possible_number(p))
self.assertFalse(phonenumbers.is_valid_number(p))
p = phonenumbers.parse('+17184734811')
self.assertTrue(phonenumbers.is_possible_number(p))
self.assertTrue(phonenumbers.is_valid_number(p))
def phone_controll(phone):
numero_tel = None
#On controlle qu'il y a un plus au début, sinon il faut donner la localisation
if phone[0] == "+":
#Si jamais il y a un pb avec le parsage
try:
number = phonenumbers.parse(phone, None)
#On vérifie que le nombre est valide
if phonenumbers.is_valid_number(number):
numero_tel = {}
numero_tel["number"] = phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.E164)
numero_tel["country"] = phonenumbers.region_code_for_number(number)
return numero_tel
else:
return numero_tel
except phonenumbers.phonenumberutil.NumberParseException:
return numero_tel
#Sinon on doit donner une localisation
else:
try:
number = phonenumbers.parse(phone, "FR")
#On vérifie que le nombre est valide
if phonenumbers.is_valid_number(number):
numero_tel = {}
numero_tel["number"] = phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.E164)
numero_tel["country"] = phonenumbers.region_code_for_number(number)
return numero_tel
elif phone.startswith("07"):
numero_tel = {}
numero_tel["number"] = phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.E164)
numero_tel["country"] = phonenumbers.region_code_for_number(number)
return numero_tel
else:
return numero_tel
except phonenumbers.phonenumberutil.NumberParseException:
return numero_tel
def clean(self):
cleaned_data = super(UWSpotExtendedInfoForm, self).clean()
# Have to check value here since we look at multiple items
key = self.cleaned_data['key']
value = self.cleaned_data['value']
if key == 's_phone':
p = re.compile('[A-Za-z]')
if p.search(value):
raise forms.ValidationError("Phone number cannot contain "
"letters")
try:
number = phonenumbers.parse(value, "US")
if (not phonenumbers.is_valid_number(number) or not
phonenumbers.is_possible_number(number)):
raise forms.ValidationError("")
value = phonenumbers.format_number(number,
phonenumbers.
PhoneNumberFormat.E164)
cleaned_data['value'] = value[2:]
except Exception as ex:
raise forms.ValidationError("s_phone must be a phone number")
elif key in validated_ei:
uw_validate(value, key, validated_ei[key])
return cleaned_data
def __init__(self,mobile):
self.mobile = mobile
self.access_token = getattr(settings, 'COGNALYS_ACCESS_TOKEN', '')
self.app_id = getattr(settings, 'COGNALYS_APP_ID', '')
self.api_version = getattr(settings, 'COGNALYS_API_VERSION', 'v1')
p = self.mobile.replace("-", "").replace(" ", "")
z = phonenumbers.parse(p, None)
if not phonenumbers.is_valid_number(z):
raise ValueError('Mobile Number is Not Valid')
elif self.access_token == '':
raise ValueError('Make sure COGNALYS_ACCESS_TOKEN is properly configured in settings.py')
elif self.app_id == '':
raise ValueError('Make sure COGNALYS_APP_ID is properly configured in settings.py')
else:
back = requests.get('https://www.cognalys.com/api/'+self.api_version+'/otp/?access_token='+self.access_token \
+'&app_id='+self.app_id+'&mobile='+p,verify=True)
self.status = back.json()['status']
if back.json()['status'] == 'failed':
self.error_messages = back.json()['errors'].values()
self.error_codes = back.json()['errors'].keys()
else:
self.keymatch = back.json()['keymatch']
self.mobile = back.json()['mobile']
self.otp_start = back.json()['otp_start']
def to_native(self, value, context=None):
""" Schematics deserializer override
We return a phoenumbers.PhoneNumber object so any kind
of formatting can be trivially performed. Additionally,
some convenient properties have been added:
e164: string formatted '+11234567890'
pretty: string formatted '(123) 456-7890'
:return: phonenumbers.PhoneNumber
"""
if isinstance(value, pn.phonenumber.PhoneNumber):
return value
try:
phone = pn.parse(value, 'US')
valid = pn.is_valid_number(phone)
except (NumberParseException, TypeError):
raise ConversionError(self.messages['convert'])
if not valid and pn.is_possible_number(phone):
raise ConversionError(self.messages['invalid'])
elif not valid:
raise ConversionError(self.messages['convert'])
phone.e164 = pn.format_number(phone, pn.PhoneNumberFormat.E164)
phone.pretty = pn.format_number(phone, pn.PhoneNumberFormat.NATIONAL)
return phone
def _validate_type_phonenumber(self, field, value):
""" Validates a phone number is valid. Optionally formatting the number.
:param field: field name.
:param value: field value.
"""
# get the region from schema for this field or use default
self._set_region(self.schema[field].get('region'))
try:
phone_number = parse(value, self.region)
# check that it's valid number
if not is_valid_number(phone_number):
self._error(field, 'Phone Number not valid: {}'.format(value))
elif self.schema[field].get('formatPhoneNumber'):
# if the schema's 'formatPhoneNumber' is set to True,
# format the phone number using a formatter derived from
# the schema's 'phoneNumberFormat' value, next checks the
# environmen variable 'PHONE_NUMBER_FORMAT',
# or defaults to 'NATIONAL'.
formatter = self.schema[field].get('phoneNumberFormat')
self._set_formatter(
formatter=formatter
)
self.document[field] = format_number(phone_number,
self.formatter)
except NumberParseException:
self._error(field, 'Phone Number not valid: {}'.format(value))
def create(self, validated_data):
caller = validated_data['caller']
destination = validated_data['destination']
if validated_data['direction'] == 'outbound':
# Because of GRID-4965, the API returns the destination number in the same format user inserted it,
# so if country code is missing let's patch it with the one from the caller number.
if not destination['number'].startswith('+'):
if caller['number'].startswith('+'):
try:
caller_number = phonenumbers.parse(caller['number'], None)
country_code = get_country_code_by_country(
geocoder.country_name_for_number(caller_number, 'en')
)
destination_number = phonenumbers.parse(destination['number'], country_code)
if phonenumbers.is_valid_number(destination_number):
destination['number'] = phonenumbers.format_number(
destination_number,
phonenumbers.PhoneNumberFormat.E164
)
except NumberParseException, e:
logger.error(traceback.format_exc(e))
data = self.match_external_participant(destination)
if not data['source']:
# We don't save outbound calls where the destination isn't an account or a contact.
# This is the only reliable way to filter out internal calls.
return CallRecord()
def handle(self, *args, **options):
for pb in PublicBody.objects.filter(fax='').exclude(contact=''):
match = FAX_RE.search(pb.contact)
if match is None:
continue
# print(pb.id)
if not match.group(1).strip():
continue
number = None
while True:
try:
number = phonenumbers.parse(match.group(1).strip(), 'DE')
break
except phonenumbers.phonenumberutil.NumberParseException:
if match.group(1).startswith(')'):
match = POST_FAX_RE.search(pb.contact)
else:
print('Bad number:@%s@' % repr(match.group(1)), pb.contact)
break
if number is None:
continue
if not phonenumbers.is_possible_number(number):
print('impossible', match.group(1), '|', pb.contact, '|', pb.id)
continue
if not phonenumbers.is_valid_number(number):
print('invalid', match.group(1), '|', pb.contact, '|', pb.id)
continue
fax_number = phonenumbers.format_number(number,
phonenumbers.PhoneNumberFormat.E164)
pb.fax = fax_number
pb.save()
def is_mobile_valid(mobile, mobile_code="+86"):
m = mobile_code+mobile
try:
return phonenumbers.is_valid_number(phonenumbers.parse(m, None))
except Exception as e:
return False
def clean_phone(key, value, phone_types):
#Athens phone numbers have a 3 digit area code(210) following for a 7 digit number
#if only 7 digits are supplied, I assume it's missing the Athens area code
list_of_phone_num = []
phone_numbers = value.split(";")
for number in phone_numbers:
number = number.replace("+30","").lstrip().rstrip() #strip out country code so that area code can be prefixed if required
m=re.match(r"[^0-9]",number)
if m:
phone_types[number].add(value)
numbers_only = re.sub("[^0-9]", "", value)
if len(numbers_only) == 7 :
number = "210" + number
try:
phone_num = pn.parse(value,"GR")
if pn.is_valid_number(phone_num):
cleaned = pn.format_number(phone_num,pn.PhoneNumberFormat.INTERNATIONAL)
list_of_phone_num.append(cleaned)
except:
pass
return list_of_phone_num
def validate_phone_number(value, validation_error_class):
"""
:type value:fields.PhoneNumber
:return:
"""
assert type(value) is PhoneNumber, "%s instance was supplied instead of PhoneNumber " % (type(value),)
try:
value.region_code = phonenumbers.region_code_for_country_code(int(value.country_code))
value.google_phone_number = phonenumbers.parse(value.phone_number, value.region_code)
value.country_code = value.google_phone_number.country_code
if not phonenumbers.is_valid_number(value.google_phone_number):
fixed = phonenumbers.format_number(phonenumbers.example_number_for_type(
value.region_code,
PhoneNumberType.FIXED_LINE
), phonenumbers.PhoneNumberFormat.NATIONAL)
mobile = phonenumbers.format_number(phonenumbers.example_number_for_type(
value.region_code,
PhoneNumberType.MOBILE
), phonenumbers.PhoneNumberFormat.NATIONAL)
raise validation_error_class(
'Invalid number. format example are: ' +
'for fixed line %(fixed_example)s, for mobile %(mobile_example)s',
code='invalid',
params={
'fixed_example': fixed if fixed else 'no example',
'mobile_example': mobile if mobile else 'no example'
}
)
except NumberParseException as ex:
raise validation_error_class(str(ex))
except validation_error_class as ex:
raise ex
return value
def to_international_format(local_number):
country_code = timezone_to_country_code(settings.TIME_ZONE)
number = phonenumbers.parse(local_number, region=country_code)
if not phonenumbers.is_valid_number(number):
raise InvalidNumber(number)
return phonenumbers.format_number(
number, phonenumbers.PhoneNumberFormat.E164)
def _format_phone_number_entry(self, entry):
"""
Takes a phone number, and adds a default country prefix to it if
missing. It is assumed that phone numbers lacking a prefix, is from
the default region defined in the configuration.
:param unicode : A phone number
:return: A phone number with a country prefix, or None
:rtype: unicode
"""
def warn():
self.logger.warning(
"CIMDataSource: Invalid phone number for person_id:{}, "
"account_name:{}: {} {!r}".format(
self.pe.entity_id,
self.ac.account_name,
str(self.co.ContactInfo(entry['contact_type'])),
phone_number))
phone_number = entry['contact_value']
try:
parsed_nr = phonenumbers.parse(
number=phone_number,
region=self.config.phone_country_default)
if phonenumbers.is_valid_number(parsed_nr):
return phonenumbers.format_number(
numobj=parsed_nr,
num_format=phonenumbers.PhoneNumberFormat.E164)
else:
warn()
except (phonenumbers.NumberParseException, UnicodeDecodeError):
warn()
return None
def verify_phone(phone, **kwargs):
phone = phonenumbers.parse(phone, "US")
if not phonenumbers.is_valid_number(phone):
raise utils.APIException("Invalid phone number")
if phone.country_code != 1:
raise utils.APIException("We only support US/CA numbers now :(")
phone = utils.e164(phone)
ip = _try_to_get_ip(kwargs)
yesterday = utils.now() - timedelta(days=1)
five = utils.now() - timedelta(seconds=5)
if db.PhoneVerify.objects.filter(phone=phone, created__gt=five).count():
return []
invalid = False
invalid |= db.UserInfo.objects.filter(phone=phone).count() > 0
invalid |= db.PhoneBlacklist.objects.filter(phone=phone).count() > 0
invalid |= (
db.PhoneVerify.objects.filter(phone=phone, created__gt=yesterday).count() > settings.SPARK_AUTH_MAX_PHONE_DAY
)
if ip:
invalid |= (
db.PhoneVerify.objects.filter(ip=ip, created__gt=yesterday).count() > settings.SPARK_AUTH_MAX_PHONE_DAY
)
if invalid:
raise utils.APIException("invalid phone number")
code = db.base36(4)
db.PhoneVerify.objects.create(phone=phone, code=code, ip=ip)
message.sms_send(phone, "sparkles phone auth code: " + code)
return []
def pass_number(number, addons):
"""Check number validity"""
passnum = True
try:
marchex = json.load(addons)
if marchex['results']['marchex_cleancall']['result']['result']['recommendation'] == 'BLOCK':
passnum = False
except:
pass
try:
gp = phonenumbers.parse(number)
except:
passnum = False
else:
if phonenumbers.is_possible_number(gp) and phonenumbers.is_valid_number(gp):
if gp.country_code == 1:
gpi = int(str(gp.national_number)[phonenumbers.phonenumberutil.length_of_national_destination_code(gp):])
if gpi >= 5550100 and gpi <= 5550199:
passnum = False
else:
passnum = False
if number in BLOCKED_NUMBERS:
passnum = False
return passnum
def main(argv):
#usage = 'usage: \n %prog [options] arg1 arg2 press -h for help.'
parser = argparse.ArgumentParser(description='Phone number validator using Google phone')
parser.add_argument("-f", "--file", dest="inputFile",help="file for phone numbers")
parser.add_argument("-p", "--phone",dest="phone",help="Phone number to validate.")
parser.add_argument("-c", "--country",dest = "country",help=" Country code to validate.")
opts = parser.parse_args()
country = None #TO prevent reference errors.
if opts.inputFile :
inputFile = opts.inputFile
elif opts.phone != None and opts.country != None :
phone = opts.phone
country = opts.country
else :
country = raw_input("Please enter country to validate against :")
phone = raw_input("Please enter the Phone number : ")
try:
x = phonenumbers.parse(phone,country)
if country:
if phonenumbers.is_valid_number(x) :
print "Valid combinition of number and country"
else :
print "Invalid combinition"
else :
print x
except Exception, e:
print "Invalid phone number or country code Please use -h for usage"
def phonenumber(request, s):
country = request.GET.get('country')
p = phonenumbers.parse(s, country)
possible = phonenumbers.is_possible_number(p)
valid = phonenumbers.is_valid_number(p)
resp = {
'isPossible' : possible,
'isValid' : valid,
}
remote = request.META.get('REMOTE_ADDR')
user = request.META.get('HTTP_X_MASHAPE_USER')
if possible and valid:
resp_deets = {
'countryCode' : p.country_code,
'nationalNumber' : p.national_number,
'e164' : phonenumbers.format_number(p, phonenumbers.PhoneNumberFormat.E164),
'international' : phonenumbers.format_number(p, phonenumbers.PhoneNumberFormat.INTERNATIONAL),
'national' : phonenumbers.format_number(p, phonenumbers.PhoneNumberFormat.NATIONAL),
'rfc3966' : phonenumbers.format_number(p, phonenumbers.PhoneNumberFormat.RFC3966),
'location' : geocoder.description_for_number(p, "en"),
'country' : geocoder.country_name_for_number(p, 'en')
}
resp = dict(resp.items() + resp_deets.items())
return resp
def format_phonenumber(number, international=True):
# type: (Text, bool) -> Text
"""Format phone number for display.
No formatting is applied if the number is not a valid phonenumber.
:param number: the phone number to format.
:param international: always use international format, unless number is in
national format OR country is the same as app's default country.
"""
country = default_country() or "FR"
try:
pn = phonenumbers.parse(number, country)
except phonenumbers.NumberParseException:
return number
except BaseException:
logger.exception(
'error while applying jinja filter "phonenumber" ' "- filter ignored"
)
return number
if not (phonenumbers.is_possible_number(pn) and phonenumbers.is_valid_number(pn)):
return number
fmt = phonenumbers.PhoneNumberFormat.INTERNATIONAL
number_country = phonenumbers.region_code_for_country_code(pn.country_code)
if not international and number_country == country:
fmt = phonenumbers.PhoneNumberFormat.NATIONAL
return phonenumbers.format_number(pn, fmt)
def send_message(number=None, content=None):
""" Send a message to the Twilio client for testing purposes.
Uses twilio authentication and account information
:param number: The 'from' phone number for this message
:param content: The message content
Returns a twilio message object.
"""
from twilio.rest import TwilioRestClient
import phonenumbers
if number is None:
assert 0, "Must provide number"
z = phonenumbers.parse(number, None)
if not phonenumbers.is_valid_number(z):
assert 0, "Dodgy number."
if content is None:
assert 0, "Message content is empty"
account = current_app.config['TWILIO_ACCOUNT_SID']
token = current_app.config['TWILIO_AUTH_TOKEN']
client = TwilioRestClient(account, token)
message = client.messages.create(
to=number,
from_=current_app.config['TWILIO_NUMBER'],
body=content)
return message
def standardize_phone_number(number):
try:
p = parse(number, 'US')
if is_valid_number(p):
return "+%d%d" % (p.country_code, p.national_number)
except:
pass
def format_phone(num):
try:
num = phonenumbers.parse(num, "AU")
if not phonenumbers.is_valid_number(num):
return None
return phonenumbers.format_number(num, phonenumbers.PhoneNumberFormat.NATIONAL)
except:
return None
def phone_number_is_valid(self, phone_number):
try:
p = phonenumbers.parse(phone_number, None)
except phonenumbers.phonenumberutil.NumberParseException:
return False
return phonenumbers.is_possible_number(p) and \
phonenumbers.is_valid_number(p)
def __call__(self, value):
value = force_text(value)
try:
phonenumber = phonenumbers.parse(value, region="AU")
except phonenumbers.NumberParseException:
raise ValidationError(self.invalid_message)
if not phonenumbers.is_valid_number(phonenumber):
raise ValidationError(self.invalid_message)
def validate_number(phone_number, country):
try:
num = phonenumbers.parse(phone_number, country)
if phonenumbers.is_valid_number(num):
print "This phone number is valid."
else:
print "This phone number is invalid."
except phonenumbers.phonenumberutil.NumberParseException:
print "This phone number is invalid."
def validate_number(self, number):
if not phonenumbers.is_possible_number(number):
return "This number is not possible: " \
"{0}".format(number)
if not phonenumbers.is_valid_number(number):
return "This number is not valid: " \
"{0}".format(number)
return number
def valid_number(phone_number):
""" validating phone numbers
:param phone_number:
"""
try:
parsed_number = phonenumbers.parse(phone_number)
except phonenumbers.phonenumberutil.NumberParseException:
return False
return phonenumbers.is_valid_number(parsed_number)
def validate_phone(value, country):
""" local phone number or international """
msg = _("Not a valid %s nor international phone number.") % country
try:
number = phonenumbers.parse(value, country)
except phonenumbers.phonenumberutil.NumberParseException:
raise ValidationError(msg)
if not phonenumbers.is_valid_number(number):
raise ValidationError(msg)
def validate_fax(fax):
try:
number = phonenumbers.parse(fax, settings.LANGUAGE_CODE.upper())
except phonenumbers.phonenumberutil.NumberParseException:
raise forms.ValidationError('Fax number cannot be parsed')
if not phonenumbers.is_possible_number(number):
raise forms.ValidationError('Impossible fax number')
if not phonenumbers.is_valid_number(number):
raise forms.ValidationError('Invalid fax number')
def parse_phone_number(self, raw_string=None, country="US"):
raw_string = raw_string or self.get_current_value()
if raw_string:
parsed_num = phonenumbers.parse(raw_string, country)
if not phonenumbers.is_valid_number(parsed_num):
raise exceptions.InvalidPhoneNumberException(
"'{}' is not a valid phone number".format(raw_string))
return parsed_num
return self.empty_value
def validate_phone(supposed_phone: str) -> bool:
"""
Validate if the phone number given is valid
or not.
:param supposed_phone: Phone number
:type supposed_phone: str
:return: True if the phone number is valid
and False if It is not.
:rtype: bool
"""
try:
supposed_phone = phonenumbers.parse(supposed_phone)
return phonenumbers.is_valid_number(supposed_phone)
except phonenumbers.phonenumberutil.NumberParseException:
return False
def phone_number_validator(value,
region=settings.KOMPASSI_PHONENUMBERS_DEFAULT_REGION
):
"""
Validate the phone number using Google's phonenumbers library.
"""
exc = _('Invalid phone number.')
try:
phone_number = phonenumbers.parse(value, region)
except phonenumbers.NumberParseException as e:
raise ValidationError(exc)
else:
if not phonenumbers.is_valid_number(phone_number):
raise ValidationError(exc)
def ValidPhone(Phone, country, url):
if Phone != None:
try:
parsed_phone = phonenumbers.parse(Phone, country.upper(), True)
valid_phone = phonenumbers.is_valid_number(parsed_phone)
if valid_phone == False:
Util.log.running_logger.warning(
'[Phone Invalid]: {0}: {1}'.format(url, Phone))
return None
return Phone
except:
Util.log.running_logger.error('[Phone Parse]: {0}: {1}'.format(
url, Phone))
return None
return None
def _sms_sanitization(self, partner, field_name):
number = partner[field_name]
if _sms_phonenumbers_lib_imported:
country = self._phone_get_country(partner)
country_code = country.code if country else None
try:
phone_nbr = phonenumbers.parse(number, region=country_code, keep_raw_input=True)
except phonenumbers.phonenumberutil.NumberParseException:
return number
if not phonenumbers.is_possible_number(phone_nbr) or not phonenumbers.is_valid_number(phone_nbr):
return number
phone_fmt = phonenumbers.PhoneNumberFormat.INTERNATIONAL
return phonenumbers.format_number(phone_nbr, phone_fmt).replace(' ', '')
else:
return number
def _validate_phone_number(value):
value = str(value)
phone_number = phonenumbers.parse(value, )
if phonenumbers.is_valid_number(phone_number):
if str(phone_number.country_code) in ALLOWED_COUNTRY_CODE.keys():
return phonenumbers.format_number(
phone_number,
phonenumbers.PhoneNumberFormat.E164)
else:
msg = _("country code not supported yet and this shouldn't "
+ "have happened anyways. It should have been checked "
+ "while registering!")
else:
msg = _("phone number is not valid!!")
raise ValueError(msg)
def set_field_new_building_in_floor(apps, schema_editor):
Flats = apps.get_model('property', 'Flat')
for flat in Flats.objects.all():
owner_phone = flat.owners_phonenumber
phone_number = phonenumbers.parse(owner_phone, "RU")
if not phonenumbers.is_possible_number(phone_number):
error_str = "Телефон {0} содержит неправильное колво цифр"
print(error_str)
continue
if not phonenumbers.is_valid_number(phone_number):
error_str = "Телефон {0} неправильный -не прошел валидациюр"
print(error_str)
continue
flat.owner_pure_phone = phonenumbers.format_number(phone_number, phonenumbers.PhoneNumberFormat.E164)
flat.save()
def printable_phone_number(s):
if not s:
return ''
# Note that we're assuming USA here, but this shouldn't matter, because
# s should already be in E.164 format.
no = phonenumbers.parse(s, 'US')
if not phonenumbers.is_valid_number(no):
return s
# We're checking for +1 here, but this simply means that non-US numbers
# will have the international prefix.
fmt = (phonenumbers.PhoneNumberFormat.NATIONAL if no.country_code == 1 else
phonenumbers.PhoneNumberFormat.INTERNATIONAL)
return phonenumbers.format_number(no, fmt)
def clean(self):
data = self.cleaned_data
if data['password'] != data['confirm_password']:
self.add_error(
'password',
'Password and confirmation did not match'
)
phone_number = data['country_code'] + data['phone_number']
try:
phone_number = phonenumbers.parse(phone_number, None)
if not phonenumbers.is_valid_number(phone_number):
self.add_error('phone_number', 'Invalid phone number')
except NumberParseException as e:
self.add_error('phone_number', e)
def validating_phone_number(sender, instance, created, **kwargs):
if created:
phone = instance.number
is_valid = False
try:
parsed = phonenumbers.parse(phone, str(instance.country).upper())
is_valid = phonenumbers.is_valid_number(parsed)
if is_valid:
phone = "{}{}".format(parsed.country_code,
parsed.national_number)
except:
pass
instance.number = phone
instance.is_phone_number = is_valid
instance.save()
def validatePhone__(self, phone):
try:
parsed_phone = phonenumbers.parse(phone,
self._language.upper(),
_check_region=True)
except phonenumbers.phonenumberutil.NumberParseException as error:
print str(phone) + ' can not parse'
Util.log.running_logger.warning(str(phone) + ' : cannot parse')
return None
if not phonenumbers.is_valid_number(parsed_phone):
print str(phone) + ': not number'
Util.log.running_logger.warning(str(phone) + ' : not number')
return None
else:
return phone
def _parse_phonenumber(val, country_code=None):
try:
phone_obj = phonenumbers.parse(val, country_code)
if phonenumbers.is_valid_number(phone_obj):
return {
'e164': phonenumbers.format_number(
phone_obj, PhoneNumberFormat.E164),
'international': phonenumbers.format_number(
phone_obj, PhoneNumberFormat.INTERNATIONAL),
'national': phonenumbers.format_number(
phone_obj, PhoneNumberFormat.NATIONAL),
}
return None
except phonenumberutil.NumberParseException:
return None
def get_normalized_phone_number(raw_phone_number, check_validity=False):
try:
parsed_data = phonenumbers.parse(raw_phone_number, "HU")
except phonenumbers.NumberParseException:
raise InvalidPhoneNumber(
_('Include "+" sign, country code and area code.'))
if phonenumbers.is_valid_number(parsed_data):
return phonenumbers.format_number(
parsed_data, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
if check_validity:
raise InvalidPhoneNumber(
_('Include "+" sign, country code and area code.'))
return raw_phone_number
def addProductPost(number):
text = number
for match in phonenumbers.PhoneNumberMatcher(text, "US"):
numberFormated = (phonenumbers.format_number(
match.number, phonenumbers.PhoneNumberFormat.E164))
z = phonenumbers.parse(numberFormated, None)
validNumber = phonenumbers.is_valid_number(z)
ch_number = phonenumbers.parse(numberFormated, "CH")
geo = geocoder.description_for_number(ch_number, "es")
#numbers, valid, location
return jsonify({
"number": numberFormated,
"valid": validNumber,
"location": geo
})
def validate_phone_number(form, field): # pylint: disable=no-self-argument, no-self-use
"""
Validates that the provided phone number is valid.
Args:
form: The EditResidentProfileForm that was submitted.
field: The phone_number field.
Raises:
ValidationError: If phone_number is not a valid phone number.
"""
if len(field.data) > 16:
raise ValidationError('Invalid phone number.')
try:
input_number = phonenumbers.parse(field.data)
if not phonenumbers.is_valid_number(input_number):
raise ValidationError('Invalid phone number.')
except NumberParseException:
try: # Try to add the US area code to it
input_number = phonenumbers.parse("+1" + field.data)
if not phonenumbers.is_valid_number(input_number):
raise ValidationError('Invalid phone number.')
except NumberParseException: # pylint: disable=bare-except
raise ValidationError('Invalid phone number.')
def validate_number(raw_number):
"""
tries to validate the incoming number. Returns the number formatted in a way Twilio likes if it works, or None if it doesn't.
"""
try:
parsed_number = phonenumbers.parse(raw_number, "US")
if phonenumbers.is_possible_number(
parsed_number) and phonenumbers.is_valid_number(parsed_number):
formatted_number = phonenumbers.format_number(
parsed_number, phonenumbers.PhoneNumberFormat.E164)
return formatted_number
else:
return None
except:
return None
def normalize_owners_phone_numbers(apps, schema_editor):
Flat = apps.get_model('property', 'Flat')
for flat in Flat.objects.all():
try:
parsed_phonenumber = phonenumbers.parse(flat.owners_phonenumber,
'RU')
if not phonenumbers.is_valid_number(parsed_phonenumber):
flat.owner_pure_phone = ""
else:
flat.owner_pure_phone = parsed_phonenumber
except phonenumbers.phonenumberutil.NumberParseException:
flat.owner_pure_phone = ""
flat.save()
def save(self, *args, **kwargs):
string_value = self.cod_pais + self.cod_area + self.nro_tel
try:
value = phonenumbers.parse(string_value, 'AR')
except NumberParseException:
raise ValidationError(
'Ingrese un numero de telefono con formato valido.')
if phonenumbers.is_valid_number(
value) and phonenumbers.is_possible_number(value):
self.full_nro_tel = phonenumbers.format_number(
value, phonenumbers.PhoneNumberFormat.E164)
else:
raise ValidationError(
'Ingrese un numero de telefono con formato valido.')
super(PerTel, self).save(*args, **kwargs)
def fill_owners_phone_pure_field(apps, schema_editor):
Flat = apps.get_model('property', 'Flat')
all_flats = Flat.objects.all()
for flat in all_flats:
phone_number_object = phonenumbers.parse(flat.owners_phonenumber, 'RU')
if phonenumbers.is_valid_number(phone_number_object):
flat.owners_phone_pure = phonenumbers.format_number(
numobj=phone_number_object,
num_format=phonenumbers.PhoneNumberFormat.E164,
)
Flat.objects.bulk_update(all_flats, ['owners_phone_pure'])
def create_route():
# Fetch clients from DB
refresh_clients()
# Validate request
if not validate_recaptcha(request.values.get("recaptcha_token")):
return "Invalid request", 401
# Validate phone number
phone_number = request.values.get("phone")
phone_number_obj = phonenumbers.parse(phone_number, None)
if phonenumbers.is_valid_number(phone_number_obj):
return begin_onboard(phone_number)
else:
return "Invalid Number", 400
def _force_validation(self, phonenumber, fieldname):
"""Force the validation using phonenumbers of a given number
:param phonenumber: string
:param str fieldname: name of the field the number is related to.
:raise ValidationError: if the given number is not validated.
"""
number = phonenumbers.parse(phonenumber, self.country_id.code)
if not phonenumbers.is_valid_number(number):
error_msg = '\n'.join([
'The number ({}) "{}" seems not valid for {}.'.format(
fieldname, phonenumber, self.country_id.name),
'Please double check it.'
])
raise ValidationError(error_msg)
def validate_order(phoneNumber, diningDate, diningTime, cuisine):
cuisine_list = ['chinese', 'japanese', 'american', 'mexican', 'italian']
if cuisine is not None:
if cuisine.lower() not in cuisine_list:
return build_validation_result(
False, 'cuisine',
'We only have Chinese, Japanese, American, Mexican,'
'Italian. Sorry for the inconvenience caused.')
if phoneNumber is not None:
try:
if not phonenumbers.is_valid_number(
phonenumbers.parse(phoneNumber, "US")):
return build_validation_result(
False, 'phoneNumber',
'Please provide a valid phone number.')
except:
return build_validation_result(
False, 'phoneNumber', 'Please provide a valid phone number.')
if diningDate is not None:
if not isvalid_date(diningDate):
return build_validation_result(
False, 'diningDate', 'I did not understand that, '
'what date would you like to go to the restaurant?')
elif datetime.datetime.strptime(
diningDate, '%Y-%m-%d').date() < datetime.date.today():
return build_validation_result(
False, 'diningDate',
'You can go to the restaurant from today onwards. '
'What day would you like to go?')
if diningTime is not None:
if len(diningTime) != 5:
# Not a valid time; use a prompt defined on the build-time model.
return build_validation_result(False, 'diningTime', None)
hour, minute = diningTime.split(':')
hour = parse_int(hour)
minute = parse_int(minute)
if math.isnan(hour) or math.isnan(minute):
# Not a valid time; use a prompt defined on the build-time model.
return build_validation_result(False, 'diningTime', None)
# if hour < 10 or hour > 16:
# # Outside of business hours
# return build_validation_result(False, 'PickupTime', 'Our business hours are from ten a m. to five p m. Can you specify a time during this range?')
return build_validation_result(True, None, None)
def getCoordFromPhoneAndPublish(self, phoneNumber, categ):
try:
rep = phonenumbers.parse(phoneNumber, None)
if not (phonenumbers.is_valid_number(rep)
or phonenumbers.is_possible_number(rep)):
self.logger.warning("Phone number not valid")
return
country_name = geocoder.country_name_for_number(rep, "en")
country_code = self.country_to_iso[country_name]
if country_code is None:
self.logger.warning("Non matching ISO_CODE")
return
coord = self.country_code_to_coord[
country_code.lower()] # countrycode is in upper case
coord_dic = {'lat': coord['lat'], 'lon': coord['long']}
ordDic = OrderedDict() #keep fields with the same layout in redis
ordDic['lat'] = coord_dic['lat']
ordDic['lon'] = coord_dic['lon']
coord_list = [coord['lat'], coord['long']]
if not self.coordinate_list_valid(coord_list):
raise InvalidCoordinate(
"Coordinate do not match EPSG:900913 / EPSG:3785 / OSGEO:41001"
)
self.push_to_redis_zset(self.keyCategCoord, json.dumps(ordDic))
self.push_to_redis_zset(self.keyCategCountry, country_code)
ordDic = OrderedDict() #keep fields with the same layout in redis
ordDic['categ'] = categ
ordDic['value'] = phoneNumber
self.push_to_redis_geo(self.keyCategRad, coord['long'],
coord['lat'], json.dumps(ordDic))
to_send = {
"coord": coord_dic,
"categ": categ,
"value": phoneNumber,
"country": country_name,
"specifName": "",
"cityName": "",
"regionCode": country_code,
}
j_to_send = json.dumps(to_send)
self.serv_coord.publish(self.CHANNELDISP, j_to_send)
self.live_helper.add_to_stream_log_cache('Map', j_to_send)
self.logger.info('Published: {}'.format(json.dumps(to_send)))
except phonenumbers.NumberParseException:
self.logger.warning("Can't resolve phone number country")
except InvalidCoordinate:
self.logger.warning("Coordinate do not follow redis specification")
def _run_validation_for_non_option_type(self, data: Any,
question: Question) -> None:
"""
This validates multiple requirements for an answer that has a
corresponding question that of a non-option type:
- The `answer_options` field must be null
- The 'answer` field must have at least one character if the
corresponding question has `required` set to True
- The `answer` field is in the correct format, depending on the
type of question the answer corresponds to
"""
# Check that `answer` field is filled if the question says its required
# and also check that the `answer_options` field is null
if data.get("answer_options") is not None:
self.fail_for_field("only_answer_field")
if question.required and (data.get("answer") is None
or data.get("answer").strip() == ""):
self.fail_for_field("answer_is_required")
# Validate if the `answer` field is in the correct format
if question.type == Question.QuestionType.PHONE:
try:
pn = phonenumbers.parse(data.get("answer"))
if not phonenumbers.is_valid_number(pn):
self.fail_for_field("invalid_phone_number")
except phonenumbers.NumberParseException:
self.fail_for_field("invalid_phone_number")
elif question.type == Question.QuestionType.EMAIL:
try:
validate_email(data.get("answer"))
except DjangoValidationError:
self.fail_for_field("invalid_email")
elif question.type == Question.QuestionType.HTTP_URL:
try:
validate_url = URLValidator(schemes=["http", "https"])
validate_url(data.get("answer"))
except DjangoValidationError:
self.fail_for_field("invalid_http_url")
elif question.type in [
Question.QuestionType.PDF_FILE,
Question.QuestionType.IMAGE_FILE,
]:
try:
af = AnswerFile.objects.get(id=data.get("answer"))
if af.question.id != question.id:
self.fail_for_field("invalid_file")
except AnswerFile.DoesNotExist:
self.fail_for_field("invalid_file")
def do(x):
phonenumber = phonenumbers.parse(x, 'NZ')
print "Raw: %s" % x
print "PhoneNumber: %s" % phonenumber
print "National: %s" % phonenumbers.format_number(
phonenumber, phonenumbers.PhoneNumberFormat.NATIONAL)
print "International: %s" % phonenumbers.format_number(
phonenumber, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
print "E164: %s" % phonenumbers.format_number(
phonenumber, phonenumbers.PhoneNumberFormat.E164)
print "Possible Number: %s" % phonenumbers.is_valid_number(phonenumber)
print "Valid Number: %s" % phonenumbers.is_possible_number(phonenumber)
print "Type: %s" % phonenumbers.number_type(phonenumber)
print "*********************"
print '\n'
def get_canonical_form(self, input_data):
""" Validate and return a canonical form to be stored in DB
and compared against.
Returns ``None`` if input isn't a valid phone number.
"""
import phonenumbers
try:
z = phonenumbers.parse(input_data,
region=config_value("PHONE_REGION_DEFAULT"))
if phonenumbers.is_valid_number(z):
return phonenumbers.format_number(
z, phonenumbers.PhoneNumberFormat.E164)
return None
except phonenumbers.phonenumberutil.NumberParseException:
return None
def phone_check(self,phone): #Try parse phone number with E164 format try: p = phonenumbers.parse(phone, None) except: try: #if not in E164 format, parse with US phone number format by default p = phonenumbers.parse(phone,'US') except: return False #Use successful parsing phone number to validate m = phonenumbers.is_valid_number(p) if m is None: return False else: return True
def validate_phone(self, phone):
try:
p = phonenumbers.parse(phone.data)
if not phonenumbers.is_valid_number(p):
raise ValueError()
except (phonenumbers.phonenumberutil.NumberParseException, ValueError):
raise ValidationError('Invalid phone number')
try:
user = User.query.filter_by(phone=phone.data).first()
if user:
raise ValidationError
except (phonenumbers.phonenumberutil.NumberParseException, ValueError):
raise ValidationError(
'This number is already registered, try another one.')
def validate_mobileNumber(self, mobileNumber):
numberExist = User.query.filter_by(
phonenumber=mobileNumber.data).first()
if numberExist is not None:
raise ValidationError(f'{mobileNumber.data} is already taken')
if phone.match(mobileNumber.data):
mobile = phonenumbers.parse(mobileNumber.data, "IN")
checkNumber = phonenumbers.is_valid_number(mobile)
if checkNumber:
pass #valid mobile Number
else:
raise ValidationError("Enter a valid phone Number")
else:
raise ValidationError(
"Phone Numbers must start 0, +91 or the 10 digit number itself"
)
def register(user_manager):
"""Create user."""
request_data = request.get_json()
if ("username" not in request_data or "password" not in request_data
or "phone" not in request_data):
raise InvalidRequestException
if not phonenumbers.is_valid_number(
phonenumbers.parse(request_data["phone"], None)):
raise InvalidRequestException
hashed_password = generate_password_hash(request_data["password"])
user_manager.create(
request_data["username"],
hashed_password,
request_data["phone"],
)
return jsonify({"message": "Successfully registered."})
def format_mobile(mobile):
if mobile and mobile != '000':
m = None
try:
m = phonenumbers.parse(mobile, 'CN')
except:
pass
if m and phonenumbers.is_valid_number(m):
if m.country_code == 86:
return unicode(m.national_number)
else:
return phonenumbers.format_number(
m, phonenumbers.PhoneNumberFormat.E164)
return mobile
