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 sortNA(CleanNumbers): # Find and sort North Am leads
NorthAm_DataFrame = False
num = pn.parse('+' + str(CleanNumbers), None)
CountryInitial = pn.region_code_for_number(num)
if CountryInitial in ['CA', 'TT', 'BS']: # Countries for North Am
NorthAm_DataFrame = True
return NorthAm_DataFrame
def sortIT(CleanNumbers): # Find and sort Italy leads
Italy_DataFrame = False
num = pn.parse('+' + str(CleanNumbers), None)
CountryInitial = pn.region_code_for_number(num)
if CountryInitial in ['IT']: # Sort Italy
Italy_DataFrame = True
return Italy_DataFrame
def sortES(CleanNumbers): # Find and sort Spain leads
Spain_DataFrame = False
num = pn.parse('+' + str(CleanNumbers), None)
CountryInitial = pn.region_code_for_number(num)
if CountryInitial in ['ES']: # Sort Spain
Spain_DataFrame = True
return Spain_DataFrame
def sortBR(CleanNumbers): # Find and sort Brazil leads
Brazil_DataFrame = False
num = pn.parse('+' + str(CleanNumbers), None)
CountryInitial = pn.region_code_for_number(num)
if CountryInitial in ['BR']: # Sort Brazil
Brazil_DataFrame = True
return Brazil_DataFrame
def sortOC(CleanNumbers): # Find and sort Oceania leads
Oceania_DataFrame = False
num = pn.parse('+' + str(CleanNumbers), None)
CountryInitial = pn.region_code_for_number(num)
if CountryInitial in ['NZ', 'AU']: # Countries for Oceania
Oceania_DataFrame = True
return Oceania_DataFrame
def country_name_for_number(numobj, lang, script=None, region=None):
"""Return the given PhoneNumber object's country name in the given language.
Arguments:
numobj -- The PhoneNumber object for which we want to get a text description.
lang -- A 2-letter lowercase ISO 639-1 language code for the language in
which the description should be returned (e.g. "en")
script -- A 4-letter titlecase (first letter uppercase, rest lowercase)
ISO script code as defined in ISO 15924, separated by an
underscore (e.g. "Hant")
region -- A 2-letter uppercase ISO 3166-1 country code (e.g. "GB")
The script and region parameters are currently ignored.
Returns a text description in the given language code, for the given phone
number's region, or an empty string if no description is available."""
number_region = region_code_for_number(numobj)
if number_region in LOCALE_DATA:
# The Locale data has a set of names for this region, in various languages.
name = LOCALE_DATA[number_region].get(lang, "")
if name.startswith('*'):
# If the location name is "*<other_lang>", this indicates that the
# name is held elsewhere, specifically in the [other_lang] entry
other_lang = name[1:]
name = LOCALE_DATA[number_region].get(other_lang, "")
return name
return u""
def get_device_info(self, phone_number, return_value="all_info"):
"""
:param phone_number: phone number
:param return_value:
: country_code: return Country Code of input phone number
: area_code: return Area Code of input phone number
: exchange: return Exchange of input phone number
: state_code: return State Code of input phone number
: time_zone: return Time Zone of input phone number
: all_info: return {dict} with all phone number info
:return: Country Code; Area Code; Exchange; State Code; Time Zone
"""
try:
number = self.normalize_device(phone_number)
pn = phonenumbers.parse(number)
pattern = re.compile(r'''(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$''', re.VERBOSE)
num = pattern.search(str(pn.national_number)).groups()
country_code = phonenumbers.region_code_for_number(pn)
area_code = num[0]
exchange = num[1]
state_code = self.get_area_code(num[0])
time_zone = str(phonenumbers.timezone.time_zones_for_number(pn))
for ch in ['(', ',', ')', "'"]:
time_zone = time_zone.replace(ch, '')
info = {"country_code": country_code, "area_code": area_code, "exchange": exchange,
"state_code": state_code, "timezone": time_zone} if "all_info" in return_value else country_code \
if "country_code" in return_value else area_code if "area_code" in return_value else exchange \
if "exchange" in return_value else state_code if "state_code" in return_value else time_zone \
if "timezone" in return_value else ""
return info
except Exception as e:
Exception("Unable get info of {0}: {1}".format(phone_number, e))
def sortAF(CleanNumbers): # Find and sort Africa leads
Africa_DataFrame = False
num = pn.parse('+' + str(CleanNumbers), None)
CountryInitial = pn.region_code_for_number(num)
if CountryInitial in ['MG', 'ZA']: # Countries for Africa
Africa_DataFrame = True
return Africa_DataFrame
def format_number(config,
phone_number,
trunk_int_dial_code=None,
trunk_country_code=None):
o = None
result = {CallerLookupLabel.IS_VALID: False}
region = trunk_country_code.upper() if trunk_country_code else None
int_dial_code = trunk_int_dial_code
try:
if region:
o = parse(phone_number, region)
else:
if int_dial_code is not None:
country_data = CallerLookupCountryCodes.get_country_data(
country_int_dial_code=int_dial_code)
for country in country_data:
region = country[CallerLookupLabel.COUNTRY_CODE].upper()
o = parse(phone_number, region)
if o is None:
o = parse(phone_number, UNKNOWN_REGION) if o is None else o
result[CallerLookupLabel.IS_VALID] = is_valid_number(o)
if result[CallerLookupLabel.IS_VALID]:
result[CallerLookupLabel.NUMBER_E164] = fmt_number(
o, PhoneNumberFormat.E164)
result[CallerLookupLabel.NUMBER_NATIONAL] = fmt_number(
o, PhoneNumberFormat.NATIONAL)
result[CallerLookupLabel.REGION] = region_code_for_number(o)
result[CallerLookupLabel.REGION_DIAL_CODE] = o.country_code
except Exception as ex:
log_debug(config, ["FORMAT_NUMBER_ERROR", str(ex), str(result)])
return result
def country(Number): # get phone number's country name
try:
num = pn.parse('+' + str(Number), None)
CountryInitial = pn.region_code_for_number(num) # Get Country Initials
return pyc.countries.get(
alpha_2=CountryInitial).name # Return Country Name
except:
pass
def sortGCC(CleanNumbers): # Find and sort GCC leads
GCC_DataFrame = False
num = pn.parse('+' + str(CleanNumbers), None)
CountryInitial = pn.region_code_for_number(num)
if CountryInitial in ['BH', 'KW', 'QA', 'SA', 'AE',
'LB']: # Countries for GCC
GCC_DataFrame = True
return GCC_DataFrame
def sortAsia(CleanNumbers): # Find and sort Asia leads
Asia_DataFrame = False
num = pn.parse('+' + str(CleanNumbers), None)
CountryInitial = pn.region_code_for_number(num)
if CountryInitial in ['HK', 'SG', 'ID', 'JP', 'MO', 'MY', 'KR',
'TW']: # Countries for Asia
Asia_DataFrame = True
return Asia_DataFrame
def tz_ids_for_phone(phone, country='US'):
""" Get the TZ identifiers that a phone number might be related to, e.g.
>>> tztrout.tz_ids_for_phone('+16503334444')
[u'America/Los_Angeles']
>>> tztrout.tz_ids_for_phone('+49 (0)711 400 40990')
[u'Europe/Berlin', u'Europe/Busingen']
"""
from phonenumbers.geocoder import description_for_number
try:
phone = phonenumbers.parse(phone, country)
except:
pass
else:
country_iso = phonenumbers.region_code_for_number(phone)
if not country_iso:
country_iso = phonenumbers.region_code_for_country_code(
phone.country_code)
if country_iso == 'US':
# check if we have a specific exception for a given area code first
exception_key = 'areacode:%s' % str(phone.national_number)[:3]
if exception_key in data_exceptions:
return data_exceptions[exception_key]['include']
state = city = None
area = description_for_number(phone, 'en').split(',')
if len(area) == 2:
city = area[0].strip()
state = area[1].strip()
elif len(area) == 1 and area[0]:
state = area[0].lower().strip()
state = td.normalized_states['US'].get(state, None)
return tz_ids_for_address(country_iso, state=state, city=city)
elif country_iso == 'CA':
area_code = str(phone.national_number)[:3]
state = td.ca_area_code_to_state.get(area_code)
return td.ca_state_to_tz_ids.get(state)
elif country_iso == 'AU':
area_code = str(phone.national_number)[:2]
state = td.au_area_code_to_state.get(area_code)
# Some Australian number prefixes (e.g. 04) are country-wide - fall
# back to all the AU tz ids
if state:
return td.au_state_to_tz_ids.get(state)
return pytz.country_timezones.get(country_iso)
elif country_iso:
return pytz.country_timezones.get(country_iso)
return []
def from_tel(phone: str) -> Optional[str]:
"""
Given a phone number in E164 returns the two letter country code for it. ex: +250788383383 -> RW
"""
try:
parsed = phonenumbers.parse(phone)
return phonenumbers.region_code_for_number(parsed)
except Exception:
return None
def add_lead(request):
if request.method == 'POST':
print(request.POST)
time_zone = "None"
country = "None"
name = request.POST.get('name')
phone = request.POST.get('phone')
try:
if phonenumbers.is_valid_number(phone):
p = phonenumbers.parse(phone)
time_zone = timezone.time_zones_for_number(p)
country = phonenumbers.region_code_for_number(p)
except (AttributeError, ValueError, Exception):
pass
email = request.POST.get('email')
created_date = request.POST.get('created_date')
status = request.POST.get('status')
if request.POST.get('manager') is not None:
manager_id = request.POST.get('manager')
else:
manager_id = request.user.id
lead = models.Lead(name=name,
phone=phone,
email=email,
country=country,
time_zone=time_zone,
created_date=created_date,
status=status,
manager=models.User.objects.get(id=manager_id))
lead.save()
manager = None
if lead.manager:
manager = lead.manager.username
content = {
'id': lead.pk,
'name': lead.name,
'email': lead.email,
'depozit': lead.depozit,
'phone': lead.phone,
'country': lead.country,
'created_date': models.json_serial(lead.created_date),
'status': lead.status,
'manager': manager,
'type': "data.new",
}
response_data = {
'result': 'Lead create successful',
'flag': 'new',
'content': content
}
return HttpResponse(json.dumps(response_data),
content_type="application/json")
else:
return HttpResponse(json.dumps(
{"nothing to see": "this isn't happening"}),
content_type="application/json")
def tz_ids_for_phone(phone, country='US'):
""" Get the TZ identifiers that a phone number might be related to, e.g.
>>> tztrout.tz_ids_for_phone('+16503334444')
[u'America/Los_Angeles']
>>> tztrout.tz_ids_for_phone('+49 (0)711 400 40990')
[u'Europe/Berlin', u'Europe/Busingen']
"""
from phonenumbers.geocoder import description_for_number
try:
phone = phonenumbers.parse(phone, country)
except:
pass
else:
country_iso = phonenumbers.region_code_for_number(phone)
if not country_iso:
country_iso = phonenumbers.region_code_for_country_code(phone.country_code)
if country_iso == 'US':
# check if we have a specific exception for a given area code first
exception_key = 'areacode:%s' % str(phone.national_number)[:3]
if exception_key in data_exceptions:
return data_exceptions[exception_key]['include']
state = city = None
area = description_for_number(phone, 'en').split(',')
if len(area) == 2:
city = area[0].strip()
state = area[1].strip()
elif len(area) == 1 and area[0]:
state = area[0].lower().strip()
state = td.normalized_states['US'].get(state, None)
return tz_ids_for_address(country_iso, state=state, city=city)
elif country_iso == 'CA':
area_code = str(phone.national_number)[:3]
state = td.ca_area_code_to_state.get(area_code)
return td.ca_state_to_tz_ids.get(state)
elif country_iso == 'AU':
area_code = str(phone.national_number)[:2]
state = td.au_area_code_to_state.get(area_code)
# Some Australian number prefixes (e.g. 04) are country-wide - fall
# back to all the AU tz ids
if state:
return td.au_state_to_tz_ids.get(state)
return pytz.country_timezones.get(country_iso)
elif country_iso:
return pytz.country_timezones.get(country_iso)
return []
def do_transform(self, request, response, config):
phone = request.entity
# Formats the string for the parser to understand the phone number
number = ""
if phone.countrycode:
number += "+" + phone.countrycode + " "
if phone.citycode:
number += citycode
if phone.areacode:
number += phone.areacode
number += phone.lastnumbers
try:
parsed = phonenumbers.parse(number)
except phonenumbers.NumberParseException as e:
# The phone number couldn't be parsed
return response
# Gets the country from the country code (if any)
country_code = phonenumbers.region_code_for_number(parsed)
# It may be the country, city, or any string that defines a geographical area
location_str = str(description_for_number(parsed, "en"))
phone_type = self.phonetype_lookup[phonenumbers.number_type(parsed)]
# Returns the result in english (we don't care, as it's just the carrier's name)
carrier_name = carrier.name_for_number(parsed, "en")
valid_number = phonenumbers.is_valid_number(parsed)
# Creates the entities to be added to the graph
if not valid_number:
# Adds a phrase warning about the invalid phone
response += ents.Phrase(text="Possibly invalid number",
link_color=LinkColor.Red,
link_thickness=3)
# Phrase with the carrier info
if carrier_name:
response += ents.Phrase("Carrier: " + carrier_name)
# Phrase with the phone type
if phone_type and phone_type.lower() != "unknown":
response += ents.Phrase("Phone type: " + phone_type)
# Location
if location_str or country_code:
response += self.extract_location(location_str, country_code)
return response
def sortEU(CleanNumbers): # Find and sort Europe leads
Europe_DataFrame = False
num = pn.parse('+' + str(CleanNumbers), None)
CountryInitial = pn.region_code_for_number(num)
if CountryInitial in [
'LU', 'LI', 'IE', 'IS', 'NL', 'NO', 'PL', 'SE', 'CH', 'GB', 'DK',
'FI', 'DE', 'BG', 'HR', 'CY', 'EE', 'GR', 'HU', 'IM', 'LT', 'MT',
'MC', 'RO', 'CZ', 'PT'
]: # Countries for Europe
Europe_DataFrame = True
return Europe_DataFrame
def get_number_country(number, default_country):
"""Retrieves the country code for a given number. If no international
prefix was found, uses the specified "default_country"."""
country = default_country
try:
p = phonenumbers.parse(number, default_country.upper())
country = phonenumbers.region_code_for_number(p)
except phonenumbers.NumberParseException:
pass
return country.lower()
def format_phonenumber(number, region):
"""
Format a phonenumber for dialing from the specified region.
Regions can be: "US", "JP", "FR", ...
"""
region = region.upper()
n = phonenumbers.parse(number, region)
if phonenumbers.region_code_for_number(n) == region:
formatting = phonenumbers.PhoneNumberFormat.NATIONAL
else:
formatting = phonenumbers.PhoneNumberFormat.INTERNATIONAL
return phonenumbers.format_number(n, formatting)
def process_message(message):
app.log.debug(message)
message_timestamp = timezone('UTC').localize(
datetime.strptime(message['message-timestamp'], '%Y-%m-%d %H:%M:%S'))
try:
sent_to = phonenumbers.parse('+' + message['to'])
cc = phonenumbers.region_code_for_number(sent_to)
except phonenumbers.phonenumberutil.NumberParseException:
sender_info = message['to']
cc = "UNKNOWN"
m = user.send_message(
title="{} (To: {}/+{})".format(message['msisdn'], cc, message['to']),
message="<b>{}: </b>{}".format(cc, html.escape(message['text'])),
html=True,
timestamp=message_timestamp)
return True
def geolocate_phone_number(number, my_country_code, lang):
import phonenumbers
import phonenumbers.geocoder # Takes an enormous amount of time...
res = ''
phonenum = phonenumbers.parse(number, my_country_code.upper())
city = phonenumbers.geocoder.description_for_number(phonenum, lang.lower())
country_code = phonenumbers.region_code_for_number(phonenum)
# We don't display the country name when it's my own country
if country_code == my_country_code.upper():
if city:
res = city
else:
# Convert country code to country name
country = phonenumbers.geocoder._region_display_name(
country_code, lang.lower())
if country and city:
res = country + ' ' + city
elif country and not city:
res = country
return res
def geolocate_phone_number(number, my_country_code, lang):
import phonenumbers
import phonenumbers.geocoder
res = ''
phonenum = phonenumbers.parse(number, my_country_code.upper())
city = phonenumbers.geocoder.description_for_number(phonenum, lang.lower())
country_code = phonenumbers.region_code_for_number(phonenum)
# We don't display the country name when it's my own country
if country_code == my_country_code.upper():
if city:
res = city
else:
# Convert country code to country name
country = phonenumbers.geocoder._region_display_name(
country_code, lang.lower())
if country and city:
res = country + ' ' + city
elif country and not city:
res = country
return res
def add_import(request):
if request.method == "POST":
response_data = {}
reader = csv.reader(
request.FILES['file_field'].read().decode('utf-8').splitlines())
for row in reader:
name = "None"
email = "None"
country = "None"
time_zone = "None"
if int(request.POST.get('name_field')) != 0:
name = row[int(request.POST.get('name_field')) - 1]
if int(request.POST.get('email_field')) != 0:
email = row[int(request.POST.get('email_field')) - 1]
if int(request.POST.get('notes_field')) != 0:
notes = row[int(request.POST.get('notes_field')) - 1]
if int(request.POST.get('agreements_field')) != 0:
agreements = row[int(request.POST.get('agreements_field')) - 1]
phone = ''.join(
filter(str.isdigit,
row[int(request.POST.get('phone_field')) - 1]))
try:
if phonenumbers.is_valid_number(phone):
p = phonenumbers.parse(phone)
time_zone = timezone.time_zones_for_number(p)
country = phonenumbers.region_code_for_number(p)
except (AttributeError, ValueError, Exception):
pass
lead = models.Lead(name=name,
email=email,
phone=phone,
country=country,
time_zone=time_zone)
lead.save()
response_data = {'result': 'Lead create successful', 'flag': 'new'}
return HttpResponse(json.dumps(response_data),
content_type="application/json")
else:
return HttpResponse(json.dumps(
{"nothing to see": "this isn't happening"}),
content_type="application/json")
def _parse_single_number_single_locale(phone_number, locale, language=DEFAULT_LANGUAGE):
'''
Tries to parse number.
Raises:
NumberParseException if the string is not a potentially viable number
ValueError if the string was for a potentially viable number that is not valid
'''
number = phonenumbers.parse(phone_number, locale)
if not phonenumbers.is_valid_number(number):
raise ValueError("not a valid number")
number_details = {}
number_details['raw_input'] = phone_number
number_details['E164'] = phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.E164)
number_details['assumed_local_locale'] = locale
number_details['region'] = phonenumbers.region_code_for_number(number)
number_details['country'] = geocoder.country_name_for_number(number, language)
number_details['description'] = geocoder.description_for_number(number, language)
number_details['carrier'] = carrier.safe_display_name(number, language)
number_details['comment'] = ""
return number_details
def get_country_code_from_phone(phone_number: str) -> str:
phone_number = phonenumbers.parse(phone_number)
return region_code_for_number(phone_number)
def send(user_details, text_body):
print('Found send')
account = nano.get_address(user_details.id + 1, str(wallet_seed))
components = text_body.split(" ")
previous = nano.get_previous(str(account))
balance = int(nano.get_balance(previous))
# Check amount is real
try:
print("Sending: ",
Decimal(components[1]) * 1000000000000000000000000000000)
amount = int(Decimal(components[1]) * 1000000000000000000000000000000)
print('Amount to send: ', amount)
authcode = int(components[3])
except:
resp = MessagingResponse()
resp.message(
"Error: Incorrect Amount please use the following format\nsend 10 +1234567890 1001"
)
return str(resp)
print('Error with send')
destination = components[2]
destination = destination.replace("\u202d", "")
destination = destination.replace("\u202c", "")
authcode = int(components[3])
#Test Number validity
regex = "(\d{3}[-\.\s]??\d{3}[-\.\s]??\d{4}|\(\d{3}\)\s*\d{3}[-\.\s]??\d{4}|\d{3}[-\.\s]??\d{4})"
if re.search(regex, destination):
valid_num = "Yes"
else:
valid_num = "No"
print(f'Destination: {destination}\nValid Number: {valid_num}')
if authcode == int(user_details.authcode):
print('Authcode valid!')
if amount > balance:
print("Insufficient balance", "\nAmount to send: ",
str(amount), "\nBalance: ",
str(balance / 1000000000000000000000000000000))
resp = MessagingResponse()
resp.message(f'Insufficient balance!\nYour Balance: {balance}')
return resp
#Send to xrb address
if destination[:4] == "xrb_":
print("Destination is xrb addresses format")
nano.send_xrb(destination, amount, account, user_details.id + 1,
str(wallet_seed))
resp = MessagingResponse()
new_authcode = authcode_gen_save(user_details)
previous = nano.get_previous(str(account))
balance = int(nano.get_balance(previous))/\
1000000000000000000000000000000
resp.message(
f'Sent to {destination}!\nYour Balance approx.: {balance}\nNew Authcode: {new_authcode}'
)
return resp
#Send to Alias
if valid_num == "No":
print("Sending request to alias address ", destination)
dest_user_details = Alias.get_or_none(alias=destination)
if dest_user_details is not None:
print(dest_user_details)
dest_address = dest_user_details.address
alias = dest_user_details.alias
dest_phone = dest_user_details.phonenumber
print(f'Sending to {dest_address} \nAlias: , {alias}')
nano.send_xrb(dest_address, amount, account,
user_details.id + 1, str(wallet_seed))
new_authcode = authcode_gen_save(user_details)
previous = nano.get_previous(str(account))
balance = int(nano.get_balance(previous)) / \
1000000000000000000000000000000
resp = MessagingResponse()
resp.message(
f'Sent to {destination}!\nYour Balance approx.: {balance}\nNew Authcode: {new_authcode}'
)
return resp
bodysend = 'You have recieved nano!\nPlease send register or balance to open your block on the Nano Network'
twilionum = Config().get("twilionum")
print(f'Sending: {bodysend}'
f' to {dest_phone} from {twilionum}')
message = client.messages.create(from_=twilionum,
body=bodysend,
to=dest_phone)
print(message.sid)
else:
print("Alias not found ", destination)
resp = MessagingResponse()
resp.message(
f'Error! Unrecognized Alias\nSet an alias with - set alias myAlias'
)
return resp
#send to phonenumber
else:
try:
phonenum = phonenumbers.parse(destination,
user_details.country)
dest_phone = phonenumbers.format_number(
phonenum, phonenumbers.PhoneNumberFormat.E164)
print('Destination is phonenumber: ', dest_phone)
except phonenumbers.phonenumberutil.NumberParseException:
print("Error")
resp = MessagingResponse()
resp.message(
"Error: Incorrect destination address/number try using E164 format"
)
return resp
if not phonenumbers.is_possible_number(phonenum):
resp = MessagingResponse()
resp.message("Error: Incorrect destination")
return resp
dest_user_details = User.get_or_none(phonenumber=dest_phone)
print('\nReciepient ID: ', dest_user_details)
#Send to phonenumber, and register if not registered.
dest_user_details = User.get_or_none(phonenumber=dest_phone)
if dest_user_details is None:
dest_authcode = random.SystemRandom().randint(1000, 9999)
rec_word = ''.join(
random.sample(open("english.txt").read().split(), 5))
x = phonenumbers.parse(dest_phone, None)
region = phonenumbers.region_code_for_number(x)
print("Destination region: ", region)
dest_user_details = User.create(phonenumber=dest_phone,
country=region,
time=datetime.now(),
count=1,
authcode=dest_authcode,
claim_last=0,
rec_word=rec_word)
print("User created", dest_phone)
dest_user_details = User.get_or_none(phonenumber=dest_phone)
dest_address = nano.get_address(dest_user_details.id + 1,
str(wallet_seed))
print("Sending to: " + dest_address)
nano.send_xrb(dest_address, amount, account, user_details.id + 1,
str(wallet_seed))
previous = nano.get_previous(str(account))
balance = int(nano.get_balance(previous))/ \
1000000000000000000000000000000
bodysend = 'You have recieved nano!\nPlease send register or balance to open your block on the Nano Network'
twilionum = Config().get("twilionum")
print(f'Sending: {bodysend}' f' to {dest_phone} from {twilionum}')
message = client.messages.create(from_=twilionum,
body=bodysend,
to=dest_phone)
print(message.sid)
resp = MessagingResponse()
new_authcode = authcode_gen_save(user_details)
resp.message(
f'Sent to {destination}!\nYour Balance approx.: {balance} \nNew Authcode: {new_authcode}'
)
return resp
else:
print('Invalid authcode! \nAuthcode submitted: ', authcode)
new_authcode = authcode_gen_save(user_details)
print('Authcode required: ', new_authcode)
resp = MessagingResponse()
resp.message("Error: Incorrect Auth Code try: " + str(new_authcode))
return resp
async def on_message(self, message):
# don't respond to ourselves
if message.author == self.user:
return
"""
-help
"""
if message.content.startswith("-ping"):
await message.delete()
await message.channel.send('Pong! {0}'.format(round(
bot.latency, 1)))
if message.author == bot.user:
return
if message.content.startswith('-help'):
await message.delete()
embed = discord.Embed(
title="Help Commands!",
description="HI! I'm Loco coins bot :wink:\n\n" +
"**User:**\n" + message.author.mention,
color=0xFF00FF)
embed.set_author(
name="Loco Coins",
icon_url=
"https://lh3.googleusercontent.com/X6YnhAu9xcb3qQ89mDHdDtJzb9Dyf2DytQTQRvLP8CloXhygKuicDyMsMmrK6S1uD1yY"
)
embed.set_thumbnail(
url=
"https://cdn.discordapp.com/attachments/587736810332094467/587980733558292483/unnamed.png"
)
embed.add_field(
name="To Get Some Loco Coins By Loco Practice Type.",
value="**-loco** +91`<your_loco_number>`",
inline=False)
embed.add_field(name="For Verify Loco Account",
value="**-code** `<you_received_otp>`",
inline=False)
embed.set_footer(text=f"Made with ♥ by MR.GENIUS KING#0001", \
icon_url="https://cdn.discordapp.com/attachments/626463527301021735/639093471382077440/images_1.jpeg")
await message.channel.send(embed=embed)
return
"""
-play <phone_number>
"""
if message.author == bot.user:
return
if message.content.startswith('-loco'):
await message.delete()
if BOT_OWNER_ROLE not in [
role.name for role in message.author.roles
]:
lol = discord.Embed(
title="**Lol You Not Have **Access** role to use this bot",
description="**User:**\n" + message.author.mention,
color=0x142c9c)
#lol.set_thumbnail(url=message.author.avatar_url)
lol.set_footer(text=f"Made with ♥ by MR.GENIUS KING#0001", \
icon_url="https://cdn.discordapp.com/attachments/626463527301021735/639093471382077440/images_1.jpeg")
await message.channel.send(embed=lol)
return
# parse phone number
try:
phone = message.content.split()[1]
pp = phonenumbers.parse(phone)
country_abbrev = phonenumbers.region_code_for_number(
pp).lower()
national_number = str(pp.national_number)
except:
worng = discord.Embed(
title="worng use:",
description="**Usage:\n-loco +91**`<your_loco_number>`\n" +
message.author.mention,
color=0x0000FF)
worng.set_footer(text=f"Made with ♥ by MR.GENIUS KING#0001", \
icon_url="https://cdn.discordapp.com/attachments/626463527301021735/639093471382077440/images_1.jpeg")
await message.channel.send(embed=worng)
return
# requesting sms code to user phone from Loco
res = loco_functions.get_sms_code_from_Loco(country_abbrev=country_abbrev,\
national_number=national_number)
if res is None:
await message.channel.send(embed=CANT_SEND_VERIF_CODE_MSG)
return
if message.author == bot.user:
return
em = discord.Embed(title="Check Your phone!",
description="**User:**\n" +
message.author.mention,
color=0x00FFCC)
em.set_author(
name="Loco Coins",
icon_url=
"https://lh3.googleusercontent.com/X6YnhAu9xcb3qQ89mDHdDtJzb9Dyf2DytQTQRvLP8CloXhygKuicDyMsMmrK6S1uD1yY"
)
em.set_thumbnail(
url=
"https://cdn.discordapp.com/attachments/587736810332094467/587980733558292483/unnamed.png"
)
em.add_field(name="verification code is sent!",
value="**-code** `<you_received_otp>`",
inline=False)
em.set_footer(
text=f"Made with ♥ by MR.GENIUS KING#0001",
icon_url=
f"https://cdn.discordapp.com/attachments/626463527301021735/639093471382077440/images_1.jpeg"
)
await message.channel.send(embed=em)
wait = discord.Embed(title="**User:**",
description=message.author.mention,
color=0x142c9c)
play_answer = await message.channel.send(embed=wait)
try:
def is_correct_sms_code(m):
if m.author != message.author:
return False
m = re.match(r'-code ([\d]{4})', m.content)
if m is None:
return False
global sms_code
sms_code = m.group(1)
return True
# if message.content.startswith('-verifyloco'):
# await message.delete()
await self.wait_for('message', check=is_correct_sms_code,\
timeout=60.0)
except asyncio.TimeoutError:
return await play_answer.edit(content=\
play_answer.content)
# await play_answer.edit(embed=em)
# await play_answer.edit(content=SENT_VERIF_CODE_MSG+WAITING_MSG)
profile_token = loco_functions.authorize(
country_abbrev=country_abbrev,
national_number=national_number,
sms_code=sms_code)
if profile_token is None:
CANT_AUTH_MSG = discord.Embed(
title="User:"******"all games play !",
value="**try after 1day .**\n**Please try again.**")
CANT_AUTH_MSG.set_author(
name="Loco Coins",
icon_url=
"https://lh3.googleusercontent.com/X6YnhAu9xcb3qQ89mDHdDtJzb9Dyf2DytQTQRvLP8CloXhygKuicDyMsMmrK6S1uD1yY"
)
CANT_AUTH_MSG.set_thumbnail(
url=
"https://cdn.discordapp.com/attachments/587736810332094467/587980733558292483/unnamed.png"
)
CANT_AUTH_MSG.set_footer(
text=f"Made with ♥ by MR.GENIUS KING#0001",
icon_url=
"https://cdn.discordapp.com/attachments/626463527301021735/639093471382077440/images_1.jpeg"
)
await message.channel.send(embed=CANT_AUTH_MSG)
# await play_answer.edit(content=CANT_AUTH_MSG)
return
try:
for res in loco_functions.main_play_loop(
country_abbrev=country_abbrev,
national_number=national_number,
profile_token=profile_token):
if 'error' in res.keys():
PRACTICE_ERR_MSG = discord.Embed(
title="User:"******"Something went wrong!",
value="**Try Again Later.**")
PRACTICE_ERR_MSG.set_author(
name="Loco Coins",
icon_url=
"https://lh3.googleusercontent.com/X6YnhAu9xcb3qQ89mDHdDtJzb9Dyf2DytQTQRvLP8CloXhygKuicDyMsMmrK6S1uD1yY"
)
PRACTICE_ERR_MSG.set_thumbnail(
url=
"https://cdn.discordapp.com/attachments/587736810332094467/587980733558292483/unnamed.png"
)
PRACTICE_ERR_MSG.set_footer(text=f"Made with ♥ by MR.GENIUS KING#0001", \
icon_url="https://cdn.discordapp.com/attachments/626463527301021735/639093471382077440/images_1.jpeg")
await message.channel.send(embed=PRACTICE_ERR_MSG)
# await play_answer.edit(content=PRACTICE_ERR_MSG)
return
# practice_msg = discord.Embed(title="Game status",description="", color=0xFF0099)
practice_msg1 = Template(
PRACTICE_STATUS_TEMPLATE1).substitute(res)
# practice_msg2 = Template(PRACTICE_STATUS_TEMPLATE2).substitute(res)
# practice_msg3 = Template(PRACTICE_STATUS_TEMPLATE3).substitute(res)
practice_msg4 = Template(
PRACTICE_STATUS_TEMPLATE4).substitute(res)
practice_msg5 = Template(
PRACTICE_STATUS_TEMPLATE5).substitute(res)
emm = discord.Embed(title=practice_msg4,
description=practice_msg5,
color=0xFF00FF)
emm.set_thumbnail(
url=
"https://cdn.discordapp.com/attachments/587736810332094467/587980733558292483/unnamed.png"
)
# emm.add_field(name=practice_msg4)
emm.add_field(name="Game Stats:", value=practice_msg1)
# emm.add_field(name="Questions Answered:",value=practice_msg2)
# emm.add_field(name="Game Played:",value=practice_msg3)
emm.set_footer(text=f"Request By:- "+str(message.author), \
icon_url=message.author.avatar_url)
await play_answer.edit(embed=emm)
# await message.edit(embed=emm)
# await message.channel.send(content=practice_msg)
# await play_answer.edit(content=practice_msg)
except:
message = await play_answer.edit(
content=play_answer.practice_msg)
# await message.channel.send(()+"\n{0.author.mention}".format(message))
return
else:
await play_answer.edit(content=play_answer.content)
al = discord.Embed(title="All games are played!",
description="**User**\n" +
message.author.mention,
color=0xFF0066)
al.add_field(name="Game Stats:", value=practice_msg1)
al.set_footer(text=f"Made with ♥ by MR.GENIUS KING#0001", \
icon_url="https://cdn.discordapp.com/attachments/626463527301021735/639093471382077440/images_1.jpeg")
await message.channel.send(embed=al)
return
if message.content.startswith('-verifycode'):
await message.delete()
def get_iso3(self):
self.phonenumber_details['iso3'] = dicts.country_iso2to3.get(phonenumbers.region_code_for_number(phonenumbers.parse(self.get_E164format(self.phonenumber))))
return self.phonenumber_details['iso3']
def get_iso3(self):
self.phonenumber_details['iso3'] = dicts.country_iso2to3.get(
phonenumbers.region_code_for_number(
phonenumbers.parse(self.get_E164format(self.phonenumber))))
return self.phonenumber_details['iso3']
def get_iso2(self):
self.phonenumber_details['iso2'] = phonenumbers.region_code_for_number(
phonenumbers.parse(self.get_E164format(self.phonenumber)))
return self.phonenumber_details['iso2']
def send(event, context):
idp_pool_id = get_mandatory_evar('COGNITO_IDP_POOL_ID')
idp_pool_client_id = get_mandatory_evar('COGNITO_IDP_POOL_CLIENT_ID')
log.debug("Event %s", event)
if 'body' not in event:
return {'statusCode': BAD_REQUEST, 'body': {'reason': "body"}}
try:
single_event = json.loads(event['body'])
except TypeError:
log.info("Failed loading body type=%s", type(event['body']))
if isinstance(event['body'], dict):
single_event = event['body']
else:
return {
'statusCode': BAD_REQUEST,
'body': {
'reason': 'Bad Body: \"%s\"' % event.get('body')
}
}
original_phone_number = single_event.get('phonenumber')
if not original_phone_number:
return {
'statusCode': BAD_REQUEST,
'body': {
'reason': "missing phonenumber"
}
}
phone_object = user_phone_to_object(original_phone_number)
if not phone_object:
# TODO: Base country code off the country code of calling country, agent-terminal-id, key, length?
phone_object = user_phone_to_object(original_phone_number, region='MX')
if not phone_object:
return {
'statusCode':
BAD_REQUEST,
'headers':
headers,
'body':
json.dumps({
"reason":
"Bad phonenumber: \"%s\"" % (original_phone_number),
})
}
phone_number = phonenumbers.format_number(
phone_object, phonenumbers.PhoneNumberFormat.E164)
#TODO: test the phone number:
# https://stackoverflow.com/a/23299989/1257603
# Also as an efficiency and performance measure: post to a queue and
# do a bunch of messages at once
auth_key = os.environ.get('PARAM_STORE_PRESHARED_KEY')
log.debug("Retrieved Key: %s", auth_key)
if not auth_key:
return {
'statusCode': INTERNAL_SERVER_ERROR,
'body': {
'reason': 'must set preshared key'
}
}
api_path = os.environ.get('api_path', 'ops-alpha/telco/outbound')
posting_path = "https://api.athenabitcoin.net/%s" % api_path
# Querying the user info before sending the code so that we can reduce the delay between sms code and user creation.
user_info = get_userinfo_by_phone(phone_number)
rand_code = random.randint(100000, 999999)
for lang in ['language', 'lang']:
if lang in single_event:
break
default_lang_code = 'en' #provided in swagger
lang_code = single_event.get(lang)
countrycode = phonenumbers.region_code_for_number(phone_object)
if not lang_code:
if countrycode in ('MX', 'CO', 'AR'):
lang_code = 'es'
else:
lang_code = default_lang_code
if lang_code == 'en':
msg = 'Your code is: %s' % rand_code
elif lang_code == 'es':
msg = 'Voy a enviarte un código: %s' % rand_code
else:
log.warn("Bad Language code, %s, defaulting to %s", lang_code,
default_lang_code)
data = {
'phone_to': phone_number,
'message': msg,
'country': countrycode,
'method': 'sms'
}
log.debug("Posting to data: %s to %s. Time Remaining: %s", data,
posting_path, context.get_remaining_time_in_millis())
try:
z = requests.post(posting_path,
headers={'Authorization': auth_key},
json=data,
timeout=(context.get_remaining_time_in_millis() *
.95 / 1000))
except TimeoutException, te:
return {
'statusCode': GATEWAY_TIMEOUT,
'body': {
'reason': 'Unexpected delay in processing'
}
}
def get_iso2(self):
self.phonenumber_details['iso2'] = phonenumbers.region_code_for_number(phonenumbers.parse(self.get_E164format(self.phonenumber)))
return self.phonenumber_details['iso2']
def send_sms(self, to, content, reference, multi=True, sender=None):
matched = False
for match in phonenumbers.PhoneNumberMatcher(to, "US"):
matched = True
to = phonenumbers.format_number(
match.number, phonenumbers.PhoneNumberFormat.E164)
client = self._client
# See documentation
# https://docs.aws.amazon.com/sns/latest/dg/sms_publish-to-phone.html#sms_publish_sdk
attributes = {
"AWS.SNS.SMS.SMSType": {
"DataType": "String",
"StringValue": "Transactional",
}
}
# If sending with a long code number, we need to use another AWS region
# and specify the phone number we want to use as the origination number
send_with_dedicated_phone_number = self._send_with_dedicated_phone_number(
sender)
if send_with_dedicated_phone_number:
client = self._long_codes_client
attributes["AWS.MM.SMS.OriginationNumber"] = {
"DataType": "String",
"StringValue": sender,
}
# If the number is US based, we must use a US Toll Free number to send the message
country = phonenumbers.region_code_for_number(match.number)
if country == "US":
client = self._long_codes_client
attributes["AWS.MM.SMS.OriginationNumber"] = {
"DataType":
"String",
"StringValue":
self.current_app.config["AWS_US_TOLL_FREE_NUMBER"],
}
try:
start_time = monotonic()
response = client.publish(PhoneNumber=to,
Message=content,
MessageAttributes=attributes)
except botocore.exceptions.ClientError as e:
self.statsd_client.incr("clients.sns.error")
raise str(e)
except Exception as e:
self.statsd_client.incr("clients.sns.error")
raise str(e)
finally:
elapsed_time = monotonic() - start_time
self.current_app.logger.info(
"AWS SNS request finished in {}".format(elapsed_time))
self.statsd_client.timing("clients.sns.request-time",
elapsed_time)
self.statsd_client.incr("clients.sns.success")
return response["MessageId"]
if not matched:
self.statsd_client.incr("clients.sns.error")
self.current_app.logger.error(
"No valid numbers found in {}".format(to))
raise ValueError("No valid numbers found for SMS delivery")
def clean_phone(self):
phone = self.cleaned_data['phone']
if region_code_for_number(phone) != 'RU':
raise forms.ValidationError(u'Неверный код страны')
return phone
