Spaces:
Paused
Paused
File size: 7,086 Bytes
b70ff07 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 |
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, delete
from typing import List, Dict, Any, Optional
from datetime import datetime, timedelta
from ..core.dependencies import get_current_active_user
from ..db.database import get_db
from ..db.models import Event, User
from pydantic import BaseModel
router = APIRouter()
class RecurringEventCreate(BaseModel):
title: str
description: str
start_time: datetime
end_time: datetime
recurrence_pattern: str
recurrence_end_date: Optional[datetime] = None
attendees: List[str] = []
reminder_minutes: int = 30
class RecurringEventUpdate(BaseModel):
title: Optional[str] = None
description: Optional[str] = None
start_time: Optional[datetime] = None
end_time: Optional[datetime] = None
attendees: Optional[List[str]] = None
reminder_minutes: Optional[int] = None
@router.post("/recurring-events")
async def create_recurring_event(
event_data: RecurringEventCreate,
current_user: User = Depends(get_current_active_user),
db: AsyncSession = Depends(get_db)
) -> List[Dict[str, Any]]:
"""Create a new recurring event"""
if event_data.recurrence_pattern not in ["daily", "weekly", "monthly", "yearly"]:
raise HTTPException(
status_code=400,
detail="Invalid recurrence pattern. Must be one of: daily, weekly, monthly, yearly"
)
if event_data.start_time >= event_data.end_time:
raise HTTPException(
status_code=400,
detail="End time must be after start time"
)
events = []
current_start = event_data.start_time
current_end = event_data.end_time
duration = event_data.end_time - event_data.start_time
sequence_number = 0
while True:
if event_data.recurrence_end_date and current_start > event_data.recurrence_end_date:
break
event = Event(
user_id=current_user.id,
title=event_data.title,
description=event_data.description,
start_time=current_start,
end_time=current_end,
attendees=event_data.attendees,
reminder_minutes=event_data.reminder_minutes,
is_recurring=True,
recurrence_pattern=event_data.recurrence_pattern,
sequence_number=sequence_number,
status="scheduled"
)
db.add(event)
events.append(event)
# Calculate next occurrence
sequence_number += 1
if event_data.recurrence_pattern == "daily":
current_start += timedelta(days=1)
elif event_data.recurrence_pattern == "weekly":
current_start += timedelta(weeks=1)
elif event_data.recurrence_pattern == "monthly":
# Add one month (approximately)
if current_start.month == 12:
current_start = current_start.replace(year=current_start.year + 1, month=1)
else:
current_start = current_start.replace(month=current_start.month + 1)
elif event_data.recurrence_pattern == "yearly":
current_start = current_start.replace(year=current_start.year + 1)
current_end = current_start + duration
await db.commit()
# Refresh all events to get their IDs
for event in events:
await db.refresh(event)
return events
@router.put("/recurring-events/{event_id}")
async def update_recurring_event(
event_id: int,
event_update: RecurringEventUpdate,
update_future: bool = True,
current_user: User = Depends(get_current_active_user),
db: AsyncSession = Depends(get_db)
) -> List[Dict[str, Any]]:
"""Update a recurring event and optionally its future occurrences"""
update_data = event_update.dict(exclude_unset=True)
if not update_data:
raise HTTPException(status_code=400, detail="No update data provided")
# Get the original event
stmt = select(Event).where(
Event.id == event_id,
Event.user_id == current_user.id
)
result = await db.execute(stmt)
event = result.scalar_one_or_none()
if not event:
raise HTTPException(
status_code=404,
detail="Event not found or you don't have permission to update it"
)
updated_events = [event]
# Update future occurrences if requested
if update_future and event.is_recurring:
future_stmt = select(Event).where(
Event.recurrence_group == event.recurrence_group,
Event.sequence_number > event.sequence_number,
Event.user_id == current_user.id
)
future_result = await db.execute(future_stmt)
future_events = future_result.scalars().all()
for future_event in future_events:
for field, value in update_data.items():
setattr(future_event, field, value)
updated_events.append(future_event)
await db.commit()
return updated_events
@router.delete("/recurring-events/{event_id}")
async def delete_recurring_event(
event_id: int,
delete_future: bool = True,
current_user: User = Depends(get_current_active_user),
db: AsyncSession = Depends(get_db)
) -> Dict[str, bool]:
"""Delete a recurring event and optionally its future occurrences"""
stmt = select(Event).where(
Event.id == event_id,
Event.user_id == current_user.id
)
result = await db.execute(stmt)
event = result.scalar_one_or_none()
if not event:
raise HTTPException(
status_code=404,
detail="Event not found or you don't have permission to delete it"
)
if delete_future and event.is_recurring:
delete_stmt = delete(Event).where(
Event.recurrence_group == event.recurrence_group,
Event.sequence_number >= event.sequence_number,
Event.user_id == current_user.id
)
await db.execute(delete_stmt)
else:
await db.delete(event)
await db.commit()
return {"success": True}
@router.get("/recurring-events/upcoming")
async def get_upcoming_recurring_events(
days: int = 30,
current_user: User = Depends(get_current_active_user),
db: AsyncSession = Depends(get_db)
) -> List[Dict[str, Any]]:
"""Get upcoming recurring events for the next N days"""
if days <= 0 or days > 365:
raise HTTPException(
status_code=400,
detail="Days parameter must be between 1 and 365"
)
end_date = datetime.utcnow() + timedelta(days=days)
stmt = select(Event).where(
Event.user_id == current_user.id,
Event.start_time <= end_date,
Event.is_recurring == True
).order_by(Event.start_time)
result = await db.execute(stmt)
return result.scalars().all() |