fix: Correction of configuration and database models

app/__main__.py

@@ -4,16 +4,76 @@ Entrypoint pour lancer l'application en dev.
 Usage:
     python3 -m app
 """
-
+import argparse
 import uvicorn
 from app.main import app
 from app.core.config import settings
 
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="MokPyo API",
+    )
+
+    # Option booléenne (type flag)
+    parser.add_argument(
+        "--init-db",
+        action="store_true",
+        help="Initialiser la base de données. Première exécution uniquement."
+    )
+
+    parser.add_argument(
+        "--reset",
+        action="store_true",
+        help="Vide les tables de la base de données (lignes uniquement). Pas besoin de --init-db au prochain lancement."
+    )
+
+    
+    parser.add_argument(
+        "--clear", 
+        action="store_true",
+        help="Vide la base de données (lignes et tables). besoin de --init-db au prochain lancement."
+    )
+
+    parser.add_argument(
+        "--host",
+        type=str,
+        default=settings.HOST,
+        help="Host sur lequel l'application va tourner. Override le host de configuration."
+    )
+
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=settings.PORT,
+        help="Port sur lequel l'application va tourner. Override le port de configuration."
+    )
+
+    return parser
+
 if __name__ == "__main__":
+
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if args.init_db:
+        from app.db.utils import init_db
+        init_db()
+        exit()
+
+    if args.reset:
+        from app.db.utils import reset_db
+        reset_db()
+        exit()
+
+    if args.clear:
+        from app.db.utils import clear_db
+        clear_db()
+        exit()
+
     uvicorn.run(
         "app.main:app",
-        host=settings.HOST,
-        port=settings.PORT,
+        host=args.host,
+        port=args.port,
         reload=settings.ENV == "dev",
         log_level=settings.LOG_LEVEL.lower(),
     )

app/core/config.py

@@ -15,7 +15,6 @@ class Settings(BaseSettings):
     DATABASE_USER: str
     DATABASE_PASSWORD: str
     DATABASE_NAME: str
-    DATABASE_DRIVER: str
 
     # =========================
     # FASTAPI

app/db/__init__.py

@@ -8,4 +8,4 @@ __version__ = "1.0.0"
 
 from .engine import engine, async_engine
 from .session import SessionLocal, AsyncSessionLocal, get_db, get_async_db
-from .models import Base
+from .models import *

app/db/models.py

@@ -1,90 +1,134 @@
-from datetime import date
 from sqlalchemy import (
-    sa,
     Column,
     Integer,
     String,
+    Text,
     Boolean,
     Date,
+    DateTime,
+    Time,
     Enum,
-    ForeignKey
+    ForeignKey,
+    text,
 )
 from sqlalchemy.orm import DeclarativeBase, relationship
 
-
+# ----------------------------------------------------------------------
+# Base class
+# ----------------------------------------------------------------------
 class Base(DeclarativeBase):
     pass
 
 
+# ----------------------------------------------------------------------
+# User
+# ----------------------------------------------------------------------
 class User(Base):
     __tablename__ = "users"
 
-    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
-    email = Column(String, unique=True, index=True)
-    username = Column(String, unique=True, index=True)
-    hashed_password = Column(String)
-    stats = Column(String)
-    is_active = Column(Boolean, default=True)
+    id = Column(Integer, primary_key=True, autoincrement=True, index=True)
+    email = Column(String(255), nullable=False, unique=True, index=True)
+    username = Column(String(150), nullable=False, unique=True, index=True)
+    hashed_password = Column(String(255), nullable=False)
 
-    tasks = relationship("Item", back_populates="owner")
-    events = relationship("Event", back_populates="owner")
-    goals = relationship("Goal", back_populates="owner")
-    sub_goals = relationship("SubGoal", back_populates="owner")
-    notes = relationship("Note", back_populates="owner")
+    # JSON est idéal pour stocker un dict, sinon utilise String + server_default
+    stats = Column(Text, nullable=False)
+
+    # bool → TINYINT(1) avec server_default
+    is_active = Column(Boolean, nullable=False, server_default=text("1"))
+
+    # Relations
+    tasks = relationship("Task", back_populates="owner", cascade="all, delete-orphan")
+    events = relationship("Event", back_populates="owner", cascade="all, delete-orphan")
+    goals = relationship("Goal", back_populates="owner", cascade="all, delete-orphan")
+    sub_goals = relationship("SubGoal", back_populates="owner", cascade="all, delete-orphan")
+    notes = relationship("Note", back_populates="owner", cascade="all, delete-orphan")
 
 
+# ----------------------------------------------------------------------
+# Task
+# ----------------------------------------------------------------------
 class Task(Base):
     __tablename__ = "tasks"
 
-    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
-    description = Column(String, index=True, nullable=False)
-    frequency = Column(Integer, default=4223, nullable=False)
+    id = Column(Integer, primary_key=True, autoincrement=True, index=True)
+    description = Column(String(255), nullable=False, index=True)
+    frequency = Column(Integer, nullable=False,
+                       server_default=text("4223"))          # valeur par défaut côté serveur
     reward = Column(Integer, nullable=True)
-    goal_id = Column(Integer, ForeignKey("goals.id"), default=None, nullable=True)
+
+    goal_id = Column(Integer, ForeignKey("goals.id"), nullable=True)
     owner_id = Column(Integer, ForeignKey("users.id"), nullable=False)
 
-    start_date = Column(Date, server_default=sa.text("CURRENT_DATE"), nullable=False)
+    start_date = Column(Date, nullable=False)
     next_date = Column(Date, nullable=True)
 
     owner = relationship("User", back_populates="tasks")
     goal = relationship("Goal", back_populates="tasks")
 
 
+# ----------------------------------------------------------------------
+# Event
+# ----------------------------------------------------------------------
 class Event(Base):
     __tablename__ = "events"
 
-    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
-    name = Column(String, index=True, nullable=False)
-    description = Column(String, index=True, nullable=True)
-    frequency = Column(Integer, default=4223, nullable=False)
-    owner_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    id = Column(Integer, primary_key=True, autoincrement=True, index=True)
+    name = Column(String(255), nullable=False, index=True)          # texte court → String
+    description = Column(String(255), nullable=True, index=True)
+    frequency = Column(Integer, nullable=False, server_default=text("4223"))
+    start_time = Column(Time, nullable=False)
+    end_time = Column(Time, nullable=False)
 
+    owner_id = Column(Integer, ForeignKey("users.id"), nullable=False)
     owner = relationship("User", back_populates="events")
 
 
+# ----------------------------------------------------------------------
+# Goal
+# ----------------------------------------------------------------------
 class Goal(Base):
     __tablename__ = "goals"
 
-    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
-    title = Column(String, index=True, nullable=False)
-    description = Column(String, index=True, nullable=True)
-    state = Column(Enum("in_progress", "successful", "failed", "aborted"), default="in_progress", nullable=False)
+    id = Column(Integer, primary_key=True, autoincrement=True, index=True)
+    title = Column(String(255), nullable=False, index=True)
+    description = Column(Text, nullable=True)
+
+    # Enum avec nom explicite
+    state = Column(
+        Enum("in_progress", "successful", "failed", "aborted",
+             name="goal_state"),
+        nullable=False,
+        server_default=text("'in_progress'")
+    )
+
     owner_id = Column(Integer, ForeignKey("users.id"), nullable=False)
 
-    tasks = relationship("Task", back_populates="goal")
-    notes = relationship("Note", back_populates="goal")
-    sub_goals = relationship("SubGoal", back_populates="goal")
+    tasks = relationship("Task", back_populates="goal", cascade="all, delete-orphan")
+    notes = relationship("Note", back_populates="goal", cascade="all, delete-orphan")
+    sub_goals = relationship("SubGoal", back_populates="goal", cascade="all, delete-orphan")
     owner = relationship("User", back_populates="goals")
 
 
+# ----------------------------------------------------------------------
+# SubGoal
+# ----------------------------------------------------------------------
 class SubGoal(Base):
     __tablename__ = "sub_goals"
 
-    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
-    title = Column(String, index=True, nullable=False)
-    description = Column(String, index=True, nullable=True)
-    state = Column(Enum("in_progress", "successful", "failed", "aborted"), default="in_progress", nullable=False)
+    id = Column(Integer, primary_key=True, autoincrement=True, index=True)
+    title = Column(String(255), nullable=False, index=True)
+    description = Column(Text, nullable=True)
+
+    state = Column(
+        Enum("in_progress", "successful", "failed", "aborted",
+             name="subgoal_state"),
+        nullable=False,
+        server_default=text("'in_progress'")
+    )
+
     reward = Column(Integer, nullable=True)
+
     goal_id = Column(Integer, ForeignKey("goals.id"), nullable=False)
     owner_id = Column(Integer, ForeignKey("users.id"), nullable=False)
 
@@ -92,19 +136,26 @@ class SubGoal(Base):
     owner = relationship("User", back_populates="sub_goals")
 
 
+# ----------------------------------------------------------------------
+# Note
+# ----------------------------------------------------------------------
 class Note(Base):
     __tablename__ = "notes"
 
-    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
-    title = Column(String, index=True, nullable=False)
-    description = Column(String, index=True, nullable=True)
-    content = Column(String, index=True, nullable=True)
+    id = Column(Integer, primary_key=True, autoincrement=True, index=True)
+    title = Column(String(255), nullable=False, index=True)
+    description = Column(Text, nullable=True)
+    content = Column(Text, nullable=True)
+
     goal_id = Column(Integer, ForeignKey("goals.id"), nullable=True)
     owner_id = Column(Integer, ForeignKey("users.id"), nullable=False)
 
-    created_at = Column(Date, server_default=sa.text("CURRENT_DATE"), nullable=False)
-    updated_at = Column(Date, server_default=sa.text("CURRENT_DATE"), nullable=False)
+    created_at = Column(DateTime, nullable=False)
+    updated_at = Column(DateTime, nullable=False)
 
     goal = relationship("Goal", back_populates="notes")
     owner = relationship("User", back_populates="notes")
 
+
+# --------------------------------------------------------------
+__all__ = ["Base", "User", "Task", "Event", "Goal", "SubGoal", "Note"]

app/db/utils.py

@@ -0,0 +1,49 @@
+from app.db.engine import engine
+from app.db.session import SessionLocal
+from app.db.models import *
+from app.core.config import settings
+
+def init_db():
+    try:
+        if settings.DEBUG:
+            print("Creating database tables...")
+        Base.metadata.create_all(bind=engine)
+        if settings.DEBUG:
+            print("Database tables created.")
+    except Exception as e:
+        print(f"Error creating database tables: {e}")
+        raise
+    finally:
+        if settings.DEBUG:
+            print("Tables :", Base.metadata.tables.keys())
+
+
+def clear_db():
+    try:
+        if settings.DEBUG:
+            print("Deleting database tables...")
+        Base.metadata.drop_all(bind=engine)
+        if settings.DEBUG:
+            print("Database tables deleted.")
+    except Exception as e:
+        print(f"Error deleting database tables: {e}")
+        raise
+
+def reset_db():
+    session = SessionLocal()
+    try:
+        if settings.DEBUG:
+            print("Deleting database rows...")
+        
+        for table in reversed(Base.metadata.sorted_tables):
+            session.execute(table.delete())
+        session.commit()
+
+        if settings.DEBUG:
+            print("Database rows deleted.")
+    except Exception as e:
+        print(f"Error deleting database rows: {e}")
+        raise
+    finally:
+        session.close()
+