363 lines
14 KiB
Python
363 lines
14 KiB
Python
"""
|
|
Survey Celery tasks
|
|
|
|
This module contains tasks for:
|
|
- Creating and sending surveys
|
|
- Sending survey reminders
|
|
- Processing survey responses
|
|
- Triggering actions based on negative feedback
|
|
"""
|
|
import logging
|
|
|
|
from celery import shared_task
|
|
from django.db import transaction
|
|
from django.utils import timezone
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
@shared_task(bind=True, max_retries=3)
|
|
def create_and_send_survey(self, stage_instance_id):
|
|
"""
|
|
Create survey instance and send invitation.
|
|
|
|
This task is triggered when a journey stage completes
|
|
and auto_send_survey=True.
|
|
|
|
Args:
|
|
stage_instance_id: UUID of PatientJourneyStageInstance
|
|
|
|
Returns:
|
|
dict: Result with survey_instance_id and delivery status
|
|
"""
|
|
from apps.core.services import create_audit_log
|
|
from apps.journeys.models import PatientJourneyStageInstance
|
|
from apps.notifications.services import NotificationService
|
|
from apps.surveys.models import SurveyInstance
|
|
|
|
try:
|
|
# Get stage instance
|
|
stage_instance = PatientJourneyStageInstance.objects.select_related(
|
|
'stage_template__survey_template',
|
|
'journey_instance__patient',
|
|
'journey_instance__hospital'
|
|
).get(id=stage_instance_id)
|
|
|
|
# Verify survey template exists
|
|
if not stage_instance.stage_template.survey_template:
|
|
logger.warning(f"No survey template for stage {stage_instance.stage_template.name}")
|
|
return {'status': 'skipped', 'reason': 'no_survey_template'}
|
|
|
|
# Check if survey already created
|
|
if stage_instance.survey_instance:
|
|
logger.info(f"Survey already exists for stage instance {stage_instance_id}")
|
|
return {'status': 'skipped', 'reason': 'already_exists'}
|
|
|
|
patient = stage_instance.journey_instance.patient
|
|
|
|
# Determine delivery channel and recipient
|
|
delivery_channel = 'sms' # Default
|
|
recipient_phone = patient.phone
|
|
recipient_email = patient.email
|
|
|
|
# Create survey instance
|
|
with transaction.atomic():
|
|
survey_instance = SurveyInstance.objects.create(
|
|
survey_template=stage_instance.stage_template.survey_template,
|
|
patient=patient,
|
|
journey_instance=stage_instance.journey_instance,
|
|
journey_stage_instance=stage_instance,
|
|
encounter_id=stage_instance.journey_instance.encounter_id,
|
|
delivery_channel=delivery_channel,
|
|
recipient_phone=recipient_phone,
|
|
recipient_email=recipient_email
|
|
)
|
|
|
|
# Link survey to stage
|
|
stage_instance.survey_instance = survey_instance
|
|
stage_instance.survey_sent_at = timezone.now()
|
|
stage_instance.save(update_fields=['survey_instance', 'survey_sent_at'])
|
|
|
|
# Send survey invitation
|
|
notification_log = NotificationService.send_survey_invitation(
|
|
survey_instance=survey_instance,
|
|
language=patient.language if hasattr(patient, 'language') else 'en'
|
|
)
|
|
|
|
# Update survey instance status
|
|
survey_instance.status = 'active'
|
|
survey_instance.sent_at = timezone.now()
|
|
survey_instance.save(update_fields=['status', 'sent_at'])
|
|
|
|
# Log audit event
|
|
create_audit_log(
|
|
event_type='survey_sent',
|
|
description=f"Survey sent to {patient.get_full_name()} for stage {stage_instance.stage_template.name}",
|
|
content_object=survey_instance,
|
|
metadata={
|
|
'survey_template': stage_instance.stage_template.survey_template.name,
|
|
'stage': stage_instance.stage_template.name,
|
|
'encounter_id': stage_instance.journey_instance.encounter_id,
|
|
'channel': delivery_channel
|
|
}
|
|
)
|
|
|
|
logger.info(
|
|
f"Survey created and sent: {survey_instance.id} to {patient.get_full_name()} "
|
|
f"via {delivery_channel}"
|
|
)
|
|
|
|
return {
|
|
'status': 'sent',
|
|
'survey_instance_id': str(survey_instance.id),
|
|
'notification_log_id': str(notification_log.id)
|
|
}
|
|
|
|
except PatientJourneyStageInstance.DoesNotExist:
|
|
error_msg = f"Stage instance {stage_instance_id} not found"
|
|
logger.error(error_msg)
|
|
return {'status': 'error', 'reason': error_msg}
|
|
|
|
except Exception as e:
|
|
error_msg = f"Error creating/sending survey: {str(e)}"
|
|
logger.error(error_msg, exc_info=True)
|
|
|
|
# Retry the task
|
|
raise self.retry(exc=e, countdown=60 * (self.request.retries + 1))
|
|
|
|
|
|
@shared_task
|
|
def send_survey_reminder(survey_instance_id):
|
|
"""
|
|
Send reminder for incomplete survey.
|
|
|
|
Args:
|
|
survey_instance_id: UUID of SurveyInstance
|
|
|
|
Returns:
|
|
dict: Result with delivery status
|
|
"""
|
|
from apps.notifications.services import NotificationService
|
|
from apps.surveys.models import SurveyInstance
|
|
|
|
try:
|
|
survey_instance = SurveyInstance.objects.select_related(
|
|
'patient', 'survey_template'
|
|
).get(id=survey_instance_id)
|
|
|
|
# Only send reminder if survey is still pending/active
|
|
if survey_instance.status not in ['pending', 'active']:
|
|
return {'status': 'skipped', 'reason': f'survey_status_{survey_instance.status}'}
|
|
|
|
# Send reminder
|
|
patient = survey_instance.patient
|
|
language = patient.language if hasattr(patient, 'language') else 'en'
|
|
|
|
notification_log = NotificationService.send_survey_invitation(
|
|
survey_instance=survey_instance,
|
|
language=language
|
|
)
|
|
|
|
logger.info(f"Survey reminder sent for {survey_instance.id}")
|
|
|
|
return {
|
|
'status': 'sent',
|
|
'notification_log_id': str(notification_log.id)
|
|
}
|
|
|
|
except SurveyInstance.DoesNotExist:
|
|
error_msg = f"Survey instance {survey_instance_id} not found"
|
|
logger.error(error_msg)
|
|
return {'status': 'error', 'reason': error_msg}
|
|
|
|
except Exception as e:
|
|
error_msg = f"Error sending survey reminder: {str(e)}"
|
|
logger.error(error_msg, exc_info=True)
|
|
return {'status': 'error', 'reason': error_msg}
|
|
|
|
|
|
@shared_task
|
|
def process_survey_completion(survey_instance_id):
|
|
"""
|
|
Process completed survey.
|
|
|
|
This task:
|
|
1. Calculates the survey score
|
|
2. Checks if score is negative
|
|
3. Creates PXAction if negative (Phase 6)
|
|
|
|
Args:
|
|
survey_instance_id: UUID of SurveyInstance
|
|
|
|
Returns:
|
|
dict: Result with score and action status
|
|
"""
|
|
from apps.core.services import create_audit_log
|
|
from apps.surveys.models import SurveyInstance
|
|
|
|
try:
|
|
survey_instance = SurveyInstance.objects.select_related(
|
|
'survey_template', 'patient'
|
|
).get(id=survey_instance_id)
|
|
|
|
# Calculate score
|
|
score = survey_instance.calculate_score()
|
|
|
|
# Log completion
|
|
create_audit_log(
|
|
event_type='survey_completed',
|
|
description=f"Survey completed by {survey_instance.patient.get_full_name()} with score {score}",
|
|
content_object=survey_instance,
|
|
metadata={
|
|
'score': float(score) if score else None,
|
|
'is_negative': survey_instance.is_negative,
|
|
'survey_template': survey_instance.survey_template.name
|
|
}
|
|
)
|
|
|
|
logger.info(
|
|
f"Survey {survey_instance.id} completed with score {score} "
|
|
f"(negative: {survey_instance.is_negative})"
|
|
)
|
|
|
|
# If negative, create PXAction
|
|
if survey_instance.is_negative:
|
|
logger.info(f"Negative survey detected - creating PXAction")
|
|
|
|
# Check if it's a complaint resolution survey
|
|
if survey_instance.survey_template.survey_type == 'complaint_resolution':
|
|
from apps.px_action_center.tasks import create_action_from_complaint_resolution
|
|
create_action_from_complaint_resolution.delay(str(survey_instance.id))
|
|
else:
|
|
# Regular survey
|
|
from apps.px_action_center.tasks import create_action_from_survey
|
|
create_action_from_survey.delay(str(survey_instance.id))
|
|
|
|
return {
|
|
'status': 'processed',
|
|
'score': float(score) if score else None,
|
|
'is_negative': survey_instance.is_negative
|
|
}
|
|
|
|
except SurveyInstance.DoesNotExist:
|
|
error_msg = f"Survey instance {survey_instance_id} not found"
|
|
logger.error(error_msg)
|
|
return {'status': 'error', 'reason': error_msg}
|
|
|
|
except Exception as e:
|
|
error_msg = f"Error processing survey completion: {str(e)}"
|
|
logger.error(error_msg, exc_info=True)
|
|
return {'status': 'error', 'reason': error_msg}
|
|
|
|
|
|
@shared_task(bind=True, max_retries=3)
|
|
def send_satisfaction_feedback(self, survey_instance_id, user_id=None):
|
|
"""
|
|
Send satisfaction feedback form to patient after negative survey contact.
|
|
|
|
This creates a feedback form linked to the survey and sends it to the patient
|
|
to assess their satisfaction with the resolution.
|
|
|
|
Args:
|
|
survey_instance_id: UUID of SurveyInstance
|
|
user_id: UUID of User who initiated the feedback (optional)
|
|
|
|
Returns:
|
|
dict: Result with feedback_id and delivery status
|
|
"""
|
|
from apps.core.services import create_audit_log
|
|
from apps.feedback.models import Feedback, FeedbackType, FeedbackResponse
|
|
from apps.notifications.services import NotificationService
|
|
from apps.surveys.models import SurveyInstance
|
|
|
|
try:
|
|
# Get survey instance
|
|
survey_instance = SurveyInstance.objects.select_related(
|
|
'patient', 'survey_template', 'journey_instance__hospital'
|
|
).get(id=survey_instance_id)
|
|
|
|
# Check if feedback already sent
|
|
if survey_instance.satisfaction_feedback_sent:
|
|
logger.warning(f"Satisfaction feedback already sent for survey {survey_instance_id}")
|
|
return {'status': 'skipped', 'reason': 'already_sent'}
|
|
|
|
# Check if patient was contacted
|
|
if not survey_instance.patient_contacted:
|
|
logger.warning(f"Patient not contacted yet for survey {survey_instance_id}")
|
|
return {'status': 'skipped', 'reason': 'patient_not_contacted'}
|
|
|
|
patient = survey_instance.patient
|
|
hospital = survey_instance.journey_instance.hospital if survey_instance.journey_instance else patient.primary_hospital
|
|
|
|
# Create satisfaction feedback
|
|
with transaction.atomic():
|
|
feedback = Feedback.objects.create(
|
|
patient=patient,
|
|
hospital=hospital,
|
|
department=survey_instance.journey_stage_instance.stage_template.department if survey_instance.journey_stage_instance else None,
|
|
feedback_type=FeedbackType.SATISFACTION_CHECK,
|
|
title=f"Satisfaction Check - {survey_instance.survey_template.name}",
|
|
message=f"Please rate your satisfaction with how we addressed your concerns regarding the survey.",
|
|
category='communication',
|
|
priority='medium',
|
|
sentiment='neutral',
|
|
status='submitted',
|
|
related_survey=survey_instance,
|
|
encounter_id=survey_instance.encounter_id,
|
|
source='system',
|
|
metadata={
|
|
'survey_id': str(survey_instance.id),
|
|
'survey_score': float(survey_instance.total_score) if survey_instance.total_score else None,
|
|
'auto_generated': True
|
|
}
|
|
)
|
|
|
|
# Create initial response
|
|
FeedbackResponse.objects.create(
|
|
feedback=feedback,
|
|
response_type='note',
|
|
message=f"Satisfaction feedback automatically created following negative survey (Score: {survey_instance.total_score})",
|
|
created_by_id=user_id,
|
|
is_internal=True
|
|
)
|
|
|
|
# Update survey instance
|
|
survey_instance.satisfaction_feedback_sent = True
|
|
survey_instance.satisfaction_feedback_sent_at = timezone.now()
|
|
survey_instance.save(update_fields=['satisfaction_feedback_sent', 'satisfaction_feedback_sent_at'])
|
|
|
|
# Send notification to patient
|
|
# TODO: Implement feedback form link notification
|
|
# For now, we'll log it
|
|
logger.info(f"Satisfaction feedback {feedback.id} created for survey {survey_instance.id}")
|
|
|
|
# Log audit event
|
|
create_audit_log(
|
|
event_type='satisfaction_feedback_sent',
|
|
description=f"Satisfaction feedback sent to {patient.get_full_name()} for survey {survey_instance.survey_template.name}",
|
|
content_object=feedback,
|
|
metadata={
|
|
'survey_id': str(survey_instance.id),
|
|
'survey_score': float(survey_instance.total_score) if survey_instance.total_score else None,
|
|
'feedback_id': str(feedback.id)
|
|
}
|
|
)
|
|
|
|
return {
|
|
'status': 'sent',
|
|
'feedback_id': str(feedback.id),
|
|
'survey_id': str(survey_instance.id)
|
|
}
|
|
|
|
except SurveyInstance.DoesNotExist:
|
|
error_msg = f"Survey instance {survey_instance_id} not found"
|
|
logger.error(error_msg)
|
|
return {'status': 'error', 'reason': error_msg}
|
|
|
|
except Exception as e:
|
|
error_msg = f"Error sending satisfaction feedback: {str(e)}"
|
|
logger.error(error_msg, exc_info=True)
|
|
|
|
# Retry the task
|
|
raise self.retry(exc=e, countdown=60 * (self.request.retries + 1))
|