feat: dodaj scheduled_date na Task i kalendar widget

- Novo polje Task.scheduled_date (DateField, nullable, db_index) za planiranje
- Migracija 0009_task_scheduled_date
- Celery task notify_upcoming_tasks: dnevno u 08:00 šalje Pusher + email za sutrašnje zadatke
- TaskCalendarWidget: react-spring slide panel s lijeve strane, grid prikaz mjeseca, dot indikatori, klik otvara TaskServiceRecordsModal
- FleetDashboardShell: import + render kalendara, Planirano stupac u tablici zadataka
- TaskCreateModal + TaskServiceRecordsModal: scheduled_date input i prikaz
- Admin + serializer + views: scheduled_date filter i prikaz
- 47 backend testova prolaze (uključuje 8 novih za notify_upcoming_tasks)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

backend/core/settings/base.py

@@ -175,6 +175,10 @@ CELERY_BEAT_SCHEDULE = {
         'task': 'modules.fleet.tasks.cleanup_expired_generated_pdfs_task',
         'schedule': crontab(minute=0),
     },
+    'notify-upcoming-tasks-daily': {
+        'task': 'modules.task_management.tasks.notify_upcoming_tasks',
+        'schedule': crontab(hour=8, minute=0),
+    },
 }
 
 # URL kojim će preglednik dohvaćati statiku

backend/modules/fleet/models.py

@@ -250,6 +250,7 @@ class WorkOrder(BaseModel):
         ('defektaza', _("Defektaža")),
         ('kontrola', _("Kontrola")),
         ('redovni_pregled', _("Redovni pregled")),
+        ('popravak', _("Popravak")),
     ]
 
     vehicle = models.ForeignKey(Vehicle, on_delete=models.PROTECT, related_name='work_orders', verbose_name=_("Vozilo"))

backend/modules/task_management/admin.py

@@ -26,8 +26,8 @@ class TaskTemplateEntryInline(admin.TabularInline):
 
 @admin.register(Task)
 class TaskAdmin(admin.ModelAdmin):
-    list_display = ('title', 'status', 'assigned_to', 'vehicle', 'work_order', 'created_at')
-    list_filter = ('status', 'created_at', 'work_order')
+    list_display = ('title', 'status', 'scheduled_date', 'assigned_to', 'vehicle', 'work_order', 'created_at')
+    list_filter = ('status', 'scheduled_date', 'created_at', 'work_order')
     search_fields = ('title', 'description', 'work_order__id', 'work_order__vehicle__registration_number')
     readonly_fields = ('id', 'created_at', 'updated_at')
     inlines = (TaskWorkHoursTableInline, TaskWorkEntryInline)

backend/modules/task_management/migrations/0009_task_scheduled_date.py

@@ -0,0 +1,22 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('task_management', '0008_task_add_ready_for_completion_status'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='task',
+            name='scheduled_date',
+            field=models.DateField(
+                null=True,
+                blank=True,
+                db_index=True,
+                verbose_name='Planirani datum izvršenja',
+                help_text='Datum kada je planirano izvršenje radnog zadatka.',
+            ),
+        ),
+    ]

backend/modules/task_management/models.py

@@ -47,6 +47,13 @@ class Task(BaseModel):
         related_name='work_order_tasks',
         verbose_name=_("Putni nalog"),
     )
+    scheduled_date = models.DateField(
+        null=True,
+        blank=True,
+        db_index=True,
+        verbose_name=_("Planirani datum izvršenja"),
+        help_text=_("Datum kada je planirano izvršenje radnog zadatka."),
+    )
 
     class Meta:
         ordering = ['-created_at']

backend/modules/task_management/serializers.py

@@ -96,6 +96,7 @@ class TaskSerializer(serializers.ModelSerializer):
             'assigned_to', 'assigned_to_name',
             'vehicle', 'vehicle_registration',
             'work_order', 'work_order_label',
+            'scheduled_date',
             'template_id', 'auto_close_work_order',
             'created_at',
         ]
@@ -106,6 +107,7 @@ class TaskSerializer(serializers.ModelSerializer):
             'status': {'required': False},
             'work_order': {'required': False, 'allow_null': True},
             'vehicle': {'required': False, 'allow_null': True},
+            'scheduled_date': {'required': False, 'allow_null': True},
         }
 
     def validate_title(self, value):

backend/modules/task_management/tasks.py

@@ -1,10 +1,64 @@
 # backend/modules/task_management/tasks.py
 
