def testWhitespaceInNationalPrefixForParsing(self):
# Python version extra test
# AR metadata has whitespace in the RE for nationalPrefixForParsing
number = phonenumberutil.parse("+540348215617137", "AR")
self.assertTrue(phonenumberutil.is_valid_number(number))
self.assertEqual(PhoneNumberType.MOBILE, phonenumberutil.number_type(number))
number = phonenumberutil.parse("0344615614207", "AR")
self.assertTrue(phonenumberutil.is_valid_number(number))
self.assertEqual(PhoneNumberType.MOBILE, phonenumberutil.number_type(number))
def testWhitespaceInNationalPrefixForParsing(self):
# Python version extra test
# AR metadata has whitespace in the RE for nationalPrefixForParsing
number = phonenumberutil.parse("+540348215617137", "AR")
self.assertTrue(phonenumberutil.is_valid_number(number))
self.assertEqual(PhoneNumberType.MOBILE, phonenumberutil.number_type(number))
number = phonenumberutil.parse("0344615614207", "AR")
self.assertTrue(phonenumberutil.is_valid_number(number))
self.assertEqual(PhoneNumberType.MOBILE, phonenumberutil.number_type(number))
def validate_phonenumber(self, field):
data = field.data
print("DATA: ", data)
if not data:
# Don't validate if nothing was provided
return field
try:
if not data.startswith('+'):
# Maybe they forgot this?
data = '+' + data
parsed = phonenumbers.parse(data)
except:
flash(
"Please ensure you prefix the phone number with your country code."
)
raise ValidationError("This is not a valid phone number")
user = User.query.filter_by(phonenumber=data).first()
if user and user.id != self.user.id:
raise ValidationError("Phone number already on record.")
if not phonenumbers.is_valid_number(parsed):
flash(
"Please ensure you prefix the phone number with your country code."
)
raise ValidationError("This is not a valid phone number")
if not carrier._is_mobile(phonenumberutil.number_type(parsed)):
raise ValidationError(
"This phone number doesn't look like a mobile phone number")
self.phonenumber_locale = phonenumbers.region_code_for_country_code(
parsed.country_code)
def onchange_mobile(self, cr, uid, ids, mobile, context=None):
value = {}
warning = {}
if mobile:
id_number = phonenumbers.parse(mobile, "ID")
if not carrier._is_mobile(number_type(id_number)):
warning = {
'title': ('Perhatian !'),
'message':
(('Masukkan nomor handphone dengan benar, misal: 0817989800'
)),
}
value['mobile'] = ''
else:
formatted_mobile = phonenumbers.format_number(
id_number, phonenumbers.PhoneNumberFormat.E164)
provider_mobile = eval(
repr(carrier.name_for_number(id_number, "en")))
value['mobile'] = formatted_mobile
value['mobile_provider'] = provider_mobile
return {
'warning': warning,
'value': value,
}
def _checkNumbersValidAndCorrectType(self, exampleNumberRequestedType,
possibleExpectedTypes):
"""
Arguments:
exampleNumberRequestedType -- type we are requesting an example number for
possibleExpectedTypes -- acceptable types that this number should match, such as
FIXED_LINE and FIXED_LINE_OR_MOBILE for a fixed line example number.
"""
for regionCode in phonenumberutil.SUPPORTED_REGIONS:
exampleNumber = phonenumberutil.example_number_for_type(
regionCode, exampleNumberRequestedType)
if exampleNumber is not None:
if not phonenumberutil.is_valid_number(exampleNumber):
self.invalid_cases.append(exampleNumber)
prnt("Failed validation for %s" % exampleNumber,
file=sys.stderr)
else:
# We know the number is valid, now we check the type.
exampleNumberType = phonenumberutil.number_type(
exampleNumber)
if exampleNumberType not in possibleExpectedTypes:
self.wrong_type_cases.append(exampleNumber)
prnt("Wrong type for %s: got %s" %
(exampleNumber, exampleNumberType),
file=sys.stderr)
prnt("Expected types: ", file=sys.stderr)
for phone_type in possibleExpectedTypes:
prnt(" %s" % phone_type, file=sys.stderr)
def is_mobile_number(phone_number):
""" "Check if `phone_number` is a French phone number
:param phone_number:
:return: a boolean
"""
return number_type(phone_number) == PhoneNumberType.MOBILE
def RegisterUser(Email,ISDCode,PhoneNo,FirstName,LastName):
status=False
msg=''
Email = str(Email).lower()
PhoneNo = ISDCode+PhoneNo
if carrier._is_mobile(number_type(phonenumbers.parse("+"+PhoneNo))):
try:
user = User.objects.get(username=PhoneNo,)
msg='Phone number already exits.'
except User.DoesNotExist:
try:
password=User.objects.make_random_password(length=6)
new_user = User.objects.create_user(PhoneNo, Email, password)
new_user.first_name = FirstName
new_user.last_name = LastName
new_user.save()
userProfile = UserProfile()
userProfile.User=new_user
userProfile.save()
status=True
msg='Sign Up Success. Please check your email for login credentials.'
except Exception as e:
print(e)
msg='An error occured. Please try later.'
else:
msg='Please use a valid Phone number.'
return {'isSuccess':status,'msg':msg}
def action_check_valid_phone(self, country_id, mobile):
return_item = {'error': '', 'valid': True}
# check mobile
if not mobile or mobile is None:
return_item['valid'] = False
return_item['error'] = _('It is necessary to define a mobile')
# check_country_code
if country_id.id == 0:
return_item['valid'] = False
return_item['error'] = _('The prefix is NOT defined')
# check prefix in phone
if mobile:
if '+' in mobile:
return_item['valid'] = False
return_item['error'] = \
_('The prefix must NOT be defined in the mobile')
# phonenumbers
if return_item['valid']:
number_to_check = '+' + str(country_id.phone_code) + str(mobile)
number_to_check = '+%s%s' % (country_id.phone_code, mobile)
try:
return_is_mobile = carrier._is_mobile(
number_type(
phonenumbers.parse(number_to_check, country_id.code)))
if not return_is_mobile:
return_item['valid'] = False
return_item['error'] = _('The mobile is not valid')
except phonenumbers.NumberParseException:
return_item['valid'] = False
return_item['error'] = \
_('The phone is not valid (NumberParseException)')
# return
return return_item
def get_auth_signup_qcontext(self):
""" Shared helper returning the rendering context for signup and reset password.
Check Condition If Email not Exists, then Signup with Mobile.
"""
if request.params.items() and request.params['mobile']:
try:
carrier._is_mobile(
number_type(phonenumbers.parse(request.params['mobile'])))
except NumberParseException:
request.params['error'] = _("Please Enter Valid Mobile Number")
if request.params.items() and request.params['login']:
if not tools.single_email_re.match(request.params['login']):
request.params['error'] = _("Please Enter Valid Email")
if request.params.items(
) and request.params['mobile'] and request.params['login'] == '':
request.params['login'] = request.params['mobile']
qcontext = request.params.copy()
qcontext.update(self.get_auth_signup_config())
if qcontext.get('token'):
try:
# retrieve the user info (name, login or email) corresponding to a signup token
token_infos = request.env['res.partner'].sudo(
).signup_retrieve_info(qcontext.get('token'))
for k, v in token_infos.items():
qcontext.setdefault(k, v)
except:
qcontext['error'] = _("Invalid signup token")
qcontext['invalid_token'] = True
return qcontext
def process_phone_step(message):
try:
chat_id = message.chat.id
user = user_dict[chat_id]
if message.contact:
number = message.contact.phone_number
else:
number = message.text
if not (carrier._is_mobile(number_type(parse(number)))):
raise Exception
if conn.exist_phone(user.phone_number):
raise PhoneExists
# Get last 10 characters
user.phone_number = f'8{number[-10:]}'
markup = types.ReplyKeyboardRemove(selective=False)
msg = bot.send_message(chat_id,
config.l10n[user.language]['name'],
reply_markup=markup)
bot.register_next_step_handler(msg, process_name_step)
except PhoneExists:
msg = bot.send_message(message.chat.id,
config.l10n[user.language]['number_exists'],
reply_markup=utils.gen_reply_markup([], 1,
False,
False))
bot.register_next_step_handler(msg, process_phone_step)
except Exception:
buttons = (config.l10n[user.language]['send_contact'], )
msg = bot.send_message(message.chat.id,
config.l10n[user.language]['number_invalid'],
reply_markup=utils.gen_reply_markup(
buttons, 1, False, True))
bot.register_next_step_handler(msg, process_phone_step)
def validate_mobile_phone(phone_number):
# Indonesia only accept mobile phone
if settings.COUNTRY == 'ID':
try:
number = parse(phone_number)
except phonenumberutil.NumberParseException:
raise ValidationError('Please enter a valid mobile phone number.')
if number.is_mobile:
return True
# International phone numbers are accepted
if phone_number.startswith('+') and len(phone_number) > 8:
return True
else:
try:
phone = phonenumbers.parse(phone_number, settings.COUNTRY)
except phonenumberutil.NumberParseException:
raise ValidationError('Please enter a valid mobile phone number.')
number_type = phonenumberutil.number_type(phone)
accepted_mobile_type = [
phonenumberutil.PhoneNumberType.MOBILE,
phonenumberutil.PhoneNumberType.FIXED_LINE_OR_MOBILE,
]
if number_type in accepted_mobile_type:
return True
raise ValidationError('Please enter a valid mobile phone number.')
def validate_phone(value):
try:
number = phonenumbers.parse('+' + str(value), None)
if not carrier._is_mobile(number_type(number)):
raise ValidationError
except:
raise ValidationError('Incorrect phone number')
def post(self):
try:
mobile_number = request.get_json().get('mobile_number', '')
emulator_name = request.get_json().get('emulator_name', '')
message_body = request.get_json().get('message_body', '')
if mobile_number == '' or emulator_name == '' or message_body == '':
return make_response(
jsonify({
"status": "0",
"message": "Insufficient Parameters"
}), 422)
mobile_format_validation = carrier._is_mobile(
number_type(phonenumbers.parse(mobile_number)))
if not mobile_format_validation:
return make_response(
jsonify({
"status":
"0",
"message":
"Mobile number not in International Indian Format. Ex: +91 XXXXX XXXXX"
}), 400)
final_message = json.dumps({
"mobile_number": mobile_number,
"emulator_name": emulator_name,
"message_body": message_body
})
single_message_queue_name = configp.get('queue_name',
'single_message')
corr_id = Rabbit().msgproducer(single_message_queue_name,
final_message, emulator_name,
'send_only')
if corr_id:
return make_response(
jsonify({
"status": "1",
"message": "Singal received for sending message",
"corr_id": corr_id
}), 200)
else:
return make_response(
jsonify({
"status": "0",
"message": "Signal Failed",
"corr_id": 0
}), 400)
except Exception as e:
self.apilog.error("SGLog:" + str(e))
return make_response(
jsonify({
"status": "0",
"message": "Exception Occured. Check Logs"
}), 500)
def check_no(number):
value = False
try:
value = carrier._is_mobile(number_type(phonenumbers.parse(number)))
except:
value = False
finally:
return (value)
def phone_detector(input_value):
try:
if carrier._is_mobile(number_type(
phonenumbers.parse(input_value))) == True:
return input_value
else:
return None
except:
return None
def validate_mobile(field, value, error):
#pattern = re.compile("^\+[0-9]+$")
#valid = bool(pattern.match(value))
a_mobile = carrier._is_mobile(number_type(phonenumbers.parse(value)))
if not a_mobile:
error(
field,
"This field should contain an international mobile number, e.g. +457543788853"
)
def _validate_type_phone_number(self, value):
"""Enables validation for `phone_number` schema attribute.
:param field: field name.
:param value: field value.
"""
try:
return carrier._is_mobile(number_type(phonenumbers.parse(value)))
except:
return False
def get_form_for_transaction(cls, transaction, sp_config):
person_id = (
str(transaction.payment.person.pk)
if transaction.payment.person
else "anonymous"
)
form = cls(
initial={
"vads_site_id": sp_config["site_id"],
"vads_ctx_mode": "PRODUCTION" if sp_config["production"] else "TEST",
"vads_currency": sp_config["currency"],
"vads_order_id": transaction.pk,
"vads_trans_id": str(transaction.pk % 900000).zfill(6),
"vads_trans_date": transaction.created.strftime("%Y%m%d%H%M%S"),
"vads_amount": transaction.payment.price,
"vads_cust_email": transaction.payment.email,
"vads_cust_id": person_id,
"vads_cust_first_name": transaction.payment.first_name,
"vads_cust_last_name": transaction.payment.last_name,
"vads_cust_address": ", ".join(
[
transaction.payment.location_address1,
transaction.payment.location_address2,
]
),
"vads_cust_zip": transaction.payment.location_zip,
"vads_cust_city": transaction.payment.location_city,
"vads_cust_state": transaction.payment.location_state,
"vads_cust_country": transaction.payment.location_country,
"vads_ext_info_type": transaction.payment.type,
}
)
if transaction.payment.phone_number:
if (
phonenumberutil.number_type(transaction.payment.phone_number)
== PhoneNumberType.MOBILE
):
form.add_field(
"vads_cust_cell_phone", transaction.payment.phone_number.as_e164
)
else:
form.add_field(
"vads_cust_phone", transaction.payment.phone_number.as_e164
)
for key in transaction.payment.meta:
form.add_field("vads_ext_info_meta_" + key, transaction.payment.meta[key])
form.update_signature(sp_config["certificate"])
return form
def randomize(self):
fake_number, fake_number_no_prefix = randomize_local(prefix=self.prefix, header=self.header)
if 'False' in fake_number or 'False' in str(fake_number_no_prefix):
return False
counter = 0
while not carrier._is_mobile(number_type(phonenumbers.parse(fake_number))) and counter < 5:
fake_number, fake_number_no_prefix = randomize_local(prefix=self.prefix, header=self.header)
counter += 1
if counter == 5:
return 0
return fake_number, fake_number_no_prefix
def validate_phone(phone_number):
"""validate national phone number
http://stackoverflow.com/questions/16135069/python-validation-mobile-number
https://github.com/daviddrysdale/python-phonenumbers
:param phone_number:
"""
try:
return carrier._is_mobile(
number_type(phonenumbers.parse(phone_number)))
except Exception:
return False
def phone_number_validator(num):
# phone_regex = re.compile(r'^(?:\+?44)?[07]\d{9,13}$')
# if check_blank_fields(num) == False:
# if not re.match(num):
# return False
if carrier._is_mobile(number_type(phonenumbers.parse(num))):
return True
else:
e = 4
return messageBox.window(e)
def validate_phone(phone_number):
"""validate national phone number
http://stackoverflow.com/questions/16135069/python-validation-mobile-number
https://github.com/daviddrysdale/python-phonenumbers
:param phone_number:
"""
try:
return carrier._is_mobile(number_type(
phonenumbers.parse(phone_number))
)
except Exception:
return False
def FindPhoneNumber(self, metadata, Collector) -> None:
"""This function requires a metadata and collector for registering data"""
for phone in re.finditer(self.pattern, str(self.sourcecode)):
try:
if carrier._is_mobile(
number_type(phonenumbers.parse(phone.group(), None))):
config.debug("Phone Number Found: {}".format(
phone.group()))
self.PhoneNumbers.append(phone.group())
metadata.Phones.append(phone.group())
except phonenumbers.phonenumberutil.NumberParseException:
pass
set(self.PhoneNumbers)
Collector.PhoneNumbers += len(self.PhoneNumbers)
def phone_number(self, phone):
new_number = ""
for i in range(phone.__len__()):
if i == 0:
pass
else:
new_number = new_number + phone[i]
number = "+255" + new_number
if not carrier._is_mobile(number_type(phonenumbers.parse(number))):
toast("wrong number")
te = self.root.ids.user_phone
te.text = "start with 07 or 06"
return False
else:
return True
def phone_number_check_admin(self, phone):
new_number = ""
if phone != "":
for i in range(phone.__len__()):
if i == 0:
pass
else:
new_number = new_number + phone[i]
number = "+255" + new_number
if not carrier._is_mobile(number_type(phonenumbers.parse(number))):
toast("Please check your phone number!", 1)
return False
else:
return True
else:
toast("enter phone number!")
def validate_phonenumber(self, field):
data = field.data
try:
if not data.startswith("+"):
# Maybe they forgot this?
data = "+" + data
parsed = phonenumbers.parse(data)
except:
flash("Please ensure you prefix the phone number with your country code.")
raise ValidationError("This is not a valid phone number")
if not phonenumbers.is_valid_number(parsed):
flash("Please ensure you prefix the phone number with your country code.")
raise ValidationError("This is not a valid phone number")
if not carrier._is_mobile(phonenumberutil.number_type(parsed)):
raise ValidationError("This phone number doesn't look like a mobile phone number")
self.phonenumber_locale = phonenumbers.region_code_for_country_code(parsed.country_code)
def select_sub_issue(id):
subissues = SubIssue.query.filter_by(issue_id=id)
form = SubIssueForm()
form.subissue.query = subissues
form.subissue.choices = [(subissue.id, subissue.name)
for subissue in subissues]
if (form.subissue.data != "None"):
subissue = request.form['subissue']
subissue_id = form.subissue.data
print(subissue_id, subissue)
additional_info = form.additional_info.data
send_url = 'http://freegeoip.net/json'
r = requests.get(send_url)
j = json.loads(r.text)
lat = j['latitude']
lon = j['longitude']
location = str(lat) + "," + str(lon)
phone = form.phone.data
if (carrier._is_mobile(number_type(
phonenumbers.parse(phone)))) and phone != '':
query = Query(employee_id=current_user.id,
issue_id=id,
subissue_id=subissue_id,
additional_info=additional_info,
location=location,
phone=phone,
zip_code=j['zip_code'])
try:
db.session.add(query)
db.session.commit()
flash('You have successfully added a query')
except:
flash('Error: Query already exists.')
else:
flash('Please enter a valid contact number')
return redirect(url_for('home.select_sub_issue', id=id))
return redirect(url_for('home.list_user_issues'))
return render_template('home/selectsubissue.html',
subissues=subissues,
form=form,
title="Select Sub Issue")
def subscribe():
"""
This is the function for handling subscription requests. It will error clearly if a new phone number wasn't passed
in when the page was requested.
:return: A tuple of an HTML page and an HTTP Status code.
"""
logging.info('subscribe page started.')
try:
form_response = request.form
subscriber_number = form_response['subscriber_number']
if not subscriber_number:
raise Exception('No subscriber number was passed in!')
logging.info('subscribe page checking subscriber_number is valid.')
# Checking if subscriber_number matches valid format: +18885554444
carrier._is_mobile(number_type(phonenumbers.parse(subscriber_number)))
logging.info(
'subscribe page got valid subscriber_number of {}.'.format(
subscriber_number))
# Try to subscribe the number.
topic_arn = 'arn:aws:sns:us-west-2:277012880214:BunAlert'
snsclient = boto3.client('sns', region_name='us-west-2')
logging.info('subscribe page made SNS client.')
subscribe_response = snsclient.subscribe(
TopicArn=topic_arn,
Protocol='sms',
Endpoint='{}'.format(subscriber_number))
logging.info('subscribe page subscribed the new subscriber_number.')
# If all's good, render the response page.
template = Environment(
loader=FileSystemLoader('html/')).get_template('subscribe.j2')
page = template.render(subscriber_number=subscriber_number)
logging.info('subscribe page returned.')
return page, 200
except Exception as e:
logging.info('subscribe page errored.')
page = 'Something went wrong! Exception: {}'.format(e)
logging.error(page)
return page, 400
def settings_addPhone():
if request.referrer is None:
return redirect(url_for('user_settings.settings_auth'))
form = UpdatePhoneForm()
if form.validate_on_submit():
number = form.country.data.split()[0] + str(form.phone.data)
try:
b = carrier._is_mobile(number_type(phonenumbers.parse(number)))
if b:
current_user.phone = number
db.session.commit()
return redirect(url_for('user_settings.settings_phone'))
else:
flash('Please enter a valid phone number.')
except NumberParseException:
flash('Please enter a valid phone number.')
return render_template('settings_addPhone.html', form=form)
def phone_number_check(self, phone):
new_number = ""
if phone != "":
for i in range(phone.__len__()):
if i == 0:
pass
else:
new_number = new_number + phone[i]
number = "+255" + new_number
if not carrier._is_mobile(number_type(phonenumbers.parse(number))):
toast("Please check your phone number!", 1)
return False
else:
self.phone_number = phone
thread = threading.Thread(target=self.Business(self.product_name, self.quantity, self.phone_number))
thread.start()
self.kill_phone()
return True
else:
toast("check your number")
def settings_addPhone(request):
if request.META.get('HTTP_REFERER') is None:
return redirect('settings_phone')
form = UpdatePhoneForm(request.POST or None)
if form.is_valid():
number = form.cleaned_data.get('country_code').split()[0] + \
str(form.cleaned_data.get('phone'))
try:
b = carrier._is_mobile(number_type(phonenumbers.parse(number)))
if b:
request.user.profile.country_code = form.cleaned_data.get(
'country_code')
request.user.profile.phone = form.cleaned_data.get('phone')
request.user.save()
return redirect('settings_phone')
else:
form.add_error(None, 'Please enter a valid phone number.')
except NumberParseException:
form.add_error(None, 'Please enter a valid phone number.')
context = {'form': form}
return render(request, 'settings_addPhone.html', context)
def host():
if request.method == "POST":
details = request.form
#getting details from teh form
Name = details['name']
Email = details['email']
Phone = details['phone']
#checking for validity of email and phone of host
number = "+91" + str(Phone)
v = carrier._is_mobile(number_type(phonenumbers.parse(number)))
is_valid = validate_email(Email, verify=True, check_mx=True)
print(v)
print(is_valid)
if v == True and is_valid == True:
try:
#inserting the host data into database
cur = mysql.connection.cursor()
cur.execute(
"INSERT INTO Host(Name, Email, Phone) VALUES(%s, %s, %s)",
(Name, Email, Phone))
mysql.connection.commit()
cur.close()
except Exception as e:
datax = "You have already checked in or database server is down! Please try again"
return render_template('log.html', datax=datax)
return render_template('success.html',
datax="Thanks for filling details")
else:
if v == False:
datax = "You entered a wrong phone number! Please try again"
return render_template('log.html', datax=datax)
else:
datax = "You entered a wrong email id! Please try again"
return render_template('log.html', datax=datax)
return render_template('host.html')
def validate_phonenumber(self, field):
data = field.data
try:
if not data.startswith('+'):
# Maybe they forgot this?
data = '+' + data
parsed = phonenumbers.parse(data)
except:
flash(
"Please ensure you prefix the phone number with your country code."
)
raise ValidationError("This is not a valid phone number")
if not phonenumbers.is_valid_number(parsed):
flash(
"Please ensure you prefix the phone number with your country code."
)
raise ValidationError("This is not a valid phone number")
if not carrier._is_mobile(phonenumberutil.number_type(parsed)):
raise ValidationError(
"This phone number doesn't look like a mobile phone number")
self.phonenumber_locale = phonenumbers.region_code_for_country_code(
parsed.country_code)
def validate_phonenumber(self, field):
data = field.data
print("DATA: ", data)
if not data:
# Don't validate if nothing was provided
return field
try:
if not data.startswith('+'):
# Maybe they forgot this?
data = '+' + data
parsed = phonenumbers.parse(data)
except:
flash("Please ensure you prefix the phone number with your country code.")
raise ValidationError("This is not a valid phone number")
user = User.query.filter_by(phonenumber=data).first()
if user and user.id != self.user.id:
raise ValidationError("Phone number already on record.")
if not phonenumbers.is_valid_number(parsed):
flash("Please ensure you prefix the phone number with your country code.")
raise ValidationError("This is not a valid phone number")
if not carrier._is_mobile(phonenumberutil.number_type(parsed)):
raise ValidationError("This phone number doesn't look like a mobile phone number")
self.phonenumber_locale = phonenumbers.region_code_for_country_code(parsed.country_code)
def _checkNumbersValidAndCorrectType(self,
exampleNumberRequestedType,
possibleExpectedTypes):
"""
Arguments:
exampleNumberRequestedType -- type we are requesting an example number for
possibleExpectedTypes -- acceptable types that this number should match, such as
FIXED_LINE and FIXED_LINE_OR_MOBILE for a fixed line example number.
"""
for regionCode in phonenumberutil.SUPPORTED_REGIONS:
exampleNumber = phonenumberutil.example_number_for_type(regionCode, exampleNumberRequestedType)
if exampleNumber is not None:
if not phonenumberutil.is_valid_number(exampleNumber):
self.invalid_cases.append(exampleNumber)
print >> sys.stderr, "Failed validation for %s" % exampleNumber
else:
# We know the number is valid, now we check the type.
exampleNumberType = phonenumberutil.number_type(exampleNumber)
if exampleNumberType not in possibleExpectedTypes:
self.wrong_type_cases.append(exampleNumber)
print >> sys.stderr, "Wrong type for %s: got %s" % (exampleNumber, exampleNumberType)
print >> sys.stderr, "Expected types: "
for phone_type in possibleExpectedTypes:
print >> sys.stderr, " %s" % phone_type
def is_landline(value):
try:
assert number_type(value) is 0
except AssertionError:
raise ValidationError('''Not a landline number.''')
def is_mobile_number(value):
"""Note, using phonenumbers lib, we allow for ambiguous numbers which could be mobiles in countries like USA."""
try:
assert number_type(value) in [1, 2]
except AssertionError:
raise ValidationError('''Not a mobile number.''')
def validate_phone(phone_number):
try:
return carrier._is_mobile(number_type(phonenumbers.parse(phone_number)))
except Exception:
return False
