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