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 ''
