def validate_phone_number(self, value): """Tracker phone number validation.""" try: validate_international_phonenumber(value) except ValidationError: raise serializers.ValidationError('Phone number is not valid.') return value
def phone_validate(phone): try: validate_international_phonenumber(phone) except ValidationError as e: return 0 else: return 1
def form_valid(self, form): csv_string = u"first_name,last_name,number\n" + form.cleaned_data[ 'csv_data' ] data = [x for x in csv.DictReader(io.StringIO(csv_string))] bad_rows = list() for row in data: try: validate_international_phonenumber(row['number']) obj = Recipient.objects.get_or_create(number=row['number'])[0] obj.first_name = row['first_name'].strip() obj.last_name = row['last_name'].strip() obj.is_archived = False obj.full_clean() obj.save() except Exception: # catch bad rows and display to the user bad_rows.append(row) if bad_rows: messages.warning( self.request, "Uh oh, something went wrong with these imports!" ) context = {} context['form'] = CsvImport() context['bad_rows'] = bad_rows return TemplateResponse(self.request, self.template_name, context) else: messages.success(self.request, "Importing your data now...") return super(ImportRecipients, self).form_valid(form)
def form_valid(self, form): csv_string = u"first_name,last_name,number\n" + form.cleaned_data[ 'csv_data'] data = [x for x in csv.DictReader(io.StringIO(csv_string))] bad_rows = list() for row in data: try: validate_international_phonenumber(row['number']) obj = Recipient.objects.get_or_create(number=row['number'])[0] obj.first_name = row['first_name'].strip() obj.last_name = row['last_name'].strip() obj.is_archived = False obj.full_clean() obj.save() except Exception: # catch bad rows and display to the user bad_rows.append(row) if bad_rows: messages.warning( self.request, "Uh oh, something went wrong with these imports!") context = {} context['form'] = CsvImport() context['bad_rows'] = bad_rows return TemplateResponse(self.request, self.template_name, context) else: messages.success(self.request, "Importing your data now...") return super(ImportRecipients, self).form_valid(form)
def check_data(self): try: phone = "+" + self.request.GET.get('check') validate_international_phonenumber(phone) return super().check_data() except ValidationError as e: return { "code": "002", "error": str(e.message) }
def clean(self): cleaned_data = super().clean() form_email = cleaned_data.get("email") form_phone_number = cleaned_data.get("phone_number") try: contact_email = cleaned_data.get("contact") validate_email(contact_email) except ValidationError: contact_email = None try: contact_phone = cleaned_data.get("contact") validate_international_phonenumber(contact_phone) except ValidationError: contact_phone = None email = contact_email if not form_email else form_email phone_number = contact_phone if not form_phone_number else form_phone_number if not email and not phone_number: raise forms.ValidationError( "Please use a valid email address or phone number." ) self.cleaned_data["phone_number"] = phone_number self.cleaned_data["email"] = email return self.cleaned_data
def phone_number_validator(phone_number): if phone_number == '': raise ValidationError(_('You need to enter a phone number.')) try: validate_international_phonenumber(phone_number) except ValidationError: raise ValidationError(_('Phone number is invalid'))
def validate(self, attrs): validated_data = super(AfricastalkingIncomingMessageSerializer, self).validate(attrs) if "from" not in self.initial_data: raise serializers.ValidationError( "From telephone has to be provided") validate_international_phonenumber(self.initial_data["from"]) return validated_data
def check_iban_phone(ldap_entries) -> Iterable[str]: """Check if IBAN and phone number are valid (otherwise cloning will fail as well).""" validate_iban = IBANValidator() for dn, attrs in _iterate_people(ldap_entries): try: validate_iban(_get_val(attrs, 'qIBAN')) validate_international_phonenumber(_get_val(attrs, 'telephoneNumber')) except ValidationError as e: yield 'Phone or IBAN error for person {}: {}'.format(dn, e)
def import_onebody_csv(): base_url = settings.ONEBODY_BASE_URL user_email = settings.ONEBODY_USER_EMAIL key = settings.ONEBODY_API_KEY if not any([base_url, user_email, key]): logger.info('Onebody Sync Disabled') return resp = requests.get( base_url + '/people.csv', auth=(user_email, key), allow_redirects=False, ) resp.raise_for_status() csv_url = resp.headers['Location'] sleep(WAIT_TIME) # wait for csv to be generated tries = 0 max_tries = 10 while tries <= max_tries: try: csv_resp = requests.get( csv_url, auth=(user_email, key), ) csv_resp.raise_for_status() data = csv.DictReader(io.StringIO(csv_resp.text)) break except Exception: sleep(WAIT_TIME) if tries >= max_tries: logger.warning('Failed to get CSV from onebody') raise OnebodyException('Failed to get CSV from onebody') tries += 1 # we now have the good data, let's import it: grp, _ = RecipientGroup.objects.get_or_create( name='[onebody]', description='imported from onebody') for row in data: try: number = row['mobile_phone'] if not number.startswith('+'): number = '+' + number validate_international_phonenumber(number) prsn_obj = Recipient.objects.get_or_create(number=number)[0] prsn_obj.first_name = row['first_name'].strip() prsn_obj.last_name = row['last_name'].strip() prsn_obj.save() # add person to group grp.recipient_set.add(prsn_obj) except ValidationError: logger.warning('Failed to import - bad number: %s %s (%s)', row['first_name'], row['last_name'], number) except Exception: logging.exception('Failed to import %s %s (%s)', row['first_name'], row['last_name'], number)
def post(self, request, format=None, **kwargs): form = self.form_class(request.data) if not form.is_valid(): return Response( { 'messages': [{ 'type_': 'warning', 'text': 'That doesn\'t look right...' }], 'errors': {}, }, status=status.HTTP_400_BAD_REQUEST, ) csv_string = u"first_name,last_name,number\n" + form.cleaned_data[ 'csv_data'] data = [x for x in csv.DictReader(io.StringIO(csv_string))] bad_rows = list() for row in data: try: validate_international_phonenumber(row['number']) obj = Recipient.objects.get_or_create(number=row['number'])[0] obj.first_name = row['first_name'].strip() obj.last_name = row['last_name'].strip() obj.is_archived = False obj.full_clean() obj.save() except Exception: # catch bad rows and display to the user bad_rows.append( '{first_name},{last_name},{number}'.format(**row)) if bad_rows: msg_text = "Uh oh, something went wrong with these imports!\n\n" msg_text = msg_text + "\n".join(bad_rows) msg_text = msg_text + "\n\nTry inputting these failed items manually to see what went wrong." return Response( { 'messages': [{ 'type_': 'warning', 'text': msg_text }], 'errors': {}, }, status=status.HTTP_400_BAD_REQUEST, ) else: msg = { 'type_': 'info', 'text': 'Importing your data now...', } return Response({ 'messages': [msg], 'errors': {}, }, status=status.HTTP_200_OK)
def import_onebody_csv(): base_url = settings.ONEBODY_BASE_URL user_email = settings.ONEBODY_USER_EMAIL key = settings.ONEBODY_API_KEY if not any([base_url, user_email, key]): logger.info('Onebody Sync Disabled') return resp = requests.get( base_url + '/people.csv', auth=(user_email, key), allow_redirects=False, ) resp.raise_for_status() csv_url = resp.headers['Location'] sleep(WAIT_TIME) # wait for csv to be generated tries = 0 max_tries = 10 while tries <= max_tries: try: csv_resp = requests.get( csv_url, auth=(user_email, key), ) csv_resp.raise_for_status() data = csv.DictReader(io.StringIO(csv_resp.text)) break except Exception: sleep(WAIT_TIME) if tries >= max_tries: logger.warning('Failed to get CSV from onebody') raise OnebodyException('Failed to get CSV from onebody') tries += 1 # we now have the good data, let's import it: grp, _ = RecipientGroup.objects.get_or_create(name='[onebody]', description='imported from onebody') for row in data: try: number = row['mobile_phone'] if not number.startswith('+'): number = '+' + number validate_international_phonenumber(number) prsn_obj = Recipient.objects.get_or_create(number=number)[0] prsn_obj.first_name = row['first_name'].strip() prsn_obj.last_name = row['last_name'].strip() prsn_obj.save() # add person to group grp.recipient_set.add(prsn_obj) except ValidationError: logger.warning('Failed to import - bad number: %s %s (%s)', row['first_name'], row['last_name'], number) except Exception: logging.exception('Failed to import %s %s (%s)', row['first_name'], row['last_name'], number)
def post(self, request, format=None, **kwargs): form = self.form_class(request.data) if not form.is_valid(): return Response( { 'messages': [{ 'type_': 'warning', 'text': 'That doesn\'t look right...' }], 'errors': {}, }, status=status.HTTP_400_BAD_REQUEST, ) csv_string = u"first_name,last_name,number\n" + form.cleaned_data['csv_data'] data = [x for x in csv.DictReader(io.StringIO(csv_string))] bad_rows = list() for row in data: try: validate_international_phonenumber(row['number']) obj = Recipient.objects.get_or_create(number=row['number'])[0] obj.first_name = row['first_name'].strip() obj.last_name = row['last_name'].strip() obj.is_archived = False obj.full_clean() obj.save() except Exception: # catch bad rows and display to the user bad_rows.append('{first_name},{last_name},{number}'.format(**row)) if bad_rows: msg_text = "Uh oh, something went wrong with these imports!\n\n" msg_text = msg_text + "\n".join(bad_rows) msg_text = msg_text + "\n\nTry inputting these failed items manually to see what went wrong." return Response( { 'messages': [{ 'type_': 'warning', 'text': msg_text }], 'errors': {}, }, status=status.HTTP_400_BAD_REQUEST, ) else: msg = { 'type_': 'info', 'text': 'Importing your data now...', } return Response( { 'messages': [msg], 'errors': {}, }, status=status.HTTP_200_OK )
def __call__(self, phone_number): if phone_number: phone_number = str(phone_number).strip() if not phone_number.startswith("+"): phone_number = "+" + phone_number try: validate_international_phonenumber(phone_number) except ValidationError as error: logging.exception("{}-{}".format("VALIDATE PHONENUMBER", str(error))) else: return phone_number
def save(self, *args, **kwargs): if self.phone: try: validate_international_phonenumber(self.phone) except ValidationError as err: raise ValidationError(_( "Tried to create an organization with an invalid phone number (%(phone_number)s). Error message: %(error_message)s" ), code='invalid', params={ 'phone_number': self.phone, 'error_message': err.message }) super(Organization, self).save(*args, **kwargs)
def create_user(self, phone, full_name, password=None, **extra_fields): validate_international_phonenumber(phone) if not phone: raise ValueError("a phone number must be provided.") user = self.model(phone=phone, full_name=full_name, base32_key=generate_key(get_user_model()), **extra_fields) user.set_password(password) user.save(using=self._db) return user
def send(self): profile = None profile_qs = Profile.objects.filter(telephone=self.phonenumber) if profile_qs.exists(): profile = profile_qs.first() validate_international_phonenumber(self.phonenumber) # We dont want to send repetitive messages, mark such as processed and skip if self.check_last_sms_match(): self.mark_processed() return text = self.text if profile is not None and profile.language_code != Profile.SupportedLanguages.English: from .tasks import translate_text self.translated_text = translate_text("en", profile.language_code, text=self.text) self.save() text = self.translated_text data = None if settings.TELERIVET_PROJECT_ID and settings.TELERIVET_API_KEY: self.handler = Message.MessageProviders.Telerivet from .handlers import Telerivet data = Telerivet.send_sms(phonenumber=str(self.phonenumber), text=text) else: self.handler = Message.MessageProviders.Africastalking from .handlers import Africastalking data = Africastalking.send_sms(phonenumber=str(self.phonenumber), text=text) charge = AccountCharges.objects.create( profile=profile, cost=float(data["cost"]), currency_code=data["currency_code"], description="SMS {}".format(self.id)) self.charge = charge self.provider_id = data["provider_id"] self.handler = data["handler"] self.delivery_status = data["delivery_status"] self.save() self.mark_processed()
def import_recipients(request): """Display the CSV import form.""" context = {} if request.method == 'POST': form = CsvImport(request.POST) if form.is_valid(): csv_string = u"first_name,last_name,number\n" + form.cleaned_data[ 'csv_data' ] data = [x for x in csv.DictReader(io.StringIO(csv_string))] bad_rows = list() for row in data: try: validate_international_phonenumber(row['number']) obj = Recipient.objects.get_or_create( number=row['number'] )[0] obj.first_name = row['first_name'].strip() obj.last_name = row['last_name'].strip() obj.is_archived = False obj.full_clean() obj.save() except Exception: # catch bad rows and display to the user bad_rows.append(row) if bad_rows: messages.warning( request, "Uh oh, something went wrong with these imports!" ) context['form'] = CsvImport() context['bad_rows'] = bad_rows return render(request, "apostello/importer.html", context) else: messages.success(request, "Importing your data now...") return redirect('/') context['form'] = form return render(request, 'apostello/importer.html', context) else: context['form'] = CsvImport() return render(request, 'apostello/importer.html', context)
def import_recipients(request): """Display the CSV import form.""" context = {} if request.method == 'POST': form = CsvImport(request.POST) if form.is_valid(): csv_string = u"first_name,last_name,number\n" + form.cleaned_data[ 'csv_data'] data = [x for x in csv.DictReader(io.StringIO(csv_string))] bad_rows = list() for row in data: try: validate_international_phonenumber(row['number']) obj = Recipient.objects.get_or_create( number=row['number'])[0] obj.first_name = row['first_name'].strip() obj.last_name = row['last_name'].strip() obj.is_archived = False obj.full_clean() obj.save() except Exception: # catch bad rows and display to the user bad_rows.append(row) if bad_rows: messages.warning( request, "Uh oh, something went wrong with these imports!") context['form'] = CsvImport() context['bad_rows'] = bad_rows return render(request, "apostello/importer.html", context) else: messages.success(request, "Importing your data now...") return redirect('/') context['form'] = form return render(request, 'apostello/importer.html', context) else: context['form'] = CsvImport() return render(request, 'apostello/importer.html', context)
def by(self, target, backend_path): try: validator = EmailValidator() user = self.get_user_target(target) try: validator(target) mode = choices.MODE_EMAIL except ValidationError: validate_international_phonenumber(target) mode = choices.MODE_SMS twofactor, created = self.get_object(user, target, mode, backend_path) logger.info("code twofactor (%s): %s" % (target, twofactor.code), extra={'user': user, 'app': 'twofactor'}) if mode == choices.MODE_EMAIL: return self.send_email(twofactor, user, target) elif mode == choices.MODE_SMS: return self.send_sms(twofactor, user, target) except UserModel.DoesNotExist: pass except ValidationError: pass return False
def send_sms(phonenumber: str, text: str): validate_international_phonenumber(phonenumber) data = Telerivet.send_sms(phonenumber=phonenumber, text=text) \ if settings.TELERIVET_PROJECT_ID and settings.TELERIVET_API_KEY \ else Africastalking.send_sms(phonenumber=phonenumber, text=text) profile = Profile.objects.get(telephone=phonenumber) if Profile.objects.filter( telephone=phonenumber).exists() else None charge = AccountCharges.objects.create( profile=profile, cost=float(data["cost"]), currency_code=data["currency_code"], ) outgoing_sms = OutgoingMessages.objects.create( phonenumber=phonenumber, text=text, handler=data["handler"], delivery_status=data["delivery_status"], provider_id=data["provider_id"], charge=charge ) charge.description = outgoing_sms.summary charge.save() return outgoing_sms
def validate_phone_number(phone): phone = phone.replace(' ', '') phone = phone.replace('-', '') phone = phone.replace('(', '') phone = phone.replace(')', '') if not phone.isdigit(): raise ValidationError("Неправильный формат номера телефона.") try: if phone.startswith('7') and len(phone) == 11: validate_international_phonenumber('+%s' % phone) elif phone.startswith('8') and len(phone) == 11: validate_international_phonenumber('+7%s' % phone[1:]) elif phone.startswith('9') and len(phone) == 10: validate_international_phonenumber('+7%s' % phone) else: validate_international_phonenumber(phone) except ValidationError: raise ValidationError("Неправильный формат номера телефона.")
def _validate_phone_number(phone_number): try: validate_international_phonenumber(phone_number) except ValidationError: raise serializers.ValidationError( {'phone_number': 'Numer telefonu jest nieprawidłowy'})
def client_signup(request): parg = pageArgs() if request.method == "GET": if request.user.is_anonymous: return render(request, 'signup_client.html') else: parg.EDIT_PROFILE = True ulist = list(Client.objects.filter(default_user=request.user)) if len(ulist) > 0: if ulist[0].role != 'client': return HttpResponseForbidden() else: return HttpResponseForbidden() parg.USER_INFO = ulist[0] parg.PROFILE_ACTIVE = True return render(request, 'signup_client.html', parg.__dict__) elif request.method == 'POST': parg.ERROR = [] f_name = request.POST.get('first_name', None) if f_name is None or len(f_name) < 1: parg.ERROR.append('First name is not provided!') l_name = request.POST.get('last_name', None) if l_name is None or len(l_name) < 1: parg.ERROR.append('Last name is not provided!') password = request.POST.get('password', None) password_repeat = request.POST.get('password_repeat', None) if request.user.is_anonymous: email = request.POST.get('email', None) if email is None: parg.ERROR.append('Email address not provided!') elif User.objects.filter(email=email).count() > 0: parg.ERROR.append('Email address already exists') if password != password_repeat: parg.ERROR.append( "Password repeat should be equal to password!") if len(password) > 0 and not check_password_stregth(password): parg.ERROR.append( "Password is not strength enough! Should be at least 8 characters with a mix of uppercase, lowercase and numbers" ) phone_number = request.POST.get('phone', None) if phone_number is not None: try: phone_validator.validate_international_phonenumber( phone_number) except: parg.ERROR.append('Phone number is not valid!') else: email = request.user.email profile = None if request.FILES and request.FILES['profile']: profile = request.FILES['profile'] if len(parg.ERROR) > 0: return render(request, 'signup_client.html', parg.__dict__) user_profile = None if request.user.is_anonymous: try: user = User.objects.create_user(email, email, password) user.save() except Exception as e: parg.ERROR.append(str(e)) return render(request, 'signup_client.html', parg.__dict__) auth.authenticate(username=user.username, password=password_repeat) user_profile = Client() user_profile.role = 'client' user_profile.default_user = user else: ulist = list(Client.objects.filter(default_user=request.user)) if len(ulist) > 0: if ulist[0].role == 'client': user_profile = Client.objects.get( default_user=request.user) else: return HttpResponseForbidden() else: return HttpResponseForbidden() phone_number = user_profile.phone_number if len(password_repeat) >= 8: user_profile.default_user.set_password(password_repeat) user_profile.default_user.save() user_profile.default_user.first_name = f_name user_profile.default_user.last_name = l_name user_profile.default_user.save() user_profile.phone_number = phone_number if profile is not None: user_profile.profile_picture = profile user_profile.has_profile_picture = True user_profile.save() user_profile.create_thumbnail() user_profile.save() return redirect('login') else: return HttpResponseForbidden()
def validate(self, data): number = dict(data)['number'] validate_international_phonenumber(number) return number
def validate_phone(self, phone): if phone: return validate_international_phonenumber(phone) return ''
def validate_phone_number(self, value): try: validate_international_phonenumber(value) except ValidationError as error: raise error return value
def validate_phone(value): try: validate_international_phonenumber(value) except ValidationError: return "" return value if value else ""
def update_or_create_from_human(self, human): # Extract if isinstance(human, dict): mc_pk = human['id'] first_name = human['first_name'] middle_name = human['middle_name'] last_name = human['last_name'] nick_name = human['nick_name'] email = human['email'] birth_date = human['birth_date'] home_phone = human['home_phone'] cell_phone = human['cell_phone'] work_phone = human['work_phone'] bhs_id = human['bhs_id'] gender = human['gender'] part = human['part'] mon = human['mon'] is_deceased = human['is_deceased'] is_honorary = human['is_honorary'] is_suspended = human['is_suspended'] is_expelled = human['is_expelled'] else: mc_pk = str(human.id) first_name = human.first_name middle_name = human.middle_name last_name = human.last_name nick_name = human.nick_name email = human.email birth_date = human.birth_date home_phone = human.home_phone cell_phone = human.cell_phone work_phone = human.work_phone bhs_id = human.bhs_id gender = human.gender part = human.part mon = human.mon is_deceased = human.is_deceased is_honorary = human.is_honorary is_suspended = human.is_suspended is_expelled = human.is_expelled # Transform inactive = any([ is_deceased, is_honorary, is_suspended, is_expelled, ]) if inactive: status = self.model.STATUS.inactive else: status = self.model.STATUS.active prefix = first_name.rpartition('Dr.')[1].strip() first_name = first_name.rpartition('Dr.')[2].strip() last_name = last_name.partition('II')[0].strip() suffix = last_name.partition('II')[1].strip() last_name = last_name.partition('III')[0].strip() suffix = last_name.partition('III')[1].strip() last_name = last_name.partition('DDS')[0].strip() suffix = last_name.partition('DDS')[1].strip() last_name = last_name.partition('Sr')[0].strip() suffix = last_name.partition('Sr')[1].strip() last_name = last_name.partition('Jr')[0].strip() suffix = last_name.partition('Jr')[1].strip() last_name = last_name.partition('M.D.')[0].strip() suffix = last_name.partition('M.D.')[1].strip() if nick_name == first_name: nick_name = "" try: validate_international_phonenumber(home_phone) except ValidationError: home_phone = "" try: validate_international_phonenumber(cell_phone) except ValidationError: cell_phone = "" try: validate_international_phonenumber(work_phone) except ValidationError: work_phone = "" if gender: gender = getattr(self.model.GENDER, gender, None) else: gender = None if part: part = getattr(self.model.PART, part, None) else: part = None try: validate_international_phonenumber(home_phone) except ValidationError: home_phone = "" try: validate_international_phonenumber(cell_phone) except ValidationError: cell_phone = "" try: validate_international_phonenumber(work_phone) except ValidationError: work_phone = "" is_deceased = bool(is_deceased) defaults = { 'status': status, 'prefix': prefix, 'first_name': first_name, 'middle_name': middle_name, 'last_name': last_name, 'suffix': suffix, 'nick_name': nick_name, 'email': email, 'birth_date': birth_date, 'home_phone': home_phone, 'cell_phone': cell_phone, 'work_phone': work_phone, 'bhs_id': bhs_id, 'gender': gender, 'part': part, 'is_deceased': is_deceased, 'mon': mon, } # Update or create person, created = self.update_or_create( mc_pk=mc_pk, defaults=defaults, ) return person, created
def clean_phone(self): try: validate_international_phonenumber(self.cleaned_data['phone']) except ValidationError as err: raise forms.ValidationError(err) return self.cleaned_data['phone']
def validate_fax_phone(self, fax_phone): if fax_phone: return validate_international_phonenumber(fax_phone) return ''