A R R R Associates
634 lines
31 KiB
Python
634 lines
31 KiB
Python
from __future__ import annotations
|
|
|
|
from datetime import date, timedelta
|
|
from typing import Any
|
|
|
|
from sqlalchemy import func, or_, select
|
|
from sqlalchemy.orm import Session, selectinload
|
|
|
|
from app.modules.clients.models import Client
|
|
from app.modules.core.iam.models import User
|
|
from app.modules.core.rbac.models import Permission, Role, RolePermission, UserRole
|
|
from app.modules.employees.service import (
|
|
build_employee_scope,
|
|
list_employee_work_assignable_users,
|
|
_engagement_sla,
|
|
_engagement_team,
|
|
_weighted_progress,
|
|
)
|
|
from app.modules.services.execution import CLOSED_TASK_STATUSES
|
|
from app.modules.services.models import ClientServiceSubscription, ClientServiceTaskInstance, ServiceCatalogue, ServiceTaskComment
|
|
|
|
MANAGER_ROLES = {"Manager", "Branch Manager", "System Admin", "Firm Admin", "Partner"}
|
|
MANAGER_PERMISSIONS = {"employees.work.manage", "services.tasks.review", "services.tasks.assign"}
|
|
REVIEW_STATUSES = {"completed", "ready_review", "review_pending", "pending_review", "manager_review"}
|
|
CLIENT_PENDING_STATUSES = {"blocked", "client_pending", "waiting_client", "documents_pending"}
|
|
|
|
|
|
def _count(db: Session, stmt) -> int:
|
|
return int(db.execute(stmt).scalar() or 0)
|
|
|
|
|
|
def get_user_role_names(db: Session, user_id: int) -> list[str]:
|
|
return list(
|
|
db.execute(
|
|
select(Role.name)
|
|
.join(UserRole, UserRole.role_id == Role.id)
|
|
.where(UserRole.user_id == int(user_id), Role.is_active.is_(True))
|
|
.order_by(Role.name.asc())
|
|
).scalars().all()
|
|
)
|
|
|
|
|
|
def get_user_permission_names(db: Session, user_id: int) -> set[str]:
|
|
"""Return active permission codes granted through the user's active roles.
|
|
|
|
The ERP stores permissions in the normalized RolePermission mapping table;
|
|
Role itself intentionally has no ``permissions`` column.
|
|
"""
|
|
rows = db.execute(
|
|
select(Permission.code)
|
|
.join(RolePermission, RolePermission.permission_id == Permission.id)
|
|
.join(Role, Role.id == RolePermission.role_id)
|
|
.join(UserRole, UserRole.role_id == Role.id)
|
|
.where(
|
|
UserRole.user_id == int(user_id),
|
|
Role.is_active.is_(True),
|
|
Permission.is_active.is_(True),
|
|
)
|
|
.distinct()
|
|
).scalars().all()
|
|
return {str(code).strip() for code in rows if code and str(code).strip()}
|
|
|
|
|
|
def can_access_manager_dashboard(db: Session, current_user) -> bool:
|
|
roles = set(get_user_role_names(db, current_user.id))
|
|
if roles.intersection(MANAGER_ROLES):
|
|
return True
|
|
return bool(get_user_permission_names(db, current_user.id).intersection(MANAGER_PERMISSIONS))
|
|
|
|
|
|
def _active_financial_year(request) -> str | None:
|
|
value = request.session.get("active_financial_year") or getattr(request.state, "year_code", None)
|
|
value = (value or "").strip()
|
|
return value or None
|
|
|
|
|
|
def _scope(db: Session, request, current_user):
|
|
return build_employee_scope(
|
|
db,
|
|
current_user,
|
|
tenant_id=request.session.get("active_tenant_id") or getattr(current_user, "tenant_id", None),
|
|
branch_id=request.session.get("active_branch_id"),
|
|
)
|
|
|
|
|
|
def _task_scope(stmt, scope, fy: str | None = None):
|
|
stmt = stmt.where(
|
|
ClientServiceTaskInstance.tenant_id == scope.tenant_id,
|
|
ClientServiceTaskInstance.is_active.is_(True),
|
|
)
|
|
if getattr(scope, "branch_id", None) is not None:
|
|
stmt = stmt.where(ClientServiceTaskInstance.branch_id == scope.branch_id)
|
|
if fy:
|
|
stmt = stmt.where(ClientServiceTaskInstance.financial_year == fy)
|
|
return stmt
|
|
|
|
|
|
def _client_scope(stmt, scope):
|
|
stmt = stmt.where(Client.tenant_id == scope.tenant_id, Client.is_active.is_(True))
|
|
if getattr(scope, "branch_id", None) is not None:
|
|
stmt = stmt.where(Client.branch_id == scope.branch_id)
|
|
return stmt
|
|
|
|
|
|
def _is_open(status: str | None) -> bool:
|
|
return (status or "pending").strip().lower() not in CLOSED_TASK_STATUSES
|
|
|
|
|
|
def _status_label(status: str | None) -> str:
|
|
return (status or "pending").replace("_", " ").replace("-", " ").title()
|
|
|
|
|
|
|
|
|
|
def _days_overdue(due_date) -> int:
|
|
if not due_date:
|
|
return 0
|
|
delta = (date.today() - due_date).days
|
|
return delta if delta > 0 else 0
|
|
|
|
|
|
def _age_bucket(days: int) -> str:
|
|
if days >= 30:
|
|
return "30+ days"
|
|
if days >= 15:
|
|
return "15-29 days"
|
|
if days >= 8:
|
|
return "8-14 days"
|
|
if days >= 4:
|
|
return "4-7 days"
|
|
if days >= 1:
|
|
return "1-3 days"
|
|
return "Current"
|
|
|
|
def _task_href(task: ClientServiceTaskInstance) -> str:
|
|
task_id = getattr(task, "id", None)
|
|
if task_id:
|
|
return f"/employees/work/tasks/{task_id}/communication"
|
|
return "/manager/work"
|
|
|
|
|
|
def _task_row(task: ClientServiceTaskInstance) -> dict[str, Any]:
|
|
today = date.today()
|
|
client = getattr(task, "client", None)
|
|
catalogue = getattr(task, "catalogue", None)
|
|
subscription = getattr(task, "subscription", None)
|
|
assignee = getattr(task, "assigned_to", None)
|
|
status = (getattr(task, "status", None) or "pending").strip().lower()
|
|
due_date = getattr(task, "internal_target_date", None)
|
|
service_name = getattr(catalogue, "service_name", None) or getattr(catalogue, "name", None)
|
|
if not service_name and subscription is not None:
|
|
sub_catalogue = getattr(subscription, "catalogue", None)
|
|
service_name = getattr(sub_catalogue, "service_name", None) or getattr(sub_catalogue, "name", None)
|
|
return {
|
|
"id": getattr(task, "id", None),
|
|
"subscription_id": getattr(task, "subscription_id", None),
|
|
"client_name": getattr(client, "client_name", None) or "Unlinked Client",
|
|
"client_code": getattr(client, "client_code", None) or "",
|
|
"service_name": service_name or "Service",
|
|
"task_name": getattr(task, "task_name", None) or "Task",
|
|
"period": getattr(task, "financial_year", None) or "-",
|
|
"due_date": due_date,
|
|
"status": status,
|
|
"status_label": _status_label(status),
|
|
"priority": getattr(task, "priority", None) or "normal",
|
|
"assigned_to": getattr(assignee, "full_name", None) or getattr(assignee, "email", None) or "Unassigned",
|
|
"comment_count": len([c for c in getattr(task, "comments", []) if not getattr(c, "is_deleted", False)]),
|
|
"is_overdue": bool(due_date and due_date < today and _is_open(status)),
|
|
"is_due_today": bool(due_date and due_date == today and _is_open(status)),
|
|
"days_overdue": _days_overdue(due_date) if _is_open(status) else 0,
|
|
"age_bucket": _age_bucket(_days_overdue(due_date)) if _is_open(status) else "Closed",
|
|
"href": _task_href(task),
|
|
}
|
|
|
|
|
|
def _load_tasks(db: Session, scope, fy: str | None) -> list[ClientServiceTaskInstance]:
|
|
stmt = (
|
|
select(ClientServiceTaskInstance)
|
|
.options(
|
|
selectinload(ClientServiceTaskInstance.client),
|
|
selectinload(ClientServiceTaskInstance.catalogue),
|
|
selectinload(ClientServiceTaskInstance.assigned_to),
|
|
selectinload(ClientServiceTaskInstance.comments).selectinload(ServiceTaskComment.created_by),
|
|
selectinload(ClientServiceTaskInstance.documents),
|
|
selectinload(ClientServiceTaskInstance.subscription).selectinload(ClientServiceSubscription.catalogue),
|
|
)
|
|
)
|
|
stmt = _task_scope(stmt, scope, fy)
|
|
stmt = stmt.order_by(
|
|
ClientServiceTaskInstance.internal_target_date.is_(None),
|
|
ClientServiceTaskInstance.internal_target_date.asc(),
|
|
ClientServiceTaskInstance.priority.desc(),
|
|
ClientServiceTaskInstance.id.desc(),
|
|
).limit(350)
|
|
return list(db.execute(stmt).scalars().all())
|
|
|
|
|
|
def _staff_rows(db: Session, scope, task_rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
|
try:
|
|
users = list_employee_work_assignable_users(db, scope)
|
|
except Exception:
|
|
stmt = select(User).where(User.tenant_id == scope.tenant_id, User.is_active.is_(True))
|
|
if getattr(scope, "branch_id", None) is not None:
|
|
stmt = stmt.where(User.branch_id == scope.branch_id)
|
|
users = list(db.execute(stmt.order_by(User.full_name.asc(), User.email.asc()).limit(100)).scalars().all())
|
|
|
|
stats_by_name: dict[str, dict[str, int]] = {}
|
|
for row in task_rows:
|
|
name = row.get("assigned_to") or "Unassigned"
|
|
bucket = stats_by_name.setdefault(name, {"active": 0, "overdue": 0, "review": 0, "client_pending": 0, "due_today": 0})
|
|
if _is_open(row.get("status")):
|
|
bucket["active"] += 1
|
|
if row.get("is_overdue"):
|
|
bucket["overdue"] += 1
|
|
if row.get("is_due_today"):
|
|
bucket["due_today"] += 1
|
|
if row.get("status") in REVIEW_STATUSES:
|
|
bucket["review"] += 1
|
|
if row.get("status") in CLIENT_PENDING_STATUSES:
|
|
bucket["client_pending"] += 1
|
|
|
|
rows: list[dict[str, Any]] = []
|
|
seen = set()
|
|
for user in users:
|
|
name = getattr(user, "full_name", None) or getattr(user, "email", None) or "User"
|
|
seen.add(name)
|
|
stats = stats_by_name.get(name, {"active": 0, "overdue": 0, "review": 0, "client_pending": 0, "due_today": 0})
|
|
total = stats["active"] + stats["review"]
|
|
rows.append({
|
|
"name": name,
|
|
"email": getattr(user, "email", None) or "",
|
|
"designation": getattr(user, "designation", None) or "",
|
|
**stats,
|
|
"load_status": "Heavy" if total >= 40 else ("Balanced" if total >= 10 else "Light"),
|
|
})
|
|
if "Unassigned" in stats_by_name and "Unassigned" not in seen:
|
|
stats = stats_by_name["Unassigned"]
|
|
rows.append({"name": "Unassigned", "email": "", "designation": "Allocation pending", **stats, "load_status": "Needs allocation"})
|
|
rows.sort(key=lambda r: (r["active"] + r["review"], r["overdue"], r["due_today"]), reverse=True)
|
|
return rows[:30]
|
|
|
|
|
|
def _client_rows(db: Session, scope, task_rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
|
clients = db.execute(_client_scope(select(Client), scope).order_by(Client.client_name.asc()).limit(100)).scalars().all()
|
|
by_client: dict[str, dict[str, int]] = {}
|
|
for row in task_rows:
|
|
key = row["client_name"]
|
|
bucket = by_client.setdefault(key, {"open": 0, "overdue": 0, "client_pending": 0, "review": 0})
|
|
if _is_open(row.get("status")):
|
|
bucket["open"] += 1
|
|
if row.get("is_overdue"):
|
|
bucket["overdue"] += 1
|
|
if row.get("status") in CLIENT_PENDING_STATUSES:
|
|
bucket["client_pending"] += 1
|
|
if row.get("status") in REVIEW_STATUSES:
|
|
bucket["review"] += 1
|
|
out: list[dict[str, Any]] = []
|
|
for client in clients:
|
|
name = getattr(client, "client_name", None) or "Client"
|
|
stats = by_client.get(name, {"open": 0, "overdue": 0, "client_pending": 0, "review": 0})
|
|
out.append({
|
|
"id": getattr(client, "id", None),
|
|
"client_name": name,
|
|
"client_code": getattr(client, "client_code", None) or "",
|
|
"pan": getattr(client, "pan", None) or "",
|
|
"gstin": getattr(client, "gstin", None) or "",
|
|
**stats,
|
|
"href": f"/clients/{getattr(client, 'id', '')}/edit" if getattr(client, "id", None) else "/clients",
|
|
})
|
|
return out[:50]
|
|
|
|
|
|
def _report_cards() -> list[dict[str, str]]:
|
|
return [
|
|
{"group": "Execution", "title": "Team Work Status", "desc": "Open, overdue, in-progress and blocked assignments for the active branch/team.", "href": "/manager/dashboard?tab=team-work"},
|
|
{"group": "Due Control", "title": "Due Calendar", "desc": "Due today, due this week and overdue work in one control view.", "href": "/manager/dashboard?tab=due-calendar"},
|
|
{"group": "Review", "title": "Manager Review Queue", "desc": "Completed or review-ready work waiting for manager action.", "href": "/manager/dashboard?tab=review-queue"},
|
|
{"group": "Client Follow-up", "title": "Client Pending Report", "desc": "Tasks blocked due to documents, clarification or client data pending.", "href": "/manager/dashboard?tab=client-pending"},
|
|
{"group": "Escalation", "title": "Escalation Register", "desc": "Unassigned, overdue and aged client-pending items requiring manager intervention.", "href": "/manager/dashboard?tab=escalations"},
|
|
{"group": "Team", "title": "Staff Workload Report", "desc": "Staff-wise active, overdue, review and client-pending workload.", "href": "/manager/dashboard?tab=team-work"},
|
|
{"group": "Documents", "title": "Document Checklist Report", "desc": "Document-related blocked tasks and communication timeline shortcuts.", "href": "/manager/dashboard?tab=documents"},
|
|
]
|
|
|
|
|
|
def _wizard_cards() -> list[dict[str, str]]:
|
|
return [
|
|
{"title": "Task Assignment Wizard", "desc": "Allocate unassigned tasks and rebalance heavy workload using the existing manager work board.", "href": "/manager/work"},
|
|
{"title": "Due Control Wizard", "desc": "Review due today, due this week and overdue items before escalation.", "href": "/manager/dashboard?tab=due-calendar"},
|
|
{"title": "Review Wizard", "desc": "Open review-ready tasks and proceed through the existing task communication timeline.", "href": "/manager/dashboard?tab=review-queue"},
|
|
{"title": "Client Query Wizard", "desc": "Handle client-pending items and record clarification/document requirements.", "href": "/manager/dashboard?tab=client-pending"},
|
|
{"title": "Document Checklist Wizard", "desc": "Verify document-related blocked tasks and open the existing documents area.", "href": "/documents"},
|
|
{"title": "Escalation Wizard", "desc": "Review aged overdue, unassigned and client-pending items requiring partner/branch attention.", "href": "/manager/dashboard?tab=escalations"},
|
|
{"title": "Work Closure Wizard", "desc": "Open engagement progress and close work after review completion.", "href": "/employees/progress"},
|
|
{"title": "Alert / Follow-up Wizard", "desc": "Open alerts for reminders, escalations and follow-up actions.", "href": "/alerts"},
|
|
]
|
|
|
|
|
|
def _advanced_engagement_rows(tasks: list[ClientServiceTaskInstance]) -> list[dict[str, Any]]:
|
|
grouped: dict[int, list[ClientServiceTaskInstance]] = {}
|
|
for task in tasks:
|
|
grouped.setdefault(int(task.subscription_id), []).append(task)
|
|
rows: list[dict[str, Any]] = []
|
|
for subscription_id, group in grouped.items():
|
|
first = group[0]
|
|
subscription = getattr(first, "subscription", None)
|
|
weighted = _weighted_progress(group)
|
|
sla = _engagement_sla(subscription, group)
|
|
team = _engagement_team(subscription)
|
|
status_values = {(getattr(t, "status", None) or "pending").strip().lower() for t in group}
|
|
completed = sum(1 for t in group if (getattr(t, "status", None) or "pending").strip().lower() in CLOSED_TASK_STATUSES)
|
|
review_pending = sum(1 for t in group if (getattr(t, "manager_review_status", None) or "") == "pending" or (getattr(t, "partner_review_status", None) or "") == "pending" or (getattr(t, "review_partner_review_status", None) or "") == "pending")
|
|
if completed == len(group) and group:
|
|
status = "completed"
|
|
elif "blocked" in status_values or getattr(subscription, "workflow_pause_reason", None):
|
|
status = "blocked"
|
|
elif "in_progress" in status_values or completed:
|
|
status = "in_progress"
|
|
else:
|
|
status = "pending"
|
|
rows.append({
|
|
"subscription_id": subscription_id,
|
|
"client_name": getattr(getattr(first, "client", None), "client_name", None) or "Client",
|
|
"service_name": getattr(getattr(first, "catalogue", None), "service_name", None) or "Service",
|
|
"financial_year": getattr(first, "financial_year", None) or "-",
|
|
"status": status,
|
|
"task_count": len(group),
|
|
"completed_count": completed,
|
|
"review_pending": review_pending,
|
|
"progress_percent": weighted["progress_percent"],
|
|
"completed_weight": weighted["completed_weight"],
|
|
"total_weight": weighted["total_weight"],
|
|
"sla": sla,
|
|
"team": team,
|
|
"manager_name": next((m["name"] for m in team if m["role"] == "Manager"), "Unassigned"),
|
|
"staff_name": next((m["name"] for m in team if m["role"] == "Primary Staff"), "Unassigned"),
|
|
"partner_name": next((m["name"] for m in team if m["role"] == "Engagement Partner"), "Unassigned"),
|
|
"href": f"/employee/work/engagements/{subscription_id}",
|
|
})
|
|
rows.sort(key=lambda r: (r["sla"]["status"] == "breached", r["review_pending"], -r["progress_percent"]), reverse=True)
|
|
return rows
|
|
|
|
|
|
def _capacity_rows(tasks: list[ClientServiceTaskInstance]) -> list[dict[str, Any]]:
|
|
by_user: dict[str, dict[str, Any]] = {}
|
|
for task in tasks:
|
|
user = getattr(task, "assigned_to", None)
|
|
name = getattr(user, "full_name", None) or getattr(user, "email", None) or "Unassigned"
|
|
row = by_user.setdefault(name, {"name": name, "open_weight": 0, "open_tasks": 0, "overdue": 0, "review": 0, "engagement_ids": set()})
|
|
status = (getattr(task, "status", None) or "pending").strip().lower()
|
|
if status not in CLOSED_TASK_STATUSES:
|
|
row["open_tasks"] += 1
|
|
row["open_weight"] += _weighted_progress([task])["total_weight"]
|
|
row["engagement_ids"].add(int(task.subscription_id))
|
|
if getattr(task, "internal_target_date", None) and task.internal_target_date < date.today():
|
|
row["overdue"] += 1
|
|
if status in REVIEW_STATUSES:
|
|
row["review"] += 1
|
|
out=[]
|
|
for row in by_user.values():
|
|
score = row["open_weight"] + row["review"] * 2 + row["overdue"] * 3
|
|
row["engagement_count"] = len(row.pop("engagement_ids"))
|
|
row["capacity_score"] = score
|
|
row["load_status"] = "Heavy" if score >= 55 else ("Balanced" if score >= 18 else "Light")
|
|
out.append(row)
|
|
out.sort(key=lambda r: r["capacity_score"], reverse=True)
|
|
return out
|
|
|
|
|
|
def build_manager_dashboard_payload(db: Session, request, current_user) -> dict[str, Any]:
|
|
scope = _scope(db, request, current_user)
|
|
fy = _active_financial_year(request)
|
|
today = date.today()
|
|
next_week = today + timedelta(days=7)
|
|
tasks = _load_tasks(db, scope, fy)
|
|
task_rows = [_task_row(t) for t in tasks]
|
|
open_rows = [r for r in task_rows if _is_open(r["status"])]
|
|
overdue_rows = [r for r in open_rows if r["is_overdue"]]
|
|
due_today_rows = [r for r in open_rows if r["is_due_today"]]
|
|
due_week_rows = [r for r in open_rows if r["due_date"] and today <= r["due_date"] <= next_week]
|
|
review_rows = [r for r in task_rows if r["status"] in REVIEW_STATUSES]
|
|
client_pending_rows = [r for r in open_rows if r["status"] in CLIENT_PENDING_STATUSES]
|
|
unassigned_rows = [r for r in open_rows if (r.get("assigned_to") or "Unassigned") == "Unassigned"]
|
|
in_progress_rows = [r for r in open_rows if r["status"] == "in_progress"]
|
|
|
|
staff_rows = _staff_rows(db, scope, task_rows)
|
|
client_rows = _client_rows(db, scope, task_rows)
|
|
advanced_engagements = _advanced_engagement_rows(tasks)
|
|
capacity_rows = _capacity_rows(tasks)
|
|
sla_breached = [row for row in advanced_engagements if row["sla"]["status"] == "breached"]
|
|
sla_warning = [row for row in advanced_engagements if row["sla"]["status"] in {"critical", "warning"}]
|
|
engagement_review_queue = [row for row in advanced_engagements if row["review_pending"]]
|
|
|
|
tenant = getattr(scope, "tenant", None)
|
|
branch = getattr(scope, "branch", None)
|
|
age_buckets = [
|
|
{"label": "1-3 days", "count": len([r for r in overdue_rows if r.get("age_bucket") == "1-3 days"])},
|
|
{"label": "4-7 days", "count": len([r for r in overdue_rows if r.get("age_bucket") == "4-7 days"])},
|
|
{"label": "8-14 days", "count": len([r for r in overdue_rows if r.get("age_bucket") == "8-14 days"])},
|
|
{"label": "15-29 days", "count": len([r for r in overdue_rows if r.get("age_bucket") == "15-29 days"])},
|
|
{"label": "30+ days", "count": len([r for r in overdue_rows if r.get("age_bucket") == "30+ days"])},
|
|
]
|
|
|
|
status_summary: dict[str, int] = {}
|
|
service_summary: dict[str, int] = {}
|
|
for row in open_rows:
|
|
status_summary[row.get("status_label") or "Pending"] = status_summary.get(row.get("status_label") or "Pending", 0) + 1
|
|
service_summary[row.get("service_name") or "Service"] = service_summary.get(row.get("service_name") or "Service", 0) + 1
|
|
|
|
escalation_rows = sorted(
|
|
(unassigned_rows + overdue_rows + client_pending_rows),
|
|
key=lambda r: (r.get("days_overdue") or 0, r.get("is_overdue") or False, r.get("due_date") or date.max),
|
|
reverse=True,
|
|
)
|
|
|
|
overview = {
|
|
"tenant": tenant,
|
|
"branch": branch,
|
|
"tenant_id": getattr(scope, "tenant_id", None),
|
|
"branch_id": getattr(scope, "branch_id", None),
|
|
"financial_year": fy,
|
|
"total_tasks": len(task_rows),
|
|
"open_task_count": len(open_rows),
|
|
"unassigned_count": len(unassigned_rows),
|
|
"in_progress_count": len(in_progress_rows),
|
|
"overdue_count": len(overdue_rows),
|
|
"due_today_count": len(due_today_rows),
|
|
"due_week_count": len(due_week_rows),
|
|
"client_pending_count": len(client_pending_rows),
|
|
"review_pending_count": len(review_rows),
|
|
"staff_count": len(staff_rows),
|
|
"client_count": len(client_rows),
|
|
"escalation_count": len(escalation_rows),
|
|
"engagement_count": len(advanced_engagements),
|
|
"sla_breached_count": len(sla_breached),
|
|
"sla_warning_count": len(sla_warning),
|
|
"engagement_review_count": len(engagement_review_queue),
|
|
"heavy_capacity_count": len([row for row in capacity_rows if row["load_status"] == "Heavy"]),
|
|
"today": today,
|
|
}
|
|
|
|
return {
|
|
"roles": sorted(get_user_role_names(db, current_user.id)),
|
|
"overview": overview,
|
|
"team_work": task_rows[:100],
|
|
"due_today": due_today_rows[:30],
|
|
"due_week": due_week_rows[:30],
|
|
"overdue": overdue_rows[:30],
|
|
"unassigned": unassigned_rows[:30],
|
|
"in_progress": in_progress_rows[:30],
|
|
"review_queue": review_rows[:60],
|
|
"client_pending": client_pending_rows[:60],
|
|
"documents_pending": client_pending_rows[:40],
|
|
"escalations": escalation_rows[:80],
|
|
"age_buckets": age_buckets,
|
|
"status_summary": sorted([{"label": k, "count": v} for k, v in status_summary.items()], key=lambda x: x["count"], reverse=True)[:10],
|
|
"service_summary": sorted([{"label": k, "count": v} for k, v in service_summary.items()], key=lambda x: x["count"], reverse=True)[:10],
|
|
"staff_rows": staff_rows,
|
|
"clients": client_rows,
|
|
"advanced_engagements": advanced_engagements,
|
|
"capacity_rows": capacity_rows,
|
|
"sla_breached": sla_breached,
|
|
"sla_warning": sla_warning,
|
|
"engagement_review_queue": engagement_review_queue,
|
|
"reports": _report_cards(),
|
|
"wizards": _wizard_cards(),
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Phase 5A - engagement-level Manager review workspace.
|
|
# This is a presentation and navigation layer over the existing task review,
|
|
# evidence, comment, rework, AQMM and lock controls. No duplicate review state
|
|
# or review table is introduced.
|
|
# ---------------------------------------------------------------------------
|
|
_MANAGER_REVIEW_PENDING = {"pending", "review_pending", "pending_review", "manager_review", "ready_review"}
|
|
_MANAGER_REVIEW_DONE = {"reviewed"}
|
|
_MANAGER_REVIEW_REWORK = {"rework_required"}
|
|
|
|
|
|
def _manager_review_task_state(task: ClientServiceTaskInstance) -> str:
|
|
manager_status = (getattr(task, "manager_review_status", None) or "not_required").strip().lower()
|
|
task_status = (getattr(task, "status", None) or "pending").strip().lower()
|
|
rework_status = (getattr(task, "rework_status", None) or "none").strip().lower()
|
|
if manager_status in _MANAGER_REVIEW_REWORK or rework_status == "open":
|
|
return "rework"
|
|
if manager_status in _MANAGER_REVIEW_DONE:
|
|
return "reviewed"
|
|
if manager_status in _MANAGER_REVIEW_PENDING or task_status in REVIEW_STATUSES:
|
|
return "pending_review"
|
|
if getattr(task, "aqmm_manager_review_required", False) and task_status in CLOSED_TASK_STATUSES:
|
|
return "pending_review"
|
|
return "not_ready"
|
|
|
|
|
|
def _manager_review_category(task: ClientServiceTaskInstance) -> str:
|
|
return (getattr(task, "task_category", None) or "General Workflow").strip() or "General Workflow"
|
|
|
|
|
|
def _manager_review_task_row(task: ClientServiceTaskInstance) -> dict[str, Any]:
|
|
state = _manager_review_task_state(task)
|
|
comments = [c for c in (getattr(task, "comments", None) or []) if not getattr(c, "is_deleted", False)]
|
|
documents = list(getattr(task, "documents", None) or [])
|
|
assignee = getattr(task, "assigned_to", None)
|
|
return {
|
|
"id": int(task.id),
|
|
"task_name": getattr(task, "task_name", None) or "Task",
|
|
"description": getattr(task, "description", None) or "",
|
|
"category": _manager_review_category(task),
|
|
"sequence_no": int(getattr(task, "sequence_no", 0) or 0),
|
|
"task_status": (getattr(task, "status", None) or "pending").strip().lower(),
|
|
"task_status_label": _status_label(getattr(task, "status", None)),
|
|
"review_state": state,
|
|
"review_state_label": state.replace("_", " ").title(),
|
|
"manager_review_status": (getattr(task, "manager_review_status", None) or "not_required").strip().lower(),
|
|
"manager_review_note": getattr(task, "manager_review_note", None) or "",
|
|
"rework_status": (getattr(task, "rework_status", None) or "none").strip().lower(),
|
|
"rework_reason": getattr(task, "rework_reason", None) or "",
|
|
"assigned_to": getattr(assignee, "full_name", None) or getattr(assignee, "email", None) or "Unassigned",
|
|
"response_type": (getattr(task, "response_type", None) or "NONE").strip().upper(),
|
|
"response_required": bool(getattr(task, "response_required", False)),
|
|
"checklist_response": getattr(task, "checklist_response", None),
|
|
"checklist_text_response": getattr(task, "checklist_text_response", None),
|
|
"checklist_number_response": getattr(task, "checklist_number_response", None),
|
|
"checklist_date_response": getattr(task, "checklist_date_response", None),
|
|
"checklist_remarks": getattr(task, "checklist_remarks", None) or "",
|
|
"evidence_required": bool(getattr(task, "evidence_required", False) or getattr(task, "aqmm_evidence_required", False)),
|
|
"evidence_count": len(documents),
|
|
"comment_count": len(comments),
|
|
"comments": comments[:20],
|
|
"is_aqmm_task": bool(getattr(task, "is_aqmm_task", False)),
|
|
"aqmm_reference": getattr(task, "aqmm_reference", None) or "",
|
|
"blocks_final_release": bool(getattr(task, "aqmm_blocks_final_release", False)),
|
|
"is_locked": bool(getattr(task, "is_locked", False) or getattr(getattr(task, "subscription", None), "is_locked", False)),
|
|
"documents_href": f"/documents/tasks/{task.id}",
|
|
"task_href": f"/services/work-tracker/tasks/{task.id}/edit",
|
|
}
|
|
|
|
|
|
def get_manager_review_workspace(
|
|
db: Session,
|
|
request,
|
|
current_user,
|
|
*,
|
|
subscription_id: int,
|
|
active_task_id: int | None = None,
|
|
) -> dict[str, Any] | None:
|
|
"""Build one Manager review workspace for an engagement in active scope."""
|
|
scope = _scope(db, request, current_user)
|
|
fy = _active_financial_year(request)
|
|
stmt = (
|
|
select(ClientServiceTaskInstance)
|
|
.options(
|
|
selectinload(ClientServiceTaskInstance.client),
|
|
selectinload(ClientServiceTaskInstance.catalogue),
|
|
selectinload(ClientServiceTaskInstance.assigned_to),
|
|
selectinload(ClientServiceTaskInstance.comments).selectinload(ServiceTaskComment.created_by),
|
|
selectinload(ClientServiceTaskInstance.documents),
|
|
selectinload(ClientServiceTaskInstance.subscription).selectinload(ClientServiceSubscription.catalogue),
|
|
)
|
|
.where(ClientServiceTaskInstance.subscription_id == int(subscription_id))
|
|
)
|
|
stmt = _task_scope(stmt, scope, fy)
|
|
tasks = list(db.execute(stmt.order_by(ClientServiceTaskInstance.sequence_no.asc(), ClientServiceTaskInstance.id.asc())).scalars().all())
|
|
if not tasks:
|
|
return None
|
|
|
|
task_rows = [_manager_review_task_row(task) for task in tasks]
|
|
reviewable = [row for row in task_rows if row["review_state"] in {"pending_review", "reviewed", "rework"}]
|
|
pending = [row for row in reviewable if row["review_state"] == "pending_review"]
|
|
reviewed = [row for row in reviewable if row["review_state"] == "reviewed"]
|
|
rework = [row for row in reviewable if row["review_state"] == "rework"]
|
|
|
|
categories_by_name: dict[str, dict[str, Any]] = {}
|
|
for row in task_rows:
|
|
category = categories_by_name.setdefault(row["category"], {
|
|
"name": row["category"], "tasks": [], "total": 0, "reviewable": 0,
|
|
"pending": 0, "reviewed": 0, "rework": 0,
|
|
})
|
|
category["tasks"].append(row)
|
|
category["total"] += 1
|
|
if row["review_state"] in {"pending_review", "reviewed", "rework"}:
|
|
category["reviewable"] += 1
|
|
category[row["review_state"].replace("pending_review", "pending")] += 1
|
|
categories = list(categories_by_name.values())
|
|
for category in categories:
|
|
denominator = category["reviewable"] or 0
|
|
category["progress_percent"] = round(category["reviewed"] * 100 / denominator) if denominator else 0
|
|
if category["rework"]:
|
|
category["status"] = "rework"
|
|
elif category["pending"]:
|
|
category["status"] = "pending_review"
|
|
elif denominator and category["reviewed"] == denominator:
|
|
category["status"] = "reviewed"
|
|
else:
|
|
category["status"] = "not_ready"
|
|
|
|
active = None
|
|
if active_task_id:
|
|
active = next((row for row in task_rows if row["id"] == int(active_task_id)), None)
|
|
if active is None:
|
|
active = (pending or rework or reviewed or task_rows)[0]
|
|
|
|
first = tasks[0]
|
|
subscription = getattr(first, "subscription", None)
|
|
weighted = _weighted_progress(tasks)
|
|
sla = _engagement_sla(subscription, tasks)
|
|
team = _engagement_team(subscription)
|
|
return {
|
|
"subscription_id": int(subscription_id),
|
|
"client_name": getattr(getattr(first, "client", None), "client_name", None) or "Client",
|
|
"service_name": getattr(getattr(first, "catalogue", None), "service_name", None) or "Service",
|
|
"financial_year": getattr(first, "financial_year", None) or "-",
|
|
"weighted_progress": weighted,
|
|
"sla": sla,
|
|
"team": team,
|
|
"categories": categories,
|
|
"tasks": task_rows,
|
|
"active_task": active,
|
|
"reviewable_count": len(reviewable),
|
|
"pending_review_count": len(pending),
|
|
"reviewed_count": len(reviewed),
|
|
"rework_count": len(rework),
|
|
"is_locked": bool(getattr(subscription, "is_locked", False)),
|
|
}
|
|
|
|
|
|
def get_next_manager_review_task_id(workspace: dict[str, Any], current_task_id: int) -> int | None:
|
|
"""Return the next task requiring Manager action, preserving category/sequence order."""
|
|
tasks = workspace.get("tasks") or []
|
|
current_index = next((i for i, row in enumerate(tasks) if int(row["id"]) == int(current_task_id)), -1)
|
|
ordered = tasks[current_index + 1:] + tasks[:max(current_index, 0)]
|
|
next_row = next((row for row in ordered if row["review_state"] == "pending_review"), None)
|
|
return int(next_row["id"]) if next_row else None
|