From ab0e71f7ebdb222a4bf7d5935435893a049eab95 Mon Sep 17 00:00:00 2001 From: S4NKALP Date: Sun, 28 Jun 2026 14:16:16 +0545 Subject: [PATCH] feat(src): add ticketing REST API and admin UI for tickets, settings, and branding Introduce DRF views for ticket creation, listing, updating, and commenting, integrate admin registrations for new models, and provide a demo data command to seed initial content. This enables full project management workflow within the backend. --- src/accounts/admin.py | 32 +- src/accounts/apps.py | 5 +- src/accounts/management/__init__.py | 0 src/accounts/management/commands/__init__.py | 0 src/accounts/management/commands/demo_data.py | 559 ++++++++++ src/accounts/management/commands/seed_data.py | 51 + src/accounts/migrations/0001_initial.py | 259 +++++ src/accounts/models.py | 80 +- src/accounts/serializers.py | 49 +- src/accounts/tests.py | 3 +- src/accounts/urls.py | 17 +- src/accounts/views.py | 144 ++- src/dashboard/board_views/__init__.py | 3 + src/dashboard/board_views/actions.py | 138 +++ src/dashboard/board_views/board.py | 250 +++++ src/dashboard/board_views/export.py | 105 ++ src/dashboard/context_processors.py | 37 + src/dashboard/list_views/__init__.py | 4 + src/dashboard/list_views/bulk_delete.py | 131 +++ src/dashboard/list_views/notification_list.py | 71 ++ src/dashboard/list_views/project_list.py | 159 +++ src/dashboard/list_views/ticket_list.py | 192 ++++ src/dashboard/page_views/__init__.py | 7 + src/dashboard/page_views/epic_views.py | 189 ++++ src/dashboard/page_views/external_views.py | 140 +++ .../page_views/notification_views.py | 154 +++ src/dashboard/page_views/other_views.py | 327 ++++++ src/dashboard/page_views/project_views.py | 674 ++++++++++++ src/dashboard/page_views/ticket_views.py | 955 ++++++++++++++++++ src/dashboard/page_views/user_views.py | 349 +++++++ src/dashboard/views/__init__.py | 4 + src/dashboard/views/activity.py | 99 ++ src/dashboard/views/charts.py | 150 +++ src/dashboard/views/dashboard.py | 364 +++++++ src/dashboard/views/timeline.py | 114 +++ src/epics/admin.py | 11 +- src/epics/apps.py | 5 +- src/epics/migrations/0001_initial.py | 50 + src/epics/models.py | 24 +- src/epics/serializers.py | 27 +- src/epics/tests.py | 3 +- src/epics/urls.py | 9 +- src/epics/views.py | 23 +- src/external/admin.py | 10 +- src/external/apps.py | 5 +- src/external/migrations/0001_initial.py | 63 ++ src/external/models.py | 35 +- src/external/serializers.py | 38 +- src/external/tests.py | 3 +- src/external/urls.py | 10 +- src/external/views.py | 68 +- src/notes/admin.py | 11 +- src/notes/apps.py | 5 +- src/notes/migrations/0001_initial.py | 63 ++ src/notes/models.py | 28 +- src/notes/serializers.py | 23 +- src/notes/tests.py | 3 +- src/notes/urls.py | 9 +- src/notes/views.py | 26 +- src/notifications/admin.py | 11 +- src/notifications/apps.py | 5 +- src/notifications/email_utils.py | 237 +++++ src/notifications/migrations/0001_initial.py | 118 +++ src/notifications/models.py | 65 +- src/notifications/serializers.py | 21 +- src/notifications/signals.py | 86 ++ src/notifications/tests.py | 3 +- src/notifications/urls.py | 13 +- src/notifications/views.py | 40 +- src/projects/admin.py | 30 +- src/projects/apps.py | 5 +- src/projects/migrations/0001_initial.py | 116 +++ src/projects/models.py | 76 +- src/projects/serializers.py | 67 +- src/projects/tests.py | 3 +- src/projects/urls.py | 26 +- src/projects/views.py | 139 ++- src/tickets/admin.py | 93 +- src/tickets/apps.py | 5 +- src/tickets/migrations/0001_initial.py | 352 +++++++ src/tickets/models.py | 187 +++- src/tickets/serializers.py | 174 +++- src/tickets/tests.py | 3 +- src/tickets/urls.py | 26 +- src/tickets/views.py | 134 ++- 85 files changed, 8257 insertions(+), 145 deletions(-) create mode 100644 src/accounts/management/__init__.py create mode 100644 src/accounts/management/commands/__init__.py create mode 100644 src/accounts/management/commands/demo_data.py create mode 100644 src/accounts/management/commands/seed_data.py create mode 100644 src/accounts/migrations/0001_initial.py create mode 100644 src/dashboard/board_views/__init__.py create mode 100644 src/dashboard/board_views/actions.py create mode 100644 src/dashboard/board_views/board.py create mode 100644 src/dashboard/board_views/export.py create mode 100644 src/dashboard/context_processors.py create mode 100644 src/dashboard/list_views/__init__.py create mode 100644 src/dashboard/list_views/bulk_delete.py create mode 100644 src/dashboard/list_views/notification_list.py create mode 100644 src/dashboard/list_views/project_list.py create mode 100644 src/dashboard/list_views/ticket_list.py create mode 100644 src/dashboard/page_views/__init__.py create mode 100644 src/dashboard/page_views/epic_views.py create mode 100644 src/dashboard/page_views/external_views.py create mode 100644 src/dashboard/page_views/notification_views.py create mode 100644 src/dashboard/page_views/other_views.py create mode 100644 src/dashboard/page_views/project_views.py create mode 100644 src/dashboard/page_views/ticket_views.py create mode 100644 src/dashboard/page_views/user_views.py create mode 100644 src/dashboard/views/__init__.py create mode 100644 src/dashboard/views/activity.py create mode 100644 src/dashboard/views/charts.py create mode 100644 src/dashboard/views/dashboard.py create mode 100644 src/dashboard/views/timeline.py create mode 100644 src/epics/migrations/0001_initial.py create mode 100644 src/external/migrations/0001_initial.py create mode 100644 src/notes/migrations/0001_initial.py create mode 100644 src/notifications/email_utils.py create mode 100644 src/notifications/migrations/0001_initial.py create mode 100644 src/notifications/signals.py create mode 100644 src/projects/migrations/0001_initial.py create mode 100644 src/tickets/migrations/0001_initial.py diff --git a/src/accounts/admin.py b/src/accounts/admin.py index 0dc5f91..ab49911 100644 --- a/src/accounts/admin.py +++ b/src/accounts/admin.py @@ -1,5 +1,31 @@ -"""generated with djinit""" - from django.contrib import admin +from django.contrib.auth.admin import UserAdmin as BaseUserAdmin -# Register your models here. \ No newline at end of file +from src.accounts.models import Setting, SiteBranding, User + + +@admin.register(User) +class UserAdmin(BaseUserAdmin): + list_display = ("id", "email", "name", "is_staff", "is_active") + search_fields = ("email", "name") + ordering = ("email",) + fieldsets = BaseUserAdmin.fieldsets + ( + ("Extra", {"fields": ("google_id", "profile_image", "role")}), + ) + + @admin.display(description="Name") + def name(self, obj): + return obj.get_full_name() or obj.username + + +@admin.register(Setting) +class SettingAdmin(admin.ModelAdmin): + list_display = ("id", "user", "group", "key", "value") + list_filter = ("group",) + search_fields = ("key", "value", "user__email") + + +@admin.register(SiteBranding) +class SiteBrandingAdmin(admin.ModelAdmin): + list_display = ("brand_name", "is_active", "created_at", "updated_at") + list_editable = ("is_active",) diff --git a/src/accounts/apps.py b/src/accounts/apps.py index 1438ca9..0c62848 100644 --- a/src/accounts/apps.py +++ b/src/accounts/apps.py @@ -1,7 +1,6 @@ from django.apps import AppConfig - class AccountsConfig(AppConfig): - default_auto_field = 'django.db.models.BigAutoField' - name = 'src.accounts' \ No newline at end of file + default_auto_field = "django.db.models.BigAutoField" + name = "src.accounts" diff --git a/src/accounts/management/__init__.py b/src/accounts/management/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/accounts/management/commands/__init__.py b/src/accounts/management/commands/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/accounts/management/commands/demo_data.py b/src/accounts/management/commands/demo_data.py new file mode 100644 index 0000000..403fd25 --- /dev/null +++ b/src/accounts/management/commands/demo_data.py @@ -0,0 +1,559 @@ +import random +from datetime import date, timedelta + +from django.contrib.auth import get_user_model +from django.core.management.base import BaseCommand +from django.utils import timezone + +from src.accounts.models import Setting, SiteBranding +from src.epics.models import Epic +from src.external.models import ExternalAccess +from src.notes.models import ProjectNote +from src.notifications.models import Notification +from src.projects.models import Project, ProjectMember +from src.tickets.models import ( + Ticket, + TicketComment, + TicketHistory, + TicketPriority, + TicketStatus, +) + +User = get_user_model() + + +# ── Helpers for rich text content (custom rich text editor format) ───────── + + +def _rich_paragraph(text): + return f"

{text}