+import logging
 from celery import shared_task
 from .models import Task
 from django.contrib.auth import get_user_model
 from modules.fleet.models import Vehicle, WorkOrder
 
+logger = logging.getLogger(__name__)
+
+
+@shared_task
+def notify_upcoming_tasks():
+    """
+    Dnevna Celery periodik task koji šalje Pusher + email notifikacije
+    za radne zadatke čiji je planirani datum izvršenja sutra.
+    """
+    from datetime import date, timedelta
+    from modules.fleet.services import NotificationService
+
+    tomorrow = date.today() + timedelta(days=1)
+    upcoming = Task.objects.filter(
+        is_active=True,
+        scheduled_date=tomorrow,
+        status__in=('aktivan', 'servis'),
+    ).select_related('assigned_to', 'vehicle')
+
+    notified = 0
+    for task in upcoming:
+        recipient = task.assigned_to
+        if not recipient:
+            continue
+        vehicle_label = (
+            task.vehicle.registration_number if task.vehicle else 'nepoznato'
+        )
+        try:
+            NotificationService.create_notification(
+                recipient=recipient,
+                title=f"Sutra planirani zadatak: {task.title}",
+                message=(
+                    f"Radni zadatak '{task.title}' na dizalici {vehicle_label} "
+                    f"je planiran za sutra ({tomorrow.strftime('%d.%m.%Y')})."
+                ),
+                level="info",
+                send_email=True,
+                metadata={
+                    "entity_type": "task",
+                    "task_id": str(task.id),
+                    "vehicle_id": str(task.vehicle_id) if task.vehicle_id else None,
+                    "section": "dashboard",
+                    "scheduled_date": tomorrow.isoformat(),
+                },
+            )
+            notified += 1
+        except Exception:
+            logger.exception("Greška pri slanju notifikacije za task %s", task.id)
+
+    logger.info("notify_upcoming_tasks: obaviješteno %d servisera za datum %s", notified, tomorrow)
+    return {"notified": notified, "date": tomorrow.isoformat()}
+
+
 @shared_task
 def create_task_from_invoice(invoice_data):
     """
@@ -25,7 +79,7 @@ def create_task_from_invoice(invoice_data):
             vehicle = work_order.vehicle
     if vehicle is None and vehicle_id:
         vehicle = Vehicle.objects.filter(pk=vehicle_id).first()
-    
+
     if amount > 1000:
         Task.objects.create(
             title=f"Provjera računa: {invoice_data['invoice_number']}",
@@ -34,4 +88,4 @@ def create_task_from_invoice(invoice_data):
             status='aktivan',
             vehicle=vehicle,
             work_order=work_order,
-        )
+        )

backend/modules/task_management/tests/test_models.py

@@ -1,5 +1,6 @@
 from django.test import TestCase
 from django.contrib.auth import get_user_model
+import datetime
 
 from modules.task_management.models import Task
 
@@ -9,4 +10,25 @@ class TaskModelTests(TestCase):
         user = get_user_model().objects.create_user(username="u1", email="u1@example.test", password="pass")
         task = Task.objects.create(title="My Task", description="Desc", assigned_to=user)
         assert str(task).startswith("My Task")
-        assert "aktivan" in str(task) or "(" in str(task)  # basic sanity
+        assert "aktivan" in str(task) or "(" in str(task)
+
+    def test_scheduled_date_defaults_to_null(self):
+        user = get_user_model().objects.create_user(username="u2", email="u2@example.test", password="pass")
+        task = Task.objects.create(title="Task bez datuma", assigned_to=user)
+        assert task.scheduled_date is None
+
+    def test_scheduled_date_is_saved_and_retrieved(self):
+        user = get_user_model().objects.create_user(username="u3", email="u3@example.test", password="pass")
+        target = datetime.date(2026, 8, 15)
+        task = Task.objects.create(title="Planirani task", assigned_to=user, scheduled_date=target)
+        task.refresh_from_db()
+        assert task.scheduled_date == target
+
+    def test_scheduled_date_can_be_updated_to_null(self):
+        user = get_user_model().objects.create_user(username="u4", email="u4@example.test", password="pass")
+        target = datetime.date(2026, 8, 15)
+        task = Task.objects.create(title="Task s datumom", assigned_to=user, scheduled_date=target)
+        task.scheduled_date = None
+        task.save()
+        task.refresh_from_db()
+        assert task.scheduled_date is None

backend/modules/task_management/tests/test_serializers.py

@@ -43,4 +43,41 @@ class TaskSerializerTests(TestCase):
         task = Task.objects.create(title="Task 4", description="", status="servis", assigned_to=self.user, vehicle=self.vehicle)
 
         serializer = TaskSerializer(instance=task, data={"status": "zavrsen", "work_order": str(work_order.id)}, partial=True)
-        assert serializer.is_valid(), serializer.errors
+        assert serializer.is_valid(), serializer.errors
+
+    def test_scheduled_date_is_optional_on_create(self):
+        serializer = TaskSerializer(data={"title": "Task planned", "status": "aktivan", "vehicle": str(self.vehicle.id)})
+        assert serializer.is_valid(), serializer.errors
+        assert 'scheduled_date' not in serializer.errors
+
+    def test_scheduled_date_is_included_in_serialized_output(self):
+        import datetime
+        task = Task.objects.create(
+            title="Task with date",
+            assigned_to=self.user,
+            vehicle=self.vehicle,
+            scheduled_date=datetime.date(2026, 9, 1),
+        )
+        serializer = TaskSerializer(instance=task)
+        assert 'scheduled_date' in serializer.data
+        assert str(serializer.data['scheduled_date']) == '2026-09-01'
+
+    def test_scheduled_date_can_be_null_in_serialized_output(self):
+        task = Task.objects.create(title="Task no date", assigned_to=self.user, vehicle=self.vehicle)
+        serializer = TaskSerializer(instance=task)
+        assert serializer.data['scheduled_date'] is None
+
+    def test_scheduled_date_accepts_valid_date(self):
+        serializer = TaskSerializer(
+            data={"title": "Task mit datum", "status": "aktivan",
+                  "vehicle": str(self.vehicle.id), "scheduled_date": "2026-12-25"}
+        )
+        assert serializer.is_valid(), serializer.errors
+
+    def test_scheduled_date_rejects_invalid_date_string(self):
+        serializer = TaskSerializer(
+            data={"title": "Task bad date", "status": "aktivan",
+                  "vehicle": str(self.vehicle.id), "scheduled_date": "not-a-date"}
+        )
+        assert not serializer.is_valid()
+        assert 'scheduled_date' in serializer.errors

backend/modules/task_management/tests/test_upcoming_notifications.py

@@ -0,0 +1,133 @@
+import datetime
+from unittest.mock import patch
+from django.test import TestCase
+from django.contrib.auth import get_user_model
+from modules.task_management.tasks import notify_upcoming_tasks
+from modules.task_management.models import Task
+from modules.fleet.models import Vehicle, WorkOrder
+
+
+class NotifyUpcomingTasksTests(TestCase):
+    def setUp(self):
+        User = get_user_model()
+        self.user = User.objects.create_user(
+            username="serviser-notif",
+            email="serviser@example.test",
+            password="pass",
+        )
+        self.vehicle = Vehicle.objects.create(
+            registration_number="ZG-NOTIF-01",
+            asset_type='crane',
+        )
+
+    @patch('modules.fleet.services.NotificationService.create_notification')
+    def test_notifies_for_task_scheduled_tomorrow(self, mock_notify):
+        tomorrow = datetime.date.today() + datetime.timedelta(days=1)
+        Task.objects.create(
+            title="Sutrašnji zadatak",
+            assigned_to=self.user,
+            vehicle=self.vehicle,
+            status='aktivan',
+            scheduled_date=tomorrow,
+        )
+        result = notify_upcoming_tasks()
+        self.assertEqual(result['notified'], 1)
+        mock_notify.assert_called_once()
+        call_kwargs = mock_notify.call_args.kwargs
+        self.assertEqual(call_kwargs['recipient'], self.user)
+        self.assertIn('Sutrašnji zadatak', call_kwargs['title'])
+        self.assertEqual(call_kwargs['level'], 'info')
+        self.assertTrue(call_kwargs.get('send_email'))
+
+    @patch('modules.fleet.services.NotificationService.create_notification')
+    def test_notifies_multiple_upcoming_tasks(self, mock_notify):
+        tomorrow = datetime.date.today() + datetime.timedelta(days=1)
+        Task.objects.create(title="Task A", assigned_to=self.user, vehicle=self.vehicle,
+                            status='aktivan', scheduled_date=tomorrow)
+        Task.objects.create(title="Task B", assigned_to=self.user, vehicle=self.vehicle,
+                            status='servis', scheduled_date=tomorrow)
+        result = notify_upcoming_tasks()
+        self.assertEqual(result['notified'], 2)
+        self.assertEqual(mock_notify.call_count, 2)
+
+    @patch('modules.fleet.services.NotificationService.create_notification')
+    def test_skips_task_without_scheduled_date(self, mock_notify):
+        Task.objects.create(
+            title="Bez datuma", assigned_to=self.user, vehicle=self.vehicle,
+            status='aktivan', scheduled_date=None,
+        )
+        result = notify_upcoming_tasks()
+        self.assertEqual(result['notified'], 0)
+        mock_notify.assert_not_called()
+
+    @patch('modules.fleet.services.NotificationService.create_notification')
+    def test_skips_task_scheduled_today(self, mock_notify):
+        today = datetime.date.today()
+        Task.objects.create(
+            title="Danas", assigned_to=self.user, vehicle=self.vehicle,
+            status='aktivan', scheduled_date=today,
+        )
+        result = notify_upcoming_tasks()
+        self.assertEqual(result['notified'], 0)
+        mock_notify.assert_not_called()
+
+    @patch('modules.fleet.services.NotificationService.create_notification')
+    def test_skips_task_scheduled_in_past(self, mock_notify):
+        yesterday = datetime.date.today() - datetime.timedelta(days=1)
+        Task.objects.create(
+            title="Jučer", assigned_to=self.user, vehicle=self.vehicle,
+            status='aktivan', scheduled_date=yesterday,
+        )
+        result = notify_upcoming_tasks()
+        self.assertEqual(result['notified'], 0)
+        mock_notify.assert_not_called()
+
+    @patch('modules.fleet.services.NotificationService.create_notification')
+    def test_skips_finished_task(self, mock_notify):
+        tomorrow = datetime.date.today() + datetime.timedelta(days=1)
+        vehicle2 = Vehicle.objects.create(registration_number="ZG-NOTIF-02", asset_type='crane')
+        work_order = WorkOrder.objects.create(
+            vehicle=vehicle2, creator=self.user, purpose='defektaza',
+            status='closed', start_mileage=100, end_mileage=200,
+        )
+        Task.objects.create(
+            title="Završeni", assigned_to=self.user, vehicle=vehicle2,
+            status='zavrsen', scheduled_date=tomorrow, work_order=work_order,
+        )
+        result = notify_upcoming_tasks()
+        self.assertEqual(result['notified'], 0)
+        mock_notify.assert_not_called()
+
+    @patch('modules.fleet.services.NotificationService.create_notification')
+    def test_skips_cancelled_task(self, mock_notify):
+        tomorrow = datetime.date.today() + datetime.timedelta(days=1)
+        vehicle3 = Vehicle.objects.create(registration_number="ZG-NOTIF-03", asset_type='crane')
+        work_order = WorkOrder.objects.create(
+            vehicle=vehicle3, creator=self.user, purpose='kontrola',
+            status='closed', start_mileage=50, end_mileage=100,
+        )
+        Task.objects.create(
+            title="Otkazani", assigned_to=self.user, vehicle=vehicle3,
+            status='neaktivan', scheduled_date=tomorrow, work_order=work_order,
+        )
+        result = notify_upcoming_tasks()
+        self.assertEqual(result['notified'], 0)
+        mock_notify.assert_not_called()
+
+    @patch('modules.fleet.services.NotificationService.create_notification')
+    def test_skips_task_without_assigned_user(self, mock_notify):
+        tomorrow = datetime.date.today() + datetime.timedelta(days=1)
+        Task.objects.create(
+            title="Bez servisera", assigned_to=None, vehicle=self.vehicle,
+            status='aktivan', scheduled_date=tomorrow,
+        )
+        result = notify_upcoming_tasks()
+        self.assertEqual(result['notified'], 0)
+        mock_notify.assert_not_called()
+
+    @patch('modules.fleet.services.NotificationService.create_notification')
+    def test_result_includes_date_string(self, mock_notify):
+        result = notify_upcoming_tasks()
+        tomorrow = datetime.date.today() + datetime.timedelta(days=1)
+        self.assertEqual(result['date'], tomorrow.isoformat())
+        self.assertEqual(result['notified'], 0)

backend/modules/task_management/views.py

@@ -27,6 +27,9 @@ class TaskViewSet(viewsets.ModelViewSet):
         vehicle_id = self.request.query_params.get('vehicle')
         if vehicle_id:
             qs = qs.filter(vehicle_id=vehicle_id)
+        scheduled_date = self.request.query_params.get('scheduled_date')
+        if scheduled_date:
+            qs = qs.filter(scheduled_date=scheduled_date)
         return qs
 
     def perform_create(self, serializer):