def save(self, *args, **kwargs): if self.phone_work: self.phone_work = phonenumbers.format_number(phonenumbers.parse(self.phone_work, 'US'), phonenumbers.PhoneNumberFormat.E164) if self.phone_mobile: self.phone_mobile = phonenumbers.format_number(phonenumbers.parse(self.phone_mobile, 'US'), phonenumbers.PhoneNumberFormat.E164) self.email = self.email.lower() super(Person, self).save(*args, **kwargs)
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 __init__(self, raw_number, country_code=None): # Bail if phonenumbers is not found. if phonenumbers is None: raise ImproperlyConfigured( "'phonenumbers' is required to use 'PhoneNumber'") self._phone_number = phonenumbers.parse(raw_number, country_code) super(PhoneNumber, self).__init__( country_code=self._phone_number.country_code, national_number=self._phone_number.national_number, extension=self._phone_number.extension, italian_leading_zero=self._phone_number.italian_leading_zero, raw_input=self._phone_number.raw_input, country_code_source=self._phone_number.country_code_source, preferred_domestic_carrier_code=( self._phone_number.preferred_domestic_carrier_code ) ) self.national = phonenumbers.format_number( self._phone_number, phonenumbers.PhoneNumberFormat.NATIONAL ) self.international = phonenumbers.format_number( self._phone_number, phonenumbers.PhoneNumberFormat.INTERNATIONAL ) self.e164 = phonenumbers.format_number( self._phone_number, phonenumbers.PhoneNumberFormat.E164 )
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_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 _format(vals): if isinstance(vals, unicode) and vals.startswith('xxx'): return { 'e164': vals, 'international': vals, 'rfc3966': vals, } pn = bss_phonenumbers_converter._parse(vals) if not pn: return { 'e164': None, 'international': None, 'rfc3966': None, } res = { 'e164': phonenumbers.format_number(pn, phonenumbers.PhoneNumberFormat.E164), 'international': phonenumbers.format_number(pn, phonenumbers.PhoneNumberFormat.INTERNATIONAL), 'rfc3966': phonenumbers.format_number(pn, phonenumbers.PhoneNumberFormat.RFC3966), } # Format +32XXXXXXXXX Belgian numbers according to test in portal_crm (which will succeed with this format) : if res['e164'][:3] == '+32' and len(res['e164']) == 12: res['international'] = '%s %s %s %s %s' % (res['e164'][:3], res['e164'][3:6], res['e164'][6:8], res['e164'][8:10], res['e164'][10:12]) return res
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 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 render_POST(self, request): send_cors(request) error, args = get_args(request, ('phone_number', 'country', 'client_secret', 'send_attempt')) if error: request.setResponseCode(400) return error raw_phone_number = args['phone_number'] country = args['country'] clientSecret = args['client_secret'] sendAttempt = args['send_attempt'] try: phone_number_object = phonenumbers.parse(raw_phone_number, country) except Exception as e: logger.warn("Invalid phone number given: %r", e) request.setResponseCode(400) return {'errcode': 'M_INVALID_PHONE_NUMBER', 'error': "Invalid phone number" } msisdn = phonenumbers.format_number( phone_number_object, phonenumbers.PhoneNumberFormat.E164 )[1:] # International formatted number. The same as an E164 but with spaces # in appropriate places to make it nicer for the humans. intl_fmt = phonenumbers.format_number( phone_number_object, phonenumbers.PhoneNumberFormat.INTERNATIONAL ) resp = None try: sid = self.sydent.validators.msisdn.requestToken( phone_number_object, clientSecret, sendAttempt, None ) except DestinationRejectedException: logger.error("Destination rejected for number: %s", msisdn); request.setResponseCode(400) resp = {'errcode': 'M_DESTINATION_REJECTED', 'error': 'Phone numbers in this country are not currently supported'} except Exception as e: logger.error("Exception sending SMS: %r", e); request.setResponseCode(500) resp = {'errcode': 'M_UNKNOWN', 'error':'Internal Server Error'} if not resp: resp = { 'success': True, 'sid': str(sid), 'msisdn': msisdn, 'intl_fmt': intl_fmt, } return resp
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 _format_phonenumber(phonenumber_obj, case=1): if case == 1: return phonenumbers.format_number( phonenumber_obj, phonenumbers.PhoneNumberFormat.E164) elif case == 2: return phonenumbers.format_number( phonenumber_obj, phonenumbers.PhoneNumberFormat.NATIONAL).replace(' ', '') elif case == 3: return phonenumbers.format_number( phonenumber_obj, phonenumbers.PhoneNumberFormat.mro).replace(' ', '')
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 clean_phone_number(phone_number): # Takes a phone number and returns a parsed copy conforming to the international schema ("+00 00 0000-0000"). import phonenumbers #importing phonenumbers module #defining list of problematic numbers mapped in the audit phase prob_phone = ["55 11 3884 4016 / 97680-0017", "+11 55 4356 5226", "+55 11 1 3135 4156","+55 11 11 2063 9494","+55 11 2901-3155 / 2769-2901","+55 11 3814-3819 - 3031-1065","+55 11 433 .7185","+55 11+55 11","+55 11193","+55 11190","+55 4104 3859","+55 4109 2485","+55 4343 6454","11 2959-3594 / 2977-2491","11 3091-3503 / 3091-3596","3862-2772 / 36730360","55+ (11) 3670-8000","+55 11 11 4128 2828","+55 11 11 4392 6611"] #treating phone numbers to be parsed later if ("-" not in phone_number) and (len(phone_number) <= 9) or (" " not in phone_number) and (len(phone_number) <= 9): phone_number = "+55 11" + phone_number elif ("-" in phone_number) and (len(phone_number) <= 10) or (" " not in phone_number) and (len(phone_number) <= 10): phone_number = "+55 11" + phone_number elif phone_number in prob_phone: prob_phone_mapping = { "+11 55 4356 5226": "+55 11 4356 5226", "+55 11 1 3135 4156": "+55 11 3135 4156", "+55 11 11 2063 9494": "+55 11 2063 9494", "+55 11 11 4128 2828": "+55 11 4128 2828", "+55 11 11 4392 6611": "+55 11 4392 6611", "+55 11 2901-3155 / 2769-2901": "+55 11 2901-3155 / +55 11 2769-2901", "+55 11 3814-3819 - 3031-1065": "+55 11 3814-3819 - +55 11 3031-1065", "+55 11 433 .7185": "+55 11 43337185", "+55 11+55 11": "+55 11", "+55 11193": "+55 11", "+55 11190": "+55 11", "+55 4104 3859": "+55 11 4104 3859", "+55 4109 2485": "+55 11 4109 2485", "+55 4343 6454": "+55 11 4343 6454", "11 2959-3594 / 2977-2491": "11 2959-3594 / 11 2977-2491", "11 3091-3503 / 3091-3596": "11 3091-3503 / 11 3091-3596", "3862-2772 / 36730360": "11 3862-2772 / 11 36730360", "55+ (11) 3670-8000": "+55 (11) 3670-8000", "55 11 3884 4016 / 97680-0017": "55 11 3884 4016 / 11 97680-0017"} for item in prob_phone_mapping.iteritems(): if phone_number == item[0]: phone_number = item[1] #parsing phone numbers using functions from the phonenumbers module try: x = phonenumbers.parse(phone_number, "BR") parsed_phone_number = phonenumbers.format_number(x, phonenumbers.PhoneNumberFormat.INTERNATIONAL) except: parsed_phone_number = [] for match in phonenumbers.PhoneNumberMatcher(phone_number, "BR"): parsed_phone = phonenumbers.format_number(match.number, phonenumbers.PhoneNumberFormat.INTERNATIONAL) parsed_phone_number.append(parsed_phone) #if the original string contains more than a number, they are converted into a list. return parsed_phone_number
def get_normalized_phone_review(me): try: if 'phones' in me.keys(): if len(me['phones']): if len(me['phones']) > 1: return( phonenumbers.format_number(phonenumbers.parse(me['phones'][0], 'US'), phonenumbers.PhoneNumberFormat.NATIONAL)) else: return( phonenumbers.format_number(phonenumbers.parse(me['phones'][0], 'US'), phonenumbers.PhoneNumberFormat.NATIONAL)) else: return np.nan else: return np.nan except: return np.nan
def display_phone(self, field_name=None, phone=None, country='BE', check=True, format='', pattern=''): """ Return a formatted localized phone number. country = 2 letters country code check = check the validity of the given phone format = 'nat' or 'int' pattern = space replacing separators in rtl order * list of 2 lists for nat and int formats => [['/', '.'], ['-', '.']] * string or 2 strings (pipe separator) for nat and int formats '/.|-.' """ if field_name: phone = self.get_value(field_name) if not phone: return u'' try: number = phonenumbers.parse(phone, country) except phonenumbers.NumberParseException: return translate(u"Bad phone number: '${nb}'", domain='collective.documentgenerator', mapping={'nb': phone}, context=self.request) return safe_unicode(phone) if check and not phonenumbers.is_valid_number(number): return translate(u"Invalid phone number: '${nb}'", domain='collective.documentgenerator', mapping={'nb': phone}, context=self.request) def format_with_pattern(nb): if not pattern: return nb index = 0 if nb.startswith('+'): index = 1 if isinstance(pattern, list): pat = len(pattern) > index and pattern[index] or '' else: lst = pattern.split('|') pat = len(lst) > index and lst[index] or '' if not pat: return nb nbl = [] for i, part in enumerate(nb.split()): nbl.append(part) nbl.append((pat[i:i + 1] + pat[-1:])[0]) return ''.join(nbl[:-1]) if format: ret = format_with_pattern(phonenumbers.format_number(number, format == 'int' and 1 or 2)) elif country in phonenumbers.data._COUNTRY_CODE_TO_REGION_CODE.get(number.country_code, []): ret = format_with_pattern(phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.NATIONAL)) else: ret = format_with_pattern(phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.INTERNATIONAL)) return ret
def StdPhone(stringa, country): if gL.trace: gL.log(gL.DEBUG) try: test = stringa.split(' - ') # due numeri di tel separati da trattino if len(test) > 1: stringa = test[0] ISO = gL.CountryISO.get(country) if ISO is None: gL.cMySql.execute("select CountryIso2 from T_Country where Country = %s", ([country])) row = gL.cMySql.fetchone() if row: ISO = row['CountryIso2'] gL.CountryISO[country] = ISO if ISO is None: gL.log(gL.ERROR, "Lingua non trovata") return False except: gL.log(gL.ERROR, stringa) gL.log(gL.ERROR, err) return False, False # formatta telefono try: newphone = '' ; newphone1 = '' ; idx = 0 numeri = phonenumbers.PhoneNumberMatcher(stringa, ISO) while numeri.has_next(): idx = idx + 1 match = numeri.next() #print(phonenumbers.format_number(b.number, phonenumbers.PhoneNumberFormat.INTERNATIONAL)) if idx == 1: newphone = phonenumbers.format_number(match.number, phonenumbers.PhoneNumberFormat.INTERNATIONAL) newphone = newphone.replace('(','') newphone = newphone.replace(')','') if idx == 2: #match = phonenumbers.parse(stringa, ISO) newphone1 = phonenumbers.format_number(match.number, phonenumbers.PhoneNumberFormat.INTERNATIONAL) #newphone = phonenumbers.format_number(y, phonenumbers.PhoneNumberFormat.INTERNATIONAL) newphone1 = newphone1.replace('(','') newphone1 = newphone1.replace(')','') except: msg ="%s - %s" % ("Phone stdz error", stringa) gL.log(gL.ERROR, msg) newphone = stringa return False, False return (newphone, newphone1)
def generic_phonenumber_to_e164( self, cr, uid, ids, field_from_to_seq, context=None): result = {} from_field_seq = [item[0] for item in field_from_to_seq] for record in self.read(cr, uid, ids, from_field_seq, context=context): result[record['id']] = {} for fromfield, tofield in field_from_to_seq: if not record.get(fromfield): res = False else: try: res = phonenumbers.format_number( phonenumbers.parse(record.get(fromfield), None), phonenumbers.PhoneNumberFormat.E164) except Exception, e: _logger.error( "Cannot reformat the phone number '%s' to E.164 " "format. Error message: %s" % (record.get(fromfield), e)) _logger.error( "You should fix this number and run the wizard " "'Reformat all phone numbers' from the menu " "Settings > Configuration > Phones") # If I raise an exception here, it won't be possible to # install the module on a DB with bad phone numbers res = False result[record['id']][tofield] = res
def run(self, **kwargs): global contacts global allgroups user = User.objects.get(email='*****@*****.**') contacts = [] allgroups = [] #print "sync google contacts" admin_accounts = GoogleAdminAccounts.objects.filter(enable=True).order_by('priority').reverse() if len(admin_accounts) > 0 : account = admin_accounts[0] gather_contacts(account.email, account.password) write_contacts() for contact in contacts: t = timezone.now() # offset-awared datetime now_aware = contact['last_changed'].replace(tzinfo=pytz.UTC) #t.astimezone(timezone.utc).replace(tzinfo=None) #print now_aware < account.last_changed if len(contact['phones']) > 0 : p = PhoneNumber() p.user = user pn = phonenumbers.format_number(contact['phones'][0]['tel'], phonenumbers.PhoneNumberFormat.E164) found_type = "" for tel_type in tel_types: if tel_type in contact['phones'][0]['type'] : found_type = tel_type #found = any(contact['phones'][0]['type'] in item for item in tel_types) print 'fnd:', found_type p.phone_type = found_type p.phone_number = pn p.save() account.last_changed = t account.save()
def normalize_phone(value): """ Normalize a phone number to E.164 format. Return None if the given value can't be parsed as a phone number. """ if not value: return None if value[0] == '+': # Phone number may already be in E.164 format. parse_type = None else: # Assume US format otherwise parse_type = 'US' try: phone_representation = phonenumbers.parse(value, parse_type) except phonenumbers.NumberParseException: return None else: formatted = phonenumbers.format_number( phone_representation, phonenumbers.PhoneNumberFormat.E164) # we only accept US/Canada numbers, they must be twelve digits in E.164 if len(formatted) != 12: return None return formatted
def generate_fake(count=100): from random import choice, randint from faker import Faker from .user import User import phonenumbers nusers = User.objects().count() fake = Faker() # fake.seed(3123) fake_pods = [] for i in range(count): if nusers > 0: user = User.objects()[randint(0, nusers - 1)] else: user = User.generate_fake(1)[0] pod = Pod( name=fake.first_name() + '-' + fake.last_name() + '-' + str(fake.random_int(min=1000)), owner=user, pod_id=fake.random_int(min=20), qr='https://s3.amazonaws.com/pulsepodqrsvgs/default.svg', imei=str(randint(100000000000000, 999999999999999)), radio='gsm', mode=choice(['normal', 'teenager', 'asleep', 'inactive']), number=phonenumbers.format_number( phonenumbers.parse( '1' + ''.join([str(randint(0, 9)) for x in range(7)]), 'US'), phonenumbers.PhoneNumberFormat.E164), ) try: pod.save() fake_pods.append(pod) except: "Pod save failed" return fake_pods
def phoneformat(phone_number, phone_format='INTERNATIONAL'): try: parsed_number = parse(phone_number, None) format = getattr(PhoneNumberFormat, phone_format) return format_number(parsed_number, format) except NumberParseException: return phone_number
def format(self, text, oldtag=None, phone=False, phone_format="international"): if self.pool.get("base.phone.installed") and phone and text: # text should already be in E164 format, so we don't have # to give a country code to phonenumbers.parse() phone_number = phonenumbers.parse(text) if phone_format == "international": res = phonenumbers.format_number(phone_number, phonenumbers.PhoneNumberFormat.INTERNATIONAL) elif phone_format == "national": res = phonenumbers.format_number(phone_number, phonenumbers.PhoneNumberFormat.NATIONAL) elif phone_format == "e164": res = phonenumbers.format_number(phone_number, phonenumbers.PhoneNumberFormat.E164) else: res = text else: res = format_original(self, text, oldtag=oldtag) return res
def get_international_phone_number(self): phone_number = self._parse_phone_number() if phone_number is None: return None return phonenumbers.format_number(phone_number, phonenumbers.PhoneNumberFormat.E164)
def validate_phone(self, value, context=None): try: number = phonenumbers.parse(value, None) phone_format = phonenumbers.PhoneNumberFormat.INTERNATIONAL return phonenumbers.format_number(number, phone_format) except Exception as exc: raise ValidationError(exc.message)
def get_phone(cls, bot): """ Get a standardized phone number """ try: x = phonenumbers.parse(bot.phone_number, "US") return phonenumbers.format_number(x, phonenumbers.PhoneNumberFormat.INTERNATIONAL) except: return "None"
def send_sms_twilio(phone, message, sender_phone=None): """ Twilio does not support setting a source number, so the "sender_phone" argument is ignored """ if not isinstance(phone, phonenumbers.phonenumber.PhoneNumber): raise ValueError('phone must be a PhoneNumber object') account = settings.TWILIO_CREDENTIALS['account'] token = settings.TWILIO_CREDENTIALS['auth_token'] from_phone_numbers = settings.TWILIO_CREDENTIALS['phone_numbers'] # Sending is done from a random number chosen_from_phone_number = random.choice(from_phone_numbers) phone_e164 = phonenumbers.format_number(phone, phonenumbers.PhoneNumberFormat.E164) def log_error(message): # TODO Better logging ... print message client = TwilioRestClient(account, token) try: client.messages.create( to=phone_e164, from_=chosen_from_phone_number, body=message) except TwilioException as e: log_error(unicode(e)) return
def normalize_number(number, country_code): """ Normalizes the passed in number, they should be only digits, some backends prepend + and maybe crazy users put in dashes or parentheses in the console. :param number: the number, e.g. "0783835665" :param country_code: the 2-letter country code, e.g. "RW" :return: a tuple of the normalized number and whether it looks like a possible full international number """ # if the number ends with e11, then that is Excel corrupting it, remove it if number.lower().endswith("e+11") or number.lower().endswith("e+12"): number = number[0:-4].replace('.', '') # remove other characters number = regex.sub('[^0-9a-z\+]', '', number.lower(), regex.V0) # add on a plus if it looks like it could be a fully qualified number if len(number) >= 11 and number[0] != '+': number = '+' + number try: normalized = phonenumbers.parse(number, str(country_code) if country_code else None) # now does it look plausible? if phonenumbers.is_possible_number(normalized): return phonenumbers.format_number(normalized, phonenumbers.PhoneNumberFormat.E164), True except Exception: pass # this must be a local number of some kind, just lowercase and save return regex.sub('[^0-9a-z]', '', number.lower(), regex.V0), False
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 __build_phone(self, param): # XXX TOFIX _vcard_types = { 'text': 'other', 'voice': 'other', 'fax': 'fax', 'cell': 'mobile', 'video': 'other', 'pager': 'pager', 'textphone': 'other', } phone = NewPhone() phone.number = param.value if 'TYPE' in param.params and param.params['TYPE']: phone_type = param.params['TYPE'][0].lower() if phone_type in _vcard_types: phone.type = _vcard_types[phone_type] else: phone.type = 'other' if 'PREF' in param.params: phone.is_primary = True try: number = phonenumbers.parse(phone.number, None) phone_format = phonenumbers.PhoneNumberFormat.INTERNATIONAL normalized = phonenumbers.format_number(number, phone_format) if normalized: phone.normalized_number = normalized except: pass return phone
def create(request): form = AppointmentForm() if request.POST: form = AppointmentForm(request.POST) if form.is_valid(): phone_representation = phonenumbers.parse(form.cleaned_data['phone_number'], "US") phone_formatted = str(phonenumbers.format_number(phone_representation, phonenumbers.PhoneNumberFormat.E164)) # get phone owner (or create then) patient = Patient.objects.get_or_create(phone_number=phone_formatted)[0] # make sure appointment date is in the future now = datetime.utcnow().replace(tzinfo=utc) app_date = form.cleaned_data['date'] if now < app_date: appointment = Appointment( owner=patient, date = app_date, ) appointment.save() patient.send_sms('You added an appointment!') return HttpResponseRedirect(reverse(detail, kwargs={ 'appointment_id':appointment.id, })) return render_to_response('appointments/create.html',{ 'form':form, },context_instance=RequestContext(request))
def handle_put_post(http_server, database_manager, session, account): subscription_plan_template = SubscriptionPlan(database_manager) subscription_conditions = [{ "column": "is_active", "equivalence": "=", "value": 1 }] subscription_plans = database_manager.fetch_by(subscription_plan_template, subscription_conditions) billing_profiles = [] for available_subscription_plan in subscription_plans: billing_profiles.append({ "slug": available_subscription_plan.name, "name": available_subscription_plan.name.title(), "amount": available_subscription_plan.amount, "currency": available_subscription_plan.currency, "allowed_requests_per_month": available_subscription_plan.allowed_requests_per_month, "allowed_requests_per_month_printed": "{:,}".format( available_subscription_plan.allowed_requests_per_month), }) template = fetch_template("account/register.jinja.htm") keys = { "current_page": "register", "billing_profiles": billing_profiles, } errors = [] required_keys = [ "billing_id", "email", "password", "verify_password", "phone", #"g-recaptcha-response" ] post_params = http_server.get_post_parameters() if "billing_id" in post_params: if post_params["billing_id"] != "free": required_keys += ["stripe_token"] keys["response"] = post_params for required_key in required_keys: if required_key not in post_params or post_params[required_key] == "": errors.append(required_key) if len(errors) == 0: email = post_params["email"] password = post_params["password"] verify_password = post_params["verify_password"] phone = post_params["phone"] formatted_number = phone if password != verify_password: errors.append("verify_password") #try: phone_details = phonenumbers.parse(phone, "US") if phonenumbers.is_valid_number(phone_details) is False: errors.append("phone") else: formatted_number = "+{} {}".format( phone_details.country_code, phonenumbers.format_number( phone_details, phonenumbers.PhoneNumberFormat.NATIONAL)) client = Client(settings["twilio"]["account_sid"], settings["twilio"]["auth_token"]) twilio_phone_details = client.lookups.phone_numbers( formatted_number).fetch(type='carrier') if twilio_phone_details.carrier["error_code"] is not None: errors.append("phone") else: if twilio_phone_details.carrier["type"] == "voip": errors.append("phone_voip") #except: # errors.append("phone") if validate_email(email) is False: errors.append("email") else: subscription_plan_name = post_params["billing_id"] subscription_plan = SubscriptionPlan.fetch_by_name( database_manager, subscription_plan_name) if subscription_plan is None: errors.append("billing_id") keys["errors"] = errors for error in errors: keys["error_{}".format(error)] = True if len(errors) > 0: output = template.render(keys) # http_server.set_status(400) http_server.print_headers() print(output) else: is_captcha_valid = True ''' recaptcha_response = post_params['g-recaptcha-response'] captcha_data = { "secret": settings["google_recaptcha3"]["secret_key"], "response": recaptcha_response } recaptcha_response = requests.post( settings["google_recaptcha3"], data=captcha_data ) recapcha_json = recaptcha_response.json() is_captcha_valid = True if recapcha_json['success']: is_captcha_valid = True else: is_captcha_valid = False ''' if is_captcha_valid is False: keys["error_invalid_captcha"] = True output = template.render(keys) # http_server.set_status(400) http_server.print_headers() print(output) else: is_marketing_ok = False if "subscribe" in post_params: if int(post_params["subscribe"]) == 1: is_marketing_ok = True keys["is_marketing_ok"] = True do_continue = True stripe_source_token = None stripe_customer_id = None stripe_subscription_id = None if subscription_plan.amount > 0: stripe.api_key = settings["stripe"]["secret_key"] discount_code = None stripe_coupon = None stripe_coupon_id = None if "discount_code" in post_params: discount_code = post_params["discount_code"] try: stripe_coupon = stripe.Coupon.retrieve(discount_code) do_continue = True stripe_coupon_id = stripe_coupon.id except Exception: errors += ["discount_code"] keys["errors"] = errors for error in errors: keys["error_{}".format(error)] = True output = template.render(keys) # http_server.set_status(400) http_server.print_headers() print(output) if do_continue is True: stripe_plan = stripe.Plan.retrieve( subscription_plan.stripe_id) # How to acquire stripe tokens # https://stripe.com/docs/sources/cards # if "stripe_token" not in post_params: # raise ApiParamMissingStripeTokenError stripe_source_token = post_params["stripe_token"] stripe_customer_description = email try: customer = stripe.Customer.create( description=stripe_customer_description, source=stripe_source_token) stripe_customer_id = customer.id # will throw an exception if it fails. Must catch subscription = stripe.Subscription.create( customer=stripe_customer_id, items=[{ "plan": stripe_plan.id }], coupon=stripe_coupon_id) stripe_subscription_id = subscription.id except Exception: errors += ["duplicate_submission"] keys["errors"] = errors for error in errors: keys["error_{}".format(error)] = True output = template.render(keys) # http_server.set_status(400) http_server.print_headers() print(output) do_continue = False if do_continue is True: # verify email doesn't already exist account = Account.fetch_by_email(database_manager, email) if account is not None: errors += ["email_taken"] keys["errors"] = errors for error in errors: keys["error_{}".format(error)] = True output = template.render(keys) # http_server.set_status(400) http_server.print_headers() print(output) else: registration = AccountRegistration.fetch_by_email( database_manager, email) if registration is not None: errors += ["email_taken"] keys["errors"] = errors for error in errors: keys["error_{}".format(error)] = True output = template.render(keys) # http_server.set_status(400) http_server.print_headers() print(output) else: registration_epoch = datetime.now() registration = AccountRegistration(database_manager) registration.email = post_params["email"] registration.password = post_params["password"] registration.phone = formatted_number registration.subscription_plan_id = subscription_plan.id registration.is_marketing_ok = is_marketing_ok registration.stripe_source_id = stripe_source_token registration.stripe_customer_id = stripe_customer_id registration.stripe_subscription_id = stripe_subscription_id registration.billing_interval = "monthly" registration.billing_year = registration_epoch.year registration.billing_month = registration_epoch.month registration.billing_day = registration_epoch.day confirmation_code = registration.generate_confirmation_code( ) # send confirmation email courier = Courier(settings["sendgrid"]) from_email = settings["email"]["from"]["email"] subject = "Confirm your account" template_id = "d-46d40e8316ba439095fdefb20b171a3e" substitutions = {"confirm_code": confirmation_code} response = courier.send_template_email( email, from_email, subject, template_id, substitutions) if response.status_code != 202: errors += ["email_delivery"] keys["errors"] = errors for error in errors: keys["error_{}".format(error)] = True output = template.render(keys) # http_server.set_status(400) http_server.print_headers() print(output) else: registration.insert() template = fetch_template( "account/register-success.jinja.htm") keys["email"] = post_params["email"] http_server.set_status(200) http_server.print_headers() output = template.render(keys) print(output)
def get_full_phone_number(phone_raw, phone_country_code): parse_phone_number = phonenumbers.parse(phone_raw, phone_country_code) return phonenumbers.format_number(parse_phone_number, phonenumbers.PhoneNumberFormat.E164)
def attempt_creation(self): """Validate fields and attempt to create account""" self.create_account_button.disabled = True # list of all problems with user input errors = [] # the following series of conditionals are all for validating # user input before we attempt to insert it into the database if not self.username_field.text: errors.append('username is required') # neither of these should be possible (field is filtered), # but just in case elif len(self.username_field.text) > 32: errors.append('username maximum length is 32 characters') elif re.search(r'\W', self.username_field.text): errors.append( 'username can only contain letters, numbers, and underscores') if not self.password_field.text: errors.append('password is required') elif len(self.password_field.text) < 8: errors.append('password minimum length is 8 characters') if not self.phone_field.text: errors.append('phone number is required') else: try: phone = parse_number(self.phone_field.text, 'US') except NumberParseException: valid = False else: valid = is_valid_number(phone) if not valid: errors.append( f'"{self.phone_field.text}" is not a valid US phone number' ) # if all inputs are valid, attempt to create a new account if not errors: try: create_user(self.username_field.text, self.password_field.text, format_number(phone, 'NATIONAL')) except AccountError as e: # username already exists errors.append(e.message) else: # account created successfully AlertPopup(title='Success', label=f'User "{self.username_field.text}" ' 'has been created', button='Go to Login', on_dismiss=self.switch_to_login).open() return # display input errors to the user popup = AlertPopup(title='Errors', label='\n'.join(f'\u2022 {e}' for e in errors), button='Dismiss') popup.label.halign = 'left' popup.open() self.create_account_button.disabled = False
def normalize_phone_number(num): return format_number(parse(num.decode('utf-8'), 'US'), PhoneNumberFormat.INTERNATIONAL)
def formatted_phone(self): if self.phone: return phonenumbers.format_number( self.phone, phonenumbers.PhoneNumberFormat.NATIONAL)
def get_NationalFormat(self): return phonenumbers.format_number( self.phonenumber_object, phonenumbers.PhoneNumberFormat.NATIONAL)
first_name = "" last_name = "" if (m != None): first_name = m.group('FIRST_NAME') last_name = m.group('LAST_NAME') extract = phoneNumberArray.split('\n') website = "" phoneNumber = extract[0] if (len(extract) >= 2): website = extract[1] website = website[5:len(website)] phoneNumber = re.sub('[^0-9]+', '', phoneNumber) if (len(phoneNumber) >= 5 and len(phoneNumber) < 12): phoneNumber = phonenumbers.format_number( phonenumbers.parse(phoneNumber, 'US'), phonenumbers.PhoneNumberFormat.NATIONAL) phoneNumber = '+1' + phoneNumber[1:len(phoneNumber)] if (')' in phoneNumber): phoneNumber = re.sub('[^0-9]+', '', phoneNumber) phoneNumber = '+' + phoneNumber places = GeoText(address) city = places.cities place = "" if (city != []): place = city[0] pincode = "" # reg = re.compile('^.*(?P<zipcode>\d{6}).*$')
def add_or_update_admin(request): post_data = read_post_data(request) if "flytta" in post_data: for flytta_id in post_data["flytta"]: add_roller(post_data["kodstugor_id"][0], "volontär", flytta_id) elif "flera" in post_data: for i, namn in enumerate(post_data["namn"]): data = ( post_data["namn"][i], post_data["epost"][i], phonenumber_to_format(post_data["telefon"][i]), arrow.get("2090-01-01").timestamp(), ) try: db.cursor.execute(""" INSERT INTO volontarer (namn, epost, telefon, utdrag_datum) VALUES (?,?,?,?) """, data) db.commit() add_roller( post_data["kodstugor_id"][0], "volontär", get_id(post_data["epost"][i]) ) send_email( post_data["epost"][i], "BESK-konto aktiverat", texter.get_one("BESK-konto aktiverat")["text"] ) except db.sqlite3.IntegrityError: pass else: try: phone_number = phonenumbers.parse(post_data["telefon"][0], "SE") phone_number_str = phonenumbers.format_number(phone_number, phonenumbers.PhoneNumberFormat.E164) except Exception: raise Error400("Fyll i ett giltigt telefonummer.") if not phonenumbers.is_valid_number(phone_number): raise Error400("Fyll i ett giltigt telefonummer.") if "id" in post_data: data = ( post_data["namn"][0], post_data["epost"][0], phone_number_str, arrow.get("2090-01-01").timestamp(), post_data["id"][0] ) db.cursor.execute(""" UPDATE volontarer SET namn = ?, epost = ?, telefon = ?, utdrag_datum = ? WHERE id = ? """, data) db.commit() roll_list = [] if "kodstugor_id" in post_data: for form_index, value in enumerate(post_data["kodstugor_id"]): roll_list.append( { "kodstugor_id": value, "roll": post_data["roller"][form_index] } ) add_or_update_roller(roll_list, post_data["id"][0]) else: add_or_update_roller([], post_data["id"][0]) else: data = ( post_data["namn"][0], post_data["epost"][0], phone_number_str, arrow.get("2090-01-01").timestamp(), ) try: db.cursor.execute(""" INSERT INTO volontarer (namn, epost, telefon, utdrag_datum) VALUES (?,?,?,?) """, data) db.commit() send_email( post_data["epost"][0], "BESK-konto aktiverat", texter.get_one("BESK-konto aktiverat")["text"] ) roll_list = [] if "kodstugor_id" in post_data: for form_index, value in enumerate(post_data["kodstugor_id"]): roll_list.append( { "kodstugor_id": value, "roll": post_data["roller"][form_index] } ) add_or_update_roller(roll_list, get_id(post_data["epost"][0])) except db.sqlite3.IntegrityError: raise Error400("E-Postadressen finns redan.")
def phonenumber_to_format(number): try: phone_number = phonenumbers.parse(number, "SE") return phonenumbers.format_number(phone_number, phonenumbers.PhoneNumberFormat.E164) except Exception: return "+46700000000"
def _write_tweets(self, results): fieldnames_ = [ 'issue', 'action', 'id', 'es_score', 'tweet_timestamp', 'query_timestamp', 'tweet_user', 'tweet_cities', 'tweet_states', 'tweet_urls', 'tweet_phone_numbers', 'tweet_dates_ref', 'tweet_legislator_names', 'tweet_legislator_handles', 'tweet' ] if self.tweets_firstline: self.tweets_firstline = False buffer = open("twitter_" + self.outfile, "w") # rzst_events table in Drupal MySQL backend. self.writer = csv.DictWriter(buffer, fieldnames=fieldnames_) self.writer.writeheader() # instantiate the row to be written as empty dict row = dict.fromkeys(fieldnames_, "") # iterate through each tweet n_results = len(results['hits']['hits']) if n_results > 0: print("Writing %s results.\n" % n_results) for result in tqdm(results['hits']['hits']): tweet = "" # potential for two KeyErrors, the second won't be caught # so use if statement instead. if 'message' in result['_source'].keys(): tweet = result['_source']['message'] elif 'text' in result['_source'].keys(): tweet = result['_source']['text'] else: print("issue with document {id}".format(id=result['_id'])) print("From index {issue}-{date}".format(issue=self.issue, date=self.date)) print(result['_source']) # skip meetup for now continue # EXTRACT PHONE NUMBER, URL, STATE, CITY, DATE, LEGISLATOR NAMES, AND LEGISLATOR TWITTER HANDLES # # -- Phone Numbers -- # phone_numbers = [] phone_matches = phonenumbers.PhoneNumberMatcher(tweet, "US") while phone_matches.has_next(): number = phone_matches.next() number = phonenumbers.format_number( number.number, phonenumbers.PhoneNumberFormat.NATIONAL) phone_numbers.append(number) phone_numbers = '; '.join(phone_numbers) # -- States -- # states = '' tweet_states = re.findall(state_regex, tweet) if tweet_states: tweet_states = list(set(tweet_states)) states = '; '.join(tweet_states) # -- CITIES -- # cities = '' tweet_cities = re.findall(city_regex, tweet) if tweet_cities: tweet_cities = list( set([city.title() for city in tweet_cities])) cities = '; '.join(tweet_cities) # -- URLS -- # urls = '' tweet_urls = re.findall(web_url_regex, tweet) if tweet_urls: tweet_urls = list(set(tweet_urls)) # only select the first URL for inclusion on the homepage urls = tweet_urls[0] # -- DATES -- # dates = '' doc = nlp(tweet) all_dates = [ doc.text for doc in doc.ents if doc.label_ == 'DATE' ] date_matches = re.findall(date_include_regex, ' '.join(all_dates)) ### EXCLUDE SOME DIRTY DATES FROM TWITTER THAT SPACY MISTAKENLY INCLUDES if date_matches: dates = all_dates[0] #re.findall(date_exclude_regex,ent.text) # -- LEGISLATOR NAMES -- # leg_names = '' tweet_legislators = re.findall(leg_name_regex, tweet) tweet_legislators = list(set(tweet_legislators)) leg_names = '; '.join(tweet_legislators) # -- LEGISLATOR TWITTER HANDLES -- # leg_twitter_handles = '' tweet_leg_handles = re.findall(leg_twitter_regex, tweet) tweet_leg_handles = list(set(tweet_leg_handles)) if tweet_leg_handles: leg_twitter_handles = '; '.join(tweet_leg_handles) # process if only first item is needed temp_row = { 'tweet_cities': cities, 'tweet_states': states, 'tweet_urls': urls, 'tweet_phone_numbers': phone_numbers, 'tweet_dates_ref': dates, 'tweet_legislator_names': leg_names, 'tweet_legislator_handles': leg_twitter_handles } if self.FIRST_MATCH: temp_row = {key: value for key, value in temp_row.items()} # Replace commas in tweet to avoid confusing parser # when reading later. tweet = tweet.replace(",", "") # fill in the values to row row.update({ 'issue': self.issue, 'action': self.action, 'id': result['_id'], 'es_score': result['_score'], 'tweet_timestamp': result['_source']['@timestamp'], 'query_timestamp': self.querytimestamp, 'tweet_user': result['_source']['user'], # TODO: Ross to filter 'message' section of document for address 'tweet': tweet }) row.update(temp_row) # skip retweets if row['tweet'][:2] == "RT": continue self.writer.writerow(row) self.line_count['twitter'] += 1 else: print("No results to save!") return None
def to_string(self, obj): return phonenumbers.format_number(obj, phonenumbers.PhoneNumberFormat.E164)
def clean_phone(phone): # This could raise, but should have been checked with validate_phone first return phonenumbers.format_number( phonenumbers.parse(phone, DEFAULT_REGION), phonenumbers.PhoneNumberFormat.E164, )
def international_phone_number(self): parsed_number = phonenumbers.parse(self.phone_number) return phonenumbers.format_number(parsed_number, PhoneNumberFormat.INTERNATIONAL)
def get_InternationalFormat(self): return phonenumbers.format_number( self.phonenumber_object, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
def normalize_phone(number): return phonenumbers.format_number(phonenumbers.parse(number, 'US'), phonenumbers.PhoneNumberFormat.E164)
def get_RFC3966Format(self): return phonenumbers.format_number( self.phonenumber_object, phonenumbers.PhoneNumberFormat.RFC3966)
def handleEvent(self, event): eventName = event.eventType srcModuleName = event.module eventData = event.data sourceData = self.sf.hashstring(eventData) if sourceData in self.results: return None else: self.results[sourceData] = True self.sf.debug("Received event, " + eventName + ", from " + srcModuleName) if eventName in [ 'TARGET_WEB_CONTENT', 'DOMAIN_WHOIS', 'NETBLOCK_WHOIS' ]: # Make potential phone numbers more friendly to parse content = eventData.replace('.', '-') for match in phonenumbers.PhoneNumberMatcher(content, region=None): n = phonenumbers.format_number( match.number, phonenumbers.PhoneNumberFormat.E164) evt = SpiderFootEvent("PHONE_NUMBER", n, self.__name__, event) if event.moduleDataSource: evt.moduleDataSource = event.moduleDataSource else: evt.moduleDataSource = "Unknown" self.notifyListeners(evt) if eventName == 'PHONE_NUMBER': try: number = phonenumbers.parse(eventData) except BaseException as e: self.sf.debug('Error parsing phone number: ' + str(e)) return None try: number_carrier = carrier.name_for_number(number, 'en') except BaseException as e: self.sf.debug('Error retrieving phone number carrier: ' + str(e)) return None if number_carrier: evt = SpiderFootEvent("PROVIDER_TELCO", number_carrier, self.__name__, event) self.notifyListeners(evt) else: self.sf.debug("No carrier information found for " + eventData) #try: # location = geocoder.description_for_number(number, 'en') #except BaseException as e: # self.sf.debug('Error retrieving phone number location: ' + str(e)) # return None #if location: # evt = SpiderFootEvent("GEOINFO", location, self.__name__, event) # self.notifyListeners(evt) #else: # self.sf.debug("No location information found for " + eventData) return None
def get_standard_phone(self): n = self.get_phone() fmt = phonenumbers.PhoneNumberFormat.E164 return phonenumbers.format_number(n, fmt)
def format_phone_number(self, phone): try: return phonenumbers.format_number(phonenumbers.parse(phone, 'US'), phonenumbers.PhoneNumberFormat.NATIONAL) except Exception as e: print('Could not format phone number!') return None
def format_as(self, format): if self.is_valid(): return phonenumbers.format_number(self, format) else: return self.raw_input
def get_national_phone(self): n = self.get_phone() fmt = phonenumbers.PhoneNumberFormat.NATIONAL return phonenumbers.format_number(n, fmt)
def format_as(self, format): return phonenumbers.format_number(self, format)
def process_number(num): phone = phonenumbers.parse(num, "ZA") return phonenumbers.format_number(phone, phonenumbers.PhoneNumberFormat.E164)
def __repr__(self): e164_number = phonenumbers.format_number(phonenumbers.parse(self.phone_number, 'US'), phonenumbers.PhoneNumberFormat.E164) return '<PhoneNumber {}>'.format(e164_number)
def claim_number(self, user, phone_number, country, role): org = user.get_org() client = org.get_vonage_client() org_config = org.config matching_phones = client.get_numbers(phone_number) is_shortcode = False # try it with just the national code (for short codes) if not matching_phones: parsed = phonenumbers.parse(phone_number, None) shortcode = str(parsed.national_number) matching_phones = client.get_numbers(shortcode) if matching_phones: is_shortcode = True phone_number = shortcode # buy the number if we have to if not matching_phones: try: client.buy_number(country, phone_number) matching_phones = client.get_numbers(phone_number) except Exception as e: raise Exception( _("There was a problem claiming that number, please check the balance on your account. " "Note that you can only claim numbers after adding credit to your Vonage account." ) + "\n" + str(e)) # what does this number support? features = [elt.upper() for elt in matching_phones[0]["features"]] supports_msgs = "SMS" in features supports_voice = "VOICE" in features role = "" if supports_msgs: role += Channel.ROLE_SEND + Channel.ROLE_RECEIVE if supports_voice: role += Channel.ROLE_ANSWER + Channel.ROLE_CALL channel_uuid = generate_uuid() callback_domain = org.get_brand_domain() receive_url = "https://" + callback_domain + reverse( "courier.nx", args=[channel_uuid, "receive"]) # if it supports voice, create new voice app for this number if supports_voice: app_id, app_private_key = client.create_application( org.get_brand_domain(), channel_uuid) else: app_id = None app_private_key = None # update the delivery URLs for it try: client.update_number(country, phone_number, receive_url, app_id) except Exception as e: # pragma: no cover # shortcodes don't seem to claim correctly, move forward anyways if not is_shortcode: raise Exception( _("There was a problem claiming that number, please check the balance on your account." ) + "\n" + str(e)) if is_shortcode: phone = phone_number vonage_phone_number = phone_number else: parsed = phonenumbers.parse(phone_number, None) phone = phonenumbers.format_number( parsed, phonenumbers.PhoneNumberFormat.INTERNATIONAL) # vonage ships numbers around as E164 without the leading + vonage_phone_number = phonenumbers.format_number( parsed, phonenumbers.PhoneNumberFormat.E164).strip("+") config = { Channel.CONFIG_VONAGE_APP_ID: app_id, Channel.CONFIG_VONAGE_APP_PRIVATE_KEY: app_private_key, Channel.CONFIG_VONAGE_API_KEY: org_config[Org.CONFIG_VONAGE_KEY], Channel.CONFIG_VONAGE_API_SECRET: org_config[Org.CONFIG_VONAGE_SECRET], Channel.CONFIG_CALLBACK_DOMAIN: callback_domain, } channel = Channel.create( org, user, country, self.channel_type, name=phone, address=phone_number, role=role, config=config, bod=vonage_phone_number, uuid=channel_uuid, tps=1, ) return channel
def number_exists(phone_number): phone_number = phonenumbers.format_number(phonenumbers.parse(phone_number, 'US'), phonenumbers.PhoneNumberFormat.E164) return PhoneNumber.query.filter_by(phone_number=phone_number).count()
def signup(): error = None if request.method == 'POST': addresslist = [] try: _username = str(request.form['username']) _password = str(request.form['password']) except: error = 'There is an error with your username/password.' return render_template('signup.html', error=error) try: phonenumber = str(request.form['phonenumber']) print phonenumber phonenumObject = ph.parse(phonenumber, None) if not ph.is_valid_number(phonenumObject): raise Exception except: error = 'Invalid Phone Number.' return render_template('signup.html', error=error) _phonenumber = str(ph.format_number(phonenumObject, ph.PhoneNumberFormat.E164)) try: _address1 = str(request.form['address1']) _starttime1 = int(request.form['starttime1']) _endtime1 = int(request.form['endtime1']) # parse address into lat lng try: geocode_result = gmaps.geocode(_address1) if len(geocode_result) == 0: raise Exception #get the lat,long of the address _addresspoint1 = geocode_result[0]['geometry']['location'].values()[0], geocode_result[0]['geometry']['location'].values()[1] #the _addresspoint1 tuple is flipped around because PostGIS uses long,lat instead of lat,long cur.execute("SELECT ST_SetSRID(ST_MakePoint('{}', '{}'), 4326)".format(_addresspoint1[1],_addresspoint1[0])) _geog1 = cur.fetchall()[0][0] except: error = "First address is invalid.{}".format(_addresspoint1) return render_template('signup.html', error=error) if _starttime1 >= _endtime1: raise Exception addresslist.append([_address1, _addresspoint1, _starttime1, _endtime1, _geog1]) except: error = "There is an issue with your first address/timings." return render_template('signup.html', error=error) if request.form['address2']: try: _address2 = str(request.form['address2']) _starttime2 = int(request.form['starttime2']) _endtime2 = int(request.form['endtime2']) #parse address into lat long here try: geocode_result = gmaps.geocode(_address2) if len(geocode_result) == 0: raise Exception _addresspoint2 = geocode_result[0]['geometry']['location'].values()[0], geocode_result[0]['geometry']['location'].values()[1] cur.execute("SELECT ST_SetSRID(ST_MakePoint('{}', '{}'), 4326)".format(_addresspoint2[1],_addresspoint2[0])) _geog2 = cur.fetchall()[0][0] except: error = "Second address is invalid." return render_template('signup.html', error=error) if _starttime2 >= _endtime2: raise Exception addresslist.append([_address2, _addresspoint2, _starttime2, _endtime2, _geog2]) except: error = "There is an issue with your second address/timings." return render_template('signup.html', error=error) if request.form['address3']: try: _address3 = str(request.form['address3']) _starttime3 = int(request.form['starttime3']) _endtime3 = int(request.form['endtime3']) #parse address into lat long here try: geocode_result = gmaps.geocode(_address3) if len(geocode_result) == 0: raise Exception _addresspoint3 = geocode_result[0]['geometry']['location'].values()[0], geocode_result[0]['geometry']['location'].values()[1] cur.execute("SELECT ST_SetSRID(ST_MakePoint('{}', '{}'), 4326)".format(_addresspoint3[1],_addresspoint3[0])) _geog3 = cur.fetchall()[0][0] except: error = "Third address is invalid." return render_template('signup.html', error=error) if _starttime3 >= _endtime3: raise Exception addresslist.append([_address3, _addresspoint3, _starttime3, _endtime3, _geog3]) except: error = "There is an issue with your third address/timings." return render_template('signup.html', error=error) try: file = request.files['file'] _filename = file.filename print _filename _filedata = db.Binary(file.read()) except: error = "There is an issue with your uploaded file.{}".format(request.form) return render_template('signup.html', error=error) try: cur.execute("INSERT INTO medics (username, password, phonenumber, active, filename, filedata, validated, pending)\ VALUES ('{}', '{}', '{}', True, '{}', {}, False, True)".format(_username, _password, _phonenumber, _filename, _filedata)) for infolist in addresslist: cur.execute("INSERT INTO addresses (username, address, addresspoint, starttime, endtime, geog)\ VALUES('{}', '{}', '{}', '{}', '{}', '{}')".format(_username, infolist[0], infolist[1], infolist[2], infolist[3], infolist[4])) except: error = 'Unable to insert into database.' return render_template('signup.html', error=error) session['username'] = _username con.commit() if session['username'] == 'admin': return redirect('/admin') return redirect('user/'+session['username']) return render_template('signup.html')
def clean_phone_number(self): phone = self.cleaned_data["phone_number"] phone = phonenumbers.parse(phone, self.cleaned_data["country"]) return phonenumbers.format_number(phone, phonenumbers.PhoneNumberFormat.E164)
def normalize_phone(number): number = number[1:] if number[:1] == '0' else number parse_phone_number = phonenumbers.parse(number, 'ID') phone_number = phonenumbers.format_number( parse_phone_number, phonenumbers.PhoneNumberFormat.E164) return phone_number
def normalize_phone(phone): phone_parsed = phonenumbers.parse(phone, region="DE") return phonenumbers.format_number(phone_parsed, phonenumbers.PhoneNumberFormat.E164)