1707 lines
64 KiB
Python
1707 lines
64 KiB
Python
"""
|
|
Survey Console UI views - Server-rendered templates for survey management
|
|
"""
|
|
from django.contrib import messages
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.core.paginator import Paginator
|
|
from django.db.models import Q, Prefetch, Avg, Count, F, Case, When, IntegerField
|
|
from django.db.models.functions import TruncDate
|
|
from django.http import FileResponse, HttpResponse
|
|
from django.shortcuts import get_object_or_404, redirect, render
|
|
from django.utils import timezone
|
|
from django.views.decorators.http import require_http_methods
|
|
from django.db.models import ExpressionWrapper, FloatField
|
|
|
|
from apps.core.services import AuditService
|
|
from apps.core.decorators import block_source_user
|
|
from apps.organizations.models import Department, Hospital
|
|
|
|
from .forms import ManualSurveySendForm, SurveyQuestionFormSet, SurveyTemplateForm, ManualPhoneSurveySendForm, BulkCSVSurveySendForm
|
|
from .services import SurveyDeliveryService
|
|
from .models import SurveyInstance, SurveyTemplate, SurveyQuestion
|
|
from .tasks import send_satisfaction_feedback
|
|
from datetime import datetime
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def survey_instance_list(request):
|
|
"""
|
|
Survey instances list view with filters.
|
|
|
|
Features:
|
|
- Server-side pagination
|
|
- Filters (status, journey type, hospital, date range)
|
|
- Search by patient MRN
|
|
- Score display
|
|
"""
|
|
# Source Users don't have access to surveys
|
|
if request.user.is_source_user():
|
|
from django.core.exceptions import PermissionDenied
|
|
raise PermissionDenied("Source users do not have access to surveys.")
|
|
|
|
# Base queryset with optimizations
|
|
queryset = SurveyInstance.objects.select_related(
|
|
'survey_template',
|
|
'patient',
|
|
'journey_instance__journey_template'
|
|
).prefetch_related(
|
|
'responses__question'
|
|
)
|
|
|
|
# Apply RBAC filters
|
|
user = request.user
|
|
if user.is_px_admin():
|
|
pass # See all
|
|
elif user.is_hospital_admin() and user.hospital:
|
|
queryset = queryset.filter(survey_template__hospital=user.hospital)
|
|
elif user.hospital:
|
|
queryset = queryset.filter(survey_template__hospital=user.hospital)
|
|
else:
|
|
queryset = queryset.none()
|
|
|
|
# Apply filters
|
|
status_filter = request.GET.get('status')
|
|
if status_filter:
|
|
queryset = queryset.filter(status=status_filter)
|
|
|
|
survey_type = request.GET.get('survey_type')
|
|
if survey_type:
|
|
queryset = queryset.filter(survey_template__survey_type=survey_type)
|
|
|
|
is_negative = request.GET.get('is_negative')
|
|
if is_negative == 'true':
|
|
queryset = queryset.filter(is_negative=True)
|
|
|
|
hospital_filter = request.GET.get('hospital')
|
|
if hospital_filter:
|
|
queryset = queryset.filter(survey_template__hospital_id=hospital_filter)
|
|
|
|
# Search
|
|
search_query = request.GET.get('search')
|
|
if search_query:
|
|
queryset = queryset.filter(
|
|
Q(patient__mrn__icontains=search_query) |
|
|
Q(patient__first_name__icontains=search_query) |
|
|
Q(patient__last_name__icontains=search_query) |
|
|
Q(encounter_id__icontains=search_query)
|
|
)
|
|
|
|
# Date range
|
|
date_from = request.GET.get('date_from')
|
|
if date_from:
|
|
queryset = queryset.filter(sent_at__gte=date_from)
|
|
|
|
date_to = request.GET.get('date_to')
|
|
if date_to:
|
|
queryset = queryset.filter(sent_at__lte=date_to)
|
|
|
|
# Ordering
|
|
order_by = request.GET.get('order_by', '-created_at')
|
|
queryset = queryset.order_by(order_by)
|
|
|
|
# Pagination
|
|
page_size = int(request.GET.get('page_size', 25))
|
|
paginator = Paginator(queryset, page_size)
|
|
page_number = request.GET.get('page', 1)
|
|
page_obj = paginator.get_page(page_number)
|
|
|
|
# Get filter options
|
|
hospitals = Hospital.objects.filter(status='active')
|
|
if not user.is_px_admin() and user.hospital:
|
|
hospitals = hospitals.filter(id=user.hospital.id)
|
|
|
|
context = {
|
|
'surveys': page_obj,
|
|
'hospitals': hospitals,
|
|
'filters': request.GET,
|
|
}
|
|
|
|
return render(request, 'surveys/instance_list.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def survey_instance_detail(request, pk):
|
|
"""
|
|
Survey instance detail view with responses.
|
|
|
|
Features:
|
|
- Full survey details
|
|
- All responses
|
|
- Score breakdown
|
|
- Related journey/stage info
|
|
- Score comparison with template average
|
|
- Related surveys from same patient
|
|
"""
|
|
survey = get_object_or_404(
|
|
SurveyInstance.objects.select_related(
|
|
'survey_template',
|
|
'patient',
|
|
'journey_instance__journey_template'
|
|
).prefetch_related(
|
|
'responses__question'
|
|
),
|
|
pk=pk
|
|
)
|
|
|
|
# Get responses
|
|
responses = survey.responses.all().order_by('question__order')
|
|
|
|
# Calculate average score for this survey template
|
|
template_average = SurveyInstance.objects.filter(
|
|
survey_template=survey.survey_template,
|
|
status='completed'
|
|
).aggregate(
|
|
avg_score=Avg('total_score')
|
|
)['avg_score'] or 0
|
|
|
|
# Get related surveys from the same patient
|
|
related_surveys = SurveyInstance.objects.filter(
|
|
patient=survey.patient,
|
|
status='completed'
|
|
).exclude(
|
|
id=survey.id
|
|
).select_related(
|
|
'survey_template'
|
|
).order_by('-completed_at')[:5]
|
|
|
|
# Get response statistics for each question (for choice questions)
|
|
question_stats = {}
|
|
for response in responses:
|
|
if response.question.question_type in ['multiple_choice', 'single_choice']:
|
|
choice_responses = SurveyInstance.objects.filter(
|
|
survey_template=survey.survey_template,
|
|
status='completed'
|
|
).values(
|
|
f'responses__choice_value'
|
|
).annotate(
|
|
count=Count('id')
|
|
).filter(
|
|
responses__question=response.question
|
|
).order_by('-count')
|
|
|
|
question_stats[response.question.id] = {
|
|
'type': 'choice',
|
|
'options': [
|
|
{
|
|
'value': opt['responses__choice_value'],
|
|
'count': opt['count'],
|
|
'percentage': round((opt['count'] / choice_responses.count() * 100) if choice_responses.count() > 0 else 0, 1)
|
|
}
|
|
for opt in choice_responses
|
|
if opt['responses__choice_value']
|
|
]
|
|
}
|
|
elif response.question.question_type == 'rating':
|
|
rating_stats = SurveyInstance.objects.filter(
|
|
survey_template=survey.survey_template,
|
|
status='completed'
|
|
).aggregate(
|
|
avg_rating=Avg('responses__numeric_value'),
|
|
total_responses=Count('responses')
|
|
)
|
|
question_stats[response.question.id] = {
|
|
'type': 'rating',
|
|
'average': round(rating_stats['avg_rating'] or 0, 2),
|
|
'total_responses': rating_stats['total_responses'] or 0
|
|
}
|
|
|
|
context = {
|
|
'survey': survey,
|
|
'responses': responses,
|
|
'template_average': round(template_average, 2),
|
|
'related_surveys': related_surveys,
|
|
'question_stats': question_stats,
|
|
}
|
|
|
|
return render(request, 'surveys/instance_detail.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def survey_template_list(request):
|
|
"""Survey templates list view"""
|
|
queryset = SurveyTemplate.objects.select_related('hospital').prefetch_related('questions')
|
|
|
|
# Apply RBAC filters
|
|
user = request.user
|
|
if user.is_px_admin():
|
|
pass
|
|
elif user.hospital:
|
|
queryset = queryset.filter(hospital=user.hospital)
|
|
else:
|
|
queryset = queryset.none()
|
|
|
|
# Apply filters
|
|
survey_type = request.GET.get('survey_type')
|
|
if survey_type:
|
|
queryset = queryset.filter(survey_type=survey_type)
|
|
|
|
hospital_filter = request.GET.get('hospital')
|
|
if hospital_filter:
|
|
queryset = queryset.filter(hospital_id=hospital_filter)
|
|
|
|
is_active = request.GET.get('is_active')
|
|
if is_active == 'true':
|
|
queryset = queryset.filter(is_active=True)
|
|
elif is_active == 'false':
|
|
queryset = queryset.filter(is_active=False)
|
|
|
|
# Ordering
|
|
queryset = queryset.order_by('hospital', 'survey_type', 'name')
|
|
|
|
# Pagination
|
|
page_size = int(request.GET.get('page_size', 25))
|
|
paginator = Paginator(queryset, page_size)
|
|
page_number = request.GET.get('page', 1)
|
|
page_obj = paginator.get_page(page_number)
|
|
|
|
# Get filter options
|
|
hospitals = Hospital.objects.filter(status='active')
|
|
if not user.is_px_admin() and user.hospital:
|
|
hospitals = hospitals.filter(id=user.hospital.id)
|
|
|
|
context = {
|
|
'page_obj': page_obj,
|
|
'templates': page_obj.object_list,
|
|
'hospitals': hospitals,
|
|
'filters': request.GET,
|
|
}
|
|
|
|
return render(request, 'surveys/template_list.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def survey_template_create(request):
|
|
"""Create a new survey template with questions"""
|
|
# Check permission
|
|
user = request.user
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
messages.error(request, "You don't have permission to create survey templates.")
|
|
return redirect('surveys:template_list')
|
|
|
|
if request.method == 'POST':
|
|
form = SurveyTemplateForm(request.POST, user=user)
|
|
formset = SurveyQuestionFormSet(request.POST)
|
|
|
|
if form.is_valid() and formset.is_valid():
|
|
template = form.save(commit=False)
|
|
template.created_by = user
|
|
template.save()
|
|
|
|
questions = formset.save(commit=False)
|
|
for question in questions:
|
|
question.survey_template = template
|
|
question.save()
|
|
|
|
messages.success(request, "Survey template created successfully.")
|
|
return redirect('surveys:template_detail', pk=template.pk)
|
|
else:
|
|
form = SurveyTemplateForm(user=user)
|
|
formset = SurveyQuestionFormSet()
|
|
|
|
context = {
|
|
'form': form,
|
|
'formset': formset,
|
|
}
|
|
|
|
return render(request, 'surveys/template_form.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def survey_template_detail(request, pk):
|
|
"""View survey template details"""
|
|
template = get_object_or_404(
|
|
SurveyTemplate.objects.select_related('hospital').prefetch_related('questions'),
|
|
pk=pk
|
|
)
|
|
|
|
# Check permission
|
|
user = request.user
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
if user.hospital and template.hospital != user.hospital:
|
|
messages.error(request, "You don't have permission to view this template.")
|
|
return redirect('surveys:template_list')
|
|
|
|
# Get statistics
|
|
total_instances = template.instances.count()
|
|
completed_instances = template.instances.filter(status='completed').count()
|
|
negative_instances = template.instances.filter(is_negative=True).count()
|
|
avg_score = template.instances.filter(status='completed').aggregate(
|
|
avg_score=Avg('total_score')
|
|
)['avg_score'] or 0
|
|
|
|
context = {
|
|
'template': template,
|
|
'questions': template.questions.all().order_by('order'),
|
|
'stats': {
|
|
'total_instances': total_instances,
|
|
'completed_instances': completed_instances,
|
|
'negative_instances': negative_instances,
|
|
'completion_rate': round((completed_instances / total_instances * 100) if total_instances > 0 else 0, 1),
|
|
'avg_score': round(avg_score, 2),
|
|
}
|
|
}
|
|
|
|
return render(request, 'surveys/template_detail.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def survey_template_edit(request, pk):
|
|
"""Edit an existing survey template with questions"""
|
|
template = get_object_or_404(SurveyTemplate, pk=pk)
|
|
|
|
# Check permission
|
|
user = request.user
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
if user.hospital and template.hospital != user.hospital:
|
|
messages.error(request, "You don't have permission to edit this template.")
|
|
return redirect('surveys:template_list')
|
|
|
|
if request.method == 'POST':
|
|
form = SurveyTemplateForm(request.POST, instance=template, user=user)
|
|
formset = SurveyQuestionFormSet(request.POST, instance=template)
|
|
|
|
if form.is_valid() and formset.is_valid():
|
|
form.save()
|
|
formset.save()
|
|
|
|
messages.success(request, "Survey template updated successfully.")
|
|
return redirect('surveys:template_detail', pk=template.pk)
|
|
else:
|
|
form = SurveyTemplateForm(instance=template, user=user)
|
|
formset = SurveyQuestionFormSet(instance=template)
|
|
|
|
context = {
|
|
'form': form,
|
|
'formset': formset,
|
|
'template': template,
|
|
}
|
|
|
|
return render(request, 'surveys/template_form.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def survey_template_delete(request, pk):
|
|
"""Delete a survey template"""
|
|
template = get_object_or_404(SurveyTemplate, pk=pk)
|
|
|
|
# Check permission
|
|
user = request.user
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
if user.hospital and template.hospital != user.hospital:
|
|
messages.error(request, "You don't have permission to delete this template.")
|
|
return redirect('surveys:template_list')
|
|
|
|
if request.method == 'POST':
|
|
template_name = template.name
|
|
template.delete()
|
|
messages.success(request, f"Survey template '{template_name}' deleted successfully.")
|
|
return redirect('surveys:template_list')
|
|
|
|
context = {
|
|
'template': template,
|
|
}
|
|
|
|
return render(request, 'surveys/template_confirm_delete.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
@require_http_methods(["POST"])
|
|
def survey_log_patient_contact(request, pk):
|
|
"""
|
|
Log patient contact for negative survey.
|
|
|
|
This records that the user contacted the patient to discuss
|
|
the negative survey feedback.
|
|
"""
|
|
survey = get_object_or_404(SurveyInstance, pk=pk)
|
|
|
|
# Check permission
|
|
user = request.user
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
if user.hospital and survey.survey_template.hospital != user.hospital:
|
|
messages.error(request, "You don't have permission to modify this survey.")
|
|
return redirect('surveys:instance_detail', pk=pk)
|
|
|
|
# Check if survey is negative
|
|
if not survey.is_negative:
|
|
messages.warning(request, "This survey is not marked as negative.")
|
|
return redirect('surveys:instance_detail', pk=pk)
|
|
|
|
# Get form data
|
|
contact_notes = request.POST.get('contact_notes', '')
|
|
issue_resolved = request.POST.get('issue_resolved') == 'on'
|
|
|
|
if not contact_notes:
|
|
messages.error(request, "Please provide contact notes.")
|
|
return redirect('surveys:instance_detail', pk=pk)
|
|
|
|
try:
|
|
# Update survey
|
|
survey.patient_contacted = True
|
|
survey.patient_contacted_at = timezone.now()
|
|
survey.patient_contacted_by = user
|
|
survey.contact_notes = contact_notes
|
|
survey.issue_resolved = issue_resolved
|
|
survey.save(update_fields=[
|
|
'patient_contacted', 'patient_contacted_at',
|
|
'patient_contacted_by', 'contact_notes', 'issue_resolved'
|
|
])
|
|
|
|
# Log audit
|
|
AuditService.log_event(
|
|
event_type='survey_patient_contacted',
|
|
description=f"Patient contacted for negative survey by {user.get_full_name()}",
|
|
user=user,
|
|
content_object=survey,
|
|
metadata={
|
|
'contact_notes': contact_notes,
|
|
'issue_resolved': issue_resolved,
|
|
'survey_score': float(survey.total_score) if survey.total_score else None
|
|
}
|
|
)
|
|
|
|
status = "resolved" if issue_resolved else "discussed"
|
|
messages.success(request, f"Patient contact logged successfully. Issue marked as {status}.")
|
|
|
|
except Exception as e:
|
|
messages.error(request, f"Error logging patient contact: {str(e)}")
|
|
|
|
return redirect('surveys:instance_detail', pk=pk)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def survey_comments_list(request):
|
|
"""
|
|
Survey comments list view with AI analysis.
|
|
|
|
Features:
|
|
- Display all survey comments with AI analysis
|
|
- Filters (sentiment, survey type, hospital, date range)
|
|
- Search by patient MRN
|
|
- Server-side pagination
|
|
- PatientType display from journey
|
|
"""
|
|
# Base queryset - only completed surveys with comments
|
|
queryset = SurveyInstance.objects.select_related(
|
|
'survey_template',
|
|
'patient',
|
|
'journey_instance__journey_template'
|
|
).filter(
|
|
status='completed',
|
|
comment__isnull=False
|
|
).exclude(
|
|
comment=''
|
|
)
|
|
|
|
# Apply RBAC filters
|
|
user = request.user
|
|
if user.is_px_admin():
|
|
pass # See all
|
|
elif user.is_hospital_admin() and user.hospital:
|
|
queryset = queryset.filter(survey_template__hospital=user.hospital)
|
|
elif user.hospital:
|
|
queryset = queryset.filter(survey_template__hospital=user.hospital)
|
|
else:
|
|
queryset = queryset.none()
|
|
|
|
# Apply filters
|
|
sentiment_filter = request.GET.get('sentiment')
|
|
if sentiment_filter:
|
|
queryset = queryset.filter(
|
|
comment_analysis__sentiment=sentiment_filter
|
|
)
|
|
|
|
survey_type = request.GET.get('survey_type')
|
|
if survey_type:
|
|
queryset = queryset.filter(survey_template__survey_type=survey_type)
|
|
|
|
hospital_filter = request.GET.get('hospital')
|
|
if hospital_filter:
|
|
queryset = queryset.filter(survey_template__hospital_id=hospital_filter)
|
|
|
|
# Patient type filter
|
|
patient_type_filter = request.GET.get('patient_type')
|
|
if patient_type_filter:
|
|
# Map filter values to HIS codes
|
|
patient_type_map = {
|
|
'outpatient': ['1'],
|
|
'inpatient': ['2', 'O'],
|
|
'emergency': ['3', 'E'],
|
|
}
|
|
if patient_type_filter in patient_type_map:
|
|
codes = patient_type_map[patient_type_filter]
|
|
queryset = queryset.filter(
|
|
metadata__patient_type__in=codes
|
|
)
|
|
|
|
# Search
|
|
search_query = request.GET.get('search')
|
|
if search_query:
|
|
queryset = queryset.filter(
|
|
Q(patient__mrn__icontains=search_query) |
|
|
Q(patient__first_name__icontains=search_query) |
|
|
Q(patient__last_name__icontains=search_query) |
|
|
Q(comment__icontains=search_query)
|
|
)
|
|
|
|
# Date range
|
|
date_from = request.GET.get('date_from')
|
|
if date_from:
|
|
queryset = queryset.filter(completed_at__gte=date_from)
|
|
|
|
date_to = request.GET.get('date_to')
|
|
if date_to:
|
|
queryset = queryset.filter(completed_at__lte=date_to)
|
|
|
|
# Ordering
|
|
order_by = request.GET.get('order_by', '-completed_at')
|
|
queryset = queryset.order_by(order_by)
|
|
|
|
# Pagination
|
|
page_size = int(request.GET.get('page_size', 25))
|
|
paginator = Paginator(queryset, page_size)
|
|
page_number = request.GET.get('page', 1)
|
|
page_obj = paginator.get_page(page_number)
|
|
|
|
# Get filter options
|
|
hospitals = Hospital.objects.filter(status='active')
|
|
if not user.is_px_admin() and user.hospital:
|
|
hospitals = hospitals.filter(id=user.hospital.id)
|
|
|
|
# Statistics
|
|
stats_queryset = SurveyInstance.objects.filter(
|
|
status='completed',
|
|
comment__isnull=False
|
|
).exclude(
|
|
comment=''
|
|
)
|
|
|
|
# Apply same RBAC filters to stats
|
|
if user.is_px_admin():
|
|
pass
|
|
elif user.is_hospital_admin() and user.hospital:
|
|
stats_queryset = stats_queryset.filter(survey_template__hospital=user.hospital)
|
|
elif user.hospital:
|
|
stats_queryset = stats_queryset.filter(survey_template__hospital=user.hospital)
|
|
else:
|
|
stats_queryset = stats_queryset.none()
|
|
|
|
total_count = stats_queryset.count()
|
|
positive_count = stats_queryset.filter(
|
|
comment_analysis__sentiment='positive'
|
|
).count()
|
|
negative_count = stats_queryset.filter(
|
|
comment_analysis__sentiment='negative'
|
|
).count()
|
|
neutral_count = stats_queryset.filter(
|
|
comment_analysis__sentiment='neutral'
|
|
).count()
|
|
analyzed_count = stats_queryset.filter(
|
|
comment_analyzed=True
|
|
).count()
|
|
|
|
# Patient Type Distribution Chart Data
|
|
patient_type_distribution = []
|
|
patient_type_labels = []
|
|
patient_type_mapping = {
|
|
'1': 'Outpatient',
|
|
'2': 'Inpatient',
|
|
'O': 'Inpatient',
|
|
'3': 'Emergency',
|
|
'E': 'Emergency',
|
|
}
|
|
|
|
# Count each patient type
|
|
outpatient_count = stats_queryset.filter(
|
|
metadata__patient_type__in=['1']
|
|
).count()
|
|
inpatient_count = stats_queryset.filter(
|
|
metadata__patient_type__in=['2', 'O']
|
|
).count()
|
|
emergency_count = stats_queryset.filter(
|
|
metadata__patient_type__in=['3', 'E']
|
|
).count()
|
|
unknown_count = total_count - (outpatient_count + inpatient_count + emergency_count)
|
|
|
|
patient_type_distribution = [
|
|
{'type': 'outpatient', 'label': 'Outpatient', 'count': outpatient_count, 'percentage': round((outpatient_count / total_count * 100) if total_count > 0 else 0, 1)},
|
|
{'type': 'inpatient', 'label': 'Inpatient', 'count': inpatient_count, 'percentage': round((inpatient_count / total_count * 100) if total_count > 0 else 0, 1)},
|
|
{'type': 'emergency', 'label': 'Emergency', 'count': emergency_count, 'percentage': round((emergency_count / total_count * 100) if total_count > 0 else 0, 1)},
|
|
{'type': 'unknown', 'label': 'N/A', 'count': unknown_count, 'percentage': round((unknown_count / total_count * 100) if total_count > 0 else 0, 1)},
|
|
]
|
|
|
|
# Sentiment by Patient Type Chart Data
|
|
sentiment_by_patient_type = {
|
|
'types': ['Outpatient', 'Inpatient', 'Emergency', 'N/A'],
|
|
'positive': [],
|
|
'negative': [],
|
|
'neutral': [],
|
|
}
|
|
|
|
# Calculate sentiment for each patient type
|
|
for pt_type, codes in [('outpatient', ['1']), ('inpatient', ['2', 'O']), ('emergency', ['3', 'E']), ('unknown', [])]:
|
|
if codes:
|
|
pt_queryset = stats_queryset.filter(metadata__patient_type__in=codes)
|
|
else:
|
|
pt_queryset = stats_queryset.exclude(
|
|
metadata__patient_type__in=['1', '2', 'O', '3', 'E']
|
|
)
|
|
|
|
pt_positive = pt_queryset.filter(comment_analysis__sentiment='positive').count()
|
|
pt_negative = pt_queryset.filter(comment_analysis__sentiment='negative').count()
|
|
pt_neutral = pt_queryset.filter(comment_analysis__sentiment='neutral').count()
|
|
|
|
sentiment_by_patient_type['positive'].append(pt_positive)
|
|
sentiment_by_patient_type['negative'].append(pt_negative)
|
|
sentiment_by_patient_type['neutral'].append(pt_neutral)
|
|
|
|
# PatientType mapping helper - maps HIS codes to display values
|
|
# HIS codes: "1"=Inpatient, "2"/"O"=Outpatient, "3"/"E"=Emergency
|
|
PATIENT_TYPE_MAPPING = {
|
|
'1': {'label': 'Outpatient', 'icon': 'bi-person-walking', 'color': 'bg-primary'},
|
|
'2': {'label': 'Inpatient', 'icon': 'bi-hospital', 'color': 'bg-warning'},
|
|
'O': {'label': 'Inpatient', 'icon': 'bi-hospital', 'color': 'bg-warning'},
|
|
'3': {'label': 'Emergency', 'icon': 'bi-ambulance', 'color': 'bg-danger'},
|
|
'E': {'label': 'Emergency', 'icon': 'bi-ambulance', 'color': 'bg-danger'},
|
|
}
|
|
|
|
def get_patient_type_display(survey):
|
|
"""Get patient type display for a survey from HIS metadata"""
|
|
# Get patient_type from survey metadata (saved by HIS adapter)
|
|
patient_type_code = survey.metadata.get('patient_type')
|
|
|
|
if patient_type_code:
|
|
type_info = PATIENT_TYPE_MAPPING.get(str(patient_type_code))
|
|
if type_info:
|
|
return {
|
|
'code': patient_type_code,
|
|
'label': type_info['label'],
|
|
'icon': type_info['icon'],
|
|
'color': type_info['color']
|
|
}
|
|
|
|
# Fallback: try to get from journey if available
|
|
if survey.journey_instance and survey.journey_instance.journey_template:
|
|
journey_type = survey.journey_instance.journey_template.journey_type
|
|
journey_mapping = {
|
|
'opd': {'label': 'Outpatient', 'icon': 'bi-person-walking', 'color': 'bg-primary'},
|
|
'inpatient': {'label': 'Inpatient', 'icon': 'bi-hospital', 'color': 'bg-warning'},
|
|
'ems': {'label': 'Emergency', 'icon': 'bi-ambulance', 'color': 'bg-danger'},
|
|
'day_case': {'label': 'Day Case', 'icon': 'bi-calendar-day', 'color': 'bg-info'},
|
|
}
|
|
return journey_mapping.get(journey_type, {'code': None, 'label': 'N/A', 'icon': 'bi-question-circle', 'color': 'bg-secondary'})
|
|
|
|
return {'code': None, 'label': 'N/A', 'icon': 'bi-question-circle', 'color': 'bg-secondary'}
|
|
|
|
# Add patient type info to surveys
|
|
for survey in page_obj.object_list:
|
|
survey.patient_type = get_patient_type_display(survey)
|
|
|
|
stats = {
|
|
'total': total_count,
|
|
'positive': positive_count,
|
|
'negative': negative_count,
|
|
'neutral': neutral_count,
|
|
'analyzed': analyzed_count,
|
|
'unanalyzed': total_count - analyzed_count,
|
|
}
|
|
|
|
# Serialize chart data to JSON
|
|
import json
|
|
patient_type_distribution_json = json.dumps(patient_type_distribution)
|
|
sentiment_by_patient_type_json = json.dumps(sentiment_by_patient_type)
|
|
|
|
context = {
|
|
'page_obj': page_obj,
|
|
'surveys': page_obj.object_list,
|
|
'stats': stats,
|
|
'hospitals': hospitals,
|
|
'filters': request.GET,
|
|
# Chart data
|
|
'patient_type_distribution': patient_type_distribution,
|
|
'sentiment_by_patient_type': sentiment_by_patient_type,
|
|
'patient_type_distribution_json': patient_type_distribution_json,
|
|
'sentiment_by_patient_type_json': sentiment_by_patient_type_json,
|
|
}
|
|
|
|
return render(request, 'surveys/comment_list.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
@require_http_methods(["POST"])
|
|
def survey_send_satisfaction_feedback(request, pk):
|
|
"""
|
|
Send satisfaction feedback form to patient.
|
|
|
|
This creates and sends a feedback form to assess patient satisfaction
|
|
with how their negative survey concerns were addressed.
|
|
"""
|
|
survey = get_object_or_404(SurveyInstance, pk=pk)
|
|
|
|
# Check permission
|
|
user = request.user
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
if user.hospital and survey.survey_template.hospital != user.hospital:
|
|
messages.error(request, "You don't have permission to modify this survey.")
|
|
return redirect('surveys:instance_detail', pk=pk)
|
|
|
|
# Check if survey is negative
|
|
if not survey.is_negative:
|
|
messages.warning(request, "This survey is not marked as negative.")
|
|
return redirect('surveys:instance_detail', pk=pk)
|
|
|
|
# Check if patient was contacted
|
|
if not survey.patient_contacted:
|
|
messages.error(request, "Please log patient contact before sending satisfaction feedback.")
|
|
return redirect('surveys:instance_detail', pk=pk)
|
|
|
|
# Check if already sent
|
|
if survey.satisfaction_feedback_sent:
|
|
messages.warning(request, "Satisfaction feedback has already been sent for this survey.")
|
|
return redirect('surveys:instance_detail', pk=pk)
|
|
|
|
try:
|
|
# Trigger async task to send satisfaction feedback
|
|
send_satisfaction_feedback.delay(str(survey.id), str(user.id))
|
|
|
|
messages.success(
|
|
request,
|
|
"Satisfaction feedback form is being sent to the patient. "
|
|
"They will receive a link to provide their feedback."
|
|
)
|
|
|
|
except Exception as e:
|
|
messages.error(request, f"Error sending satisfaction feedback: {str(e)}")
|
|
|
|
return redirect('surveys:instance_detail', pk=pk)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def manual_survey_send(request):
|
|
"""
|
|
Manually send a survey to a patient or staff member.
|
|
|
|
Features:
|
|
- Select survey template
|
|
- Choose recipient type (patient/staff)
|
|
- Search and select recipient
|
|
- Choose delivery channel (email/SMS)
|
|
- Add custom message (optional)
|
|
- Send survey immediately
|
|
"""
|
|
user = request.user
|
|
|
|
# Check permission
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
messages.error(request, "You don't have permission to send surveys manually.")
|
|
return redirect('surveys:instance_list')
|
|
|
|
if request.method == 'POST':
|
|
form = ManualSurveySendForm(user, request.POST)
|
|
|
|
if form.is_valid():
|
|
try:
|
|
# Get form data
|
|
survey_template = form.cleaned_data['survey_template']
|
|
recipient_type = form.cleaned_data['recipient_type']
|
|
recipient_id = form.cleaned_data['recipient']
|
|
delivery_channel = form.cleaned_data['delivery_channel']
|
|
custom_message = form.cleaned_data.get('custom_message', '')
|
|
|
|
# Get recipient object
|
|
from apps.organizations.models import Patient, Staff
|
|
|
|
if recipient_type == 'patient':
|
|
recipient = get_object_or_404(Patient, pk=recipient_id)
|
|
recipient_name = f"{recipient.first_name} {recipient.last_name}"
|
|
else:
|
|
recipient = get_object_or_404(Staff, pk=recipient_id)
|
|
recipient_name = f"{recipient.first_name} {recipient.last_name}"
|
|
|
|
# Check if recipient has contact info for selected channel
|
|
if delivery_channel == 'email':
|
|
contact_info = recipient.email
|
|
if not contact_info:
|
|
messages.error(request, f"{recipient_type.title()} does not have an email address.")
|
|
return render(request, 'surveys/manual_send.html', {'form': form})
|
|
elif delivery_channel == 'sms':
|
|
contact_info = recipient.phone
|
|
if not contact_info:
|
|
messages.error(request, f"{recipient_type.title()} does not have a phone number.")
|
|
return render(request, 'surveys/manual_send.html', {'form': form})
|
|
|
|
# Create survey instance
|
|
from .models import SurveyStatus
|
|
|
|
survey_instance = SurveyInstance.objects.create(
|
|
survey_template=survey_template,
|
|
patient=recipient if recipient_type == 'patient' else None,
|
|
staff=recipient if recipient_type == 'staff' else None,
|
|
hospital=survey_template.hospital,
|
|
delivery_channel=delivery_channel,
|
|
recipient_email=contact_info if delivery_channel == 'email' else None,
|
|
recipient_phone=contact_info if delivery_channel == 'sms' else None,
|
|
status=SurveyStatus.SENT,
|
|
metadata={
|
|
'sent_manually': True,
|
|
'sent_by': str(user.id),
|
|
'custom_message': custom_message,
|
|
'recipient_type': recipient_type
|
|
}
|
|
)
|
|
|
|
# Send survey
|
|
success = SurveyDeliveryService.deliver_survey(survey_instance)
|
|
|
|
if success:
|
|
# Log audit
|
|
AuditService.log_event(
|
|
event_type='survey_sent_manually',
|
|
description=f"Survey sent manually to {recipient_name} ({recipient_type}) by {user.get_full_name()}",
|
|
user=user,
|
|
content_object=survey_instance,
|
|
metadata={
|
|
'survey_template': survey_template.name,
|
|
'recipient_type': recipient_type,
|
|
'recipient_id': recipient_id,
|
|
'delivery_channel': delivery_channel,
|
|
'custom_message': custom_message
|
|
}
|
|
)
|
|
|
|
messages.success(
|
|
request,
|
|
f"Survey sent successfully to {recipient_name} via {delivery_channel.upper()}. "
|
|
f"Survey ID: {survey_instance.id}"
|
|
)
|
|
return redirect('surveys:instance_detail', pk=survey_instance.pk)
|
|
else:
|
|
messages.error(request, "Failed to send survey. Please try again.")
|
|
survey_instance.delete()
|
|
return render(request, 'surveys/manual_send.html', {'form': form})
|
|
|
|
except Exception as e:
|
|
import logging
|
|
logger = logging.getLogger(__name__)
|
|
logger.error(f"Error sending survey manually: {str(e)}", exc_info=True)
|
|
messages.error(request, f"Error sending survey: {str(e)}")
|
|
return render(request, 'surveys/manual_send.html', {'form': form})
|
|
else:
|
|
form = ManualSurveySendForm(user)
|
|
|
|
context = {
|
|
'form': form,
|
|
}
|
|
|
|
return render(request, 'surveys/manual_send.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def manual_survey_send_phone(request):
|
|
"""
|
|
Send survey to a manually entered phone number.
|
|
|
|
Features:
|
|
- Enter phone number directly
|
|
- Optional recipient name
|
|
- Send via SMS only
|
|
"""
|
|
user = request.user
|
|
|
|
# Check permission
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
messages.error(request, "You don't have permission to send surveys manually.")
|
|
return redirect('surveys:instance_list')
|
|
|
|
if request.method == 'POST':
|
|
form = ManualPhoneSurveySendForm(user, request.POST)
|
|
|
|
if form.is_valid():
|
|
try:
|
|
survey_template = form.cleaned_data['survey_template']
|
|
phone_number = form.cleaned_data['phone_number']
|
|
recipient_name = form.cleaned_data.get('recipient_name', '')
|
|
custom_message = form.cleaned_data.get('custom_message', '')
|
|
|
|
# Create survey instance
|
|
from .models import SurveyStatus
|
|
|
|
survey_instance = SurveyInstance.objects.create(
|
|
survey_template=survey_template,
|
|
hospital=survey_template.hospital,
|
|
delivery_channel='sms',
|
|
recipient_phone=phone_number,
|
|
status=SurveyStatus.SENT,
|
|
metadata={
|
|
'sent_manually': True,
|
|
'sent_by': str(user.id),
|
|
'custom_message': custom_message,
|
|
'recipient_name': recipient_name,
|
|
'recipient_type': 'manual_phone'
|
|
}
|
|
)
|
|
|
|
# Send survey
|
|
success = SurveyDeliveryService.deliver_survey(survey_instance)
|
|
|
|
if success:
|
|
# Log audit
|
|
AuditService.log_event(
|
|
event_type='survey_sent_manually_phone',
|
|
description=f"Survey sent manually to phone {phone_number} by {user.get_full_name()}",
|
|
user=user,
|
|
content_object=survey_instance,
|
|
metadata={
|
|
'survey_template': survey_template.name,
|
|
'phone_number': phone_number,
|
|
'recipient_name': recipient_name,
|
|
'custom_message': custom_message
|
|
}
|
|
)
|
|
|
|
display_name = recipient_name if recipient_name else phone_number
|
|
messages.success(
|
|
request,
|
|
f"Survey sent successfully to {display_name} via SMS. Survey ID: {survey_instance.id}"
|
|
)
|
|
return redirect('surveys:instance_detail', pk=survey_instance.pk)
|
|
else:
|
|
messages.error(request, "Failed to send survey. Please try again.")
|
|
survey_instance.delete()
|
|
return render(request, 'surveys/manual_send_phone.html', {'form': form})
|
|
|
|
except Exception as e:
|
|
import logging
|
|
logger = logging.getLogger(__name__)
|
|
logger.error(f"Error sending survey to phone: {str(e)}", exc_info=True)
|
|
messages.error(request, f"Error sending survey: {str(e)}")
|
|
return render(request, 'surveys/manual_send_phone.html', {'form': form})
|
|
else:
|
|
form = ManualPhoneSurveySendForm(user)
|
|
|
|
context = {
|
|
'form': form,
|
|
}
|
|
|
|
return render(request, 'surveys/manual_send_phone.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def manual_survey_send_csv(request):
|
|
"""
|
|
Bulk send surveys via CSV upload.
|
|
|
|
CSV Format:
|
|
phone_number,name(optional)
|
|
+966501234567,John Doe
|
|
+966501234568,Jane Smith
|
|
|
|
Features:
|
|
- Upload CSV with phone numbers
|
|
- Optional names for each recipient
|
|
- Bulk processing with success/failure reporting
|
|
"""
|
|
import csv
|
|
import io
|
|
from django.utils.translation import gettext as _
|
|
|
|
user = request.user
|
|
|
|
# Check permission
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
messages.error(request, "You don't have permission to send surveys manually.")
|
|
return redirect('surveys:instance_list')
|
|
|
|
if request.method == 'POST':
|
|
form = BulkCSVSurveySendForm(user, request.POST, request.FILES)
|
|
|
|
if form.is_valid():
|
|
try:
|
|
survey_template = form.cleaned_data['survey_template']
|
|
csv_file = form.cleaned_data['csv_file']
|
|
custom_message = form.cleaned_data.get('custom_message', '')
|
|
|
|
# Parse CSV
|
|
decoded_file = csv_file.read().decode('utf-8-sig') # Handle BOM
|
|
io_string = io.StringIO(decoded_file)
|
|
reader = csv.reader(io_string)
|
|
|
|
# Skip header if present
|
|
first_row = next(reader, None)
|
|
if not first_row:
|
|
messages.error(request, "CSV file is empty.")
|
|
return render(request, 'surveys/manual_send_csv.html', {'form': form})
|
|
|
|
# Check if first row is header or data
|
|
rows = []
|
|
if first_row[0].strip().lower() in ['phone', 'phone_number', 'mobile', 'number', 'tel']:
|
|
# First row is header, use remaining rows
|
|
pass
|
|
else:
|
|
# First row is data
|
|
rows.append(first_row)
|
|
|
|
# Read remaining rows
|
|
for row in reader:
|
|
if row and row[0].strip(): # Skip empty rows
|
|
rows.append(row)
|
|
|
|
if not rows:
|
|
messages.error(request, "No valid phone numbers found in CSV.")
|
|
return render(request, 'surveys/manual_send_csv.html', {'form': form})
|
|
|
|
# Process each row
|
|
from .models import SurveyStatus
|
|
|
|
success_count = 0
|
|
failed_count = 0
|
|
failed_numbers = []
|
|
created_instances = []
|
|
|
|
import logging
|
|
logger = logging.getLogger(__name__)
|
|
|
|
for row in rows:
|
|
try:
|
|
phone_number = row[0].strip() if len(row) > 0 else ''
|
|
recipient_name = row[1].strip() if len(row) > 1 else ''
|
|
|
|
# Clean phone number
|
|
phone_number = phone_number.replace(' ', '').replace('-', '').replace('(', '').replace(')', '')
|
|
|
|
logger.info(f"Processing row: phone={phone_number}, name={recipient_name}")
|
|
|
|
# Skip empty or invalid
|
|
if not phone_number or not phone_number.startswith('+'):
|
|
failed_count += 1
|
|
failed_numbers.append(f"{phone_number} (invalid format - must start with +)")
|
|
logger.warning(f"Invalid phone format: {phone_number}")
|
|
continue
|
|
|
|
# Create survey instance
|
|
survey_instance = SurveyInstance.objects.create(
|
|
survey_template=survey_template,
|
|
hospital=survey_template.hospital,
|
|
delivery_channel='sms',
|
|
recipient_phone=phone_number,
|
|
status=SurveyStatus.SENT,
|
|
metadata={
|
|
'sent_manually': True,
|
|
'sent_by': str(user.id),
|
|
'custom_message': custom_message,
|
|
'recipient_name': recipient_name,
|
|
'recipient_type': 'csv_upload',
|
|
'csv_row': row
|
|
}
|
|
)
|
|
|
|
logger.info(f"Created survey instance: {survey_instance.id}")
|
|
|
|
# Send survey
|
|
success = SurveyDeliveryService.deliver_survey(survey_instance)
|
|
|
|
logger.info(f"Survey delivery result for {phone_number}: success={success}")
|
|
|
|
if success:
|
|
success_count += 1
|
|
created_instances.append(survey_instance)
|
|
else:
|
|
failed_count += 1
|
|
failed_numbers.append(f"{phone_number} (delivery failed - check logs)")
|
|
survey_instance.delete()
|
|
|
|
except Exception as e:
|
|
failed_count += 1
|
|
phone_display = phone_number if 'phone_number' in locals() else 'unknown'
|
|
failed_numbers.append(f"{phone_display} (exception: {str(e)})")
|
|
logger.error(f"Exception processing row {row}: {str(e)}", exc_info=True)
|
|
|
|
# Log audit for bulk operation
|
|
AuditService.log_event(
|
|
event_type='survey_sent_manually_csv',
|
|
description=f"Bulk survey send via CSV: {success_count} successful, {failed_count} failed by {user.get_full_name()}",
|
|
user=user,
|
|
metadata={
|
|
'survey_template': survey_template.name,
|
|
'success_count': success_count,
|
|
'failed_count': failed_count,
|
|
'total_count': len(rows),
|
|
'custom_message': custom_message
|
|
}
|
|
)
|
|
|
|
# Show results
|
|
if success_count > 0 and failed_count == 0:
|
|
messages.success(
|
|
request,
|
|
f"Successfully sent {success_count} surveys from CSV."
|
|
)
|
|
elif success_count > 0 and failed_count > 0:
|
|
messages.warning(
|
|
request,
|
|
f"Sent {success_count} surveys successfully. {failed_count} failed. Check failed numbers: {', '.join(failed_numbers[:5])}{'...' if len(failed_numbers) > 5 else ''}"
|
|
)
|
|
else:
|
|
messages.error(
|
|
request,
|
|
f"All {failed_count} surveys failed to send. Check the phone numbers and try again."
|
|
)
|
|
|
|
# Redirect to list view with filter for these surveys
|
|
if created_instances:
|
|
return redirect('surveys:instance_list')
|
|
else:
|
|
return render(request, 'surveys/manual_send_csv.html', {'form': form})
|
|
|
|
except Exception as e:
|
|
import logging
|
|
logger = logging.getLogger(__name__)
|
|
logger.error(f"Error processing CSV upload: {str(e)}", exc_info=True)
|
|
messages.error(request, f"Error processing CSV: {str(e)}")
|
|
return render(request, 'surveys/manual_send_csv.html', {'form': form})
|
|
else:
|
|
form = BulkCSVSurveySendForm(user)
|
|
|
|
context = {
|
|
'form': form,
|
|
}
|
|
|
|
return render(request, 'surveys/manual_send_csv.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def survey_analytics_reports(request):
|
|
"""
|
|
Survey analytics reports management page.
|
|
|
|
Features:
|
|
- List all available reports
|
|
- View report details
|
|
- Generate new reports
|
|
- Download reports
|
|
- Delete reports
|
|
"""
|
|
import os
|
|
from django.conf import settings
|
|
|
|
user = request.user
|
|
|
|
# Check permission - only admins and hospital admins can view reports
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
messages.error(request, "You don't have permission to view analytics reports.")
|
|
return redirect('surveys:instance_list')
|
|
|
|
output_dir = getattr(settings, 'SURVEY_REPORTS_DIR', 'reports')
|
|
|
|
# Get all reports
|
|
reports = []
|
|
if os.path.exists(output_dir):
|
|
for filename in os.listdir(output_dir):
|
|
filepath = os.path.join(output_dir, filename)
|
|
if os.path.isfile(filepath):
|
|
stat = os.stat(filepath)
|
|
report_type = 'unknown'
|
|
if filename.endswith('.json'):
|
|
report_type = 'json'
|
|
elif filename.endswith('.html'):
|
|
report_type = 'html'
|
|
elif filename.endswith('.md'):
|
|
report_type = 'markdown'
|
|
|
|
reports.append({
|
|
'filename': filename,
|
|
'type': report_type,
|
|
'size': stat.st_size,
|
|
'size_human': _human_readable_size(stat.st_size),
|
|
'created': stat.st_ctime,
|
|
'created_date': datetime.fromtimestamp(stat.st_ctime),
|
|
'modified': stat.st_mtime,
|
|
})
|
|
|
|
# Sort by creation date (newest first)
|
|
reports.sort(key=lambda x: x['created'], reverse=True)
|
|
|
|
# Statistics
|
|
total_reports = len(reports)
|
|
json_reports = len([r for r in reports if r['type'] == 'json'])
|
|
html_reports = len([r for r in reports if r['type'] == 'html'])
|
|
markdown_reports = len([r for r in reports if r['type'] == 'markdown'])
|
|
|
|
context = {
|
|
'reports': reports,
|
|
'stats': {
|
|
'total': total_reports,
|
|
'json': json_reports,
|
|
'html': html_reports,
|
|
'markdown': markdown_reports,
|
|
},
|
|
}
|
|
|
|
return render(request, 'surveys/analytics_reports.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def survey_analytics_report_view(request, filename):
|
|
"""
|
|
View a specific survey analytics report.
|
|
|
|
Features:
|
|
- Display HTML reports in browser
|
|
- Provide download links for all formats
|
|
- Show report metadata
|
|
"""
|
|
import os
|
|
from django.conf import settings
|
|
|
|
user = request.user
|
|
|
|
# Check permission
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
messages.error(request, "You don't have permission to view analytics reports.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
output_dir = getattr(settings, 'SURVEY_REPORTS_DIR', 'reports')
|
|
filepath = os.path.join(output_dir, filename)
|
|
|
|
# Security check - ensure file is in reports directory
|
|
if not os.path.abspath(filepath).startswith(os.path.abspath(output_dir)):
|
|
messages.error(request, "Invalid report file.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
if not os.path.exists(filepath):
|
|
messages.error(request, "Report file not found.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
# Determine report type
|
|
report_type = 'unknown'
|
|
if filename.endswith('.json'):
|
|
report_type = 'json'
|
|
elif filename.endswith('.html'):
|
|
report_type = 'html'
|
|
elif filename.endswith('.md'):
|
|
report_type = 'markdown'
|
|
|
|
# Get file info
|
|
stat = os.stat(filepath)
|
|
|
|
# For HTML files, render them directly
|
|
if report_type == 'html':
|
|
with open(filepath, 'r', encoding='utf-8') as f:
|
|
content = f.read()
|
|
|
|
context = {
|
|
'filename': filename,
|
|
'content': content,
|
|
'report_type': report_type,
|
|
'size': stat.st_size,
|
|
'size_human': _human_readable_size(stat.st_size),
|
|
'created_date': datetime.fromtimestamp(stat.st_ctime),
|
|
'modified_date': datetime.fromtimestamp(stat.st_mtime),
|
|
}
|
|
|
|
return render(request, 'surveys/analytics_report_view.html', context)
|
|
|
|
# For JSON and Markdown files, show info and provide download
|
|
context = {
|
|
'filename': filename,
|
|
'report_type': report_type,
|
|
'size': stat.st_size,
|
|
'size_human': _human_readable_size(stat.st_size),
|
|
'created_date': datetime.fromtimestamp(stat.st_ctime),
|
|
'modified_date': datetime.fromtimestamp(stat.st_mtime),
|
|
}
|
|
|
|
return render(request, 'surveys/analytics_report_info.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def survey_analytics_report_download(request, filename):
|
|
"""
|
|
Download a survey analytics report file.
|
|
"""
|
|
import os
|
|
from django.conf import settings
|
|
from django.http import FileResponse
|
|
|
|
user = request.user
|
|
|
|
# Check permission
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
messages.error(request, "You don't have permission to download analytics reports.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
output_dir = getattr(settings, 'SURVEY_REPORTS_DIR', 'reports')
|
|
filepath = os.path.join(output_dir, filename)
|
|
|
|
# Security check
|
|
if not os.path.abspath(filepath).startswith(os.path.abspath(output_dir)):
|
|
messages.error(request, "Invalid report file.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
if not os.path.exists(filepath):
|
|
messages.error(request, "Report file not found.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
# Determine content type
|
|
content_type = 'application/octet-stream'
|
|
if filename.endswith('.html'):
|
|
content_type = 'text/html'
|
|
elif filename.endswith('.json'):
|
|
content_type = 'application/json'
|
|
elif filename.endswith('.md'):
|
|
content_type = 'text/markdown'
|
|
|
|
# Send file
|
|
return FileResponse(
|
|
open(filepath, 'rb'),
|
|
content_type=content_type,
|
|
as_attachment=True,
|
|
filename=filename
|
|
)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def survey_analytics_report_view_inline(request, filename):
|
|
"""
|
|
View a survey analytics report inline in the browser.
|
|
|
|
Unlike download, this displays the file content directly in the browser
|
|
without forcing a download. Works for HTML, JSON, and Markdown files.
|
|
"""
|
|
import os
|
|
from django.conf import settings
|
|
from django.http import FileResponse, HttpResponse
|
|
|
|
user = request.user
|
|
|
|
# Check permission
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
messages.error(request, "You don't have permission to view analytics reports.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
output_dir = getattr(settings, 'SURVEY_REPORTS_DIR', 'reports')
|
|
filepath = os.path.join(output_dir, filename)
|
|
|
|
# Security check
|
|
if not os.path.abspath(filepath).startswith(os.path.abspath(output_dir)):
|
|
messages.error(request, "Invalid report file.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
if not os.path.exists(filepath):
|
|
messages.error(request, "Report file not found.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
# Determine content type
|
|
content_type = 'application/octet-stream'
|
|
if filename.endswith('.html'):
|
|
content_type = 'text/html'
|
|
elif filename.endswith('.json'):
|
|
content_type = 'application/json'
|
|
elif filename.endswith('.md'):
|
|
content_type = 'text/plain; charset=utf-8' # Plain text for markdown
|
|
|
|
# For HTML and JSON, serve inline with FileResponse
|
|
if filename.endswith(('.html', '.json')):
|
|
response = FileResponse(
|
|
open(filepath, 'rb'),
|
|
content_type=content_type,
|
|
as_attachment=False # Display inline
|
|
)
|
|
# Add CSP header to allow inline scripts for HTML reports
|
|
if filename.endswith('.html'):
|
|
response['Content-Security-Policy'] = "default-src 'self' 'unsafe-inline' 'unsafe-eval' cdn.jsdelivr.net cdnjs.cloudflare.com; script-src 'self' 'unsafe-inline' 'unsafe-eval' cdn.jsdelivr.net; style-src 'self' 'unsafe-inline' cdn.jsdelivr.net cdnjs.cloudflare.com;"
|
|
return response
|
|
|
|
# For Markdown, render it in a template with viewer
|
|
elif filename.endswith('.md'):
|
|
with open(filepath, 'r', encoding='utf-8') as f:
|
|
content = f.read()
|
|
|
|
stat = os.stat(filepath)
|
|
context = {
|
|
'filename': filename,
|
|
'content': content,
|
|
'report_type': 'markdown',
|
|
'size': stat.st_size,
|
|
'size_human': _human_readable_size(stat.st_size),
|
|
'created_date': datetime.fromtimestamp(stat.st_ctime),
|
|
'modified_date': datetime.fromtimestamp(stat.st_mtime),
|
|
}
|
|
return render(request, 'surveys/analytics_report_markdown_view.html', context)
|
|
|
|
# For other files, fallback to download
|
|
return FileResponse(
|
|
open(filepath, 'rb'),
|
|
content_type=content_type,
|
|
as_attachment=True,
|
|
filename=filename
|
|
)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
@require_http_methods(["POST"])
|
|
def survey_analytics_report_delete(request, filename):
|
|
"""
|
|
Delete a survey analytics report file.
|
|
"""
|
|
import os
|
|
from django.conf import settings
|
|
|
|
user = request.user
|
|
|
|
# Check permission - only PX admins can delete reports
|
|
if not user.is_px_admin():
|
|
messages.error(request, "You don't have permission to delete analytics reports.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
output_dir = getattr(settings, 'SURVEY_REPORTS_DIR', 'reports')
|
|
filepath = os.path.join(output_dir, filename)
|
|
|
|
# Security check
|
|
if not os.path.abspath(filepath).startswith(os.path.abspath(output_dir)):
|
|
messages.error(request, "Invalid report file.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
if not os.path.exists(filepath):
|
|
messages.error(request, "Report file not found.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
try:
|
|
os.remove(filepath)
|
|
messages.success(request, f"Report '{filename}' deleted successfully.")
|
|
except Exception as e:
|
|
messages.error(request, f"Error deleting report: {str(e)}")
|
|
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
|
|
def _human_readable_size(size_bytes):
|
|
"""Convert bytes to human readable format"""
|
|
for unit in ['B', 'KB', 'MB', 'GB']:
|
|
if size_bytes < 1024.0:
|
|
return f"{size_bytes:.2f} {unit}"
|
|
size_bytes /= 1024.0
|
|
return f"{size_bytes:.2f} TB"
|
|
|
|
|
|
|
|
# ============================================================================
|
|
# ENHANCED SURVEY REPORTS - Separate reports per survey type
|
|
# ============================================================================
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def enhanced_survey_reports_list(request):
|
|
"""
|
|
List all enhanced survey report directories.
|
|
"""
|
|
from django.conf import settings
|
|
import os
|
|
|
|
user = request.user
|
|
|
|
# Check permission
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
messages.error(request, "You don't have permission to view analytics reports.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
output_dir = getattr(settings, 'SURVEY_REPORTS_DIR', 'reports')
|
|
|
|
# Find all report directories (folders starting with "reports_")
|
|
report_sets = []
|
|
if os.path.exists(output_dir):
|
|
for item in sorted(os.listdir(output_dir), reverse=True):
|
|
item_path = os.path.join(output_dir, item)
|
|
if os.path.isdir(item_path) and item.startswith('reports_'):
|
|
# Check if it has an index.html
|
|
index_path = os.path.join(item_path, 'index.html')
|
|
if os.path.exists(index_path):
|
|
stat = os.stat(item_path)
|
|
# Count individual reports
|
|
report_count = len([f for f in os.listdir(item_path) if f.endswith('.html') and f != 'index.html'])
|
|
|
|
report_sets.append({
|
|
'dir_name': item,
|
|
'created': datetime.fromtimestamp(stat.st_ctime),
|
|
'modified': datetime.fromtimestamp(stat.st_mtime),
|
|
'report_count': report_count,
|
|
'size': sum(os.path.getsize(os.path.join(item_path, f)) for f in os.listdir(item_path) if os.path.isfile(os.path.join(item_path, f)))
|
|
})
|
|
|
|
context = {
|
|
'report_sets': report_sets,
|
|
}
|
|
|
|
return render(request, 'surveys/enhanced_reports_list.html', context)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def enhanced_survey_report_view(request, dir_name):
|
|
"""
|
|
View the index of an enhanced report set.
|
|
"""
|
|
from django.conf import settings
|
|
import os
|
|
|
|
user = request.user
|
|
|
|
# Check permission
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
messages.error(request, "You don't have permission to view analytics reports.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
output_dir = getattr(settings, 'SURVEY_REPORTS_DIR', 'reports')
|
|
dir_path = os.path.join(output_dir, dir_name)
|
|
|
|
# Security check
|
|
if not os.path.abspath(dir_path).startswith(os.path.abspath(output_dir)):
|
|
messages.error(request, "Invalid report directory.")
|
|
return redirect('surveys:enhanced_reports_list')
|
|
|
|
if not os.path.exists(dir_path):
|
|
messages.error(request, "Report directory not found.")
|
|
return redirect('surveys:enhanced_reports_list')
|
|
|
|
# Serve the index.html file
|
|
index_path = os.path.join(dir_path, 'index.html')
|
|
if os.path.exists(index_path):
|
|
with open(index_path, 'r', encoding='utf-8') as f:
|
|
content = f.read()
|
|
return HttpResponse(content, content_type='text/html')
|
|
|
|
messages.error(request, "Index file not found.")
|
|
return redirect('surveys:enhanced_reports_list')
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def enhanced_survey_report_file(request, dir_name, filename):
|
|
"""
|
|
View/serve an individual enhanced report file.
|
|
"""
|
|
from django.conf import settings
|
|
import os
|
|
from django.http import FileResponse
|
|
|
|
user = request.user
|
|
|
|
# Check permission
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
messages.error(request, "You don't have permission to view analytics reports.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
output_dir = getattr(settings, 'SURVEY_REPORTS_DIR', 'reports')
|
|
dir_path = os.path.join(output_dir, dir_name)
|
|
filepath = os.path.join(dir_path, filename)
|
|
|
|
# Security check
|
|
if not os.path.abspath(filepath).startswith(os.path.abspath(dir_path)):
|
|
messages.error(request, "Invalid file path.")
|
|
return redirect('surveys:enhanced_reports_list')
|
|
|
|
if not os.path.exists(filepath):
|
|
messages.error(request, "File not found.")
|
|
return redirect('surveys:enhanced_reports_list')
|
|
|
|
# Serve file based on type
|
|
if filename.endswith('.html'):
|
|
with open(filepath, 'r', encoding='utf-8') as f:
|
|
content = f.read()
|
|
response = HttpResponse(content, content_type='text/html')
|
|
# Allow inline scripts/CDN resources
|
|
response['Content-Security-Policy'] = "default-src 'self' 'unsafe-inline' 'unsafe-eval' cdn.jsdelivr.net cdnjs.cloudflare.com unpkg.com; script-src 'self' 'unsafe-inline' 'unsafe-eval' cdn.jsdelivr.net unpkg.com; style-src 'self' 'unsafe-inline' cdn.jsdelivr.net cdnjs.cloudflare.com fonts.googleapis.com; font-src 'self' fonts.gstatic.com;"
|
|
return response
|
|
elif filename.endswith('.json'):
|
|
return FileResponse(open(filepath, 'rb'), content_type='application/json')
|
|
else:
|
|
return FileResponse(open(filepath, 'rb'), as_attachment=True)
|
|
|
|
|
|
@block_source_user
|
|
@login_required
|
|
def generate_enhanced_report_ui(request):
|
|
"""
|
|
UI view to generate enhanced reports with form.
|
|
"""
|
|
from apps.surveys.models import SurveyTemplate
|
|
from django.conf import settings
|
|
|
|
user = request.user
|
|
|
|
# Check permission
|
|
if not user.is_px_admin() and not user.is_hospital_admin():
|
|
messages.error(request, "You don't have permission to generate analytics reports.")
|
|
return redirect('surveys:analytics_reports')
|
|
|
|
if request.method == 'POST':
|
|
template_id = request.POST.get('template')
|
|
start_date = request.POST.get('start_date')
|
|
end_date = request.POST.get('end_date')
|
|
|
|
try:
|
|
# Get template name if specified
|
|
template_name = None
|
|
if template_id:
|
|
try:
|
|
template = SurveyTemplate.objects.get(id=template_id)
|
|
template_name = template.name
|
|
except SurveyTemplate.DoesNotExist:
|
|
pass
|
|
|
|
# Parse dates
|
|
start_dt = None
|
|
end_dt = None
|
|
if start_date:
|
|
start_dt = datetime.strptime(start_date, '%Y-%m-%d').date()
|
|
if end_date:
|
|
end_dt = datetime.strptime(end_date, '%Y-%m-%d').date()
|
|
|
|
# Generate enhanced reports
|
|
from .analytics_utils import generate_enhanced_survey_reports
|
|
result = generate_enhanced_survey_reports(
|
|
template_name=template_name,
|
|
start_date=start_dt,
|
|
end_date=end_dt
|
|
)
|
|
|
|
messages.success(
|
|
request,
|
|
f"Generated {len(result['individual_reports'])} reports successfully!"
|
|
)
|
|
|
|
# Redirect to the report directory
|
|
dir_name = os.path.basename(result['reports_dir'])
|
|
return redirect('surveys:enhanced_report_view', dir_name=dir_name)
|
|
|
|
except Exception as e:
|
|
messages.error(request, f"Error generating reports: {str(e)}")
|
|
return redirect('surveys:enhanced_reports_list')
|
|
|
|
# GET request - show form
|
|
templates = SurveyTemplate.objects.filter(is_active=True).order_by('name')
|
|
|
|
context = {
|
|
'templates': templates,
|
|
}
|
|
|
|
return render(request, 'surveys/generate_enhanced_report.html', context)
|
|
|