def get_df():
while True:
try:
first_msg = c.poll(10)
mapa = first_msg.value()
print(mapa)
mapa['CODE'] = region_code_for_number(
phonenumbers.parse('+' + str(int(mapa['CALLEE']))))
callee_country = pycountry.countries.get(
alpha_2=region_code_for_number(
phonenumbers.parse('+' + str(int(mapa['CALLEE'])))))
mapa['CALLEE_COUNTRY'] = callee_country.name
caller_country = pycountry.countries.get(
alpha_2=region_code_for_number(
phonenumbers.parse('+' + str(int(mapa['CALLER'])))))
mapa['CALLER_COUNTRY'] = caller_country.name
mapa['AVG_CALL_DURATION_LAST_1D'] = mapa[
'TOTAL_CALL_DURATION_LAST_1D'] / (
mapa['CALLER_CALL_COUNT_LAST_1D'] +
mapa['CALLEE_CALL_COUNT_LAST_1D'])
if float(mapa['AVG_CALL_DURATION_LAST_1D']) > float(
mapa['TOTAL_CALL_DURATION_LAST_1D']):
continue
values = [list(mapa.values())] #spremamo vrijednosti prve poruke
columns = list(mapa.keys()) #spremamo atribute prve poruke
df = pd.DataFrame(values, columns=columns)
return df
except:
continue
def get_phone_number_object(self, data_string):
"""
Takes the data_string and tries to parse a phone number out of it
:param data_string: data that might be a phone number
:type data_string: str
:return: phone number data if it's a phone number
:rtype: dict
"""
try:
check_region = (data_string[0] == "+")
# First pass to see if it's a valid number
num_obj = phonenumberutil.parse(
data_string,
_check_region=check_region
)
num_desc = geocoder.description_for_valid_number(
num_obj, "en"
).strip()
except NumberParseException:
# If we can't parse it out, it's not a valid number
return False
# if we weren't able to check the region, and we didn't get a
# description we want to modify the data and give it another go
# with a country code added
if not check_region and not num_desc:
prefix = None
if len(self.digits) == 11 and data_string[0] == "1":
prefix = "+"
elif len(self.digits) == 10 \
and (data_string[0].isdigit() or
data_string[0] in string.punctuation):
prefix = "+1"
if prefix:
try:
# Second pass to see if we can get an actual
# geocode out of it using a hammer
second_pass = phonenumberutil.parse(prefix + data_string)
num_desc = geocoder.description_for_valid_number(
second_pass, "en"
).strip()
if num_desc:
num_obj = second_pass
# confidence hit because we had to
# modify the data to get a result
self.confidence -= 5
except (NumberParseException, Exception):
pass
# Attempting to get a valid region
num_region = phonenumberutil.region_code_for_number(num_obj)
# This is the compiled phone number data that
# we will use for the confidence decision
return self.build_phone_number_dict(num_obj, num_desc, num_region)
def twilioSMS(k,msg, count): # To check for country code pn = phonenumbers.parse(k) print pn.country_code country = pycountry.countries.get(alpha_2=region_code_for_number(pn)) yo = region_code_for_country_code(pn.country_code) # To get timezone for the specified country url = "http://api.timezonedb.com/v2/list-time-zone?key=" + API_Key + "&format=json&country=" + yo json_obj_places = urllib2.urlopen(url) places = json.load(json_obj_places) print places["zones"][0]["zoneName"] local_date = datetime.now(pytz.timezone(places["zones"][0]["zoneName"])) print local_date.time() hour = local_date.time().hour try: # To check whether the time is the night time or not if hour in range(7, 23): client = Client(account_sid, auth_token) message = client.messages.create(to=k, from_=my_twilio, body=msg) time.sleep( 60 ) print message.sid bappa = client.messages(message.sid).fetch() print(bappa.body) print(bappa.status) # Checking the status of the Message after 1 minute if not delivered or sent, sending again if bappa.status not in ["delivered", "sent"] and count<5: print bappa.status count = count +1 print count logging.basicConfig() time.sleep(2) obj = MessageLog(number=k, dateField=local_date.date(), timeField=local_date.time(), status="Failed or Undelivered") obj.save() print "yoyo" time.sleep(5) twilioSMS(k,msg, count) else: #Saving to database in Night Time print "Night time" time.sleep(2) logging.basicConfig() obj = MessageLog(number=k, dateField=local_date.date(), timeField=local_date.time(), status="Night Time") print obj obj.save() print "bappa" except: # Checking if the number is invalid print "yo bappa" obj = MessageLog(number=k, dateField=local_date.date(), timeField=local_date.time(), status="Not Sent") obj.save() print "error"
def region_code(self):
"""
Generate region code of phone number or None if it's invalid.
"""
code = None
if self.is_valid():
code = region_code_for_number(self)
return code
def phone_number_display(self):
if not isinstance(self.phone_number, PhoneNumber):
return self.phone_number
if region_code_for_number(
self.phone_number) == settings.PHONENUMBER_DEFAULT_REGION:
return self.phone_number.as_national
else:
return self.phone_number.as_international
def country_hint(self, value: str) -> Optional[str]:
try:
number = parse_number(value)
code = region_code_for_number(number)
if code is None:
return None
return str(code).lower()
except NumberParseException:
return None
def format_value(self, value):
if isinstance(value, PhoneNumber):
number_region = region_code_for_number(value)
if self.region != number_region:
formatter = PhoneNumberFormat.INTERNATIONAL
else:
formatter = PhoneNumberFormat.NATIONAL
return value.format_as(formatter)
return super().format_value(value)
def _format_value(self, value):
if isinstance(value, PhoneNumber):
number_region = region_code_for_number(value)
if self.region != number_region:
formatter = PhoneNumberFormat.INTERNATIONAL
else:
formatter = PhoneNumberFormat.NATIONAL
return value.format_as(formatter)
return super(PhoneNumberInternationalFallbackWidget, self)._format_value(value)
def post(self, request, *args, **kwargs):
data = request.data
try:
check_if_user_have_phone_registerd = Sim.objects.get(
phone_number=data['phone'])
if check_if_user_have_phone_registerd:
user = User.objects.get(
id=check_if_user_have_phone_registerd.fk_account.id)
verification_code = str(randint(100000, 999999))
check_if_user_have_phone_registerd.verified_sim_code = verification_code
check_if_user_have_phone_registerd.save()
return JsonResponse({
'status': 'not_verified',
'username': user.username
})
except:
username = uuid.uuid1(
) # make a UUID based on the host ID and current time
username_hashed = hashlib.md5((
str(username)).encode()) # encode() : Converts the string into
username_hashed = username_hashed.hexdigest(
) # bytes to be acceptable by hash function.
user = User.objects.create_user(username=username_hashed,
password='******',
first_name=data['first_name'],
last_name=data['last_name'])
device = Device.objects.create(
fk_account=AdditionalUserData.objects.get(user=user),
device_uuid=data['device_uuid'],
vendor=data['device_vender'],
model=data['device_model'],
os=data['device_platform'])
pn = phonenumbers.parse(str(data['phone']))
country = pycountry.countries.get(
alpha_2=region_code_for_number(pn))
verification_code = str(randint(100000, 999999))
sim = Sim.objects.create(fk_account=user,
country=country.name,
phone_number=data['phone'],
verified_sim_code=verification_code)
M2M_Device_Sim.objects.create(id_sim=sim,
id_device=device,
fk_account=user.id)
data = {
'number': sim.phone_number,
'message':
'Your Events confirmation code is : ' + verification_code,
'type': 'reset password',
'uuid': 'events',
'status': 0,
}
r = requests.post(url=settings.SMSSERVER, data=data)
return JsonResponse({
'status': 'not_verified',
'username': username_hashed
})
def _format_value(self, value):
if isinstance(value, PhoneNumber):
number_region = region_code_for_number(value)
if self.region != number_region:
formatter = PhoneNumberFormat.INTERNATIONAL
else:
formatter = PhoneNumberFormat.NATIONAL
return value.format_as(formatter)
return super(PhoneNumberInternationalFallbackWidget,
self)._format_value(value)
def __get_country_by_phone(self, phone):
if phone == None:
return {}
pn = phonenumbers.parse(phone)
country = pycountry.countries.get(alpha_2=region_code_for_number(pn))
return {
'region_code': region_code_for_country_code(pn.country_code),
'country': country.name
}
def run(self, users):
self.country_count = {}
for user in users:
pn = phonenumbers.parse('+' + str(user))
country = pycountry.countries.get(
alpha_2=region_code_for_number(pn)).name
if country not in self.country_count:
self.country_count[country] = 0
self.country_count[country] += 1
return {"user_counties_count": len(self.country_count)}
def get_phone_number_object(self, data_string):
"""Takes the data_string and tries to parse a phone number out of it"""
try:
check_region = (data_string[0] == "+")
# First pass to see if it's a valid number
num_obj = phonenumberutil.parse(
data_string,
_check_region=check_region
)
num_desc = geocoder.description_for_valid_number(
num_obj, "en"
).strip()
except NumberParseException:
# If we can't parse it out, it's not a valid number
return False
# if we weren't able to check the region, and we didn't get a
# description we want to modify the data and give it another go
# with a country code added
if not check_region and not num_desc:
prefix = None
if len(self.digits) == 11 and data_string[0] == "1":
prefix = "+"
elif len(self.digits) == 10 \
and (data_string[0].isdigit() or
data_string[0] in string.punctuation):
prefix = "+1"
if prefix:
try:
# Second pass to see if we can get an actual
# geocode out of it using a hammer
second_pass = phonenumberutil.parse(prefix + data_string)
num_desc = geocoder.description_for_valid_number(
second_pass, "en"
).strip()
if num_desc:
num_obj = second_pass
# confidence hit because we had to
# modify the data to get a result
self.confidence -= 5
except (NumberParseException, Exception):
pass
# Attempting to get a valid region
num_region = phonenumberutil.region_code_for_number(num_obj)
# This is the compiled phone number data that
# we will use for the confidence decision
return self.build_phone_number_dict(num_obj, num_desc, num_region)
def _format_phonenumber(value):
number_region = region_code_for_number(value)
if DEFAULT_REGION != number_region:
formatter = PhoneNumberFormat.INTERNATIONAL
else:
formatter = PhoneNumberFormat.NATIONAL
fv = value.format_as(formatter)
# use the raw input if all else fails...
# (Can happen when PHONENUMBER_DEFAULT_REGION is not set)
if fv is None or fv == "None":
fv = value.raw_input
return fv
def get_existing_numbers(self, org):
client = org.get_twilio_client()
if client:
twilio_account_numbers = client.api.incoming_phone_numbers.stream(page_size=1000)
numbers = []
for number in twilio_account_numbers:
parsed = phonenumbers.parse(number.phone_number, None)
numbers.append(
dict(
number=phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.INTERNATIONAL),
country=region_code_for_number(parsed),
)
)
return numbers
def get_existing_numbers(self, org):
client = org.get_twilio_client()
if client:
twilio_account_numbers = client.phone_numbers.list(page_size=1000)
twilio_short_codes = client.sms.short_codes.list(page_size=1000)
numbers = []
for number in twilio_account_numbers:
parsed = phonenumbers.parse(number.phone_number, None)
numbers.append(dict(number=phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.INTERNATIONAL),
country=region_code_for_number(parsed)))
org_country = timezone_to_country_code(org.timezone)
for number in twilio_short_codes:
numbers.append(dict(number=number.short_code, country=org_country))
return numbers
def get_existing_numbers(self, org):
client = org.get_twilio_client()
if client:
twilio_account_numbers = client.api.incoming_phone_numbers.stream(page_size=1000)
twilio_short_codes = client.api.short_codes.stream(page_size=1000)
numbers = []
for number in twilio_account_numbers:
parsed = phonenumbers.parse(number.phone_number, None)
numbers.append(
dict(
number=phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.INTERNATIONAL),
country=region_code_for_number(parsed),
)
)
org_country = timezone_to_country_code(org.timezone)
for number in twilio_short_codes:
numbers.append(dict(number=number.short_code, country=org_country))
return numbers
def e164_to_e212(number, verbose=0):
if number[0] != "+": number = "+" + number
try:
parsed = parse_number(number)
if verbose > 1: print("number info: " + str(parsed))
country = phonenumberutil.region_code_for_number(parsed)
if not country:
country = phone_iso3166.country.phone_country(number)
if country in countries:
country2 = countries[country]
if verbose > 0:
print(" country: " + country + " -> " + country2)
country = country2
else:
if verbose > 0: print(" country: " + country)
networks = phone_iso3166.network.country_networks(country)
if verbose > 0: print(" networks: " + str(networks))
name = phonenumbers.carrier.name_for_valid_number(parsed, "en").lower()
if verbose > 0: print(" name: " + str(name))
if not name:
return ("error", "name_not_found")
names = name.split("/")
found = []
for name in names:
for (mcc, mnc, ntw) in networks:
if ntw.lower().find(name) != -1:
found.append("{}{:02d}".format(mcc, mnc))
if found:
return ("ok", found)
else:
return ("error", "id_not_found")
except Exception as e:
print(number)
raise
def geo(request):
res = {}
status_code = 200
if request.method == 'GET':
if 'number' in request.GET:
number = request.GET['number']
country = ''
if 'country' in request.GET:
country = request.GET['country']
tmpphone = cleaner(number, country.upper())
try:
parse_number = phonenumbers.parse(tmpphone, country.upper())
except NumberParseException:
try:
if not tmpphone.startswith('+'):
tmpphone = '+' + tmpphone
parse_number = phonenumbers.parse(tmpphone, None)
except NumberParseException:
c = get_object_or_404(Country, iata=country.upper())
try:
parse_number = phonenumbers.parse(
'+' + c.code + tmpphone.replace('+', ''),
country.upper())
except:
raise Http404(
'Country {0} does not match with number'.format(
country.upper()))
if not phonenumbers.is_valid_number(parse_number) and country:
c = get_object_or_404(Country, iata=country.upper())
try:
parse_number = phonenumbers.parse(
'+' + c.code + tmpphone.replace('+', ''),
country.upper())
except:
raise Http404(
'Country {0} does not match with number'.format(
country.upper()))
if country.upper() == 'AR' or tmpphone.startswith('+54'):
parse_number = format_ar_number(tmpphone)
if Country.objects.filter(code='54').exists():
country_object = Country.objects.get(code='54')
mobile_code = country_object.mobile_code
trunk_prefix = country_object.trunk_prefix
else:
mobile_code = '15'
trunk_prefix = '0'
national_number = parse_number['discable']
region_code = parse_number['interurban']
country_code = parse_number['country']
number_type = parse_number['type']
is_valid = True if number_type != PhoneNumberType.UNKNOWN else False
location = parse_number['location']
country = 'Argentina'
country_iata = 'AR'
tmpcarrier = parse_number['carrier']
urbano = parse_number['urban']
linea = parse_number['line']
local_number = parse_number['urban'] + parse_number['line']
is_posible = True if number_type != PhoneNumberType.UNKNOWN else False
dial_number = phonenumbers.format_number(
phonenumbers.parse('+' + country_code + national_number,
None),
phonenumbers.PhoneNumberFormat.E164)
else:
national_number = local_number = str(
parse_number.national_number)
region_code = ''
country_code = str(parse_number.country_code)
number_type = carrier.number_type(parse_number)
is_valid = phonenumbers.is_valid_number(parse_number)
location = geocoder.description_for_number(parse_number, 'EN')
country = geocoder.country_name_for_number(parse_number, 'EN')
country_iata = region_code_for_number(parse_number)
tmpcarrier = carrier.name_for_valid_number(parse_number, 'EN')
is_posible = phonenumbers.is_possible_number(parse_number)
urbano = ''
linea = ''
mobile_code = ''
trunk_prefix = ''
dial_number = phonenumbers.format_number(
parse_number, phonenumbers.PhoneNumberFormat.E164)
if Country.objects.filter(code=country_code).exists():
country_object = Country.objects.filter(code=country_code)
if len(country_object) == 1:
country_object = country_object[0]
country = country_object.name
mobile_code = country_object.mobile_code
trunk_prefix = country_object.trunk_prefix
for i in range(1, 5):
sub = local_number[:i]
if AreaCode.objects.filter(country=country_object,
code=sub).exists():
ac = AreaCode.objects.get(
country=country_object, code=sub)
location = ac.name
local_number = local_number[i:]
region_code = ac.code
break
if country_code == '52' and is_valid:
parse_mx_number = format_mx_number(region_code,
local_number)
urbano = parse_mx_number['urban']
linea = parse_mx_number['line']
number_type = parse_mx_number['type']
if is_posible:
res = {
'is_valid': is_valid,
'location': location,
'country': country,
'country_iata': country_iata,
'carrier': tmpcarrier,
'type': number_type,
'dial_number': dial_number,
'urban': urbano,
'line': linea,
'is_posible': is_posible,
'ori_number': number,
'number_data': {
'CC':
country_code,
'NN':
national_number,
'AC':
region_code,
'LN':
local_number,
'MC':
mobile_code,
'IM':
True if number_type == 1 else
(True if location == 'Mobile' else False),
'TP':
trunk_prefix,
'IN':
dial_number.replace('+', '').strip()
}
}
else:
status_code = 400
res.update({'code': status_code, 'message': 'invalid number'})
else:
status_code = 400
res.update({
'code': status_code,
'message': 'some arguments missing'
})
else:
status_code = 405
res.update({
'code': status_code,
'message': 'illegal request method ' + str(request.method)
})
response = JsonResponse(res)
response.status_code = status_code
return response
def country_parser(y):
try:
return (pycountry.countries.get(
alpha2=region_code_for_number(y)).name)
except:
" "
def get_country_iso_code(phone_object):
return region_code_for_number(phone_object)
