seeded database

.env

@@ -1,7 +1,7 @@
-PG_DATABASE=health_tracker
+PG_DATABASE=health
 PG_PORT=5432
 PG_HOST=localhost
-PG_USERNAME=victor
-PG_PASSWORD=vic123
+PG_USERNAME=victor123
+PG_PASSWORD=victor
 
 

.gitignore

@@ -1,2 +1 @@
 env
-migrations

alembic.ini

@@ -63,8 +63,8 @@ version_path_separator = os
 # are written from script.py.mako
 # output_encoding = utf-8
 
-sqlalchemy.url = postgresql://victor:vic123@localhost:5432/health_tracker
 
+sqlalchemy.url = postgresql://victor123:victor@localhost:5432/health
 
 [post_write_hooks]
 # post_write_hooks defines scripts or Python functions that are run

controllers/FoodEntryController.py

@@ -0,0 +1,53 @@
+from models.FoodEntry import FoodEntry
+from sqlalchemy.orm import Session
+from datetime import datetime
+
+def create_food_entry(session: Session, user_id: int, food_name: str, calories: int, meal_type: str, quantity: int, date: str):
+    """Create a new food entry for a user"""
+    date_obj = datetime.fromisoformat(date)
+    new_entry = FoodEntry(
+        user_id=user_id,
+        food_name=food_name,
+        calories=calories,
+        meal_type=meal_type,
+        quantity=quantity,
+        date=date_obj
+    )
+    session.add(new_entry)
+    session.commit()
+    return new_entry
+
+def get_all_food_entries(session: Session, user_id: int):
+    """Retrieve all food entries for a user"""
+    return session.query(FoodEntry).filter_by(user_id=user_id).all()
+
+def get_food_entry_by_id(session: Session, entry_id: int):
+    """Retrieve a food entry by its id"""
+    return session.query(FoodEntry).get(entry_id)
+
+def update_food_entry(session: Session, entry_id: int, food_name: str = None, calories: int = None, meal_type: str = None, quantity: int = None, date: str = None):
+    """Update an existing food entry"""
+    entry = session.query(FoodEntry).get(entry_id)
+    if not entry:
+        return None
+    if food_name is not None:
+        entry.food_name = food_name
+    if calories is not None:
+        entry.calories = calories
+    if meal_type is not None:
+        entry.meal_type = meal_type
+    if quantity is not None:
+        entry.quantity = quantity
+    if date is not None:
+        entry.date = datetime.fromisoformat(date)
+    session.commit()
+    return entry
+
+def delete_food_entry(session: Session, entry_id: int):
+    """Delete a food entry by its id"""
+    entry = session.query(FoodEntry).get(entry_id)
+    if entry:
+        session.delete(entry)
+        session.commit()
+        return True
+    return False

controllers/GoalController.py

@@ -0,0 +1,42 @@
+from models.Goal import Goal
+from sqlalchemy.orm import Session
+
+def create_goal(session: Session, user_id: int, daily_calories: int, weekly_calories: int):
+    """Create a new goal for a user"""
+    new_goal = Goal(
+        user_id=user_id,
+        daily_calories=daily_calories,
+        weekly_calories=weekly_calories
+    )
+    session.add(new_goal)
+    session.commit()
+    return new_goal
+
+def get_all_goals(session: Session, user_id: int):
+    """Retrieve all goals for a user"""
+    return session.query(Goal).filter_by(user_id=user_id).all()
+
+def get_goal_by_id(session: Session, goal_id: int):
+    """Retrieve a goal by its id"""
+    return session.query(Goal).get(goal_id)
+
+def update_goal(session: Session, goal_id: int, daily_calories: int = None, weekly_calories: int = None):
+    """Update an existing goal"""
+    goal = session.query(Goal).get(goal_id)
+    if not goal:
+        return None
+    if daily_calories is not None:
+        goal.daily_calories = daily_calories
+    if weekly_calories is not None:
+        goal.weekly_calories = weekly_calories
+    session.commit()
+    return goal
+
+def delete_goal(session: Session, goal_id: int):
+    """Delete a goal by its id"""
+    goal = session.query(Goal).get(goal_id)
+    if goal:
+        session.delete(goal)
+        session.commit()
+        return True
+    return False

controllers/MealPlanController.py

