def validatePhoneNumber(number):
valid = False
try:
# Leave shortcodes alone.
if number is not None:
if len(number) in (3, 4, 5, 6) and number.isdigit():
return True
# it's okay to search for the region US for all US/Can b/c they share
# the same parsing/formatting rules
p = phonenumbers.parse(number, 'US')
# but we need to check the number is valid in either country
if phonenumbers.is_valid_number_for_region(p, 'US') or \
phonenumbers.is_valid_number_for_region(p, 'CA'):
phonenumbers.format_number(
p,
phonenumbers.PhoneNumberFormat.E164
)
valid = True
except phonenumbers.NumberParseException as e:
logging.error('Detected invalid phone number: {0}-{1}'.format(
number, e))
return valid
def validatePhoneNumber(number, allowShortcode=True):
valid = False
try:
# Leave shortcodes alone.
if number is not None:
if allowShortcode and len(number) in (
3, 4, 5, 6) and number.isdigit(): # noqa
return True
# it's okay to search for the region US for all US/Can b/c they
# share the same parsing/formatting rules
p = phonenumbers.parse(number, 'US')
# but we need to check the number is valid in either country
if phonenumbers.is_valid_number_for_region(p, 'US') or \
phonenumbers.is_valid_number_for_region(p, 'CA'):
phonenumbers.format_number(p,
phonenumbers.PhoneNumberFormat.E164)
valid = True
except phonenumbers.NumberParseException as e:
logging.warning('Detected invalid phone number: {0} - {1}'.format(
number, e))
return valid
def test_load_alt_patterns(load_fixture):
phone_number = PhoneNumber(load_fixture)
assert phone_number.get_national() == '+0{}'.format('2' * 7)
assert phone_number.get_mobile() == '+0{}'.format('1' * 9)
clean_alt_patters()
phone_number = PhoneNumber(load_fixture)
num_obj = phonenumbers.parse(phone_number.get_national(), load_fixture)
assert phonenumbers.is_valid_number_for_region(num_obj, load_fixture)
num_obj = phonenumbers.parse(phone_number.get_mobile(), load_fixture)
assert phonenumbers.is_valid_number_for_region(num_obj, load_fixture)
def change_phonenumbers(apps, schema_editor):
Flat = apps.get_model('property', 'Flat')
for flat in Flat.objects.all():
phone_number = phonenumbers.parse(flat.owners_phonenumber, 'RU')
if phonenumbers.is_valid_number_for_region(phone_number, 'RU'):
flat.owner_phone_pure = phonenumbers.format_number(phone_number, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
flat.save()
def validate_phone_number(phone_number: str = ''):
try:
if not phone_number:
return 'Missing phone number', -4
if type(phone_number) != str:
return "Unable to determine phone number", -4
region = "KE"
# Create a `PhoneNumber` object from a string representing a phone number
# Specify country of origin of phone number.
# This maybe unnecessary for numbers starting with '+' since they are globally unique.
parsed_phone = phonenumbers.parse(phone_number, region)
# Check whether it's a possible number (e.g. it has the right number of digits)
if not phonenumbers.is_possible_number(parsed_phone):
return "Possibly not a number. Check if e.g. number of digits is correct", -4
# Check whether it's a valid number (e.g. it's in an assigned exchange)
if not phonenumbers.is_valid_number_for_region(parsed_phone, region):
return "Invalid phone number", -4
# Format number as per international format code E164
phone_number = phonenumbers.format_number(
parsed_phone, phonenumbers.PhoneNumberFormat.E164)
# Get the carrier of the phone number
operator = carrier.name_for_number(parsed_phone,
"en") if carrier.name_for_number(
parsed_phone, "en") else ''
return f"""Phone number valid. Phone: {phone_number}. Operator: {operator}""", 0
except phonenumbers.phonenumberutil.NumberParseException as err:
return f'{err}', -4
except BaseException as ex:
return f'{ex}', -4
def ussd_flow(request):
request_data = request.GET if request.method == 'GET' else request.POST
request_data = request_data.copy()
request_data['format'] = 'text'
mobile = request_data.get(settings.USSD_MOBILE_NUMBER_FIELD, '')
try:
country_code = pycountry.countries.lookup(settings.COUNTRY).alpha_2
pn = phonenumbers.parse(mobile, country_code)
if phonenumbers.is_valid_number_for_region(pn, country_code):
mobile = pn.national_number
request_data['uid'] = mobile
request_data['value'] = request_data.get(settings.USSD_MSG_FIELD,
'')
if request.method == 'GET':
request.GET = request_data
if request.method == 'POST':
request.POST = request_data
_response = respond(request)
response = settings.USSD_RESPONSE_FORMAT % {
'response': _response.content.strip()
}
else:
response = 'Invalid mobile number for your region'
except phonenumbers.NumberParseException:
response = 'Invalid mobile number'
return HttpResponse(response.encode('ascii'),
content_type='text/plain; charset=utf-8')
def parse_phone(phone_str, country_code=0, alpha2=u"US"):
"returns a dict with phone number properties if the string is parsable"
"""
returns dict w/: phone_str, phone_str_digits_only, country_code, region, errors (if any)
"""
try:
if COUNTRY_RG.match(phone_str):
phone = parse_number(rm_punct_leaving_plus_sign(phone_str), keep_raw_input=True)
elif country_code != 0:
phone = parse_number(u"+{} {}".format(country_code, phone_str), keep_raw_input=True)
else:
country_code = country_code_for_region(alpha2)
if country_code != 0:
phone = parse_number(u"+{} {}".format(country_code, phone_str), keep_raw_input=True)
else:
phone = parse_number(phone_str, alpha2, keep_raw_input=True)
phone_dict = phone.__dict__.copy()
phone_dict['region_code'] = region_code_for_country_code(phone.country_code)
phone_dict['phone_str'] = phone_str
phone_dict['is_valid_for_region'] = is_valid_number_for_region(phone, region_code_for_country_code(phone.country_code))
except:
keys = ['region_code','italian_leading_zero','extension','national_number','is_valid_for_region','raw_input','country_code_source','phone_str','country_code','number_of_leading_zeros','preferred_domestic_carrier_code']
phone_dict = {k: None for k in keys}
phone_dict['phone_str'] = phone_str
return phone_dict
def is_phone_number_valid(phone_number):
try:
parse = phonenumbers.parse(phone_number)
except phonenumbers.phonenumberutil.NumberParseException:
return False
if phonenumbers.is_valid_number_for_region(parse, 'RU'):
return parse.national_number
def validate(self):
# check if all required fields are filled
rv = FlaskForm.validate(self)
if not rv:
return False
password = self.password.data
if len(password) < 8 or len(password) > 100:
self.password.errors.append(
"Please enter a password of between 8 and 100 characters")
return False
telephone = self.telephone.data
if not telephone:
self.telephone.errors.append("Missing phone numbers")
return False
if type(telephone) != str:
self.telephone.errors.append("Unable to determine phone number")
return False
region = "KE"
# Create a `PhoneNumber` object from a string representing a phone number
# Specify country of origin of phone number.
# This maybe unnecessary for numbers starting with '+' since they are globally unique.
phone = phonenumbers.parse(telephone, region)
# Check whether it's a possible number (e.g. it has the right number of digits)
if not phonenumbers.is_possible_number(phone):
self.telephone.errors.append(
"Possibly not a number. Check if e.g. number of digits is correct"
)
return False
# Check whether it's a valid number (e.g. it's in an assigned exchange)
if not phonenumbers.is_valid_number_for_region(phone, region):
self.telephone.errors.append("Invalid phone number")
return False
# Format number as per international format code E164
phone_number = phonenumbers.format_number(
phone, phonenumbers.PhoneNumberFormat.E164)
# Get the carrier of the phone number
operator = carrier.name_for_number(
phone, "en") if carrier.name_for_number(phone, "en") else ''
print(phone_number, operator)
# Ensure phone is Safaricom
if operator != "Safaricom":
self.telephone.errors.append(
"Kindly use a Safaricom line for MPESA prompt")
return False
# If telephone is not registered, raise error
user = User.query.filter_by(telephone=phone_number).first()
if not user:
self.telephone.errors.append('User not registered')
return False
# confirm user's password
if not user.verify_password(password):
self.password.errors.append("Invalid password")
return False
return True
def parsePhoneNumber(n, debugging=False):
if debugging: print(n)
n = pn.parse(n, 'GB')
assert (pn.is_possible_number(n))
isUK = pn.is_valid_number_for_region(n, 'GB')
if debugging: print('valid UK number?', isUK)
INTN = pn.format_number(n, pn.PhoneNumberFormat.INTERNATIONAL)
if debugging: print INTN
return INTN
def parsePhoneNumber(n,debugging = False):
if debugging: print (n)
n = pn.parse(n,'GB')
assert (pn.is_possible_number(n))
isUK = pn.is_valid_number_for_region(n,'GB')
if debugging: print('valid UK number?',isUK)
INTN = pn.format_number(n, pn.PhoneNumberFormat.INTERNATIONAL)
if debugging: print INTN
return INTN
async def get_user_phonenumber(self, phonenumber: str):
try:
phone = phonenumbers.parse(phonenumber, self.region)
except phonenumbers.phonenumberutil.NumberParseException:
raise TypeError("Invalid Phone Number")
if is_valid_number_for_region(phone, self.region):
return phonenumbers.format_number(
phone, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
raise Exception(
f"{phonenumber} is not a valid number format for {self.country_name.name.capitalize()}"
)
def parse_phone_number(pnum, country='us'):
"""Parse and validate phone number input and return an E164 formatted number or None if invalid."""
region_code = country.upper()
try:
pn = phonenumbers.parse(pnum, region_code)
except phonenumbers.NumberParseException:
return None
if phonenumbers.is_valid_number_for_region(pn, region_code):
return phonenumbers.format_number(pn, phonenumbers.PhoneNumberFormat.E164)
return None
def parse_phone_number(pnum, country="us"):
"""Parse and validate phone number input and return an E164 formatted number or None if invalid."""
region_code = country.upper()
try:
pn = phonenumbers.parse(pnum, region_code)
except phonenumbers.NumberParseException:
return None
if phonenumbers.is_valid_number_for_region(pn, region_code):
return phonenumbers.format_number(pn, phonenumbers.PhoneNumberFormat.E164)
return None
def format_for_display(value, region):
try:
phonenumber = phonenumbers.parse(value, region)
except phonenumbers.NumberParseException:
# For historical data that may not be parseable
return value
if phonenumbers.is_valid_number_for_region(phonenumber, region):
return phonenumbers.format_number(
phonenumber, phonenumbers.PhoneNumberFormat.NATIONAL)
else:
return phonenumbers.format_number(
phonenumber, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
def detect(self, txt, country="FR"):
"""
:param txt: the text where we will try to find phone numbers
:param country: the country format of the phone
"""
txt = re.sub("\s", " ", txt)
return [(self._categorize_phone(txt, match),
pn.format_number(match.number,
pn.PhoneNumberFormat.INTERNATIONAL))
for match in pn.PhoneNumberMatcher(txt, country)
if pn.is_valid_number_for_region(match.number, country)]
def send(self, message):
"""
Send a single text message.
TODO: Add a batch send feature.
:param message: (smsframework.OutgoingMessage) The message to send.
:return: (smsframework.OutgoingMessage) The sent message, updated with
msgid.
"""
logging.debug('smsframework africastalking sending sms')
target_country = message.provider_params['target_country']
try:
phone_number = phonenumbers.parse(message.dst, target_country)
except:
raise InvalidNumberError(message.dst, 'Unable to Parse Number')
number_is_valid = phonenumbers.is_valid_number_for_region(
phone_number, target_country)
if number_is_valid is False:
raise InvalidNumberError(message.dst,
'Invalid Phone Number for Target Country',
target_country=target_country)
try:
formatted_number = phonenumbers.format_number(
phone_number, phonenumbers.PhoneNumberFormat.E164)
except:
InvalidNumberError(message.dst, 'Unable to Parse Phone Number')
try:
api_response = self.sms_client.send(
message.body, [formatted_number],
message.provider_options.senderId)
except Exception as e:
error = json.loads(e.args[0])
error_status = error['SMSMessageData']['Recipients'][0]['status']
logging.error('smsframework africastalking sms failed')
if error_status == 'InvalidPhoneNumber':
raise InvalidNumberError(formatted_number)
else:
raise AfricasTalkingProviderError(error_status)
sent_message = api_response['SMSMessageData']['Recipients'][0]
message.msgid = sent_message['messageId']
return message
def format_for_display(value, region=None):
try:
phonenumber = phonenumbers.parse(value, region)
except phonenumbers.NumberParseException:
# For historical data that may not be parseable
return value
if region is not None and phonenumbers.is_valid_number_for_region(
phonenumber, region):
return phonenumbers.format_number(
phonenumber, phonenumbers.PhoneNumberFormat.NATIONAL)
else:
return phonenumbers.format_number(
phonenumber, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
def validatePhoneNumber(self):
self.phonenumber_details[
'is_validnumber'] = phonenumbers.is_valid_number(
self.phonenumber_object)
self.phonenumber_details[
'is_possiblenumber'] = phonenumbers.is_possible_number(
self.phonenumber_object)
self.phonenumber_details[
'is_validnumberforRegion'] = phonenumbers.is_valid_number_for_region(
self.phonenumber_object, self.get_iso2())
return self.phonenumber_details[
'is_validnumber'] * self.phonenumber_details[
'is_possiblenumber'] * self.phonenumber_details[
'is_validnumberforRegion']
def validate_phone_number(value, country_code='VN'):
"""
Validate a phone number
:param value:
:param country_code: country code to check phone number
:return: formated phone number
"""
msg = _('Invalid phone number format.')
try:
phone = phonenumbers.parse(value, country_code)
except:
raise ValidationError(msg)
if not phonenumbers.is_valid_number_for_region(phone, country_code):
raise ValidationError(msg)
return value
def clean_phone_number(self):
region_code = "US" # US only for proof of concept.
number = self.cleaned_data["phone_number"]
# For testing purposes we accept 5555555555 (no formatting).
if number == "5555555555":
return number
try:
pn = phonenumbers.parse(number, region_code)
except phonenumbers.NumberParseException:
raise forms.ValidationError("Invalid phone number")
if not phonenumbers.is_valid_number_for_region(pn, region_code):
raise forms.ValidationError(f"Invalid phone number for region: {region_code}")
return phonenumbers.format_number(pn, phonenumbers.PhoneNumberFormat.E164)
def parse_mobile_number(value):
def is_mobile_number(parsed_number):
for prefix in MOBILE_PHONE_PREFIXES:
if str(parsed_number.national_number).startswith(prefix[1:]):
return True
return False
try:
parsed_number = phonenumbers.parse(value, 'DE')
except NumberParseException:
raise ValidationError(BAD_FORMAT_NUMBER)
if not phonenumbers.is_valid_number_for_region(parsed_number, 'de'):
raise ValidationError(INVALID_NUMBER)
if not is_mobile_number(parsed_number):
raise ValidationError(INVALID_MOBILE_NUMBER)
return phonenumbers.format_number(parsed_number,
phonenumbers.PhoneNumberFormat.INTERNATIONAL)
def parse_mobile_number(value):
def is_mobile_number(parsed_number):
for prefix in MOBILE_PHONE_PREFIXES:
if str(parsed_number.national_number).startswith(prefix[1:]):
return True
return False
try:
parsed_number = phonenumbers.parse(value, 'DE')
except NumberParseException:
raise ValidationError(BAD_FORMAT_NUMBER)
if not phonenumbers.is_valid_number_for_region(parsed_number, 'de'):
raise ValidationError(INVALID_NUMBER)
if not is_mobile_number(parsed_number):
raise ValidationError(INVALID_MOBILE_NUMBER)
return phonenumbers.format_number(
parsed_number, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
def clean_user_identifier(self):
identifier = self.cleaned_data.get('user_identifier', '')
try:
country_code = pycountry.countries.lookup(settings.COUNTRY).alpha_2
identifier = phonenumbers.parse(identifier, country_code)
if phonenumbers.is_valid_number_for_region(identifier, country_code):
self.cleaned_data[
'user_identifier'] = identifier.national_number
else:
raise ValidationError('Invalid mobile number for your region')
except phonenumbers.NumberParseException:
raise ValidationError('Invalid mobile number')
accesses = USSDAccess.objects.filter(
user_identifier=identifier.national_number)
if self.instance and accesses.exclude(
interviewer=self.instance.interviewer).exists():
raise ValidationError(
'This mobile number is already in use by %s' %
accesses. exclude(
interviewer=self.instance.interviewer)[0].interviewer.name)
return self.cleaned_data['user_identifier']
def clean_user_identifier(self):
identifier = self.cleaned_data.get('user_identifier', '')
try:
identifier = phonenumbers.parse(identifier, settings.COUNTRY_CODE)
if phonenumbers.is_valid_number_for_region(identifier,
settings.COUNTRY_CODE):
self.cleaned_data[
'user_identifier'] = identifier.national_number
else:
raise ValidationError('Invalid mobile number for your region')
except phonenumbers.NumberParseException:
raise ValidationError('Invalid mobile number')
accesses = USSDAccess.objects.filter(
user_identifier=identifier.national_number)
if self.instance and accesses.exclude(
interviewer=self.instance.interviewer).exists():
raise ValidationError(
'This mobile number is already in use by %s' %
accesses.exclude(
interviewer=self.instance.interviewer)[0].interviewer.name)
return self.cleaned_data['user_identifier']
def validate(self, attrs):
"""
Validate that every attributes of the serializer is valid.
This mainly checks the phone number.
:param attrs: attributes to validate
:return: all valid attributes
"""
attrs = super().validate(attrs)
if "phone_number" in attrs and "country" not in attrs:
raise ValidationError({
"country":
"This field is required when giving phone number."
})
if "country" in attrs and "phone_number" not in attrs:
raise ValidationError({
"phone_number":
"This field is required when giving a country."
})
if "phone_number" in attrs:
try:
phone_number = phonenumbers.parse(attrs["phone_number"],
attrs["country"])
except Exception:
raise ValidationError(
{"phone_number": "This is not a valid phone number"})
if not phonenumbers.is_valid_number_for_region(
phone_number, attrs["country"]):
raise ValidationError(
{"phone_number": "This is not a valid phone number."})
attrs["phone_number"] = phonenumbers.format_number(
phone_number, phonenumbers.PhoneNumberFormat.E164)
attrs.pop("country")
return attrs
def handle(request):
if request.method == 'GET':
data = request.GET
else:
data = request.POST
trnx_id = data.get('transactionId', '').strip()
msisdn = data.get('msisdn', '').strip()
try:
pn = phonenumbers.parse(msisdn, settings.COUNTRY_CODE)
if phonenumbers.is_valid_number_for_region(pn, settings.COUNTRY_CODE):
msisdn = pn.national_number
else:
return HttpResponse('Invaid mobile number for your region')
except phonenumbers.NumberParseException:
return HttpResponse('Invaid mobile number')
request_string = data.get('ussdRequestString', '').strip()
res = manage(msisdn, trnx_id, request_string)
action = 0
if res:
action = 1
ussd_resp = 'responseString=%s&action=%s' % (res, action)
return HttpResponse(ussd_resp)
def format_value(cls, value=None, type_=None):
if phonenumbers and type_ in _PHONE_TYPES:
Configuration = Pool().get('party.configuration')
config = Configuration(1)
if config.party_phonecountry:
code = config.party_phonecountry.code
try:
phonenumber = phonenumbers.parse(value, region=code)
except NumberParseException:
pass
else:
if phonenumbers.is_possible_number(
phonenumber) and phonenumbers.is_valid_number(
phonenumber):
if code and phonenumbers.is_valid_number_for_region(
phonenumber, code):
value = phonenumbers.format_number(
phonenumber, PhoneNumberFormat.NATIONAL)
else:
value = phonenumbers.format_number(
phonenumber, PhoneNumberFormat.INTERNATIONAL)
return value
def clean_phone_number(self):
value = self.cleaned_data["phone_number"]
if not value:
return value
country = self.initial.get("country")
if country is None:
return value
country = "{}".format(country)
try:
ph = phonenumbers.parse(value, country)
if not phonenumbers.is_valid_number(ph):
raise forms.ValidationError(_("Invalid phone number"))
if not phonenumbers.is_valid_number_for_region(ph, country):
raise forms.ValidationError(_("Invalid phone number"))
except phonenumbers.NumberParseException:
raise forms.ValidationError(_("Invalid phone number"))
return value
def test_find_iso3(capfd, iso, code, arg):
os.system('phone-gen {}{}'.format(arg, iso))
captured = capfd.readouterr()
num_obg = phonenumbers.parse(captured.out, code)
assert phonenumbers.is_valid_number_for_region(num_obg, code)
def test_get_without_country_code(capfd, country, arg):
os.system('phone-gen -f{} {}'.format(arg, country))
captured = capfd.readouterr()
code = PATTERNS['data'][country]['code']
num_obg = phonenumbers.parse('{}{}'.format(code, captured.out), country)
assert phonenumbers.is_valid_number_for_region(num_obg, country)
def test_get_country(capfd, country, arg):
os.system('phone-gen {}{}'.format(arg, country))
captured = capfd.readouterr()
num_obg = phonenumbers.parse(captured.out, country)
assert phonenumbers.is_valid_number_for_region(num_obg, country)
def valid_mobile_number(number):
parsed_number = phonenumbers.parse(number, 'DE')
assert phonenumbers.is_valid_number_for_region(
parsed_number, 'de'), parsed_number
return True
def validatePhoneNumber(self):
self.phonenumber_details['is_validnumber'] = phonenumbers.is_valid_number(self.phonenumber_object)
self.phonenumber_details['is_possiblenumber'] = phonenumbers.is_possible_number(self.phonenumber_object)
self.phonenumber_details['is_validnumberforRegion'] = phonenumbers.is_valid_number_for_region(self.phonenumber_object,self.get_iso2())
return self.phonenumber_details['is_validnumber'] * self.phonenumber_details['is_possiblenumber'] * self.phonenumber_details['is_validnumberforRegion']
def validate_phone_number(self, phone_number):
phone_number_obj = phonenumbers.parse(phone_number, 'US')
if not phonenumbers.is_valid_number_for_region(phone_number_obj, 'US'):
raise ValidationError('Not USA phone number')
return phone_number
def valid_mobile_number(number):
parsed_number = phonenumbers.parse(number, 'DE')
assert phonenumbers.is_valid_number_for_region(
parsed_number, 'de'), parsed_number
return True
def test_mobile(country, count):
phone_number = PhoneNumber(country)
number = phone_number.get_mobile()
num_obj = phonenumbers.parse(number, country)
assert phonenumbers.is_valid_number_for_region(num_obj, country)
def test_ref(code, ref, count):
number = PhoneNumber(code).get_number()
num_obj = phonenumbers.parse(number, code)
assert phonenumbers.is_valid_number_for_region(num_obj, ref)
