redisign and bug fix

backend/api.py

@@ -1,19 +1,13 @@
-from fastapi import APIRouter, Depends, HTTPException, Body
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, and_, or_
 from datetime import datetime, timedelta
-import pytz
-from typing import List, Union
 
-from backend.database import get_db, Task, Event, WeeklyTaskException
-from backend.models import (
-    TaskCreate, EventCreate, ScheduleResponse, ScheduleItem,
-    TaskResponse, EventResponse, UpdateRequest
-)
-from backend.utils import (
-    get_week_range, check_event_overlap, get_weekday_from_date,
-    materialize_weekly_tasks, format_date_russian
-)
+import pytz
+from fastapi import APIRouter, Depends, HTTPException, Body
+from sqlalchemy import and_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.database import get_db, Task, Event, WeeklyTaskException, EventException
+from backend.models import TaskCreate, EventCreate, ScheduleResponse, ScheduleItem, UpdateRequest
+from backend.utils import check_event_overlap, get_weekday_from_date, materialize_weekly_tasks, materialize_events
 
 router = APIRouter()
 
@@ -26,16 +20,18 @@ async def get_schedule(
     to_date: str,
     db: AsyncSession = Depends(get_db)
 ):
-    """Получить расписание в диапазоне дат"""
+    """Получить расписание в диапазоне дат."""
     try:
         from_dt = datetime.strptime(from_date, "%Y-%m-%d").date()
         to_dt = datetime.strptime(to_date, "%Y-%m-%d").date()
     except ValueError:
         raise HTTPException(status_code=400, detail="Invalid date format. Use YYYY-MM-DD")
-    
+
+    if to_dt < from_dt:
+        raise HTTPException(status_code=400, detail="to_date must be greater than or equal to from_date")
+
     items = []
