def validate(self, value, force=False):
if has_phonenumbers:
try:
phonenumbers.parse(value, None)
except NumberParseException as e:
raise Invalid(_(unicode(e._msg)))
return super(PhoneWidgetValidator, self).validate(value, force)
def valid(number, country_code=None):
"""Determine whether or not a phone number is valid."""
try:
phonenumbers.parse(number, country_code)
return True
except Exception:
return False
def to_python(self, value, *args, **kwargs):
""" Convert value from National US phone number to international """
if value in validators.EMPTY_VALUES:
value = None
else:
# Parse the value
try:
if value.startswith("+"):
value = phonenumbers.parse(value)
else:
value = phonenumbers.parse(value, "US")
except phonenumbers.phonenumberutil.NumberParseException:
value = phonenumbers.PhoneNumber(raw_input=value)
# Produce international format without formatting.
value = "+{country_code}{national_number}".format(
country_code=value.country_code,
national_number=value.national_number
)
try: return super(LocalPhoneNumberField, self).to_python(
value, *args, **kwargs
)
except:
raise exceptions.ValidationError("Please enter a phone number in the format (xxx) xxx-xxxx", code="invalid")
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 phone_number(number, region_code=None, pattern=None, number_format=None, prefix_format=None):
"""
for number +995595119925
pattern="(\\d{3})(\\d{2})(\\d{2})(\\d{2})", format="\\1 \\2-\\3-\\4"
result 595 11-99-25
"""
if pattern is None or number_format is None or prefix_format is None:
return number
if type(number) is PhoneNumber:
try:
number = phonenumbers.parse(number.phone_number, number.region_code)
except:
return number
elif type(number) is str:
if region_code is None:
return number
try:
number = phonenumbers.parse(number, region_code)
except:
return number
new_number_format = NumberFormat(pattern=pattern, format=number_format)
new_number_format._mutable = True
new_number_format.national_prefix_formatting_rule = prefix_format % (number.country_code, '$FG')
new_number_formats = [new_number_format]
return phonenumbers.format_by_pattern(
number,
phonenumbers.PhoneNumberFormat.NATIONAL,
new_number_formats
)
def is_a_phone(value, key=None, pos=None):
value = str(value).strip()
if len(value) > 20:
return False
"""Check for international numbers"""
if value.startswith('+'):
try:
phonenumbers.parse(value)
return True
except:
return False
"""Otherwise let's hope it's a US number"""
reg = re.compile(".*?(\(?\d{3}\D{0,3}\d{3}\D{0,3}\d{4}).*?", re.S)
matches = reg.search(value)
"""We're not looking for text fields that contain phone numbers, only fields
that are dedicated to phone number"""
if matches and len(matches.group(1)) == len(value):
return True
return False
def from_string(cls, phone_number, region=None):
phone_number_obj = cls()
if region is None:
region = getattr(settings, 'PHONENUMBER_DEFAULT_REGION', None)
phonenumbers.parse(number=phone_number, region=region,
keep_raw_input=True, numobj=phone_number_obj)
return phone_number_obj
def create(self, validated_data):
caller = validated_data['caller']
destination = validated_data['destination']
if validated_data['direction'] == 'outbound':
# Because of GRID-4965, the API returns the destination number in the same format user inserted it,
# so if country code is missing let's patch it with the one from the caller number.
if not destination['number'].startswith('+'):
if caller['number'].startswith('+'):
try:
caller_number = phonenumbers.parse(caller['number'], None)
country_code = get_country_code_by_country(
geocoder.country_name_for_number(caller_number, 'en')
)
destination_number = phonenumbers.parse(destination['number'], country_code)
if phonenumbers.is_valid_number(destination_number):
destination['number'] = phonenumbers.format_number(
destination_number,
phonenumbers.PhoneNumberFormat.E164
)
except NumberParseException, e:
logger.error(traceback.format_exc(e))
data = self.match_external_participant(destination)
if not data['source']:
# We don't save outbound calls where the destination isn't an account or a contact.
# This is the only reliable way to filter out internal calls.
return CallRecord()
def test_is_valid_number(self):
p = phonenumbers.parse('+1123456789')
self.assertFalse(phonenumbers.is_possible_number(p))
self.assertFalse(phonenumbers.is_valid_number(p))
p = phonenumbers.parse('+17184734811')
self.assertTrue(phonenumbers.is_possible_number(p))
self.assertTrue(phonenumbers.is_valid_number(p))
def unify_phone(origin_phone):
try:
try:
phone = pn.parse(origin_phone)
except NumberParseException:
phone = pn.parse(origin_phone, 'RU')
return pn.format_number(phone, pn.PhoneNumberFormat.INTERNATIONAL)
except NameError:
raise ImportError('django-phonenumber-field module is not available')
def from_string(cls, phone_number):
phone_number_obj = cls()
region = getattr(settings, 'PHONENUMER_DEFAULT_REGION', None)
if not region:
language_code = getattr(settings, 'LANGUAGE_CODE', None)
if language_code:
region = language_code.upper()
phonenumbers.parse(number=phone_number, region=region, keep_raw_input=True, numobj=phone_number_obj)
return phone_number_obj
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 format_phone(dct):
num_obj = None
if dct.get("country_code") and dct.get("phone"):
num_obj = phonenumbers.parse("+{country_code} {phone}".format(**dct))
elif dct.get("From"):
num_obj = phonenumbers.parse(dct.get("From"))
if num_obj:
number = phonenumbers.format_number_for_mobile_dialing(num_obj, "us", True)
return number
else:
return ""
def format_phone(dct):
num_obj = None
if dct.get('country_code') and dct.get('phone'):
num_obj = phonenumbers.parse('+{country_code} {phone}'.format(**dct))
elif dct.get('From'):
num_obj = phonenumbers.parse(dct.get('From'))
if num_obj:
number = phonenumbers.format_number_for_mobile_dialing(num_obj, 'us',
True)
return number
else:
return ''
def __init__(self, nr):
self.phone_number = sub(r'\s', '', str(nr))
self.phone_number = sub(r'/', '', self.phone_number)
self.phone_number = sub(r'\-', '', self.phone_number)
self.phone_number = sub(r'\(', '', self.phone_number)
self.phone_number = sub(r'\)', '', self.phone_number)
self.phone_number = sub(r'\\', '', self.phone_number)
try:
self.phone_number = phonenumbers.parse(self.phone_number, None)
except NumberParseException:
self.phone_number = phonenumbers.parse(self.phone_number, 'DE')
finally:
return None
return self.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 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 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 valid_us_phone(phone):
try:
phone_number = phonenumbers.parse(phone, "US")
if len(str(phone_number.national_number)) == 10 and phone_number.country_code == 1:
return
except phonenumbers.phonenumberutil.NumberParseException, e:
pass
def clean(self):
cd = super(CustomerForm, self).clean()
phone = cd.get('phone')
country = cd.get('country')
if len(phone) < 1:
return cd
try:
phonenumbers.parse(phone, country)
except phonenumbers.NumberParseException:
msg = _('Enter a valid phone number')
self._errors["phone"] = self.error_class([msg])
return cd
def _reformat_number(
self, cr, uid, erp_number, fs_server=None, context=None):
'''
This function is dedicated to the transformation of the number
available in OpenERP to the number that FreeSWITCH should dial.
You may have to inherit this function in another module specific
for your company if you are not happy with the way I reformat
the OpenERP numbers.
'''
assert(erp_number), 'Missing phone number'
_logger.debug('Number before reformat = %s' % erp_number)
if not fs_server:
fs_server = self._get_freeswitch_server_from_user(
cr, uid, context=context)
# erp_number are supposed to be in E.164 format, so no need to
# give a country code here
parsed_num = phonenumbers.parse(erp_number, None)
country_code = fs_server.company_id.country_id.code
assert(country_code), 'Missing country on company'
_logger.debug('Country code = %s' % country_code)
to_dial_number = phonenumbers.format_out_of_country_calling_number(
parsed_num, country_code.upper()).replace(' ', '').replace('-', '').replace('(', '').replace(')', '')
# Add 'out prefix' to all numbers
if fs_server.out_prefix:
_logger.debug('Out prefix = %s' % fs_server.out_prefix)
to_dial_number = '%s%s' % (fs_server.out_prefix, to_dial_number)
_logger.debug('Number to be sent to FreeSWITCH = %s' % to_dial_number)
return to_dial_number
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 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 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 as_phone_number(value):
if not value or isinstance(value, PhoneNumber):
return value
try:
return phonenumbers.parse(value, settings.DEFAULT_TELEPHONE_COUNTRY_CODE)
except NumberParseException:
return PhoneNumber()
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 __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 send_sms(destination_phone, message, sender_phone=None):
"""
destination_phone must be formatted as international E164
sender_phone must be formatted as international E164, or it may be "None"
Note that the system will make a "best effort" to make the SMS appear to be
sent from sender_phone, but it may not succeed
"""
p = phonenumbers.parse(destination_phone)
if in_testing_mode():
# During unit tests, don't actually send any SMS messages. Instead,
# keep a record of sent SMS's in the testing outbox
if hasattr(send_sms, 'testing_outbox'):
send_sms.testing_outbox.append((destination_phone, message, sender_phone))
return
# Don't actually send any SMS messages for test numbers
if is_test_number(p):
return
default_sender = send_sms_twilio
country_overrides = {
COUNTRY_CODE_ISRAEL: send_sms_smartsms
}
sender = country_overrides.get(p.country_code, default_sender)
sender(p, message, sender_phone)
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 _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 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()
return redirect('user/' + session['username'])
return render_template('signup.html')
def phone_validator(num):
parsed = phonenumbers.parse(num, "US")
if not phonenumbers.is_valid_number(parsed):
raise ValidationError('Must be a valid US phone number.')
return num
import phonenumbers
from phonenumbers import geocoder, carrier
given_No = input("Enter the no:")
number = phonenumbers.parse(given_No)
print(carrier.name_for_number(number, "en"))
print(geocoder.description_for_number(number, "en"))
if phonenumbers.is_valid_number(number) == False:
print("Not a valid number")
Y = phonenumbers.format_number(number,
phonenumbers.PhoneNumberFormat.INTERNATIONAL)
print(Y)
def migrate_person(self, person, occurrences, episodes):
self.total_persons += 1
occurrence = self.get_open_occurrence(occurrences)
if occurrence:
episodes = [case for case in episodes
if not case.closed and case.type == CASE_TYPE_EPISODE
and any([index.referenced_id == occurrence.case_id for index in case.indices])]
episode = episodes[0] if episodes else None
else:
episode = None
props = {
'updated_by_migration': 'enikshay_2b_case_properties',
'enrolled_in_private': 'false',
'case_version': '20',
'area': person.get_case_property('phi_area'),
'language_code': 'hin',
'referred_outside_enikshay_date': person.get_case_property('date_referred_out'),
'referred_outside_enikshay_by_id': person.get_case_property('referred_by_id'),
}
if episode:
props.update({
'current_episode_type': episode.get_case_property('episode_type'),
'alcohol_history': episode.get_case_property('alcohol_history'),
'alcohol_deaddiction': episode.get_case_property('alcohol_deaddiction'),
'tobacco_user': episode.get_case_property('tobacco_user'),
'occupation': episode.get_case_property('occupation'),
'phone_number_other': episode.get_case_property('phone_number_other'),
})
phone_number = person.get_case_property('phone_number')
if phone_number:
props['contact_phone_number'] = strip_plus(
phonenumbers.format_number(
phonenumbers.parse(phone_number, "IN"),
phonenumbers.PhoneNumberFormat.E164)
)
location = self.locations.get(person.owner_id)
if location:
dataset = 'real' if location.metadata.get('is_test') == 'no' else 'test'
props['dataset'] = person.get_case_property('dataset') or dataset
if location.location_type.code == 'phi':
props['phi_name'] = location.name
ancestors_by_type = self.get_ancestors_by_type(location)
if 'tu' in ancestors_by_type:
props['tu_name'] = ancestors_by_type['tu'].name
props['tu_id'] = ancestors_by_type['tu'].location_id
if 'dto' in ancestors_by_type:
props['dto_name'] = ancestors_by_type['dto'].name
props['dto_id'] = ancestors_by_type['dto'].location_id
return CaseStructure(
case_id=person.case_id,
walk_related=False,
attrs={
"create": False,
"owner_id": person.owner_id or '-',
"update": props,
},
)
addresslocation = input("Enter your Address here :")
geolocator = Nominatim(user_agent="Curriculum_Validator")
location = geolocator.geocode(addresslocation)
try:
location.latitude
a0 = 1
except:
a0 = 0
import phonenumbers
from phonenumbers import carrier
from phonenumbers.phonenumberutil import number_type
number = input("Enter your phone number with country code :")
try:
if (carrier._is_mobile(number_type(phonenumbers.parse(number)))):
a1 = 1
else:
a1 = 0
except:
a1 = 0
emailid = input("Enter your email-id :")
is_valid = validate_email(emailid, verify=True)
if is_valid == True:
a3 = 1
else:
a3 = 0
qual = input("Enter your qualification :")
qual_List = ['b.tech', 'b.e', 'B.Tech', 'B.E']
def normalize_phone_number(num):
return format_number(parse(num.decode('utf-8'), 'US'),
PhoneNumberFormat.INTERNATIONAL)
def get_formatted_phone(phone):
return phonenumbers.format_number(phonenumbers.parse(phone),
phonenumbers.PhoneNumberFormat.E164)
#0645632754
#import phone_iso3166
import pycountry
import tkinter
from phone_iso3166.country import phone_country
import phonenumbers
from phonenumbers import geocoder, carrier
number = "33645632754"
code = phone_country(number)
print("code=" + code)
C = pycountry.countries.get(alpha_2=code)
print("C={}".format(C))
print("getitng continent")
ch_number = phonenumbers.parse(number, "CH") #country name
print("ch_number={}".format(ch_number))
print("geocoder={}".format(geocoder.description_for_number(ch_number, "en")))
print("getting operator")
service_number = phonenumbers.parse(number, "RO")
print("carrier={}".format(carrier.name_for_number(service_number, "en")))
import phonenumbers
from phonenumbers import geocoder
from phonenumbers import carrier
number = input('Enter Number (With Country Code): ')
ch_num = phonenumbers.parse(number, 'CH')
print(geocoder.description_for_number(ch_num, 'en'))
service_pro = phonenumbers.parse(number, 'RO')
print(carrier.name_for_number(service_pro, 'en'))
import phonenumbers
from phonenumbers import carrier
mobileNo = input('Enter Mobile Number With Country Code : ')
service_provider = phonenumbers.parse(mobileNo)
print(carrier.name_for_number(service_provider, "en"))
print("Devloped By C15C01337 (Bishal Aryal)")
print("Follow me on Twitter username @C15C01337")
import phonenumbers #pip install phonenumbers
number = input("Enter your number with country code:")
from phonenumbers import geocoder
ch_number = phonenumbers.parse(number, "CH")
print(geocoder.description_for_number(ch_number, "en"))
from phonenumbers import carrier
service_number = phonenumbers.parse(number, "RO")
print(carrier.name_for_number(service_number, "en"))
import phonenumbers
from phonenumbers import geocoder, carrier
inp_numero = input('Número: ')
try:
numero = phonenumbers.parse(inp_numero)
operadora = carrier.name_for_number(numero, 'pt-br')
regiao = geocoder.description_for_number(numero, 'pt-br')
print(f'\n\nOperadora: {operadora}\nEstado: {regiao}')
except:
print('\n\nAlgo deu errado.')
import phonenumbers
from phonenumbers import carrier
from phonenumbers import geocoder
import sys
print("Enter your phonenumber with country code: ")
number = sys.argv[1]
if len(number) < 1:
print("No Number")
exit()
else:
x = phonenumbers.parse(number)
print(x)
print("Carrier: " + carrier.name_for_number(x, 'en'))
print("Location: " + geocoder.description_for_number(x, 'en'))
def get_users(app):
USERS_BLACKLIST = os.getenv('USERS_BLACKLIST', '').split(',')
SLACK_TOKEN = os.getenv('SLACK_TOKEN')
if not SLACK_TOKEN:
raise Exception('SLACK_TOKEN not defined!')
sc = SlackClient(SLACK_TOKEN)
try:
users = sc.api_call("users.list")['members']
except Exception:
raise Exception('Can not get Slack user list!')
# Get users and keep only active members
active_users = []
# Compute users list
for user in users:
# Exclude deleted users
if user['deleted'] == True:
app.logger.debug('Skip deleted user: %s', user['name'])
continue
# Exclude bot users
if user['is_bot'] == True:
app.logger.debug('Skip bot user: %s', user['name'])
continue
# Exclude users in blacklist
if user['name'] in USERS_BLACKLIST:
app.logger.debug('Skip blacklisted user: %s', user['name'])
continue
# Format phone number
if 'phone' in user['profile'] and user['profile']['phone']:
try:
phone_number = phonenumbers.parse(user['profile']['phone'],
"FR")
user['profile']['phone'] = phonenumbers.format_number(
phone_number, phonenumbers.PhoneNumberFormat.NATIONAL)
user['profile']['phone_link'] = phonenumbers.format_number(
phone_number, phonenumbers.PhoneNumberFormat.E164)
except Exception:
app.logger.warning('Invalid phone number "%s" for user "%s"!',
user['profile']['phone'], user['name'])
# According to Slack documentation (https://api.slack.com/methods/users.list),
# Only the image_* fields are guaranteed to be included in user profile
# So we need to check all user profile fields
active_users.append({
'id': user['id'],
'team_id': user['team_id'],
'name': user['name'],
'deleted': user['deleted'],
#'status': user['status'],
'real_name': user['real_name'],
'tz': user['tz'],
'tz_label': user['tz_label'],
'tz_offset': user['tz_offset'],
'profile': {
'first_name':
user['profile'].get('first_name', ''),
'last_name':
user['profile'].get('last_name', ''),
'avatar_hash':
user['profile'].get('avatar_hash', ''),
'title':
user['profile'].get('title', ''),
'phone':
user['profile'].get('phone', ''),
'phone_link':
user['profile'].get('phone_link', ''),
'skype':
user['profile'].get('skype', ''),
'image_24':
user['profile'].get('image_24', ''),
'image_32':
user['profile'].get('image_32', ''),
'image_48':
user['profile'].get('image_48', ''),
'image_72':
user['profile'].get('image_72', ''),
'image_192':
user['profile'].get('image_192', ''),
'image_512':
user['profile'].get('image_512', ''),
'image_1024':
user['profile'].get('image_1024', ''),
'image_original':
user['profile'].get('image_original', ''),
'real_name':
user['profile'].get('real_name', ''),
'real_name_normalized':
user['profile'].get('real_name_normalized', ''),
'email':
user['profile'].get('email', ''),
},
'is_admin': user['is_admin'],
'is_owner': user['is_owner'],
#'is_primary_owner': user['is_primary_owner'],
#'is_restricted': user['is_restricted'],
#'is_ultra_restricted': user['is_ultra_restricted'],
'is_bot': user['is_bot'],
#'has_2fa': user['has_2fa'],
#'two_factor_type': user['two_factor_type']
})
return active_users
def register():
try:
database = psycopg2.connect(
user="******",
password=
"******",
host=os.getenv('DATABASE_IP', "172.17.0.1"),
port="5432",
database="dauhmnvct04jp4")
if database:
cursor = database.cursor()
response = dict()
data = request.get_json()
for key, value in data.items():
error = checkValidityOfData(value, key)
response['error'] = error
if error != None:
raise Exception(response)
email = data['email'].lower()
password = data['password']
firstName = data['first_name']
lastName = data['last_name']
personalStreetAddress = data['personal_street_address']
personalCity = data['personal_city']
personalState = data['personal_state']
personalPostal = data['personal_postal']
personalCountry = data['personal_country']
phoneNumber = data['phone_number']
status = data['status']
gender = data['gender']
if (not phonenumbers.is_valid_number(
phonenumbers.parse(phoneNumber, "US"))):
response['error'] = "Invalid US Phone Number"
raise Exception(response)
isValid = validate_email(email)
if isValid:
salt = generate_salt_string()
encryptedPassword = encrypt_password(password, salt)
salt = salt.decode("utf-8")
cursor.execute(
f"""SELECT * FROM public."Personal Information" WHERE email = '{email}' and first_name = '{firstName}'"""
)
account = cursor.fetchone()
if not account:
cursor.execute(
f"""INSERT INTO public."Personal Information" (email, password, first_name, last_name, personal_street_address, personal_state, personal_city, personal_postal, personal_country, phone_number, status, gender, salts ) VALUES ('{email}', '{encryptedPassword}', '{firstName}', '{lastName}', '{personalStreetAddress}', '{personalState}', '{personalCity}', '{personalPostal}', '{personalCountry}', '{phoneNumber}', '{status}', '{gender}', '{salt}')"""
)
database.commit()
response['status'] = True
response['status_info'] = 'Account created successfully!'
return response
else:
response['error'] = "User Already Exists!"
raise Exception(response)
else:
response['error'] = "Entered Email Is Not Valid!"
raise Exception(response)
else:
error = "Connection to database failed!"
response['error'] = error
raise Exception(response)
except Exception:
return (response, 400)
def update(self, instance, validated_data):
"""
Override this function to include extra functionality.
"""
# For debugging purposes only.
# print(validated_data)
# Get our inputs.
email = validated_data.get('email', instance.email)
# Update telephone numbers.
fax_number = validated_data.get('fax_number', instance.fax_number)
if fax_number is not None:
validated_data['fax_number'] = phonenumbers.parse(fax_number, "CA")
telephone = validated_data.get('telephone', instance.telephone)
if telephone is not None:
validated_data['telephone'] = phonenumbers.parse(telephone, "CA")
other_telephone = validated_data.get('other_telephone', instance.other_telephone)
if other_telephone is not None:
validated_data['other_telephone'] = phonenumbers.parse(other_telephone, "CA")
#---------------------------
# Update `SharedUser` object.
#---------------------------
instance.owner, created = SharedUser.objects.update_or_create(
email=email,
defaults={
'email': email,
'first_name': validated_data.get('given_name', instance.given_name),
'last_name': validated_data.get('last_name', instance.last_name),
'is_active': validated_data.get('is_active', False)
}
)
logger.info("Updated shared user.")
# Update the password.
password = validated_data.get('password', None)
if password:
instance.owner.set_password(password)
# Save the model.
instance.owner.save()
#---------------------------
# Update `Partner` object.
#---------------------------
instance.email = email
# Organization
instance.organization_name = validated_data.get('organization_name', None),
instance.organization_type_of = validated_data.get('organization_type_of', None),
# Profile
instance.given_name=validated_data.get('given_name', instance.given_name)
instance.last_name=validated_data.get('last_name', instance.last_name)
instance.middle_name=validated_data.get('middle_name', instance.middle_name)
instance.birthdate=validated_data.get('birthdate', instance.birthdate)
instance.join_date=validated_data.get('join_date', instance.join_date)
instance.gender = validated_data.get('gender', instance.gender)
instance.description = validated_data.get('description', instance.description)
# Misc
instance.is_ok_to_email=validated_data.get('is_ok_to_email', None)
instance.is_ok_to_text=validated_data.get('is_ok_to_text', None)
instance.hourly_salary_desired=validated_data.get('hourly_salary_desired', 0.00)
instance.limit_special=validated_data.get('limit_special', None)
instance.dues_date=validated_data.get('dues_date', None)
instance.commercial_insurance_expiry_date=validated_data.get('commercial_insurance_expiry_date', None)
instance.police_check=validated_data.get('police_check', None)
instance.drivers_license_class=validated_data.get('drivers_license_class', None)
instance.how_hear=validated_data.get('how_hear', None)
instance.last_modified_by = self.context['last_modified_by']
instance.last_modified_from = self.context['last_modified_from']
instance.last_modified_from_is_public = self.context['last_modified_from_is_public']
# 'organizations', #TODO: IMPLEMENT.
# Contact Point
instance.area_served=validated_data.get('area_served', None)
instance.available_language=validated_data.get('available_language', None)
instance.contact_type=validated_data.get('contact_type', None)
instance.fax_number=validated_data.get('fax_number', None)
# 'hours_available', #TODO: IMPLEMENT.
instance.telephone=validated_data.get('telephone', None)
instance.telephone_extension=validated_data.get('telephone_extension', None)
instance.telephone_type_of=validated_data.get('telephone_type_of', TELEPHONE_CONTACT_POINT_TYPE_OF_ID)
instance.other_telephone=validated_data.get('other_telephone', None)
instance.other_telephone_extension=validated_data.get('other_telephone_extension', None)
instance.other_telephone_type_of=validated_data.get('other_telephone_type_of', TELEPHONE_CONTACT_POINT_TYPE_OF_ID)
# Postal Address
instance.address_country=validated_data.get('address_country', None)
instance.address_locality=validated_data.get('address_locality', None)
instance.address_region=validated_data.get('address_region', None)
instance.post_office_box_number=validated_data.get('post_office_box_number', None)
instance.postal_code=validated_data.get('postal_code', None)
instance.street_address=validated_data.get('street_address', None)
instance.street_address_extra=validated_data.get('street_address_extra', None)
# Geo-coordinate
instance.elevation=validated_data.get('elevation', None)
instance.latitude=validated_data.get('latitude', None)
instance.longitude=validated_data.get('longitude', None)
# 'location' #TODO: IMPLEMENT.
# Save our instance.
instance.save()
logger.info("Updated the partner.")
# #---------------------------
# # Attach our comment.
# #---------------------------
# extra_comment = validated_data.get('extra_comment', None)
# if extra_comment is not None:
# comment = Comment.objects.create(
# created_by=self.context['last_modified_by'],
# last_modified_by=self.context['last_modified_by'],
# text=extra_comment
# )
# partner_comment = PartnerComment.objects.create(
# partner=instance,
# comment=comment,
# created_from = self.context['last_modified_from'],
# created_from_is_public = self.context['last_modified_from_is_public']
# )
#---------------------------
# Update validation data.
#---------------------------
# validated_data['comments'] = PartnerComment.objects.filter(partner=instance)
validated_data['last_modified_by'] = self.context['last_modified_by']
# validated_data['extra_comment'] = None
# Return our validated data.
return validated_data
def _save_message(self,
message,
group_name,
chat_id,
msg_id,
file_name,
msg_id_path='/data/mensagens_grupo/'):
"""
Escreve em formato json a mensagem coletada no arquivo
referente ao grupo em que ela foi enviada. Caso o arquivo do grupo
ainda não exista, ele será criado.
Parâmetros
------------
message : webwhatsapi.Message()
Objeto da mensagem coletada.
group_name : str
Nome do grupo em que a mensagem foi enviada.
chat_id : str
Id do grupo em que a mensagem foi enviada.
msg_id : str
Id da mensagem coletada.
file_name : str
Nome do arquivo da mídia possivelmente contida na mensagem.
msg_id_path : str
Caminho da pasta em que os arquivos de mensagens por grupo
serão escritos.
"""
if not message.sender:
return
item = dict()
sender = message.sender.id
sender = sender.replace(' ', '').strip()
sender = sender.split('@')[0]
sender = ('+' + sender)
try:
phone = phonenumbers.parse(sender)
except Exception:
phone = phonenumbers.parse('+' + sender)
country_code = phone.country_code
country = phonenumbers.phonenumberutil.region_code_for_country_code(
country_code)
mid = smart_str(msg_id)
gid = smart_str(chat_id)
try:
content = message.content
content = smart_str(content)
content = smart_str(content.replace('\n', ' '))
except Exception:
content = '<NoContent>'
t = str(message)
index = t.find(' at ') + 4
index2 = index + 19
date = str(t[index:index2])
date = smart_str(date.replace(' ', '\t').strip())
filename = '<NoFile>'
mediatype = 'application/json'
if (isinstance(message, MESSAGE.MediaMessage)
or isinstance(message, MESSAGE.MMSMessage)):
mediatype = smart_str(message.type)
try:
filename = message.filename
content = '<' + filename + '>'
except Exception:
filename = '<NoFile>'
if hasattr(message, 'caption'):
content = smart_str(message.caption)
if 'text' in mediatype:
mediatype = 'application/json'
phash = ''
checksum = ''
if ((mediatype == 'image' and self.process_image_hashes)
or (mediatype == 'video' and self.process_video_hashes)
or (mediatype == 'audio' and self.process_audio_hashes)):
dir = ""
if mediatype == 'image':
dir = self.data_path + "image"
if mediatype == 'video':
dir = self.data_path + "video"
if mediatype == 'audio':
dir = self.data_path + "audio"
try:
checksum = hash_functions.get_hash_from_method(
os.path.join(dir, message.filename), "checksum")
except Exception:
print("Couldn't process checksum for file %s." %
(message.filename))
if mediatype == 'image':
try:
phash = hash_functions.get_hash_from_method(
os.path.join(dir, message.filename), "phash")
except Exception:
print("Couldn't process phash for file %s." %
(message.filename))
item['mensagem_id'] = mid
item['identificador'] = mid
item['grupo_id'] = gid
item['titulo'] = group_name
item['pais'] = country
item['enviado_por'] = smart_str(sender)
item['criado_em'] = smart_str(date)
item['tipo'] = mediatype
item['arquivo'] = smart_str(filename)
item['datalake'] = join(self.data_path, smart_str(filename))
item['texto'] = smart_str(content)
if (mediatype == 'video' or mediatype == 'image'
or mediatype == 'audio'):
item['checksum'] = checksum
if mediatype == 'image':
item['phash'] = phash
messageLine = '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%r\t%s\t%s' % \
(mid, gid, group_name, country, smart_str(sender),
smart_str(date), mediatype, checksum, smart_str(filename),
self._process_string(content))
print(messageLine)
# Save message on kafka
if self.save_kafka:
topic = self.kafka.get_topic('whatsapp', 'mensagem')
json_dump_object = json.dumps(item)
self.kafka.publish_kafka_message(self.producer, topic, 'raw',
json_dump_object)
if self.save_file:
# Save message on group ID file
if self.write_mode == 'group' or self.write_mode == 'file' or self.write_mode == 'both':
message_group_filename = '%smensagens_grupo_%s.json' % (
msg_id_path, gid)
with open(message_group_filename, 'a') as json_file:
json.dump(item, json_file)
print('', file=json_file)
if self.write_mode == 'day' or self.write_mode == 'file' or self.write_mode == 'both':
message_day_filename = file_name
# Save message on file for all messages of the day
with open(message_day_filename, 'a') as json_file:
json.dump(item, json_file)
print('', file=json_file)
# Always save mid reference for future checks
reference_mid_filename = '/data/mids/%s.txt' % (gid)
with open(reference_mid_filename, 'a') as fmid:
messageLine = '%s\t%s\t%s' % (mid, gid, smart_str(date))
print(messageLine, file=fmid)
return item
def team_edit_user(pid, tid):
''' Team edit user '''
# pylint: disable=too-many-locals,too-many-return-statements,too-many-branches,too-many-statements
team, project, _redirect = check_the_team_and_project_are_existed(pid=pid,
tid=tid)
if _redirect:
return _redirect
is_admin = (g.user['account']['_id'] in team['chiefs']
or g.user['account']['_id'] in team['owners']
or g.user['account']['_id'] in project['owners'])
if not is_admin:
return redirect('/')
if request.method == 'GET':
waitting_list = list(WaitList.list_by_team(pid=pid, tid=tid))
uids = [u['uid'] for u in waitting_list]
users_info = User.get_info(uids)
for user in waitting_list:
user['_info'] = users_info[user['uid']]
user['_history'] = []
for wait_info in WaitList.find_history(pid=pid, uid=user['uid']):
if 'result' not in wait_info:
wait_info['result'] = 'waitting'
user['_history'].append(wait_info)
user['_mail'] = User(uid=user['uid']).get()['mail']
return render_template('./team_edit_user.html',
project=project,
team=team,
waitting_list=waitting_list)
if request.method == 'POST':
data = request.json
if data['case'] == 'deluser':
Team.update_members(pid=pid, tid=tid, del_uids=[
data['uid'],
])
elif data['case'] == 'history':
history = []
for raw in WaitList.find_history_in_team(uid=data['uid'],
pid=pid,
tid=tid):
raw['_id'] = str(raw['_id'])
history.append(raw)
return jsonify({'history': history})
elif data['case'] == 'members':
result_members = []
if team['members'] or team['chiefs']:
_all_uids = set(team['chiefs']) | set(team['members'])
users_info = User.get_info(list(_all_uids))
for uid in _all_uids:
result_members.append(users_info[uid])
for user in result_members:
user['chat'] = {}
mid = MattermostTools.find_possible_mid(uid=user['_id'])
if mid:
user['chat'] = {
'mid': mid,
'name': MattermostTools.find_user_name(mid=mid)
}
user['phone'] = {'country_code': '', 'phone': ''}
if 'phone' in user['profile_real'] and user[
'profile_real']['phone']:
phone = phonenumbers.parse(
user['profile_real']['phone'])
user['phone']['country_code'] = phonenumbers.COUNTRY_CODE_TO_REGION_CODE[phone.country_code][0] # pylint: disable=line-too-long
user['phone']['phone'] = phonenumbers.format_number(
phone, phonenumbers.PhoneNumberFormat.NATIONAL)
result_members = sorted(
result_members, key=lambda u: u['profile']['badge_name'])
return jsonify({
'members':
result_members,
'tags':
team.get('tag_members', []),
'members_tags':
Team.get_members_tags(pid=pid, tid=tid),
})
elif data['case'] == 'add_tag':
result = Team.add_tag_member(pid=pid,
tid=tid,
tag_name=data['tag_name'])
return jsonify({'tag': result})
elif data['case'] == 'update_member_tags':
team_tags = [i['id'] for i in team.get('tag_members', [])]
team_members = set(team['members'] + team['chiefs'])
tag_datas = {}
for uid in team_members:
if uid in data['data']:
tag_datas[uid] = {
'tags': list(set(team_tags) & set(data['data'][uid]))
}
if tag_datas:
Team.add_tags_to_members(pid=pid, tid=tid, data=tag_datas)
return jsonify({'data': tag_datas})
elif data['case'] == 'del_tag':
Team.del_tag(pid=pid, tid=tid, tag_id=data['tag']['id'])
return jsonify({})
return jsonify(data)
return jsonify({})
import phonenumbers
from phonenumbers import geocoder
from phonenumbers import carrier
user_inp = input('Enter a Phone Number with Country Code: ')
# TO know From which country the Number Belongs!!
ch_nmber = phonenumbers.parse(user_inp, 'CH')
print(geocoder.description_for_number(ch_nmber, "en"))
# TO know From which Service Provider the Number is being Linked to!!
service_numb = phonenumbers.parse(user_inp, "RO")
print(carrier.name_for_number(service_numb, "en"))
#help(geocoder)
import phonenumbers
# geocoder: to know the specific
# location to that phone number
from phonenumbers import geocoder
from phonenumbers import carrier
# Indian phone number example: +91**********
phone_number = phonenumbers.parse("+91**********")
# this will print the country name
print(geocoder.description_for_number(phone_number, 'en'))
# this will print the service provider name
print(carrier.name_for_number(phone_number, 'en'))
import phonenumbers
from phonenumbers import geocoder
phone = input("Digite o número no formato +551100000000: ")
phone_number = (phonenumbers.parse(phone))
print(geocoder.description_for_number(phone_number, "pt"))
def localScan(InputNumber):
global number
global localNumber
global internationalNumber
global numberCountryCode
global numberCountry
print(code_info + 'Executando verificação local...')
time.sleep(1)
FormattedPhoneNumber = "+" + formatNumber(InputNumber)
try:
PhoneNumberObject = phonenumbers.parse(FormattedPhoneNumber, None)
except:
return False
else:
if not phonenumbers.is_valid_number(PhoneNumberObject):
return False
number = phonenumbers.format_number(
PhoneNumberObject,
phonenumbers.PhoneNumberFormat.E164).replace('+', '')
numberCountryCode = phonenumbers.format_number(
PhoneNumberObject,
phonenumbers.PhoneNumberFormat.INTERNATIONAL).split(' ')[0]
countryRequest = json.loads(
requests.request(
'GET',
'https://restcountries.eu/rest/v2/callingcode/{}'.format(
numberCountryCode.replace('+', ''))).content)
numberCountry = countryRequest[0]['alpha2Code']
localNumber = phonenumbers.format_number(
PhoneNumberObject, phonenumbers.PhoneNumberFormat.E164).replace(
numberCountryCode, '')
internationalNumber = phonenumbers.format_number(
PhoneNumberObject, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
print('')
print(code_result +
'»Formato internacional: {}'.format(internationalNumber))
print
print(code_result + '»Formato local: 0{}'.format(localNumber))
print
print(code_result + '»Código do país: {}'.format(numberCountryCode))
print
print(code_result + '»Localização: {}'.format(
geocoder.description_for_number(PhoneNumberObject, "en")))
print
print(code_result + '»Transportadora: {}'.format(
carrier.name_for_number(PhoneNumberObject, 'en')))
print
print(code_result + '»Area: {}'.format(
geocoder.description_for_number(PhoneNumberObject, 'en')))
print
for timezoneResult in timezone.time_zones_for_number(
PhoneNumberObject):
print(code_result + '»Fuso horário: {}'.format(timezoneResult))
print
if phonenumbers.is_possible_number(PhoneNumberObject):
print(code_info + '\033[1;34m>O número é válido e possível. ')
else:
print(
code_warning +
'\033[1;36m# >O número é válido, mas pode não ser possível. #'
)
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)
import phonenumbers from test import number from phonenumbers import geocoder, carrier, timezone country_num = phonenumbers.parse(number, "CH") print(geocoder.description_for_number(country_num, "en")) service_num = phonenumbers.parse(number, "RO") print(carrier.name_for_number(service_num, "en")) gb_num = phonenumbers.parse(number, "GB") print(timezone.time_zones_for_number(gb_num))
"""main.py"""
import phonenumbers
from test import number
from phonenumbers import geocoder
ch_nmber = phonenumbers.parse(number, "CH")
print(geocoder.description_for_number(ch_nmber, "en"))
"""test.py"""
n = input("enter country code: ")
m = input("enter the Number: ")
number = '+' + 'n' + 'm'
import phonenumbers
from phonenumbers import geocoder
phone_number = phonenumbers.parse('+18033360564')
print(geocoder.description_for_number(phone_number, 'en'))
import phonenumbers
from colorama import init
from phonenumbers import geocoder
from termcolor import colored
init()
print(" ")
print(colored(" ███ ██ ██ ███ ██ ███████ ██████ ", "red"))
print(colored(" ████ ██ ██ ████ ██ ██ ██ ██ ", "magenta"))
print(colored(" ██ ██ ██ - ██ ██ ██ ██ █████ ██ ██ ", "yellow"))
print(colored(" ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ", "green"))
print(colored(" ██ ████ ██ ██ ████ ██ ██████ ", "blue"))
print(" ")
print(colored(" Number Service Shower & Country @yFley 2021", "green"))
print(" ")
number = input(" Number: ")
de_nmber = phonenumbers.parse(number, "DE")
print(geocoder.description_for_number(de_nmber, "de"))
from phonenumbers import carrier
service_nmber = phonenumbers.parse(number, "RO")
print(carrier.name_for_number(service_nmber, "de"))
def sms_reply():
"""Respond to incoming calls with a simple text message."""
# Fetch the message
msg = request.form.get('Body').lower()
sms_reply.ph = request.form.get("From")
lat, lon = request.form.get('Latitude'), request.form.get('Longitude')
global lati, long
global count
# Create reply
sms_reply.resp = MessagingResponse()
twiml = VoiceResponse()
print('What user Typed:', msg)
#resp.message("You said: {}".format(msg))
if len(msg) == 12:
print("first count")
count += 1
sms_reply.z = phonenumbers.parse(msg, "IN")
if (phonenumbers.is_valid_number(sms_reply.z)) is True:
print("valid:", sms_reply.z)
sms_reply.sms = msg
print(sms_reply.sms)
sms_reply.id = str(random.randint(1000, 9999))
print(sms_reply.id)
client = Client(account_sid, auth_token)
message = client.messages.create(
from_='whatsapp:+<your twilio number>',
body=(sms_reply.id),
to='whatsapp:+' + sms_reply.sms)
print(message.sid)
elif count in range(1, 999999) and msg == sms_reply.id:
print("count:", count)
import requests
requests.get('<Your ngrok or server link>/dial/' + sms_reply.sms)
elif any(c in msg for c in list1):
import requests
url = "https://trueway-places.p.rapidapi.com/FindPlacesNearby"
querystring = {
"location": lati + "," + long,
"type": msg,
"radius": "1200",
"language": "en"
}
headers = {
'x-rapidapi-key': "<your TrueWay Places rapid api key>",
'x-rapidapi-host': "trueway-places.p.rapidapi.com"
}
response = requests.request("GET",
url,
headers=headers,
params=querystring)
data = response.json()
ids = data['results']
for i in range(0, len(ids) - 1):
location = str(ids[i]["location"]["lat"]) + "," + str(
ids[i]["location"]["lng"])
link = "http://maps.google.com/maps?q=" + location
name = " *_Name:_* " + ids[i]["name"] + "\n *_Address:_* " + (
response.json()["results"][i]["address"]
) + "\n *_Distance (Approx):_* " + str(
ids[i]["distance"]) + "mt" + "\n\n *_Location:_* " + link
print(name)
#print("Distance:", ids[i]['distance'],)
sms_reply.resp.message(name)
#sms_reply.resp.message(ids[i]['address'])
#sms_reply.resp.message(str(ids[i]['distance']))
return str(sms_reply.resp)
elif 'user1' in msg:
match = re.search(r'[\w\.-]+@[\w\.-]+', msg)
l = (match.group(0))
sms_reply.to = l
print(l)
elif 'subject1' in msg:
sms_reply.subject = msg
print('subject is:', sms_reply.subject)
elif 'body1' in msg:
sms_reply.body = msg
print('body is:', sms_reply.body)
elif 'send1' in msg:
with smtplib.SMTP('smtp.gmail.com', 587) as smtp:
smtp.ehlo()
smtp.starttls()
smtp.ehlo()
smtp.login(EMAIL_ADDRESS, EMAIL_PASSWORD)
subject = sms_reply.subject
body = sms_reply.body
msg = f'Subject: {subject}\n\n{body}'
smtp.sendmail(EMAIL_PASSWORD, sms_reply.to, msg)
sms_reply.resp.message('send succesfully')
print('send succesfully')
print("To:", sms_reply.to)
print("Subject:", sms_reply.subject)
print("Body:", sms_reply.body)
elif "my email" in msg:
match = re.search(r'[\w\.-]+@[\w\.-]+', msg)
s = (match.group(0))
print("Your email:", s)
elif "email" in msg:
print("its email")
sms_reply.resp.message(
"OK so you want to send an e-mail\n\n"
"1.)Firstly You have to enter email to which you want to send and click send\n\n"
"2.)Then type 'subject1' before entering your subject in the same line and click send\n\n"
"3.)And for body write 'body1' before writing mssg in the same line and click send\n\n"
"4.) After typing all the details types 'send1' and its done")
else:
print("no phone number")
return str(sms_reply.resp)
def setUp(self):
self.maxDiff = None
self.recipient = RecipientFactory(verification_code="123456",
phone_number=phonenumbers.parse(
"+61421955955", "AU"))
def is_phone(phone):
try:
return phonenumbers.is_valid_number(phonenumbers.parse(phone, None))
except phonenumbers.NumberParseException:
return False
