from datetime import date, datetime, timedelta from typing import Dict, List, Optional from fastapi import Depends, FastAPI, HTTPException, Query from fastapi.middleware.cors import CORSMiddleware from pydantic import BaseModel from sqlalchemy import and_, desc, select from sqlalchemy.ext.asyncio import AsyncSession from services.calendar_service.models import CalendarEntry, CycleData, HealthInsights import services.calendar_service.schemas as schemas from services.calendar_service.schemas import (CalendarEntryCreate, CalendarEntryResponse, CycleDataResponse, CycleOverview, EntryType, FlowIntensity, HealthInsightResponse, MoodType, CalendarEventCreate) from shared.auth import get_current_user_from_token as get_current_user from shared.config import settings from shared.database import get_db app = FastAPI(title="Calendar Service", version="1.0.0") # CORS middleware app.add_middleware( CORSMiddleware, allow_origins=settings.CORS_ORIGINS, allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) @app.get("/health") async def health_check(): """Health check endpoint""" return {"status": "healthy", "service": "calendar_service"} # Используем классы из schemas def calculate_cycle_phase( cycle_start: date, cycle_length: int, current_date: date ) -> str: """Calculate current cycle phase""" days_since_start = (current_date - cycle_start).days if days_since_start <= 5: return "menstrual" elif days_since_start <= cycle_length // 2 - 2: return "follicular" elif cycle_length // 2 - 2 < days_since_start <= cycle_length // 2 + 2: return "ovulation" else: return "luteal" async def calculate_predictions(user_id: int, db: AsyncSession): """Calculate cycle predictions based on historical data""" # Get last 6 cycles for calculations cycles = await db.execute( select(CycleData) .filter(CycleData.user_id == user_id) .order_by(desc(CycleData.cycle_start_date)) .limit(6) ) cycle_list = cycles.scalars().all() if len(cycle_list) < 2: return None # Calculate averages cycle_lengths = [c.cycle_length for c in cycle_list if c.cycle_length] period_lengths = [c.period_length for c in cycle_list if c.period_length] if not cycle_lengths: return None avg_cycle = sum(cycle_lengths) / len(cycle_lengths) avg_period = sum(period_lengths) / len(period_lengths) if period_lengths else 5 # Predict next period last_cycle = cycle_list[0] next_period_date = last_cycle.cycle_start_date + timedelta(days=int(avg_cycle)) return { "avg_cycle_length": int(avg_cycle), "avg_period_length": int(avg_period), "next_period_predicted": next_period_date, "ovulation_date": last_cycle.cycle_start_date + timedelta(days=int(avg_cycle // 2)), } @app.post("/api/v1/entries", response_model=CalendarEntryResponse, status_code=201) @app.post("/api/v1/entry", response_model=CalendarEntryResponse, status_code=201) async def create_calendar_entry_legacy( entry_data: CalendarEntryCreate, current_user: Dict = Depends(get_current_user), db: AsyncSession = Depends(get_db), ): """Create a new calendar entry via legacy endpoint""" return await create_calendar_entry(entry_data, current_user, db) @app.post("/api/v1/calendar/entry", response_model=CalendarEntryResponse, status_code=201) async def create_calendar_entry_mobile_app( entry_data: CalendarEventCreate, current_user: Dict = Depends(get_current_user), db: AsyncSession = Depends(get_db), ): """Create a new calendar entry via mobile app format endpoint""" # Convert mobile app format to server format server_entry_data = entry_data.to_server_format() response = await create_calendar_entry(server_entry_data, current_user, db) return response async def update_cycle_data(user_id: int, period_date: date, db: AsyncSession): """Update cycle data when period is logged""" # Get last cycle last_cycle = await db.execute( select(CycleData) .filter(CycleData.user_id == user_id) .order_by(desc(CycleData.cycle_start_date)) .limit(1) ) last_cycle_data = last_cycle.scalars().first() if last_cycle_data: # Calculate cycle length cycle_length = (period_date - last_cycle_data.cycle_start_date).days last_cycle_data.cycle_length = cycle_length # Create new cycle predictions = await calculate_predictions(user_id, db) new_cycle = CycleData( user_id=user_id, cycle_start_date=period_date, avg_cycle_length=predictions["avg_cycle_length"] if predictions else None, next_period_predicted=predictions["next_period_predicted"] if predictions else None, ovulation_date=predictions["ovulation_date"] if predictions else None, ) db.add(new_cycle) await db.commit() @app.get("/api/v1/entries", response_model=List[CalendarEntryResponse]) async def get_calendar_entries( current_user: Dict = Depends(get_current_user), db: AsyncSession = Depends(get_db), start_date: Optional[date] = Query(None), end_date: Optional[date] = Query(None), entry_type: Optional[EntryType] = Query(None), limit: int = Query(100, ge=1, le=365), ): """Get calendar entries with optional filtering""" query = select(CalendarEntry).filter(CalendarEntry.user_id == current_user["user_id"]) if start_date: query = query.filter(CalendarEntry.entry_date >= start_date) if end_date: query = query.filter(CalendarEntry.entry_date <= end_date) if entry_type: query = query.filter(CalendarEntry.entry_type == entry_type.value) query = query.order_by(desc(CalendarEntry.entry_date)).limit(limit) result = await db.execute(query) entries = result.scalars().all() return [CalendarEntryResponse.model_validate(entry) for entry in entries] @app.get("/api/v1/cycle-overview", response_model=CycleOverview) async def get_cycle_overview( current_user: Dict = Depends(get_current_user), db: AsyncSession = Depends(get_db) ): """Get current cycle overview and predictions""" # Get current cycle current_cycle = await db.execute( select(CycleData) .filter(CycleData.user_id == current_user["user_id"]) .order_by(desc(CycleData.cycle_start_date)) .limit(1) ) cycle_data = current_cycle.scalars().first() if not cycle_data: return CycleOverview( current_cycle_day=None, current_phase="unknown", next_period_date=None, days_until_period=None, cycle_regularity="unknown", avg_cycle_length=None, ) today = date.today() current_cycle_day = (today - cycle_data.cycle_start_date).days + 1 # Calculate current phase cycle_length = cycle_data.avg_cycle_length or 28 current_phase = calculate_cycle_phase( cycle_data.cycle_start_date, cycle_length, today ) # Days until next period next_period_date = cycle_data.next_period_predicted days_until_period = None if next_period_date: days_until_period = (next_period_date - today).days # Calculate regularity cycles = await db.execute( select(CycleData) .filter(CycleData.user_id == current_user["user_id"]) .order_by(desc(CycleData.cycle_start_date)) .limit(6) ) cycle_list = cycles.scalars().all() regularity = "unknown" if len(cycle_list) >= 3: lengths = [c.cycle_length for c in cycle_list if c.cycle_length] if lengths: variance = max(lengths) - min(lengths) if variance <= 2: regularity = "very_regular" elif variance <= 5: regularity = "regular" elif variance <= 10: regularity = "irregular" else: regularity = "very_irregular" return CycleOverview( current_cycle_day=current_cycle_day, current_phase=current_phase, next_period_date=next_period_date, days_until_period=days_until_period, cycle_regularity=regularity, avg_cycle_length=cycle_data.avg_cycle_length, ) @app.get("/api/v1/insights", response_model=List[HealthInsightResponse]) async def get_health_insights( current_user: Dict = Depends(get_current_user), db: AsyncSession = Depends(get_db), limit: int = Query(10, ge=1, le=50), ): """Get personalized health insights""" result = await db.execute( select(HealthInsights) .filter( HealthInsights.user_id == current_user["user_id"], HealthInsights.is_dismissed == False, ) .order_by(desc(HealthInsights.created_at)) .limit(limit) ) insights = result.scalars().all() return [HealthInsightResponse.model_validate(insight) for insight in insights] @app.get("/api/v1/calendar/entries", response_model=List[CalendarEntryResponse]) async def get_all_calendar_entries( start_date: Optional[date] = None, end_date: Optional[date] = None, entry_type: Optional[EntryType] = None, current_user: Dict = Depends(get_current_user), db: AsyncSession = Depends(get_db), limit: int = Query(100, ge=1, le=500), ): """Get all calendar entries for the current user""" query = select(CalendarEntry).filter(CalendarEntry.user_id == current_user["user_id"]) if start_date: query = query.filter(CalendarEntry.entry_date >= start_date) if end_date: query = query.filter(CalendarEntry.entry_date <= end_date) if entry_type: query = query.filter(CalendarEntry.entry_type == entry_type) query = query.order_by(CalendarEntry.entry_date.desc()).limit(limit) result = await db.execute(query) entries = result.scalars().all() return [CalendarEntryResponse.model_validate(entry) for entry in entries] @app.post("/api/v1/calendar/entries", response_model=CalendarEntryResponse, status_code=201) async def create_calendar_entry( entry_data: CalendarEntryCreate, current_user: Dict = Depends(get_current_user), db: AsyncSession = Depends(get_db), ): """Create a new calendar entry""" # Debug prints import logging logging.info(f"Current user: {current_user}") logging.info(f"Entry data: {entry_data}") try: # Check if entry already exists for this date and type existing = await db.execute( select(CalendarEntry).filter( and_( CalendarEntry.user_id == current_user["user_id"], CalendarEntry.entry_date == entry_data.entry_date, CalendarEntry.entry_type == entry_data.entry_type.value, ) ) ) if existing.scalars().first(): raise HTTPException( status_code=400, detail="Entry already exists for this date and type" ) except Exception as e: logging.error(f"Error checking for existing entry: {str(e)}") raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}") # Create new calendar entry new_entry = CalendarEntry( user_id=current_user["user_id"], entry_date=entry_data.entry_date, entry_type=entry_data.entry_type.value, flow_intensity=entry_data.flow_intensity.value if entry_data.flow_intensity else None, period_symptoms=entry_data.period_symptoms, mood=entry_data.mood.value if entry_data.mood else None, energy_level=entry_data.energy_level, sleep_hours=entry_data.sleep_hours, symptoms=entry_data.symptoms, medications=entry_data.medications, notes=entry_data.notes, ) db.add(new_entry) await db.commit() await db.refresh(new_entry) # If this is a period entry, update cycle data if entry_data.entry_type == EntryType.PERIOD: await update_cycle_data(current_user["user_id"], entry_data.entry_date, db) return CalendarEntryResponse.model_validate(new_entry) @app.delete("/api/v1/entries/{entry_id}") async def delete_calendar_entry( entry_id: int, current_user: Dict = Depends(get_current_user), db: AsyncSession = Depends(get_db), ): """Delete calendar entry""" result = await db.execute( select(CalendarEntry).filter( and_(CalendarEntry.id == entry_id, CalendarEntry.user_id == current_user["user_id"]) ) ) entry = result.scalars().first() if not entry: raise HTTPException(status_code=404, detail="Entry not found") await db.delete(entry) await db.commit() return {"message": "Entry deleted successfully"} @app.get("/api/v1/health") async def health_check(): """Health check endpoint""" return {"status": "healthy", "service": "calendar-service"} # Новый эндпоинт для мобильного приложения @app.post("/api/v1/calendar/entry", response_model=schemas.CalendarEvent, status_code=201) async def create_mobile_calendar_entry( entry_data: schemas.CalendarEventCreate, current_user: Dict = Depends(get_current_user), db: AsyncSession = Depends(get_db), ): """Create a new calendar entry from mobile app""" import logging logging.info(f"Received mobile entry data: {entry_data}") # Преобразуем в серверный формат server_entry_data = entry_data.to_server_format() logging.info(f"Converted to server format: {server_entry_data}") # Проверяем существование записи try: existing = await db.execute( select(CalendarEntry).filter( and_( CalendarEntry.user_id == current_user["user_id"], CalendarEntry.entry_date == server_entry_data.entry_date, CalendarEntry.entry_type == server_entry_data.entry_type.value, ) ) ) existing_entry = existing.scalars().first() if existing_entry: # Если запись существует, обновляем её if server_entry_data.flow_intensity: existing_entry.flow_intensity = server_entry_data.flow_intensity.value if server_entry_data.symptoms: existing_entry.symptoms = server_entry_data.symptoms if server_entry_data.mood: existing_entry.mood = server_entry_data.mood.value if server_entry_data.notes: existing_entry.notes = server_entry_data.notes await db.commit() await db.refresh(existing_entry) # Возвращаем обновлённую запись response = schemas.CalendarEntryResponse.model_validate(existing_entry) return schemas.CalendarEvent.from_server_response(response) # Создаем новую запись db_entry = CalendarEntry( user_id=current_user["user_id"], entry_date=server_entry_data.entry_date, entry_type=server_entry_data.entry_type.value, flow_intensity=server_entry_data.flow_intensity.value if server_entry_data.flow_intensity else None, period_symptoms=server_entry_data.period_symptoms, mood=server_entry_data.mood.value if server_entry_data.mood else None, energy_level=server_entry_data.energy_level, sleep_hours=server_entry_data.sleep_hours, symptoms=server_entry_data.symptoms, medications=server_entry_data.medications, notes=server_entry_data.notes, ) db.add(db_entry) await db.commit() await db.refresh(db_entry) # Если это запись о периоде, обновляем данные цикла if server_entry_data.entry_type == schemas.EntryType.PERIOD: await update_cycle_data(current_user["user_id"], server_entry_data.entry_date, db) # Преобразуем в формат для мобильного приложения response = schemas.CalendarEntryResponse.model_validate(db_entry) return schemas.CalendarEvent.from_server_response(response) except Exception as e: logging.error(f"Error creating calendar entry: {str(e)}") raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}") if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8004)