-    
-    # Получаем разовые tasks
+
     result = await db.execute(
         select(Task).where(
             and_(
@@ -51,34 +47,14 @@ async def get_schedule(
             kind="task",
             id=task.id,
             date=task.date,
+            source_date=task.date,
             title=task.title,
             repeat_weekly=False
         ))
-    
-    # Получаем events
-    result = await db.execute(
-        select(Event).where(
-            and_(
-                Event.date >= from_date,
-                Event.date <= to_date
-            )
-        )
-    )
-    events = result.scalars().all()
-    for event in events:
-        items.append(ScheduleItem(
-            kind="event",
-            id=event.id,
-            date=event.date,
-            title=event.title,
-            start_time=event.start_time,
-            duration_min=event.duration_min
-        ))
-    
-    # Материализуем weekly tasks
-    weekly_tasks = await materialize_weekly_tasks(db, from_date, to_date)
-    items.extend(weekly_tasks)
-    
+
+    items.extend(await materialize_weekly_tasks(db, from_date, to_date))
+    items.extend(await materialize_events(db, from_date, to_date))
+
     return ScheduleResponse(items=items)
 
 
@@ -88,74 +64,69 @@ async def create_item(
     data: dict = Body(...),
     db: AsyncSession = Depends(get_db)
 ):
-    """Создать task или event"""
+    """Создать task или event."""
     if kind == "task":
         try:
             task = TaskCreate(**data)
-        except Exception as e:
-            raise HTTPException(status_code=400, detail=f"Invalid task data: {e}")
-        
-        # Создаём основную task
+        except Exception as exc:
+            raise HTTPException(status_code=400, detail=f"Invalid task data: {exc}")
+
         new_task = Task(
             date=task.date,
             title=task.title,
             repeat_weekly=task.repeat_weekly
         )
-        
         if task.repeat_weekly:
-            weekday = get_weekday_from_date(task.date)
-            new_task.weekday = weekday
-        
+            new_task.weekday = get_weekday_from_date(task.date)
+
         db.add(new_task)
         await db.commit()
         await db.refresh(new_task)
-        
-        # Копирование на другие дни недели
+
         if task.copy_to_weekdays and not task.repeat_weekly:
             base_date = datetime.strptime(task.date, "%Y-%m-%d").date()
             base_weekday = base_date.weekday()
             for target_weekday in task.copy_to_weekdays:
-                # Вычисляем дату целевого дня недели в той же неделе
-                days_diff = (target_weekday - base_weekday) % 7
-                if days_diff > 0:  # только будущие дни
-                    target_date = base_date + timedelta(days=days_diff)
-                    copy_task = Task(
-                        date=target_date.strftime("%Y-%m-%d"),
-                        title=task.title,
-                        repeat_weekly=False
-                    )
-                    db.add(copy_task)
+                days_diff = target_weekday - base_weekday
+                if days_diff <= 0:
+                    continue
+                target_date = base_date + timedelta(days=days_diff)
+                db.add(Task(
+                    date=target_date.strftime("%Y-%m-%d"),
+                    title=task.title,
+                    repeat_weekly=False
+                ))
             await db.commit()
-        
+
         return {"id": new_task.id, "kind": "task"}
-    
-    elif kind == "event":
+
+    if kind == "event":
         try:
             event = EventCreate(**data)
-        except Exception as e:
-            raise HTTPException(status_code=400, detail=f"Invalid event data: {e}")
-        
-        # Проверка пересечений
-        overlap = await check_event_overlap(
-            db, event.date, event.start_time, event.duration_min, None
-        )
+        except Exception as exc:
+            raise HTTPException(status_code=400, detail=f"Invalid event data: {exc}")
+
+        overlap = await check_event_overlap(db, event.date, event.start_time, event.duration_min, None)
         if overlap:
             raise HTTPException(status_code=400, detail="Нельзя добавить: пересечение по времени")
-        
+
         new_event = Event(
             date=event.date,
             start_time=event.start_time,
             duration_min=event.duration_min,
-            title=event.title
+            title=event.title,
+            repeat_weekly=event.repeat_weekly
         )
+        if event.repeat_weekly:
+            new_event.weekday = get_weekday_from_date(event.date)
+
         db.add(new_event)
         await db.commit()
         await db.refresh(new_event)
-        
+
         return {"id": new_event.id, "kind": "event"}
-    
-    else:
-        raise HTTPException(status_code=400, detail="Invalid kind. Use 'task' or 'event'")
+
+    raise HTTPException(status_code=400, detail="Invalid kind. Use 'task' or 'event'")
 
 
 @router.put("/events/{item_id}")
@@ -164,130 +135,200 @@ async def update_item(
     update: UpdateRequest,
     db: AsyncSession = Depends(get_db)
 ):
-    """Обновить task или event"""
-    # Пробуем найти как task
+    """Обновить task или event."""
     result = await db.execute(select(Task).where(Task.id == item_id))
     task = result.scalar_one_or_none()
-    
+
     if task:
         if task.repeat_weekly and update.scope == "one_date":
-            # Создаём исключение для конкретной даты
-            weekday = get_weekday_from_date(task.date)
+            occurrence_date = update.occurrence_date or task.date
+            result = await db.execute(
+                select(WeeklyTaskException).where(
+                    and_(
+                        WeeklyTaskException.task_id == task.id,
+                        WeeklyTaskException.date == occurrence_date
+                    )
+                )
+            )
+            for existing_exception in result.scalars().all():
+                await db.delete(existing_exception)
             exception = WeeklyTaskException(
-                weekday=weekday,
-                date=task.date,
-                action="replace" if update.title else "delete",
-                replacement_title=update.title
+                task_id=task.id,
+                weekday=get_weekday_from_date(occurrence_date),
+                date=occurrence_date,
+                action="replace",
+                replacement_title=update.title or task.title,
+                replacement_date=update.date or occurrence_date
             )
             db.add(exception)
             await db.commit()
             return {"success": True, "action": "exception_created"}
-        
+
         if update.title:
-            if task.repeat_weekly and update.scope == "series":
-                # Обновляем все weekly tasks с этим weekday
-                await db.execute(
-                    Task.__table__.update()
-                    .where(Task.weekday == task.weekday)
-                    .values(title=update.title)
-                )
-            else:
-                task.title = update.title
-        
+            task.title = update.title
+        if update.date:
+            task.date = update.date
+            if task.repeat_weekly:
+                task.weekday = get_weekday_from_date(update.date)
+
         await db.commit()
         return {"success": True}
-    
-    # Пробуем найти как event
+
     result = await db.execute(select(Event).where(Event.id == item_id))
     event = result.scalar_one_or_none()
-    
-    if event:
-        new_date = update.date or event.date
-        new_start_time = update.start_time or event.start_time
-        new_duration = update.duration_min or event.duration_min
-        
-        # Проверка пересечений
+    if not event:
+        raise HTTPException(status_code=404, detail="Item not found")
+
+    if event.repeat_weekly and update.scope == "one_date":
+        occurrence_date = update.occurrence_date or event.date
+        replacement_date = update.date or occurrence_date
+        replacement_start_time = update.start_time or event.start_time
+        replacement_duration = update.duration_min or event.duration_min
+
         overlap = await check_event_overlap(
-            db, new_date, new_start_time, new_duration, item_id
+            db,
+            replacement_date,
+            replacement_start_time,
+            replacement_duration,
+            item_id,
+            occurrence_date=occurrence_date
         )
         if overlap:
             raise HTTPException(status_code=400, detail="Нельзя изменить: пересечение по времени")
-        
-        if update.title:
-            event.title = update.title
-        if update.date:
-            event.date = update.date
-        if update.start_time:
-            event.start_time = update.start_time
-        if update.duration_min:
-            event.duration_min = update.duration_min
-        
+
+        result = await db.execute(
+            select(EventException).where(
+                and_(
+                    EventException.event_id == event.id,
+                    EventException.date == occurrence_date
+                )
+            )
+        )
+        for existing_exception in result.scalars().all():
+            await db.delete(existing_exception)
+
+        db.add(EventException(
+            event_id=event.id,
+            date=occurrence_date,
+            action="replace",
+            replacement_title=update.title or event.title,
+            replacement_date=replacement_date,
+            replacement_start_time=replacement_start_time,
+            replacement_duration_min=replacement_duration
+        ))
         await db.commit()
-        return {"success": True}
-    
-    raise HTTPException(status_code=404, detail="Item not found")
+        return {"success": True, "action": "exception_created"}
+
+    new_date = update.date or event.date
+    new_start_time = update.start_time or event.start_time
+    new_duration = update.duration_min or event.duration_min
+
+    overlap = await check_event_overlap(db, new_date, new_start_time, new_duration, item_id)
+    if overlap:
+        raise HTTPException(status_code=400, detail="Нельзя изменить: пересечение по времени")
+
+    if update.title:
+        event.title = update.title
+    if update.date:
+        event.date = update.date
+        if event.repeat_weekly:
+            event.weekday = get_weekday_from_date(update.date)
+    if update.start_time:
+        event.start_time = update.start_time
+    if update.duration_min:
+        event.duration_min = update.duration_min
+
+    await db.commit()
+    return {"success": True}
 
 
 @router.delete("/events/{item_id}")
 async def delete_item(
     item_id: int,
     scope: str = None,
+    occurrence_date: str = None,
     db: AsyncSession = Depends(get_db)
 ):
-    """Удалить task или event"""
-    # Пробуем найти как task
+    """Удалить task или event."""
     result = await db.execute(select(Task).where(Task.id == item_id))
     task = result.scalar_one_or_none()
-    
+
     if task:
-        if task.repeat_weekly:
-            if scope == "one_date":
-                # Создаём исключение на удаление
-                weekday = get_weekday_from_date(task.date)
-                exception = WeeklyTaskException(
-                    weekday=weekday,
-                    date=task.date,
-                    action="delete"
+        if task.repeat_weekly and scope == "one_date":
+            delete_date = occurrence_date or task.date
+            result = await db.execute(
+                select(WeeklyTaskException).where(
+                    and_(
+                        WeeklyTaskException.task_id == task.id,
+                        WeeklyTaskException.date == delete_date
+                    )
                 )
-                db.add(exception)
-                await db.commit()
-                return {"success": True, "action": "exception_created"}
-            elif scope == "series":
-                # Удаляем все weekly tasks с этим weekday
-                await db.execute(
-                    Task.__table__.delete().where(Task.weekday == task.weekday)
-                )
-                await db.commit()
-                return {"success": True}
-        
+            )
+            for existing_exception in result.scalars().all():
+                await db.delete(existing_exception)
+            db.add(WeeklyTaskException(
+                task_id=task.id,
+                weekday=get_weekday_from_date(delete_date),
+                date=delete_date,
+                action="delete"
+            ))
+            await db.commit()
+            return {"success": True, "action": "exception_created"}
+
+        if task.repeat_weekly and scope == "series":
+            result = await db.execute(select(WeeklyTaskException).where(WeeklyTaskException.task_id == task.id))
+            for exception in result.scalars().all():
+                await db.delete(exception)
+
         await db.delete(task)
         await db.commit()
         return {"success": True}
-    
-    # Пробуем найти как event
+
     result = await db.execute(select(Event).where(Event.id == item_id))
     event = result.scalar_one_or_none()
-    
-    if event:
-        await db.delete(event)
+    if not event:
+        raise HTTPException(status_code=404, detail="Item not found")
+
+    if event.repeat_weekly and scope == "one_date":
+        delete_date = occurrence_date or event.date
+        result = await db.execute(
+            select(EventException).where(
+                and_(
+                    EventException.event_id == event.id,
+                    EventException.date == delete_date
+                )
+            )
+        )
+        for existing_exception in result.scalars().all():
+            await db.delete(existing_exception)
+        db.add(EventException(
+            event_id=event.id,
+            date=delete_date,
+            action="delete"
+        ))
         await db.commit()
-        return {"success": True}
-    
-    raise HTTPException(status_code=404, detail="Item not found")
+        return {"success": True, "action": "exception_created"}
+
+    if event.repeat_weekly and scope == "series":
+        result = await db.execute(select(EventException).where(EventException.event_id == event.id))
+        for exception in result.scalars().all():
+            await db.delete(exception)
+
+    await db.delete(event)
+    await db.commit()
+    return {"success": True}
 
 
 @router.get("/backup")
 async def backup_database():
-    """Создать backup базы данных"""
-    import shutil
+    """Создать backup базы данных."""
     import os
-    from datetime import datetime
-    
+    import shutil
+
     db_path = os.getenv("DATABASE_PATH", "data/schedule.db")
     backup_path = f"{db_path}.backup.{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-    
+
     if os.path.exists(db_path):
         shutil.copy2(db_path, backup_path)
         return {"success": True, "backup_path": backup_path}
     return {"success": False, "error": "Database not found"}
-