def get_auth_signup_qcontext(self):
""" Shared helper returning the rendering context for signup and reset password.
Check Condition If Email not Exists, then Signup with Mobile.
"""
if request.params.items() and request.params['mobile']:
try:
carrier._is_mobile(
number_type(phonenumbers.parse(request.params['mobile'])))
except NumberParseException:
request.params['error'] = _("Please Enter Valid Mobile Number")
if request.params.items() and request.params['login']:
if not tools.single_email_re.match(request.params['login']):
request.params['error'] = _("Please Enter Valid Email")
if request.params.items(
) and request.params['mobile'] and request.params['login'] == '':
request.params['login'] = request.params['mobile']
qcontext = request.params.copy()
qcontext.update(self.get_auth_signup_config())
if qcontext.get('token'):
try:
# retrieve the user info (name, login or email) corresponding to a signup token
token_infos = request.env['res.partner'].sudo(
).signup_retrieve_info(qcontext.get('token'))
for k, v in token_infos.items():
qcontext.setdefault(k, v)
except:
qcontext['error'] = _("Invalid signup token")
qcontext['invalid_token'] = True
return qcontext
def action_check_valid_phone(self, country_id, mobile):
return_item = {'error': '', 'valid': True}
# check mobile
if not mobile or mobile is None:
return_item['valid'] = False
return_item['error'] = _('It is necessary to define a mobile')
# check_country_code
if country_id.id == 0:
return_item['valid'] = False
return_item['error'] = _('The prefix is NOT defined')
# check prefix in phone
if mobile:
if '+' in mobile:
return_item['valid'] = False
return_item['error'] = \
_('The prefix must NOT be defined in the mobile')
# phonenumbers
if return_item['valid']:
number_to_check = '+' + str(country_id.phone_code) + str(mobile)
number_to_check = '+%s%s' % (country_id.phone_code, mobile)
try:
return_is_mobile = carrier._is_mobile(
number_type(
phonenumbers.parse(number_to_check, country_id.code)))
if not return_is_mobile:
return_item['valid'] = False
return_item['error'] = _('The mobile is not valid')
except phonenumbers.NumberParseException:
return_item['valid'] = False
return_item['error'] = \
_('The phone is not valid (NumberParseException)')
# return
return return_item
def process_phone_step(message):
try:
chat_id = message.chat.id
user = user_dict[chat_id]
if message.contact:
number = message.contact.phone_number
else:
number = message.text
if not (carrier._is_mobile(number_type(parse(number)))):
raise Exception
if conn.exist_phone(user.phone_number):
raise PhoneExists
# Get last 10 characters
user.phone_number = f'8{number[-10:]}'
markup = types.ReplyKeyboardRemove(selective=False)
msg = bot.send_message(chat_id,
config.l10n[user.language]['name'],
reply_markup=markup)
bot.register_next_step_handler(msg, process_name_step)
except PhoneExists:
msg = bot.send_message(message.chat.id,
config.l10n[user.language]['number_exists'],
reply_markup=utils.gen_reply_markup([], 1,
False,
False))
bot.register_next_step_handler(msg, process_phone_step)
except Exception:
buttons = (config.l10n[user.language]['send_contact'], )
msg = bot.send_message(message.chat.id,
config.l10n[user.language]['number_invalid'],
reply_markup=utils.gen_reply_markup(
buttons, 1, False, True))
bot.register_next_step_handler(msg, process_phone_step)
def RegisterUser(Email,ISDCode,PhoneNo,FirstName,LastName):
status=False
msg=''
Email = str(Email).lower()
PhoneNo = ISDCode+PhoneNo
if carrier._is_mobile(number_type(phonenumbers.parse("+"+PhoneNo))):
try:
user = User.objects.get(username=PhoneNo,)
msg='Phone number already exits.'
except User.DoesNotExist:
try:
password=User.objects.make_random_password(length=6)
new_user = User.objects.create_user(PhoneNo, Email, password)
new_user.first_name = FirstName
new_user.last_name = LastName
new_user.save()
userProfile = UserProfile()
userProfile.User=new_user
userProfile.save()
status=True
msg='Sign Up Success. Please check your email for login credentials.'
except Exception as e:
print(e)
msg='An error occured. Please try later.'
else:
msg='Please use a valid Phone number.'
return {'isSuccess':status,'msg':msg}
def validate_phone(value):
try:
number = phonenumbers.parse('+' + str(value), None)
if not carrier._is_mobile(number_type(number)):
raise ValidationError
except:
raise ValidationError('Incorrect phone number')
def validate_phonenumber(self, field):
data = field.data
print("DATA: ", data)
if not data:
# Don't validate if nothing was provided
return field
try:
if not data.startswith('+'):
# Maybe they forgot this?
data = '+' + data
parsed = phonenumbers.parse(data)
except:
flash(
"Please ensure you prefix the phone number with your country code."
)
raise ValidationError("This is not a valid phone number")
user = User.query.filter_by(phonenumber=data).first()
if user and user.id != self.user.id:
raise ValidationError("Phone number already on record.")
if not phonenumbers.is_valid_number(parsed):
flash(
"Please ensure you prefix the phone number with your country code."
)
raise ValidationError("This is not a valid phone number")
if not carrier._is_mobile(phonenumberutil.number_type(parsed)):
raise ValidationError(
"This phone number doesn't look like a mobile phone number")
self.phonenumber_locale = phonenumbers.region_code_for_country_code(
parsed.country_code)
def onchange_mobile(self, cr, uid, ids, mobile, context=None):
value = {}
warning = {}
if mobile:
id_number = phonenumbers.parse(mobile, "ID")
if not carrier._is_mobile(number_type(id_number)):
warning = {
'title': ('Perhatian !'),
'message':
(('Masukkan nomor handphone dengan benar, misal: 0817989800'
)),
}
value['mobile'] = ''
else:
formatted_mobile = phonenumbers.format_number(
id_number, phonenumbers.PhoneNumberFormat.E164)
provider_mobile = eval(
repr(carrier.name_for_number(id_number, "en")))
value['mobile'] = formatted_mobile
value['mobile_provider'] = provider_mobile
return {
'warning': warning,
'value': value,
}
def post(self):
try:
mobile_number = request.get_json().get('mobile_number', '')
emulator_name = request.get_json().get('emulator_name', '')
message_body = request.get_json().get('message_body', '')
if mobile_number == '' or emulator_name == '' or message_body == '':
return make_response(
jsonify({
"status": "0",
"message": "Insufficient Parameters"
}), 422)
mobile_format_validation = carrier._is_mobile(
number_type(phonenumbers.parse(mobile_number)))
if not mobile_format_validation:
return make_response(
jsonify({
"status":
"0",
"message":
"Mobile number not in International Indian Format. Ex: +91 XXXXX XXXXX"
}), 400)
final_message = json.dumps({
"mobile_number": mobile_number,
"emulator_name": emulator_name,
"message_body": message_body
})
single_message_queue_name = configp.get('queue_name',
'single_message')
corr_id = Rabbit().msgproducer(single_message_queue_name,
final_message, emulator_name,
'send_only')
if corr_id:
return make_response(
jsonify({
"status": "1",
"message": "Singal received for sending message",
"corr_id": corr_id
}), 200)
else:
return make_response(
jsonify({
"status": "0",
"message": "Signal Failed",
"corr_id": 0
}), 400)
except Exception as e:
self.apilog.error("SGLog:" + str(e))
return make_response(
jsonify({
"status": "0",
"message": "Exception Occured. Check Logs"
}), 500)
def check_no(number):
value = False
try:
value = carrier._is_mobile(number_type(phonenumbers.parse(number)))
except:
value = False
finally:
return (value)
def phone_detector(input_value):
try:
if carrier._is_mobile(number_type(
phonenumbers.parse(input_value))) == True:
return input_value
else:
return None
except:
return None
def _validate_type_phone_number(self, value):
"""Enables validation for `phone_number` schema attribute.
:param field: field name.
:param value: field value.
"""
try:
return carrier._is_mobile(number_type(phonenumbers.parse(value)))
except:
return False
def validate_mobile(field, value, error):
#pattern = re.compile("^\+[0-9]+$")
#valid = bool(pattern.match(value))
a_mobile = carrier._is_mobile(number_type(phonenumbers.parse(value)))
if not a_mobile:
error(
field,
"This field should contain an international mobile number, e.g. +457543788853"
)
def subscribe():
"""
This is the function for handling subscription requests. It will error clearly if a new phone number wasn't passed
in when the page was requested.
:return: A tuple of an HTML page and an HTTP Status code.
"""
logging.info('subscribe page started.')
try:
form_response = request.form
subscriber_number = form_response['subscriber_number']
if not subscriber_number:
raise Exception('No subscriber number was passed in!')
logging.info('subscribe page checking subscriber_number is valid.')
# Checking if subscriber_number matches valid format: +18885554444
carrier._is_mobile(number_type(phonenumbers.parse(subscriber_number)))
logging.info(
'subscribe page got valid subscriber_number of {}.'.format(
subscriber_number))
# Try to subscribe the number.
topic_arn = 'arn:aws:sns:us-west-2:277012880214:BunAlert'
snsclient = boto3.client('sns', region_name='us-west-2')
logging.info('subscribe page made SNS client.')
subscribe_response = snsclient.subscribe(
TopicArn=topic_arn,
Protocol='sms',
Endpoint='{}'.format(subscriber_number))
logging.info('subscribe page subscribed the new subscriber_number.')
# If all's good, render the response page.
template = Environment(
loader=FileSystemLoader('html/')).get_template('subscribe.j2')
page = template.render(subscriber_number=subscriber_number)
logging.info('subscribe page returned.')
return page, 200
except Exception as e:
logging.info('subscribe page errored.')
page = 'Something went wrong! Exception: {}'.format(e)
logging.error(page)
return page, 400
def randomize(self):
fake_number, fake_number_no_prefix = randomize_local(prefix=self.prefix, header=self.header)
if 'False' in fake_number or 'False' in str(fake_number_no_prefix):
return False
counter = 0
while not carrier._is_mobile(number_type(phonenumbers.parse(fake_number))) and counter < 5:
fake_number, fake_number_no_prefix = randomize_local(prefix=self.prefix, header=self.header)
counter += 1
if counter == 5:
return 0
return fake_number, fake_number_no_prefix
def validate_phone(phone_number):
"""validate national phone number
http://stackoverflow.com/questions/16135069/python-validation-mobile-number
https://github.com/daviddrysdale/python-phonenumbers
:param phone_number:
"""
try:
return carrier._is_mobile(
number_type(phonenumbers.parse(phone_number)))
except Exception:
return False
def phone_number_validator(num):
# phone_regex = re.compile(r'^(?:\+?44)?[07]\d{9,13}$')
# if check_blank_fields(num) == False:
# if not re.match(num):
# return False
if carrier._is_mobile(number_type(phonenumbers.parse(num))):
return True
else:
e = 4
return messageBox.window(e)
def validate_phone(phone_number):
"""validate national phone number
http://stackoverflow.com/questions/16135069/python-validation-mobile-number
https://github.com/daviddrysdale/python-phonenumbers
:param phone_number:
"""
try:
return carrier._is_mobile(number_type(
phonenumbers.parse(phone_number))
)
except Exception:
return False
def FindPhoneNumber(self, metadata, Collector) -> None:
"""This function requires a metadata and collector for registering data"""
for phone in re.finditer(self.pattern, str(self.sourcecode)):
try:
if carrier._is_mobile(
number_type(phonenumbers.parse(phone.group(), None))):
config.debug("Phone Number Found: {}".format(
phone.group()))
self.PhoneNumbers.append(phone.group())
metadata.Phones.append(phone.group())
except phonenumbers.phonenumberutil.NumberParseException:
pass
set(self.PhoneNumbers)
Collector.PhoneNumbers += len(self.PhoneNumbers)
def phone_number(self, phone):
new_number = ""
for i in range(phone.__len__()):
if i == 0:
pass
else:
new_number = new_number + phone[i]
number = "+255" + new_number
if not carrier._is_mobile(number_type(phonenumbers.parse(number))):
toast("wrong number")
te = self.root.ids.user_phone
te.text = "start with 07 or 06"
return False
else:
return True
def phone_number_check_admin(self, phone):
new_number = ""
if phone != "":
for i in range(phone.__len__()):
if i == 0:
pass
else:
new_number = new_number + phone[i]
number = "+255" + new_number
if not carrier._is_mobile(number_type(phonenumbers.parse(number))):
toast("Please check your phone number!", 1)
return False
else:
return True
else:
toast("enter phone number!")
def validate_phonenumber(self, field):
data = field.data
try:
if not data.startswith("+"):
# Maybe they forgot this?
data = "+" + data
parsed = phonenumbers.parse(data)
except:
flash("Please ensure you prefix the phone number with your country code.")
raise ValidationError("This is not a valid phone number")
if not phonenumbers.is_valid_number(parsed):
flash("Please ensure you prefix the phone number with your country code.")
raise ValidationError("This is not a valid phone number")
if not carrier._is_mobile(phonenumberutil.number_type(parsed)):
raise ValidationError("This phone number doesn't look like a mobile phone number")
self.phonenumber_locale = phonenumbers.region_code_for_country_code(parsed.country_code)
def select_sub_issue(id):
subissues = SubIssue.query.filter_by(issue_id=id)
form = SubIssueForm()
form.subissue.query = subissues
form.subissue.choices = [(subissue.id, subissue.name)
for subissue in subissues]
if (form.subissue.data != "None"):
subissue = request.form['subissue']
subissue_id = form.subissue.data
print(subissue_id, subissue)
additional_info = form.additional_info.data
send_url = 'http://freegeoip.net/json'
r = requests.get(send_url)
j = json.loads(r.text)
lat = j['latitude']
lon = j['longitude']
location = str(lat) + "," + str(lon)
phone = form.phone.data
if (carrier._is_mobile(number_type(
phonenumbers.parse(phone)))) and phone != '':
query = Query(employee_id=current_user.id,
issue_id=id,
subissue_id=subissue_id,
additional_info=additional_info,
location=location,
phone=phone,
zip_code=j['zip_code'])
try:
db.session.add(query)
db.session.commit()
flash('You have successfully added a query')
except:
flash('Error: Query already exists.')
else:
flash('Please enter a valid contact number')
return redirect(url_for('home.select_sub_issue', id=id))
return redirect(url_for('home.list_user_issues'))
return render_template('home/selectsubissue.html',
subissues=subissues,
form=form,
title="Select Sub Issue")
def phone_number_check(self, phone):
new_number = ""
if phone != "":
for i in range(phone.__len__()):
if i == 0:
pass
else:
new_number = new_number + phone[i]
number = "+255" + new_number
if not carrier._is_mobile(number_type(phonenumbers.parse(number))):
toast("Please check your phone number!", 1)
return False
else:
self.phone_number = phone
thread = threading.Thread(target=self.Business(self.product_name, self.quantity, self.phone_number))
thread.start()
self.kill_phone()
return True
else:
toast("check your number")
def settings_addPhone():
if request.referrer is None:
return redirect(url_for('user_settings.settings_auth'))
form = UpdatePhoneForm()
if form.validate_on_submit():
number = form.country.data.split()[0] + str(form.phone.data)
try:
b = carrier._is_mobile(number_type(phonenumbers.parse(number)))
if b:
current_user.phone = number
db.session.commit()
return redirect(url_for('user_settings.settings_phone'))
else:
flash('Please enter a valid phone number.')
except NumberParseException:
flash('Please enter a valid phone number.')
return render_template('settings_addPhone.html', form=form)
def settings_addPhone(request):
if request.META.get('HTTP_REFERER') is None:
return redirect('settings_phone')
form = UpdatePhoneForm(request.POST or None)
if form.is_valid():
number = form.cleaned_data.get('country_code').split()[0] + \
str(form.cleaned_data.get('phone'))
try:
b = carrier._is_mobile(number_type(phonenumbers.parse(number)))
if b:
request.user.profile.country_code = form.cleaned_data.get(
'country_code')
request.user.profile.phone = form.cleaned_data.get('phone')
request.user.save()
return redirect('settings_phone')
else:
form.add_error(None, 'Please enter a valid phone number.')
except NumberParseException:
form.add_error(None, 'Please enter a valid phone number.')
context = {'form': form}
return render(request, 'settings_addPhone.html', context)
def host():
if request.method == "POST":
details = request.form
#getting details from teh form
Name = details['name']
Email = details['email']
Phone = details['phone']
#checking for validity of email and phone of host
number = "+91" + str(Phone)
v = carrier._is_mobile(number_type(phonenumbers.parse(number)))
is_valid = validate_email(Email, verify=True, check_mx=True)
print(v)
print(is_valid)
if v == True and is_valid == True:
try:
#inserting the host data into database
cur = mysql.connection.cursor()
cur.execute(
"INSERT INTO Host(Name, Email, Phone) VALUES(%s, %s, %s)",
(Name, Email, Phone))
mysql.connection.commit()
cur.close()
except Exception as e:
datax = "You have already checked in or database server is down! Please try again"
return render_template('log.html', datax=datax)
return render_template('success.html',
datax="Thanks for filling details")
else:
if v == False:
datax = "You entered a wrong phone number! Please try again"
return render_template('log.html', datax=datax)
else:
datax = "You entered a wrong email id! Please try again"
return render_template('log.html', datax=datax)
return render_template('host.html')
def validate_phonenumber(self, field):
data = field.data
try:
if not data.startswith('+'):
# Maybe they forgot this?
data = '+' + data
parsed = phonenumbers.parse(data)
except:
flash(
"Please ensure you prefix the phone number with your country code."
)
raise ValidationError("This is not a valid phone number")
if not phonenumbers.is_valid_number(parsed):
flash(
"Please ensure you prefix the phone number with your country code."
)
raise ValidationError("This is not a valid phone number")
if not carrier._is_mobile(phonenumberutil.number_type(parsed)):
raise ValidationError(
"This phone number doesn't look like a mobile phone number")
self.phonenumber_locale = phonenumbers.region_code_for_country_code(
parsed.country_code)
def validate_phonenumber(self, field):
data = field.data
print("DATA: ", data)
if not data:
# Don't validate if nothing was provided
return field
try:
if not data.startswith('+'):
# Maybe they forgot this?
data = '+' + data
parsed = phonenumbers.parse(data)
except:
flash("Please ensure you prefix the phone number with your country code.")
raise ValidationError("This is not a valid phone number")
user = User.query.filter_by(phonenumber=data).first()
if user and user.id != self.user.id:
raise ValidationError("Phone number already on record.")
if not phonenumbers.is_valid_number(parsed):
flash("Please ensure you prefix the phone number with your country code.")
raise ValidationError("This is not a valid phone number")
if not carrier._is_mobile(phonenumberutil.number_type(parsed)):
raise ValidationError("This phone number doesn't look like a mobile phone number")
self.phonenumber_locale = phonenumbers.region_code_for_country_code(parsed.country_code)
def check_value(self, value):
# NOTE: the phone number must be a valid international number
return carrier._is_mobile(number_type(parse(value)))
def check_in_window(e1, e2, e3, e4, e5,
e6): # This function start when check-in button is clicked
if e1.get() and e2.get() and e3.get() and e4.get() and e5.get() and e6.get(
): # If you forget to enter any one detail on home page it will display an error
cursor1 = connection.cursor()
s1 = e1.get()
s2 = e2.get()
formula = "select * from info where visitor_Email=%s"
cursor1.execute(formula, (s2, ))
fe = cursor1.fetchall()
flag = 1
#fe = cursor1.fetchall()
for i in fe:
nam = i[0]
eml = i[1]
if (s2 == eml):
if not i[7]:
flag = 2
break
nam1 = i[3]
em11 = i[4]
num1 = i[5]
chkin = i[6]
if flag == 2:
messagebox.showerror("Error", " You have already been checked-In")
else:
if (
validate_email(s2, verify=True)
): # This Function checks whether visitor email-id enter is correct or not
s3 = e3.get()
s3 = "+91" + s3 # Concate The number with +91
try:
carrier._is_mobile(
number_type(phonenumbers.parse(s3))
) # This Function checks whether the visitor Phone number enter is valid or not
s4 = e4.get()
s5 = e5.get()
if (
validate_email(s5, verify=True)
): # This Function checks whether host email-id enter is correct or not
s6 = e6.get()
s6 = "+91" + s6
try:
carrier._is_mobile(
number_type(phonenumbers.parse(s6))
) # This Function checks whether the host Phone number enter is valid or not
hemail(s1, s5, s3)
sms(s1, s3, s6)
sql2 = "INSERT INTO info(visitor_Name,visitor_Email,visitor_Number,host_Name,host_Email,host_Number) VALUES(%s,%s,%s,%s,%s,%s)"
var = (s1, s2, s3, s4, s5, s6)
cursor1.execute(sql2, (var))
connection.commit()
popup1()
except: # These errors are displayed when any details enter is wrong.
messagebox.showerror(
"Error", "Please enter correct Host Number!")
else:
messagebox.showerror(
"Error", "Please enter correct Host Email!")
except:
messagebox.showerror(
"Error", "Please enter correct visitor Number!")
else:
messagebox.showerror("Error",
"Please enter correct visitor email!")
else:
messagebox.showerror("Error", "Please fill the details")
def validate_tell_region(data):
number = data['phone']
verify=carrier._is_mobile(number_type(phonenumbers.parse(number, "KE")))
if False:
return {'error': 'phone number must be a valid international number'}
return None
def action_send_sms(self):
'''
This function opens a window to compose an sms, with the edi sale template message loaded by default
'''
self.ensure_one()
#fix
super(SaleOrder, self).action_generate_sale_order_link_tracker()
allow_send = True
if self.partner_id.id == 0:
allow_send = False
raise Warning("Es necesario definir un contacto")
if allow_send == True and self.partner_id.mobile == False:
allow_send = False
raise Warning("Es necesario definir un movil")
if allow_send == True and (
self.partner_id.mobile_code == False
or self.partner_id.mobile_code_res_country_id.id == 0):
allow_send = False
raise Warning("Es necesario prefijo de movil")
if allow_send == True:
if '+' in self.partner_id.mobile:
allow_send = False
raise Warning("El prefijo NO debe estar definido en el movil")
if allow_send == True:
number_to_check = '+' + str(self.partner_id.mobile_code) + str(
self.partner_id.mobile)
try:
return_is_mobile = carrier._is_mobile(
number_type(
phonenumbers.parse(
number_to_check,
self.partner_id.mobile_code_res_country_id.code)))
if return_is_mobile == False:
allow_send = False
raise Warning("El movil no es valido")
except phonenumbers.NumberParseException:
allow_send = False
raise Warning("El movil no es valido")
if allow_send == True and self.partner_id.opt_out == True:
allow_send = False
raise Warning("El cliente no acepta mensajes")
if allow_send == True:
ir_model_data = self.env['ir.model.data']
try:
sms_template_id = ir_model_data.get_object_reference(
'sms_arelux', 'sms_template_id_default_sale_order')[1]
except ValueError:
sms_template_id = False
try:
compose_form_id = ir_model_data.get_object_reference(
'mail', 'sms_compose_message_wizard_form')[1]
except ValueError:
compose_form_id = False
#default_sender
default_sender = 'Todocesped'
if self.ar_qt_activity_type == 'arelux':
default_sender = 'Arelux'
elif self.ar_qt_activity_type == 'evert':
default_sender = 'Evert'
ctx = dict()
ctx.update({
'default_model':
'sale.order',
'default_res_id':
self.ids[0],
'default_use_template':
True,
'default_sms_template_id':
sms_template_id,
'default_country_id':
self.partner_id.mobile_code_res_country_id.id,
'default_mobile':
self.partner_id.mobile,
'default_sender':
default_sender,
'custom_layout':
"sms_arelux.sms_template_data_notification_sms_sale_order"
})
return {
'type': 'ir.actions.act_window',
'view_type': 'form',
'view_mode': 'form',
'res_model': 'sms.compose.message',
'views': [(compose_form_id, 'form')],
'view_id': compose_form_id,
'target': 'new',
'context': ctx,
}
def validate_phone(phone_number):
try:
return carrier._is_mobile(number_type(phonenumbers.parse(phone_number)))
except Exception:
return False
def mobile_validation(number):
try:
return carrier._is_mobile(number_type(phonenumbers.parse(number)))
except Exception:
return False
