Andrew K. Choi
76d0d86211
All checks were successful
continuous-integration/drone/push Build is passing
686 lines
27 KiB
Python
686 lines
27 KiB
Python
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 services.calendar_service.mobile_endpoint import MobileCalendarEntryCreate, mobile_create_calendar_entry
|
||
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"}
|
||
|
||
@app.get("/debug/entries")
|
||
async def debug_entries(db: AsyncSession = Depends(get_db)):
|
||
"""Debug endpoint for entries without auth"""
|
||
# Получить последние 10 записей из БД для отладки
|
||
query = select(CalendarEntry).limit(10)
|
||
result = await db.execute(query)
|
||
entries = result.scalars().all()
|
||
|
||
# Преобразовать в словари для ответа
|
||
entries_list = []
|
||
for entry in entries:
|
||
entry_dict = {
|
||
"id": entry.id,
|
||
"user_id": entry.user_id,
|
||
"entry_date": str(entry.entry_date),
|
||
"entry_type": entry.entry_type,
|
||
"note": entry.notes,
|
||
"symptoms": entry.symptoms,
|
||
"flow_intensity": entry.flow_intensity,
|
||
"mood": entry.mood,
|
||
"created_at": str(entry.created_at)
|
||
}
|
||
entries_list.append(entry_dict)
|
||
|
||
return entries_list
|
||
|
||
@app.get("/debug/add-entry")
|
||
async def debug_add_entry(db: AsyncSession = Depends(get_db)):
|
||
"""Debug endpoint to add a test entry without auth"""
|
||
try:
|
||
# Создаем тестовую запись
|
||
new_entry = CalendarEntry(
|
||
user_id=29, # ID пользователя
|
||
entry_date=date.today(),
|
||
entry_type="period",
|
||
flow_intensity="medium",
|
||
period_symptoms=["cramps", "headache"],
|
||
mood="neutral",
|
||
symptoms=["headache", "cramps"],
|
||
notes="Test entry added via debug endpoint",
|
||
is_predicted=False
|
||
)
|
||
|
||
db.add(new_entry)
|
||
await db.commit()
|
||
await db.refresh(new_entry)
|
||
|
||
return {
|
||
"message": "Test entry added successfully",
|
||
"entry_id": new_entry.id,
|
||
"user_id": new_entry.user_id,
|
||
"entry_date": str(new_entry.entry_date),
|
||
"entry_type": new_entry.entry_type
|
||
}
|
||
except Exception as e:
|
||
await db.rollback()
|
||
return {"error": str(e)}
|
||
|
||
|
||
# Используем классы из 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.post("/api/v1/calendar/entries/mobile", response_model=CalendarEntryResponse, status_code=201)
|
||
async def create_mobile_calendar_entry_endpoint(
|
||
mobile_entry: MobileCalendarEntryCreate,
|
||
current_user: Dict = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""Создать новую запись календаря из мобильного приложения"""
|
||
import logging
|
||
logging.info(f"Получены данные мобильного приложения: {mobile_entry.model_dump()}")
|
||
|
||
try:
|
||
# Преобразуем симптомы из списка в строку
|
||
symptoms_str = ""
|
||
if mobile_entry.symptoms:
|
||
symptoms_str = ", ".join(mobile_entry.symptoms)
|
||
logging.info(f"Преобразованы симптомы в строку: {symptoms_str}")
|
||
|
||
# Преобразуем данные из мобильного формата в формат сервера
|
||
server_entry = CalendarEntryCreate(
|
||
entry_date=mobile_entry.date,
|
||
entry_type=EntryType.PERIOD if mobile_entry.type == "MENSTRUATION" else
|
||
EntryType.OVULATION if mobile_entry.type == "OVULATION" else
|
||
EntryType.SYMPTOMS,
|
||
flow_intensity=FlowIntensity.from_int(mobile_entry.flow_intensity) if mobile_entry.flow_intensity else None,
|
||
mood=MoodType.from_mobile_mood(mobile_entry.mood) if mobile_entry.mood else None,
|
||
symptoms=symptoms_str,
|
||
notes=mobile_entry.notes,
|
||
# Значения по умолчанию для обязательных полей сервера
|
||
period_symptoms="",
|
||
energy_level=1, # Минимальное значение должно быть 1
|
||
sleep_hours=0,
|
||
medications="",
|
||
)
|
||
logging.info(f"Преобразовано в серверный формат: {server_entry}")
|
||
|
||
# Проверяем существование записи
|
||
existing = await db.execute(
|
||
select(CalendarEntry).filter(
|
||
and_(
|
||
CalendarEntry.user_id == current_user["user_id"],
|
||
CalendarEntry.entry_date == server_entry.entry_date,
|
||
CalendarEntry.entry_type == server_entry.entry_type.value,
|
||
)
|
||
)
|
||
)
|
||
existing_entry = existing.scalars().first()
|
||
|
||
if existing_entry:
|
||
logging.info(f"Найдена существующая запись с ID: {existing_entry.id}")
|
||
# Если запись существует, обновляем её
|
||
if server_entry.flow_intensity is not None:
|
||
setattr(existing_entry, 'flow_intensity', server_entry.flow_intensity.value if server_entry.flow_intensity else None)
|
||
if server_entry.symptoms is not None:
|
||
setattr(existing_entry, 'symptoms', server_entry.symptoms)
|
||
if server_entry.mood is not None:
|
||
setattr(existing_entry, 'mood', server_entry.mood.value if server_entry.mood else None)
|
||
if server_entry.notes is not None:
|
||
setattr(existing_entry, 'notes', server_entry.notes)
|
||
|
||
await db.commit()
|
||
await db.refresh(existing_entry)
|
||
logging.info("Существующая запись обновлена")
|
||
|
||
return CalendarEntryResponse.model_validate(existing_entry)
|
||
|
||
# Создаем новую запись в календаре
|
||
new_entry = CalendarEntry(
|
||
user_id=current_user["user_id"],
|
||
entry_date=server_entry.entry_date,
|
||
entry_type=server_entry.entry_type.value,
|
||
flow_intensity=server_entry.flow_intensity.value if server_entry.flow_intensity else None,
|
||
period_symptoms=server_entry.period_symptoms,
|
||
mood=server_entry.mood.value if server_entry.mood else None,
|
||
energy_level=server_entry.energy_level,
|
||
sleep_hours=server_entry.sleep_hours,
|
||
symptoms=server_entry.symptoms,
|
||
medications=server_entry.medications,
|
||
notes=server_entry.notes,
|
||
)
|
||
|
||
db.add(new_entry)
|
||
await db.commit()
|
||
await db.refresh(new_entry)
|
||
logging.info(f"Создана новая запись с ID: {new_entry.id}")
|
||
|
||
# Если это запись о менструации, обновляем данные цикла
|
||
if server_entry.entry_type == EntryType.PERIOD:
|
||
await update_cycle_data(current_user["user_id"], server_entry.entry_date, db)
|
||
logging.info("Данные цикла обновлены")
|
||
|
||
return CalendarEntryResponse.model_validate(new_entry)
|
||
|
||
except Exception as e:
|
||
logging.error(f"Ошибка при создании записи календаря: {str(e)}")
|
||
await db.rollback() # Откатываем транзакцию при ошибке
|
||
raise HTTPException(status_code=500, detail=f"Ошибка сервера: {str(e)}")
|
||
|
||
@app.post("/debug/mobile-entry", status_code=200)
|
||
async def debug_mobile_calendar_entry(
|
||
mobile_entry: MobileCalendarEntryCreate,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""Тестовый эндпоинт для проверки преобразования данных из мобильного формата (без создания записи)"""
|
||
# Используем фиктивного пользователя для тестирования
|
||
mock_user = {"user_id": 1, "username": "test_user"}
|
||
|
||
# Преобразуем симптомы из списка в строку
|
||
symptoms_str = ""
|
||
if mobile_entry.symptoms:
|
||
symptoms_str = ", ".join(mobile_entry.symptoms)
|
||
|
||
# Преобразуем данные из мобильного формата в формат сервера
|
||
server_entry = CalendarEntryCreate(
|
||
entry_date=mobile_entry.date,
|
||
entry_type=EntryType.PERIOD if mobile_entry.type == "MENSTRUATION" else
|
||
EntryType.OVULATION if mobile_entry.type == "OVULATION" else
|
||
EntryType.SYMPTOMS,
|
||
flow_intensity=FlowIntensity.from_int(mobile_entry.flow_intensity) if mobile_entry.flow_intensity else None,
|
||
mood=MoodType.from_mobile_mood(mobile_entry.mood) if mobile_entry.mood else None,
|
||
symptoms=symptoms_str,
|
||
notes=mobile_entry.notes,
|
||
# Значения по умолчанию для обязательных полей сервера
|
||
period_symptoms="",
|
||
energy_level=1, # Минимальное значение должно быть 1
|
||
sleep_hours=0,
|
||
medications="",
|
||
)
|
||
|
||
# Создаем ответ без сохранения в БД
|
||
response_data = {
|
||
"id": 0, # Фиктивный ID
|
||
"user_id": mock_user["user_id"],
|
||
"entry_date": server_entry.entry_date.isoformat(),
|
||
"entry_type": server_entry.entry_type.value,
|
||
"flow_intensity": server_entry.flow_intensity.value if server_entry.flow_intensity else None,
|
||
"period_symptoms": server_entry.period_symptoms,
|
||
"mood": server_entry.mood.value if server_entry.mood else None,
|
||
"energy_level": server_entry.energy_level,
|
||
"sleep_hours": server_entry.sleep_hours,
|
||
"symptoms": server_entry.symptoms,
|
||
"medications": server_entry.medications,
|
||
"notes": server_entry.notes,
|
||
"created_at": date.today().isoformat(),
|
||
"updated_at": date.today().isoformat(),
|
||
"is_active": True
|
||
}
|
||
|
||
return {
|
||
"message": "Данные успешно преобразованы из мобильного формата (без сохранения в БД)",
|
||
"original_data": mobile_entry.model_dump(),
|
||
"transformed_data": response_data
|
||
}
|
||
|
||
|
||
@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 is not None:
|
||
setattr(existing_entry, 'flow_intensity', server_entry_data.flow_intensity.value if server_entry_data.flow_intensity else None)
|
||
if server_entry_data.symptoms is not None:
|
||
setattr(existing_entry, 'symptoms', server_entry_data.symptoms)
|
||
if server_entry_data.mood is not None:
|
||
setattr(existing_entry, 'mood', server_entry_data.mood.value if server_entry_data.mood else None)
|
||
if server_entry_data.notes is not None:
|
||
setattr(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)
|