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