def post(self, request, uuid=None):
client, administrative_note, client_notes = self.get_queryset(
uuid=uuid)
administrative_note_form = ClientAdministrativeNoteForm(
administrative_note.__dict__)
client_note_form = ClientNoteForm(self.request.POST or None)
if client_note_form.is_valid():
client_note = ClientNote()
client_note.client_note_title = client_note_form.cleaned_data[
'client_note_title']
client_note.client_note_body = client_note_form.cleaned_data[
'client_note_body']
client_note.client = client
client_note.created_by = self.request.user
client_note.last_modified_by = self.request.user
client_note.save()
ActivityStream(customer=self.request.user.customer,
actor=self.request.user.username,
verb='created_client_note',
action_object=client_note.uuid,
target=client_note.client.__str__()).save()
messages.success(request, 'Client updated succesfully')
return redirect('clients:client-detail', uuid=uuid)
messages.error(request, 'There was an error updating client')
context = {
'client': client,
'administrative_note': administrative_note,
'client_notes': client_notes,
'administrative_note_form': administrative_note_form,
'client_note_form': client_note_form,
}
return render(request, self.template_name, context)
def create_client_portal_credentials(self, requester: User):
if self.client_user_obj is None:
client_user_manager = UserManager()
password = client_user_manager.make_random_password()
client_user_obj = client_user_manager.create_user(
customer=requester.customer,
username=self.primary_email,
first_name="un_assigned"
if self.first_name is None else self.first_name,
last_name="un_assigned"
if self.first_name is None else self.first_name,
email=self.primary_email,
phone="un_assigned"
if self.first_name is None else self.first_name,
password=password,
is_client=True,
region_code=requester.region_code,
timezone=requester.timezone,
)
ActivityStream(customer=requester.customer,
actor=requester.username,
verb='created_client_portal_access_credentials',
action_object=self.__str__()).save()
self.client_user_obj = client_user_obj
self.save()
emailer.send_client_credential_email(self, password, requester)
def post(self, request, uuid=None):
client_note = get_object_or_404(ClientNote, uuid=uuid)
client = client_note.client
administrative_note = client.clientadministrativenote
client.check_if_user_has_permissions(Client.CAN_NOTES, request.user)
client_notes = client.clientnote_set
administrative_note_form = ClientAdministrativeNoteForm(
administrative_note.__dict__)
client_note_form = ClientNoteForm(self.request.POST or None)
if client_note_form.is_valid():
client_note.client_note_title = client_note_form.cleaned_data[
'client_note_title']
client_note.client_note_body = client_note_form.cleaned_data[
'client_note_body']
client_note.last_modified_by = self.request.user.username
client_note.save()
messages.success(request, 'Client note saved successfully')
ActivityStream(customer=self.request.user.customer,
actor=self.request.user.username,
verb='updated_note',
action_object=client_note.uuid,
target=client.__str__()).save()
return redirect('clients:client-detail', uuid=client.uuid)
messages.error(request, 'There was an error saving note')
context = {
'client': client,
'administrative_note': administrative_note,
'client_notes': client_notes,
'administrative_note_form': administrative_note_form,
'client_note_form': client_note_form,
}
return render(request, self.template_name, context)
def enable_client_portal(self, requester: User):
if self.client_user_obj is not None:
self.client_user_obj.is_active = True
self.client_user_obj.save()
ActivityStream(customer=requester.customer,
actor=requester.username,
verb='enabled_client_portal_access',
action_object=self.__str__()).save()
def revoke_client_portal(self, requester: User):
if self.client_user_obj is not None:
self.client_user_obj.is_active = False
self.client_user_obj.save()
ActivityStream(customer=requester.customer,
actor=requester.username,
verb='revoked_client_portal',
action_object=self.__str__()).save()
def form_valid(self, form):
"""If the form is valid, save the associated model."""
self.object = form.save()
messages.success(self.request, 'Template saved successfully')
ActivityStream(customer=self.request.user.customer,
actor=self.request.user.username,
verb='updated_email_template').save()
return super().form_valid(form)
def login_failed_do_stuff(sender, request, **kwargs):
ActivityStream(customer=Customer.objects.get(pk=1),
actor='unknown',
verb='login_failed' + request.META['HTTP_HOST'],
target=request.POST['username']).save()
user = User.objects.filter(username=request.POST['username'])
if user.exists():
user = user.first()
user.unsuccessful_login_attempts += 1
user.save()
if user.unsuccessful_login_attempts > 10:
ActivityStream(customer=user.customer,
actor='unknown',
verb='Login_fail_exceeded_10times_account_disabled',
target=user.username).save()
user.is_active = False
user.save()
def delete_client_note(self, request: HttpRequest):
self.client.check_if_user_has_permissions(self.client.CAN_DELETE,
request.user)
self.delete()
messages.success(request, 'Note deleted successfully')
ActivityStream(customer=request.user.customer,
actor=request.user.username,
verb='deleted_note',
action_object=self.uuid,
target=self.client.__str__()).save()
def post(self, request, username=None, *args, **kwargs):
user_obj = get_object_or_404(User, username=username)
if user_obj.is_owner:
raise PermissionDenied
if not request.user.is_owner:
raise PermissionDenied
user_obj.delete()
messages.success(request, 'Team member deleted successfully')
ActivityStream(customer=self.request.user.customer, actor=self.request.user.username,
verb='deleted_team_member', action_object=user_obj.username).save()
return redirect('team-list')
def post(self, request, uuid=None, *args, **kwargs):
appointment = self.get_queryset(uuid=uuid)
form = AppointmentUpdateForm(request.POST or None)
qs = User.objects.filter(Q(is_owner=True) | Q(is_team=True))
form.fields['assigned_to'].choices = [
(user.username, user.first_name + ' ' + user.last_name)
for user in qs.all()
]
if form.is_valid():
old_date = appointment.appointment_date
old_time = appointment.appointment_time
appointment.appointment_date = form.cleaned_data[
'appointment_date']
appointment.appointment_time = form.cleaned_data[
'appointment_time']
appointment.appointment_duration = form.cleaned_data[
'appointment_duration']
appointment.appointment_reason = form.cleaned_data[
'appointment_reason']
appointment.assigned_to = get_object_or_404(
User, username=form.cleaned_data['assigned_to'])
appointment.status_setter(form.cleaned_data['appointment_status'])
nieve_dt = datetime.combine(form.cleaned_data['appointment_date'],
form.cleaned_data['appointment_time'])
appointment_datetime_utc = make_aware(nieve_dt,
timezone=pytz.timezone(
request.user.timezone))
appointment.appointment_datetime_utc = appointment_datetime_utc
appointment.save()
messages.success(request, 'Appointment updated successfully')
ActivityStream(
customer=self.request.user.customer,
actor=self.request.user.username,
verb='modified_appointment',
action_object=appointment.get_human_readable_datetime(),
target=appointment.client.__str__()).save()
if old_time != form.cleaned_data[
'appointment_time'] or old_date != form.cleaned_data[
'appointment_date']:
if form.cleaned_data['send_reschedule_email']:
emailer.send_appointment_reschedule_email(
appointment, old_date, old_time, request.user)
return redirect('appointments:calendar-view')
messages.error(request, 'There was an error updating appointment')
context = {'form': form}
return render(request, self.template_name, context)
def get(self, request, uuid=None):
file_object = get_object_or_404(ClientFile.objects,
uuid=self.kwargs['uuid'])
file_object.client.check_if_user_has_permissions(
permission=Client.CAN_DELETE)
file_object.client.deny_permission_if_scheduler(request.user)
ActivityStream(customer=request.user.customer,
actor=request.user.username,
verb='downloaded_file',
action_object=file_object.file_name,
target=file_object.client).save()
media_storage = get_storage_class()()
return redirect(media_storage.url(file_object.file.__str__()))
def delete(self, request, *args, **kwargs):
"""
Call the delete() method on the fetched object and then redirect to the
success URL.
"""
self.object = self.get_object()
success_url = self.get_success_url()
self.object.delete()
messages.success(request, 'Client deleted successfully')
ActivityStream(customer=self.request.user.customer,
actor=self.request.user.username,
verb='deleted_client',
action_object=self.object).save()
return HttpResponseRedirect(success_url)
def post(self, request, uuid=None):
client = get_object_or_404(Client, uuid=uuid)
administrative_note_form = ClientAdministrativeNoteForm(request.POST)
if administrative_note_form.is_valid():
if administrative_note_form.cleaned_data.get(
'administrative_note_body') == '':
administrative_note = client.clientadministrativenote
administrative_note.administrative_note_body = ''
administrative_note.save()
messages.success(request,
'Administrative Note saved succesfully')
ActivityStream(
customer=self.request.user.customer,
actor=self.request.user.username,
verb='created_client_note',
action_object=administrative_note.uuid,
target=administrative_note.client.__str__()).save()
elif administrative_note_form.has_changed():
administrative_note = client.clientadministrativenote
administrative_note.administrative_note_body = administrative_note_form.cleaned_data.get(
'administrative_note_body')
administrative_note.save()
messages.success(request,
'Administrative Note saved succesfully')
ActivityStream(
customer=self.request.user.customer,
actor=self.request.user.username,
verb='created_client_note',
action_object=administrative_note.uuid,
target=administrative_note.client.__str__()).save()
else:
messages.error(
request, 'There was an error updating Administrative note')
return redirect('clients:client-detail', uuid=uuid)
def form_valid(self, form):
"""If the form is valid, save the associated model."""
client = Client(**form.cleaned_data)
client.created_by = self.request.user.username
client.last_modified_by = self.request.user.username
client.save()
messages.success(self.request, 'Client created successfully')
ActivityStream(customer=self.request.user.customer,
actor=self.request.user.username,
verb='created_client',
action_object=client).save()
client.set_permissions_to_team_after_creation()
if client.access_client_portal:
client.create_client_portal_credentials(
requester=self.request.user)
return redirect('clients:clients-list')
def post(self, request, uuid=None, *args, **kwargs):
client = get_object_or_404(Client, uuid=uuid)
if not request.user.has_perm(Client.CAN_VIEW, client):
raise PermissionDenied
form = AppointmentForm(request.POST or None)
qs = User.objects.filter(Q(is_owner=True) | Q(is_team=True))
form.fields['assigned_to'].choices = [
(user.username, user.first_name + ' ' + user.last_name)
for user in qs.all()
]
if form.is_valid():
appointment = Appointment()
appointment.client = client
appointment.appointment_date = form.cleaned_data[
'appointment_date']
appointment.appointment_time = form.cleaned_data[
'appointment_time']
appointment.appointment_duration = form.cleaned_data[
'appointment_duration']
appointment.appointment_reason = form.cleaned_data[
'appointment_reason']
appointment.assigned_to = get_object_or_404(
User, username=form.cleaned_data['assigned_to'])
appointment.set_aware_appointment_datetime_utc(
request.user.timezone)
if form.cleaned_data['send_confirmation_email']:
emailer.send_appointment_created_email(appointment,
request.user)
appointment.save()
messages.success(request, 'Appointment deleted successfully')
ActivityStream(
customer=self.request.user.customer,
actor=self.request.user.username,
verb='created_appointment',
action_object=appointment.get_human_readable_datetime(),
target=client.__str__()).save()
return redirect('clients:client-appointments', uuid=client.uuid)
messages.error(request, 'There was an error Creating appointment')
context = {'form': form}
return render(request, self.template_name, context)
def post(self, request, *args, **kwargs):
form = TeamRegisterForm(request.POST or None)
if form.is_valid():
if not request.user.is_owner:
raise PermissionDenied
user_manager = UserManager()
password = user_manager.make_random_password()
ph = parse(form.cleaned_data['phone'])
region_code = region_code_for_country_code(ph.country_code)
team_member = user_manager.create_user(
customer=request.user.customer,
username=form.cleaned_data['username'],
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
email=form.cleaned_data['email'],
phone=form.cleaned_data['phone'],
password=password,
is_team=True,
is_clinician=form.cleaned_data['is_clinician'],
is_scheduler=form.cleaned_data['is_scheduler'],
is_biller=form.cleaned_data['is_biller'],
region_code=region_code,
timezone=request.user.timezone,
)
messages.success(request, 'Team member created successfully')
ActivityStream(customer=self.request.user.customer, actor=self.request.user.username,
verb='created_team_member', action_object=team_member.username).save()
from clients.models import Client
clients = get_objects_for_user(request.user, Client.CAN_VIEW, Client)
for user in User.objects.filter(Q(is_owner=True) | Q(is_team=True)):
assign_perm(Client.CAN_VIEW, user, clients)
assign_perm(Client.CAN_EDIT, user, clients)
assign_perm(Client.CAN_DELETE, user, clients)
if user.is_clinician:
assign_perm(Client.CAN_NOTES, user, clients)
emailer.send_team_member_credential_email(team_member, password, self.request.user)
return redirect('team-list')
messages.error(request, 'There was an error creating Team member')
context = {'form': form}
return render(request, self.template, context)
def delete(self, request, *args, **kwargs):
"""
Call the delete() method on the fetched object and then redirect to the
success URL.
"""
self.object = self.get_object()
success_url = self.get_success_url()
from django.core.files.storage import default_storage
default_storage.delete(str(self.object.file))
self.object.delete()
messages.success(self.request, 'File deleted successfully')
# logic to delete file from s3
ActivityStream(customer=self.request.user.customer,
actor=self.request.user.username,
verb='deleted_file',
action_object=self.object.file_name,
target=self.object.client.__str__()).save()
return HttpResponseRedirect(success_url)
def delete(self, request, *args, **kwargs):
"""
Call the delete() method on the fetched object and then redirect to the
success URL.
"""
self.object = self.get_object()
success_url = self.get_success_url()
action_object = self.object.get_human_readable_datetime()
self.object.delete()
messages.success(request, 'Appointment deleted succesfully')
if self.request.POST.get('canceled_checkbox'):
emailer.send_appointment_canceled_email(self.object,
self.request.user)
ActivityStream(customer=self.request.user.customer,
actor=self.request.user.username,
verb='deleted_appointment',
action_object=action_object,
target=self.object.client.__str__()).save()
return HttpResponseRedirect(success_url)
def post(self, request):
form = RegisterForm(request.POST or None)
if form.is_valid():
formdata = form.cleaned_data.copy()
formdata.pop('password2')
formdata.pop('password')
tenant = Customer()
tenant.username = form.cleaned_data['username']
tenant.first_name = form.cleaned_data['first_name']
tenant.last_name = form.cleaned_data['last_name']
tenant.email = form.cleaned_data['email']
tenant.phone = form.cleaned_data['phone']
tenant.timezone = form.cleaned_data['timezone']
ph = parse(form.cleaned_data['phone'])
region_code = region_code_for_country_code(ph.country_code)
tenant.region_code = region_code
tenant.save()
print(tenant.__dict__)
user_manager = UserManager()
user_manager.create_user(
customer=tenant,
username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
password=form.cleaned_data['password'],
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
phone=form.cleaned_data['phone'],
is_owner=True,
is_clinician=True,
is_scheduler=True,
is_biller=True,
region_code=tenant.region_code,
timezone=tenant.timezone,
)
ActivityStream(customer=tenant,
actor=form.cleaned_data['username'],
verb='signed up').save()
return redirect('login') # to be changed later
context = {'form': form}
return render(request, self.template, context)
def post(self, request, uuid=None):
client = get_object_or_404(Client, uuid=uuid)
upload_form = ClientFileUploadForm(request.POST, request.FILES)
if upload_form.is_valid():
client.check_if_user_has_permissions(Client.CAN_VIEW,
self.request.user)
file_model = upload_form.save(commit=False)
file_model.client = client
file_model.uploaded_by = request.user
file_model.file_name = request.FILES['file'].name
file_model.save()
messages.success(self.request, 'File saved successfully')
ActivityStream(customer=self.request.user.customer,
actor=self.request.user.username,
verb='uploaded_file',
action_object=file_model.file_name,
target=client.__str__()).save()
return redirect('clients:client-detail', uuid=client.uuid)
from django.utils.html import strip_tags
if upload_form['file'].errors:
messages.error(request, strip_tags(upload_form['file'].errors))
return redirect('clients:client-detail', uuid=client.uuid)
def post(self, request, username=None, *args, **kwargs):
user_obj = get_object_or_404(User, username=username)
form = TeamMemberUpdateForm(request.POST or None, user_obj=user_obj)
if form.is_valid():
if user_obj.is_owner:
raise PermissionDenied
if not request.user.is_owner:
raise PermissionDenied
user_obj.first_name = form.cleaned_data['first_name']
user_obj.last_name = form.cleaned_data['last_name']
user_obj.email = form.cleaned_data['email']
user_obj.phone = form.cleaned_data['phone']
user_obj.is_clinician = form.cleaned_data['is_clinician']
user_obj.is_scheduler = form.cleaned_data['is_scheduler']
user_obj.is_biller = form.cleaned_data['is_biller']
user_obj.save()
messages.success(request, 'Team member updated successfully')
ActivityStream(customer=self.request.user.customer, actor=self.request.user.username,
verb='updated_team_member', action_object=user_obj.username).save()
return redirect('team-list')
messages.error(request, 'There was an error updating Team member')
context = {'form': form}
return render(request, self.template, context)
def login_do_stuff(sender, user, request, **kwargs):
ActivityStream(customer=user.customer,
actor=user.username,
verb='logged in').save()
user.unsuccessful_login_attempts = 0
user.save()
def logout_do_stuff(sender, user, request, **kwargs):
ActivityStream(customer=user.customer,
actor=user.username,
verb='logged out').save()