" + + +def _rich_bold(text): + return f"{text}" + + +def _rich_list(items): + lis = "".join(f"
  • {item}
  • " for item in items) + return f"" + + +def project_rich_description(name, details): + return ( + _rich_paragraph(f"Welcome to the {_rich_bold(name)} project. {details}") + + _rich_paragraph( + "This project follows agile methodology with bi-weekly sprints. " + "All team members are expected to participate in daily stand-ups and sprint retrospectives." + ) + + _rich_list( + [ + "Ensure all code is peer-reviewed before merging to main.", + "Write unit tests for all new features and bug fixes.", + "Update project documentation when adding new functionality.", + "Use the project board to track task progress.", + ] + ) + ) + + +def epic_rich_description(epic_name, proj_name): + return ( + _rich_paragraph( + f"This epic covers the {_rich_bold(epic_name)} module of the {_rich_bold(proj_name)} project." + ) + + _rich_paragraph( + "The scope includes requirement analysis, design, implementation, testing, and deployment. " + "All sub-tasks must be completed before the epic can be marked as done." + ) + + _rich_list( + [ + "Define technical specifications and architecture.", + "Implement backend APIs and database schemas.", + "Build frontend components with responsive design.", + "Conduct integration testing and QA review.", + ] + ) + ) + + +def ticket_rich_description(ticket_name): + descriptions = [ + ( + f"This task involves implementing the feature {ticket_name}. " + "Please review the requirements in the associated epic before starting." + ), + f"

    Work on {ticket_name} requires both backend and frontend changes.

    Refer to the wireframes and API docs for guidance.

    ", + f"

    This is a critical task for {ticket_name}.

    ", + ] + return random.choice(descriptions) + + +def comment_rich_text(c_idx, ticket_name): + comments = [ + "

    I've started working on this. The initial approach looks promising. ETA: 2 days.

    ", + "

    Found an issue with the API response format. Needs discussion in the next standup.

    ", + f"

    Code review completed for {ticket_name}. A few minor changes requested.

    Please address the comments and re-request review.

    ", + "

    Tests are passing locally. Ready for QA.

    @qa-team please verify on staging environment.

    ", + "

    Updated the PR with the requested changes. Please re-review when you get a chance.

    ", + "

    This is blocked by an external dependency. Waiting for the API team to finalize the endpoints.

    ", + ] + return comments[c_idx % len(comments)] + + +def note_rich_content(title, proj_name): + return ( + _rich_paragraph( + f"Meeting notes for {title} related to the {_rich_bold(proj_name)} project." + ) + + _rich_paragraph( + "Key discussion points and decisions made during the session." + ) + + _rich_list( + [ + "Discussed sprint progress and upcoming milestones.", + "Identified potential risks and mitigation strategies.", + "Assigned action items to team members.", + "Next meeting scheduled to review progress.", + ] + ) + ) + + +class Command(BaseCommand): + help = "Create demo projects, members, tickets, notes, notifications, external access, and activity with rich data" + + def add_arguments(self, parser): + parser.add_argument( + "--clear", + action="store_true", + help="Clear all existing demo data before seeding (preserves superadmin users and their settings)", + ) + + def handle(self, *args, **options): + should_clear = options.get("clear", False) + + if should_clear: + self.stdout.write("Clearing existing demo data (preserving superadmins)...") + superadmin_ids = list( + User.objects.filter(is_superuser=True).values_list("id", flat=True) + ) + Notification.objects.exclude(user_id__in=superadmin_ids).delete() + Notification.objects.filter(user_id__in=superadmin_ids).delete() + ProjectNote.objects.all().delete() + ExternalAccess.objects.all().delete() + Ticket.objects.all().delete() + Epic.objects.all().delete() + Project.objects.all().delete() + Setting.objects.exclude(user_id__in=superadmin_ids).delete() + # Delete demo users (non-superadmin, non-staff) + User.objects.filter(is_superuser=False, is_staff=False).delete() + else: + self.stdout.write("Adding demo data on top of existing data...") + + # ── Admin user ────────────────────────────────────────────────────── + admin = User.objects.filter(is_superuser=True).first() + if not admin: + admin = User.objects.create_superuser("admin", "admin@mail.com", "admin123") + + # ── Ticket Priorities (seed if not present) ───────────────────────── + priority_defs = [ + ("Critical", "#EF4444"), + ("High", "#F59E0B"), + ("Medium", "#3B82F6"), + ("Low", "#6B7280"), + ("Trivial", "#10B981"), + ] + priorities = {} + for name, color in priority_defs: + p, _ = TicketPriority.objects.get_or_create( + name=name, defaults={"color": color} + ) + priorities[name] = p + + # ── Site Branding ──────────────────────────────────────────────────── + branding_defaults = { + "brand_name": "DevBoard", + "copyright_name": "DevBoard Project Management", + "is_active": True, + } + SiteBranding.objects.get_or_create( + brand_name="DevBoard", defaults=branding_defaults + ) + self.stdout.write(" ✓ Site branding seeded") + + # ── Demo Users ─────────────────────────────────────────────────────── + + users = [] + for i in range(1, 10): + user, _ = User.objects.get_or_create( + username=f"user{i}", + defaults={ + "email": f"user{i}@mail.com", + "first_name": f"Developer{i}", + "last_name": "User", + "role": "member", + }, + ) + user.set_password("user123") + if user.role != "member": + user.role = "member" + user.save() + users.append(user) + + # Additional specific roles + roles = ["Manager", "Designer", "Tester", "DevOps"] + for r_name in roles: + u_role = "manager" if r_name == "Manager" else "member" + user, _ = User.objects.get_or_create( + username=r_name.lower(), + defaults={ + "email": f"{r_name.lower()}@mail.com", + "first_name": r_name, + "last_name": "Staff", + "role": u_role, + }, + ) + user.set_password("user123") + if user.role != u_role: + user.role = u_role + user.save() + users.append(user) + + all_users = [admin] + users + self.stdout.write(f" ✓ {len(all_users)} users ready") + + # ── User Settings ──────────────────────────────────────────────────── + theme_options = ["blue", "emerald", "indigo", "purple", "teal", "rose"] + nav_options = ["sidebar", "top"] + for u in all_users: + Setting.objects.get_or_create( + user=u, + key="theme", + defaults={"value": random.choice(theme_options), "group": "ui"}, + ) + Setting.objects.get_or_create( + user=u, + key="navigation_style", + defaults={"value": random.choice(nav_options), "group": "ui"}, + ) + Setting.objects.get_or_create( + user=u, + key="items_per_page", + defaults={"value": "25", "group": "preferences"}, + ) + self.stdout.write(" ✓ User settings seeded") + + # ── Projects Data ──────────────────────────────────────────────────── + projects_data = [ + { + "name": "Ecommerce with POS/Inventory", + "prefix": "ECO", + "color": "#3B82F6", + "description": "A comprehensive ecommerce platform with integrated Point of Sale (POS) and real-time inventory tracking for physical and digital stores.", + "epics": [ + "POS Integration", + "Inventory Management", + "Shopping Cart", + "Payment Gateway", + ], + }, + { + "name": "Org Website", + "prefix": "ORG", + "color": "#10B981", + "description": "A modern and responsive corporate website for the organization, highlighting our services, team, and company culture.", + "epics": [ + "Homepage Redesign", + "About Us Page", + "Services Section", + "Contact & Forms", + ], + }, + { + "name": "Health Homeservice Website", + "prefix": "HLT", + "color": "#EC4899", + "description": "A platform connecting patients with healthcare professionals for at-home care, nursing services, and telemedicine consultations.", + "epics": [ + "Provider Dashboard", + "Patient Portal", + "Booking System", + "Telehealth Video", + ], + }, + { + "name": "Consultancy Website", + "prefix": "CON", + "color": "#F59E0B", + "description": "A professional platform for consultancy services to showcase expertise, manage client inquiries, and schedule consultations.", + "epics": [ + "Case Studies Portfolio", + "Lead Generation Forms", + "Scheduling Integration", + "Client Testimonials", + ], + }, + { + "name": "School Website with Student Management", + "prefix": "SCH", + "color": "#8B5CF6", + "description": "An educational portal combining a public-facing school website with a comprehensive backend for student records, attendance, and grading.", + "epics": [ + "Student Information System", + "Parent Portal", + "Grading & Attendance", + "Public Admissions Page", + ], + }, + { + "name": "Human Resource Management Website", + "prefix": "HRM", + "color": "#6366F1", + "description": "A robust internal HR platform for managing employee records, payroll, leave requests, and performance evaluations.", + "epics": [ + "Employee Onboarding", + "Payroll Processing", + "Leave Management", + "Performance Reviews", + ], + }, + { + "name": "Staff Location Tracking Application", + "prefix": "TRK", + "color": "#EF4444", + "description": "A mobile and web application for tracking remote and on-field staff locations in real-time, optimizing routes and managing dispatch.", + "epics": [ + "GPS Tracking Module", + "Dispatch Dashboard", + "Mobile App Core", + "Reporting & Analytics", + ], + }, + { + "name": "Ecommerce App", + "prefix": "ECA", + "color": "#14B8A6", + "description": "A suite of mobile applications (iOS and Android) for our core ecommerce platform to boost mobile sales and customer engagement.", + "epics": [ + "iOS App Development", + "Android App Development", + "Push Notifications", + "Mobile Checkout", + ], + }, + ] + + # ── Create Projects, Epics, Tickets ───────────────────────────────── + for pd in projects_data: + start_date = date.today() - timedelta(days=random.randint(30, 120)) + end_date = start_date + timedelta(days=random.randint(60, 180)) + + proj, created = Project.objects.get_or_create( + name=pd["name"], + defaults={ + "ticket_prefix": pd["prefix"], + "color": pd["color"], + "start_date": start_date, + "end_date": end_date, + "description": project_rich_description( + pd["name"], pd["description"] + ), + "pinned_date": timezone.now() if random.random() > 0.8 else None, + }, + ) + + if not created: + proj.description = project_rich_description( + pd["name"], pd["description"] + ) + proj.color = pd["color"] + proj.start_date = start_date + proj.end_date = end_date + proj.save() + + project_members = random.sample(users, random.randint(4, 8)) + [admin] + project_members = list(set(project_members)) + for u in project_members: + ProjectMember.objects.get_or_create(project=proj, user=u) + + # ── Statuses ──────────────────────────────────────────────────── + statuses = [] + for i, (name, color, completed) in enumerate( + [ + ("Backlog", "#6B7280", False), + ("Todo", "#3B82F6", False), + ("In Progress", "#F59E0B", False), + ("In Review", "#8B5CF6", False), + ("Done", "#10B981", True), + ] + ): + st, _ = TicketStatus.objects.get_or_create( + project=proj, + name=name, + defaults={ + "color": color, + "sort_order": i, + "is_completed": completed, + }, + ) + statuses.append(st) + + # ── Epics (with rich description) ─────────────────────────────── + epics = [] + for i, epic_name in enumerate(pd["epics"]): + epic_start = proj.start_date + timedelta(days=random.randint(0, 20)) + epic_end = epic_start + timedelta(days=random.randint(20, 60)) + epic, _ = Epic.objects.get_or_create( + project=proj, + name=epic_name, + defaults={ + "description": epic_rich_description(epic_name, proj.name), + "start_date": epic_start, + "end_date": epic_end, + "sort_order": i, + }, + ) + epics.append(epic) + + # ── Tickets (with rich description) ────────────────────────────── + priority_values = list(priorities.values()) + for i in range(random.randint(10, 20)): + epic = random.choice(epics + [None]) + status = random.choice(statuses) + priority = random.choice(priority_values) + + t_start = proj.start_date + timedelta(days=random.randint(0, 30)) + t_due = t_start + timedelta(days=random.randint(5, 45)) + + ticket_name = ( + f"Implement {epic.name if epic else 'Core Feature'} Part {i + 1}" + ) + target_ticket_date = timezone.now() - timedelta( + days=random.randint(1, 365), hours=random.randint(1, 24) + ) + + ticket, t_created = Ticket.objects.get_or_create( + project=proj, + name=ticket_name, + defaults={ + "status": status, + "priority": priority, + "epic": epic, + "description": ticket_rich_description(ticket_name), + "start_date": t_start, + "due_date": t_due, + "created_by": random.choice(project_members), + }, + ) + + if t_created: + Ticket.objects.filter(id=ticket.id).update( + created_at=target_ticket_date + ) + + # Assign random users + assignees = random.sample(project_members, random.randint(1, 3)) + for u in assignees: + ticket.assignees.add(u) + + # ── Ticket History ─────────────────────────────────────── + for _ in range(random.randint(1, 4)): + hist_status = random.choice(statuses) + hist = TicketHistory.objects.create( + ticket=ticket, + user=random.choice(project_members), + status=hist_status, + ) + target_date = timezone.now() - timedelta( + days=random.randint(1, 365), hours=random.randint(1, 24) + ) + TicketHistory.objects.filter(id=hist.id).update( + created_at=target_date + ) + + # ── Ticket Comments (with rich text + replies) ─────────── + for c_idx in range(random.randint(0, 3)): + comment = TicketComment.objects.create( + ticket=ticket, + user=random.choice(project_members), + comment=comment_rich_text(c_idx, ticket.name), + ) + target_date = timezone.now() - timedelta( + days=random.randint(0, 365) + ) + TicketComment.objects.filter(id=comment.id).update( + created_at=target_date + ) + + # Add a reply to some comments + if random.random() > 0.6: + reply = TicketComment.objects.create( + ticket=ticket, + user=random.choice(project_members), + parent=comment, + comment=( + "

    Agreed. I'll take care of this. Updating the status accordingly.

    " + ), + ) + TicketComment.objects.filter(id=reply.id).update( + created_at=target_date + + timedelta(hours=random.randint(1, 12)) + ) + + # ── Notifications for ticket activity ──────────────────── + notif_types = ["status_changed", "comment_added", "ticket_assigned"] + for _ in range(random.randint(0, 2)): + target_user = random.choice(project_members) + Notification.objects.create( + user=target_user, + type=random.choice(notif_types), + title=f"Update on {ticket.name}", + message=f"There is new activity on ticket {ticket.uuid}.", + data={"ticket_id": ticket.id}, + read_at=None if random.random() > 0.4 else timezone.now(), + ) + + # ── Project Notes (with rich content) ─────────────────────────── + note_titles = [ + "Sprint Planning Meeting", + "Architecture Review Session", + "Client Requirements Gathering", + "QA Test Plan Review", + "Sprint Retrospective", + ] + for _ in range(random.randint(2, 4)): + title = random.choice(note_titles) + note_date = proj.start_date + timedelta(days=random.randint(5, 60)) + ProjectNote.objects.create( + project=proj, + created_by=random.choice(project_members), + title=title, + content=note_rich_content(title, proj.name), + note_date=note_date, + ) + + self.stdout.write( + f" ✓ {len(projects_data)} projects seeded with epics, tickets, comments, notes" + ) + + # ── External Access for some projects ─────────────────────────────── + all_projects = list(Project.objects.all()) + for proj in random.sample(all_projects, min(3, len(all_projects))): + ExternalAccess.objects.create(project=proj, is_active=True) + self.stdout.write(" ✓ External access seeded for some projects") + + # ── Summary ───────────────────────────────────────────────────────── + total_tickets = Ticket.objects.count() + total_comments = TicketComment.objects.count() + total_notes = ProjectNote.objects.count() + total_notifs = Notification.objects.count() + self.stdout.write( + self.style.SUCCESS( + f"Demo data seeded! " + f"{len(all_projects)} projects, " + f"{total_tickets} tickets, " + f"{total_comments} comments, " + f"{total_notes} notes, " + f"{total_notifs} notifications" + ) + ) diff --git a/src/accounts/management/commands/seed_data.py b/src/accounts/management/commands/seed_data.py new file mode 100644 index 0000000..0858966 --- /dev/null +++ b/src/accounts/management/commands/seed_data.py @@ -0,0 +1,51 @@ +from django.contrib.auth import get_user_model +from django.core.management.base import BaseCommand + +from src.tickets.models import TicketPriority + +User = get_user_model() + + +class Command(BaseCommand): + help = "Seed initial foundational data: priorities and superuser" + + def handle(self, *args, **options): + self.stdout.write("Starting foundational data seeding...") + self._seed_priorities() + self._seed_superuser() + self.stdout.write(self.style.SUCCESS("Foundational data seeding complete!")) + + def _seed_priorities(self): + defaults = [ + {"name": "Lowest", "color": "#9CA3AF"}, # Gray + {"name": "Low", "color": "#6B7280"}, # Darker Gray + {"name": "Medium", "color": "#F59E0B"}, # Amber + {"name": "High", "color": "#EF4444"}, # Red + {"name": "Critical", "color": "#991B1B"}, # Dark Red + ] + + for item in defaults: + TicketPriority.objects.get_or_create( + name=item["name"], defaults={"color": item["color"]} + ) + + self.stdout.write(f" -> {TicketPriority.objects.count()} priorities seeded") + + def _seed_superuser(self): + if not User.objects.filter(username="admin").exists(): + admin = User.objects.create_superuser( + username="admin", + email="admin@dewakoding.com", + password="admin123", + first_name="Super", + last_name="Admin", + ) + admin.role = "superadmin" + admin.save() + self.stdout.write(" -> superuser created: admin / admin123") + else: + admin = User.objects.get(username="admin") + if admin.role != "superadmin": + admin.role = "superadmin" + admin.save() + self.stdout.write(" -> superuser 'admin' already exists (role verified)") diff --git a/src/accounts/migrations/0001_initial.py b/src/accounts/migrations/0001_initial.py new file mode 100644 index 0000000..4a6ff1c --- /dev/null +++ b/src/accounts/migrations/0001_initial.py @@ -0,0 +1,259 @@ +# Generated by Django 6.0.6 on 2026-06-28 07:26 + +import django.contrib.auth.models +import django.contrib.auth.validators +import django.db.models.deletion +import django.utils.timezone +from django.conf import settings +from django.db import migrations, models + + +class Migration(migrations.Migration): + initial = True + + dependencies = [ + ("auth", "0012_alter_user_first_name_max_length"), + ] + + operations = [ + migrations.CreateModel( + name="SiteBranding", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ( + "favicon", + models.FileField( + blank=True, + help_text="Favicon file (.ico, .png)", + null=True, + upload_to="branding/", + ), + ), + ( + "logo", + models.ImageField( + blank=True, + help_text="Main logo image", + null=True, + upload_to="branding/", + ), + ), + ( + "logo_small", + models.ImageField( + blank=True, + help_text="Small logo for collapsed sidebar", + null=True, + upload_to="branding/", + ), + ), + ( + "brand_name", + models.CharField(default="Project Management", max_length=100), + ), + ( + "copyright_name", + models.CharField(default="Project Management", max_length=200), + ), + ("is_active", models.BooleanField(default=True)), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ], + options={ + "verbose_name": "Site Branding", + "verbose_name_plural": "Site Branding", + "db_table": "site_branding", + }, + ), + migrations.CreateModel( + name="User", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ("password", models.CharField(max_length=128, verbose_name="password")), + ( + "last_login", + models.DateTimeField( + blank=True, null=True, verbose_name="last login" + ), + ), + ( + "is_superuser", + models.BooleanField( + default=False, + help_text="Designates that this user has all permissions without explicitly assigning them.", + verbose_name="superuser status", + ), + ), + ( + "username", + models.CharField( + error_messages={ + "unique": "A user with that username already exists." + }, + help_text="Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.", + max_length=150, + unique=True, + validators=[ + django.contrib.auth.validators.UnicodeUsernameValidator() + ], + verbose_name="username", + ), + ), + ( + "first_name", + models.CharField( + blank=True, max_length=150, verbose_name="first name" + ), + ), + ( + "last_name", + models.CharField( + blank=True, max_length=150, verbose_name="last name" + ), + ), + ( + "email", + models.EmailField( + blank=True, max_length=254, verbose_name="email address" + ), + ), + ( + "is_staff", + models.BooleanField( + default=False, + help_text="Designates whether the user can log into this admin site.", + verbose_name="staff status", + ), + ), + ( + "is_active", + models.BooleanField( + default=True, + help_text="Designates whether this user should be treated as active. Unselect this instead of deleting accounts.", + verbose_name="active", + ), + ), + ( + "date_joined", + models.DateTimeField( + default=django.utils.timezone.now, verbose_name="date joined" + ), + ), + ( + "role", + models.CharField( + choices=[ + ("superadmin", "Superadmin"), + ("manager", "Manager"), + ("member", "Member"), + ("guest", "Guest"), + ], + default="member", + max_length=20, + ), + ), + ( + "google_id", + models.CharField( + blank=True, max_length=255, null=True, unique=True + ), + ), + ( + "profile_image", + models.ImageField(blank=True, null=True, upload_to="profiles/"), + ), + ( + "receive_deadline_emails", + models.BooleanField( + default=True, + help_text="Receive email reminders when ticket deadlines are approaching", + ), + ), + ( + "groups", + models.ManyToManyField( + blank=True, + help_text="The groups this user belongs to. A user will get all permissions granted to each of their groups.", + related_name="user_set", + related_query_name="user", + to="auth.group", + verbose_name="groups", + ), + ), + ( + "user_permissions", + models.ManyToManyField( + blank=True, + help_text="Specific permissions for this user.", + related_name="user_set", + related_query_name="user", + to="auth.permission", + verbose_name="user permissions", + ), + ), + ], + options={ + "verbose_name": "User", + "verbose_name_plural": "Users", + "db_table": "users", + }, + managers=[ + ("objects", django.contrib.auth.models.UserManager()), + ], + ), + migrations.CreateModel( + name="Setting", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ("group", models.CharField(blank=True, max_length=255, null=True)), + ("key", models.CharField(max_length=255)), + ("value", models.TextField(blank=True, null=True)), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ( + "user", + models.ForeignKey( + blank=True, + null=True, + on_delete=django.db.models.deletion.CASCADE, + related_name="settings", + to=settings.AUTH_USER_MODEL, + ), + ), + ], + options={ + "verbose_name": "Setting", + "verbose_name_plural": "Settings", + "db_table": "settings", + "constraints": [ + models.UniqueConstraint( + fields=("user", "key"), name="unique_user_setting" + ) + ], + }, + ), + ] diff --git a/src/accounts/models.py b/src/accounts/models.py index d7b9f75..d502b2b 100644 --- a/src/accounts/models.py +++ b/src/accounts/models.py @@ -1,5 +1,79 @@ -"""generated with djinit""" - +from django.contrib.auth.models import AbstractUser from django.db import models -# Create your models here. \ No newline at end of file + +class User(AbstractUser): + ROLE_CHOICES = ( + ("superadmin", "Superadmin"), + ("manager", "Manager"), + ("member", "Member"), + ("guest", "Guest"), + ) + role = models.CharField(max_length=20, choices=ROLE_CHOICES, default="member") + google_id = models.CharField(max_length=255, blank=True, null=True, unique=True) + profile_image = models.ImageField(upload_to="profiles/", blank=True, null=True) + receive_deadline_emails = models.BooleanField( + default=True, + help_text="Receive email reminders when ticket deadlines are approaching", + ) + + class Meta: + db_table = "users" + verbose_name = "User" + verbose_name_plural = "Users" + + def __str__(self): + return self.email or self.username + + +class Setting(models.Model): + user = models.ForeignKey( + User, on_delete=models.CASCADE, blank=True, null=True, related_name="settings" + ) + group = models.CharField(max_length=255, blank=True, null=True) + key = models.CharField(max_length=255) + value = models.TextField(blank=True, null=True) + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "settings" + verbose_name = "Setting" + verbose_name_plural = "Settings" + constraints = [ + models.UniqueConstraint(fields=["user", "key"], name="unique_user_setting") + ] + + def __str__(self): + return f"{self.key}={self.value}" + + +class SiteBranding(models.Model): + favicon = models.FileField( + upload_to="branding/", + blank=True, + null=True, + help_text="Favicon file (.ico, .png)", + ) + logo = models.ImageField( + upload_to="branding/", blank=True, null=True, help_text="Main logo image" + ) + logo_small = models.ImageField( + upload_to="branding/", + blank=True, + null=True, + help_text="Small logo for collapsed sidebar", + ) + brand_name = models.CharField(max_length=100, default="Project Management") + copyright_name = models.CharField(max_length=200, default="Project Management") + is_active = models.BooleanField(default=True) + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "site_branding" + verbose_name = "Site Branding" + verbose_name_plural = "Site Branding" + + def __str__(self): + return self.brand_name diff --git a/src/accounts/serializers.py b/src/accounts/serializers.py index fbcbed8..7a382b9 100644 --- a/src/accounts/serializers.py +++ b/src/accounts/serializers.py @@ -1,5 +1,48 @@ -"""generated with djinit""" - +from django.contrib.auth import get_user_model from rest_framework import serializers -# Create your serializers here. \ No newline at end of file +from src.accounts.models import Setting + +User = get_user_model() + + +class UserSerializer(serializers.ModelSerializer): + name = serializers.SerializerMethodField() + + class Meta: + model = User + fields = ( + "id", + "email", + "name", + "username", + "first_name", + "last_name", + "is_active", + "is_staff", + "date_joined", + "last_login", + ) + read_only_fields = ("id", "is_staff", "is_active", "date_joined", "last_login") + + def get_name(self, obj): + return obj.get_full_name() or obj.username + + +class RegisterSerializer(serializers.ModelSerializer): + password = serializers.CharField(write_only=True, min_length=8) + + class Meta: + model = User + fields = ("email", "username", "password", "first_name", "last_name") + + def create(self, validated_data): + user = User.objects.create_user(**validated_data) + return user + + +class SettingSerializer(serializers.ModelSerializer): + class Meta: + model = Setting + fields = ("id", "user", "group", "key", "value", "created_at", "updated_at") + read_only_fields = ("id", "user", "created_at", "updated_at") diff --git a/src/accounts/tests.py b/src/accounts/tests.py index a8b0ed1..337a402 100644 --- a/src/accounts/tests.py +++ b/src/accounts/tests.py @@ -1,5 +1,4 @@ """generated with djinit""" -from django.test import TestCase -# Create your tests here. \ No newline at end of file +# Create your tests here. diff --git a/src/accounts/urls.py b/src/accounts/urls.py index 8020533..8075f8e 100644 --- a/src/accounts/urls.py +++ b/src/accounts/urls.py @@ -1,7 +1,16 @@ -"""generated with djinit""" - from django.urls import path +from rest_framework_simplejwt.views import TokenObtainPairView, TokenRefreshView + +from src.accounts import views urlpatterns = [ - # Add your URL patterns here -] \ No newline at end of file + path("me/", views.MeView.as_view(), name="auth-me"), + path("register/", views.RegisterView.as_view(), name="auth-register"), + path("login/", TokenObtainPairView.as_view(), name="auth-login"), + path("refresh/", TokenRefreshView.as_view(), name="auth-refresh"), + path("google/", views.GoogleAuthUrlView.as_view(), name="auth-google"), + path( + "google/callback/", views.GoogleLoginView.as_view(), name="auth-google-callback" + ), + path("settings/", views.user_settings_view, name="auth-settings"), +] diff --git a/src/accounts/views.py b/src/accounts/views.py index 6630beb..5a94113 100644 --- a/src/accounts/views.py +++ b/src/accounts/views.py @@ -1,5 +1,143 @@ -"""generated with djinit""" +import requests +from django.conf import settings +from django.contrib.auth import get_user_model +from rest_framework import generics, permissions, status +from rest_framework.decorators import api_view, permission_classes +from rest_framework.response import Response +from rest_framework.views import APIView +from rest_framework_simplejwt.tokens import RefreshToken -from rest_framework import viewsets +from src.accounts.models import Setting +from src.accounts.serializers import ( + RegisterSerializer, + SettingSerializer, + UserSerializer, +) -# Create your views here. \ No newline at end of file +User = get_user_model() + + +class MeView(generics.RetrieveUpdateAPIView): + serializer_class = UserSerializer + permission_classes = (permissions.IsAuthenticated,) + + def get_object(self): + return self.request.user + + +class RegisterView(generics.CreateAPIView): + queryset = User.objects.all() + serializer_class = RegisterSerializer + permission_classes = (permissions.AllowAny,) + + +class GoogleLoginView(APIView): + permission_classes = (permissions.AllowAny,) + + def post(self, request): + code = request.data.get("code") + if not code: + return Response( + {"error": "Authorization code is required"}, + status=status.HTTP_400_BAD_REQUEST, + ) + + token_url = "https://oauth2.googleapis.com/token" + data = { + "code": code, + "client_id": settings.GOOGLE_CLIENT_ID, + "client_secret": settings.GOOGLE_CLIENT_SECRET, + "redirect_uri": settings.GOOGLE_REDIRECT_URI, + "grant_type": "authorization_code", + } + + token_resp = requests.post(token_url, data=data, timeout=10) + if token_resp.status_code != 200: + return Response( + {"error": "Failed to exchange authorization code"}, + status=status.HTTP_400_BAD_REQUEST, + ) + + tokens = token_resp.json() + access_token = tokens.get("access_token") + + userinfo_resp = requests.get( + "https://www.googleapis.com/oauth2/v2/userinfo", + headers={"Authorization": f"Bearer {access_token}"}, + timeout=10, + ) + if userinfo_resp.status_code != 200: + return Response( + {"error": "Failed to get user info"}, + status=status.HTTP_400_BAD_REQUEST, + ) + + google_user = userinfo_resp.json() + google_id = google_user["id"] + email = google_user.get("email") + first_name = google_user.get("given_name", "") + last_name = google_user.get("family_name", "") + + try: + user = User.objects.get(google_id=google_id) + except User.DoesNotExist: + user = User.objects.filter(email=email).first() + if user: + user.google_id = google_id + user.save() + else: + user = User.objects.create_user( + username=email.split("@")[0] if email else google_id, + email=email, + google_id=google_id, + first_name=first_name, + last_name=last_name, + ) + + refresh = RefreshToken.for_user(user) + return Response( + { + "refresh": str(refresh), + "access": str(refresh.access_token), + "user": UserSerializer(user).data, + } + ) + + +class GoogleAuthUrlView(APIView): + permission_classes = (permissions.AllowAny,) + + def get(self, request): + client_id = settings.GOOGLE_CLIENT_ID + redirect_uri = settings.GOOGLE_REDIRECT_URI + url = ( + f"https://accounts.google.com/o/oauth2/v2/auth" + f"?client_id={client_id}" + f"&redirect_uri={redirect_uri}" + f"&response_type=code" + f"&scope=email%20profile" + ) + return Response({"url": url}) + + +@api_view(["GET", "PUT"]) +@permission_classes([permissions.IsAuthenticated]) +def user_settings_view(request): + if request.method == "PUT": + data = request.data + Setting.objects.update_or_create( + user=request.user, + key=data.get("key"), + defaults={ + "group": data.get("group", ""), + "value": data.get("value", ""), + }, + ) + return Response({"status": "ok"}) + + group = request.query_params.get("group") + qs = Setting.objects.filter(user=request.user) + if group: + qs = qs.filter(group=group) + serializer = SettingSerializer(qs, many=True) + return Response(serializer.data) diff --git a/src/dashboard/board_views/__init__.py b/src/dashboard/board_views/__init__.py new file mode 100644 index 0000000..fdc5c88 --- /dev/null +++ b/src/dashboard/board_views/__init__.py @@ -0,0 +1,3 @@ +from .actions import * +from .board import * +from .export import * diff --git a/src/dashboard/board_views/actions.py b/src/dashboard/board_views/actions.py new file mode 100644 index 0000000..5540369 --- /dev/null +++ b/src/dashboard/board_views/actions.py @@ -0,0 +1,138 @@ +import json + +from django.contrib import messages +from django.contrib.auth import get_user_model +from django.http import JsonResponse +from django.shortcuts import get_object_or_404, redirect +from django.views.decorators.http import require_http_methods + +from src.notifications.email_utils import send_notification_email +from src.notifications.models import Notification +from src.projects.models import Project +from src.tickets.models import ( + Ticket, + TicketHistory, + TicketStatus, + TicketUser, +) + +User = get_user_model() + +DEFAULT_STATUS_NAMES = ["Backlog", "Todo", "In Progress", "In Review", "Done"] +DEFAULT_STATUS_COLORS = ["#6B7280", "#3B82F6", "#F59E0B", "#8B5CF6", "#10B981"] + + +@require_http_methods(["POST"]) +def board_create_ticket(request, project_id): + project = get_object_or_404(Project, pk=project_id) + name = request.POST.get("name", "").strip() + description = request.POST.get("description", "").strip() + status_id = request.POST.get("status") + priority_id = request.POST.get("priority") or None + epic_id = request.POST.get("epic") or None + assignee_ids = [int(x) for x in request.POST.getlist("assignees") if x] + start_date = request.POST.get("start_date") or None + due_date = request.POST.get("due_date") or None + + if not name or not status_id: + messages.error(request, "Name and status are required.") + return redirect("project-board-project", project_id=project_id) + + status = get_object_or_404(TicketStatus, pk=status_id) + + ticket = Ticket.objects.create( + project=project, + status=status, + name=name, + description=description or None, + priority_id=priority_id, + epic_id=epic_id, + start_date=start_date, + due_date=due_date, + created_by=request.user, + ) + + for uid in assignee_ids: + TicketUser.objects.get_or_create(ticket=ticket, user_id=uid) + + TicketHistory.objects.create( + ticket=ticket, + user=request.user, + status=status, + ) + + notify_users = list(ticket.assignees.all()) + if ticket.created_by and ticket.created_by not in notify_users: + notify_users.append(ticket.created_by) + for u in notify_users: + notification = Notification.objects.create( + user=u, + type="ticket_created", + title=f"New Ticket: {ticket.uuid}", + message=f"Ticket '{ticket.name}' created on board by {request.user.get_full_name() or request.user.username}", + data={"ticket_id": ticket.id, "ticket_uuid": ticket.uuid}, + ) + # Send email notification + send_notification_email( + user=u, + notification_type="ticket_created", + title=notification.title, + message=notification.message, + data={ + "ticket_id": ticket.id, + "ticket_uuid": ticket.uuid, + "project_name": ticket.project.name, + "user_name": request.user.get_full_name() or request.user.username, + }, + ) + + messages.success(request, f"Ticket '{ticket.name}' created successfully.") + return redirect("project-board-project", project_id=project_id) + + +@require_http_methods(["POST"]) +def move_ticket(request, project_id, ticket_id): + ticket = get_object_or_404(Ticket, pk=ticket_id, project_id=project_id) + data = json.loads(request.body) + status_id = data.get("status_id") + if not status_id: + return JsonResponse( + {"success": False, "error": "status_id required"}, status=400 + ) + + status = get_object_or_404(TicketStatus, pk=status_id, project_id=project_id) + ticket.status = status + ticket.save(update_fields=["status", "updated_at"]) + + TicketHistory.objects.create( + ticket=ticket, + user=request.user, + status=status, + ) + + notify_users = list(ticket.assignees.all()) + if ticket.created_by and ticket.created_by not in notify_users: + notify_users.append(ticket.created_by) + for u in notify_users: + notification = Notification.objects.create( + user=u, + type="status_changed", + title=f"Ticket {ticket.uuid} moved", + message=f"Ticket moved to {status.name} by {request.user.get_full_name() or request.user.username}", + data={"ticket_id": ticket.id, "ticket_uuid": ticket.uuid}, + ) + # Send email notification + send_notification_email( + user=u, + notification_type="status_changed", + title=notification.title, + message=notification.message, + data={ + "ticket_id": ticket.id, + "ticket_uuid": ticket.uuid, + "project_name": ticket.project.name, + "user_name": request.user.get_full_name() or request.user.username, + }, + ) + + return JsonResponse({"success": True}) diff --git a/src/dashboard/board_views/board.py b/src/dashboard/board_views/board.py new file mode 100644 index 0000000..908a835 --- /dev/null +++ b/src/dashboard/board_views/board.py @@ -0,0 +1,250 @@ +import json +from datetime import date + +from django.contrib.auth import get_user_model +from django.db.models import Count, Q +from django.shortcuts import get_object_or_404, render +from django.views.decorators.http import require_http_methods + +from src.epics.models import Epic +from src.projects.models import Project +from src.tickets.models import ( + Ticket, + TicketPriority, + TicketStatus, +) + +User = get_user_model() + +DEFAULT_STATUS_NAMES = ["Backlog", "Todo", "In Progress", "In Review", "Done"] +DEFAULT_STATUS_COLORS = ["#6B7280", "#3B82F6", "#F59E0B", "#8B5CF6", "#10B981"] + + +def _ensure_default_statuses(project): + # Auto-migrate legacy 'Review' to 'In Review' if it exists + review_status = TicketStatus.objects.filter(project=project, name="Review").first() + if review_status: + in_review_status, created = TicketStatus.objects.get_or_create( + project=project, + name="In Review", + defaults={"color": "#8B5CF6", "sort_order": 3}, + ) + Ticket.objects.filter(status=review_status).update(status=in_review_status) + review_status.delete() + + for i, name in enumerate(DEFAULT_STATUS_NAMES): + TicketStatus.objects.get_or_create( + project=project, + name=name, + defaults={"color": DEFAULT_STATUS_COLORS[i], "sort_order": i}, + ) + + +def project_board(request, project_id=None): + projects = Project.objects.all() + if request.user.role == "member": + projects = projects.filter(members=request.user) + projects = projects.annotate( + member_count=Count("members", distinct=True), + ticket_count=Count("tickets", distinct=True), + ).order_by("-pinned_date", "name") + + search = request.GET.get("search", "").strip() + if search: + projects = projects.filter( + Q(name__icontains=search) | Q(ticket_prefix__icontains=search) + ) + + selected_project = None + project_members = [] + columns = [] + sort = request.GET.get("sort", "created_at_desc") + selected_user_ids = [] + + if project_id: + selected_project = get_object_or_404( + Project.objects.prefetch_related( + "ticket_statuses", "project_members__user" + ), + pk=project_id, + ) + _ensure_default_statuses(selected_project) + project_members = selected_project.project_members.select_related("user").all() + statuses = TicketStatus.objects.filter(project=selected_project).order_by( + "sort_order" + ) + + tickets_qs = ( + Ticket.objects.filter(project=selected_project) + .select_related("status", "priority", "epic", "created_by") + .prefetch_related("assignees") + ) + + user_ids_param = request.GET.get("user_ids", "").strip() + if user_ids_param: + try: + selected_user_ids = [ + int(x) for x in user_ids_param.split(",") if x.strip() + ] + except (ValueError, TypeError): + selected_user_ids = [] + if selected_user_ids: + tickets_qs = tickets_qs.filter( + assignees__id__in=selected_user_ids + ).distinct() + + if sort == "created_at_asc": + tickets_qs = tickets_qs.order_by("created_at") + elif sort == "name_asc": + tickets_qs = tickets_qs.order_by("name") + elif sort == "name_desc": + tickets_qs = tickets_qs.order_by("-name") + elif sort == "due_date_asc": + tickets_qs = tickets_qs.order_by("due_date") + elif sort == "due_date_desc": + tickets_qs = tickets_qs.order_by("-due_date") + elif sort == "priority": + tickets_qs = tickets_qs.order_by("priority__name") + elif sort == "priority_desc": + tickets_qs = tickets_qs.order_by("-priority__name") + else: + tickets_qs = tickets_qs.order_by("-created_at") + + for status in statuses: + col_tickets = [t for t in tickets_qs if t.status_id == status.id] + columns.append( + { + "status": status, + "tickets": col_tickets, + "count": len(col_tickets), + } + ) + + can_move = request.user.role in ["superadmin", "manager"] or ( + selected_project + and selected_project.members.filter(id=request.user.id).exists() + ) + + priorities = TicketPriority.objects.all() + epics = Epic.objects.filter(project=selected_project) if selected_project else [] + + project_users = [] + if selected_project: + assigned_user_ids = ( + Ticket.objects.filter(project=selected_project) + .values_list("assignees__id", flat=True) + .distinct() + ) + users_qs = User.objects.filter(id__in=set(assigned_user_ids)) + project_users = [ + { + "id": u.id, + "username": u.username, + "full_name": u.get_full_name() or u.username, + } + for u in users_qs + ] + + first_status_id = None + first_status_name = None + statuses_json = "[]" + if selected_project: + first_status = ( + TicketStatus.objects.filter(project=selected_project) + .order_by("sort_order") + .first() + ) + if first_status: + first_status_id = first_status.id + first_status_name = first_status.name + statuses_json = json.dumps( + [ + {"id": s.id, "name": s.name, "color": s.color} + for s in TicketStatus.objects.filter(project=selected_project).order_by( + "sort_order" + ) + ] + ) + + return render( + request, + "projects/board.html", + { + "projects": projects, + "selected_project_id": project_id, + "selected_project": selected_project, + "project_members": project_members, + "columns": columns, + "priorities": priorities, + "epics": epics, + "sort": sort, + "search": search, + "can_move": can_move, + "today": date.today(), + "project_users": project_users, + "project_users_json": json.dumps(project_users), + "selected_user_ids": selected_user_ids, + "priorities_json": json.dumps( + [{"id": p.id, "name": p.name, "color": p.color} for p in priorities] + ), + "epics_json": json.dumps([{"id": e.id, "name": e.name} for e in epics]) + if selected_project + else "[]", + "statuses_json": statuses_json, + "first_status_id": first_status_id, + "first_status_name": first_status_name, + }, + ) + + +@require_http_methods(["GET"]) +def board_data(request, project_id): + project = get_object_or_404(Project, pk=project_id) + _ensure_default_statuses(project) + statuses = TicketStatus.objects.filter(project=project).order_by("sort_order") + tickets = ( + Ticket.objects.filter(project=project) + .select_related("status", "priority", "epic", "created_by") + .prefetch_related("assignees") + ) + + sort = request.GET.get("sort", "created_at_desc") + if sort == "created_at_asc": + tickets = tickets.order_by("created_at") + elif sort == "name_asc": + tickets = tickets.order_by("name") + elif sort == "name_desc": + tickets = tickets.order_by("-name") + elif sort == "due_date_asc": + tickets = tickets.order_by("due_date") + elif sort == "priority": + tickets = tickets.order_by("priority__name") + else: + tickets = tickets.order_by("-created_at") + + columns = [] + for status in statuses: + col_tickets = [t for t in tickets if t.status_id == status.id] + columns.append( + { + "status": status, + "tickets": col_tickets, + "count": len(col_tickets), + } + ) + + priorities = TicketPriority.objects.all() + epics = Epic.objects.filter(project=project) + + return render( + request, + "projects/partials/board_columns.html", + { + "project": project, + "columns": columns, + "priorities": priorities, + "epics": epics, + "sort": sort, + "today": date.today(), + }, + ) diff --git a/src/dashboard/board_views/export.py b/src/dashboard/board_views/export.py new file mode 100644 index 0000000..337d4af --- /dev/null +++ b/src/dashboard/board_views/export.py @@ -0,0 +1,105 @@ +import json +from datetime import date + +import openpyxl +from django.contrib.auth import get_user_model +from django.http import HttpResponse +from django.shortcuts import get_object_or_404 +from django.views.decorators.http import require_http_methods + +from src.projects.models import Project +from src.tickets.models import ( + Ticket, +) + +User = get_user_model() + +DEFAULT_STATUS_NAMES = ["Backlog", "Todo", "In Progress", "In Review", "Done"] +DEFAULT_STATUS_COLORS = ["#6B7280", "#3B82F6", "#F59E0B", "#8B5CF6", "#10B981"] + + +@require_http_methods(["POST"]) +def export_board_tickets(request, project_id): + project = get_object_or_404(Project, pk=project_id) + data = json.loads(request.body) + selected_columns = data.get( + "columns", ["uuid", "name", "status", "assignee", "due_date", "created_at"] + ) + + tickets = ( + Ticket.objects.filter(project=project) + .select_related("status", "priority", "epic", "created_by") + .prefetch_related("assignees") + .order_by("-created_at") + ) + + available_columns = { + "uuid": "Ticket ID", + "name": "Title", + "description": "Description", + "status": "Status", + "assignee": "Assignee", + "project": "Project", + "epic": "Epic", + "start_date": "Start Date", + "due_date": "Due Date", + "created_at": "Created At", + "updated_at": "Updated At", + } + + wb = openpyxl.Workbook() + ws = wb.active + ws.title = "Tickets" + + headers = [available_columns[c] for c in selected_columns if c in available_columns] + ws.append(headers) + + for t in tickets: + row = [] + for col in selected_columns: + if col == "uuid": + row.append(t.uuid) + elif col == "name": + row.append(t.name) + elif col == "description": + row.append(t.description or "") + elif col == "status": + row.append(t.status.name if t.status else "") + elif col == "assignee": + row.append( + ", ".join( + a.get_full_name() or a.username for a in t.assignees.all() + ) + ) + elif col == "project": + row.append(t.project.name) + elif col == "epic": + row.append(t.epic.name if t.epic else "") + elif col == "start_date": + row.append(str(t.start_date) if t.start_date else "") + elif col == "due_date": + row.append(str(t.due_date) if t.due_date else "") + elif col == "created_at": + row.append( + t.created_at.replace(tzinfo=None).isoformat() + if t.created_at + else "" + ) + elif col == "updated_at": + row.append( + t.updated_at.replace(tzinfo=None).isoformat() + if t.updated_at + else "" + ) + else: + row.append("") + ws.append(row) + + response = HttpResponse( + content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" + ) + response["Content-Disposition"] = ( + f'attachment; filename="board-export-{project.ticket_prefix}-{date.today().isoformat()}.xlsx"' + ) + wb.save(response) + return response diff --git a/src/dashboard/context_processors.py b/src/dashboard/context_processors.py new file mode 100644 index 0000000..2f51c0d --- /dev/null +++ b/src/dashboard/context_processors.py @@ -0,0 +1,37 @@ +from django.contrib.auth import get_user_model + +from src.accounts.models import Setting, SiteBranding +from src.tickets.models import Ticket + + +def site_stats(request): + User = get_user_model() + + total_users = User.objects.filter(is_active=True).count() + if request.user.is_authenticated and request.user.role == "member": + total_tickets = Ticket.objects.filter(assignees=request.user).count() + else: + total_tickets = Ticket.objects.count() + + ctx = { + "total_users": total_users, + "total_tickets": total_tickets, + } + user_ui_settings = {} + if request.user.is_authenticated: + for s in Setting.objects.filter(user=request.user, group="ui"): + user_ui_settings[s.key] = s.value + ctx["user_ui_settings"] = user_ui_settings + ctx["navigation_style"] = user_ui_settings.get("navigation_style", "sidebar") + ctx["color_theme"] = user_ui_settings.get("color_theme", "blue") + + branding = SiteBranding.objects.filter(is_active=True).first() + if branding: + ctx["branding"] = branding + ctx["brand_name"] = branding.brand_name + ctx["copyright_name"] = branding.copyright_name + else: + ctx["branding"] = None + ctx["brand_name"] = "Project Management" + ctx["copyright_name"] = "Project Management" + return ctx diff --git a/src/dashboard/list_views/__init__.py b/src/dashboard/list_views/__init__.py new file mode 100644 index 0000000..a96b291 --- /dev/null +++ b/src/dashboard/list_views/__init__.py @@ -0,0 +1,4 @@ +from .bulk_delete import * +from .notification_list import * +from .project_list import * +from .ticket_list import * diff --git a/src/dashboard/list_views/bulk_delete.py b/src/dashboard/list_views/bulk_delete.py new file mode 100644 index 0000000..8488de5 --- /dev/null +++ b/src/dashboard/list_views/bulk_delete.py @@ -0,0 +1,131 @@ +from django.contrib import messages +from django.contrib.auth import get_user_model +from django.shortcuts import redirect +from django.views.decorators.http import require_POST + +from src.epics.models import Epic +from src.notes.models import ProjectNote +from src.projects.models import Project +from src.tickets.models import Ticket + +User = get_user_model() + +ALL_COLUMNS = [ + "color", + "name", + "ticket_prefix", + "progress", + "start_date", + "end_date", + "remaining_days", + "pinned", + "members", + "tickets", + "created_at", + "updated_at", +] +DEFAULT_COLUMNS = [ + "color", + "name", + "ticket_prefix", + "progress", + "start_date", + "end_date", + "remaining_days", + "pinned", + "members", + "tickets", +] + +ALL_TICKET_COLUMNS = [ + "uuid", + "project", + "name", + "status", + "priority", + "assignees", + "creator", + "start_date", + "due_date", + "epic", + "created_at", +] +DEFAULT_TICKET_COLUMNS = [ + "uuid", + "project", + "name", + "status", + "priority", + "assignees", + "start_date", + "due_date", + "epic", +] + + +@require_POST +def tickets_bulk_delete(request): + ids = request.POST.getlist("ids") + if not ids: + messages.warning(request, "No tickets selected.") + else: + count = Ticket.objects.filter(id__in=ids).count() + Ticket.objects.filter(id__in=ids).delete() + messages.success(request, f"Deleted {count} ticket(s).") + referer = request.META.get("HTTP_REFERER", "") + return redirect(referer or "tickets-list") + + +@require_POST +def projects_bulk_delete(request): + ids = request.POST.getlist("ids") + if not ids: + messages.warning(request, "No projects selected.") + else: + count = Project.objects.filter(id__in=ids).count() + Project.objects.filter(id__in=ids).delete() + messages.success(request, f"Deleted {count} project(s).") + referer = request.META.get("HTTP_REFERER", "") + return redirect(referer or "projects-list") + + +@require_POST +def users_bulk_delete(request): + ids = request.POST.getlist("ids") + if not ids: + messages.warning(request, "No users selected.") + return redirect("users-list") + if str(request.user.id) in ids: + messages.error(request, "You cannot delete yourself.") + return redirect("users-list") + count = User.objects.filter(id__in=ids).count() + User.objects.filter(id__in=ids).delete() + messages.success(request, f"Deleted {count} user(s).") + referer = request.META.get("HTTP_REFERER", "") + return redirect(referer or "users-list") + + +@require_POST +def epics_bulk_delete(request): + ids = request.POST.getlist("ids") + if not ids: + messages.warning(request, "No epics selected.") + else: + count = Epic.objects.filter(id__in=ids).count() + Epic.objects.filter(id__in=ids).delete() + messages.success(request, f"Deleted {count} epic(s).") + referer = request.META.get("HTTP_REFERER", "") + return redirect(referer or "epics-overview") + + +@require_POST +def notes_bulk_delete(request): + ids = request.POST.getlist("ids") + if not ids: + messages.warning(request, "No notes selected.") + else: + count = ProjectNote.objects.filter(id__in=ids).count() + ProjectNote.objects.filter(id__in=ids).delete() + messages.success(request, f"Deleted {count} note(s).") + referer = request.META.get("HTTP_REFERER", "") + return redirect(referer or "projects-list") diff --git a/src/dashboard/list_views/notification_list.py b/src/dashboard/list_views/notification_list.py new file mode 100644 index 0000000..fb069b6 --- /dev/null +++ b/src/dashboard/list_views/notification_list.py @@ -0,0 +1,71 @@ +from django.contrib.auth import get_user_model +from django.shortcuts import render +from django.views.decorators.http import require_http_methods + +from src.notifications.models import Notification + +User = get_user_model() + +ALL_COLUMNS = [ + "color", + "name", + "ticket_prefix", + "progress", + "start_date", + "end_date", + "remaining_days", + "pinned", + "members", + "tickets", + "created_at", + "updated_at", +] +DEFAULT_COLUMNS = [ + "color", + "name", + "ticket_prefix", + "progress", + "start_date", + "end_date", + "remaining_days", + "pinned", + "members", + "tickets", +] + +ALL_TICKET_COLUMNS = [ + "uuid", + "project", + "name", + "status", + "priority", + "assignees", + "creator", + "start_date", + "due_date", + "epic", + "created_at", +] +DEFAULT_TICKET_COLUMNS = [ + "uuid", + "project", + "name", + "status", + "priority", + "assignees", + "start_date", + "due_date", + "epic", +] + + +@require_http_methods(["GET"]) +def notifications_unread_count(request): + count = Notification.objects.filter(user=request.user, read_at__isnull=True).count() + return render( + request, + "dashboard/partials/notif_badge.html", + { + "count": count, + }, + ) diff --git a/src/dashboard/list_views/project_list.py b/src/dashboard/list_views/project_list.py new file mode 100644 index 0000000..f171685 --- /dev/null +++ b/src/dashboard/list_views/project_list.py @@ -0,0 +1,159 @@ +from django.contrib.auth import get_user_model +from django.core.paginator import Paginator +from django.db.models import Count, Q +from django.shortcuts import render +from django.utils import timezone + +from src.projects.models import Project +from src.tickets.models import Ticket + +User = get_user_model() + +ALL_COLUMNS = [ + "color", + "name", + "ticket_prefix", + "progress", + "start_date", + "end_date", + "remaining_days", + "pinned", + "members", + "tickets", + "created_at", + "updated_at", +] +DEFAULT_COLUMNS = [ + "color", + "name", + "ticket_prefix", + "progress", + "start_date", + "end_date", + "remaining_days", + "pinned", + "members", + "tickets", +] + +ALL_TICKET_COLUMNS = [ + "uuid", + "project", + "name", + "status", + "priority", + "assignees", + "creator", + "start_date", + "due_date", + "epic", + "created_at", +] +DEFAULT_TICKET_COLUMNS = [ + "uuid", + "project", + "name", + "status", + "priority", + "assignees", + "start_date", + "due_date", + "epic", +] + + +def projects_list(request): + search = request.GET.get("search", "").strip() + sort = request.GET.get("sort", "name") + order = request.GET.get("order", "asc") + per_page = int(request.GET.get("per_page", 10)) + cols_param = request.GET.getlist("columns") + today = timezone.now().date() + + columns = ( + [c for c in cols_param if c in ALL_COLUMNS] + if cols_param + else DEFAULT_COLUMNS[:] + ) + + projects = Project.objects.annotate() + if request.user.role == "member": + projects = projects.filter(members=request.user) + projects = projects.annotate( + member_count=Count("members", distinct=True), + ticket_count=Count("tickets", distinct=True), + ) + + if search: + projects = projects.filter( + Q(name__icontains=search) | Q(ticket_prefix__icontains=search) + ) + + sort_field = sort + if sort_field == "members": + sort_field = "member_count" + elif sort_field == "tickets": + sort_field = "ticket_count" + if order == "desc": + sort_field = f"-{sort_field}" + if sort_field.lstrip("-") in ( + "name", + "member_count", + "ticket_count", + "start_date", + "end_date", + "created_at", + "updated_at", + "ticket_prefix", + ): + projects = projects.order_by(sort_field) + else: + projects = projects.order_by("name") + + paginator = Paginator(projects, per_page) + page_number = request.GET.get("page", 1) + page_obj = paginator.get_page(page_number) + + # Compute progress and remaining_days per project (after pagination, using bulk queries) + project_ids = [p.id for p in page_obj] + if project_ids: + completion_stats = ( + Ticket.objects.filter(project_id__in=project_ids) + .values("project_id") + .annotate( + total=Count("id"), + completed=Count("id", filter=Q(status__is_completed=True)), + ) + ) + stats_map = {s["project_id"]: s for s in completion_stats} + else: + stats_map = {} + for p in page_obj: + stats = stats_map.get(p.id) + if stats and stats["total"] > 0: + p.progress_percentage = round( + (stats["completed"] / stats["total"]) * 100, 1 + ) + else: + p.progress_percentage = 0.0 + if p.end_date: + diff = (p.end_date - today).days + p.remaining_days = max(diff, 0) + else: + p.remaining_days = None + + return render( + request, + "projects/list.html", + { + "page_obj": page_obj, + "projects": page_obj.object_list, + "search": search, + "sort": sort, + "order": order, + "per_page": per_page, + "columns": columns, + "all_columns": ALL_COLUMNS, + "today": today, + }, + ) diff --git a/src/dashboard/list_views/ticket_list.py b/src/dashboard/list_views/ticket_list.py new file mode 100644 index 0000000..f56ae69 --- /dev/null +++ b/src/dashboard/list_views/ticket_list.py @@ -0,0 +1,192 @@ +from django.contrib.auth import get_user_model +from django.core.paginator import Paginator +from django.db.models import Q +from django.shortcuts import render +from django.utils import timezone + +from src.epics.models import Epic +from src.projects.models import Project +from src.tickets.models import Ticket, TicketPriority, TicketStatus + +User = get_user_model() + +ALL_COLUMNS = [ + "color", + "name", + "ticket_prefix", + "progress", + "start_date", + "end_date", + "remaining_days", + "pinned", + "members", + "tickets", + "created_at", + "updated_at", +] +DEFAULT_COLUMNS = [ + "color", + "name", + "ticket_prefix", + "progress", + "start_date", + "end_date", + "remaining_days", + "pinned", + "members", + "tickets", +] + +ALL_TICKET_COLUMNS = [ + "uuid", + "project", + "name", + "status", + "priority", + "assignees", + "creator", + "start_date", + "due_date", + "epic", + "created_at", +] +DEFAULT_TICKET_COLUMNS = [ + "uuid", + "project", + "name", + "status", + "priority", + "assignees", + "start_date", + "due_date", + "epic", +] + + +def tickets_list(request): + search = request.GET.get("search", "").strip() + sort = request.GET.get("sort", "created_at") + order = request.GET.get("order", "desc") + per_page = int(request.GET.get("per_page", 10)) + cols_param = request.GET.getlist("columns") + today = timezone.now().date() + + columns = ( + [c for c in cols_param if c in ALL_TICKET_COLUMNS] + if cols_param + else DEFAULT_TICKET_COLUMNS[:] + ) + + tickets = Ticket.objects.select_related( + "status", "priority", "project", "created_by", "epic" + ).prefetch_related("assignees") + + if request.user.role == "member": + tickets = tickets.filter(assignees=request.user) + + # Search across name, uuid, project name, assignee name, creator name, epic name + if search: + tickets = tickets.filter( + Q(name__icontains=search) + | Q(uuid__icontains=search) + | Q(project__name__icontains=search) + | Q(assignees__username__icontains=search) + | Q(assignees__first_name__icontains=search) + | Q(assignees__last_name__icontains=search) + | Q(created_by__username__icontains=search) + | Q(created_by__first_name__icontains=search) + | Q(created_by__last_name__icontains=search) + | Q(epic__name__icontains=search) + ).distinct() + + # Filters + project_id = request.GET.get("project") + status_id = request.GET.get("status") + epic_id = request.GET.get("epic") + priority_id = request.GET.get("priority") + assignee_ids = request.GET.getlist("assignee") + created_by = request.GET.get("created_by") + due_from = request.GET.get("due_from") + due_to = request.GET.get("due_to") + + if project_id: + tickets = tickets.filter(project_id=project_id) + if status_id: + tickets = tickets.filter(status_id=status_id) + if epic_id: + tickets = tickets.filter(epic_id=epic_id) + if priority_id: + tickets = tickets.filter(priority_id=priority_id) + if assignee_ids: + tickets = tickets.filter(assignees__id__in=assignee_ids) + if created_by: + tickets = tickets.filter(created_by_id=created_by) + if due_from: + tickets = tickets.filter(due_date__gte=due_from) + if due_to: + tickets = tickets.filter(due_date__lte=due_to) + + # Sorting + allowed_sorts = { + "uuid": "uuid", + "project": "project__name", + "name": "name", + "status": "status__name", + "priority": "priority__name", + "creator": "created_by__first_name", + "start_date": "start_date", + "due_date": "due_date", + "epic": "epic__name", + "created_at": "created_at", + } + sort_field = allowed_sorts.get(sort, "created_at") + if order == "desc": + sort_field = f"-{sort_field}" + tickets = tickets.order_by(sort_field) + + paginator = Paginator(tickets, per_page) + page_number = request.GET.get("page", 1) + page_obj = paginator.get_page(page_number) + + # Context for filter dropdowns + if request.user.role != "superadmin": + user_project_ids = request.user.projects.values_list("id", flat=True) + projects = Project.objects.filter(id__in=user_project_ids) + statuses = TicketStatus.objects.filter(project_id__in=user_project_ids) + epics = Epic.objects.filter(project_id__in=user_project_ids) + else: + projects = Project.objects.all() + statuses = TicketStatus.objects.all() + epics = Epic.objects.all() + + priorities = TicketPriority.objects.all() + users = User.objects.filter(is_active=True).order_by("username") + + return render( + request, + "tickets/list.html", + { + "page_obj": page_obj, + "tickets": page_obj.object_list, + "search": search, + "sort": sort, + "order": order, + "per_page": per_page, + "columns": columns, + "all_columns": ALL_TICKET_COLUMNS, + "today": today, + "projects": projects, + "statuses": statuses, + "epics": epics, + "priorities": priorities, + "users": users, + "selected_project": project_id, + "selected_status": status_id, + "selected_epic": epic_id, + "selected_priority": priority_id, + "selected_assignees": assignee_ids, + "selected_created_by": created_by, + "due_from": due_from, + "due_to": due_to, + }, + ) diff --git a/src/dashboard/page_views/__init__.py b/src/dashboard/page_views/__init__.py new file mode 100644 index 0000000..7621458 --- /dev/null +++ b/src/dashboard/page_views/__init__.py @@ -0,0 +1,7 @@ +from .epic_views import * +from .external_views import * +from .notification_views import * +from .other_views import * +from .project_views import * +from .ticket_views import * +from .user_views import * diff --git a/src/dashboard/page_views/epic_views.py b/src/dashboard/page_views/epic_views.py new file mode 100644 index 0000000..1fa0474 --- /dev/null +++ b/src/dashboard/page_views/epic_views.py @@ -0,0 +1,189 @@ +from django.contrib import messages +from django.contrib.auth import get_user_model +from django.db.models import Count +from django.shortcuts import get_object_or_404, redirect, render +from django.views.decorators.http import require_http_methods + +from src.epics.models import Epic +from src.projects.models import Project +from src.tickets.models import ( + TicketPriority, + TicketStatus, +) + +User = get_user_model() + +COLOR_PALETTE = [ + ("blue", "#3b82f6", "Blue"), + ("emerald", "#10b981", "Emerald"), + ("green", "#22c55e", "Green"), + ("indigo", "#6366f1", "Indigo"), + ("orange", "#f97316", "Orange"), + ("purple", "#a855f7", "Purple"), + ("red", "#ef4444", "Red"), + ("rose", "#f43f5e", "Rose"), + ("sky", "#0ea5e9", "Sky"), + ("teal", "#14b8a6", "Teal"), + ("violet", "#8b5cf6", "Violet"), + ("amber", "#f59e0b", "Amber"), + ("yellow", "#eab308", "Yellow"), + ("pink", "#ec4899", "Pink"), + ("cyan", "#06b6d4", "Cyan"), + ("lime", "#84cc16", "Lime"), + ("slate", "#64748b", "Slate"), + ("gray", "#6b7280", "Gray"), + ("zinc", "#71717a", "Zinc"), +] + +# ── Epic Create ─────────────────────────────────────────────────────────── + + +@require_http_methods(["GET", "POST"]) +def epic_create(request, project_id=None): + projects = Project.objects.all() + + if request.method == "POST": + project_id_post = request.POST.get("project") or project_id + name = request.POST.get("name", "").strip() + description = request.POST.get("description", "").strip() + start_date = request.POST.get("start_date") or None + end_date = request.POST.get("end_date") or None + + if not project_id_post or not name: + messages.error(request, "Project and name are required.") + return redirect("epic-create") + + Epic.objects.create( + project_id=project_id_post, + name=name, + description=description or None, + start_date=start_date, + end_date=end_date, + ) + messages.success(request, "Epic created successfully.") + return redirect("epics-overview-project", project_id=project_id_post) + + selected_project = None + if project_id: + selected_project = get_object_or_404(Project, pk=project_id) + + return render( + request, + "epics/form.html", + { + "projects": projects, + "selected_project": selected_project, + }, + ) + + +# ── Epic Edit ───────────────────────────────────────────────────────────── + + +@require_http_methods(["GET", "POST"]) +def epic_edit(request, epic_id): + epic = get_object_or_404(Epic, pk=epic_id) + projects = Project.objects.all() + + if request.method == "POST": + project_id = request.POST.get("project") + name = request.POST.get("name", "").strip() + description = request.POST.get("description", "").strip() + start_date = request.POST.get("start_date") or None + end_date = request.POST.get("end_date") or None + + if not project_id or not name: + messages.error(request, "Project and name are required.") + return redirect("epic-edit", epic_id=epic.id) + + epic.project_id = project_id + epic.name = name + epic.description = description or None + epic.start_date = start_date + epic.end_date = end_date + epic.save( + update_fields=[ + "project_id", + "name", + "description", + "start_date", + "end_date", + "updated_at", + ] + ) + messages.success(request, "Epic updated successfully.") + return redirect("epics-overview-project", project_id=epic.project_id) + + return render( + request, + "epics/form.html", + { + "epic": epic, + "projects": projects, + }, + ) + + +# ── Epic Delete ─────────────────────────────────────────────────────────── + + +@require_http_methods(["POST"]) +def epic_delete(request, epic_id): + epic = get_object_or_404(Epic, pk=epic_id) + project_id = epic.project_id + epic.delete() + messages.success(request, "Epic deleted successfully.") + return redirect("epics-overview-project", project_id=project_id) + + +# ── Epics Overview ──────────────────────────────────────────────────────── + + +def epics_overview(request, project_id=None): + projects = Project.objects.all() + if request.user.role == "member": + projects = projects.filter(members=request.user) + projects = projects.annotate( + ticket_count=Count("tickets"), + member_count=Count("members", distinct=True), + ) + selected_project = None + epics = [] + statuses = [] + priorities = [] + if project_id: + selected_project = get_object_or_404(Project, pk=project_id) + if ( + request.user.role == "member" + and not selected_project.members.filter(id=request.user.id).exists() + ): + from django.contrib import messages + from django.shortcuts import redirect + + messages.error(request, "Permission denied.") + return redirect("dashboard") + epics = ( + Epic.objects.filter(project=selected_project) + .prefetch_related( + "tickets__status", "tickets__priority", "tickets__assignees" + ) + .order_by("sort_order") + ) + + statuses = TicketStatus.objects.filter(project=selected_project).order_by( + "sort_order" + ) + priorities = TicketPriority.objects.all().order_by("name") + + return render( + request, + "epics/overview.html", + { + "projects": projects, + "selected_project": selected_project, + "selected_project_id": project_id, + "epics": epics, + "statuses": statuses, + "priorities": priorities, + }, + ) diff --git a/src/dashboard/page_views/external_views.py b/src/dashboard/page_views/external_views.py new file mode 100644 index 0000000..2a1fc78 --- /dev/null +++ b/src/dashboard/page_views/external_views.py @@ -0,0 +1,140 @@ +import secrets +import string + +from django.contrib import messages +from django.contrib.auth import get_user_model +from django.shortcuts import get_object_or_404, redirect, render +from django.utils import timezone +from django.views.decorators.http import require_http_methods + +from src.external.models import ExternalAccess +from src.projects.models import Project +from src.tickets.models import ( + Ticket, +) + +User = get_user_model() + +COLOR_PALETTE = [ + ("blue", "#3b82f6", "Blue"), + ("emerald", "#10b981", "Emerald"), + ("green", "#22c55e", "Green"), + ("indigo", "#6366f1", "Indigo"), + ("orange", "#f97316", "Orange"), + ("purple", "#a855f7", "Purple"), + ("red", "#ef4444", "Red"), + ("rose", "#f43f5e", "Rose"), + ("sky", "#0ea5e9", "Sky"), + ("teal", "#14b8a6", "Teal"), + ("violet", "#8b5cf6", "Violet"), + ("amber", "#f59e0b", "Amber"), + ("yellow", "#eab308", "Yellow"), + ("pink", "#ec4899", "Pink"), + ("cyan", "#06b6d4", "Cyan"), + ("lime", "#84cc16", "Lime"), + ("slate", "#64748b", "Slate"), + ("gray", "#6b7280", "Gray"), + ("zinc", "#71717a", "Zinc"), +] + +# ── External Access Management ────────────────────────────────────────── + + +@require_http_methods(["GET"]) +def external_access_list(request): + accesses = ExternalAccess.objects.select_related("project").all() + return render(request, "external/list.html", {"accesses": accesses}) + + +@require_http_methods(["POST"]) +def external_access_create(request, project_id): + project = get_object_or_404(Project, pk=project_id) + ExternalAccess.objects.create(project=project) + messages.success(request, "External access created successfully.") + return redirect("external-access-list") + + +@require_http_methods(["POST"]) +def external_access_regenerate(request, access_id): + access = get_object_or_404(ExternalAccess, pk=access_id) + access.password = "".join( + secrets.choice(string.ascii_letters + string.digits) for _ in range(8) + ) + access.save(update_fields=["password"]) + messages.success(request, "Password regenerated successfully.") + return redirect("external-access-list") + + +@require_http_methods(["POST"]) +def external_access_regenerate_project(request, project_id): + project = get_object_or_404(Project, pk=project_id) + project.generate_external_access() + messages.success(request, "External access regenerated successfully.") + return redirect("project-edit", project_id=project.id) + + +@require_http_methods(["POST"]) +def external_access_toggle(request, access_id): + access = get_object_or_404(ExternalAccess, pk=access_id) + access.is_active = not access.is_active + access.save(update_fields=["is_active"]) + status = "activated" if access.is_active else "deactivated" + messages.success(request, f"External access {status} successfully.") + return redirect("external-access-list") + + +# ── External Client Access (public, no auth) ──────────────────────────── + + +def external_access_view(request, token): + access = get_object_or_404(ExternalAccess, access_token=token) + authenticated = request.session.get("ext_token") == token + + if request.method == "POST": + password = request.POST.get("password", "") + if password == access.password and access.is_active: + request.session["ext_token"] = token + access.last_accessed_at = timezone.now() + access.save(update_fields=["last_accessed_at"]) + return redirect("external-dashboard", token=token) + return render( + request, + "external/access.html", + { + "access": access, + "error": "Invalid password or access is disabled.", + "authenticated": False, + }, + ) + + if authenticated and access.is_active: + tickets = ( + Ticket.objects.filter(project=access.project) + .select_related("status", "priority") + .order_by("-created_at") + ) + return render( + request, + "external/access.html", + { + "access": access, + "authenticated": True, + "tickets": tickets, + }, + ) + + return render( + request, + "external/access.html", + { + "access": access, + "authenticated": False, + }, + ) + + +@require_http_methods(["POST"]) +def external_access_logout(request, token): + if request.session.get("ext_token") == token: + del request.session["ext_token"] + return redirect("external-dashboard", token=token) diff --git a/src/dashboard/page_views/notification_views.py b/src/dashboard/page_views/notification_views.py new file mode 100644 index 0000000..d9ad234 --- /dev/null +++ b/src/dashboard/page_views/notification_views.py @@ -0,0 +1,154 @@ +from django.contrib import messages +from django.contrib.auth import get_user_model +from django.core.paginator import Paginator +from django.db.models import Q +from django.http import JsonResponse +from django.shortcuts import redirect, render +from django.utils import timezone +from django.views.decorators.http import require_http_methods + +from src.notifications.models import Notification + +User = get_user_model() + +COLOR_PALETTE = [ + ("blue", "#3b82f6", "Blue"), + ("emerald", "#10b981", "Emerald"), + ("green", "#22c55e", "Green"), + ("indigo", "#6366f1", "Indigo"), + ("orange", "#f97316", "Orange"), + ("purple", "#a855f7", "Purple"), + ("red", "#ef4444", "Red"), + ("rose", "#f43f5e", "Rose"), + ("sky", "#0ea5e9", "Sky"), + ("teal", "#14b8a6", "Teal"), + ("violet", "#8b5cf6", "Violet"), + ("amber", "#f59e0b", "Amber"), + ("yellow", "#eab308", "Yellow"), + ("pink", "#ec4899", "Pink"), + ("cyan", "#06b6d4", "Cyan"), + ("lime", "#84cc16", "Lime"), + ("slate", "#64748b", "Slate"), + ("gray", "#6b7280", "Gray"), + ("zinc", "#71717a", "Zinc"), +] + +# ── Notifications ────────────────────────────────────────────────────────── + + +@require_http_methods(["GET"]) +def notifications_list(request): + filter_param = request.GET.get("filter", "all") + search_query = request.GET.get("search", "").strip() + type_filter = request.GET.get("type", "") + + qs = Notification.objects.filter(user=request.user) + + if filter_param == "unread": + qs = qs.filter(read_at__isnull=True) + elif filter_param == "read": + qs = qs.filter(read_at__isnull=False) + + if type_filter: + qs = qs.filter(type=type_filter) + + if search_query: + qs = qs.filter( + Q(title__icontains=search_query) | Q(message__icontains=search_query) + ) + + try: + per_page = int(request.GET.get("per_page", 20)) + except ValueError: + per_page = 20 + + paginator = Paginator(qs.select_related("user"), per_page) + page_number = request.GET.get("page", 1) + page_obj = paginator.get_page(page_number) + + all_count = Notification.objects.filter(user=request.user).count() + unread_count = Notification.objects.filter( + user=request.user, read_at__isnull=True + ).count() + read_count = Notification.objects.filter( + user=request.user, read_at__isnull=False + ).count() + + return render( + request, + "notifications/list.html", + { + "notifications": page_obj, + "page_obj": page_obj, + "filter": filter_param, + "all_count": all_count, + "unread_count": unread_count, + "read_count": read_count, + "search_query": search_query, + "type_filter": type_filter, + "per_page": per_page, + }, + ) + + +@require_http_methods(["GET"]) +def notifications_dropdown(request): + notifications = Notification.objects.filter( + user=request.user, read_at__isnull=True + )[:10] + return render( + request, + "dashboard/partials/notif_dropdown.html", + { + "notifications": notifications, + }, + ) + + +@require_http_methods(["GET"]) +def notification_mark_read(request, notification_id): + try: + notif = Notification.objects.get(pk=notification_id, user=request.user) + except Notification.DoesNotExist: + messages.warning(request, "Notification not found.") + return redirect("notifications-list") + notif.read_at = timezone.now() + notif.save(update_fields=["read_at"]) + next_url = request.GET.get("next") or request.META.get("HTTP_REFERER") + if next_url: + return redirect(next_url) + return JsonResponse({"status": "ok"}) + + +@require_http_methods(["GET"]) +def notification_mark_all_read(request): + Notification.objects.filter(user=request.user, read_at__isnull=True).update( + read_at=timezone.now() + ) + # For HTMX requests from the dropdown, return the updated dropdown (empty state) + if request.META.get("HTTP_HX_REQUEST"): + from django.http import HttpResponse + from django.template.loader import render_to_string + + html = render_to_string( + "dashboard/partials/notif_dropdown.html", + { + "notifications": [], + }, + request=request, + ) + response = HttpResponse(html) + response["HX-Trigger"] = "notifications-cleared" + return response + return redirect("notifications-list") + + +@require_http_methods(["POST"]) +def notification_mark_bulk_read(request): + ids = request.POST.getlist("notification_ids") + if ids: + Notification.objects.filter( + id__in=ids, user=request.user, read_at__isnull=True + ).update(read_at=timezone.now()) + messages.success(request, f"{len(ids)} notification(s) marked as read.") + return redirect(request.POST.get("next", "notifications-list")) diff --git a/src/dashboard/page_views/other_views.py b/src/dashboard/page_views/other_views.py new file mode 100644 index 0000000..f4c0404 --- /dev/null +++ b/src/dashboard/page_views/other_views.py @@ -0,0 +1,327 @@ +import hashlib +import json +from datetime import date, timedelta + +from django.contrib import messages +from django.contrib.auth import get_user_model +from django.shortcuts import get_object_or_404, redirect, render +from django.utils import timezone +from django.views.decorators.http import require_http_methods + +from src.accounts.models import Setting +from src.tickets.models import ( + Ticket, + TicketComment, + TicketHistory, + TicketPriority, +) + +User = get_user_model() + +COLOR_PALETTE = [ + ("blue", "#3b82f6", "Blue"), + ("emerald", "#10b981", "Emerald"), + ("green", "#22c55e", "Green"), + ("indigo", "#6366f1", "Indigo"), + ("orange", "#f97316", "Orange"), + ("purple", "#a855f7", "Purple"), + ("red", "#ef4444", "Red"), + ("rose", "#f43f5e", "Rose"), + ("sky", "#0ea5e9", "Sky"), + ("teal", "#14b8a6", "Teal"), + ("violet", "#8b5cf6", "Violet"), + ("amber", "#f59e0b", "Amber"), + ("yellow", "#eab308", "Yellow"), + ("pink", "#ec4899", "Pink"), + ("cyan", "#06b6d4", "Cyan"), + ("lime", "#84cc16", "Lime"), + ("slate", "#64748b", "Slate"), + ("gray", "#6b7280", "Gray"), + ("zinc", "#71717a", "Zinc"), +] + +# ── Leaderboard ─────────────────────────────────────────────────────────── + + +def leaderboard(request): + days = int(request.GET.get("days", 7)) + top_n = int(request.GET.get("top", 10)) + since = timezone.now() - timedelta(days=days) + + users = User.objects.filter(is_active=True) + leaderboard_data = [] + + for user in users: + tickets_created = Ticket.objects.filter( + created_by=user, created_at__gte=since + ).count() + status_changes = TicketHistory.objects.filter( + user=user, created_at__gte=since + ).count() + comments_made = TicketComment.objects.filter( + user=user, created_at__gte=since + ).count() + active_days = ( + TicketHistory.objects.filter(user=user, created_at__gte=since) + .dates("created_at", "day") + .count() + ) + + score = ( + (status_changes * 5) + + (tickets_created * 2) + + (comments_made * 2) + + (active_days * 1) + ) + + if score > 0 or tickets_created > 0 or comments_made > 0: + leaderboard_data.append( + { + "user": user, + "score": score, + "tickets_created": tickets_created, + "status_changes": status_changes, + "comments_made": comments_made, + "active_days": active_days, + } + ) + + leaderboard_data.sort(key=lambda x: x["score"], reverse=True) + leaderboard_data = leaderboard_data[:top_n] + + for entry in leaderboard_data: + name = entry["user"].get_full_name() or entry["user"].username + h = hashlib.md5(name.encode()).hexdigest()[:6] + r, g, b = int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16) + entry["avatar_color"] = f"rgb({r},{g},{b})" + + context = { + "leaderboard": leaderboard_data, + "days": days, + "top_n": top_n, + } + + # For HTMX requests, render only the partial content (avoids nesting full page inside main) + if request.META.get("HTTP_HX_REQUEST"): + return render(request, "leaderboard/partials/content.html", context) + + return render(request, "leaderboard/index.html", context) + + +# ── User Contributions (Heatmap) ────────────────────────────────────────── + + +def user_contributions(request): + current_year = timezone.now().year + year_str = request.GET.get("year") + + if year_str and year_str.isdigit(): + target_year = int(year_str) + else: + target_year = current_year + + tz = timezone.get_current_timezone() + # Start and end of the target year + since = timezone.make_aware(timezone.datetime(target_year, 1, 1), timezone=tz) + + if target_year == current_year: + end = timezone.now().date() + else: + end = timezone.datetime(target_year, 12, 31).date() + + # Get available years for the tabs + first_history = TicketHistory.objects.order_by("created_at").first() + start_year = first_history.created_at.year if first_history else current_year + available_years = list(range(start_year, current_year + 1)) + + # Ensure target_year is in available_years + if target_year not in available_years and target_year <= current_year: + available_years.append(target_year) + available_years.sort(reverse=True) + + users = User.objects.filter(is_active=True)[:10] + contributions = [] + + for user in users: + tickets_created = Ticket.objects.filter( + created_by=user, created_at__year=target_year + ).count() + status_changes = TicketHistory.objects.filter( + user=user, created_at__year=target_year + ).count() + comments_made = TicketComment.objects.filter( + user=user, created_at__year=target_year + ).count() + active_days = ( + TicketHistory.objects.filter(user=user, created_at__year=target_year) + .dates("created_at", "day") + .count() + ) + + # Build heatmap data + heatmap_values = {} + current = since.date() + # end is already defined above + while current <= end: + heatmap_values[current.isoformat()] = 0 + current += timedelta(days=1) + + for h in TicketHistory.objects.filter(user=user, created_at__year=target_year): + day = h.created_at.date().isoformat() + if day in heatmap_values: + heatmap_values[day] += 1 + + max_val = max(heatmap_values.values()) if heatmap_values else 1 + + # Group into weeks (list of lists of day objects) + weeks = [] + week = [] + sorted_days = sorted(heatmap_values.keys()) + for i, day_str in enumerate(sorted_days): + if i > 0 and sorted_days[i - 1] < day_str: + pass + day_date = date.fromisoformat(day_str) + count = heatmap_values[day_str] + if count == 0: + level = 0 + elif count <= max_val // 4: + level = 1 + elif count <= max_val // 2: + level = 2 + elif count <= int(max_val / 1.5): + level = 3 + else: + level = 4 + week.append( + { + "date": day_str, + "count": count, + "level": level, + "day": day_date.weekday(), + } + ) + if day_date.weekday() == 6: # Sunday + weeks.append(week) + week = [] + if week: + weeks.append(week) + + contributions.append( + { + "user": user, + "tickets_created": tickets_created, + "status_changes": status_changes, + "comments_made": comments_made, + "active_days": active_days, + "weeks": weeks, + "max_val": max_val, + } + ) + + return render( + request, + "contributions/index.html", + { + "contributions": contributions, + "target_year": target_year, + "available_years": available_years, + }, + ) + + +# ── Ticket Priorities ───────────────────────────────────────────────────── + + +@require_http_methods(["GET"]) +def ticket_priorities(request): + priorities = TicketPriority.objects.all().order_by("name") + return render(request, "tickets/priorities.html", {"priorities": priorities}) + + +@require_http_methods(["POST"]) +def ticket_priority_add(request): + if request.user.role == "member": + messages.error(request, "Permission denied.") + return redirect("ticket-priorities") + name = request.POST.get("name", "").strip() + color = request.POST.get("color", "#6B7280") + if name: + TicketPriority.objects.create(name=name, color=color) + messages.success(request, "Priority added successfully.") + else: + messages.error(request, "Priority name is required.") + return redirect("ticket-priorities") + + +@require_http_methods(["POST"]) +def ticket_priority_edit(request, priority_id): + if request.user.role == "member": + messages.error(request, "Permission denied.") + return redirect("ticket-priorities") + priority = get_object_or_404(TicketPriority, pk=priority_id) + name = request.POST.get("name", "").strip() + color = request.POST.get("color", priority.color) + if name: + priority.name = name + priority.color = color + priority.save(update_fields=["name", "color"]) + messages.success(request, "Priority updated successfully.") + else: + messages.error(request, "Priority name is required.") + return redirect("ticket-priorities") + + +@require_http_methods(["POST"]) +def ticket_priority_delete(request, priority_id): + if request.user.role == "member": + messages.error(request, "Permission denied.") + return redirect("ticket-priorities") + priority = get_object_or_404(TicketPriority, pk=priority_id) + priority.delete() + messages.success(request, "Priority deleted successfully.") + return redirect("ticket-priorities") + + +# ── UI Settings ──────────────────────────────────────────────────────────── + + +def ui_settings(request): + the_user = request.user + user_settings = {} + if the_user.is_authenticated: + for s in Setting.objects.filter(user=the_user, group="ui"): + user_settings[s.key] = s.value + + if request.method == "POST": + navigation_style = request.POST.get("navigation_style", "sidebar") + color_theme = request.POST.get("color_theme", "blue") + valid_nav = ("sidebar", "top") + valid_colors = {c[0] for c in COLOR_PALETTE} + if navigation_style not in valid_nav: + navigation_style = "sidebar" + if color_theme not in valid_colors: + color_theme = "blue" + + Setting.objects.update_or_create( + user=the_user, + key="navigation_style", + defaults={"value": navigation_style, "group": "ui"}, + ) + Setting.objects.update_or_create( + user=the_user, + key="color_theme", + defaults={"value": color_theme, "group": "ui"}, + ) + messages.success(request, "UI settings saved successfully.") + return redirect("ui-settings") + + return render( + request, + "settings/ui.html", + { + "navigation_style": user_settings.get("navigation_style", "sidebar"), + "color_theme": user_settings.get("color_theme", "blue"), + "color_palette": COLOR_PALETTE, + "color_map": json.dumps({c[0]: c[1] for c in COLOR_PALETTE}), + }, + ) diff --git a/src/dashboard/page_views/project_views.py b/src/dashboard/page_views/project_views.py new file mode 100644 index 0000000..4dc366b --- /dev/null +++ b/src/dashboard/page_views/project_views.py @@ -0,0 +1,674 @@ +import json +from datetime import date + +from django.contrib import messages +from django.contrib.auth import get_user_model +from django.core.paginator import Paginator +from django.db.models import Count, Q +from django.shortcuts import get_object_or_404, redirect, render +from django.urls import reverse +from django.utils import timezone +from django.views.decorators.http import require_http_methods + +from src.epics.models import Epic +from src.notes.models import ProjectNote +from src.projects.models import Project, ProjectMember +from src.tickets.models import ( + Ticket, + TicketPriority, + TicketStatus, +) + +User = get_user_model() + +COLOR_PALETTE = [ + ("blue", "#3b82f6", "Blue"), + ("emerald", "#10b981", "Emerald"), + ("green", "#22c55e", "Green"), + ("indigo", "#6366f1", "Indigo"), + ("orange", "#f97316", "Orange"), + ("purple", "#a855f7", "Purple"), + ("red", "#ef4444", "Red"), + ("rose", "#f43f5e", "Rose"), + ("sky", "#0ea5e9", "Sky"), + ("teal", "#14b8a6", "Teal"), + ("violet", "#8b5cf6", "Violet"), + ("amber", "#f59e0b", "Amber"), + ("yellow", "#eab308", "Yellow"), + ("pink", "#ec4899", "Pink"), + ("cyan", "#06b6d4", "Cyan"), + ("lime", "#84cc16", "Lime"), + ("slate", "#64748b", "Slate"), + ("gray", "#6b7280", "Gray"), + ("zinc", "#71717a", "Zinc"), +] + +# ── Project Create ───────────────────────────────────────────────────────── + + +@require_http_methods(["GET", "POST"]) +def project_create(request): + if request.user.role == "member": + from django.contrib import messages + from django.shortcuts import redirect + + messages.error(request, "Permission denied.") + return redirect("dashboard") + if request.method == "POST": + name = request.POST.get("name", "").strip() + ticket_prefix = request.POST.get("ticket_prefix", "").strip() + color = request.POST.get("color", "#3b82f6") + description = request.POST.get("description", "").strip() + start_date = request.POST.get("start_date") or None + end_date = request.POST.get("end_date") or None + member_ids = request.POST.getlist("members") + + if not name: + messages.error(request, "Project name is required.") + return redirect("project-create") + + project = Project.objects.create( + name=name, + ticket_prefix=ticket_prefix or name[:3].upper(), + color=color, + description=description or None, + start_date=start_date, + end_date=end_date, + ) + + is_pinned = request.POST.get("is_pinned") == "1" + if is_pinned: + project.pin() + + if member_ids: + for uid in member_ids: + try: + user = User.objects.get(pk=uid) + ProjectMember.objects.get_or_create(project=project, user=user) + except User.DoesNotExist: + pass + + if request.POST.get("use_default_statuses") == "1": + default_statuses = ["Backlog", "Todo", "In Progress", "In Review", "Done"] + for i, sname in enumerate(default_statuses): + TicketStatus.objects.create( + project=project, + name=sname, + sort_order=i, + is_completed=(sname == "Done"), + color={ + "Backlog": "#6B7280", + "Todo": "#3B82F6", + "In Progress": "#F59E0B", + "In Review": "#8B5CF6", + "Done": "#10B981", + }.get(sname, "#6B7280"), + ) + + messages.success(request, f"Project '{project.name}' created successfully.") + + if request.POST.get("create_another") == "1": + return redirect("project-create") + + return redirect("project-detail", project_id=project.id) + + users = User.objects.filter(is_active=True).order_by("username") + return render( + request, + "projects/form.html", + { + "users": users, + }, + ) + + +# ── Project Detail ───────────────────────────────────────────────────────── + + +@require_http_methods(["GET"]) +def project_detail(request, project_id): + + today = timezone.now().date() + project = get_object_or_404( + Project.objects.prefetch_related("project_members__user", "ticket_statuses"), + pk=project_id, + ) + + # ─ Statistics ─ + members_count = project.project_members.count() + tickets_count = Ticket.objects.filter(project=project).count() + epics_count = Epic.objects.filter(project=project).count() + statuses_count = project.ticket_statuses.count() + + if project.end_date: + diff = (project.end_date - today).days + remaining_days = max(diff, 0) + else: + remaining_days = None + + pinned_display = None + if project.pinned_date: + pinned_display = project.pinned_date.strftime("d/m/Y H:i") + + # ─ Ticket Statuses ─ + statuses_qs = project.ticket_statuses.all().order_by("sort_order") + statuses_search = request.GET.get("statuses_search", "").strip() + if statuses_search: + statuses_qs = statuses_qs.filter(name__icontains=statuses_search) + statuses_per_page = int(request.GET.get("statuses_per_page", 10)) + statuses_paginator = Paginator(statuses_qs, statuses_per_page) + statuses_page = statuses_paginator.get_page(request.GET.get("statuses_page", 1)) + + statuses_columns = request.GET.getlist("statuses_columns") + all_statuses_columns = ["name", "color", "sort_order", "is_completed"] + if not statuses_columns: + statuses_columns = all_statuses_columns[:] + + # ─ Members ─ + members_qs = project.project_members.select_related("user").all() + members_search = request.GET.get("members_search", "").strip() + if members_search: + members_qs = members_qs.filter( + Q(user__first_name__icontains=members_search) + | Q(user__last_name__icontains=members_search) + | Q(user__email__icontains=members_search) + | Q(user__username__icontains=members_search) + ) + members_per_page = int(request.GET.get("members_per_page", 10)) + members_paginator = Paginator(members_qs, members_per_page) + members_page = members_paginator.get_page(request.GET.get("members_page", 1)) + + members_columns = request.GET.getlist("members_columns") + all_members_columns = ["name", "email", "joined"] + if not members_columns: + members_columns = all_members_columns[:] + + # ─ Epics with pagination ─ + epics_qs = ( + Epic.objects.filter(project=project) + .annotate(ticket_count=Count("tickets")) + .order_by("sort_order") + ) + epics_search = request.GET.get("epics_search", "").strip() + if epics_search: + epics_qs = epics_qs.filter(name__icontains=epics_search) + epics_per_page = int(request.GET.get("epics_per_page", 10)) + epics_paginator = Paginator(epics_qs, epics_per_page) + epics_page = epics_paginator.get_page(request.GET.get("epics_page", 1)) + + epics_columns = request.GET.getlist("epics_columns") + all_epics_columns = ["name", "sort_order", "start_date", "end_date", "tickets"] + if not epics_columns: + epics_columns = all_epics_columns[:] + + # ─ Tickets with pagination ─ + tickets_qs = ( + Ticket.objects.filter(project=project) + .select_related("status", "priority") + .prefetch_related("assignees") + .order_by("-created_at") + ) + tickets_search = request.GET.get("tickets_search", "").strip() + if tickets_search: + tickets_qs = tickets_qs.filter( + Q(name__icontains=tickets_search) | Q(uuid__icontains=tickets_search) + ) + tickets_status = request.GET.get("tickets_status", "").strip() + if tickets_status: + tickets_qs = tickets_qs.filter(status_id=tickets_status) + tickets_priority = request.GET.get("tickets_priority", "").strip() + if tickets_priority: + tickets_qs = tickets_qs.filter(priority_id=tickets_priority) + tickets_per_page = int(request.GET.get("tickets_per_page", 10)) + tickets_paginator = Paginator(tickets_qs, tickets_per_page) + tickets_page = tickets_paginator.get_page(request.GET.get("tickets_page", 1)) + tickets_columns = request.GET.getlist("tickets_columns") + all_ticket_columns = [ + "uuid", + "name", + "status", + "priority", + "assignees", + "start_date", + "due_date", + "created_at", + ] + if not tickets_columns: + tickets_columns = all_ticket_columns[:] + + # ─ External Access ─ + external_access = project.external_accesses.first() + if not external_access: + external_access = project.generate_external_access() + + # ─ Notes with pagination ─ + notes_qs = project.notes.select_related("created_by").order_by( + "-note_date", "-created_at" + ) + notes_search = request.GET.get("notes_search", "").strip() + if notes_search: + notes_qs = notes_qs.filter( + Q(title__icontains=notes_search) | Q(content__icontains=notes_search) + ) + notes_per_page = int(request.GET.get("notes_per_page", 10)) + notes_paginator = Paginator(notes_qs, notes_per_page) + notes_page = notes_paginator.get_page(request.GET.get("notes_page", 1)) + + notes_columns = request.GET.getlist("notes_columns") + all_notes_columns = ["title", "date", "content", "created_by"] + if not notes_columns: + notes_columns = all_notes_columns[:] + + return render( + request, + "projects/detail.html", + { + "project": project, + "statuses": statuses_page, + "statuses_paginator": statuses_page, + "statuses_search": statuses_search, + "statuses_per_page": statuses_per_page, + "statuses_columns": statuses_columns, + "all_statuses_columns": all_statuses_columns, + "members": members_page, + "members_paginator": members_page, + "members_search": members_search, + "members_per_page": members_per_page, + "members_columns": members_columns, + "all_members_columns": all_members_columns, + "epics": epics_page, + "epics_paginator": epics_page, + "epics_search": epics_search, + "epics_per_page": epics_per_page, + "epics_columns": epics_columns, + "all_epics_columns": all_epics_columns, + "priorities": TicketPriority.objects.all().order_by("name"), + "tickets": tickets_page, + "tickets_paginator": tickets_page, + "tickets_search": tickets_search, + "tickets_status": tickets_status, + "tickets_priority": tickets_priority, + "tickets_per_page": tickets_per_page, + "tickets_columns": tickets_columns, + "all_ticket_columns": all_ticket_columns, + "full_tickets": tickets_qs, + "tickets_count": tickets_qs.count(), + "notes": notes_page, + "notes_paginator": notes_page, + "notes_search": notes_search, + "notes_per_page": notes_per_page, + "notes_columns": notes_columns, + "all_notes_columns": all_notes_columns, + "status_counts": None, + "members_count": members_count, + "tickets_count_total": tickets_count, + "epics_count": epics_count, + "statuses_count": statuses_count, + "remaining_days": remaining_days, + "pinned_display": pinned_display, + "today": today, + "external_access": external_access, + }, + ) + + +# ── Project Edit ─────────────────────────────────────────────────────────── + + +@require_http_methods(["GET", "POST"]) +def project_edit(request, project_id): + project = get_object_or_404(Project, pk=project_id) + + if request.method == "POST": + name = request.POST.get("name", "").strip() + ticket_prefix = request.POST.get("ticket_prefix", "").strip() + color = request.POST.get("color", "#3b82f6") + description = request.POST.get("description", "").strip() + start_date = request.POST.get("start_date") or None + end_date = request.POST.get("end_date") or None + is_pinned = request.POST.get("is_pinned") == "1" + member_ids = [int(x) for x in request.POST.getlist("members") if x] + + if not name: + messages.error(request, "Project name is required.") + return redirect("project-edit", project_id=project.id) + + project.name = name + project.ticket_prefix = ticket_prefix or project.ticket_prefix + project.color = color + project.description = description or None + project.start_date = start_date + project.end_date = end_date + if is_pinned and not project.pinned_date: + project.pin() + elif not is_pinned and project.pinned_date: + project.unpin() + project.save( + update_fields=[ + "name", + "ticket_prefix", + "color", + "description", + "start_date", + "end_date", + "pinned_date", + "updated_at", + ] + ) + + existing_ids = set(project.project_members.values_list("user_id", flat=True)) + new_ids = set(member_ids) + for uid in new_ids - existing_ids: + try: + user = User.objects.get(pk=uid) + ProjectMember.objects.get_or_create(project=project, user=user) + except User.DoesNotExist: + pass + project.project_members.filter(user_id__in=(existing_ids - new_ids)).delete() + + messages.success(request, f"Project '{project.name}' updated successfully.") + return redirect("project-detail", project_id=project.id) + + users = User.objects.filter(is_active=True).order_by("username") + member_ids = set(project.project_members.values_list("user_id", flat=True)) + external_access = project.external_accesses.first() + if not external_access: + external_access = project.generate_external_access() + + # ─ Related resource data (same as project_detail) ─ + from django.core.paginator import Paginator + + statuses = project.ticket_statuses.all().order_by("sort_order") + members = project.project_members.select_related("user").all() + members_search = request.GET.get("members_search", "").strip() + if members_search: + members = members.filter( + Q(user__first_name__icontains=members_search) + | Q(user__last_name__icontains=members_search) + | Q(user__email__icontains=members_search) + ) + + epics_qs = ( + Epic.objects.filter(project=project) + .annotate(ticket_count=Count("tickets")) + .order_by("sort_order") + ) + epics_search = request.GET.get("epics_search", "").strip() + if epics_search: + epics_qs = epics_qs.filter(name__icontains=epics_search) + epics_per_page = int(request.GET.get("epics_per_page", 10)) + epics_paginator = Paginator(epics_qs, epics_per_page) + epics_page = epics_paginator.get_page(request.GET.get("epics_page", 1)) + + epics_columns = request.GET.getlist("epics_columns") + all_epics_columns = ["name", "sort_order", "start_date", "end_date", "tickets"] + if not epics_columns: + epics_columns = all_epics_columns[:] + + tickets_qs = ( + Ticket.objects.filter(project=project) + .select_related("status", "priority") + .prefetch_related("assignees") + .order_by("-created_at") + ) + tickets_search = request.GET.get("tickets_search", "").strip() + if tickets_search: + tickets_qs = tickets_qs.filter( + Q(name__icontains=tickets_search) | Q(uuid__icontains=tickets_search) + ) + tickets_status = request.GET.get("tickets_status", "").strip() + if tickets_status: + tickets_qs = tickets_qs.filter(status_id=tickets_status) + tickets_priority = request.GET.get("tickets_priority", "").strip() + if tickets_priority: + tickets_qs = tickets_qs.filter(priority_id=tickets_priority) + tickets_per_page = int(request.GET.get("tickets_per_page", 10)) + tickets_paginator = Paginator(tickets_qs, tickets_per_page) + tickets_page = tickets_paginator.get_page(request.GET.get("tickets_page", 1)) + tickets_columns = request.GET.getlist("tickets_columns") + all_ticket_columns = [ + "uuid", + "name", + "status", + "priority", + "assignees", + "start_date", + "due_date", + "created_at", + ] + if not tickets_columns: + tickets_columns = all_ticket_columns[:] + + notes_qs = project.notes.select_related("created_by").order_by( + "-note_date", "-created_at" + ) + notes_search = request.GET.get("notes_search", "").strip() + if notes_search: + notes_qs = notes_qs.filter( + Q(title__icontains=notes_search) | Q(content__icontains=notes_search) + ) + notes_per_page = int(request.GET.get("notes_per_page", 10)) + notes_paginator = Paginator(notes_qs, notes_per_page) + notes_page = notes_paginator.get_page(request.GET.get("notes_page", 1)) + + notes_columns = request.GET.getlist("notes_columns") + all_notes_columns = ["title", "date", "content", "created_by"] + if not notes_columns: + notes_columns = all_notes_columns[:] + + return render( + request, + "projects/form.html", + { + "project": project, + "users": users, + "member_ids": member_ids, + "external_access": external_access, + "statuses": statuses, + "members": members, + "members_search": members_search, + "epics": epics_page, + "epics_paginator": epics_page, + "epics_search": epics_search, + "epics_per_page": epics_per_page, + "priorities": TicketPriority.objects.all().order_by("name"), + "tickets": tickets_page, + "tickets_paginator": tickets_page, + "tickets_search": tickets_search, + "tickets_status": tickets_status, + "tickets_priority": tickets_priority, + "tickets_per_page": tickets_per_page, + "tickets_columns": tickets_columns, + "all_ticket_columns": all_ticket_columns, + "full_tickets": tickets_qs, + "notes": notes_page, + "notes_paginator": notes_page, + "notes_search": notes_search, + "notes_per_page": notes_per_page, + "tickets_count_total": tickets_qs.count(), + "epics_count": epics_paginator.count, + "members_count": members.count(), + "statuses_count": statuses.count(), + }, + ) + + +# ── Project Delete ───────────────────────────────────────────────────────── + + +@require_http_methods(["POST"]) +def project_delete(request, project_id): + if request.user.role == "member": + from django.contrib import messages + from django.shortcuts import redirect + + messages.error(request, "Permission denied.") + return redirect("dashboard") + project = get_object_or_404(Project, pk=project_id) + project.delete() + messages.success(request, "Project deleted successfully.") + return redirect("projects-list") + + +@require_http_methods(["POST"]) +def project_toggle_pin(request, project_id): + project = get_object_or_404(Project, pk=project_id) + if project.pinned_date: + project.unpin() + messages.success(request, f"Project '{project.name}' unpinned.") + else: + project.pin() + messages.success(request, f"Project '{project.name}' pinned.") + return redirect("projects-list") + + +# ── Project Timeline (Gantt) ────────────────────────────────────────────── + + +def project_timeline(request): + projects_qs = Project.objects.filter( + start_date__isnull=False, end_date__isnull=False + ) + if request.user.role == "member": + projects_qs = projects_qs.filter(members=request.user) + projects_qs = projects_qs.order_by("start_date") + + today = date.today() + gantt_data = {"data": [], "links": []} + has_data = False + + for p in projects_qs: + has_data = True + total = (p.end_date - p.start_date).days or 1 + elapsed = (today - p.start_date).days + progress = max(0, min(100, int(elapsed / total * 100))) + remaining = (p.end_date - today).days + + if remaining < 0: + status = "Overdue" + bar_color = "#ef4444" + is_overdue = True + elif remaining <= 7: + status = "Approaching Deadline" + bar_color = "#f59e0b" + is_overdue = False + elif progress >= 100: + status = "Completed" + bar_color = "#10b981" + is_overdue = False + elif progress > 0: + status = "In Progress" + bar_color = "#3b82f6" + is_overdue = False + else: + status = "Not Started" + bar_color = "#9ca3af" + is_overdue = False + + gantt_data["data"].append( + { + "id": p.id, + "text": p.name, + "start_date": p.start_date.isoformat(), + "end_date": p.end_date.isoformat(), + "duration": total, + "progress": progress / 100.0, + "status": status, + "is_overdue": is_overdue, + "color": bar_color, + "prefix": p.ticket_prefix or "", + "project_color": p.color or "#3b82f6", + } + ) + + project_count = len(gantt_data["data"]) + min_height = 400 + row_height = 40 + header_height = 80 + calculated_height = max(min_height, project_count * row_height + header_height) + return render( + request, + "projects/timeline.html", + { + "gantt_data_json": json.dumps(gantt_data), + "gantt_data": gantt_data, + "has_data": has_data, + "project_count": project_count, + "calculated_height": calculated_height, + "today": today, + }, + ) + + +@require_http_methods(["POST"]) +def project_member_create(request): + project_id = request.POST.get("project_id") + project = get_object_or_404(Project, pk=project_id) + user_id = request.POST.get("user_id") + if user_id: + try: + user = User.objects.get(pk=user_id) + ProjectMember.objects.get_or_create(project=project, user=user) + messages.success(request, "Member added to project.") + except User.DoesNotExist: + messages.error(request, "User not found.") + else: + messages.error(request, "Please select a user.") + + response = redirect("project-edit", project_id=project_id) + if request.POST.get("create_another"): + response["Location"] += "?add_member=1" + return response + + +@require_http_methods(["POST"]) +def project_member_delete(request, member_id): + member = get_object_or_404(ProjectMember, pk=member_id) + project_id = member.project_id + member.delete() + messages.success(request, "Project member removed.") + return redirect("project-edit", project_id=project_id) + + +@require_http_methods(["POST"]) +def project_member_edit(request, member_id): + member = get_object_or_404(ProjectMember, pk=member_id) + user_id = request.POST.get("user_id") + if user_id: + try: + member.user_id = int(user_id) + member.save() + messages.success(request, "Project member updated.") + except Exception: + messages.error(request, "Invalid user selected.") + return redirect("project-edit", project_id=member.project_id) + + +@require_http_methods(["POST"]) +def project_note_create(request): + project_id = request.POST.get("project_id") + project = get_object_or_404(Project, pk=project_id) + title = request.POST.get("title", "").strip() + content = request.POST.get("content", "").strip() + + if not title: + messages.error(request, "Note title is required.") + else: + ProjectNote.objects.create( + project=project, author=request.user, title=title, content=content + ) + messages.success(request, "Project note created.") + + return redirect( + f"{reverse('project-edit', kwargs={'project_id': project_id})}?tab=notes" + ) + + +@require_http_methods(["POST"]) +def project_note_edit(request, note_id): + note = get_object_or_404(ProjectNote, pk=note_id) + note.title = request.POST.get("title", note.title) + note.content = request.POST.get("content", note.content) + note.save() + messages.success(request, "Project note updated.") + return redirect("project-edit", project_id=note.project_id) diff --git a/src/dashboard/page_views/ticket_views.py b/src/dashboard/page_views/ticket_views.py new file mode 100644 index 0000000..3ea1c8f --- /dev/null +++ b/src/dashboard/page_views/ticket_views.py @@ -0,0 +1,955 @@ +import json +from datetime import date + +import openpyxl +from django.contrib import messages +from django.contrib.auth import get_user_model +from django.db.models import Count, Prefetch +from django.http import HttpResponse, JsonResponse +from django.shortcuts import get_object_or_404, redirect, render +from django.utils import timezone +from django.views.decorators.http import require_http_methods + +from src.epics.models import Epic +from src.notifications.email_utils import send_notification_email +from src.notifications.models import Notification +from src.projects.models import Project +from src.tickets.models import ( + Ticket, + TicketComment, + TicketHistory, + TicketPriority, + TicketStatus, + TicketUser, +) + +User = get_user_model() + +COLOR_PALETTE = [ + ("blue", "#3b82f6", "Blue"), + ("emerald", "#10b981", "Emerald"), + ("green", "#22c55e", "Green"), + ("indigo", "#6366f1", "Indigo"), + ("orange", "#f97316", "Orange"), + ("purple", "#a855f7", "Purple"), + ("red", "#ef4444", "Red"), + ("rose", "#f43f5e", "Rose"), + ("sky", "#0ea5e9", "Sky"), + ("teal", "#14b8a6", "Teal"), + ("violet", "#8b5cf6", "Violet"), + ("amber", "#f59e0b", "Amber"), + ("yellow", "#eab308", "Yellow"), + ("pink", "#ec4899", "Pink"), + ("cyan", "#06b6d4", "Cyan"), + ("lime", "#84cc16", "Lime"), + ("slate", "#64748b", "Slate"), + ("gray", "#6b7280", "Gray"), + ("zinc", "#71717a", "Zinc"), +] + +# ── Ticket Timeline (Gantt) ─────────────────────────────────────────────── + + +def ticket_timeline(request, project_id=None): + projects = Project.objects.all() + if request.user.role == "member": + projects = projects.filter(members=request.user) + projects = projects.annotate( + ticket_count=Count("tickets"), + member_count=Count("members", distinct=True), + ) + selected_project = None + tickets = [] + tickets_with_dates = False + gantt_json = "null" + if project_id: + selected_project = get_object_or_404(Project, pk=project_id) + tickets_qs = ( + Ticket.objects.filter(project=selected_project) + .select_related("status", "priority") + .filter(start_date__isnull=False, due_date__isnull=False) + .order_by("start_date", "due_date") + ) + + if tickets_qs.exists(): + tickets_with_dates = True + gantt_data = {"data": [], "links": []} + for t in tickets_qs: + status_name = t.status.name if t.status else "Open" + progress = 0 + overdue = False + if t.start_date and t.due_date: + total = (t.due_date - t.start_date).days or 1 + elapsed = (date.today() - t.start_date).days + progress = max(0, min(100, int(elapsed / total * 100))) / 100.0 + overdue = (t.due_date - date.today()).days < 0 + gantt_data["data"].append( + { + "id": t.id, + "text": f"[{t.uuid}] {t.name}", + "start_date": t.start_date.isoformat() + if t.start_date + else None, + "end_date": t.due_date.isoformat() if t.due_date else None, + "duration": (t.due_date - t.start_date).days + if t.start_date and t.due_date + else 1, + "progress": progress, + "status": status_name, + "is_overdue": overdue, + "parent": None, + } + ) + gantt_json = json.dumps(gantt_data) + + return render( + request, + "tickets/timeline.html", + { + "projects": projects, + "selected_project": selected_project, + "selected_project_id": project_id, + "tickets": tickets, + "tickets_with_dates": tickets_with_dates, + "gantt_json": gantt_json, + }, + ) + + +# ── Ticket Create ────────────────────────────────────────────────────────── + + +def _project_data(p): + return { + "id": p.id, + "name": p.name, + "statuses": [ + {"id": s.id, "name": s.name, "color": s.color} + for s in p.ticket_statuses.all().order_by("sort_order") + ], + "epics": [{"id": e.id, "name": e.name} for e in p.epics.all()], + "members": [ + {"id": m.user.id, "name": m.user.get_full_name() or m.user.username} + for m in p.project_members.all() + ], + } + + +@require_http_methods(["GET", "POST"]) +def ticket_create(request): + projects_qs = Project.objects.prefetch_related( + "ticket_statuses", "epics", "project_members__user" + ).all() + priorities = TicketPriority.objects.all() + + if request.method == "POST": + project_id = request.POST.get("project") + name = request.POST.get("name", "").strip() + description = request.POST.get("description", "").strip() + status_id = request.POST.get("status") + priority_id = request.POST.get("priority") or None + epic_id = request.POST.get("epic") or None + assignee_ids = [int(x) for x in request.POST.getlist("assignees") if x] + start_date = request.POST.get("start_date") or None + due_date = request.POST.get("due_date") or None + + if not project_id or not name or not status_id: + messages.error(request, "Project, name, and status are required.") + return redirect("ticket-create") + + project = get_object_or_404(Project, pk=project_id) + status = get_object_or_404(TicketStatus, pk=status_id) + + ticket = Ticket.objects.create( + project=project, + status=status, + name=name, + description=description or None, + priority_id=priority_id, + epic_id=epic_id, + start_date=start_date, + due_date=due_date, + created_by=request.user, + ) + + for uid in assignee_ids: + TicketUser.objects.get_or_create(ticket=ticket, user_id=uid) + + TicketHistory.objects.create( + ticket=ticket, + user=request.user, + status=status, + ) + + notify_users = list(ticket.assignees.all()) + if ticket.created_by and ticket.created_by not in notify_users: + notify_users.append(ticket.created_by) + + for u in notify_users: + notification = Notification.objects.create( + user=u, + type="ticket_created", + title=f"New Ticket: {ticket.uuid}", + message=f"Ticket '{ticket.name}' created by {request.user.get_full_name() or request.user.username}", + data={"ticket_id": ticket.id, "ticket_uuid": ticket.uuid}, + ) + # Send email notification + send_notification_email( + user=u, + notification_type="ticket_created", + title=notification.title, + message=notification.message, + data={ + "ticket_id": ticket.id, + "ticket_uuid": ticket.uuid, + "project_name": project.name, + "user_name": request.user.get_full_name() or request.user.username, + }, + ) + + messages.success(request, f"Ticket '{ticket.name}' created successfully.") + return redirect("ticket-detail", ticket_id=ticket.id) + + selected_project_id = request.GET.get("project") + + projects_json = json.dumps([_project_data(p) for p in projects_qs]) + priorities_json = json.dumps( + [{"id": p.id, "name": p.name, "color": p.color} for p in priorities] + ) + + return render( + request, + "tickets/form.html", + { + "projects": projects_qs, + "priorities": priorities, + "projects_json": projects_json, + "priorities_json": priorities_json, + "current_assignee_ids": [], + "selected_project_id": selected_project_id, + }, + ) + + +# ── Ticket Edit ──────────────────────────────────────────────────────────── + + +@require_http_methods(["GET", "POST"]) +def ticket_edit(request, ticket_id): + ticket = get_object_or_404( + Ticket.objects.select_related("project", "status", "priority", "epic"), + pk=ticket_id, + ) + projects_qs = Project.objects.prefetch_related( + "ticket_statuses", "epics", "project_members__user" + ).all() + priorities = TicketPriority.objects.all() + current_assignee_ids = list(ticket.assignees.values_list("id", flat=True)) + + if request.method == "POST": + project_id = request.POST.get("project") + name = request.POST.get("name", "").strip() + description = request.POST.get("description", "").strip() + status_id = request.POST.get("status") + priority_id = request.POST.get("priority") or None + epic_id = request.POST.get("epic") or None + assignee_ids = [int(x) for x in request.POST.getlist("assignees") if x] + start_date = request.POST.get("start_date") or None + due_date = request.POST.get("due_date") or None + + if not project_id or not name or not status_id: + messages.error(request, "Project, name, and status are required.") + return redirect("ticket-edit", ticket_id=ticket.id) + + old_status_id = ticket.status_id + + ticket.project_id = project_id + ticket.name = name + ticket.description = description or None + ticket.status_id = status_id + ticket.priority_id = priority_id + ticket.epic_id = epic_id + ticket.start_date = start_date + ticket.due_date = due_date + ticket.save( + update_fields=[ + "project_id", + "name", + "description", + "status_id", + "priority_id", + "epic_id", + "start_date", + "due_date", + "updated_at", + ] + ) + + existing_assignee_ids = set(current_assignee_ids) + new_assignee_ids = set(assignee_ids) + for uid in new_assignee_ids - existing_assignee_ids: + TicketUser.objects.get_or_create(ticket=ticket, user_id=uid) + TicketUser.objects.filter( + ticket=ticket, user_id__in=(existing_assignee_ids - new_assignee_ids) + ).delete() + + if int(status_id) != old_status_id: + new_status = TicketStatus.objects.get(pk=status_id) + TicketHistory.objects.create( + ticket=ticket, + user=request.user, + status=new_status, + ) + + notify_users = list(ticket.assignees.all()) + if ticket.created_by and ticket.created_by not in notify_users: + notify_users.append(ticket.created_by) + + for u in notify_users: + notification = Notification.objects.create( + user=u, + type="status_changed", + title=f"Ticket {ticket.uuid} status changed", + message=f"Status changed to {new_status.name} by {request.user.get_full_name() or request.user.username}", + data={"ticket_id": ticket.id, "ticket_uuid": ticket.uuid}, + ) + # Send email notification + send_notification_email( + user=u, + notification_type="status_changed", + title=notification.title, + message=notification.message, + data={ + "ticket_id": ticket.id, + "ticket_uuid": ticket.uuid, + "project_name": ticket.project.name, + "user_name": request.user.get_full_name() + or request.user.username, + }, + ) + + messages.success(request, f"Ticket '{ticket.name}' updated successfully.") + return redirect("ticket-detail", ticket_id=ticket.id) + + projects_json = json.dumps([_project_data(p) for p in projects_qs]) + priorities_json = json.dumps( + [{"id": p.id, "name": p.name, "color": p.color} for p in priorities] + ) + + return render( + request, + "tickets/form.html", + { + "ticket": ticket, + "projects": projects_qs, + "priorities": priorities, + "projects_json": projects_json, + "priorities_json": priorities_json, + "current_assignee_ids": current_assignee_ids, + }, + ) + + +# ── Ticket Delete ────────────────────────────────────────────────────────── + + +@require_http_methods(["POST"]) +def ticket_delete(request, ticket_id): + ticket = get_object_or_404(Ticket, pk=ticket_id) + ticket.delete() + messages.success(request, "Ticket deleted successfully.") + return redirect("tickets-list") + + +# ── Ticket Detail ────────────────────────────────────────────────────────── + + +@require_http_methods(["GET"]) +def ticket_detail(request, ticket_id): + comments_qs = ( + TicketComment.objects.select_related("user") + .prefetch_related("replies__user") + .filter(parent__isnull=True) + .order_by("created_at") + ) + histories_qs = TicketHistory.objects.select_related("user", "status").order_by( + "-created_at" + ) + + ticket = get_object_or_404( + Ticket.objects.select_related( + "status", "priority", "project", "created_by", "epic" + ).prefetch_related( + Prefetch("comments", queryset=comments_qs), + Prefetch("histories", queryset=histories_qs), + "assignees", + ), + pk=ticket_id, + ) + today = timezone.now().date() + return render(request, "tickets/detail.html", {"ticket": ticket, "today": today}) + + +# ── Ticket Comment Add ──────────────────────────────────────────────────── + + +@require_http_methods(["POST"]) +def ticket_comment_add(request, ticket_id): + ticket = get_object_or_404(Ticket, pk=ticket_id) + comment_text = request.POST.get("comment", "").strip() + parent_id = request.POST.get("parent_id") + if comment_text: + kwargs = { + "ticket": ticket, + "user": request.user, + "comment": comment_text, + } + if parent_id: + parent = get_object_or_404(TicketComment, pk=parent_id, ticket=ticket) + kwargs["parent"] = parent + TicketComment.objects.create(**kwargs) + comments = ( + TicketComment.objects.select_related("user") + .prefetch_related("replies__user") + .filter(ticket=ticket, parent__isnull=True) + .order_by("created_at") + ) + return render(request, "tickets/partials/comments.html", {"comments": comments}) + + +# ── Ticket Comment Delete ──────────────────────────────────────────────── + + +@require_http_methods(["POST"]) +def ticket_comment_delete(request, ticket_id, comment_id): + comment = get_object_or_404(TicketComment, pk=comment_id, ticket_id=ticket_id) + if request.user == comment.user or request.user.role == "superadmin": + comment.delete() + ticket = get_object_or_404(Ticket, pk=ticket_id) + comments = ( + TicketComment.objects.select_related("user") + .prefetch_related("replies__user") + .filter(ticket=ticket, parent__isnull=True) + .order_by("created_at") + ) + return render(request, "tickets/partials/comments.html", {"comments": comments}) + + +# ── Ticket Update Description ──────────────────────────────────────────── + + +@require_http_methods(["POST"]) +def ticket_update_description(request, ticket_id): + ticket = get_object_or_404(Ticket, pk=ticket_id) + description = request.POST.get("description", "").strip() + ticket.description = description + ticket.save(update_fields=["description", "updated_at"]) + if description: + return HttpResponse(f'
    {description}
    ') + return HttpResponse( + '

    No description set.

    ' + ) + + +# ── Ticket Update Field ────────────────────────────────────────────────── + + +@require_http_methods(["POST"]) +def ticket_update_field(request, ticket_id): + ticket = get_object_or_404(Ticket, pk=ticket_id) + field = request.POST.get("field") + value = request.POST.get("value", "").strip() + + if field in ("name",): + ticket.name = value + ticket.save(update_fields=["name", "updated_at"]) + return HttpResponse(value) + elif field in ("start_date", "due_date"): + if value: + setattr(ticket, field, value) + else: + setattr(ticket, field, None) + ticket.save(update_fields=[field, "updated_at"]) + return HttpResponse(value or "-") + return JsonResponse({"error": "Invalid field"}, status=400) + + +# ── Tickets Export ────────────────────────────────────────────────────── + + +@require_http_methods(["GET"]) +def tickets_export(request): + tickets = Ticket.objects.select_related( + "project", "status", "priority", "created_by", "epic" + ) + if request.user.role == "member": + tickets = tickets.filter(assignees=request.user) + tickets = ( + tickets.select_related("status", "priority", "project", "created_by", "epic") + .prefetch_related("assignees") + .order_by("-created_at") + ) + + if request.user.role != "superadmin": + user_project_ids = request.user.projects.values_list("id", flat=True) + tickets = tickets.filter(project_id__in=user_project_ids) + + project_id = request.GET.get("project") + status_id = request.GET.get("status") + priority_id = request.GET.get("priority") + + if project_id: + tickets = tickets.filter(project_id=project_id) + if status_id: + tickets = tickets.filter(status_id=status_id) + if priority_id: + tickets = tickets.filter(priority_id=priority_id) + + wb = openpyxl.Workbook() + ws = wb.active + ws.title = "Tickets" + + headers = [ + "UUID", + "Name", + "Description", + "Project", + "Status", + "Priority", + "Epic", + "Assignees", + "Start Date", + "Due Date", + "Created By", + "Created At", + "Updated At", + ] + ws.append(headers) + + for t in tickets: + ws.append( + [ + t.uuid, + t.name, + t.description or "", + t.project.name, + t.status.name, + t.priority.name if t.priority else "", + t.epic.name if t.epic else "", + ", ".join(a.get_full_name() or a.username for a in t.assignees.all()), + t.start_date or "", + t.due_date or "", + t.created_by.get_full_name() or t.created_by.username + if t.created_by + else "", + t.created_at.replace(tzinfo=None) if t.created_at else "", + t.updated_at.replace(tzinfo=None) if t.updated_at else "", + ] + ) + + response = HttpResponse( + content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" + ) + response["Content-Disposition"] = ( + f'attachment; filename="tickets-export-{date.today().isoformat()}.xlsx"' + ) + wb.save(response) + return response + + +# ── Tickets Import ────────────────────────────────────────────────────── + + +@require_http_methods(["GET", "POST"]) +def tickets_import(request): + result = None + + if request.method == "POST" and request.FILES.get("file"): + excel_file = request.FILES["file"] + created_count = 0 + errors = [] + + try: + wb = openpyxl.load_workbook(excel_file, read_only=True) + ws = wb.active + rows = list(ws.iter_rows(values_only=True)) + if not rows: + errors.append("Empty file.") + else: + headers = [str(h).strip().lower() if h else "" for h in rows[0]] + expected = [ + "name", + "project", + "status", + "priority", + "epic", + "start date", + "due date", + "description", + "assignees", + ] + col_map = {} + for i, h in enumerate(headers): + for e in expected: + if h == e: + col_map[e] = i + + if "name" not in col_map: + errors.append("Missing required column: Name") + if "project" not in col_map: + errors.append("Missing required column: Project") + + for row_idx, row in enumerate(rows[1:], start=2): + if all(v is None or str(v).strip() == "" for v in row): + continue + row_errors = [] + try: + name = ( + str(row[col_map["name"]]).strip() + if col_map.get("name") is not None and row[col_map["name"]] + else "" + ) + if not name: + row_errors.append("Name is required") + + project_str = ( + str(row[col_map["project"]]).strip() + if col_map.get("project") is not None + and row[col_map["project"]] + else "" + ) + if not project_str: + row_errors.append("Project is required") + + if row_errors: + errors.append(f"Row {row_idx}: {'; '.join(row_errors)}") + continue + + # Find project by name or prefix + project = Project.objects.filter(name=project_str).first() + if not project: + project = Project.objects.filter( + ticket_prefix=project_str + ).first() + if not project: + errors.append( + f"Row {row_idx}: Project '{project_str}' not found" + ) + continue + + # Find status by name within project + status = None + if col_map.get("status") is not None and row[col_map["status"]]: + status_str = str(row[col_map["status"]]).strip() + status = TicketStatus.objects.filter( + project=project, name__iexact=status_str + ).first() + if not status: + status = TicketStatus.objects.filter( + project=project + ).first() + if not status: + errors.append( + f"Row {row_idx}: No status found for project '{project.name}'" + ) + continue + + # Find priority by name + priority = None + if ( + col_map.get("priority") is not None + and row[col_map["priority"]] + ): + priority_str = str(row[col_map["priority"]]).strip() + priority = TicketPriority.objects.filter( + name__iexact=priority_str + ).first() + + # Find epic by name within project + epic = None + if col_map.get("epic") is not None and row[col_map["epic"]]: + epic_str = str(row[col_map["epic"]]).strip() + epic = Epic.objects.filter( + project=project, name__iexact=epic_str + ).first() + + # Parse dates + start_date = None + if ( + col_map.get("start date") is not None + and row[col_map["start date"]] + ): + try: + start_date = row[col_map["start date"]] + if hasattr(start_date, "date"): + start_date = start_date.date() + except (ValueError, TypeError): + pass + + due_date = None + if ( + col_map.get("due date") is not None + and row[col_map["due date"]] + ): + try: + due_date = row[col_map["due date"]] + if hasattr(due_date, "date"): + due_date = due_date.date() + except (ValueError, TypeError): + pass + + description = "" + if ( + col_map.get("description") is not None + and row[col_map["description"]] + ): + description = str(row[col_map["description"]]).strip() + + # Create ticket + ticket = Ticket.objects.create( + project=project, + status=status, + priority=priority, + epic=epic, + name=name, + description=description or None, + start_date=start_date, + due_date=due_date, + created_by=request.user, + ) + + # Add assignees + if ( + col_map.get("assignees") is not None + and row[col_map["assignees"]] + ): + assignees_str = str(row[col_map["assignees"]]).strip() + if assignees_str: + for part in assignees_str.split(","): + part = part.strip() + if not part: + continue + user = User.objects.filter( + email__iexact=part + ).first() + if not user: + user = User.objects.filter( + username__iexact=part + ).first() + if user: + TicketUser.objects.get_or_create( + ticket=ticket, user=user + ) + else: + errors.append( + f"Row {row_idx}: Assignee '{part}' not found" + ) + + created_count += 1 + except Exception as e: + errors.append(f"Row {row_idx}: {str(e)}") + + wb.close() + except Exception as e: + errors.append(f"File error: {str(e)}") + + result = {"created": created_count, "errors": errors} + + return render(request, "tickets/import.html", {"result": result}) + + +# ── Bulk Operations ──────────────────────────────────────────────────────── + + +@require_http_methods(["POST"]) +def tickets_bulk_status(request): + import json + + data = json.loads(request.body) + ticket_ids = data.get("ticket_ids", []) + status_id = data.get("status_id") + + if not ticket_ids or not status_id: + return JsonResponse( + {"success": False, "error": "Missing ticket_ids or status_id"}, status=400 + ) + + status = get_object_or_404(TicketStatus, pk=status_id) + tickets = Ticket.objects.filter(pk__in=ticket_ids).select_related("status") + + if request.user.role != "superadmin": + user_project_ids = request.user.projects.values_list("id", flat=True) + tickets = tickets.filter(project_id__in=user_project_ids) + + count = 0 + for ticket in tickets: + old_name = ticket.status.name + ticket.status = status + ticket.save(update_fields=["status", "updated_at"]) + + TicketHistory.objects.create( + ticket=ticket, + user=request.user, + status=status, + ) + + notify_users = list(ticket.assignees.all()) + if ticket.created_by and ticket.created_by not in notify_users: + notify_users.append(ticket.created_by) + + for u in notify_users: + Notification.objects.create( + user=u, + type="status_changed", + title=f"Ticket {ticket.uuid} status changed", + message=f"Status changed from {old_name} to {status.name} by {request.user.get_full_name() or request.user.username}", + data={"ticket_id": ticket.id, "ticket_uuid": ticket.uuid}, + ) + + count += 1 + + return JsonResponse({"success": True, "count": count}) + + +@require_http_methods(["POST"]) +def tickets_bulk_priority(request): + import json + + data = json.loads(request.body) + ticket_ids = data.get("ticket_ids", []) + priority_id = data.get("priority_id") + + if not ticket_ids or not priority_id: + return JsonResponse( + {"success": False, "error": "Missing ticket_ids or priority_id"}, status=400 + ) + + priority = get_object_or_404(TicketPriority, pk=priority_id) + tickets = Ticket.objects.filter(pk__in=ticket_ids) + + if request.user.role != "superadmin": + user_project_ids = request.user.projects.values_list("id", flat=True) + tickets = tickets.filter(project_id__in=user_project_ids) + + count = tickets.update(priority=priority, updated_at=timezone.now()) + + return JsonResponse({"success": True, "count": count}) + + +@require_http_methods(["POST"]) +def tickets_bulk_assign(request): + import json + + data = json.loads(request.body) + ticket_ids = data.get("ticket_ids", []) + user_id = data.get("user_id") + + if not ticket_ids or not user_id: + return JsonResponse( + {"success": False, "error": "Missing ticket_ids or user_id"}, status=400 + ) + + user_to_assign = get_object_or_404(User, pk=user_id, is_active=True) + tickets = Ticket.objects.filter(pk__in=ticket_ids) + + if request.user.role != "superadmin": + user_project_ids = request.user.projects.values_list("id", flat=True) + tickets = tickets.filter(project_id__in=user_project_ids) + + count = 0 + for ticket in tickets: + _, created = TicketUser.objects.get_or_create( + ticket=ticket, user=user_to_assign + ) + if created: + count += 1 + + return JsonResponse({"success": True, "count": count}) + + +@require_http_methods(["POST"]) +def tickets_bulk_epic(request): + import json + + data = json.loads(request.body) + ticket_ids = data.get("ticket_ids", []) + epic_id = data.get("epic_id") + + if not ticket_ids: + return JsonResponse( + {"success": False, "error": "Missing ticket_ids"}, status=400 + ) + + epic = None + if epic_id is not None: + epic = get_object_or_404(Epic, pk=epic_id) + + tickets = Ticket.objects.filter(pk__in=ticket_ids) + + if request.user.role != "superadmin": + user_project_ids = request.user.projects.values_list("id", flat=True) + tickets = tickets.filter(project_id__in=user_project_ids) + + count = 0 + for ticket in tickets: + ticket.epic = epic + ticket.save(update_fields=["epic", "updated_at"]) + count += 1 + + return JsonResponse({"success": True, "count": count}) + + +@require_http_methods(["POST"]) +def ticket_status_create(request): + project_id = request.POST.get("project_id") + project = get_object_or_404(Project, pk=project_id) + name = request.POST.get("name", "").strip() + color = request.POST.get("color", "#6B7280").strip() + sort_order = request.POST.get("sort_order", 0) + is_completed = request.POST.get("is_completed") == "on" + if name: + TicketStatus.objects.create( + project=project, + name=name, + color=color, + sort_order=sort_order, + is_completed=is_completed, + ) + messages.success(request, "Ticket status created.") + else: + messages.error(request, "Status name is required.") + return redirect("project-edit", project_id=project_id) + + +@require_http_methods(["POST"]) +def ticket_status_delete(request, status_id): + status = get_object_or_404(TicketStatus, pk=status_id) + project_id = status.project_id + status.delete() + messages.success(request, "Ticket status deleted.") + return redirect("project-edit", project_id=project_id) + + +@require_http_methods(["POST"]) +def ticket_statuses_bulk_delete(request): + ids = request.POST.getlist("ids") + project_id = request.POST.get("project_id") + if ids: + count = TicketStatus.objects.filter(id__in=ids, project_id=project_id).count() + TicketStatus.objects.filter(id__in=ids, project_id=project_id).delete() + messages.success(request, f"Deleted {count} status(es).") + else: + messages.warning(request, "No statuses selected.") + return redirect("project-edit", project_id=project_id) + + +@require_http_methods(["POST"]) +def ticket_status_edit(request, status_id): + status = get_object_or_404(TicketStatus, pk=status_id) + status.name = request.POST.get("name", status.name) + status.color = request.POST.get("color", status.color) + status.sort_order = request.POST.get("sort_order", status.sort_order) + status.is_completed = request.POST.get("is_completed") == "on" + status.save() + messages.success(request, "Ticket status updated.") + return redirect("project-edit", project_id=status.project_id) diff --git a/src/dashboard/page_views/user_views.py b/src/dashboard/page_views/user_views.py new file mode 100644 index 0000000..db0da7e --- /dev/null +++ b/src/dashboard/page_views/user_views.py @@ -0,0 +1,349 @@ +from django import forms +from django.contrib import messages +from django.contrib.auth import get_user_model +from django.core.paginator import Paginator +from django.db.models import Count, Q +from django.shortcuts import get_object_or_404, redirect, render +from django.views.decorators.http import require_http_methods + +from src.projects.models import Project, ProjectMember +from src.tickets.models import ( + Ticket, +) + +User = get_user_model() + +COLOR_PALETTE = [ + ("blue", "#3b82f6", "Blue"), + ("emerald", "#10b981", "Emerald"), + ("green", "#22c55e", "Green"), + ("indigo", "#6366f1", "Indigo"), + ("orange", "#f97316", "Orange"), + ("purple", "#a855f7", "Purple"), + ("red", "#ef4444", "Red"), + ("rose", "#f43f5e", "Rose"), + ("sky", "#0ea5e9", "Sky"), + ("teal", "#14b8a6", "Teal"), + ("violet", "#8b5cf6", "Violet"), + ("amber", "#f59e0b", "Amber"), + ("yellow", "#eab308", "Yellow"), + ("pink", "#ec4899", "Pink"), + ("cyan", "#06b6d4", "Cyan"), + ("lime", "#84cc16", "Lime"), + ("slate", "#64748b", "Slate"), + ("gray", "#6b7280", "Gray"), + ("zinc", "#71717a", "Zinc"), +] + +# ── Users List ──────────────────────────────────────────────────────────── + + +@require_http_methods(["GET"]) +def users_list(request): + if request.user.role != "superadmin": + messages.error(request, "Permission denied.") + return redirect("dashboard") + qs = ( + User.objects.filter(is_active=True) + .annotate( + project_count=Count("projects", distinct=True), + ticket_count=Count("created_tickets", distinct=True), + assigned_count=Count("assigned_tickets", distinct=True), + comment_count=Count("ticket_comments", distinct=True), + ) + .order_by("first_name") + ) + search = request.GET.get("search", "").strip() + has_projects = request.GET.get("has_projects") + has_assigned = request.GET.get("has_assigned") + has_created = request.GET.get("has_created") + role = request.GET.get("role") + unverified = request.GET.get("unverified") + per_page = int(request.GET.get("per_page", 10)) + columns = request.GET.getlist("columns") + + if search: + qs = qs.filter( + Q(first_name__icontains=search) + | Q(last_name__icontains=search) + | Q(email__icontains=search) + | Q(username__icontains=search) + ) + if has_projects: + qs = qs.filter(project_count__gt=0) + if has_assigned: + qs = qs.filter(assigned_count__gt=0) + if has_created: + qs = qs.filter(ticket_count__gt=0) + if role: + qs = qs.filter(role=role) + if unverified: + qs = qs.filter(is_active=False) + + paginator = Paginator(qs, per_page) + page_number = request.GET.get("page", 1) + page_obj = paginator.get_page(page_number) + + all_columns = [ + "name", + "email", + "roles", + "projects", + "assigned", + "created", + "joined", + ] + if not columns: + columns = all_columns[:] + + return render( + request, + "users/list.html", + { + "users": page_obj, + "search": search, + "has_projects": has_projects, + "has_assigned": has_assigned, + "has_created": has_created, + "role": role, + "unverified": unverified, + "roles": ["superadmin", "manager", "member", "guest"], + "roles_label": { + "superadmin": "Superadmin", + "manager": "Manager", + "member": "Member", + "guest": "Guest", + }, + "per_page": per_page, + "columns": columns, + "all_columns": all_columns, + "page_obj": page_obj, + }, + ) + + +# ── User Create ──────────────────────────────────────────────────────────── + + +@require_http_methods(["GET", "POST"]) +def user_create(request): + if request.user.role != "superadmin": + messages.error(request, "Permission denied.") + return redirect("dashboard") + from django.contrib.auth.forms import UserCreationForm + + UserModel = get_user_model() + + class CustomUserCreationForm(UserCreationForm): + class Meta(UserCreationForm.Meta): + model = UserModel + fields = ["username", "first_name", "last_name", "email", "profile_image"] + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + for f in self.visible_fields(): + f.field.widget.attrs["class"] = ( + "w-full text-sm border border-gray-200 dark:border-gray-700 rounded-lg px-3 py-2 bg-white dark:bg-gray-800 focus:outline-none focus:ring-2 focus:ring-blue-500" + ) + f.field.widget.attrs["placeholder"] = f.field.label + self.fields["profile_image"].widget.attrs["class"] = ( + "w-full text-sm border border-gray-200 dark:border-gray-700 rounded-lg px-3 py-2 bg-white dark:bg-gray-800 focus:outline-none focus:ring-2 focus:ring-blue-500 file:mr-3 file:py-1.5 file:px-3 file:rounded-lg file:border-0 file:text-xs file:font-medium file:bg-blue-50 file:text-blue-700 hover:file:bg-blue-100 dark:file:bg-blue-900/20 dark:file:text-blue-400" + ) + self.fields["profile_image"].required = False + + if request.method == "POST": + form = CustomUserCreationForm(request.POST, request.FILES) + if form.is_valid(): + user = form.save() + user.is_active = True + if request.user.role == "superadmin": + role = request.POST.get("role", "member") + user.role = role + user.save() + messages.success( + request, + f"User '{user.get_full_name() or user.username}' created successfully.", + ) + return redirect("users-list") + else: + form = CustomUserCreationForm() + + return render( + request, + "users/form.html", + { + "form": form, + "roles": ["superadmin", "manager", "member", "guest"], + "roles_label": { + "superadmin": "Superadmin", + "manager": "Manager", + "member": "Member", + "guest": "Guest", + }, + "can_change_role": request.user.role == "superadmin", + }, + ) + + +# ── User Detail ──────────────────────────────────────────────────────────── + + +def user_detail(request, user_id): + UserModel = get_user_model() + u = get_object_or_404(UserModel, id=user_id) + role = u.role + project_count = Project.objects.filter(members=u).count() + assigned_count = Ticket.objects.filter(assignees=u).count() + created_count = Ticket.objects.filter(created_by=u).count() + return render( + request, + "users/detail.html", + { + "u": u, + "role": role, + "roles_label": { + "superadmin": "Superadmin", + "manager": "Manager", + "member": "Member", + "guest": "Guest", + }, + "projects_count": project_count, + "assigned_count": assigned_count, + "created_count": created_count, + }, + ) + + +# ── User Edit ────────────────────────────────────────────────────────────── + + +@require_http_methods(["GET", "POST"]) +def user_edit(request, user_id): + if request.user.role != "superadmin": + messages.error(request, "Permission denied.") + return redirect("dashboard") + UserModel = get_user_model() + user_obj = get_object_or_404(UserModel, id=user_id) + + class UserEditForm(forms.ModelForm): + class Meta: + model = UserModel + fields = [ + "username", + "first_name", + "last_name", + "email", + "is_active", + "profile_image", + ] + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + for f in self.visible_fields(): + f.field.widget.attrs["class"] = ( + "w-full text-sm border border-gray-200 dark:border-gray-700 rounded-lg px-3 py-2 bg-white dark:bg-gray-800 focus:outline-none focus:ring-2 focus:ring-blue-500" + ) + f.field.widget.attrs["placeholder"] = f.field.label + self.fields["profile_image"].widget.attrs["class"] = ( + "w-full text-sm border border-gray-200 dark:border-gray-700 rounded-lg px-3 py-2 bg-white dark:bg-gray-800 focus:outline-none focus:ring-2 focus:ring-blue-500 file:mr-3 file:py-1.5 file:px-3 file:rounded-lg file:border-0 file:text-xs file:font-medium file:bg-blue-50 file:text-blue-700 hover:file:bg-blue-100 dark:file:bg-blue-900/20 dark:file:text-blue-400" + ) + self.fields["profile_image"].required = False + + if request.method == "POST": + form = UserEditForm(request.POST, request.FILES, instance=user_obj) + if form.is_valid(): + user_obj = form.save() + if request.user.role == "superadmin": + role = request.POST.get("role", "member") + user_obj.role = role + user_obj.save() + messages.success( + request, + f"User '{user_obj.get_full_name() or user_obj.username}' updated.", + ) + return redirect("users-list") + else: + form = UserEditForm(instance=user_obj) + + current_role = user_obj.role + + project_search = request.GET.get("project_search", "").strip() + try: + proj_per_page = int(request.GET.get("proj_per_page", 10)) + except ValueError: + proj_per_page = 10 + + memberships_qs = ( + ProjectMember.objects.filter(user=user_obj) + .select_related("project") + .prefetch_related("project__members") + .annotate( + ticket_count=Count("project__tickets"), + member_count=Count("project__members"), + ) + ) + if project_search: + memberships_qs = memberships_qs.filter(project__name__icontains=project_search) + + proj_paginator = Paginator(memberships_qs, proj_per_page) + proj_page = proj_paginator.get_page(request.GET.get("proj_page", 1)) + + existing_project_ids = set(memberships_qs.values_list("project_id", flat=True)) + available_projects = Project.objects.exclude(id__in=existing_project_ids).order_by( + "name" + ) + + return render( + request, + "users/form.html", + { + "form": form, + "editing": True, + "user_obj": user_obj, + "current_role": current_role, + "roles": ["superadmin", "manager", "member", "guest"], + "roles_label": { + "superadmin": "Superadmin", + "manager": "Manager", + "member": "Member", + "guest": "Guest", + }, + "can_change_role": request.user.role == "superadmin", + "user_memberships": proj_page, + "proj_page_obj": proj_page, + "project_search": project_search, + "proj_per_page": proj_per_page, + "available_projects": available_projects, + }, + ) + + +@require_http_methods(["POST"]) +def user_project_attach(request): + user_id = request.POST.get("user_id") + project_id = request.POST.get("project_id") + user = get_object_or_404(User, pk=user_id) + project = get_object_or_404(Project, pk=project_id) + ProjectMember.objects.get_or_create(project=project, user=user) + messages.success( + request, + f"Project '{project.name}' attached to user '{user.get_full_name() or user.username}'.", + ) + response = redirect("user-edit", user_id=user_id) + if request.POST.get("create_another"): + response["Location"] += "?open_attach=1" + return response + + +@require_http_methods(["POST"]) +def user_project_members_bulk_delete(request): + user_id = request.POST.get("user_id") + member_ids = request.POST.getlist("member_ids") + user = get_object_or_404(User, pk=user_id) + if member_ids: + count = ProjectMember.objects.filter(id__in=member_ids, user=user).count() + ProjectMember.objects.filter(id__in=member_ids, user=user).delete() + messages.success(request, f"Detached {count} project(s).") + else: + messages.warning(request, "No projects selected.") + return redirect("user-edit", user_id=user_id) diff --git a/src/dashboard/views/__init__.py b/src/dashboard/views/__init__.py new file mode 100644 index 0000000..0482e63 --- /dev/null +++ b/src/dashboard/views/__init__.py @@ -0,0 +1,4 @@ +from .activity import * +from .charts import * +from .dashboard import * +from .timeline import * diff --git a/src/dashboard/views/activity.py b/src/dashboard/views/activity.py new file mode 100644 index 0000000..6de586e --- /dev/null +++ b/src/dashboard/views/activity.py @@ -0,0 +1,99 @@ +from django.contrib.auth import get_user_model +from django.core.paginator import Paginator +from django.db.models import Q +from django.shortcuts import render +from django.utils import timezone +from django.views.decorators.http import require_http_methods + +from src.tickets.models import TicketHistory, TicketStatus + +User = get_user_model() + + +@require_http_methods(["GET"]) +def recent_activity(request): + user = request.user + is_super = user.role in ["superadmin", "manager"] + + qs = TicketHistory.objects.select_related( + "ticket", "user", "status", "ticket__project" + ) + if not is_super: + qs = qs.filter(ticket__project__members=user) + + qs = qs.order_by("-created_at")[:5] + + return render( + request, + "dashboard/partials/recent_activity.html", + { + "histories": qs, + "statuses": TicketStatus.objects.all(), + "users": User.objects.filter(is_active=True), + }, + ) + + +@require_http_methods(["GET"]) +def recent_activity_all(request): + user = request.user + is_super = user.role in ["superadmin", "manager"] + + qs = TicketHistory.objects.select_related( + "ticket", "user", "status", "ticket__project" + ) + if not is_super: + qs = qs.filter(ticket__project__members=user) + + start_date = request.GET.get("start_date", "") + end_date = request.GET.get("end_date", "") + today_filter = request.GET.get("today") + user_filter = request.GET.get("user", "") + search_query = request.GET.get("search", "").strip() + + if today_filter: + qs = qs.filter(created_at__date=timezone.now().date()) + else: + if start_date: + qs = qs.filter(created_at__date__gte=start_date) + if end_date: + qs = qs.filter(created_at__date__lte=end_date) + + if user_filter: + qs = qs.filter(user_id=user_filter) + + if search_query: + qs = qs.filter( + Q(ticket__name__icontains=search_query) + | Q(user__username__icontains=search_query) + | Q(user__first_name__icontains=search_query) + | Q(user__last_name__icontains=search_query) + ) + + qs = qs.order_by("-created_at") + + try: + per_page = int(request.GET.get("per_page", 20)) + except ValueError: + per_page = 20 + + paginator = Paginator(qs, per_page) + page_number = request.GET.get("page", 1) + page_obj = paginator.get_page(page_number) + + return render( + request, + "dashboard/recent_activity_all.html", + { + "histories": page_obj, + "page_obj": page_obj, + "statuses": TicketStatus.objects.all(), + "users": User.objects.filter(is_active=True), + "start_date": start_date, + "end_date": end_date, + "today_filter": today_filter, + "user_filter": user_filter, + "search_query": search_query, + "per_page": per_page, + }, + ) diff --git a/src/dashboard/views/charts.py b/src/dashboard/views/charts.py new file mode 100644 index 0000000..d90d604 --- /dev/null +++ b/src/dashboard/views/charts.py @@ -0,0 +1,150 @@ +import json +from datetime import date, datetime + +from django.contrib.auth import get_user_model +from django.db.models import Count +from django.http import JsonResponse +from django.shortcuts import render +from django.utils import timezone +from django.views.decorators.http import require_http_methods + +from src.projects.models import Project +from src.tickets.models import Ticket + +User = get_user_model() + + +@require_http_methods(["GET"]) +def tickets_per_project_chart(request): + user = request.user + is_super = user.role in ["superadmin", "manager"] + + qs = Project.objects.annotate(count=Count("tickets")).order_by("name") + if not is_super: + qs = qs.filter(members=user) + + base_colors = [ + "#3B82F6", + "#10B981", + "#F59E0B", + "#EF4444", + "#8B5CF6", + "#06B6D4", + "#F97316", + "#84CC16", + "#EC4899", + "#6B7280", + ] + data = list(qs.values("name", "count")) + max_count = max((d["count"] for d in data), default=1) + for i, d in enumerate(data): + d["color"] = base_colors[i % len(base_colors)] + d["pct"] = round(d["count"] / max_count * 100, 1) if max_count else 0 + + return render( + request, + "dashboard/partials/tickets_per_project_chart.html", + { + "chart_data": data, + }, + ) + + +@require_http_methods(["GET"]) +def user_statistics_data(request): + user = request.user + is_super = user.role in ["superadmin", "manager"] + + users_qs = User.objects.annotate( + project_count=Count("projects", distinct=True), + assigned_count=Count("assigned_tickets", distinct=True), + ) + if not is_super: + users_qs = users_qs.filter(id=user.id) + users_qs = users_qs.order_by("first_name")[:10] + + return JsonResponse( + { + "labels": [u.get_full_name() or u.username for u in users_qs], + "projects": [u.project_count for u in users_qs], + "assigned": [u.assigned_count for u in users_qs], + } + ) + + +@require_http_methods(["GET"]) +def user_statistics_chart(request): + return render(request, "dashboard/partials/user_statistics_chart.html") + + +@require_http_methods(["GET"]) +def monthly_trend_chart(request): + user = request.user + is_super = user.role in ["superadmin", "manager"] + + earliest = Ticket.objects.all() + if not is_super: + earliest = earliest.filter(project__members=user) + + earliest_ticket = earliest.order_by("created_at").first() + + months = [] + data = [] + + if earliest_ticket: + start = earliest_ticket.created_at.date().replace(day=1) + end = timezone.now().date().replace(day=1) + cur = start + while cur <= end: + months.append( + {"year": cur.year, "month": cur.month, "label": cur.strftime("%b %Y")} + ) + if cur.month == 12: + cur = cur.replace(year=cur.year + 1, month=1) + else: + cur = cur.replace(month=cur.month + 1) + else: + for i in range(5, -1, -1): + m = timezone.now().month - i + y = timezone.now().year + while m < 1: + m += 12 + y -= 1 + months.append( + {"year": y, "month": m, "label": date(y, m, 1).strftime("%b %Y")} + ) + + qs = Ticket.objects + if not is_super: + qs = qs.filter(project__members=user) + + tz = timezone.get_current_timezone() + for m in months: + month_start = timezone.make_aware( + datetime(m["year"], m["month"], 1), timezone=tz + ) + if m["month"] == 12: + month_end = timezone.make_aware(datetime(m["year"] + 1, 1, 1), timezone=tz) + else: + month_end = timezone.make_aware( + datetime(m["year"], m["month"] + 1, 1), timezone=tz + ) + + count = qs.filter( + created_at__year=m["year"], + created_at__month=m["month"], + ).count() + completed = qs.filter( + status__is_completed=True, + updated_at__gte=month_start, + updated_at__lt=month_end, + ).count() + data.append({"label": m["label"], "count": count, "completed": completed}) + + return render( + request, + "dashboard/partials/monthly_trend_chart.html", + { + "chart_data": json.dumps(data), + }, + ) diff --git a/src/dashboard/views/dashboard.py b/src/dashboard/views/dashboard.py new file mode 100644 index 0000000..d2abaa5 --- /dev/null +++ b/src/dashboard/views/dashboard.py @@ -0,0 +1,364 @@ +from datetime import timedelta + +from django.contrib.auth import get_user_model +from django.core.cache import cache +from django.shortcuts import render +from django.utils import timezone +from django.views.decorators.http import require_http_methods + +from src.notifications.email_utils import process_deadline_reminders +from src.projects.models import Project +from src.tickets.models import Ticket + +User = get_user_model() + + +def dashboard(request): + user = request.user + now = timezone.now() + today = now.date() + week_start = now.replace(hour=0, minute=0, second=0, microsecond=0) - timedelta( + days=now.weekday() + ) + + is_super = user.role in ["superadmin", "manager"] + + if is_super: + total_projects = Project.objects.count() + total_tickets = Ticket.objects.count() + my_tickets = Ticket.objects.filter(assignees=user).count() + team_members = User.objects.count() + stats = [ + { + "label": "Total Projects", + "value": total_projects, + "desc": "Active projects in the system", + "icon": "fa-layer-group", + "color": "primary", + "super": True, + }, + { + "label": "Total Tickets", + "value": total_tickets, + "desc": "Tickets across all projects", + "icon": "fa-ticket", + "color": "success", + "super": True, + }, + { + "label": "My Assigned Tickets", + "value": my_tickets, + "desc": "Tickets assigned to you", + "icon": "fa-user-circle", + "color": "info", + "super": True, + }, + { + "label": "Team Members", + "value": team_members, + "desc": "Registered users", + "icon": "fa-users", + "color": "gray", + "super": True, + }, + ] + else: + my_projects = Project.objects.filter(members=user).count() + my_project_ids = Project.objects.filter(members=user).values_list( + "id", flat=True + ) + project_tickets = Ticket.objects.filter(project_id__in=my_project_ids).count() + my_assigned = Ticket.objects.filter(assignees=user).count() + my_created = Ticket.objects.filter(created_by=user).count() + + new_this_week = Ticket.objects.filter( + project_id__in=my_project_ids, + created_at__gte=week_start, + ).count() + + my_overdue = Ticket.objects.filter( + assignees=user, + due_date__lt=today, + status__is_completed=False, + ).count() + + my_completed_this_week = Ticket.objects.filter( + assignees=user, + status__is_completed=True, + updated_at__gte=week_start, + ).count() + + team_members = ( + User.objects.filter(project_memberships__project__members=user) + .exclude(id=user.id) + .distinct() + .count() + ) + + assigned_color = "gray" + if my_assigned > 10: + assigned_color = "danger" + elif my_assigned > 5: + assigned_color = "warning" + else: + assigned_color = "success" + + completed_color = "success" if my_completed_this_week > 0 else "gray" + overdue_color = "danger" if my_overdue > 0 else "success" + + stats = [ + { + "label": "My Projects", + "value": my_projects, + "desc": "Projects you are member of", + "icon": "fa-layer-group", + "color": "primary", + }, + { + "label": "My Assigned Tickets", + "value": my_assigned, + "desc": "Tickets assigned to you", + "icon": "fa-user-circle", + "color": assigned_color, + }, + { + "label": "My Created Tickets", + "value": my_created, + "desc": "Tickets you created", + "icon": "fa-pen-square", + "color": "info", + }, + { + "label": "Project Tickets", + "value": project_tickets, + "desc": "Total tickets in your projects", + "icon": "fa-ticket", + "color": "success", + }, + { + "label": "Completed This Week", + "value": my_completed_this_week, + "desc": "Your completed tickets", + "icon": "fa-check-circle", + "color": completed_color, + }, + { + "label": "New Tasks This Week", + "value": new_this_week, + "desc": "Created in your projects", + "icon": "fa-plus-circle", + "color": "info", + }, + { + "label": "My Overdue Tasks", + "value": my_overdue, + "desc": "Your past due tickets", + "icon": "fa-exclamation-triangle", + "color": overdue_color, + }, + { + "label": "Team Members", + "value": team_members, + "desc": "People in your projects", + "icon": "fa-users", + "color": "gray", + }, + ] + + # ── Deadline Reminder Check (signal-driven / dashboard-triggered) ───── + # Avoid running on every HTMX dashboard reload; throttle to once per hour. + reminder_cache_key = "deadline_reminders_processed_at" + last_run = cache.get(reminder_cache_key) + now_ts = timezone.now().timestamp() + if not last_run or (now_ts - float(last_run)) >= 3600: + process_deadline_reminders() + cache.set(reminder_cache_key, str(now_ts), timeout=3600) + + import random + + quotes = [ + "The only way to do great work is to love what you do. — Steve Jobs", + "Quality is not an act, it is a habit. — Aristotle", + "Action is the foundational key to all success. — Pablo Picasso", + "Strive not to be a success, but rather to be of value. — Albert Einstein", + "The secret of getting ahead is getting started. — Mark Twain", + "It always seems impossible until it's done. — Nelson Mandela", + "Focus on being productive instead of busy. — Tim Ferriss", + "Productivity is being able to do things that you were never able to do before. — Franz Kafka", + "Good planning without action is just a dream. — Unknown", + "Believe you can and you're halfway there. — Theodore Roosevelt", + ] + random_quote = random.choice(quotes) + + return render( + request, "dashboard/index.html", {"stats": stats, "quote": random_quote} + ) + + +@require_http_methods(["GET"]) +def stats_cards(request): + user = request.user + now = timezone.now() + today = now.date() + week_start = now.replace(hour=0, minute=0, second=0, microsecond=0) - timedelta( + days=now.weekday() + ) + + is_super = user.role in ["superadmin", "manager"] + + if is_super: + total_projects = Project.objects.count() + total_tickets = Ticket.objects.count() + my_tickets = Ticket.objects.filter(assignees=user).count() + team_members = User.objects.count() + + return render( + request, + "dashboard/partials/stats_cards.html", + { + "stats": [ + { + "label": "Total Projects", + "value": total_projects, + "desc": "Active projects in the system", + "icon": "fa-layer-group", + "color": "primary", + "super": True, + }, + { + "label": "Total Tickets", + "value": total_tickets, + "desc": "Tickets across all projects", + "icon": "fa-ticket", + "color": "success", + "super": True, + }, + { + "label": "My Assigned Tickets", + "value": my_tickets, + "desc": "Tickets assigned to you", + "icon": "fa-user-circle", + "color": "info", + "super": True, + }, + { + "label": "Team Members", + "value": team_members, + "desc": "Registered users", + "icon": "fa-users", + "color": "gray", + "super": True, + }, + ], + "is_superuser": True, + }, + ) + else: + my_projects = Project.objects.filter(members=user).count() + my_project_ids = Project.objects.filter(members=user).values_list( + "id", flat=True + ) + project_tickets = Ticket.objects.filter(project_id__in=my_project_ids).count() + my_assigned = Ticket.objects.filter(assignees=user).count() + my_created = Ticket.objects.filter(created_by=user).count() + + new_this_week = Ticket.objects.filter( + project_id__in=my_project_ids, + created_at__gte=week_start, + ).count() + + my_overdue = Ticket.objects.filter( + assignees=user, + due_date__lt=today, + status__is_completed=False, + ).count() + + my_completed_this_week = Ticket.objects.filter( + assignees=user, + status__is_completed=True, + updated_at__gte=week_start, + ).count() + + team_members = ( + User.objects.filter(project_memberships__project__members=user) + .exclude(id=user.id) + .distinct() + .count() + ) + + assigned_color = "gray" + if my_assigned > 10: + assigned_color = "danger" + elif my_assigned > 5: + assigned_color = "warning" + else: + assigned_color = "success" + + completed_color = "success" if my_completed_this_week > 0 else "gray" + overdue_color = "danger" if my_overdue > 0 else "success" + + return render( + request, + "dashboard/partials/stats_cards.html", + { + "stats": [ + { + "label": "My Projects", + "value": my_projects, + "desc": "Projects you are member of", + "icon": "fa-layer-group", + "color": "primary", + }, + { + "label": "My Assigned Tickets", + "value": my_assigned, + "desc": "Tickets assigned to you", + "icon": "fa-user-circle", + "color": assigned_color, + }, + { + "label": "My Created Tickets", + "value": my_created, + "desc": "Tickets you created", + "icon": "fa-pen-square", + "color": "info", + }, + { + "label": "Project Tickets", + "value": project_tickets, + "desc": "Total tickets in your projects", + "icon": "fa-ticket", + "color": "success", + }, + { + "label": "Completed This Week", + "value": my_completed_this_week, + "desc": "Your completed tickets", + "icon": "fa-check-circle", + "color": completed_color, + }, + { + "label": "New Tasks This Week", + "value": new_this_week, + "desc": "Created in your projects", + "icon": "fa-plus-circle", + "color": "info", + }, + { + "label": "My Overdue Tasks", + "value": my_overdue, + "desc": "Your past due tickets", + "icon": "fa-exclamation-triangle", + "color": overdue_color, + }, + { + "label": "Team Members", + "value": team_members, + "desc": "People in your projects", + "icon": "fa-users", + "color": "gray", + }, + ], + "is_superuser": False, + }, + ) diff --git a/src/dashboard/views/timeline.py b/src/dashboard/views/timeline.py new file mode 100644 index 0000000..69ca216 --- /dev/null +++ b/src/dashboard/views/timeline.py @@ -0,0 +1,114 @@ +from datetime import date + +from django.contrib.auth import get_user_model +from django.shortcuts import render +from django.views.decorators.http import require_http_methods + +from src.projects.models import Project + +User = get_user_model() + + +@require_http_methods(["GET"]) +def project_timeline_widget(request): + filter_type = request.GET.get("filter", "pinned") + user = request.user + is_super = user.role in ["superadmin", "manager"] + + qs = Project.objects.filter(start_date__isnull=False, end_date__isnull=False) + if request.user.role == "member": + qs = qs.filter(members=request.user) + if not is_super: + qs = qs.filter(members=user) + + pinned_count = qs.filter(pinned_date__isnull=False).count() + all_count = qs.count() + + if filter_type == "pinned": + qs = qs.filter(pinned_date__isnull=False).order_by("-pinned_date") + else: + qs = qs.order_by("start_date") + + today = date.today() + timeline_data = [] + + for p in qs.select_related(): + if not p.start_date or not p.end_date: + continue + total_days = (p.end_date - p.start_date).days or 1 + elapsed = (today - p.start_date).days + progress = max(0, min(100, int(elapsed / total_days * 100))) + remaining_days = (p.end_date - today).days + + if today > p.end_date: + status = "Completed" + status_color = "success" + elif remaining_days < 0: + status = "Overdue" + status_color = "danger" + elif remaining_days <= 7: + status = "Approaching Deadline" + status_color = "warning" + elif today < p.start_date: + status = "Not Started" + status_color = "gray" + else: + status = "In Progress" + status_color = "primary" + + past_days = max(0, elapsed) + completed_text = ( + f"{past_days} day{'s' if past_days != 1 else ''} completed" + if past_days > 0 + else "" + ) + + if remaining_days > 0: + remaining_text = ( + f"{remaining_days} day{'s' if remaining_days != 1 else ''} remaining" + ) + elif remaining_days < 0: + remaining_text = f"{abs(remaining_days)} day{'s' if abs(remaining_days) != 1 else ''} overdue" + else: + remaining_text = "Due today" + + ticket_counts = { + "total": p.tickets.count(), + "completed": p.tickets.filter(status__is_completed=True).count(), + "overdue": p.tickets.filter(due_date__lt=today) + .exclude(status__is_completed=True) + .count(), + } + + timeline_data.append( + { + "id": p.id, + "name": p.name, + "description": p.description, + "start_date": p.start_date, + "end_date": p.end_date, + "total_days": total_days, + "past_days": past_days, + "remaining_days": remaining_days, + "progress": progress, + "status": status, + "status_color": status_color, + "completed_text": completed_text, + "remaining_text": remaining_text, + "ticket_counts": ticket_counts, + "pinned": p.pinned_date is not None, + } + ) + + timeline_data.sort(key=lambda x: x["start_date"]) + + return render( + request, + "dashboard/partials/project_timeline.html", + { + "projects": timeline_data, + "current_filter": filter_type, + "pinned_count": pinned_count, + "all_count": all_count, + }, + ) diff --git a/src/epics/admin.py b/src/epics/admin.py index 0dc5f91..bbc1591 100644 --- a/src/epics/admin.py +++ b/src/epics/admin.py @@ -1,5 +1,10 @@ -"""generated with djinit""" - from django.contrib import admin -# Register your models here. \ No newline at end of file +from src.epics.models import Epic + + +@admin.register(Epic) +class EpicAdmin(admin.ModelAdmin): + list_display = ("id", "name", "project", "start_date", "end_date", "sort_order") + list_filter = ("project",) + search_fields = ("name", "project__name") diff --git a/src/epics/apps.py b/src/epics/apps.py index f32b3dc..7eab122 100644 --- a/src/epics/apps.py +++ b/src/epics/apps.py @@ -1,7 +1,6 @@ from django.apps import AppConfig - class EpicsConfig(AppConfig): - default_auto_field = 'django.db.models.BigAutoField' - name = 'src.epics' \ No newline at end of file + default_auto_field = "django.db.models.BigAutoField" + name = "src.epics" diff --git a/src/epics/migrations/0001_initial.py b/src/epics/migrations/0001_initial.py new file mode 100644 index 0000000..7605cbe --- /dev/null +++ b/src/epics/migrations/0001_initial.py @@ -0,0 +1,50 @@ +# Generated by Django 6.0.6 on 2026-06-28 07:26 + +import django.db.models.deletion +from django.db import migrations, models + + +class Migration(migrations.Migration): + initial = True + + dependencies = [ + ("projects", "0001_initial"), + ] + + operations = [ + migrations.CreateModel( + name="Epic", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ("name", models.CharField(max_length=255)), + ("description", models.TextField(blank=True, null=True)), + ("start_date", models.DateField(blank=True, null=True)), + ("end_date", models.DateField(blank=True, null=True)), + ("sort_order", models.IntegerField(default=0)), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ( + "project", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="epics", + to="projects.project", + ), + ), + ], + options={ + "verbose_name": "Epic", + "verbose_name_plural": "Epics", + "db_table": "epics", + "ordering": ("sort_order",), + }, + ), + ] diff --git a/src/epics/models.py b/src/epics/models.py index d7b9f75..52b3c7a 100644 --- a/src/epics/models.py +++ b/src/epics/models.py @@ -1,5 +1,23 @@ -"""generated with djinit""" - from django.db import models -# Create your models here. \ No newline at end of file + +class Epic(models.Model): + project = models.ForeignKey( + "projects.Project", on_delete=models.CASCADE, related_name="epics" + ) + name = models.CharField(max_length=255) + description = models.TextField(blank=True, null=True) + start_date = models.DateField(blank=True, null=True) + end_date = models.DateField(blank=True, null=True) + sort_order = models.IntegerField(default=0) + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "epics" + verbose_name = "Epic" + verbose_name_plural = "Epics" + ordering = ("sort_order",) + + def __str__(self): + return f"[{self.project.ticket_prefix}] {self.name}" diff --git a/src/epics/serializers.py b/src/epics/serializers.py index fbcbed8..71e413c 100644 --- a/src/epics/serializers.py +++ b/src/epics/serializers.py @@ -1,5 +1,26 @@ -"""generated with djinit""" - from rest_framework import serializers -# Create your serializers here. \ No newline at end of file +from src.epics.models import Epic + + +class EpicSerializer(serializers.ModelSerializer): + ticket_count = serializers.SerializerMethodField() + + class Meta: + model = Epic + fields = ( + "id", + "project", + "name", + "description", + "start_date", + "end_date", + "sort_order", + "ticket_count", + "created_at", + "updated_at", + ) + read_only_fields = ("id", "created_at", "updated_at") + + def get_ticket_count(self, obj): + return obj.tickets.count() diff --git a/src/epics/tests.py b/src/epics/tests.py index a8b0ed1..337a402 100644 --- a/src/epics/tests.py +++ b/src/epics/tests.py @@ -1,5 +1,4 @@ """generated with djinit""" -from django.test import TestCase -# Create your tests here. \ No newline at end of file +# Create your tests here. diff --git a/src/epics/urls.py b/src/epics/urls.py index 8020533..6a2c010 100644 --- a/src/epics/urls.py +++ b/src/epics/urls.py @@ -1,7 +1,8 @@ -"""generated with djinit""" - from django.urls import path +from src.epics import views + urlpatterns = [ - # Add your URL patterns here -] \ No newline at end of file + path("", views.EpicListCreateView.as_view(), name="epic-list"), + path("/", views.EpicDetailView.as_view(), name="epic-detail"), +] diff --git a/src/epics/views.py b/src/epics/views.py index 6630beb..712abc6 100644 --- a/src/epics/views.py +++ b/src/epics/views.py @@ -1,5 +1,22 @@ -"""generated with djinit""" +from rest_framework import generics, permissions -from rest_framework import viewsets +from src.epics.models import Epic +from src.epics.serializers import EpicSerializer -# Create your views here. \ No newline at end of file + +class EpicListCreateView(generics.ListCreateAPIView): + serializer_class = EpicSerializer + permission_classes = (permissions.IsAuthenticated,) + + def get_queryset(self): + qs = Epic.objects.all() + project_id = self.request.query_params.get("project") + if project_id: + qs = qs.filter(project_id=project_id) + return qs + + +class EpicDetailView(generics.RetrieveUpdateDestroyAPIView): + queryset = Epic.objects.all() + serializer_class = EpicSerializer + permission_classes = (permissions.IsAuthenticated,) diff --git a/src/external/admin.py b/src/external/admin.py index 0dc5f91..e5e9c5f 100644 --- a/src/external/admin.py +++ b/src/external/admin.py @@ -1,5 +1,9 @@ -"""generated with djinit""" - from django.contrib import admin -# Register your models here. \ No newline at end of file +from src.external.models import ExternalAccess + + +@admin.register(ExternalAccess) +class ExternalAccessAdmin(admin.ModelAdmin): + list_display = ("id", "project", "access_token", "is_active", "last_accessed_at") + list_filter = ("is_active", "project") diff --git a/src/external/apps.py b/src/external/apps.py index 1b19bf1..924521e 100644 --- a/src/external/apps.py +++ b/src/external/apps.py @@ -1,7 +1,6 @@ from django.apps import AppConfig - class ExternalConfig(AppConfig): - default_auto_field = 'django.db.models.BigAutoField' - name = 'src.external' \ No newline at end of file + default_auto_field = "django.db.models.BigAutoField" + name = "src.external" diff --git a/src/external/migrations/0001_initial.py b/src/external/migrations/0001_initial.py new file mode 100644 index 0000000..9ffaea1 --- /dev/null +++ b/src/external/migrations/0001_initial.py @@ -0,0 +1,63 @@ +# Generated by Django 6.0.6 on 2026-06-28 07:26 + +import django.db.models.deletion +from django.db import migrations, models + +import src.external.models + + +class Migration(migrations.Migration): + initial = True + + dependencies = [ + ("projects", "0001_initial"), + ] + + operations = [ + migrations.CreateModel( + name="ExternalAccess", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ( + "access_token", + models.CharField( + default=src.external.models.generate_access_token, + max_length=255, + unique=True, + ), + ), + ( + "password", + models.CharField( + default=src.external.models.generate_access_password, + max_length=255, + ), + ), + ("is_active", models.BooleanField(default=True)), + ("last_accessed_at", models.DateTimeField(blank=True, null=True)), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ( + "project", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="external_accesses", + to="projects.project", + ), + ), + ], + options={ + "verbose_name": "External Access", + "verbose_name_plural": "External Accesses", + "db_table": "external_access", + }, + ), + ] diff --git a/src/external/models.py b/src/external/models.py index d7b9f75..a2eab0c 100644 --- a/src/external/models.py +++ b/src/external/models.py @@ -1,5 +1,36 @@ -"""generated with djinit""" +import secrets +import string from django.db import models -# Create your models here. \ No newline at end of file + +def generate_access_token(): + return secrets.token_hex(16) + + +def generate_access_password(): + return "".join( + secrets.choice(string.ascii_letters + string.digits) for _ in range(8) + ) + + +class ExternalAccess(models.Model): + project = models.ForeignKey( + "projects.Project", on_delete=models.CASCADE, related_name="external_accesses" + ) + access_token = models.CharField( + max_length=255, unique=True, default=generate_access_token + ) + password = models.CharField(max_length=255, default=generate_access_password) + is_active = models.BooleanField(default=True) + last_accessed_at = models.DateTimeField(blank=True, null=True) + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "external_access" + verbose_name = "External Access" + verbose_name_plural = "External Accesses" + + def __str__(self): + return f"ExternalAccess for {self.project.name}" diff --git a/src/external/serializers.py b/src/external/serializers.py index fbcbed8..df5d8c9 100644 --- a/src/external/serializers.py +++ b/src/external/serializers.py @@ -1,5 +1,37 @@ -"""generated with djinit""" - from rest_framework import serializers -# Create your serializers here. \ No newline at end of file +from src.external.models import ExternalAccess + + +class ExternalAccessSerializer(serializers.ModelSerializer): + class Meta: + model = ExternalAccess + fields = ( + "id", + "project", + "access_token", + "password", + "is_active", + "last_accessed_at", + "created_at", + "updated_at", + ) + read_only_fields = ( + "id", + "access_token", + "password", + "last_accessed_at", + "created_at", + "updated_at", + ) + + +class ExternalLoginSerializer(serializers.Serializer): + token = serializers.CharField() + password = serializers.CharField() + + +class ExternalAccessCreateSerializer(serializers.ModelSerializer): + class Meta: + model = ExternalAccess + fields = ("project", "is_active") diff --git a/src/external/tests.py b/src/external/tests.py index a8b0ed1..337a402 100644 --- a/src/external/tests.py +++ b/src/external/tests.py @@ -1,5 +1,4 @@ """generated with djinit""" -from django.test import TestCase -# Create your tests here. \ No newline at end of file +# Create your tests here. diff --git a/src/external/urls.py b/src/external/urls.py index 8020533..4b0167f 100644 --- a/src/external/urls.py +++ b/src/external/urls.py @@ -1,7 +1,9 @@ -"""generated with djinit""" - from django.urls import path +from src.external import views + urlpatterns = [ - # Add your URL patterns here -] \ No newline at end of file + path("", views.ExternalAccessListCreateView.as_view(), name="external-list"), + path("login/", views.external_login_view, name="external-login"), + path("/", views.ExternalAccessDetailView.as_view(), name="external-detail"), +] diff --git a/src/external/views.py b/src/external/views.py index 6630beb..995b35c 100644 --- a/src/external/views.py +++ b/src/external/views.py @@ -1,5 +1,67 @@ -"""generated with djinit""" +from django.utils import timezone +from rest_framework import generics, permissions, status +from rest_framework.decorators import api_view, permission_classes +from rest_framework.response import Response -from rest_framework import viewsets +from src.external.models import ExternalAccess +from src.external.serializers import ( + ExternalAccessCreateSerializer, + ExternalAccessSerializer, + ExternalLoginSerializer, +) -# Create your views here. \ No newline at end of file + +class ExternalAccessListCreateView(generics.ListCreateAPIView): + permission_classes = (permissions.IsAuthenticated,) + + def get_serializer_class(self): + if self.request.method == "POST": + return ExternalAccessCreateSerializer + return ExternalAccessSerializer + + def get_queryset(self): + return ExternalAccess.objects.select_related("project").all() + + +class ExternalAccessDetailView(generics.RetrieveUpdateDestroyAPIView): + queryset = ExternalAccess.objects.all() + serializer_class = ExternalAccessSerializer + permission_classes = (permissions.IsAuthenticated,) + + +@api_view(["POST"]) +@permission_classes([permissions.AllowAny]) +def external_login_view(request): + serializer = ExternalLoginSerializer(data=request.data) + serializer.is_valid(raise_exception=True) + + try: + access = ExternalAccess.objects.get( + access_token=serializer.validated_data["token"], + is_active=True, + ) + except ExternalAccess.DoesNotExist: + return Response( + {"error": "Invalid access token"}, + status=status.HTTP_401_UNAUTHORIZED, + ) + + if serializer.validated_data["password"] != access.password: + return Response( + {"error": "Invalid password"}, + status=status.HTTP_401_UNAUTHORIZED, + ) + + access.last_accessed_at = timezone.now() + access.save(update_fields=["last_accessed_at"]) + + return Response( + { + "access_token": access.access_token, + "project": { + "id": access.project_id, + "name": access.project.name, + "ticket_prefix": access.project.ticket_prefix, + }, + } + ) diff --git a/src/notes/admin.py b/src/notes/admin.py index 0dc5f91..fde295a 100644 --- a/src/notes/admin.py +++ b/src/notes/admin.py @@ -1,5 +1,10 @@ -"""generated with djinit""" - from django.contrib import admin -# Register your models here. \ No newline at end of file +from src.notes.models import ProjectNote + + +@admin.register(ProjectNote) +class ProjectNoteAdmin(admin.ModelAdmin): + list_display = ("id", "title", "project", "created_by", "note_date") + list_filter = ("project", "note_date") + search_fields = ("title", "project__name") diff --git a/src/notes/apps.py b/src/notes/apps.py index 872fe05..e21abfc 100644 --- a/src/notes/apps.py +++ b/src/notes/apps.py @@ -1,7 +1,6 @@ from django.apps import AppConfig - class NotesConfig(AppConfig): - default_auto_field = 'django.db.models.BigAutoField' - name = 'src.notes' \ No newline at end of file + default_auto_field = "django.db.models.BigAutoField" + name = "src.notes" diff --git a/src/notes/migrations/0001_initial.py b/src/notes/migrations/0001_initial.py new file mode 100644 index 0000000..d8b7af1 --- /dev/null +++ b/src/notes/migrations/0001_initial.py @@ -0,0 +1,63 @@ +# Generated by Django 6.0.6 on 2026-06-28 07:26 + +import django.db.models.deletion +from django.conf import settings +from django.db import migrations, models + + +class Migration(migrations.Migration): + initial = True + + dependencies = [ + ("projects", "0001_initial"), + migrations.swappable_dependency(settings.AUTH_USER_MODEL), + ] + + operations = [ + migrations.CreateModel( + name="ProjectNote", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ("title", models.CharField(max_length=255)), + ("content", models.TextField(blank=True, null=True)), + ("note_date", models.DateField()), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ( + "created_by", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="project_notes", + to=settings.AUTH_USER_MODEL, + ), + ), + ( + "project", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="notes", + to="projects.project", + ), + ), + ], + options={ + "verbose_name": "Project Note", + "verbose_name_plural": "Project Notes", + "db_table": "project_notes", + "indexes": [ + models.Index( + fields=["project", "note_date"], + name="project_not_project_833ff9_idx", + ) + ], + }, + ), + ] diff --git a/src/notes/models.py b/src/notes/models.py index d7b9f75..403ab94 100644 --- a/src/notes/models.py +++ b/src/notes/models.py @@ -1,5 +1,27 @@ -"""generated with djinit""" - +from django.conf import settings from django.db import models -# Create your models here. \ No newline at end of file + +class ProjectNote(models.Model): + project = models.ForeignKey( + "projects.Project", on_delete=models.CASCADE, related_name="notes" + ) + created_by = models.ForeignKey( + settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="project_notes" + ) + title = models.CharField(max_length=255) + content = models.TextField(blank=True, null=True) + note_date = models.DateField() + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "project_notes" + verbose_name = "Project Note" + verbose_name_plural = "Project Notes" + indexes = [ + models.Index(fields=["project", "note_date"]), + ] + + def __str__(self): + return f"{self.title} - {self.project.name}" diff --git a/src/notes/serializers.py b/src/notes/serializers.py index fbcbed8..66712b8 100644 --- a/src/notes/serializers.py +++ b/src/notes/serializers.py @@ -1,5 +1,22 @@ -"""generated with djinit""" - from rest_framework import serializers -# Create your serializers here. \ No newline at end of file +from src.accounts.serializers import UserSerializer +from src.notes.models import ProjectNote + + +class ProjectNoteSerializer(serializers.ModelSerializer): + created_by = UserSerializer(read_only=True) + + class Meta: + model = ProjectNote + fields = ( + "id", + "project", + "created_by", + "title", + "content", + "note_date", + "created_at", + "updated_at", + ) + read_only_fields = ("id", "created_by", "created_at", "updated_at") diff --git a/src/notes/tests.py b/src/notes/tests.py index a8b0ed1..337a402 100644 --- a/src/notes/tests.py +++ b/src/notes/tests.py @@ -1,5 +1,4 @@ """generated with djinit""" -from django.test import TestCase -# Create your tests here. \ No newline at end of file +# Create your tests here. diff --git a/src/notes/urls.py b/src/notes/urls.py index 8020533..a23d36e 100644 --- a/src/notes/urls.py +++ b/src/notes/urls.py @@ -1,7 +1,8 @@ -"""generated with djinit""" - from django.urls import path +from src.notes import views + urlpatterns = [ - # Add your URL patterns here -] \ No newline at end of file + path("", views.ProjectNoteListCreateView.as_view(), name="note-list"), + path("/", views.ProjectNoteDetailView.as_view(), name="note-detail"), +] diff --git a/src/notes/views.py b/src/notes/views.py index 6630beb..1de74e1 100644 --- a/src/notes/views.py +++ b/src/notes/views.py @@ -1,5 +1,25 @@ -"""generated with djinit""" +from rest_framework import generics, permissions -from rest_framework import viewsets +from src.notes.models import ProjectNote +from src.notes.serializers import ProjectNoteSerializer -# Create your views here. \ No newline at end of file + +class ProjectNoteListCreateView(generics.ListCreateAPIView): + serializer_class = ProjectNoteSerializer + permission_classes = (permissions.IsAuthenticated,) + + def get_queryset(self): + qs = ProjectNote.objects.select_related("created_by") + project_id = self.request.query_params.get("project") + if project_id: + qs = qs.filter(project_id=project_id) + return qs.order_by("-note_date", "-created_at") + + def perform_create(self, serializer): + serializer.save(created_by=self.request.user) + + +class ProjectNoteDetailView(generics.RetrieveUpdateDestroyAPIView): + queryset = ProjectNote.objects.all() + serializer_class = ProjectNoteSerializer + permission_classes = (permissions.IsAuthenticated,) diff --git a/src/notifications/admin.py b/src/notifications/admin.py index 0dc5f91..fd3003f 100644 --- a/src/notifications/admin.py +++ b/src/notifications/admin.py @@ -1,5 +1,10 @@ -"""generated with djinit""" - from django.contrib import admin -# Register your models here. \ No newline at end of file +from src.notifications.models import Notification + + +@admin.register(Notification) +class NotificationAdmin(admin.ModelAdmin): + list_display = ("id", "user", "type", "title", "read_at", "created_at") + list_filter = ("type", "read_at", "user") + search_fields = ("title", "message", "user__email") diff --git a/src/notifications/apps.py b/src/notifications/apps.py index bdd4e96..d49c498 100644 --- a/src/notifications/apps.py +++ b/src/notifications/apps.py @@ -1,7 +1,6 @@ from django.apps import AppConfig - class NotificationsConfig(AppConfig): - default_auto_field = 'django.db.models.BigAutoField' - name = 'src.notifications' \ No newline at end of file + default_auto_field = "django.db.models.BigAutoField" + name = "src.notifications" diff --git a/src/notifications/email_utils.py b/src/notifications/email_utils.py new file mode 100644 index 0000000..f934070 --- /dev/null +++ b/src/notifications/email_utils.py @@ -0,0 +1,237 @@ +from datetime import date + +from django.conf import settings +from django.contrib.auth import get_user_model +from django.core.mail import EmailMultiAlternatives +from django.template.loader import render_to_string +from django.utils.html import strip_tags + +from src.notifications.models import DeadlineReminderLog, Notification +from src.tickets.models import Ticket + + +def send_notification_email(user, notification_type, title, message, data=None): + """ + Queue an email notification to be sent to a user asynchronously. + """ + if not user.email: + return + + # Respect user email preference + if hasattr(user, "receive_deadline_emails") and not user.receive_deadline_emails: + return + + from django_q.tasks import async_task + + async_task( + "src.notifications.email_utils.do_send_notification_email", + user.id, + notification_type, + title, + message, + data, + ) + + +def do_send_notification_email(user_id, notification_type, title, message, data=None): + User = get_user_model() + try: + user = User.objects.get(pk=user_id) + except User.DoesNotExist: + return + + if not user.email: + return + + if hasattr(user, "receive_deadline_emails") and not user.receive_deadline_emails: + return + + data = data or {} + ticket_id = data.get("ticket_id") + ticket_uuid = data.get("ticket_uuid") + project_name = data.get("project_name", "") + user_name = data.get("user_name", "") + + ticket_url = "" + if ticket_id: + ticket_url = f"{settings.BASE_URL or 'http://localhost:8000'}/dashboard/tickets/{ticket_id}/" + + subject = f"[PM] {title}" + + html_content = render_to_string( + "emails/notification.html", + { + "title": title, + "message": message, + "ticket_url": ticket_url, + "ticket_uuid": ticket_uuid, + "project_name": project_name, + "user_name": user_name, + "site_name": getattr(settings, "SITE_NAME", "Project Management"), + }, + ) + text_content = strip_tags(html_content) + + email = EmailMultiAlternatives( + subject=subject, + body=text_content, + from_email=getattr(settings, "DEFAULT_FROM_EMAIL", "noreply@pm.com"), + to=[user.email], + ) + email.attach_alternative(html_content, "text/html") + email.send(fail_silently=True) + + +def send_deadline_reminder_email(user, ticket, days_left): + """ + Queue a deadline reminder email to be sent asynchronously. + """ + if not user.email: + return + + # Respect user email preference + if hasattr(user, "receive_deadline_emails") and not user.receive_deadline_emails: + return + + from django_q.tasks import async_task + + async_task( + "src.notifications.email_utils.do_send_deadline_reminder_email", + user.id, + ticket.id, + days_left, + ) + + +def do_send_deadline_reminder_email(user_id, ticket_id, days_left): + + User = get_user_model() + try: + user = User.objects.get(pk=user_id) + ticket = Ticket.objects.select_related("project", "priority", "status").get( + pk=ticket_id + ) + except (User.DoesNotExist, Ticket.DoesNotExist): + return + + if not user.email: + return + + if hasattr(user, "receive_deadline_emails") and not user.receive_deadline_emails: + return + + ticket_url = ( + f"{settings.BASE_URL or 'http://localhost:8000'}/dashboard/tickets/{ticket.id}/" + ) + + due_date_str = ticket.due_date.strftime("%b %d, %Y") if ticket.due_date else "N/A" + priority_name = ticket.priority.name if ticket.priority else "" + status_name = ticket.status.name if ticket.status else "Unknown" + + subject = f"[PM] Deadline Reminder: {ticket.uuid} - Due in {days_left} day{'s' if days_left != 1 else ''}" + + html_content = render_to_string( + "emails/deadline_reminder.html", + { + "days_left": days_left, + "ticket_name": ticket.name, + "ticket_uuid": ticket.uuid, + "ticket_url": ticket_url, + "due_date": due_date_str, + "project_name": ticket.project.name, + "status_name": status_name, + "priority_name": priority_name, + "site_name": getattr(settings, "SITE_NAME", "Project Management"), + }, + ) + text_content = strip_tags(html_content) + + email = EmailMultiAlternatives( + subject=subject, + body=text_content, + from_email=getattr(settings, "DEFAULT_FROM_EMAIL", "noreply@pm.com"), + to=[user.email], + ) + email.attach_alternative(html_content, "text/html") + email.send(fail_silently=True) + + +def process_deadline_reminders(ticket=None): + """ + Central function to process deadline reminders. + Called from: + 1. Ticket post_save signal (on create/update) + 2. Dashboard load (for time-based checks) + + If ticket is provided, only process that ticket. + Otherwise, process all eligible tickets. + """ + REMINDER_DAYS = [15, 10, 5, 2, 1] + today = date.today() + sent_count = 0 + + tickets_qs = ( + Ticket.objects.filter( + status__is_completed=False, + due_date__isnull=False, + ) + .exclude(due_date__lt=today) + .select_related("project", "status", "priority") + .prefetch_related("assignees") + ) + + if ticket: + tickets_qs = tickets_qs.filter(pk=ticket.pk) + + for t in tickets_qs: + assignees = list(t.assignees.all()) + if t.created_by and t.created_by not in assignees: + assignees.append(t.created_by) + + for user in assignees: + if not user.email: + continue + + # Respect user email preference + if ( + hasattr(user, "receive_deadline_emails") + and not user.receive_deadline_emails + ): + continue + + days_until_due = (t.due_date - today).days + + for days_before in REMINDER_DAYS: + if days_until_due == days_before: + already_sent = DeadlineReminderLog.objects.filter( + ticket=t, + user=user, + days_before=days_before, + ).exists() + + if already_sent: + continue + + send_deadline_reminder_email(user, t, days_before) + DeadlineReminderLog.objects.create( + ticket=t, + user=user, + days_before=days_before, + ) + Notification.objects.create( + user=user, + type="deadline_reminder", + title=f"Deadline Reminder: {t.uuid}", + message=( + f"Ticket '{t.name}' is due in {days_before} day{'s' if days_before != 1 else ''} " + f"({t.due_date.strftime('%b %d, %Y')})" + ), + data={ + "ticket_id": t.id, + "ticket_uuid": t.uuid, + "days_before": days_before, + }, + ) + sent_count += 1 + + return sent_count diff --git a/src/notifications/migrations/0001_initial.py b/src/notifications/migrations/0001_initial.py new file mode 100644 index 0000000..fd54514 --- /dev/null +++ b/src/notifications/migrations/0001_initial.py @@ -0,0 +1,118 @@ +# Generated by Django 6.0.6 on 2026-06-28 07:26 + +import django.db.models.deletion +from django.conf import settings +from django.db import migrations, models + + +class Migration(migrations.Migration): + initial = True + + dependencies = [ + ("tickets", "0001_initial"), + migrations.swappable_dependency(settings.AUTH_USER_MODEL), + ] + + operations = [ + migrations.CreateModel( + name="DeadlineReminderLog", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ( + "days_before", + models.IntegerField( + help_text="How many days before the deadline this reminder was sent" + ), + ), + ("sent_at", models.DateTimeField(auto_now_add=True)), + ( + "ticket", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="deadline_reminders", + to="tickets.ticket", + ), + ), + ( + "user", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="deadline_reminders", + to=settings.AUTH_USER_MODEL, + ), + ), + ], + options={ + "verbose_name": "Deadline Reminder Log", + "verbose_name_plural": "Deadline Reminder Logs", + "db_table": "deadline_reminder_log", + "constraints": [ + models.UniqueConstraint( + fields=("ticket", "user", "days_before"), + name="unique_ticket_user_days_reminder", + ) + ], + }, + ), + migrations.CreateModel( + name="Notification", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ( + "type", + models.CharField( + help_text="e.g. comment_added, project_assigned", max_length=255 + ), + ), + ("title", models.CharField(max_length=255)), + ("message", models.TextField(blank=True, null=True)), + ( + "data", + models.JSONField( + blank=True, + help_text="Arbitrary payload e.g. ticket_id, comment_id", + null=True, + ), + ), + ("read_at", models.DateTimeField(blank=True, null=True)), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ( + "user", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="notifications", + to=settings.AUTH_USER_MODEL, + ), + ), + ], + options={ + "verbose_name": "Notification", + "verbose_name_plural": "Notifications", + "db_table": "notifications", + "ordering": ("-created_at",), + "indexes": [ + models.Index( + fields=["user", "read_at"], + name="notificatio_user_id_6c7360_idx", + ) + ], + }, + ), + ] diff --git a/src/notifications/models.py b/src/notifications/models.py index d7b9f75..1eb940f 100644 --- a/src/notifications/models.py +++ b/src/notifications/models.py @@ -1,5 +1,64 @@ -"""generated with djinit""" - +from django.conf import settings from django.db import models -# Create your models here. \ No newline at end of file + +class Notification(models.Model): + user = models.ForeignKey( + settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="notifications" + ) + type = models.CharField( + max_length=255, help_text="e.g. comment_added, project_assigned" + ) + title = models.CharField(max_length=255) + message = models.TextField(blank=True, null=True) + data = models.JSONField( + blank=True, null=True, help_text="Arbitrary payload e.g. ticket_id, comment_id" + ) + read_at = models.DateTimeField(blank=True, null=True) + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "notifications" + verbose_name = "Notification" + verbose_name_plural = "Notifications" + indexes = [ + models.Index(fields=["user", "read_at"]), + ] + ordering = ("-created_at",) + + def __str__(self): + return f"[{self.type}] {self.title}" + + +class DeadlineReminderLog(models.Model): + """Track which deadline reminders have been sent to avoid duplicates.""" + + ticket = models.ForeignKey( + "tickets.Ticket", on_delete=models.CASCADE, related_name="deadline_reminders" + ) + user = models.ForeignKey( + settings.AUTH_USER_MODEL, + on_delete=models.CASCADE, + related_name="deadline_reminders", + ) + days_before = models.IntegerField( + help_text="How many days before the deadline this reminder was sent" + ) + sent_at = models.DateTimeField(auto_now_add=True) + + class Meta: + db_table = "deadline_reminder_log" + verbose_name = "Deadline Reminder Log" + verbose_name_plural = "Deadline Reminder Logs" + constraints = [ + models.UniqueConstraint( + fields=["ticket", "user", "days_before"], + name="unique_ticket_user_days_reminder", + ) + ] + + def __str__(self): + return ( + f"Reminder: {self.ticket.uuid} -> {self.user} ({self.days_before}d before)" + ) diff --git a/src/notifications/serializers.py b/src/notifications/serializers.py index fbcbed8..5cf5271 100644 --- a/src/notifications/serializers.py +++ b/src/notifications/serializers.py @@ -1,5 +1,20 @@ -"""generated with djinit""" - from rest_framework import serializers -# Create your serializers here. \ No newline at end of file +from src.notifications.models import Notification + + +class NotificationSerializer(serializers.ModelSerializer): + class Meta: + model = Notification + fields = ( + "id", + "user", + "type", + "title", + "message", + "data", + "read_at", + "created_at", + "updated_at", + ) + read_only_fields = ("id", "user", "created_at", "updated_at") diff --git a/src/notifications/signals.py b/src/notifications/signals.py new file mode 100644 index 0000000..0db7943 --- /dev/null +++ b/src/notifications/signals.py @@ -0,0 +1,86 @@ +from django.db.models.signals import post_save +from django.dispatch import receiver + +from src.notifications.email_utils import send_notification_email +from src.notifications.models import Notification +from src.tickets.models import TicketComment, TicketHistory + + +@receiver(post_save, sender=TicketComment, dispatch_uid="ticket_comment_notification") +def notify_comment_added(sender, instance, created, **kwargs): + if not created: + return + + ticket = instance.ticket + user_name = instance.user.get_full_name() or instance.user.username + recipients = set(ticket.assignees.all()) + if ticket.created_by: + recipients.add(ticket.created_by) + recipients.discard(instance.user) + + for user in recipients: + notification = Notification.objects.create( + user=user, + type="comment_added", + title=f"New comment on {ticket.uuid}", + message=instance.comment[:200], + data={ + "ticket_id": ticket.id, + "project_id": ticket.project_id, + "comment_id": instance.id, + "user_name": user_name, + }, + ) + # Send email notification + send_notification_email( + user=user, + notification_type="comment_added", + title=notification.title, + message=instance.comment[:200], + data={ + "ticket_id": ticket.id, + "ticket_uuid": ticket.uuid, + "project_name": ticket.project.name, + "user_name": user_name, + }, + ) + + +@receiver(post_save, sender=TicketHistory, dispatch_uid="ticket_history_notification") +def notify_status_changed(sender, instance, created, **kwargs): + if not created: + return + + ticket = instance.ticket + user_name = instance.user.get_full_name() or instance.user.username + recipients = set(ticket.assignees.all()) + if ticket.created_by: + recipients.add(ticket.created_by) + recipients.discard(instance.user) + + for user in recipients: + notification = Notification.objects.create( + user=user, + type="status_changed", + title=f"Ticket {ticket.uuid} moved to {instance.status.name}", + message=f"{user_name} changed status to {instance.status.name}", + data={ + "ticket_id": ticket.id, + "project_id": ticket.project_id, + "history_id": instance.id, + "user_name": user_name, + }, + ) + # Send email notification + send_notification_email( + user=user, + notification_type="status_changed", + title=notification.title, + message=f"{user_name} changed status to {instance.status.name}", + data={ + "ticket_id": ticket.id, + "ticket_uuid": ticket.uuid, + "project_name": ticket.project.name, + "user_name": user_name, + }, + ) diff --git a/src/notifications/tests.py b/src/notifications/tests.py index a8b0ed1..337a402 100644 --- a/src/notifications/tests.py +++ b/src/notifications/tests.py @@ -1,5 +1,4 @@ """generated with djinit""" -from django.test import TestCase -# Create your tests here. \ No newline at end of file +# Create your tests here. diff --git a/src/notifications/urls.py b/src/notifications/urls.py index 8020533..64d6566 100644 --- a/src/notifications/urls.py +++ b/src/notifications/urls.py @@ -1,7 +1,12 @@ -"""generated with djinit""" - from django.urls import path +from src.notifications import views + urlpatterns = [ - # Add your URL patterns here -] \ No newline at end of file + path("", views.NotificationListView.as_view(), name="notification-list"), + path("unread-count/", views.unread_count_view, name="notification-unread-count"), + path("mark-all-read/", views.mark_all_read_view, name="notification-mark-all-read"), + path( + "/", views.NotificationDetailView.as_view(), name="notification-detail" + ), +] diff --git a/src/notifications/views.py b/src/notifications/views.py index 6630beb..1230e1c 100644 --- a/src/notifications/views.py +++ b/src/notifications/views.py @@ -1,5 +1,39 @@ -"""generated with djinit""" +from django.utils import timezone +from rest_framework import generics, permissions +from rest_framework.decorators import api_view, permission_classes +from rest_framework.response import Response -from rest_framework import viewsets +from src.notifications.models import Notification +from src.notifications.serializers import NotificationSerializer -# Create your views here. \ No newline at end of file + +class NotificationListView(generics.ListAPIView): + serializer_class = NotificationSerializer + permission_classes = (permissions.IsAuthenticated,) + + def get_queryset(self): + return Notification.objects.filter(user=self.request.user) + + +class NotificationDetailView(generics.RetrieveUpdateDestroyAPIView): + serializer_class = NotificationSerializer + permission_classes = (permissions.IsAuthenticated,) + + def get_queryset(self): + return Notification.objects.filter(user=self.request.user) + + +@api_view(["POST"]) +@permission_classes([permissions.IsAuthenticated]) +def mark_all_read_view(request): + Notification.objects.filter(user=request.user, read_at__isnull=True).update( + read_at=timezone.now() + ) + return Response({"status": "ok"}) + + +@api_view(["GET"]) +@permission_classes([permissions.IsAuthenticated]) +def unread_count_view(request): + count = Notification.objects.filter(user=request.user, read_at__isnull=True).count() + return Response({"unread_count": count}) diff --git a/src/projects/admin.py b/src/projects/admin.py index 0dc5f91..5ed5ef7 100644 --- a/src/projects/admin.py +++ b/src/projects/admin.py @@ -1,5 +1,29 @@ -"""generated with djinit""" - from django.contrib import admin -# Register your models here. \ No newline at end of file +from src.projects.models import Project, ProjectMember + + +class ProjectMemberInline(admin.TabularInline): + model = ProjectMember + extra = 1 + + +@admin.register(Project) +class ProjectAdmin(admin.ModelAdmin): + list_display = ( + "id", + "name", + "ticket_prefix", + "color", + "start_date", + "end_date", + "pinned_date", + ) + search_fields = ("name", "ticket_prefix") + inlines = (ProjectMemberInline,) + + +@admin.register(ProjectMember) +class ProjectMemberAdmin(admin.ModelAdmin): + list_display = ("id", "project", "user") + search_fields = ("project__name", "user__email") diff --git a/src/projects/apps.py b/src/projects/apps.py index 15827da..e2356f7 100644 --- a/src/projects/apps.py +++ b/src/projects/apps.py @@ -1,7 +1,6 @@ from django.apps import AppConfig - class ProjectsConfig(AppConfig): - default_auto_field = 'django.db.models.BigAutoField' - name = 'src.projects' \ No newline at end of file + default_auto_field = "django.db.models.BigAutoField" + name = "src.projects" diff --git a/src/projects/migrations/0001_initial.py b/src/projects/migrations/0001_initial.py new file mode 100644 index 0000000..edec2ab --- /dev/null +++ b/src/projects/migrations/0001_initial.py @@ -0,0 +1,116 @@ +# Generated by Django 6.0.6 on 2026-06-28 07:26 + +import django.db.models.deletion +from django.conf import settings +from django.db import migrations, models + + +class Migration(migrations.Migration): + initial = True + + dependencies = [ + migrations.swappable_dependency(settings.AUTH_USER_MODEL), + ] + + operations = [ + migrations.CreateModel( + name="Project", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ("name", models.CharField(max_length=255)), + ("description", models.TextField(blank=True, null=True)), + ("ticket_prefix", models.CharField(max_length=255)), + ( + "color", + models.CharField( + blank=True, + help_text="Hex color e.g. #3B82F6", + max_length=7, + null=True, + ), + ), + ("start_date", models.DateField(blank=True, null=True)), + ("end_date", models.DateField(blank=True, null=True)), + ("pinned_date", models.DateTimeField(blank=True, null=True)), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ], + options={ + "verbose_name": "Project", + "verbose_name_plural": "Projects", + "db_table": "projects", + }, + ), + migrations.CreateModel( + name="ProjectMember", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ( + "project", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="project_members", + to="projects.project", + ), + ), + ( + "user", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="project_memberships", + to=settings.AUTH_USER_MODEL, + ), + ), + ], + options={ + "verbose_name": "Project Member", + "verbose_name_plural": "Project Members", + "db_table": "project_members", + }, + ), + migrations.AddField( + model_name="project", + name="members", + field=models.ManyToManyField( + related_name="projects", + through="projects.ProjectMember", + to=settings.AUTH_USER_MODEL, + ), + ), + migrations.AddConstraint( + model_name="projectmember", + constraint=models.UniqueConstraint( + fields=("project", "user"), name="unique_project_member" + ), + ), + migrations.AddIndex( + model_name="project", + index=models.Index( + fields=["pinned_date"], name="projects_pinned__118cce_idx" + ), + ), + migrations.AddIndex( + model_name="project", + index=models.Index( + fields=["start_date", "end_date"], name="projects_start_d_cb24a6_idx" + ), + ), + ] diff --git a/src/projects/models.py b/src/projects/models.py index d7b9f75..80d1db7 100644 --- a/src/projects/models.py +++ b/src/projects/models.py @@ -1,5 +1,75 @@ -"""generated with djinit""" - +from django.conf import settings from django.db import models +from django.utils import timezone -# Create your models here. \ No newline at end of file + +class Project(models.Model): + name = models.CharField(max_length=255) + description = models.TextField(blank=True, null=True) + ticket_prefix = models.CharField(max_length=255) + color = models.CharField( + max_length=7, blank=True, null=True, help_text="Hex color e.g. #3B82F6" + ) + start_date = models.DateField(blank=True, null=True) + end_date = models.DateField(blank=True, null=True) + pinned_date = models.DateTimeField(blank=True, null=True) + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + members = models.ManyToManyField( + settings.AUTH_USER_MODEL, + through="ProjectMember", + related_name="projects", + ) + + class Meta: + db_table = "projects" + verbose_name = "Project" + verbose_name_plural = "Projects" + indexes = [ + models.Index(fields=["pinned_date"]), + models.Index(fields=["start_date", "end_date"]), + ] + + def pin(self): + self.pinned_date = timezone.now() + self.save(update_fields=["pinned_date"]) + + def unpin(self): + self.pinned_date = None + self.save(update_fields=["pinned_date"]) + + def generate_external_access(self): + from apps.external.models import ExternalAccess + + self.external_accesses.all().delete() + return ExternalAccess.objects.create(project=self) + + def __str__(self): + return self.name + + +class ProjectMember(models.Model): + project = models.ForeignKey( + Project, on_delete=models.CASCADE, related_name="project_members" + ) + user = models.ForeignKey( + settings.AUTH_USER_MODEL, + on_delete=models.CASCADE, + related_name="project_memberships", + ) + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "project_members" + verbose_name = "Project Member" + verbose_name_plural = "Project Members" + constraints = [ + models.UniqueConstraint( + fields=["project", "user"], name="unique_project_member" + ) + ] + + def __str__(self): + return f"{self.user} -> {self.project}" diff --git a/src/projects/serializers.py b/src/projects/serializers.py index fbcbed8..2316d94 100644 --- a/src/projects/serializers.py +++ b/src/projects/serializers.py @@ -1,5 +1,66 @@ -"""generated with djinit""" - from rest_framework import serializers -# Create your serializers here. \ No newline at end of file +from src.accounts.serializers import UserSerializer +from src.projects.models import Project, ProjectMember + + +class ProjectMemberSerializer(serializers.ModelSerializer): + user = UserSerializer(read_only=True) + user_id = serializers.IntegerField(write_only=True) + + class Meta: + model = ProjectMember + fields = ("id", "user", "user_id", "created_at") + read_only_fields = ("id", "created_at") + + +class ProjectListSerializer(serializers.ModelSerializer): + member_count = serializers.SerializerMethodField() + ticket_count = serializers.SerializerMethodField() + + class Meta: + model = Project + fields = ( + "id", + "name", + "description", + "ticket_prefix", + "color", + "start_date", + "end_date", + "pinned_date", + "member_count", + "ticket_count", + "created_at", + "updated_at", + ) + read_only_fields = ("id", "created_at", "updated_at") + + def get_member_count(self, obj): + return obj.members.count() + + def get_ticket_count(self, obj): + return obj.tickets.count() + + +class ProjectDetailSerializer(serializers.ModelSerializer): + members = ProjectMemberSerializer( + source="project_members", many=True, read_only=True + ) + + class Meta: + model = Project + fields = ( + "id", + "name", + "description", + "ticket_prefix", + "color", + "start_date", + "end_date", + "pinned_date", + "members", + "created_at", + "updated_at", + ) + read_only_fields = ("id", "created_at", "updated_at") diff --git a/src/projects/tests.py b/src/projects/tests.py index a8b0ed1..337a402 100644 --- a/src/projects/tests.py +++ b/src/projects/tests.py @@ -1,5 +1,4 @@ """generated with djinit""" -from django.test import TestCase -# Create your tests here. \ No newline at end of file +# Create your tests here. diff --git a/src/projects/urls.py b/src/projects/urls.py index 8020533..9a5df62 100644 --- a/src/projects/urls.py +++ b/src/projects/urls.py @@ -1,7 +1,25 @@ -"""generated with djinit""" - from django.urls import path +from src.projects import views + urlpatterns = [ - # Add your URL patterns here -] \ No newline at end of file + path("", views.ProjectListCreateView.as_view(), name="project-list"), + path("dashboard/", views.dashboard_stats_view, name="project-dashboard"), + path("/", views.ProjectDetailView.as_view(), name="project-detail"), + path( + "/members/", + views.ProjectMemberListCreateView.as_view(), + name="project-member-list", + ), + path( + "/members//", + views.ProjectMemberDestroyView.as_view(), + name="project-member-destroy", + ), + path( + "/statuses/", + views.project_statuses_view, + name="project-statuses", + ), + path("/stats/", views.project_stats_view, name="project-stats"), +] diff --git a/src/projects/views.py b/src/projects/views.py index 6630beb..773e295 100644 --- a/src/projects/views.py +++ b/src/projects/views.py @@ -1,5 +1,138 @@ -"""generated with djinit""" +from django.db import models +from django.utils import timezone +from rest_framework import generics, permissions +from rest_framework.decorators import api_view, permission_classes +from rest_framework.response import Response -from rest_framework import viewsets +from src.projects.models import Project, ProjectMember +from src.projects.serializers import ( + ProjectDetailSerializer, + ProjectListSerializer, + ProjectMemberSerializer, +) +from src.tickets.models import Ticket, TicketStatus +from src.tickets.serializers import TicketStatusSerializer -# Create your views here. \ No newline at end of file + +class ProjectListCreateView(generics.ListCreateAPIView): + serializer_class = ProjectListSerializer + permission_classes = (permissions.IsAuthenticated,) + + def get_queryset(self): + user = self.request.user + if user.is_superuser: + return Project.objects.all() + return Project.objects.filter(members=user).distinct() + + def perform_create(self, serializer): + project = serializer.save() + ProjectMember.objects.get_or_create(project=project, user=self.request.user) + + +class ProjectDetailView(generics.RetrieveUpdateDestroyAPIView): + serializer_class = ProjectDetailSerializer + permission_classes = (permissions.IsAuthenticated,) + + def get_queryset(self): + user = self.request.user + if user.is_superuser: + return Project.objects.all() + return Project.objects.filter(members=user).distinct() + + +class ProjectMemberListCreateView(generics.ListCreateAPIView): + serializer_class = ProjectMemberSerializer + permission_classes = (permissions.IsAuthenticated,) + + def get_queryset(self): + return ProjectMember.objects.filter(project_id=self.kwargs["project_pk"]) + + def perform_create(self, serializer): + serializer.save(project_id=self.kwargs["project_pk"]) + + +class ProjectMemberDestroyView(generics.DestroyAPIView): + permission_classes = (permissions.IsAuthenticated,) + + def get_queryset(self): + return ProjectMember.objects.filter(project_id=self.kwargs["project_pk"]) + + def get_object(self): + return self.get_queryset().get(user_id=self.kwargs["user_id"]) + + +@api_view(["GET"]) +@permission_classes([permissions.IsAuthenticated]) +def project_statuses_view(request, project_pk): + statuses = TicketStatus.objects.filter(project_id=project_pk).order_by("sort_order") + serializer = TicketStatusSerializer(statuses, many=True) + return Response(serializer.data) + + +@api_view(["GET"]) +@permission_classes([permissions.IsAuthenticated]) +def project_stats_view(request, project_pk): + project = generics.get_object_or_404( + Project.objects.filter(members=request.user) + if not request.user.is_superuser + else Project.objects.all(), + pk=project_pk, + ) + tickets = project.tickets.all() + stats = { + "total_tickets": tickets.count(), + "open_tickets": tickets.exclude(status__is_completed=True).count(), + "completed_tickets": tickets.filter(status__is_completed=True).count(), + "total_members": project.members.count(), + "total_epics": project.epics.count(), + } + return Response(stats) + + +@api_view(["GET"]) +@permission_classes([permissions.IsAuthenticated]) +def dashboard_stats_view(request): + user = request.user + if user.is_superuser: + total_projects = Project.objects.count() + total_tickets = Ticket.objects.count() + total_members = user.__class__.objects.count() + else: + total_projects = Project.objects.filter(members=user).count() + total_tickets = ( + Ticket.objects.filter( + models.Q(project__members=user) | models.Q(assignees=user) + ) + .distinct() + .count() + ) + total_members = ( + user.__class__.objects.filter(project_memberships__project__members=user) + .distinct() + .count() + ) + + my_assigned = Ticket.objects.filter(assignees=user).count() + my_overdue = Ticket.objects.filter( + assignees=user, due_date__lt=timezone.now().date(), status__is_completed=False + ).count() + completed_this_week = ( + Ticket.objects.filter( + models.Q(assignees=user) | models.Q(created_by=user), + histories__created_at__week=timezone.now().isocalendar()[1], + histories__status__is_completed=True, + ) + .distinct() + .count() + ) + + return Response( + { + "total_projects": total_projects, + "total_tickets": total_tickets, + "total_members": total_members, + "my_assigned": my_assigned, + "my_overdue": my_overdue, + "completed_this_week": completed_this_week, + } + ) diff --git a/src/tickets/admin.py b/src/tickets/admin.py index 0dc5f91..ad0c01c 100644 --- a/src/tickets/admin.py +++ b/src/tickets/admin.py @@ -1,5 +1,92 @@ -"""generated with djinit""" - from django.contrib import admin +from django.contrib.auth import get_user_model -# Register your models here. \ No newline at end of file +from src.epics.models import Epic +from src.tickets.models import ( + Ticket, + TicketComment, + TicketHistory, + TicketPriority, + TicketStatus, + TicketUser, +) + +User = get_user_model() + + +class TicketUserInline(admin.TabularInline): + model = TicketUser + extra = 1 + + def formfield_for_foreignkey(self, db_field, request, **kwargs): + if db_field.name == "user": + parent_id = request.resolver_match.kwargs.get("object_id") + if parent_id: + try: + ticket = Ticket.objects.get(pk=parent_id) + kwargs["queryset"] = User.objects.filter( + project_memberships__project=ticket.project + ) + except Ticket.DoesNotExist: + pass + return super().formfield_for_foreignkey(db_field, request, **kwargs) + + +class TicketCommentInline(admin.TabularInline): + model = TicketComment + extra = 0 + readonly_fields = ("user", "comment", "created_at") + + +class TicketHistoryInline(admin.TabularInline): + model = TicketHistory + extra = 0 + readonly_fields = ("user", "status", "created_at") + + +@admin.register(Ticket) +class TicketAdmin(admin.ModelAdmin): + list_display = ("id", "uuid", "name", "project", "status", "priority", "due_date") + list_filter = ("project", "status", "priority") + search_fields = ("name", "uuid") + inlines = (TicketUserInline, TicketCommentInline, TicketHistoryInline) + + def formfield_for_foreignkey(self, db_field, request, **kwargs): + obj = kwargs.get("obj") + if db_field.name == "status" and obj: + kwargs["queryset"] = TicketStatus.objects.filter(project=obj.project) + if db_field.name == "epic" and obj: + kwargs["queryset"] = Epic.objects.filter(project=obj.project) + if db_field.name == "created_by" and obj: + kwargs["queryset"] = User.objects.filter( + project_memberships__project=obj.project + ) + return super().formfield_for_foreignkey(db_field, request, **kwargs) + + +@admin.register(TicketStatus) +class TicketStatusAdmin(admin.ModelAdmin): + list_display = ("id", "name", "project", "color", "sort_order", "is_completed") + list_filter = ("project",) + + +@admin.register(TicketPriority) +class TicketPriorityAdmin(admin.ModelAdmin): + list_display = ("id", "name", "color") + + +@admin.register(TicketComment) +class TicketCommentAdmin(admin.ModelAdmin): + list_display = ("id", "ticket", "user", "created_at") + readonly_fields = ("ticket", "user", "comment", "created_at") + + +@admin.register(TicketHistory) +class TicketHistoryAdmin(admin.ModelAdmin): + list_display = ("id", "ticket", "user", "status", "created_at") + readonly_fields = ("ticket", "user", "status", "created_at") + + +@admin.register(TicketUser) +class TicketUserAdmin(admin.ModelAdmin): + list_display = ("id", "ticket", "user") diff --git a/src/tickets/apps.py b/src/tickets/apps.py index 222445a..1e3d1a5 100644 --- a/src/tickets/apps.py +++ b/src/tickets/apps.py @@ -1,7 +1,6 @@ from django.apps import AppConfig - class TicketsConfig(AppConfig): - default_auto_field = 'django.db.models.BigAutoField' - name = 'src.tickets' \ No newline at end of file + default_auto_field = "django.db.models.BigAutoField" + name = "src.tickets" diff --git a/src/tickets/migrations/0001_initial.py b/src/tickets/migrations/0001_initial.py new file mode 100644 index 0000000..e22a610 --- /dev/null +++ b/src/tickets/migrations/0001_initial.py @@ -0,0 +1,352 @@ +# Generated by Django 6.0.6 on 2026-06-28 07:26 + +import django.db.models.deletion +from django.conf import settings +from django.db import migrations, models + + +class Migration(migrations.Migration): + initial = True + + dependencies = [ + ("epics", "0001_initial"), + ("projects", "0001_initial"), + migrations.swappable_dependency(settings.AUTH_USER_MODEL), + ] + + operations = [ + migrations.CreateModel( + name="TicketPriority", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ("name", models.CharField(max_length=255, unique=True)), + ("color", models.CharField(default="#6B7280", max_length=7)), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ], + options={ + "verbose_name": "Ticket Priority", + "verbose_name_plural": "Ticket Priorities", + "db_table": "ticket_priorities", + }, + ), + migrations.CreateModel( + name="Ticket", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ("name", models.CharField(max_length=255)), + ("description", models.TextField(blank=True, null=True)), + ("uuid", models.CharField(editable=False, max_length=255, unique=True)), + ("start_date", models.DateField(blank=True, null=True)), + ("due_date", models.DateField(blank=True, null=True)), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ( + "created_by", + models.ForeignKey( + blank=True, + null=True, + on_delete=django.db.models.deletion.SET_NULL, + related_name="created_tickets", + to=settings.AUTH_USER_MODEL, + ), + ), + ( + "epic", + models.ForeignKey( + blank=True, + null=True, + on_delete=django.db.models.deletion.SET_NULL, + related_name="tickets", + to="epics.epic", + ), + ), + ( + "project", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="tickets", + to="projects.project", + ), + ), + ( + "priority", + models.ForeignKey( + blank=True, + null=True, + on_delete=django.db.models.deletion.SET_NULL, + related_name="tickets", + to="tickets.ticketpriority", + ), + ), + ], + options={ + "verbose_name": "Ticket", + "verbose_name_plural": "Tickets", + "db_table": "tickets", + }, + ), + migrations.CreateModel( + name="TicketComment", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ("comment", models.TextField(help_text="Rich text HTML content")), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ( + "parent", + models.ForeignKey( + blank=True, + null=True, + on_delete=django.db.models.deletion.CASCADE, + related_name="replies", + to="tickets.ticketcomment", + ), + ), + ( + "ticket", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="comments", + to="tickets.ticket", + ), + ), + ( + "user", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="ticket_comments", + to=settings.AUTH_USER_MODEL, + ), + ), + ], + options={ + "verbose_name": "Ticket Comment", + "verbose_name_plural": "Ticket Comments", + "db_table": "ticket_comments", + }, + ), + migrations.CreateModel( + name="TicketStatus", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ("name", models.CharField(max_length=255)), + ("color", models.CharField(default="#10B981", max_length=7)), + ("sort_order", models.IntegerField(default=0)), + ("is_completed", models.BooleanField(default=False)), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ( + "project", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="ticket_statuses", + to="projects.project", + ), + ), + ], + options={ + "verbose_name": "Ticket Status", + "verbose_name_plural": "Ticket Statuses", + "db_table": "ticket_statuses", + }, + ), + migrations.CreateModel( + name="TicketHistory", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ( + "ticket", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="histories", + to="tickets.ticket", + ), + ), + ( + "user", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="ticket_histories", + to=settings.AUTH_USER_MODEL, + ), + ), + ( + "status", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="histories", + to="tickets.ticketstatus", + ), + ), + ], + options={ + "verbose_name": "Ticket History", + "verbose_name_plural": "Ticket Histories", + "db_table": "ticket_histories", + }, + ), + migrations.AddField( + model_name="ticket", + name="status", + field=models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="tickets", + to="tickets.ticketstatus", + ), + ), + migrations.CreateModel( + name="TicketUser", + fields=[ + ( + "id", + models.BigAutoField( + auto_created=True, + primary_key=True, + serialize=False, + verbose_name="ID", + ), + ), + ("created_at", models.DateTimeField(auto_now_add=True)), + ("updated_at", models.DateTimeField(auto_now=True)), + ( + "ticket", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + related_name="ticket_assignees", + to="tickets.ticket", + ), + ), + ( + "user", + models.ForeignKey( + on_delete=django.db.models.deletion.CASCADE, + to=settings.AUTH_USER_MODEL, + ), + ), + ], + options={ + "verbose_name": "Ticket Assignee", + "verbose_name_plural": "Ticket Assignees", + "db_table": "ticket_users", + }, + ), + migrations.AddField( + model_name="ticket", + name="assignees", + field=models.ManyToManyField( + related_name="assigned_tickets", + through="tickets.TicketUser", + to=settings.AUTH_USER_MODEL, + ), + ), + migrations.AddIndex( + model_name="ticketstatus", + index=models.Index( + fields=["project", "sort_order"], name="ticket_stat_project_262e3f_idx" + ), + ), + migrations.AddIndex( + model_name="ticketstatus", + index=models.Index( + fields=["project", "is_completed"], + name="ticket_stat_project_283078_idx", + ), + ), + migrations.AddIndex( + model_name="ticketuser", + index=models.Index( + fields=["ticket", "user"], name="ticket_user_ticket__0340c3_idx" + ), + ), + migrations.AddIndex( + model_name="ticketuser", + index=models.Index(fields=["user"], name="ticket_user_user_id_437f9e_idx"), + ), + migrations.AddConstraint( + model_name="ticketuser", + constraint=models.UniqueConstraint( + fields=("ticket", "user"), name="unique_ticket_user" + ), + ), + migrations.AddIndex( + model_name="ticket", + index=models.Index( + fields=["project", "status"], name="tickets_project_3ab72a_idx" + ), + ), + migrations.AddIndex( + model_name="ticket", + index=models.Index( + fields=["status", "created_at"], name="tickets_status__3a7341_idx" + ), + ), + migrations.AddIndex( + model_name="ticket", + index=models.Index( + fields=["project", "created_at"], name="tickets_project_5cdbb2_idx" + ), + ), + migrations.AddIndex( + model_name="ticket", + index=models.Index( + fields=["project", "updated_at"], name="tickets_project_4298d2_idx" + ), + ), + migrations.AddIndex( + model_name="ticket", + index=models.Index(fields=["due_date"], name="tickets_due_dat_c75c11_idx"), + ), + migrations.AddIndex( + model_name="ticket", + index=models.Index(fields=["priority"], name="tickets_priorit_1ce021_idx"), + ), + migrations.AddIndex( + model_name="ticket", + index=models.Index( + fields=["created_by"], name="tickets_created_b5c671_idx" + ), + ), + ] diff --git a/src/tickets/models.py b/src/tickets/models.py index d7b9f75..e555971 100644 --- a/src/tickets/models.py +++ b/src/tickets/models.py @@ -1,5 +1,188 @@ -"""generated with djinit""" +import random +import string +from django.conf import settings from django.db import models -# Create your models here. \ No newline at end of file + +def generate_ticket_uuid(prefix): + rand = "".join(random.choices(string.ascii_uppercase + string.digits, k=6)) + return f"{prefix}-{rand}" + + +class TicketPriority(models.Model): + name = models.CharField(max_length=255, unique=True) + color = models.CharField(max_length=7, default="#6B7280") + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "ticket_priorities" + verbose_name = "Ticket Priority" + verbose_name_plural = "Ticket Priorities" + + def __str__(self): + return self.name + + +class TicketStatus(models.Model): + project = models.ForeignKey( + "projects.Project", on_delete=models.CASCADE, related_name="ticket_statuses" + ) + name = models.CharField(max_length=255) + color = models.CharField(max_length=7, default="#10B981") + sort_order = models.IntegerField(default=0) + is_completed = models.BooleanField(default=False) + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "ticket_statuses" + verbose_name = "Ticket Status" + verbose_name_plural = "Ticket Statuses" + indexes = [ + models.Index(fields=["project", "sort_order"]), + models.Index(fields=["project", "is_completed"]), + ] + + def __str__(self): + return f"[{self.project.ticket_prefix}] {self.name}" + + +class Ticket(models.Model): + project = models.ForeignKey( + "projects.Project", on_delete=models.CASCADE, related_name="tickets" + ) + status = models.ForeignKey( + TicketStatus, on_delete=models.CASCADE, related_name="tickets" + ) + epic = models.ForeignKey( + "epics.Epic", + on_delete=models.SET_NULL, + blank=True, + null=True, + related_name="tickets", + ) + priority = models.ForeignKey( + TicketPriority, + on_delete=models.SET_NULL, + blank=True, + null=True, + related_name="tickets", + ) + name = models.CharField(max_length=255) + description = models.TextField(blank=True, null=True) + uuid = models.CharField(max_length=255, unique=True, editable=False) + start_date = models.DateField(blank=True, null=True) + due_date = models.DateField(blank=True, null=True) + created_by = models.ForeignKey( + settings.AUTH_USER_MODEL, + on_delete=models.SET_NULL, + blank=True, + null=True, + related_name="created_tickets", + ) + assignees = models.ManyToManyField( + settings.AUTH_USER_MODEL, + through="TicketUser", + related_name="assigned_tickets", + ) + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "tickets" + verbose_name = "Ticket" + verbose_name_plural = "Tickets" + indexes = [ + models.Index(fields=["project", "status"]), + models.Index(fields=["status", "created_at"]), + models.Index(fields=["project", "created_at"]), + models.Index(fields=["project", "updated_at"]), + models.Index(fields=["due_date"]), + models.Index(fields=["priority"]), + models.Index(fields=["created_by"]), + ] + + def __str__(self): + return f"{self.uuid} - {self.name}" + + def save(self, *args, **kwargs): + if not self.uuid: + self.uuid = generate_ticket_uuid(self.project.ticket_prefix) + super().save(*args, **kwargs) + + +class TicketUser(models.Model): + ticket = models.ForeignKey( + Ticket, on_delete=models.CASCADE, related_name="ticket_assignees" + ) + user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE) + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "ticket_users" + verbose_name = "Ticket Assignee" + verbose_name_plural = "Ticket Assignees" + constraints = [ + models.UniqueConstraint( + fields=["ticket", "user"], name="unique_ticket_user" + ) + ] + indexes = [ + models.Index(fields=["ticket", "user"]), + models.Index(fields=["user"]), + ] + + def __str__(self): + return f"{self.user} -> {self.ticket}" + + +class TicketHistory(models.Model): + ticket = models.ForeignKey( + Ticket, on_delete=models.CASCADE, related_name="histories" + ) + user = models.ForeignKey( + settings.AUTH_USER_MODEL, + on_delete=models.CASCADE, + related_name="ticket_histories", + ) + status = models.ForeignKey( + TicketStatus, on_delete=models.CASCADE, related_name="histories" + ) + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "ticket_histories" + verbose_name = "Ticket History" + verbose_name_plural = "Ticket Histories" + + def __str__(self): + return f"{self.ticket.uuid} -> {self.status.name} by {self.user}" + + +class TicketComment(models.Model): + ticket = models.ForeignKey( + Ticket, on_delete=models.CASCADE, related_name="comments" + ) + user = models.ForeignKey( + settings.AUTH_USER_MODEL, + on_delete=models.CASCADE, + related_name="ticket_comments", + ) + parent = models.ForeignKey( + "self", on_delete=models.CASCADE, null=True, blank=True, related_name="replies" + ) + comment = models.TextField(help_text="Rich text HTML content") + created_at = models.DateTimeField(auto_now_add=True) + updated_at = models.DateTimeField(auto_now=True) + + class Meta: + db_table = "ticket_comments" + verbose_name = "Ticket Comment" + verbose_name_plural = "Ticket Comments" + + def __str__(self): + return f"Comment by {self.user} on {self.ticket.uuid}" diff --git a/src/tickets/serializers.py b/src/tickets/serializers.py index fbcbed8..72286b6 100644 --- a/src/tickets/serializers.py +++ b/src/tickets/serializers.py @@ -1,5 +1,173 @@ -"""generated with djinit""" - from rest_framework import serializers -# Create your serializers here. \ No newline at end of file +from src.accounts.serializers import UserSerializer +from src.epics.serializers import EpicSerializer +from src.tickets.models import ( + Ticket, + TicketComment, + TicketHistory, + TicketPriority, + TicketStatus, + TicketUser, +) + + +class TicketPrioritySerializer(serializers.ModelSerializer): + class Meta: + model = TicketPriority + fields = ("id", "name", "color", "created_at", "updated_at") + read_only_fields = ("id", "created_at", "updated_at") + + +class TicketStatusSerializer(serializers.ModelSerializer): + class Meta: + model = TicketStatus + fields = ( + "id", + "project", + "name", + "color", + "sort_order", + "is_completed", + "created_at", + "updated_at", + ) + read_only_fields = ("id", "created_at", "updated_at") + + +class TicketUserSerializer(serializers.ModelSerializer): + user = UserSerializer(read_only=True) + user_id = serializers.IntegerField(write_only=True) + + class Meta: + model = TicketUser + fields = ("id", "user", "user_id", "created_at") + read_only_fields = ("id", "created_at") + + +class TicketCommentSerializer(serializers.ModelSerializer): + user = UserSerializer(read_only=True) + + class Meta: + model = TicketComment + fields = ("id", "ticket", "user", "comment", "created_at", "updated_at") + read_only_fields = ("id", "user", "created_at", "updated_at") + + +class TicketHistorySerializer(serializers.ModelSerializer): + user = UserSerializer(read_only=True) + status = TicketStatusSerializer(read_only=True) + + class Meta: + model = TicketHistory + fields = ("id", "ticket", "user", "status", "created_at") + read_only_fields = ("id", "created_at") + + +class TicketListSerializer(serializers.ModelSerializer): + status = TicketStatusSerializer(read_only=True) + priority = TicketPrioritySerializer(read_only=True) + epic = EpicSerializer(read_only=True) + assignees = UserSerializer(many=True, read_only=True) + creator = UserSerializer(source="created_by", read_only=True) + + class Meta: + model = Ticket + fields = ( + "id", + "uuid", + "project", + "status", + "epic", + "priority", + "name", + "description", + "start_date", + "due_date", + "creator", + "assignees", + "created_at", + "updated_at", + ) + read_only_fields = ("id", "uuid", "created_at", "updated_at") + + +class TicketDetailSerializer(serializers.ModelSerializer): + status = TicketStatusSerializer(read_only=True) + priority = TicketPrioritySerializer(read_only=True) + epic = EpicSerializer(read_only=True) + assignees = UserSerializer(many=True, read_only=True) + creator = UserSerializer(source="created_by", read_only=True) + comments = TicketCommentSerializer(many=True, read_only=True) + histories = TicketHistorySerializer(many=True, read_only=True) + + class Meta: + model = Ticket + fields = ( + "id", + "uuid", + "project", + "status", + "epic", + "priority", + "name", + "description", + "start_date", + "due_date", + "creator", + "assignees", + "comments", + "histories", + "created_at", + "updated_at", + ) + read_only_fields = ("id", "uuid", "created_at", "updated_at") + + +class TicketWriteSerializer(serializers.ModelSerializer): + assignee_ids = serializers.ListField( + child=serializers.IntegerField(), write_only=True, required=False + ) + + class Meta: + model = Ticket + fields = ( + "project", + "status", + "epic", + "priority", + "name", + "description", + "start_date", + "due_date", + "assignee_ids", + ) + + def create(self, validated_data): + assignee_ids = validated_data.pop("assignee_ids", []) + user = self.context["request"].user + ticket = Ticket.objects.create(**validated_data, created_by=user) + for uid in assignee_ids: + TicketUser.objects.get_or_create(ticket=ticket, user_id=uid) + return ticket + + def update(self, instance, validated_data): + assignee_ids = validated_data.pop("assignee_ids", None) + for attr, value in validated_data.items(): + setattr(instance, attr, value) + old_status_id = instance.status_id + instance.save() + + if assignee_ids is not None: + instance.ticket_assignees.all().delete() + for uid in assignee_ids: + TicketUser.objects.get_or_create(ticket=instance, user_id=uid) + + if "status" in validated_data and old_status_id != instance.status_id: + TicketHistory.objects.create( + ticket=instance, + user=self.context["request"].user, + status=instance.status, + ) + + return instance diff --git a/src/tickets/tests.py b/src/tickets/tests.py index a8b0ed1..337a402 100644 --- a/src/tickets/tests.py +++ b/src/tickets/tests.py @@ -1,5 +1,4 @@ """generated with djinit""" -from django.test import TestCase -# Create your tests here. \ No newline at end of file +# Create your tests here. diff --git a/src/tickets/urls.py b/src/tickets/urls.py index 8020533..fb7e8b8 100644 --- a/src/tickets/urls.py +++ b/src/tickets/urls.py @@ -1,7 +1,25 @@ -"""generated with djinit""" - from django.urls import path +from src.tickets import views + urlpatterns = [ - # Add your URL patterns here -] \ No newline at end of file + path("", views.TicketListCreateView.as_view(), name="ticket-list"), + path("priorities/", views.PriorityListView.as_view(), name="priority-list"), + path( + "priorities//", + views.PriorityDetailView.as_view(), + name="priority-detail", + ), + path("/", views.TicketDetailView.as_view(), name="ticket-detail"), + path("/move/", views.move_ticket_view, name="ticket-move"), + path( + "/comments/", + views.TicketCommentListCreateView.as_view(), + name="ticket-comment-list", + ), + path( + "/histories/", + views.TicketHistoryListView.as_view(), + name="ticket-history-list", + ), +] diff --git a/src/tickets/views.py b/src/tickets/views.py index 6630beb..2ce3413 100644 --- a/src/tickets/views.py +++ b/src/tickets/views.py @@ -1,5 +1,133 @@ -"""generated with djinit""" +from django.db import models +from rest_framework import generics, permissions +from rest_framework.decorators import api_view, permission_classes +from rest_framework.response import Response -from rest_framework import viewsets +from src.tickets.models import ( + Ticket, + TicketComment, + TicketHistory, + TicketPriority, +) +from src.tickets.serializers import ( + TicketCommentSerializer, + TicketDetailSerializer, + TicketHistorySerializer, + TicketListSerializer, + TicketPrioritySerializer, + TicketWriteSerializer, +) -# Create your views here. \ No newline at end of file + +class TicketListCreateView(generics.ListCreateAPIView): + permission_classes = (permissions.IsAuthenticated,) + + def get_serializer_class(self): + if self.request.method == "POST": + return TicketWriteSerializer + return TicketListSerializer + + def get_queryset(self): + qs = Ticket.objects.select_related( + "status", "priority", "epic", "created_by" + ).prefetch_related("assignees") + project_id = self.request.query_params.get("project") + status_id = self.request.query_params.get("status") + epic_id = self.request.query_params.get("epic") + priority_id = self.request.query_params.get("priority") + assignee_id = self.request.query_params.get("assignee") + + if project_id: + qs = qs.filter(project_id=project_id) + if status_id: + qs = qs.filter(status_id=status_id) + if epic_id: + qs = qs.filter(epic_id=epic_id) + if priority_id: + qs = qs.filter(priority_id=priority_id) + if assignee_id: + qs = qs.filter(ticket_assignees__user_id=assignee_id) + + user = self.request.user + if not user.is_superuser: + qs = qs.filter( + models.Q(project__members=user) | models.Q(assignees=user) + ).distinct() + + return qs.order_by("-created_at") + + +class TicketDetailView(generics.RetrieveUpdateDestroyAPIView): + permission_classes = (permissions.IsAuthenticated,) + + def get_serializer_class(self): + if self.request.method in ("PUT", "PATCH"): + return TicketWriteSerializer + return TicketDetailSerializer + + def get_queryset(self): + return Ticket.objects.select_related( + "status", "priority", "epic", "created_by" + ).prefetch_related("assignees", "comments__user", "histories__user__status") + + +class TicketCommentListCreateView(generics.ListCreateAPIView): + serializer_class = TicketCommentSerializer + permission_classes = (permissions.IsAuthenticated,) + + def get_queryset(self): + return ( + TicketComment.objects.filter(ticket_id=self.kwargs["ticket_pk"]) + .select_related("user") + .order_by("created_at") + ) + + def perform_create(self, serializer): + serializer.save( + ticket_id=self.kwargs["ticket_pk"], + user=self.request.user, + ) + + +class TicketHistoryListView(generics.ListAPIView): + serializer_class = TicketHistorySerializer + permission_classes = (permissions.IsAuthenticated,) + + def get_queryset(self): + return ( + TicketHistory.objects.filter(ticket_id=self.kwargs["ticket_pk"]) + .select_related("user", "status") + .order_by("-created_at") + ) + + +@api_view(["PATCH"]) +@permission_classes([permissions.IsAuthenticated]) +def move_ticket_view(request, pk): + ticket = generics.get_object_or_404(Ticket, pk=pk) + new_status_id = request.data.get("status_id") + if new_status_id: + old_status_id = ticket.status_id + ticket.status_id = new_status_id + ticket.save() + if old_status_id != int(new_status_id): + TicketHistory.objects.create( + ticket=ticket, + user=request.user, + status_id=new_status_id, + ) + + return Response(TicketListSerializer(ticket).data) + + +# Priority and Status list views (global) +class PriorityListView(generics.ListCreateAPIView): + queryset = TicketPriority.objects.all() + serializer_class = TicketPrioritySerializer + permission_classes = (permissions.IsAuthenticated,) + + +class PriorityDetailView(generics.RetrieveUpdateDestroyAPIView): + queryset = TicketPriority.objects.all() + serializer_class = TicketPrioritySerializer + permission_classes = (permissions.IsAuthenticated,)