@@ -0,0 +1,45 @@
+from models.MealPlan import MealPlan
+from sqlalchemy.orm import Session
+
+def create_meal_plan(session: Session, user_id: int, week_number: int, planned_meals: str, nutrition_balance: str):
+    """Create a new meal plan for a user"""
+    meal_plan = MealPlan(
+        user_id=user_id,
+        week_number=week_number,
+        planned_meals=planned_meals,
+        nutrition_balance=nutrition_balance
+    )
+    session.add(meal_plan)
+    session.commit()
+    return meal_plan
+
+def get_meal_plans_by_user(session: Session, user_id: int):
+    """Retrieve all meal plans for a user"""
+    return session.query(MealPlan).filter_by(user_id=user_id).all()
+
+def get_meal_plan_by_id(session: Session, meal_plan_id: int):
+    """Retrieve a meal plan by its id"""
+    return session.query(MealPlan).get(meal_plan_id)
+
+def update_meal_plan(session: Session, meal_plan_id: int, week_number: int = None, planned_meals: str = None, nutrition_balance: str = None):
+    """Update an existing meal plan"""
+    meal_plan = session.query(MealPlan).get(meal_plan_id)
+    if not meal_plan:
+        return None
+    if week_number is not None:
+        meal_plan.week_number = week_number
+    if planned_meals is not None:
+        meal_plan.planned_meals = planned_meals
+    if nutrition_balance is not None:
+        meal_plan.nutrition_balance = nutrition_balance
+    session.commit()
+    return meal_plan
+
+def delete_meal_plan(session: Session, meal_plan_id: int):
+    """Delete a meal plan by its id"""
+    meal_plan = session.query(MealPlan).get(meal_plan_id)
+    if meal_plan:
+        session.delete(meal_plan)
+        session.commit()
+        return True
+    return False

controllers/ReportController.py

@@ -0,0 +1,50 @@
+from models.Report import Report
+from sqlalchemy.orm import Session
+from datetime import datetime
+
+def create_report(session: Session, user_id: int, weekly_progress: float, goal_status: bool, total_calories: int, date: str):
+    """Create a report for a user"""
+    date_obj = datetime.fromisoformat(date)
+    report = Report(
+        user_id=user_id,
+        weekly_progress=weekly_progress,
+        goal_status=goal_status,
+        total_calories=total_calories,
+        date=date_obj
+    )
+    session.add(report)
+    session.commit()
+    return report
+
+def get_all_reports(session: Session, user_id: int):
+    """Get all reports for a user"""
+    return session.query(Report).filter_by(user_id=user_id).all()
+
+def get_report_by_id(session: Session, report_id: int):
+    """Get a report by its id"""
+    return session.query(Report).get(report_id)
+
+def update_report(session: Session, report_id: int, weekly_progress: float = None, goal_status: bool = None, total_calories: int = None, date: str = None):
+    """Update a report by id"""
+    report = session.query(Report).get(report_id)
+    if not report:
+        return None
+    if weekly_progress is not None:
+        report.weekly_progress = weekly_progress
+    if goal_status is not None:
+        report.goal_status = goal_status
+    if total_calories is not None:
+        report.total_calories = total_calories
+    if date is not None:
+        report.date = datetime.fromisoformat(date)
+    session.commit()
+    return report
+
+def delete_report(session: Session, report_id: int):
+    """Delete a report by ID"""
+    report = session.query(Report).get(report_id)
+    if report:
+        session.delete(report)
+        session.commit()
+        return True
+    return False

controllers/UserController.py

@@ -0,0 +1,26 @@
+from models.User import User
+from sqlalchemy.orm import Session
+
+def create_user(session: Session, name: str):
+    """Create a new user with a given name"""
+    new_user = User(name=name)
+    session.add(new_user)
+    session.commit()
+    return new_user
+
+def get_all_users(session: Session):
+    """Retrieve all users from the database"""
+    return session.query(User).all()
+
+def get_user_by_id(session: Session, user_id: int):
+    """Retrieve a user by their id"""
+    return session.query(User).get(user_id)
+
+def delete_user(session: Session, user_id: int):
+    """Delete a user by their id"""
+    user = session.query(User).get(user_id)
+    if user:
+        session.delete(user)
+        session.commit()
+        return True
+    return False

main.py

@@ -11,7 +11,7 @@
 from datetime import datetime
 
 app = typer.Typer()
-DATABASE_URL = "postgresql://victor:vic123@localhost:5432/health_tracker"
+DATABASE_URL = "postgresql://victor123:victor@localhost:5432/health"
 engine = create_engine(DATABASE_URL)
 Session = sessionmaker(bind=engine)
 

migrations/README

@@ -0,0 +1 @@
+Generic single-database configuration.

migrations/env.py

@@ -0,0 +1,79 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+from models import Base, FoodEntry, Goal, MealPlan, Report, User
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = Base.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

migrations/script.py.mako

@@ -0,0 +1,26 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}