marwan/HH
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
HH/apps/dashboard/views.py
ismail c5f76b3855
Some checks are pending
Build and Push Docker Image / build (push) Waiting to run
Details
updates
2026-05-11 14:45:30 +03:00

2882 lines
118 KiB
Python
Raw Blame History

"""
Dashboard views - PX Command Center and analytics dashboards
"""
import json
from datetime import timedelta, datetime
from django.contrib.auth.decorators import login_required
from django.contrib.auth.mixins import LoginRequiredMixin
from django.core.paginator import Paginator
from django.db.models import Avg, Count, Q, Sum
from django.http import JsonResponse
from django.shortcuts import redirect, render, reverse
from django.utils import timezone
from django.views.generic import TemplateView
from django.utils.translation import gettext_lazy as _
from django.contrib import messages
class CommandCenterView(LoginRequiredMixin, TemplateView):
"""
PX Command Center Dashboard - Real-time control panel.
Shows:
- Red Alert Banner (urgent items requiring immediate attention)
- Top KPI cards (complaints, actions, surveys, etc.) with drill-down
- Charts (trends, satisfaction, leaderboards)
- Live feed (latest complaints, actions, events)
- Enhanced modules (Inquiries, Observations)
- Filters (date range, hospital, department)
Follows the "5-Second Rule": Critical signals dominant and comprehensible within 5 seconds.
Uses modular tile/card system with 30-60 second auto-refresh capability.
"""
template_name = "dashboard/command_center.html"
def dispatch(self, request, *args, **kwargs):
"""Check user type and redirect accordingly"""
if request.user.is_authenticated and request.user.is_source_user():
return redirect("px_sources:source_user_dashboard")
if request.user.is_authenticated and request.user.is_basic_staff():
if hasattr(request.user, "department") and request.user.department:
return redirect("organizations:department_detail", pk=request.user.department.pk)
if request.user.is_authenticated and request.user.is_champion() and request.user.department:
return redirect("organizations:department_detail", pk=request.user.department.pk)
if request.user.is_authenticated and request.user.is_department_manager() and request.user.department:
return redirect("organizations:department_detail", pk=request.user.department.pk)
if request.user.is_authenticated and request.user.is_px_admin() and not request.tenant_hospital:
return redirect("core:select_hospital")
return super().dispatch(request, *args, **kwargs)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
user = self.request.user
# Import models
from apps.complaints.models import Complaint, Inquiry
from apps.px_action_center.models import PXAction
from apps.surveys.models import SurveyInstance
from apps.callcenter.models import CallCenterInteraction
from apps.integrations.models import InboundEvent
from apps.physicians.models import PhysicianMonthlyRating
from apps.organizations.models import Staff
from apps.observations.models import Observation
# Date filters
now = timezone.now()
last_24h = now - timedelta(hours=24)
last_7d = now - timedelta(days=7)
last_30d = now - timedelta(days=30)
last_60d = now - timedelta(days=60)
# Base querysets (filtered by user role and tenant_hospital)
if user.is_px_admin():
# PX Admins use their selected hospital from session
hospital = self.request.tenant_hospital
complaints_qs = Complaint.objects.filter(hospital=hospital) if hospital else Complaint.objects.none()
inquiries_qs = Inquiry.objects.filter(hospital=hospital) if hospital else Inquiry.objects.none()
actions_qs = PXAction.objects.filter(hospital=hospital) if hospital else PXAction.objects.none()
surveys_qs = (
SurveyInstance.objects.filter(hospital=hospital) if hospital else SurveyInstance.objects.none()
) # Filter by tenant hospital
calls_qs = (
CallCenterInteraction.objects.filter(hospital=hospital)
if hospital
else CallCenterInteraction.objects.none()
)
observations_qs = Observation.objects.filter(hospital=hospital) if hospital else Observation.objects.none()
elif user.is_hospital_admin() and user.hospital:
complaints_qs = Complaint.objects.filter(hospital=user.hospital)
inquiries_qs = Inquiry.objects.filter(hospital=user.hospital)
actions_qs = PXAction.objects.filter(hospital=user.hospital)
surveys_qs = SurveyInstance.objects.filter(hospital=user.hospital)
calls_qs = CallCenterInteraction.objects.filter(hospital=user.hospital)
observations_qs = Observation.objects.filter(hospital=user.hospital)
elif user.is_department_manager() and user.department:
complaints_qs = Complaint.objects.filter(department=user.department)
inquiries_qs = Inquiry.objects.filter(department=user.department)
actions_qs = PXAction.objects.filter(department=user.department)
surveys_qs = SurveyInstance.objects.filter(journey_instance__department=user.department)
calls_qs = CallCenterInteraction.objects.filter(department=user.department)
observations_qs = Observation.objects.filter(assigned_department=user.department)
elif user.is_champion() and user.department:
complaints_qs = Complaint.objects.filter(department=user.department)
inquiries_qs = Inquiry.objects.filter(
Q(department=user.department) | Q(outgoing_department=user.department)
)
actions_qs = PXAction.objects.filter(department=user.department)
surveys_qs = SurveyInstance.objects.none()
calls_qs = CallCenterInteraction.objects.none()
observations_qs = Observation.objects.filter(assigned_department=user.department)
elif user.is_director():
directed_depts = user.get_directed_departments()
if directed_depts.exists():
complaints_qs = Complaint.objects.filter(department__in=directed_depts)
inquiries_qs = Inquiry.objects.filter(department__in=directed_depts)
actions_qs = PXAction.objects.filter(department__in=directed_depts)
surveys_qs = SurveyInstance.objects.filter(journey_instance__department__in=directed_depts)
calls_qs = CallCenterInteraction.objects.filter(department__in=directed_depts)
observations_qs = Observation.objects.filter(assigned_department__in=directed_depts)
else:
complaints_qs = Complaint.objects.none()
inquiries_qs = Inquiry.objects.none()
actions_qs = PXAction.objects.none()
surveys_qs = SurveyInstance.objects.none()
calls_qs = CallCenterInteraction.objects.none()
observations_qs = Observation.objects.none()
else:
complaints_qs = Complaint.objects.none()
inquiries_qs = Inquiry.objects.none()
actions_qs = PXAction.objects.none()
surveys_qs = SurveyInstance.objects.none()
calls_qs = CallCenterInteraction.objects.none()
observations_qs = Observation.objects.none()
# ========================================
# RED ALERT ITEMS (5-Second Rule)
# ========================================
red_alerts = []
# Critical complaints
critical_complaints = complaints_qs.filter(severity="critical", status__in=["open", "in_progress"]).count()
if critical_complaints > 0:
red_alerts.append(
{
"type": "critical_complaints",
"label": _("Critical Complaints"),
"value": critical_complaints,
"icon": "alert-octagon",
"color": "red",
"url": f"{reverse('complaints:complaint_list')}?severity=critical&status=open,in_progress",
"priority": 1,
}
)
# Overdue complaints
overdue_complaints = complaints_qs.filter(is_overdue=True, status__in=["open", "in_progress"]).count()
if overdue_complaints > 0:
red_alerts.append(
{
"type": "overdue_complaints",
"label": _("Overdue Complaints"),
"value": overdue_complaints,
"icon": "clock",
"color": "orange",
"url": f"{reverse('complaints:complaint_list')}?is_overdue=true&status=open,in_progress",
"priority": 2,
}
)
# Escalated actions
escalated_actions = actions_qs.filter(escalation_level__gt=0, status__in=["open", "in_progress"]).count()
if escalated_actions > 0:
red_alerts.append(
{
"type": "escalated_actions",
"label": _("Escalated Actions"),
"value": escalated_actions,
"icon": "arrow-up-circle",
"color": "red",
"url": reverse("actions:action_list"),
"priority": 3,
}
)
# Negative surveys in last 24h
negative_surveys_24h = surveys_qs.filter(is_negative=True, completed_at__gte=last_24h).count()
if negative_surveys_24h > 0:
red_alerts.append(
{
"type": "negative_surveys",
"label": _("Negative Surveys (24h)"),
"value": negative_surveys_24h,
"icon": "frown",
"color": "yellow",
"url": reverse("surveys:instance_list"),
"priority": 4,
}
)
# Sort by priority
red_alerts.sort(key=lambda x: x["priority"])
context["red_alerts"] = red_alerts
context["has_red_alerts"] = len(red_alerts) > 0
# ========================================
# COMPLAINTS MODULE DATA
# ========================================
complaints_current = complaints_qs.filter(created_at__gte=last_30d).count()
complaints_previous = complaints_qs.filter(created_at__gte=last_60d, created_at__lt=last_30d).count()
complaints_variance = 0
if complaints_previous > 0:
complaints_variance = round(((complaints_current - complaints_previous) / complaints_previous) * 100, 1)
# Resolution time calculation
resolved_complaints = complaints_qs.filter(status="closed", closed_at__isnull=False, created_at__gte=last_30d)
avg_resolution_hours = 0
if resolved_complaints.exists():
total_hours = sum((c.closed_at - c.created_at).total_seconds() / 3600 for c in resolved_complaints)
avg_resolution_hours = round(total_hours / resolved_complaints.count(), 1)
# Complaints by severity for donut chart
complaints_by_severity = {
"critical": complaints_qs.filter(severity="critical", status__in=["open", "in_progress"]).count(),
"high": complaints_qs.filter(severity="high", status__in=["open", "in_progress"]).count(),
"medium": complaints_qs.filter(severity="medium", status__in=["open", "in_progress"]).count(),
"low": complaints_qs.filter(severity="low", status__in=["open", "in_progress"]).count(),
}
# Complaints by department for heatmap
complaints_by_department = list(
complaints_qs.filter(status__in=["open", "in_progress"], department__isnull=False)
.values("department__name")
.annotate(count=Count("id"))
.order_by("-count")[:10]
)
context["complaints_module"] = {
"total_active": complaints_qs.filter(status__in=["open", "in_progress"]).count(),
"current_period": complaints_current,
"previous_period": complaints_previous,
"variance": complaints_variance,
"variance_direction": "up" if complaints_variance > 0 else "down" if complaints_variance < 0 else "neutral",
"avg_resolution_hours": avg_resolution_hours,
"overdue": complaints_qs.filter(is_overdue=True, status__in=["open", "in_progress"]).count(),
"by_severity": complaints_by_severity,
"by_department": complaints_by_department,
"critical_new": complaints_qs.filter(severity="critical", created_at__gte=last_24h).count(),
}
# ========================================
# SURVEY INSIGHTS MODULE DATA
# ========================================
surveys_completed_30d = surveys_qs.filter(completed_at__gte=last_30d)
total_surveys_30d = surveys_completed_30d.count()
# Calculate average satisfaction
avg_satisfaction = (
surveys_completed_30d.filter(total_score__isnull=False).aggregate(Avg("total_score"))["total_score__avg"]
or 0
)
# NPS-style calculation (promoters - detractors)
positive_count = surveys_completed_30d.filter(is_negative=False).count()
negative_count = surveys_completed_30d.filter(is_negative=True).count()
nps_score = 0
if total_surveys_30d > 0:
nps_score = round(((positive_count - negative_count) / total_surveys_30d) * 100)
# Response rate (completed vs sent in last 30 days)
surveys_sent_30d = surveys_qs.filter(sent_at__gte=last_30d).count()
response_rate = 0
if surveys_sent_30d > 0:
response_rate = round((total_surveys_30d / surveys_sent_30d) * 100, 1)
context["survey_module"] = {
"avg_satisfaction": round(avg_satisfaction, 1),
"nps_score": nps_score,
"response_rate": response_rate,
"total_completed": total_surveys_30d,
"positive_count": positive_count,
"negative_count": negative_count,
"neutral_count": total_surveys_30d - positive_count - negative_count,
"negative_24h": surveys_qs.filter(is_negative=True, completed_at__gte=last_24h).count(),
}
# ========================================
# PX ACTIONS MODULE DATA
# ========================================
actions_open = actions_qs.filter(status="open").count()
actions_in_progress = actions_qs.filter(status="in_progress").count()
actions_pending_approval = actions_qs.filter(status="pending_approval").count()
actions_closed_30d = actions_qs.filter(status="closed", closed_at__gte=last_30d).count()
# Time to close calculation
closed_actions = actions_qs.filter(status="closed", closed_at__isnull=False, created_at__gte=last_30d)
avg_time_to_close_hours = 0
if closed_actions.exists():
total_hours = sum((a.closed_at - a.created_at).total_seconds() / 3600 for a in closed_actions)
avg_time_to_close_hours = round(total_hours / closed_actions.count(), 1)
# Actions by source for breakdown
actions_by_source = list(
actions_qs.filter(status__in=["open", "in_progress"])
.values("source_type")
.annotate(count=Count("id"))
.order_by("-count")
)
context["actions_module"] = {
"open": actions_open,
"in_progress": actions_in_progress,
"pending_approval": actions_pending_approval,
"overdue": actions_qs.filter(is_overdue=True, status__in=["open", "in_progress"]).count(),
"escalated": actions_qs.filter(escalation_level__gt=0, status__in=["open", "in_progress"]).count(),
"closed_30d": actions_closed_30d,
"avg_time_to_close_hours": avg_time_to_close_hours,
"by_source": actions_by_source,
"new_today": actions_qs.filter(created_at__gte=last_24h).count(),
}
# ========================================
# INQUIRIES MODULE DATA
# ========================================
inquiries_open = inquiries_qs.filter(status="open").count()
inquiries_in_progress = inquiries_qs.filter(status="in_progress").count()
inquiries_resolved_30d = inquiries_qs.filter(status="resolved", updated_at__gte=last_30d).count()
context["inquiries_module"] = {
"open": inquiries_open,
"in_progress": inquiries_in_progress,
"total_active": inquiries_open + inquiries_in_progress,
"resolved_30d": inquiries_resolved_30d,
"new_24h": inquiries_qs.filter(created_at__gte=last_24h).count(),
}
# ========================================
# OBSERVATIONS MODULE DATA
# ========================================
observations_new = observations_qs.filter(status="new").count()
observations_in_progress = observations_qs.filter(status="in_progress").count()
observations_critical = observations_qs.filter(
severity="critical", status__in=["new", "triaged", "assigned", "in_progress"]
).count()
# Observations by category
observations_by_category = list(
observations_qs.filter(status__in=["new", "triaged", "assigned", "in_progress"])
.values("category__name_en")
.annotate(count=Count("id"))
.order_by("-count")[:5]
)
context["observations_module"] = {
"new": observations_new,
"in_progress": observations_in_progress,
"critical": observations_critical,
"total_active": observations_new + observations_in_progress,
"resolved_30d": observations_qs.filter(status="resolved", resolved_at__gte=last_30d).count(),
"by_category": observations_by_category,
}
# ========================================
# COMMUNICATION/CALL CENTER MODULE DATA
# ========================================
calls_7d = calls_qs.filter(call_started_at__gte=last_7d)
total_calls = calls_7d.count()
low_rating_calls = calls_7d.filter(is_low_rating=True).count()
context["calls_module"] = {
"total_7d": total_calls,
"low_ratings": low_rating_calls,
"satisfaction_rate": round(((total_calls - low_rating_calls) / total_calls * 100), 1)
if total_calls > 0
else 0,
}
# ========================================
# LEGACY STATS (for backward compatibility)
# ========================================
context["stats"] = {
"total_complaints": context["complaints_module"]["total_active"],
"avg_resolution_time": f"{avg_resolution_hours}h",
"satisfaction_score": round(avg_satisfaction, 0),
"active_actions": context["actions_module"]["open"] + context["actions_module"]["in_progress"],
"new_today": context["actions_module"]["new_today"],
}
# ========================================
# LATEST ITEMS FOR LIVE FEED
# ========================================
# Latest high severity complaints
context["latest_complaints"] = (
complaints_qs.filter(severity__in=["high", "critical"])
.select_related("patient", "hospital", "department")
.order_by("-created_at")[:5]
)
# Latest escalated actions
context["latest_actions"] = (
actions_qs.filter(escalation_level__gt=0)
.select_related("hospital", "assigned_to")
.order_by("-escalated_at")[:5]
)
# Latest inquiries
context["latest_inquiries"] = (
inquiries_qs.filter(status__in=["open", "in_progress"])
.select_related("patient", "hospital", "department")
.order_by("-created_at")[:5]
)
# Latest observations
context["latest_observations"] = (
observations_qs.filter(status__in=["new", "triaged", "assigned"])
.select_related("hospital", "category")
.order_by("-created_at")[:5]
)
# Latest integration events
context["latest_events"] = (
InboundEvent.objects.filter(status="processed").select_related().order_by("-processed_at")[:10]
)
# ========================================
# PHYSICIAN LEADERBOARD
# ========================================
current_month_ratings = PhysicianMonthlyRating.objects.filter(year=now.year, month=now.month).select_related(
"staff", "staff__hospital", "staff__department"
)
# Filter by user role
if user.is_hospital_admin() and user.hospital:
current_month_ratings = current_month_ratings.filter(staff__hospital=user.hospital)
elif user.is_department_manager() and user.department:
current_month_ratings = current_month_ratings.filter(staff__department=user.department)
elif user.is_director():
directed_depts = user.get_directed_departments()
if directed_depts.exists():
current_month_ratings = current_month_ratings.filter(staff__department__in=directed_depts)
else:
current_month_ratings = current_month_ratings.none()
# Top 5 staff this month
context["top_physicians"] = current_month_ratings.order_by("-average_rating")[:5]
# Staff stats
physician_stats = current_month_ratings.aggregate(
total_physicians=Count("id"), avg_rating=Avg("average_rating"), total_surveys=Count("total_surveys")
)
context["physician_stats"] = physician_stats
# ========================================
# CHART DATA
# ========================================
context["chart_data"] = {
"complaints_trend": json.dumps(self.get_complaints_trend(complaints_qs, last_30d)),
"complaints_by_severity": json.dumps(complaints_by_severity),
"survey_satisfaction": avg_satisfaction,
"nps_trend": json.dumps(self.get_nps_trend(surveys_qs, last_30d)),
"actions_funnel": json.dumps(
{
"open": actions_open,
"in_progress": actions_in_progress,
"pending_approval": actions_pending_approval,
"closed": actions_closed_30d,
}
),
}
# Add hospital context
context["current_hospital"] = self.request.tenant_hospital
context["is_px_admin"] = user.is_px_admin()
# Last updated timestamp
context["last_updated"] = now.strftime("%Y-%m-%d %H:%M:%S")
return context
def get_complaints_trend(self, queryset, start_date):
"""Get complaints trend data for chart"""
# Group by day for last 30 days
data = []
for i in range(30):
date = start_date + timedelta(days=i)
count = queryset.filter(created_at__date=date.date()).count()
data.append({"date": date.strftime("%Y-%m-%d"), "count": count})
return data
def get_nps_trend(self, queryset, start_date):
"""Get NPS trend data for chart"""
data = []
for i in range(30):
date = start_date + timedelta(days=i)
day_surveys = queryset.filter(completed_at__date=date.date())
total = day_surveys.count()
if total > 0:
positive = day_surveys.filter(is_negative=False).count()
negative = day_surveys.filter(is_negative=True).count()
nps = round(((positive - negative) / total) * 100)
else:
nps = 0
data.append({"date": date.strftime("%Y-%m-%d"), "nps": nps})
return data
def get_survey_satisfaction(self, queryset, start_date):
"""Get survey satisfaction averages"""
return (
queryset.filter(completed_at__gte=start_date, total_score__isnull=False).aggregate(Avg("total_score"))[
"total_score__avg"
]
or 0
)
@login_required
def my_dashboard(request):
"""
My Dashboard - Personal view of all assigned items.
Shows:
- Summary cards with statistics
- Tabbed interface for 6 model types:
* Complaints
* Inquiries
* Observations
* PX Actions
* Tasks (QI Project Tasks)
* Feedback
- Date range filtering
- Search and filter controls
- Export functionality (CSV/Excel)
- Bulk actions support
- Charts showing trends
"""
# Redirect Source Users to their dashboard
if request.user.is_source_user():
return redirect("px_sources:source_user_dashboard")
user = request.user
# Get selected hospital for PX Admins (from middleware)
selected_hospital = getattr(request, "tenant_hospital", None)
# Get date range filter
date_range_days = int(request.GET.get("date_range", 30))
if date_range_days == -1: # All time
start_date = None
else:
start_date = timezone.now() - timedelta(days=date_range_days)
# Get active tab
active_tab = request.GET.get("tab", "complaints")
# Get search query
search_query = request.GET.get("search", "")
# Get status filter
status_filter = request.GET.get("status", "")
# Get priority/severity filter
priority_filter = request.GET.get("priority", "")
# Build querysets for all models
querysets = {}
# 1. Complaints
from apps.complaints.models import Complaint
complaints_qs = Complaint.objects.filter(assigned_to=user)
# Filter by selected hospital for PX Admins
if selected_hospital:
complaints_qs = complaints_qs.filter(hospital=selected_hospital)
if start_date:
complaints_qs = complaints_qs.filter(created_at__gte=start_date)
if search_query:
complaints_qs = complaints_qs.filter(Q(title__icontains=search_query) | Q(description__icontains=search_query))
if status_filter:
complaints_qs = complaints_qs.filter(status=status_filter)
if priority_filter:
complaints_qs = complaints_qs.filter(severity=priority_filter)
querysets["complaints"] = complaints_qs.select_related(
"patient", "hospital", "department", "source", "created_by"
).order_by("-created_at")
# 2. Inquiries
from apps.complaints.models import Inquiry
inquiries_qs = Inquiry.objects.filter(assigned_to=user)
# Filter by selected hospital for PX Admins
if selected_hospital:
inquiries_qs = inquiries_qs.filter(hospital=selected_hospital)
if start_date:
inquiries_qs = inquiries_qs.filter(created_at__gte=start_date)
if search_query:
inquiries_qs = inquiries_qs.filter(Q(subject__icontains=search_query) | Q(message__icontains=search_query))
if status_filter:
inquiries_qs = inquiries_qs.filter(status=status_filter)
querysets["inquiries"] = inquiries_qs.select_related("patient", "hospital", "department").order_by("-created_at")
# 3. Observations
from apps.observations.models import Observation
observations_qs = Observation.objects.filter(assigned_to=user)
# Filter by selected hospital for PX Admins
if selected_hospital:
observations_qs = observations_qs.filter(hospital=selected_hospital)
if start_date:
observations_qs = observations_qs.filter(created_at__gte=start_date)
if search_query:
observations_qs = observations_qs.filter(
Q(title__icontains=search_query) | Q(description__icontains=search_query)
)
if status_filter:
observations_qs = observations_qs.filter(status=status_filter)
if priority_filter:
observations_qs = observations_qs.filter(severity=priority_filter)
querysets["observations"] = observations_qs.select_related("hospital", "assigned_department").order_by(
"-created_at"
)
# 4. PX Actions
from apps.px_action_center.models import PXAction
actions_qs = PXAction.objects.filter(assigned_to=user)
# Filter by selected hospital for PX Admins
if selected_hospital:
actions_qs = actions_qs.filter(hospital=selected_hospital)
if start_date:
actions_qs = actions_qs.filter(created_at__gte=start_date)
if search_query:
actions_qs = actions_qs.filter(Q(title__icontains=search_query) | Q(description__icontains=search_query))
if status_filter:
actions_qs = actions_qs.filter(status=status_filter)
if priority_filter:
actions_qs = actions_qs.filter(severity=priority_filter)
querysets["actions"] = actions_qs.select_related("hospital", "department", "approved_by").order_by("-created_at")
# 5. QI Project Tasks
from apps.projects.models import QIProjectTask
tasks_qs = QIProjectTask.objects.filter(assigned_to=user)
# Filter by selected hospital for PX Admins (via project)
if selected_hospital:
tasks_qs = tasks_qs.filter(project__hospital=selected_hospital)
if start_date:
tasks_qs = tasks_qs.filter(created_at__gte=start_date)
if search_query:
tasks_qs = tasks_qs.filter(Q(title__icontains=search_query) | Q(description__icontains=search_query))
if status_filter:
tasks_qs = tasks_qs.filter(status=status_filter)
querysets["tasks"] = tasks_qs.select_related("project").order_by("-created_at")
# 6. Feedback
from apps.feedback.models import Feedback
feedback_qs = Feedback.objects.filter(assigned_to=user)
# Filter by selected hospital for PX Admins
if selected_hospital:
feedback_qs = feedback_qs.filter(hospital=selected_hospital)
if start_date:
feedback_qs = feedback_qs.filter(created_at__gte=start_date)
if search_query:
feedback_qs = feedback_qs.filter(Q(title__icontains=search_query) | Q(message__icontains=search_query))
if status_filter:
feedback_qs = feedback_qs.filter(status=status_filter)
if priority_filter:
feedback_qs = feedback_qs.filter(priority=priority_filter)
querysets["feedback"] = feedback_qs.select_related("hospital", "department", "patient").order_by("-created_at")
# Calculate statistics
stats = {}
total_stats = {"total": 0, "open": 0, "in_progress": 0, "resolved": 0, "closed": 0, "overdue": 0}
# Complaints stats
complaints_open = querysets["complaints"].filter(status="open").count()
complaints_in_progress = querysets["complaints"].filter(status="in_progress").count()
complaints_resolved = querysets["complaints"].filter(status="resolved").count()
complaints_closed = querysets["complaints"].filter(status="closed").count()
complaints_overdue = querysets["complaints"].filter(is_overdue=True).count()
stats["complaints"] = {
"total": querysets["complaints"].count(),
"open": complaints_open,
"in_progress": complaints_in_progress,
"resolved": complaints_resolved,
"closed": complaints_closed,
"overdue": complaints_overdue,
}
total_stats["total"] += stats["complaints"]["total"]
total_stats["open"] += complaints_open
total_stats["in_progress"] += complaints_in_progress
total_stats["resolved"] += complaints_resolved
total_stats["closed"] += complaints_closed
total_stats["overdue"] += complaints_overdue
# Inquiries stats
inquiries_open = querysets["inquiries"].filter(status="open").count()
inquiries_in_progress = querysets["inquiries"].filter(status="in_progress").count()
inquiries_resolved = querysets["inquiries"].filter(status="resolved").count()
inquiries_closed = querysets["inquiries"].filter(status="closed").count()
stats["inquiries"] = {
"total": querysets["inquiries"].count(),
"open": inquiries_open,
"in_progress": inquiries_in_progress,
"resolved": inquiries_resolved,
"closed": inquiries_closed,
"overdue": 0,
}
total_stats["total"] += stats["inquiries"]["total"]
total_stats["open"] += inquiries_open
total_stats["in_progress"] += inquiries_in_progress
total_stats["resolved"] += inquiries_resolved
total_stats["closed"] += inquiries_closed
# Observations stats
observations_open = querysets["observations"].filter(status="open").count()
observations_in_progress = querysets["observations"].filter(status="in_progress").count()
observations_closed = querysets["observations"].filter(status="closed").count()
# Observations don't have is_overdue field - set to 0
observations_overdue = 0
stats["observations"] = {
"total": querysets["observations"].count(),
"open": observations_open,
"in_progress": observations_in_progress,
"resolved": 0,
"closed": observations_closed,
"overdue": observations_overdue,
}
total_stats["total"] += stats["observations"]["total"]
total_stats["open"] += observations_open
total_stats["in_progress"] += observations_in_progress
total_stats["closed"] += observations_closed
total_stats["overdue"] += observations_overdue
# PX Actions stats
actions_open = querysets["actions"].filter(status="open").count()
actions_in_progress = querysets["actions"].filter(status="in_progress").count()
actions_closed = querysets["actions"].filter(status="closed").count()
actions_overdue = querysets["actions"].filter(is_overdue=True).count()
stats["actions"] = {
"total": querysets["actions"].count(),
"open": actions_open,
"in_progress": actions_in_progress,
"resolved": 0,
"closed": actions_closed,
"overdue": actions_overdue,
}
total_stats["total"] += stats["actions"]["total"]
total_stats["open"] += actions_open
total_stats["in_progress"] += actions_in_progress
total_stats["closed"] += actions_closed
total_stats["overdue"] += actions_overdue
# Tasks stats
tasks_open = querysets["tasks"].filter(status="open").count()
tasks_in_progress = querysets["tasks"].filter(status="in_progress").count()
tasks_closed = querysets["tasks"].filter(status="closed").count()
stats["tasks"] = {
"total": querysets["tasks"].count(),
"open": tasks_open,
"in_progress": tasks_in_progress,
"resolved": 0,
"closed": tasks_closed,
"overdue": 0,
}
total_stats["total"] += stats["tasks"]["total"]
total_stats["open"] += tasks_open
total_stats["in_progress"] += tasks_in_progress
total_stats["closed"] += tasks_closed
# Feedback stats
feedback_open = querysets["feedback"].filter(status="submitted").count()
feedback_in_progress = querysets["feedback"].filter(status="reviewed").count()
feedback_acknowledged = querysets["feedback"].filter(status="acknowledged").count()
feedback_closed = querysets["feedback"].filter(status="closed").count()
stats["feedback"] = {
"total": querysets["feedback"].count(),
"open": feedback_open,
"in_progress": feedback_in_progress,
"resolved": feedback_acknowledged,
"closed": feedback_closed,
"overdue": 0,
}
total_stats["total"] += stats["feedback"]["total"]
total_stats["open"] += feedback_open
total_stats["in_progress"] += feedback_in_progress
total_stats["resolved"] += feedback_acknowledged
total_stats["closed"] += feedback_closed
# Paginate all querysets
page_size = int(request.GET.get("page_size", 25))
paginated_data = {}
for tab_name, qs in querysets.items():
paginator = Paginator(qs, page_size)
page_number = request.GET.get(f"page_{tab_name}", 1)
paginated_data[tab_name] = paginator.get_page(page_number)
# Get chart data
chart_data = get_dashboard_chart_data(user, start_date, selected_hospital)
from apps.accounts.models import StaffActivityLog
activity_logs = StaffActivityLog.objects.filter(user=user).select_related("content_type")
if start_date:
activity_logs = activity_logs.filter(created_at__gte=start_date)
activity_logs = activity_logs[:50]
context = {
"stats": stats,
"total_stats": total_stats,
"paginated_data": paginated_data,
"active_tab": active_tab,
"date_range": date_range_days,
"search_query": search_query,
"status_filter": status_filter,
"priority_filter": priority_filter,
"chart_data": chart_data,
"selected_hospital": selected_hospital,
"activity_logs": activity_logs,
}
return render(request, "dashboard/my_dashboard.html", context)
def get_dashboard_chart_data(user, start_date=None, selected_hospital=None):
"""
Get chart data for dashboard trends.
Returns JSON-serializable data for ApexCharts.
"""
from apps.complaints.models import Complaint
from apps.px_action_center.models import PXAction
from apps.observations.models import Observation
from apps.feedback.models import Feedback
from apps.complaints.models import Inquiry
from apps.projects.models import QIProjectTask
# Default to last 30 days if no start_date
if not start_date:
start_date = timezone.now() - timedelta(days=30)
# Get completion trends
completion_data = []
labels = []
# Group by day for last 30 days
for i in range(30):
date = start_date + timedelta(days=i)
date_str = date.strftime("%Y-%m-%d")
labels.append(date.strftime("%b %d"))
completed_count = 0
# Check each model for completions on this date
# Apply hospital filter for PX Admins
complaint_qs = Complaint.objects.filter(assigned_to=user, status="closed", closed_at__date=date.date())
if selected_hospital:
complaint_qs = complaint_qs.filter(hospital=selected_hospital)
completed_count += complaint_qs.count()
inquiry_qs = Inquiry.objects.filter(assigned_to=user, status="closed", updated_at__date=date.date())
if selected_hospital:
inquiry_qs = inquiry_qs.filter(hospital=selected_hospital)
completed_count += inquiry_qs.count()
observation_qs = Observation.objects.filter(assigned_to=user, status="closed", updated_at__date=date.date())
if selected_hospital:
observation_qs = observation_qs.filter(hospital=selected_hospital)
completed_count += observation_qs.count()
action_qs = PXAction.objects.filter(assigned_to=user, status="closed", closed_at__date=date.date())
if selected_hospital:
action_qs = action_qs.filter(hospital=selected_hospital)
completed_count += action_qs.count()
task_qs = QIProjectTask.objects.filter(assigned_to=user, status="closed", completed_date=date.date())
if selected_hospital:
task_qs = task_qs.filter(project__hospital=selected_hospital)
completed_count += task_qs.count()
feedback_qs = Feedback.objects.filter(assigned_to=user, status="closed", closed_at__date=date.date())
if selected_hospital:
feedback_qs = feedback_qs.filter(hospital=selected_hospital)
completed_count += feedback_qs.count()
completion_data.append(completed_count)
return {"completion_trend": {"labels": labels, "data": completion_data}}
@login_required
def dashboard_bulk_action(request):
"""
Handle bulk actions on dashboard items.
Supported actions:
- bulk_assign: Assign to user
- bulk_status: Change status
"""
if request.method != "POST":
return JsonResponse({"success": False, "error": "POST required"}, status=405)
import json
try:
data = json.loads(request.body)
action = data.get("action")
tab_name = data.get("tab")
item_ids = data.get("item_ids", [])
if not action or not tab_name:
return JsonResponse({"success": False, "error": "Missing required fields"}, status=400)
# Route to appropriate handler based on tab
if tab_name == "complaints":
from apps.complaints.models import Complaint
queryset = Complaint.objects.filter(id__in=item_ids, assigned_to=request.user)
elif tab_name == "inquiries":
from apps.complaints.models import Inquiry
queryset = Inquiry.objects.filter(id__in=item_ids, assigned_to=request.user)
elif tab_name == "observations":
from apps.observations.models import Observation
queryset = Observation.objects.filter(id__in=item_ids, assigned_to=request.user)
elif tab_name == "actions":
from apps.px_action_center.models import PXAction
queryset = PXAction.objects.filter(id__in=item_ids, assigned_to=request.user)
elif tab_name == "tasks":
from apps.projects.models import QIProjectTask
queryset = QIProjectTask.objects.filter(id__in=item_ids, assigned_to=request.user)
elif tab_name == "feedback":
from apps.feedback.models import Feedback
queryset = Feedback.objects.filter(id__in=item_ids, assigned_to=request.user)
else:
return JsonResponse({"success": False, "error": "Invalid tab"}, status=400)
# Apply bulk action
if action == "bulk_status":
new_status = data.get("new_status")
if not new_status:
return JsonResponse({"success": False, "error": "Missing new_status"}, status=400)
count = queryset.update(status=new_status)
return JsonResponse({"success": True, "updated_count": count})
elif action == "bulk_assign":
user_id = data.get("user_id")
if not user_id:
return JsonResponse({"success": False, "error": "Missing user_id"}, status=400)
from apps.accounts.models import User
assignee = User.objects.get(id=user_id)
count = queryset.update(assigned_to=assignee, assigned_at=timezone.now())
return JsonResponse({"success": True, "updated_count": count})
else:
return JsonResponse({"success": False, "error": "Invalid action"}, status=400)
except json.JSONDecodeError:
return JsonResponse({"success": False, "error": "Invalid JSON"}, status=400)
except Exception as e:
return JsonResponse({"success": False, "error": str(e)}, status=500)
@login_required
def admin_evaluation(request):
"""
Admin Evaluation Dashboard - Staff performance analysis.
Shows:
- Performance metrics for all staff members
- Complaints: Source breakdown, status distribution, response time, activation time
- Inquiries: Status distribution, response time
- Multi-staff comparison
- Date range filtering
- Hospital/department filtering
Access: PX Admin and Hospital Admin only
"""
from django.core.exceptions import PermissionDenied
from apps.analytics.services.analytics_service import UnifiedAnalyticsService
from apps.accounts.models import User
from apps.organizations.models import Hospital, Department
user = request.user
# Only PX Admins and Hospital Admins can access
if not (user.is_px_admin() or user.is_hospital_admin()):
raise PermissionDenied("Only PX Admins and Hospital Admins can access the Admin Evaluation dashboard.")
# Get date range filter
date_range = request.GET.get("date_range", "30d")
custom_start = request.GET.get("custom_start")
custom_end = request.GET.get("custom_end")
# Parse custom dates if provided
if custom_start:
from datetime import datetime
custom_start = datetime.fromisoformat(custom_start)
if custom_end:
from datetime import datetime
custom_end = datetime.fromisoformat(custom_end)
# Get hospital and department filters
hospital_id = request.GET.get("hospital_id")
department_id = request.GET.get("department_id")
# Get selected staff IDs for comparison
selected_staff_ids = request.GET.getlist("staff_ids")
status_filter = request.GET.get("status", "active")
# Get available hospitals (for PX Admins)
if user.is_px_admin():
hospitals = Hospital.objects.filter(status="active")
elif user.is_hospital_admin() and user.hospital:
hospitals = Hospital.objects.filter(id=user.hospital.id)
hospital_id = hospital_id or user.hospital.id # Default to user's hospital
else:
hospitals = Hospital.objects.none()
# Get available departments based on hospital filter
if hospital_id:
departments = Department.objects.filter(hospital_id=hospital_id, status="active")
elif user.hospital:
departments = Department.objects.filter(hospital=user.hospital, status="active")
else:
departments = Department.objects.none()
# Get staff performance metrics
performance_data = UnifiedAnalyticsService.get_staff_performance_metrics(
user=user,
date_range=date_range,
hospital_id=hospital_id,
department_id=department_id,
staff_ids=selected_staff_ids if selected_staff_ids else None,
custom_start=custom_start,
custom_end=custom_end,
)
# Get all staff for the dropdown
staff_queryset = User.objects.filter(groups__name="PX Employee")
if user.is_px_admin():
# PX Admins MUST filter by tenant_hospital
if request.tenant_hospital:
staff_queryset = staff_queryset.filter(hospital=request.tenant_hospital)
hospital_id = hospital_id or request.tenant_hospital.id
else:
staff_queryset = User.objects.none() # No access without selected hospital
elif user.is_hospital_admin() and user.hospital:
staff_queryset = staff_queryset.filter(hospital=user.hospital)
hospital_id = hospital_id or user.hospital.id
if department_id:
staff_queryset = staff_queryset.filter(department_id=department_id)
if status_filter == "active":
staff_queryset = staff_queryset.filter(is_active=True)
elif status_filter == "inactive":
staff_queryset = staff_queryset.filter(is_active=False)
# Only staff with assigned complaints or inquiries
staff_queryset = (
staff_queryset.filter(Q(assigned_complaints__isnull=False) | Q(assigned_inquiries__isnull=False))
.distinct()
.select_related("hospital", "department")
)
context = {
"departments": departments,
"staff_list": staff_queryset,
"selected_hospital_id": hospital_id,
"selected_department_id": department_id,
"selected_staff_ids": selected_staff_ids,
"date_range": date_range,
"custom_start": custom_start,
"custom_end": custom_end,
"performance_data": performance_data,
"status_filter": status_filter,
}
return render(request, "dashboard/admin_evaluation.html", context)
@login_required
def admin_evaluation_chart_data(request):
"""
API endpoint to get chart data for admin evaluation dashboard.
Access: PX Admin and Hospital Admin only
"""
from apps.analytics.services.analytics_service import UnifiedAnalyticsService
if request.method != "GET":
return JsonResponse({"success": False, "error": "GET required"}, status=405)
user = request.user
# Only PX Admins and Hospital Admins can access
if not (user.is_px_admin() or user.is_hospital_admin()):
return JsonResponse({"success": False, "error": "Permission denied"}, status=403)
chart_type = request.GET.get("chart_type")
date_range = request.GET.get("date_range", "30d")
hospital_id = request.GET.get("hospital_id")
department_id = request.GET.get("department_id")
staff_ids = request.GET.getlist("staff_ids")
# For PX Admins without explicit hospital_id, use tenant_hospital
if user.is_px_admin() and not hospital_id and request.tenant_hospital:
hospital_id = str(request.tenant_hospital.id)
# Parse custom dates if provided
custom_start = request.GET.get("custom_start")
custom_end = request.GET.get("custom_end")
if custom_start:
from datetime import datetime
custom_start = datetime.fromisoformat(custom_start)
if custom_end:
from datetime import datetime
custom_end = datetime.fromisoformat(custom_end)
try:
if chart_type == "staff_performance":
data = UnifiedAnalyticsService.get_staff_performance_metrics(
user=user,
date_range=date_range,
hospital_id=hospital_id,
department_id=department_id,
staff_ids=staff_ids if staff_ids else None,
custom_start=custom_start,
custom_end=custom_end,
)
else:
data = {"error": f"Unknown chart type: {chart_type}"}
return JsonResponse({"success": True, "data": data})
except Exception as e:
return JsonResponse({"success": False, "error": str(e)}, status=500)
# ============================================================================
# ENHANCED ADMIN EVALUATION VIEWS
# ============================================================================
@login_required
def staff_performance_detail(request, staff_id):
"""
Detailed performance view for a single staff member.
Shows:
- Performance score with breakdown
- Daily workload trends
- Recent complaints and inquiries
- Performance metrics
Access: PX Admin and Hospital Admin only
"""
from django.core.exceptions import PermissionDenied
from apps.analytics.services.analytics_service import UnifiedAnalyticsService
# Only PX Admins and Hospital Admins can access
if not (request.user.is_px_admin() or request.user.is_hospital_admin()):
raise PermissionDenied("Only PX Admins and Hospital Admins can access staff performance details.")
from apps.accounts.models import User
user = request.user
# Get date range
date_range = request.GET.get("date_range", "30d")
try:
staff = User.objects.select_related("hospital", "department").get(id=staff_id)
# Check permissions
if not user.is_px_admin():
if user.hospital and staff.hospital != user.hospital:
messages.error(request, "You don't have permission to view this staff member's performance.")
return redirect("dashboard:admin_evaluation")
# Get detailed performance
performance = UnifiedAnalyticsService.get_staff_detailed_performance(
staff_id=staff_id, user=user, date_range=date_range
)
# Get trends
trends = UnifiedAnalyticsService.get_staff_performance_trends(staff_id=staff_id, user=user, months=6)
context = {
"staff": performance["staff"],
"performance": performance,
"trends": trends,
"date_range": date_range,
}
return render(request, "dashboard/staff_performance_detail.html", context)
except User.DoesNotExist:
messages.error(request, "Staff member not found.")
return redirect("dashboard:admin_evaluation")
except PermissionError:
messages.error(request, "You don't have permission to view this staff member.")
return redirect("dashboard:admin_evaluation")
@login_required
def staff_performance_trends(request, staff_id):
"""
API endpoint to get staff performance trends as JSON.
Access: PX Admin and Hospital Admin only
"""
from apps.analytics.services.analytics_service import UnifiedAnalyticsService
from apps.accounts.models import User
# Only PX Admins and Hospital Admins can access
if not (request.user.is_px_admin() or request.user.is_hospital_admin()):
return JsonResponse({"success": False, "error": "Permission denied"}, status=403)
user = request.user
months = int(request.GET.get("months", 6))
try:
trends = UnifiedAnalyticsService.get_staff_performance_trends(staff_id=staff_id, user=user, months=months)
return JsonResponse({"success": True, "trends": trends})
except Exception as e:
return JsonResponse({"success": False, "error": str(e)}, status=400)
@login_required
def department_benchmarks(request):
"""
Department benchmarking view comparing all staff.
Access: PX Admin and Hospital Admin only
"""
from django.core.exceptions import PermissionDenied
from apps.analytics.services.analytics_service import UnifiedAnalyticsService
# Only PX Admins and Hospital Admins can access
if not (request.user.is_px_admin() or request.user.is_hospital_admin()):
raise PermissionDenied("Only PX Admins and Hospital Admins can access department benchmarks.")
user = request.user
# Get filters
department_id = request.GET.get("department_id")
date_range = request.GET.get("date_range", "30d")
# If user is department manager, use their department
if user.is_department_manager() and user.department and not department_id:
department_id = str(user.department.id)
try:
benchmarks = UnifiedAnalyticsService.get_department_benchmarks(
user=user, department_id=department_id, date_range=date_range
)
context = {"benchmarks": benchmarks, "date_range": date_range}
return render(request, "dashboard/department_benchmarks.html", context)
except Exception as e:
messages.error(request, f"Error loading benchmarks: {str(e)}")
return redirect("dashboard:admin_evaluation")
@login_required
def export_staff_performance(request):
"""
Export staff performance report in various formats.
Access: PX Admin and Hospital Admin only
"""
from django.core.exceptions import PermissionDenied
from apps.analytics.services.analytics_service import UnifiedAnalyticsService
import csv
import json
from django.http import HttpResponse
# Only PX Admins and Hospital Admins can access
if not (request.user.is_px_admin() or request.user.is_hospital_admin()):
raise PermissionDenied("Only PX Admins and Hospital Admins can export staff performance.")
user = request.user
if request.method != "POST":
return JsonResponse({"error": "POST required"}, status=405)
try:
data = json.loads(request.body)
staff_ids = data.get("staff_ids", [])
date_range = data.get("date_range", "30d")
format_type = data.get("format", "csv")
# Generate report
report = UnifiedAnalyticsService.export_staff_performance_report(
staff_ids=staff_ids, user=user, date_range=date_range, format_type=format_type
)
if format_type == "csv":
response = HttpResponse(content_type="text/csv")
response["Content-Disposition"] = (
f'attachment; filename="staff_performance_{timezone.now().strftime("%Y%m%d")}.csv"'
)
if report["data"]:
writer = csv.DictWriter(response, fieldnames=report["data"][0].keys())
writer.writeheader()
writer.writerows(report["data"])
return response
elif format_type == "json":
return JsonResponse(report)
else:
return JsonResponse({"error": f"Unsupported format: {format_type}"}, status=400)
except Exception as e:
return JsonResponse({"error": str(e)}, status=500)
@login_required
def command_center_api(request):
"""
API endpoint for Command Center live data updates.
Returns JSON with all module data for AJAX refresh without page reload.
Enables true real-time updates every 30-60 seconds.
"""
from apps.complaints.models import Complaint, Inquiry
from apps.px_action_center.models import PXAction
from apps.surveys.models import SurveyInstance
from apps.physicians.models import PhysicianMonthlyRating
from apps.observations.models import Observation
user = request.user
now = timezone.now()
last_24h = now - timedelta(hours=24)
last_30d = now - timedelta(days=30)
last_60d = now - timedelta(days=60)
# Build querysets based on user role
if user.is_px_admin():
hospital = request.tenant_hospital
complaints_qs = Complaint.objects.filter(hospital=hospital) if hospital else Complaint.objects.none()
inquiries_qs = Inquiry.objects.filter(hospital=hospital) if hospital else Inquiry.objects.none()
actions_qs = PXAction.objects.filter(hospital=hospital) if hospital else PXAction.objects.none()
surveys_qs = SurveyInstance.objects.all()
observations_qs = Observation.objects.filter(hospital=hospital) if hospital else Observation.objects.none()
elif user.is_hospital_admin() and user.hospital:
complaints_qs = Complaint.objects.filter(hospital=user.hospital)
inquiries_qs = Inquiry.objects.filter(hospital=user.hospital)
actions_qs = PXAction.objects.filter(hospital=user.hospital)
surveys_qs = SurveyInstance.objects.filter(survey_template__hospital=user.hospital)
observations_qs = Observation.objects.filter(hospital=user.hospital)
elif user.is_department_manager() and user.department:
complaints_qs = Complaint.objects.filter(department=user.department)
inquiries_qs = Inquiry.objects.filter(department=user.department)
actions_qs = PXAction.objects.filter(department=user.department)
surveys_qs = SurveyInstance.objects.filter(journey_instance__department=user.department)
observations_qs = Observation.objects.filter(assigned_department=user.department)
elif user.is_director():
directed_depts = user.get_directed_departments()
if directed_depts.exists():
complaints_qs = Complaint.objects.filter(department__in=directed_depts)
inquiries_qs = Inquiry.objects.filter(department__in=directed_depts)
actions_qs = PXAction.objects.filter(department__in=directed_depts)
surveys_qs = SurveyInstance.objects.filter(journey_instance__department__in=directed_depts)
observations_qs = Observation.objects.filter(assigned_department__in=directed_depts)
else:
complaints_qs = Complaint.objects.none()
inquiries_qs = Inquiry.objects.none()
actions_qs = PXAction.objects.none()
surveys_qs = SurveyInstance.objects.none()
observations_qs = Observation.objects.none()
else:
complaints_qs = Complaint.objects.none()
inquiries_qs = Inquiry.objects.none()
actions_qs = PXAction.objects.none()
surveys_qs = SurveyInstance.objects.none()
observations_qs = Observation.objects.none()
# Calculate all module data
# Complaints
complaints_current = complaints_qs.filter(created_at__gte=last_30d).count()
complaints_previous = complaints_qs.filter(created_at__gte=last_60d, created_at__lt=last_30d).count()
complaints_variance = (
round(((complaints_current - complaints_previous) / complaints_previous) * 100, 1)
if complaints_previous > 0
else 0
)
# Surveys
surveys_completed_30d = surveys_qs.filter(completed_at__gte=last_30d)
total_surveys_30d = surveys_completed_30d.count()
positive_count = surveys_completed_30d.filter(is_negative=False).count()
negative_count = surveys_completed_30d.filter(is_negative=True).count()
nps_score = round(((positive_count - negative_count) / total_surveys_30d) * 100) if total_surveys_30d > 0 else 0
avg_satisfaction = (
surveys_completed_30d.filter(total_score__isnull=False).aggregate(Avg("total_score"))["total_score__avg"] or 0
)
surveys_sent_30d = surveys_qs.filter(sent_at__gte=last_30d).count()
response_rate = round((total_surveys_30d / surveys_sent_30d) * 100, 1) if surveys_sent_30d > 0 else 0
# Actions
actions_open = actions_qs.filter(status="open").count()
actions_in_progress = actions_qs.filter(status="in_progress").count()
actions_pending_approval = actions_qs.filter(status="pending_approval").count()
actions_closed_30d = actions_qs.filter(status="closed", closed_at__gte=last_30d).count()
# Red alerts
red_alerts = []
critical_complaints = complaints_qs.filter(severity="critical", status__in=["open", "in_progress"]).count()
if critical_complaints > 0:
red_alerts.append({"type": "critical_complaints", "value": critical_complaints})
overdue_complaints = complaints_qs.filter(is_overdue=True, status__in=["open", "in_progress"]).count()
if overdue_complaints > 0:
red_alerts.append({"type": "overdue_complaints", "value": overdue_complaints})
escalated_actions = actions_qs.filter(escalation_level__gt=0, status__in=["open", "in_progress"]).count()
if escalated_actions > 0:
red_alerts.append({"type": "escalated_actions", "value": escalated_actions})
negative_surveys_24h = surveys_qs.filter(is_negative=True, completed_at__gte=last_24h).count()
if negative_surveys_24h > 0:
red_alerts.append({"type": "negative_surveys", "value": negative_surveys_24h})
return JsonResponse(
{
"success": True,
"timestamp": now.isoformat(),
"last_updated": now.strftime("%Y-%m-%d %H:%M:%S"),
"red_alerts": {"has_alerts": len(red_alerts) > 0, "count": len(red_alerts), "items": red_alerts},
"modules": {
"complaints": {
"total_active": complaints_qs.filter(status__in=["open", "in_progress"]).count(),
"variance": complaints_variance,
"variance_direction": "up"
if complaints_variance > 0
else "down"
if complaints_variance < 0
else "neutral",
"overdue": complaints_qs.filter(is_overdue=True, status__in=["open", "in_progress"]).count(),
"critical": complaints_qs.filter(severity="critical", status__in=["open", "in_progress"]).count(),
"by_severity": {
"critical": complaints_qs.filter(
severity="critical", status__in=["open", "in_progress"]
).count(),
"high": complaints_qs.filter(severity="high", status__in=["open", "in_progress"]).count(),
"medium": complaints_qs.filter(severity="medium", status__in=["open", "in_progress"]).count(),
"low": complaints_qs.filter(severity="low", status__in=["open", "in_progress"]).count(),
},
},
"surveys": {
"nps_score": nps_score,
"avg_satisfaction": round(avg_satisfaction, 1),
"response_rate": response_rate,
"total_completed": total_surveys_30d,
"negative_24h": surveys_qs.filter(is_negative=True, completed_at__gte=last_24h).count(),
},
"actions": {
"open": actions_open,
"in_progress": actions_in_progress,
"pending_approval": actions_pending_approval,
"closed_30d": actions_closed_30d,
"overdue": actions_qs.filter(is_overdue=True, status__in=["open", "in_progress"]).count(),
"escalated": actions_qs.filter(escalation_level__gt=0, status__in=["open", "in_progress"]).count(),
},
"inquiries": {
"open": inquiries_qs.filter(status="open").count(),
"in_progress": inquiries_qs.filter(status="in_progress").count(),
"total_active": inquiries_qs.filter(status__in=["open", "in_progress"]).count(),
"new_24h": inquiries_qs.filter(created_at__gte=last_24h).count(),
},
"observations": {
"new": observations_qs.filter(status="new").count(),
"in_progress": observations_qs.filter(status="in_progress").count(),
"total_active": observations_qs.filter(status__in=["new", "in_progress"]).count(),
"critical": observations_qs.filter(
severity="critical", status__in=["new", "triaged", "assigned", "in_progress"]
).count(),
},
},
}
)
@login_required
def performance_analytics_api(request):
"""
API endpoint for various performance analytics.
Access: PX Admin and Hospital Admin only
"""
from apps.analytics.services.analytics_service import UnifiedAnalyticsService
# Only PX Admins and Hospital Admins can access
if not (request.user.is_px_admin() or request.user.is_hospital_admin()):
return JsonResponse({"success": False, "error": "Permission denied"}, status=403)
user = request.user
chart_type = request.GET.get("chart_type")
try:
if chart_type == "staff_trends":
staff_id = request.GET.get("staff_id")
months = int(request.GET.get("months", 6))
data = UnifiedAnalyticsService.get_staff_performance_trends(staff_id=staff_id, user=user, months=months)
elif chart_type == "department_benchmarks":
department_id = request.GET.get("department_id")
date_range = request.GET.get("date_range", "30d")
data = UnifiedAnalyticsService.get_department_benchmarks(
user=user, department_id=department_id, date_range=date_range
)
else:
return JsonResponse({"error": f"Unknown chart type: {chart_type}"}, status=400)
return JsonResponse({"success": True, "data": data})
except Exception as e:
return JsonResponse({"success": False, "error": str(e)}, status=500)
@login_required
def employee_evaluation(request):
"""
Employee Evaluation Dashboard - PAD Department Weekly Dashboard.
Shows comprehensive performance metrics for all staff members side-by-side.
Based on the employee_evaluation.md specification.
Access: PX Admin and Hospital Admin only
"""
from django.core.exceptions import PermissionDenied
from apps.analytics.services.analytics_service import UnifiedAnalyticsService
from apps.accounts.models import User
from apps.organizations.models import Hospital, Department
user = request.user
# Only PX Admins and Hospital Admins can access
if not (user.is_px_admin() or user.is_hospital_admin()):
raise PermissionDenied("Only PX Admins and Hospital Admins can access the Employee Evaluation dashboard.")
# Get date range filter - default to last 7 days (weekly)
date_range = request.GET.get("date_range", "7d")
custom_start = request.GET.get("custom_start")
custom_end = request.GET.get("custom_end")
# Parse custom dates if provided
if custom_start:
from datetime import datetime
custom_start = datetime.fromisoformat(custom_start)
if custom_end:
from datetime import datetime
custom_end = datetime.fromisoformat(custom_end)
# Get hospital and department filters
hospital_id = request.GET.get("hospital_id")
department_id = request.GET.get("department_id")
# Get selected staff IDs for comparison
selected_staff_ids = request.GET.getlist("staff_ids")
status_filter = request.GET.get("status", "active")
# Get available hospitals (for PX Admins)
if user.is_px_admin():
hospitals = Hospital.objects.filter(status="active")
elif user.is_hospital_admin() and user.hospital:
hospitals = Hospital.objects.filter(id=user.hospital.id)
hospital_id = hospital_id or user.hospital.id # Default to user's hospital
else:
hospitals = Hospital.objects.none()
# Get available departments based on hospital filter
if hospital_id:
departments = Department.objects.filter(hospital_id=hospital_id, status="active")
elif user.hospital:
departments = Department.objects.filter(hospital=user.hospital, status="active")
else:
departments = Department.objects.none()
# Get employee evaluation metrics
evaluation_data = UnifiedAnalyticsService.get_employee_evaluation_metrics(
user=user,
date_range=date_range,
hospital_id=hospital_id,
department_id=department_id,
staff_ids=selected_staff_ids if selected_staff_ids else None,
custom_start=custom_start,
custom_end=custom_end,
)
# Get all staff for the dropdown
staff_queryset = User.objects.filter(groups__name="PX Employee")
if user.is_px_admin():
if hospital_id:
staff_queryset = staff_queryset.filter(hospital_id=hospital_id)
elif request.tenant_hospital:
staff_queryset = staff_queryset.filter(hospital=request.tenant_hospital)
hospital_id = hospital_id or request.tenant_hospital.id
elif user.is_hospital_admin() and user.hospital:
staff_queryset = staff_queryset.filter(hospital=user.hospital)
hospital_id = hospital_id or user.hospital.id
if department_id:
staff_queryset = staff_queryset.filter(department_id=department_id)
if status_filter == "active":
staff_queryset = staff_queryset.filter(is_active=True)
elif status_filter == "inactive":
staff_queryset = staff_queryset.filter(is_active=False)
# Only staff with assigned complaints or inquiries
staff_queryset = (
staff_queryset.filter(Q(assigned_complaints__isnull=False) | Q(assigned_inquiries__isnull=False))
.distinct()
.select_related("hospital", "department")
)
context = {
"departments": departments,
"staff_list": staff_queryset,
"selected_hospital_id": hospital_id,
"selected_department_id": department_id,
"selected_staff_ids": selected_staff_ids,
"date_range": date_range,
"custom_start": custom_start,
"custom_end": custom_end,
"evaluation_data": evaluation_data,
"status_filter": status_filter,
}
return render(request, "dashboard/employee_evaluation.html", context)
@login_required
def employee_evaluation_charts(request):
"""
Employee Evaluation Charts page — comparison table + visual charts.
Access: PX Admin and Hospital Admin only
"""
from django.core.exceptions import PermissionDenied
from apps.analytics.services.analytics_service import UnifiedAnalyticsService
from apps.accounts.models import User
from apps.organizations.models import Hospital, Department
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin()):
raise PermissionDenied("Only PX Admins and Hospital Admins can access this page.")
date_range = request.GET.get("date_range", "7d")
custom_start = request.GET.get("custom_start")
custom_end = request.GET.get("custom_end")
if custom_start:
from datetime import datetime
custom_start = datetime.fromisoformat(custom_start)
if custom_end:
from datetime import datetime
custom_end = datetime.fromisoformat(custom_end)
hospital_id = request.GET.get("hospital_id")
department_id = request.GET.get("department_id")
selected_staff_ids = request.GET.getlist("staff_ids")
status_filter = request.GET.get("status", "active")
if user.is_px_admin():
hospitals = Hospital.objects.filter(status="active")
elif user.is_hospital_admin() and user.hospital:
hospitals = Hospital.objects.filter(id=user.hospital.id)
hospital_id = hospital_id or user.hospital.id
else:
hospitals = Hospital.objects.none()
if hospital_id:
departments = Department.objects.filter(hospital_id=hospital_id, status="active")
elif user.hospital:
departments = Department.objects.filter(hospital=user.hospital, status="active")
else:
departments = Department.objects.none()
evaluation_data = UnifiedAnalyticsService.get_employee_evaluation_metrics(
user=user,
date_range=date_range,
hospital_id=hospital_id,
department_id=department_id,
staff_ids=selected_staff_ids if selected_staff_ids else None,
custom_start=custom_start,
custom_end=custom_end,
)
staff_queryset = User.objects.filter(groups__name="PX Employee")
if user.is_px_admin():
if hospital_id:
staff_queryset = staff_queryset.filter(hospital_id=hospital_id)
elif request.tenant_hospital:
staff_queryset = staff_queryset.filter(hospital=request.tenant_hospital)
hospital_id = hospital_id or request.tenant_hospital.id
elif user.is_hospital_admin() and user.hospital:
staff_queryset = staff_queryset.filter(hospital=user.hospital)
hospital_id = hospital_id or user.hospital.id
if department_id:
staff_queryset = staff_queryset.filter(department_id=department_id)
if status_filter == "active":
staff_queryset = staff_queryset.filter(is_active=True)
elif status_filter == "inactive":
staff_queryset = staff_queryset.filter(is_active=False)
staff_queryset = (
staff_queryset.filter(Q(assigned_complaints__isnull=False) | Q(assigned_inquiries__isnull=False))
.distinct()
.select_related("hospital", "department")
)
context = {
"departments": departments,
"staff_list": staff_queryset,
"selected_hospital_id": hospital_id,
"selected_department_id": department_id,
"selected_staff_ids": selected_staff_ids,
"date_range": date_range,
"custom_start": custom_start,
"custom_end": custom_end,
"evaluation_data": evaluation_data,
"hospitals": hospitals,
"status_filter": status_filter,
}
return render(request, "dashboard/employee_evaluation_charts.html", context)
@login_required
def employee_evaluation_data(request):
"""
API endpoint to get employee evaluation data for charts and tables.
Access: PX Admin and Hospital Admin only
"""
from apps.analytics.services.analytics_service import UnifiedAnalyticsService
if request.method != "GET":
return JsonResponse({"success": False, "error": "GET required"}, status=405)
user = request.user
# Only PX Admins and Hospital Admins can access
if not (user.is_px_admin() or user.is_hospital_admin()):
return JsonResponse({"success": False, "error": "Permission denied"}, status=403)
date_range = request.GET.get("date_range", "7d")
hospital_id = request.GET.get("hospital_id")
department_id = request.GET.get("department_id")
staff_ids = request.GET.getlist("staff_ids")
# For PX Admins without explicit hospital_id, use tenant_hospital
if user.is_px_admin() and not hospital_id and request.tenant_hospital:
hospital_id = str(request.tenant_hospital.id)
# Parse custom dates if provided
custom_start = request.GET.get("custom_start")
custom_end = request.GET.get("custom_end")
if custom_start:
from datetime import datetime
custom_start = datetime.fromisoformat(custom_start)
if custom_end:
from datetime import datetime
custom_end = datetime.fromisoformat(custom_end)
try:
# Get employee evaluation metrics
evaluation_data = UnifiedAnalyticsService.get_employee_evaluation_metrics(
user=user,
date_range=date_range,
hospital_id=hospital_id,
department_id=department_id,
staff_ids=staff_ids if staff_ids else None,
custom_start=custom_start,
custom_end=custom_end,
)
return JsonResponse({"success": True, "data": evaluation_data})
except Exception as e:
return JsonResponse({"success": False, "error": str(e)}, status=500)
return JsonResponse({"success": False, "error": str(e)}, status=500)
@login_required
def complaint_request_list(request):
"""
Step 0 — Complaint Request List view.
Shows all complaint requests (filled, not filled, on hold)
with filters for month, staff, status. Includes export button.
"""
from django.core.exceptions import PermissionDenied
from apps.dashboard.models import ComplaintRequest
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin()):
raise PermissionDenied("Only PX Admins and Hospital Admins can access.")
qs = ComplaintRequest.objects.select_related("staff", "hospital", "complained_department", "complaint")
if user.is_hospital_admin() and user.hospital:
qs = qs.filter(hospital=user.hospital)
elif user.is_px_admin() and request.tenant_hospital:
qs = qs.filter(hospital=request.tenant_hospital)
month = request.GET.get("month")
year = request.GET.get("year")
staff_id = request.GET.get("staff_id")
status = request.GET.get("status")
if year and month:
qs = qs.filter(request_date__year=int(year), request_date__month=int(month))
elif year:
qs = qs.filter(request_date__year=int(year))
if staff_id:
qs = qs.filter(staff_id=staff_id)
if status == "filled":
qs = qs.filter(filled=True)
elif status == "not_filled":
qs = qs.filter(not_filled=True)
elif status == "on_hold":
qs = qs.filter(on_hold=True)
elif status == "barcode":
qs = qs.filter(from_barcode=True)
qs = qs.order_by("-request_date", "-created_at")
paginator = Paginator(qs, 50)
page_number = request.GET.get("page", 1)
page_obj = paginator.get_page(page_number)
from apps.accounts.models import User
staff_members = User.objects.filter(complaint_requests_sent__isnull=False)
# Filter by hospital based on user role
if user.is_hospital_admin() and user.hospital:
staff_members = staff_members.filter(hospital=user.hospital)
elif user.is_px_admin() and request.tenant_hospital:
staff_members = staff_members.filter(hospital=request.tenant_hospital)
staff_members = staff_members.distinct().order_by("first_name", "last_name")
context = {
"page_obj": page_obj,
"staff_members": staff_members,
"selected_year": year,
"selected_month": month,
"selected_staff": staff_id,
"selected_status": status,
"years_range": range(2024, timezone.now().year + 1),
"months_range": range(1, 13),
}
return render(request, "dashboard/complaint_request_list.html", context)
@login_required
def complaint_request_export(request):
"""
Step 0 — Export complaint requests to Excel.
"""
from django.core.exceptions import PermissionDenied
from apps.dashboard.models import ComplaintRequest
from apps.complaints.utils import export_requests_report
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin()):
raise PermissionDenied("Only PX Admins and Hospital Admins can export.")
qs = ComplaintRequest.objects.select_related("staff", "hospital", "complained_department", "complaint")
if user.is_hospital_admin() and user.hospital:
qs = qs.filter(hospital=user.hospital)
elif user.is_px_admin() and request.tenant_hospital:
qs = qs.filter(hospital=request.tenant_hospital)
year = request.GET.get("year")
month = request.GET.get("month")
if year and month:
qs = qs.filter(request_date__year=int(year), request_date__month=int(month))
elif year:
qs = qs.filter(request_date__year=int(year))
return export_requests_report(
qs,
year=int(year) if year else None,
month=int(month) if month else None,
)
@login_required
def census_report(request):
import json
from django.core.exceptions import PermissionDenied
from apps.dashboard.services.census import CensusService
from apps.organizations.models import Hospital
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee() or user.is_px_management()):
raise PermissionDenied("Only PX Admins, Hospital Admins, and PX Employee and PX Management can access.")
hospital_id = request.GET.get("hospital")
year = request.GET.get("year")
if user.is_hospital_admin() and user.hospital:
hospital_id = hospital_id or str(user.hospital.id)
elif user.is_px_admin() and request.tenant_hospital:
hospital_id = hospital_id or str(request.tenant_hospital.id)
if not hospital_id:
first = Hospital.objects.first()
if first:
hospital_id = str(first.id)
if not hospital_id:
return render(request, "dashboard/census_report.html", {"no_data": True})
year = int(year) if year else timezone.now().year
service = CensusService(hospital_id=hospital_id, year=year)
monthly_counts = service.get_monthly_counts(year)
quarterly_data = service.get_quarterly_data(year)
year_totals = service.get_year_totals(year)
available_years = service.get_available_years()
chart_data = service.get_chart_data(years=[year - 2, year - 1, year])
context = {
"hospitals": Hospital.objects.all(),
"selected_hospital": hospital_id,
"selected_year": year,
"available_years": available_years,
"monthly_counts": monthly_counts,
"quarterly_data": quarterly_data,
"year_totals": year_totals,
"chart_data_json": json.dumps(chart_data),
}
return render(request, "dashboard/census_report.html", context)
@login_required
def inquiry_report(request):
import json
from django.core.exceptions import PermissionDenied
from apps.dashboard.services.inquiry_report import InquiryReportService
from apps.organizations.models import Hospital
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee() or user.is_px_management()):
raise PermissionDenied("Only PX Admins, Hospital Admins, and PX Employee and PX Management can access.")
hospital_id = request.GET.get("hospital")
year = request.GET.get("year")
month = request.GET.get("month")
if user.is_hospital_admin() and user.hospital:
hospital_id = hospital_id or str(user.hospital.id)
elif user.is_px_admin() and request.tenant_hospital:
hospital_id = hospital_id or str(request.tenant_hospital.id)
if not hospital_id:
first = Hospital.objects.first()
if first:
hospital_id = str(first.id)
if not hospital_id:
return render(request, "dashboard/inquiry_report.html", {"no_data": True})
year = int(year) if year else timezone.now().year
month = int(month) if month else timezone.now().month
service = InquiryReportService(hospital_id=hospital_id, year=year, month=month)
available_months = service.get_available_months()
incoming_summary = service.get_summary(is_outgoing=False)
outgoing_summary = service.get_summary(is_outgoing=True)
chart_data = service.get_chart_data()
employee_breakdown = service.get_employee_breakdown()
department_breakdown = service.get_department_breakdown()
fmt = lambda n: f"{n:,}"
for bd in employee_breakdown + department_breakdown:
bd["total_fmt"] = fmt(bd["total"])
context = {
"hospitals": Hospital.objects.all(),
"selected_hospital": hospital_id,
"selected_year": year,
"selected_month": month,
"available_months": available_months,
"incoming": incoming_summary,
"outgoing": outgoing_summary,
"incoming_total_fmt": fmt(incoming_summary["total"]),
"outgoing_total_fmt": fmt(outgoing_summary["total"]),
"chart_data_json": json.dumps(chart_data),
"employee_breakdown": employee_breakdown,
"department_breakdown": department_breakdown,
}
return render(request, "dashboard/inquiry_report.html", context)
@login_required
def census_report_export(request):
from django.core.exceptions import PermissionDenied
from django.http import HttpResponse
from apps.dashboard.services.census import CensusService
from apps.dashboard.services.census_export import generate_census_excel
from apps.organizations.models import Hospital
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin()):
raise PermissionDenied("Only PX Admins and Hospital Admins can access.")
hospital_id = request.GET.get("hospital")
year = request.GET.get("year")
month = request.GET.get("month")
if user.is_hospital_admin() and user.hospital:
hospital_id = hospital_id or str(user.hospital.id)
elif user.is_px_admin() and request.tenant_hospital:
hospital_id = hospital_id or str(request.tenant_hospital.id)
if not hospital_id:
return HttpResponse("Hospital parameter required", status=400)
year = int(year) if year else timezone.now().year
month = int(month) if month else timezone.now().month
service = CensusService(hospital_id=hospital_id, year=year, month=month)
buf = generate_census_excel(service)
month_label = f"{year}-{month:02d}"
response = HttpResponse(
buf.getvalue(),
content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
)
response["Content-Disposition"] = f'attachment; filename="census_{month_label}.xlsx"'
return response
@login_required
def observation_report(request):
import json
from datetime import date
from django.core.exceptions import PermissionDenied
from apps.dashboard.services.observation_report import ObservationReportService
from apps.organizations.models import Hospital
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee() or user.is_px_management()):
raise PermissionDenied("Only PX Admins, Hospital Admins, and PX Employee and PX Management can access.")
hospital_id = request.GET.get("hospital")
date_from_str = request.GET.get("date_from")
date_to_str = request.GET.get("date_to")
if user.is_hospital_admin() and user.hospital:
hospital_id = hospital_id or str(user.hospital.id)
elif user.is_px_admin() and request.tenant_hospital:
hospital_id = hospital_id or str(request.tenant_hospital.id)
if not hospital_id:
first = Hospital.objects.first()
if first:
hospital_id = str(first.id)
if not hospital_id:
return render(request, "dashboard/observation_report.html", {"no_data": True})
today = timezone.now().date()
if date_from_str:
date_from = date.fromisoformat(date_from_str)
else:
date_from = today.replace(day=1)
if date_to_str:
date_to = date.fromisoformat(date_to_str)
else:
date_to = today
service = ObservationReportService(hospital_id=hospital_id, date_from=date_from, date_to=date_to)
summary = service.get_summary()
chart_data = service.get_chart_data()
employee_breakdown = service.get_employee_breakdown()
department_breakdown = service.get_department_breakdown()
category_breakdown = service.get_category_breakdown()
fmt = lambda n: f"{n:,}"
for bd in employee_breakdown + department_breakdown:
bd["total_fmt"] = fmt(bd["total"])
context = {
"hospitals": Hospital.objects.all(),
"selected_hospital": hospital_id,
"date_from": date_from.isoformat(),
"date_to": date_to.isoformat(),
"summary": summary,
"total_fmt": fmt(summary["total"]),
"chart_data_json": json.dumps(chart_data),
"employee_breakdown": employee_breakdown,
"department_breakdown": department_breakdown,
"category_breakdown": category_breakdown,
}
return render(request, "dashboard/observation_report.html", context)
@login_required
def observation_report_export(request):
from datetime import date
from django.core.exceptions import PermissionDenied
from django.http import HttpResponse
from apps.dashboard.services.observation_report import ObservationReportService
from apps.dashboard.services.observation_report_export import generate_observation_excel
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin()):
raise PermissionDenied("Only PX Admins and Hospital Admins can access.")
hospital_id = request.GET.get("hospital")
date_from_str = request.GET.get("date_from")
date_to_str = request.GET.get("date_to")
if user.is_hospital_admin() and user.hospital:
hospital_id = hospital_id or str(user.hospital.id)
elif user.is_px_admin() and request.tenant_hospital:
hospital_id = hospital_id or str(request.tenant_hospital.id)
if not hospital_id:
return HttpResponse("Hospital parameter required", status=400)
today = timezone.now().date()
if date_from_str:
date_from = date.fromisoformat(date_from_str)
else:
date_from = today.replace(day=1)
if date_to_str:
date_to = date.fromisoformat(date_to_str)
else:
date_to = today
service = ObservationReportService(hospital_id=hospital_id, date_from=date_from, date_to=date_to)
buf = generate_observation_excel(service)
date_label = f"{date_from.isoformat()}_to_{date_to.isoformat()}"
response = HttpResponse(
buf.getvalue(),
content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
)
response["Content-Disposition"] = f'attachment; filename="observations_{date_label}.xlsx"'
return response
@login_required
def complaint_monthly_report(request):
import json
from django.core.exceptions import PermissionDenied
from apps.dashboard.services.complaint_monthly_service import ComplaintMonthlyService
from apps.organizations.models import Hospital
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee() or user.is_px_management()):
raise PermissionDenied("Only PX Admins, Hospital Admins, and PX Employee and PX Management can access.")
hospital_id = request.GET.get("hospital")
year = request.GET.get("year")
month = request.GET.get("month")
if user.is_hospital_admin() and user.hospital:
hospital_id = hospital_id or str(user.hospital.id)
elif user.is_px_admin() and request.tenant_hospital:
hospital_id = hospital_id or str(request.tenant_hospital.id)
if not hospital_id:
first = Hospital.objects.first()
if first:
hospital_id = str(first.id)
if not hospital_id:
return render(request, "dashboard/complaint_monthly_report.html", {"no_data": True})
year = int(year) if year else timezone.now().year
month = int(month) if month else timezone.now().month
service = ComplaintMonthlyService(hospital_id=hospital_id, year=year, month=month)
available_months = service.get_available_months()
summary = service.get_summary()
chart_data = service.get_chart_data()
stage_times = service.get_avg_stage_times()
fmt = lambda n: f"{n:,}"
context = {
"hospitals": Hospital.objects.all(),
"selected_hospital": hospital_id,
"selected_year": year,
"selected_month": month,
"available_months": available_months,
"summary": summary,
"total_fmt": fmt(summary["total"]),
"chart_data_json": json.dumps(chart_data),
"stage_times": stage_times,
}
return render(request, "dashboard/complaint_monthly_report.html", context)
@login_required
def complaint_monthly_export(request):
from django.core.exceptions import PermissionDenied
from django.http import HttpResponse
from apps.dashboard.services.complaint_monthly_service import ComplaintMonthlyService
from apps.dashboard.services.complaint_monthly_export import generate_complaint_monthly_excel
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin()):
raise PermissionDenied("Only PX Admins and Hospital Admins can access.")
hospital_id = request.GET.get("hospital")
year = int(request.GET.get("year", timezone.now().year))
month = int(request.GET.get("month", timezone.now().month))
if user.is_hospital_admin() and user.hospital:
hospital_id = hospital_id or str(user.hospital.id)
elif user.is_px_admin() and request.tenant_hospital:
hospital_id = hospital_id or str(request.tenant_hospital.id)
if not hospital_id:
return HttpResponse("Hospital parameter required", status=400)
service = ComplaintMonthlyService(hospital_id=hospital_id, year=year, month=month)
buf = generate_complaint_monthly_excel(service)
month_label = f"{year}-{month:02d}"
response = HttpResponse(
buf.getvalue(),
content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
)
response["Content-Disposition"] = f'attachment; filename="complaints_monthly_{month_label}.xlsx"'
return response
def _build_kpi_blocks(kpi_data, satisfaction_data, moh_kpi_data, active_months):
blocks = [
{
"label": "KPI #1 - Resolution to Patient Complaints",
"numerator_label": "Total Number of Closed Complaints",
"denominator_label": "Total Number of Complaints",
"result_label": "Result (%)",
"numerator_values": [kpi_data["months"][m]["closed"] for m in active_months],
"denominator_values": [kpi_data["months"][m]["total"] for m in active_months],
"result_values": [kpi_data["months"][m]["resolution_rate"] for m in active_months],
"total_num": kpi_data["totals"]["closed"],
"total_den": kpi_data["totals"]["total"],
"total_res": kpi_data["totals"]["resolution_rate"],
},
{
"label": "KPI #2 - 72-Hour Complaint Resolution Rate",
"numerator_label": "Number of Complaints Resolved Within 72 Hours",
"denominator_label": "Total Number of Complaints",
"result_label": "Result (%)",
"numerator_values": [kpi_data["months"][m]["resolved_72h"] for m in active_months],
"denominator_values": [kpi_data["months"][m]["total"] for m in active_months],
"result_values": [kpi_data["months"][m]["resolved_72h_rate"] for m in active_months],
"total_num": kpi_data["totals"]["resolved_72h"],
"total_den": kpi_data["totals"]["total"],
"total_res": kpi_data["totals"]["resolved_72h_rate"],
},
{
"label": "KPI #3 - Satisfaction Rate",
"numerator_label": "Number of Satisfied Responses",
"denominator_label": "Total Number of Patient Surveyed (Responses)",
"result_label": "Result (%)",
"numerator_values": [satisfaction_data["months"][m]["satisfied"] for m in active_months],
"denominator_values": [satisfaction_data["months"][m]["surveyed"] for m in active_months],
"result_values": [satisfaction_data["months"][m]["rate"] for m in active_months],
"total_num": satisfaction_data["totals"]["satisfied"],
"total_den": satisfaction_data["totals"]["surveyed"],
"total_res": satisfaction_data["totals"]["rate"],
},
{
"label": "Response Rate - Calls",
"numerator_label": "Total Responses",
"denominator_label": "Total Complaints",
"result_label": "Result (%)",
"numerator_values": [satisfaction_data["call_months"][m]["responses"] for m in active_months],
"denominator_values": [satisfaction_data["call_months"][m]["total"] for m in active_months],
"result_values": [satisfaction_data["call_months"][m]["rate"] for m in active_months],
"total_num": satisfaction_data["call_totals"]["responses"],
"total_den": satisfaction_data["call_totals"]["total"],
"total_res": satisfaction_data["call_totals"]["rate"],
},
{
"label": "Response Rate - Survey",
"numerator_label": "Total Responses",
"denominator_label": "Total Complaints",
"result_label": "Result (%)",
"numerator_values": [satisfaction_data["survey_months"][m]["responses"] for m in active_months],
"denominator_values": [satisfaction_data["survey_months"][m]["total"] for m in active_months],
"result_values": [satisfaction_data["survey_months"][m]["rate"] for m in active_months],
"total_num": satisfaction_data["survey_totals"]["responses"],
"total_den": satisfaction_data["survey_totals"]["total"],
"total_res": satisfaction_data["survey_totals"]["rate"],
},
{
"label": "MOH KPI",
"numerator_label": "Complaints which received a (satisfied) scoring on its resolution",
"denominator_label": "Total number of complaints received",
"result_label": "Result (%)",
"numerator_values": [moh_kpi_data["moh"]["months"][m]["satisfied_scoring"] for m in active_months],
"denominator_values": [moh_kpi_data["moh"]["months"][m]["total"] for m in active_months],
"result_values": [moh_kpi_data["moh"]["months"][m]["rate"] for m in active_months],
"total_num": moh_kpi_data["moh"]["totals"]["satisfied_scoring"],
"total_den": moh_kpi_data["moh"]["totals"]["total"],
"total_res": moh_kpi_data["moh"]["totals"]["rate"],
},
{
"label": "MOH KPI - Real Numbers",
"numerator_label": "Complaints which received a (satisfied) scoring on its resolution",
"denominator_label": "Total number of complaints received",
"result_label": "Result (%)",
"numerator_values": [moh_kpi_data["real"]["months"][m]["satisfied_scoring"] for m in active_months],
"denominator_values": [moh_kpi_data["real"]["months"][m]["total"] for m in active_months],
"result_values": [moh_kpi_data["real"]["months"][m]["rate"] for m in active_months],
"total_num": moh_kpi_data["real"]["totals"]["satisfied_scoring"],
"total_den": moh_kpi_data["real"]["totals"]["total"],
"total_res": moh_kpi_data["real"]["totals"]["rate"],
},
{
"label": "KPI #4 - 48-Hour Response Rate",
"numerator_label": "Total Responses Within 48 Hours",
"denominator_label": "Total Number of Complaints",
"result_label": "Result (%)",
"numerator_values": [kpi_data["months"][m]["resolved_48h"] for m in active_months],
"denominator_values": [kpi_data["months"][m]["total"] for m in active_months],
"result_values": [kpi_data["months"][m]["resolved_48h_rate"] for m in active_months],
"total_num": kpi_data["totals"]["resolved_48h"],
"total_den": kpi_data["totals"]["total"],
"total_res": kpi_data["totals"]["resolved_48h_rate"],
},
]
return blocks
def _build_source_subrows(source_breakdown, keys, labels, active_months):
rows = []
for key, label in zip(keys, labels):
total = sum(source_breakdown[m][key] for m in active_months)
if total == 0:
continue
monthly = [{"count": source_breakdown[m][key]} for m in active_months]
rows.append({"label": label, "total": total, "monthly": monthly})
return rows
def _build_location_ratio_tables(location_ratios, active_months):
import calendar
tables = []
for area, title, comp_col, pat_col in [
("ip", "In-Patient Complaints vs Patients", "In-Patient Complaints", "Total In-Patient"),
("op", "Out-Patient Complaints vs Patients", "Out-Patient Complaint", "Total Out-Patient"),
("er", "ER Complaints vs Patients", "ER Complaints", "Total ER Patients"),
]:
rows = []
for m in active_months:
d = location_ratios["months"][m]
rows.append({
"month": calendar.month_abbr[m],
"complaints": d[f"{area}_complaints"],
"patients": d[f"{area}_patients"],
"ratio": d[f"{area}_ratio"] * 100,
"is_total": False,
})
t = location_ratios["totals"][area]
rows.append({
"month": "TOTAL",
"complaints": t["complaints"],
"patients": t["patients"],
"ratio": t["ratio"] * 100,
"is_total": True,
})
tables.append({
"title": title, "complaint_col": comp_col, "patient_col": pat_col,
"rows": rows,
})
return tables
@login_required
def complaint_quarterly_report(request):
import json
from django.core.exceptions import PermissionDenied
from apps.dashboard.services.complaint_quarterly_service import ComplaintQuarterlyService
from apps.organizations.models import Hospital
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee() or user.is_px_management()):
raise PermissionDenied("Only PX Admins, Hospital Admins, and PX Employee and PX Management can access.")
hospital_id = request.GET.get("hospital")
start_date_str = request.GET.get("start_date")
end_date_str = request.GET.get("end_date")
if user.is_hospital_admin() and user.hospital:
hospital_id = hospital_id or str(user.hospital.id)
elif user.is_px_admin() and request.tenant_hospital:
hospital_id = hospital_id or str(request.tenant_hospital.id)
if not hospital_id:
first = Hospital.objects.first()
if first:
hospital_id = str(first.id)
if not hospital_id:
return render(request, "dashboard/complaint_quarterly_report.html", {"no_data": True})
from datetime import date as _date
current_year = timezone.now().year
if start_date_str and end_date_str:
start_date = _date.fromisoformat(start_date_str)
end_date = _date.fromisoformat(end_date_str)
else:
start_date = _date(current_year, 1, 1)
end_date = _date(current_year, 12, 31)
start_date_str = start_date.isoformat()
end_date_str = end_date.isoformat()
service = ComplaintQuarterlyService(hospital_id=hospital_id, start_date=start_date, end_date=end_date)
active_months = service.active_months
context = {
"hospitals": Hospital.objects.all(),
"selected_hospital": hospital_id,
"selected_year": start_date.year,
"start_date": start_date_str,
"end_date": end_date_str,
"available_years": service.get_available_years(),
"kpi_data": service.get_kpi_data(),
"satisfaction_data": service.get_satisfaction_data(),
"moh_kpi_data": service.get_moh_kpi_data(),
"source_breakdown": service.get_source_breakdown(),
"source_totals": service.get_source_totals(),
"location_breakdown": service.get_location_breakdown(),
"dept_type_breakdown": service.get_dept_type_breakdown(),
"dept_type_monthly": service.get_dept_type_monthly_table(),
"location_ratios": service.get_location_ratios(),
"quarterly_volumes": service.get_quarterly_volumes(),
"monthly_summary": service.get_monthly_summary(),
"escalated": service.get_escalated_breakdown(),
"response_rates": service.get_response_rates(),
"chart_data_json": json.dumps(service.get_chart_data()),
}
kpi_data = context["kpi_data"]
satisfaction_data = context["satisfaction_data"]
moh_kpi_data = context["moh_kpi_data"]
source_breakdown = context["source_breakdown"]
source_totals = context["source_totals"]
location_breakdown = context["location_breakdown"]
dept_type_breakdown = context["dept_type_breakdown"]
dept_type_monthly = context["dept_type_monthly"]
location_ratios = context["location_ratios"]
monthly_summary = context["monthly_summary"]
escalated = context["escalated"]
response_rates = context["response_rates"]
import calendar as _cal
context["month_labels"] = [_cal.month_abbr[m] for m in active_months]
context["kpi_blocks"] = _build_kpi_blocks(kpi_data, satisfaction_data, moh_kpi_data, active_months)
context["source_sub_external"] = _build_source_subrows(source_breakdown, ["moh", "chi", "insurance"], ["MOH", "CHI", "Insurance Company"], active_months)
context["source_sub_internal"] = _build_source_subrows(source_breakdown, ["patients", "relatives"], ["Patients", "Patient's relatives"], active_months)
context["source_internal_monthly"] = [source_breakdown[m]["internal"] for m in active_months]
context["source_total_monthly"] = [source_breakdown[m]["total"] for m in active_months]
context["source_total_rows"] = [
{"label": "Internal Complaints", "count": source_totals["internal"]["count"], "pct_label": "% Internal", "pct": source_totals["internal"]["pct"]},
{"label": "External Complaints", "count": source_totals["external"]["count"], "pct_label": "% External", "pct": source_totals["external"]["pct"]},
]
if source_totals["moh"]["count"] > 0:
context["source_total_rows"].append({"label": "MOH", "count": source_totals["moh"]["count"], "pct_label": "% MOH", "pct": source_totals["moh"]["pct"]})
if source_totals["chi"]["count"] > 0:
context["source_total_rows"].append({"label": "CHI", "count": source_totals["chi"]["count"], "pct_label": "% CHI", "pct": source_totals["chi"]["pct"]})
if source_totals["insurance"]["count"] > 0:
context["source_total_rows"].append({"label": "Insurance Company", "count": source_totals["insurance"]["count"], "pct_label": "% Insurance Comp.", "pct": source_totals["insurance"]["pct"]})
total_all = sum(location_breakdown[m]["total"] for m in active_months)
context["location_rows"] = []
for label, key in [("In-Patient", "ip"), ("Out-Patient", "op"), ("ER", "er")]:
t = sum(location_breakdown[m][key] for m in active_months)
context["location_rows"].append({
"label": label, "total": t, "pct": round(t / total_all, 3) if total_all else 0,
"monthly": [location_breakdown[m][key] for m in active_months], "is_total": False,
})
context["location_rows"].append({
"label": "Total", "total": total_all, "pct": 1,
"monthly": [location_breakdown[m]["total"] for m in active_months], "is_total": True,
})
context["dept_type_rows"] = []
for label, key in [("Medical", "medical"), ("Admin", "admin"), ("Nursing", "nursing"), ("Support Services", "support")]:
t = sum(dept_type_breakdown[m][key] for m in active_months)
context["dept_type_rows"].append({
"label": label, "total": t, "pct": round(t / total_all, 3) if total_all else 0,
"monthly": [dept_type_breakdown[m][key] for m in active_months], "is_total": False,
})
context["dept_type_rows"].append({
"label": "Total", "total": total_all, "pct": 1,
"monthly": [dept_type_breakdown[m]["total"] for m in active_months], "is_total": True,
})
context["dept_monthly_rows"] = []
for mr in dept_type_monthly["months"]:
context["dept_monthly_rows"].append({
"month": mr["month"], "medical": mr["medical"], "admin": mr["admin"],
"nursing": mr["nursing"], "support": mr["support"], "total": mr["total"],
"is_total": False, "is_pct": False,
})
context["dept_monthly_rows"].append({
"month": "TOTAL",
"medical": dept_type_monthly["totals"]["medical"], "admin": dept_type_monthly["totals"]["admin"],
"nursing": dept_type_monthly["totals"]["nursing"], "support": dept_type_monthly["totals"]["support"],
"total": dept_type_monthly["totals"]["total"],
"is_total": True, "is_pct": False,
})
context["dept_monthly_rows"].append({
"month": "% From total",
"medical": dept_type_monthly["percentages"]["medical"], "admin": dept_type_monthly["percentages"]["admin"],
"nursing": dept_type_monthly["percentages"]["nursing"], "support": dept_type_monthly["percentages"]["support"],
"total": dept_type_monthly["percentages"]["total"],
"is_total": False, "is_pct": True,
})
context["location_ratio_tables"] = _build_location_ratio_tables(location_ratios, active_months)
context["monthly_summary_json"] = json.dumps(monthly_summary)
context["dept_type_rows_json"] = json.dumps(context["dept_type_rows"])
per_dept = service.get_per_department_breakdown()
cat_configs = [
("Medical", "medical"),
("Non-Medical", "non_medical"),
("Nursing", "nursing"),
("Support Services", "support_services"),
]
escalated_by_cat = escalated["by_category"]
escalated_table = []
for cat_label, cat_key in cat_configs:
depts = escalated_by_cat.get(cat_key, {})
tc = sum(d["total"] for d in per_dept["categories"].get(cat_key, []))
esc_total = sum(depts.values())
sorted_depts = sorted(depts.items(), key=lambda x: -x[1])
escalated_table.append({
"label": cat_label,
"sub_depts": [{"name": n, "count": c} for n, c in sorted_depts],
"total_escalated": esc_total,
"total_complaints": tc,
"escalation_rate": round(esc_total / tc, 3) if tc else 0,
})
context["escalated_table"] = escalated_table
context["escalated_json"] = json.dumps({
"by_source": escalated.get("by_source", {}),
"total_escalated": escalated.get("total_escalated", 0),
"total_complaints": escalated.get("total_complaints", 0),
"escalation_rate": escalated.get("escalation_rate", 0),
"by_category_rates": {e["label"]: e["escalation_rate"] for e in escalated_table},
"by_category_counts": {e["label"]: e["total_escalated"] for e in escalated_table},
})
context["per_dept"] = per_dept
context["per_dept_json"] = json.dumps({
"categories": {k: v for k, v in per_dept["categories"].items()},
"source_totals": per_dept["source_totals"],
"avg_response_days": per_dept.get("avg_response_days", {}),
})
dept_category_tables = []
for cat_label, cat_key in cat_configs:
depts = per_dept["categories"].get(cat_key, [])
totals = {
"moh": sum(d["moh"] for d in depts),
"chi": sum(d["chi"] for d in depts),
"insurance": sum(d["insurance"] for d in depts),
"internal": sum(d["internal"] for d in depts),
"total": sum(d["total"] for d in depts),
"escalated": sum(d["escalated"] for d in depts),
}
dept_category_tables.append({"label": cat_label, "depts": depts, "totals": totals})
context["dept_category_tables"] = dept_category_tables
st = per_dept["source_totals"]
context["per_dept_source_rows"] = [
{"label": "MOH", "count": st["moh"], "is_total": False},
{"label": "CHI", "count": st["chi"], "is_total": False},
{"label": "Internal", "count": st["internal"], "is_total": False},
{"label": "Insurance Co.", "count": st["insurance"], "is_total": False},
{"label": "Total", "count": st["total"], "is_total": True},
]
context["response_rates_json"] = json.dumps(response_rates)
context["response_rate_source_list"] = [
{"label": "Internal Complaints", "total": response_rates["internal"]["total"], "individual": response_rates["internal"].get("individual", [])},
{"label": "MOH Complaints", "total": response_rates["moh"]["total"], "individual": response_rates["moh"].get("individual", [])},
{"label": "CHI Complaints", "total": response_rates["chi"]["total"], "individual": response_rates["chi"].get("individual", [])},
]
return render(request, "dashboard/complaint_quarterly_report.html", context)
@login_required
def complaint_quarterly_export(request):
from django.core.exceptions import PermissionDenied
from django.http import HttpResponse
from apps.dashboard.services.complaint_quarterly_service import ComplaintQuarterlyService
from apps.dashboard.services.complaint_quarterly_export import generate_complaint_quarterly_excel
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin()):
raise PermissionDenied("Only PX Admins and Hospital Admins can access.")
hospital_id = request.GET.get("hospital")
start_date_str = request.GET.get("start_date")
end_date_str = request.GET.get("end_date")
if user.is_hospital_admin() and user.hospital:
hospital_id = hospital_id or str(user.hospital.id)
elif user.is_px_admin() and request.tenant_hospital:
hospital_id = hospital_id or str(request.tenant_hospital.id)
if not hospital_id:
return HttpResponse("Hospital parameter required", status=400)
from datetime import date as _date
current_year = timezone.now().year
if start_date_str and end_date_str:
start_date = _date.fromisoformat(start_date_str)
end_date = _date.fromisoformat(end_date_str)
else:
start_date = _date(current_year, 1, 1)
end_date = _date(current_year, 12, 31)
service = ComplaintQuarterlyService(hospital_id=hospital_id, start_date=start_date, end_date=end_date)
buf = generate_complaint_quarterly_excel(service)
response = HttpResponse(
buf.getvalue(),
content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
)
date_label = f"{start_date.strftime('%Y%m%d')}-{end_date.strftime('%Y%m%d')}"
response["Content-Disposition"] = f'attachment; filename="complaints_{date_label}.xlsx"'
return response
@login_required
def comments_report(request):
import json
from django.core.exceptions import PermissionDenied
from apps.dashboard.services.comments_report_service import CommentsReportService
from apps.organizations.models import Hospital
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee() or user.is_px_management()):
raise PermissionDenied("Only PX Admins, Hospital Admins, and PX Employee and PX Management can access.")
hospital_id = request.GET.get("hospital")
period = request.GET.get("period", "monthly")
year = request.GET.get("year")
quarter = request.GET.get("quarter")
if user.is_hospital_admin() and user.hospital:
hospital_id = hospital_id or str(user.hospital.id)
elif user.is_px_admin() and request.tenant_hospital:
hospital_id = hospital_id or str(request.tenant_hospital.id)
if not hospital_id:
first = Hospital.objects.first()
if first:
hospital_id = str(first.id)
if not hospital_id:
return render(request, "dashboard/comments_report.html", {"no_data": True})
year = int(year) if year else timezone.now().year
quarter = int(quarter) if quarter else ((timezone.now().month - 1) // 3 + 1)
service = CommentsReportService(hospital_id=hospital_id, year=year, quarter=quarter)
available_periods = service.get_available_periods()
summary = service.get_summary()
by_category = service.get_category_breakdown()
by_sentiment = service.get_sentiment_breakdown()
by_subcategory = service.get_subcategory_breakdown()
action_plans = service.get_action_plans()
chart_data = service.get_chart_data()
fmt = lambda n: f"{n:,}"
context = {
"hospitals": Hospital.objects.all(),
"selected_hospital": hospital_id,
"selected_year": year,
"selected_quarter": quarter,
"available_periods": available_periods,
"summary": summary,
"by_category": by_category,
"by_sentiment": by_sentiment,
"by_subcategory": by_subcategory,
"action_plans": action_plans,
"chart_data_json": json.dumps(chart_data),
}
return render(request, "dashboard/comments_report.html", context)
@login_required
def standards_dashboard(request):
from django.core.exceptions import PermissionDenied
from apps.dashboard.services.standards_report_service import StandardsReportService
from apps.standards.models import StandardSource
from apps.organizations.models import Hospital
user = request.user
if not (user.is_px_admin() or user.is_hospital_admin() or user.is_px_employee() or user.is_px_management()):
raise PermissionDenied("Only PX Admins, Hospital Admins, and PX Employee and PX Management can access.")
hospital_id = request.GET.get("hospital")
source_code = request.GET.get("source", "")
if user.is_hospital_admin() and user.hospital:
hospital_id = hospital_id or str(user.hospital.id)
elif user.is_px_admin() and request.tenant_hospital:
hospital_id = hospital_id or str(request.tenant_hospital.id)
if not hospital_id:
first = Hospital.objects.first()
if first:
hospital_id = str(first.id)
if not hospital_id:
return render(request, "dashboard/standards_dashboard.html", {"no_data": True})
service = StandardsReportService(hospital_id=hospital_id, source_code=source_code or None)
summary = service.get_summary()
if summary["total"] == 0:
return render(request, "dashboard/standards_dashboard.html", {
"no_data": True,
"hospitals": Hospital.objects.all(),
"selected_hospital": hospital_id,
"sources": StandardSource.objects.filter(is_active=True),
"selected_source": source_code,
})
category_breakdown = service.get_category_breakdown()
corrective_actions = service.get_corrective_actions()
standards_table = service.get_standards_table()
score_gauge = service.get_score_gauge_data()
import json
context = {
"hospitals": Hospital.objects.all(),
"selected_hospital": hospital_id,
"sources": StandardSource.objects.filter(is_active=True),
"selected_source": source_code,
"summary": summary,
"category_breakdown": category_breakdown,
"corrective_actions": corrective_actions,
"standards_table": standards_table,
"score_gauge": score_gauge,
"chart_data_json": service.get_all_chart_data(),
}
return render(request, "dashboard/standards_dashboard.html", context)
@login_required
def my_performance(request):
from apps.analytics.services.analytics_service import UnifiedAnalyticsService
from apps.organizations.models import Staff
user = request.user
staff_member = Staff.objects.filter(user=user).select_related("department", "hospital").first()
if not staff_member:
messages.error(request, _("No staff profile found for your account."))
return redirect("dashboard:my_dashboard")
date_range = request.GET.get("date_range", "30d")
custom_start = request.GET.get("custom_start")
custom_end = request.GET.get("custom_end")
if custom_start:
from datetime import datetime
custom_start = datetime.fromisoformat(custom_start)
if custom_end:
from datetime import datetime
custom_end = datetime.fromisoformat(custom_end)
start_date, end_date = UnifiedAnalyticsService._get_date_range(date_range, custom_start, custom_end)
performance = UnifiedAnalyticsService.get_staff_detailed_performance(
staff_id=str(staff_member.user_id),
user=user,
date_range=date_range,
custom_start=custom_start,
custom_end=custom_end,
)
trends = UnifiedAnalyticsService.get_staff_performance_trends(
staff_id=str(staff_member.user_id), user=user, months=6
)
if staff_member.department:
benchmarks = UnifiedAnalyticsService.get_department_benchmarks(
user=user,
department_id=str(staff_member.department.id),
date_range=date_range,
)
else:
benchmarks = None
context = {
"staff_member": staff_member,
"performance": performance,
"trends": trends,
"benchmarks": benchmarks,
"date_range": date_range,
"start_date": start_date,
"end_date": end_date,
}
return render(request, "dashboard/my_performance.html", context)
Reference in New Issue View Git Blame Copy Permalink