def _send_email(self): from rdrf.services.io.notifications.email_notification import process_notification from rdrf.events.events import EventType from registry.patients.models import Patient from registry.patients.models import ParentGuardian patient = Patient.objects.get(id=self.patient_id) try: parent = ParentGuardian.objects.get(patient=patient) participant_name = "%s %s" % (parent.first_name, parent.last_name) except ParentGuardian.DoesNotExist: participant_name = "No parent" patient_name = "%s %s" % (patient.given_names, patient.family_name) if self.clinician_other.speciality: speciality = self.clinician_other.speciality.name else: speciality = "Unspecified" template_data = { "speciality": speciality, "clinician_last_name": self.clinician_other.clinician_last_name, "participant_name": participant_name, "clinician_email": self.clinician_other.clinician_email, "patient_name": patient_name, "registration_link": self._construct_registration_link() } process_notification(self.registry.code, EventType.CLINICIAN_SIGNUP_REQUEST, template_data)
def send_participant_notification(registry_model, clinician_user, patient_model, diagnosis): from rdrf.services.io.notifications.email_notification import process_notification from rdrf.events.events import EventType from registry.patients.models import ParentGuardian if diagnosis is None: return participants = [ pg for pg in ParentGuardian.objects.filter(patient=patient_model) ] if len(participants) > 0: participant = participants[0] else: raise Exception("No participant associated with patient") patient_name = "%s %s" % (patient_model.given_names, patient_model.family_name) template_data = { "participant_email": participant.user.email, "diagnosis": diagnosis, "patient_name": patient_name, "clinician_name": clinician_user.last_name, } process_notification(registry_model.code, EventType.PARTICIPANT_CLINICIAN_NOTIFICATION, template_data)
def send(self): if self.state == SurveyRequestStates.REQUESTED: try: self._send_proms_request() except PromsRequestError as pre: logger.error("Error sending survey request %s: %s" % (self.pk, pre)) self._set_error(pre) return False if (self.communication_type == 'email'): try: # As we don't know how friendly the message needs to be, admin can pick the name format. template_data = { "display_name": f"{self.patient.given_names} {self.patient.family_name}", "combined_name": self.patient.combined_name, "given_names": self.patient.given_names, "family_name": self.patient.family_name, "patient_email": self.patient.email, "email_link": self.email_link, "registry_name": self.registry.name, "survey_name": self.survey_name } process_notification(self.registry.code, EventType.SURVEY_REQUEST, template_data) return True except PromsEmailError as pe: logger.error("Error emailing survey request %s: %s" % (self.pk, pe)) self._set_error(pe) return False
def user_activated_callback(sender, user, request, **kwargs): from rdrf.services.io.notifications.email_notification import process_notification from rdrf.events.events import EventType from registry.patients.models import Patient from registry.patients.models import ParentGuardian parent = patient = None email_notification_description = EventType.ACCOUNT_VERIFIED template_data = {} if user.is_patient: patient = Patient.objects.get(user=user) elif user.is_parent: # is the user is a parent they will have created 1 patient (only?) parent = ParentGuardian.objects.get(user=user) patients = [p for p in parent.patient.all()] if len(patients) >= 1: patient = patients[0] if patient: template_data["patient"] = patient if parent: template_data["parent"] = parent template_data["user"] = user for registry_model in user.registry.all(): registry_code = registry_model.code process_notification(registry_code, email_notification_description, template_data)
def process(self): registry_code = self.request.POST['registry_code'] registry = self._get_registry_object(registry_code) preferred_language = self.request.POST.get("preferred_language", "en") if self.clinician_signup: logger.debug("signing up clinician") self._do_clinician_signup(registry) return user = self._create_django_user(self.request, self.user, registry, is_parent=True) user.preferred_language = preferred_language # Initially UNALLOCATED working_group, status = WorkingGroup.objects.get_or_create( name=self._UNALLOCATED_GROUP, registry=registry) user.working_groups = [working_group] user.save() logger.debug("AngelmanRegistration process - created user") patient = Patient.objects.create( consent=True, family_name=self.request.POST["surname"], given_names=self.request.POST["first_name"], date_of_birth=self.request.POST["date_of_birth"], sex=self.request.POST["gender"]) patient.rdrf_registry.add(registry) patient.working_groups.add(working_group) patient.home_phone = self.request.POST["phone_number"] patient.email = user.username patient.user = None patient.save() logger.debug("AngelmanRegistration process - created patient") address = self._create_patient_address(patient, self.request) address.save() logger.debug("AngelmanRegistration process - created patient address") parent_guardian = self._create_parent(self.request) parent_guardian.patient.add(patient) parent_guardian.user = user parent_guardian.save() logger.debug("AngelmanRegistration process - created parent") template_data = { "patient": patient, "parent": parent_guardian, "registration": RegistrationProfile.objects.get(user=user) } process_notification(registry_code, EventType.NEW_PATIENT, template_data) logger.debug( "AngelmanRegistration process - sent notification for NEW_PATIENT")
def _send_email_notification(self, user, days_left): template_data = { 'user': user, 'days_left': days_left, } for registry_model in user.registry.all(): process_notification(registry_model.code, EventType.PASSWORD_EXPIRY_WARNING, template_data)
def account_lockout_handler(sender, user=None, **kwargs): from rdrf.services.io.notifications.email_notification import process_notification template_data = { "user": user, } for registry_model in user.registry.all(): process_notification(registry_model.code, EventType.ACCOUNT_LOCKED, template_data)
def notify_participant_on_verification(self, diagnosis=""): from registry.patients.models import Patient patient = Patient.objects.get(id=self.patient_id) participants = self._get_participants(patient) event_type = EventType.PARTICIPANT_CLINICIAN_NOTIFICATION template_data = { "diagnosis": diagnosis, "clinician_name": self.clinican_other.clinician_name, "participants": participants, "patient_name": "%s" % patient, } from rdrf.services.io.notifications.email_notification import process_notification process_notification(self.registry.code, event_type, template_data)
def _do_clinician_signup(self, registry_model): from rdrf.helpers.utils import get_site user = self._create_django_user(self.request, self.user, registry_model, is_parent=False, is_clinician=True) logger.debug("created django user for clinician") # working group should be the working group of the patient patient = Patient.objects.get(id=self.clinician_signup.patient_id) user.working_groups = [wg for wg in patient.working_groups.all()] user.save() logger.debug("set clinician working groups to patient's") self.clinician_signup.clinician_other.user = user self.clinician_signup.clinician_other.use_other = False self.clinician_signup.clinician_other.save() self.clinician_signup.state = "signed-up" # at this stage the user is created but not active self.clinician_signup.save() patient.clinician = user patient.save() logger.debug("made this clinician the clinician of the patient") site_url = get_site() activation_template_data = { "site_url": site_url, "clinician_email": self.clinician_signup.clinician_email, "clinician_lastname": self.clinician_signup.clinician_other.clinician_last_name, "registration": RegistrationProfile.objects.get(user=user) } process_notification(registry_model.code, EventType.CLINICIAN_ACTIVATION, activation_template_data) logger.debug( "AngelmanRegistration process - sent activation link for registered clinician" )