feature/finish-recipe-assets (#384)

* add features to readme

* Copy markdown reference

* prop as whole recipe

* parameter as url instead of query

* add card styling to editor

* move images to /recipes/{slug}/images

* add image to breaking changes

* fix delete and import errors

* fix debug/about response

* logger updates

* dashboard ui

* add server side events

* unorganized routes

* default slot

* add backup viewer to dashboard

* format

* add dialog to backup imports

* initial event support

* delete assets when removed

Co-authored-by: hay-kot <hay-kot@pm.me>

mealie/app.py

@@ -4,11 +4,13 @@ from fastapi import FastAPI
 from mealie.core import root_logger
 from mealie.core.config import APP_VERSION, settings
 from mealie.routes import backup_routes, debug_routes, migration_routes, theme_routes, utility_routes
+from mealie.routes.about import about_router
 from mealie.routes.groups import groups
 from mealie.routes.mealplans import mealplans
 from mealie.routes.recipe import router as recipe_router
 from mealie.routes.site_settings import all_settings
 from mealie.routes.users import users
+from mealie.services.events import create_general_event
 
 logger = root_logger.get_logger()
 
@@ -31,6 +33,7 @@ def api_routers():
     app.include_router(groups.router)
     # Recipes
     app.include_router(recipe_router)
+    app.include_router(about_router)
     # Meal Routes
     app.include_router(mealplans.router)
     # Settings Routes
@@ -53,6 +56,7 @@ def system_startup():
     logger.info("-----SYSTEM STARTUP----- \n")
     logger.info("------APP SETTINGS------")
     logger.info(settings.json(indent=4, exclude={"SECRET", "DEFAULT_PASSWORD", "SFTP_PASSWORD", "SFTP_USERNAME"}))
+    create_general_event("Application Startup", f"Mealie API started on port {settings.API_PORT}")
 
 
 def main():

mealie/core/root_logger.py

@@ -4,8 +4,8 @@ import sys
 from mealie.core.config import DATA_DIR
 
 LOGGER_FILE = DATA_DIR.joinpath("mealie.log")
-LOGGER_FORMAT = "%(levelname)s: \t%(message)s"
 DATE_FORMAT = "%d-%b-%y %H:%M:%S"
+LOGGER_FORMAT = "%(levelname)s: %(asctime)s \t%(message)s"
 
 logging.basicConfig(level=logging.INFO, format=LOGGER_FORMAT, datefmt="%d-%b-%y %H:%M:%S")
 
@@ -30,6 +30,9 @@ def logger_init() -> logging.Logger:
     return logger
 
 
+root_logger = logger_init()
+
+
 def get_logger(module=None) -> logging.Logger:
     """ Returns a child logger for mealie """
     global root_logger
@@ -38,6 +41,3 @@ def get_logger(module=None) -> logging.Logger:
         return root_logger
 
     return root_logger.getChild(module)
-
-
-root_logger = logger_init()

mealie/db/database.py

@@ -1,6 +1,7 @@
 from logging import getLogger
 
 from mealie.db.db_base import BaseDocument
+from mealie.db.models.event import Event
 from mealie.db.models.group import Group
 from mealie.db.models.mealplan import MealPlanModel
 from mealie.db.models.recipe.recipe import Category, RecipeModel, Tag
@@ -9,6 +10,7 @@ from mealie.db.models.sign_up import SignUp
 from mealie.db.models.theme import SiteThemeModel
 from mealie.db.models.users import User
 from mealie.schema.category import RecipeCategoryResponse, RecipeTagResponse
+from mealie.schema.events import Event as EventSchema
 from mealie.schema.meal import MealPlanInDB
 from mealie.schema.recipe import Recipe
 from mealie.schema.settings import CustomPageOut
@@ -18,7 +20,6 @@ from mealie.schema.theme import SiteTheme
 from mealie.schema.user import GroupInDB, UserInDB
 from sqlalchemy.orm.session import Session
 
-
 logger = getLogger()
 
 
@@ -35,6 +36,26 @@ class _Recipes(BaseDocument):
 
         return f"{slug}.{extension}"
 
+    def count_uncategorized(self, session: Session, count=True, override_schema=None) -> int:
+        eff_schema = override_schema or self.schema
+        if count:
+            return session.query(self.sql_model).filter(RecipeModel.recipe_category == None).count()  # noqa: 711
+        else:
+            return [
+                eff_schema.from_orm(x)
+                for x in session.query(self.sql_model).filter(RecipeModel.tags == None).all()  # noqa: 711
+            ]
+
+    def count_untagged(self, session: Session, count=True, override_schema=None) -> int:
+        eff_schema = override_schema or self.schema
+        if count:
+            return session.query(self.sql_model).filter(RecipeModel.tags == None).count()  # noqa: 711
+        else:
+            return [
+                eff_schema.from_orm(x)
+                for x in session.query(self.sql_model).filter(RecipeModel.tags == None).all()  # noqa: 711
+            ]
+
 
 class _Categories(BaseDocument):
     def __init__(self) -> None:
@@ -110,8 +131,6 @@ class _Groups(BaseDocument):
         """
         group: GroupInDB = session.query(self.sql_model).filter_by(**{match_key: match_value}).one_or_none()
 
-        # Potentially not needed? column is sorted by SqlAlchemy based on startDate
-        # return sorted(group.mealplans, key=lambda mealplan: mealplan.startDate)
         return group.mealplans
 
 
@@ -129,6 +148,13 @@ class _CustomPages(BaseDocument):
         self.schema = CustomPageOut
 
 
+class _Events(BaseDocument):
+    def __init__(self) -> None:
+        self.primary_key = "id"
+        self.sql_model = Event
+        self.schema = EventSchema
+
+
 class Database:
     def __init__(self) -> None:
         self.recipes = _Recipes()
@@ -141,6 +167,7 @@ class Database:
         self.sign_ups = _SignUps()
         self.groups = _Groups()
         self.custom_pages = _CustomPages()
+        self.events = _Events()
 
 
 db = Database()

mealie/db/db_base.py

@@ -23,6 +23,14 @@ class BaseDocument:
     ) -> List[dict]:
         eff_schema = override_schema or self.schema
 
+        if order_by:
+            order_attr = getattr(self.sql_model, str(order_by))
+
+            return [
+                eff_schema.from_orm(x)
+                for x in session.query(self.sql_model).order_by(order_attr.desc()).offset(start).limit(limit).all()
+            ]
+
         return [eff_schema.from_orm(x) for x in session.query(self.sql_model).offset(start).limit(limit).all()]
 
     def get_all_limit_columns(self, session: Session, fields: List[str], limit: int = None) -> List[SqlAlchemyBase]:
@@ -154,3 +162,14 @@ class BaseDocument:
         session.commit()
 
         return results_as_model
+
+    def delete_all(self, session: Session) -> None:
+        session.query(self.sql_model).delete()
+        session.commit()
+
+    def count_all(self, session: Session, match_key=None, match_value=None) -> int:
+
+        if None in [match_key, match_value]:
+            return session.query(self.sql_model).count()
+        else:
+            return session.query(self.sql_model).filter_by(**{match_key: match_value}).count()

mealie/db/init_db.py

@@ -5,6 +5,7 @@ from mealie.db.database import db
 from mealie.db.db_setup import create_session
 from mealie.schema.settings import SiteSettings
 from mealie.schema.theme import SiteTheme
+from mealie.services.events import create_general_event
 from sqlalchemy.orm import Session
 
 logger = root_logger.get_logger("init_db")
@@ -58,6 +59,7 @@ def main():
     else:
         print("Database Doesn't Exists, Initializing...")
         init_db()
+        create_general_event("Initialize Database", "Initialize database with default values", session)
 
 
 if __name__ == "__main__":

mealie/db/models/_all_models.py

@@ -1,7 +1,8 @@
+from mealie.db.models.event import *
+from mealie.db.models.group import *
 from mealie.db.models.mealplan import *
 from mealie.db.models.recipe.recipe import *
 from mealie.db.models.settings import *
+from mealie.db.models.sign_up import *
 from mealie.db.models.theme import *
 from mealie.db.models.users import *
-from mealie.db.models.sign_up import *
-from mealie.db.models.group import *

mealie/db/models/event.py

@@ -0,0 +1,17 @@
+import sqlalchemy as sa
+from mealie.db.models.model_base import BaseMixins, SqlAlchemyBase
+
+
+class Event(SqlAlchemyBase, BaseMixins):
+    __tablename__ = "events"
+    id = sa.Column(sa.Integer, primary_key=True)
+    title = sa.Column(sa.String)
+    text = sa.Column(sa.String)
+    time_stamp = sa.Column(sa.DateTime)
+    category = sa.Column(sa.String)
+
+    def __init__(self, title, text, time_stamp, category, *args, **kwargs) -> None:
+        self.title = title
+        self.text = text
+        self.time_stamp = time_stamp
+        self.category = category

mealie/db/models/model_base.py

@@ -4,5 +4,5 @@ SqlAlchemyBase = dec.declarative_base()
 
 
 class BaseMixins:
-    def _pass_on_me():
-        pass
+    def update(self, *args, **kwarg):
+        self.__init__(*args, **kwarg)

mealie/routes/about/__init__.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+from .events import router as events_router
+
+about_router = APIRouter(prefix="/api/about")
+
+about_router.include_router(events_router)

mealie/routes/about/events.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter, Depends
+from mealie.db.database import db
+from mealie.db.db_setup import generate_session
+from mealie.routes.deps import get_current_user
+from mealie.schema.events import EventsOut
+from sqlalchemy.orm.session import Session
+
+router = APIRouter(prefix="/events", tags=["App Events"])
+
+
+@router.get("", response_model=EventsOut)
+async def get_events(session: Session = Depends(generate_session), current_user=Depends(get_current_user)):
+    """ Get event from the Database """
+    # Get Item
+    return EventsOut(total=db.events.count_all(session), events=db.events.get_all(session, order_by="time_stamp"))
+
+
+@router.delete("")
+async def delete_events(session: Session = Depends(generate_session), current_user=Depends(get_current_user)):
+    """ Get event from the Database """
+    # Get Item
+    return db.events.delete_all(session)
+
+
+@router.delete("/{id}")
+async def delete_event(id: int, session: Session = Depends(generate_session), current_user=Depends(get_current_user)):
+    """ Delete event from the Database """
+    return db.events.delete(session, id)

mealie/routes/backup_routes.py

@@ -1,17 +1,21 @@
 import operator
 import shutil
+from pathlib import Path
 
 from fastapi import APIRouter, Depends, File, HTTPException, UploadFile, status
 from mealie.core.config import app_dirs
+from mealie.core.root_logger import get_logger
 from mealie.core.security import create_file_token
 from mealie.db.db_setup import generate_session
 from mealie.routes.deps import get_current_user
 from mealie.schema.backup import BackupJob, ImportJob, Imports, LocalBackup
 from mealie.services.backups import imports
 from mealie.services.backups.exports import backup_all
+from mealie.services.events import create_backup_event
 from sqlalchemy.orm.session import Session
 
 router = APIRouter(prefix="/api/backups", tags=["Backups"], dependencies=[Depends(get_current_user)])
+logger = get_logger()
 
 
 @router.get("/available", response_model=Imports)
@@ -43,8 +47,10 @@ def export_database(data: BackupJob, session: Session = Depends(generate_session
             export_users=data.options.users,
             export_groups=data.options.groups,
         )
+        create_backup_event("Database Backup", f"Manual Backup Created '{Path(export_path).name}'", session)
         return {"export_path": export_path}
-    except Exception:
+    except Exception as e:
+        logger.error(e)
         raise HTTPException(status.HTTP_500_INTERNAL_SERVER_ERROR)
 
 
@@ -72,7 +78,7 @@ async def download_backup_file(file_name: str):
 def import_database(file_name: str, import_data: ImportJob, session: Session = Depends(generate_session)):
     """ Import a database backup file generated from Mealie. """
 
-    return imports.import_database(
+    db_import = imports.import_database(
         session=session,
         archive=import_data.name,
         import_recipes=import_data.recipes,
@@ -84,6 +90,8 @@ def import_database(file_name: str, import_data: ImportJob, session: Session = D
         force_import=import_data.force,
         rebase=import_data.rebase,
     )
+    create_backup_event("Database Restore", f"Restored Database File {file_name}", session)
+    return db_import
 
 
 @router.delete("/{file_name}/delete", status_code=status.HTTP_200_OK)

mealie/routes/debug_routes.py

@@ -2,8 +2,11 @@ from fastapi import APIRouter, Depends
 from mealie.core.config import APP_VERSION, app_dirs, settings
 from mealie.core.root_logger import LOGGER_FILE
 from mealie.core.security import create_file_token
+from mealie.db.database import db
+from mealie.db.db_setup import generate_session
 from mealie.routes.deps import get_current_user
-from mealie.schema.debug import AppInfo, DebugInfo
+from mealie.schema.about import AppInfo, AppStatistics, DebugInfo
+from sqlalchemy.orm.session import Session
 
 router = APIRouter(prefix="/api/debug", tags=["Debug"])
 
@@ -18,11 +21,23 @@ async def get_debug_info(current_user=Depends(get_current_user)):
         demo_status=settings.IS_DEMO,
         api_port=settings.API_PORT,
         api_docs=settings.API_DOCS,
+        db_type=settings.DB_ENGINE,
         db_url=settings.DB_URL,
         default_group=settings.DEFAULT_GROUP,
     )
 
 
+@router.get("/statistics")
+async def get_app_statistics(session: Session = Depends(generate_session)):
+    return AppStatistics(
+        total_recipes=db.recipes.count_all(session),
+        uncategorized_recipes=db.recipes.count_uncategorized(session),
+        untagged_recipes=db.recipes.count_untagged(session),
+        total_users=db.users.count_all(session),
+        total_groups=db.groups.count_all(session),
+    )
+
+
 @router.get("/version")
 async def get_mealie_version():
     """ Returns the current version of mealie"""

mealie/routes/mealplans/crud.py

@@ -88,7 +88,7 @@ def get_todays_image(session: Session = Depends(generate_session), group_name: s
     recipe = get_todays_meal(session, group_in_db)
 
     if recipe:
-        recipe_image = image.read_image(recipe.slug, image_type=image.IMG_OPTIONS.ORIGINAL_IMAGE)
+        recipe_image = recipe.image_dir.joinpath(image.ImageOptions.ORIGINAL_IMAGE)
     else:
         raise HTTPException(status.HTTP_404_NOT_FOUND)
     if recipe_image:

mealie/routes/recipe/__init__.py

@@ -1,10 +1,10 @@
 from fastapi import APIRouter
-from mealie.routes.recipe import all_recipe_routes, category_routes, recipe_assets, recipe_crud_routes, tag_routes
+from mealie.routes.recipe import all_recipe_routes, category_routes, recipe_crud_routes, recipe_media, tag_routes
 
 router = APIRouter()
 
 router.include_router(all_recipe_routes.router)
 router.include_router(recipe_crud_routes.router)
-router.include_router(recipe_assets.router)
+router.include_router(recipe_media.router)
 router.include_router(category_routes.router)
 router.include_router(tag_routes.router)

mealie/routes/recipe/all_recipe_routes.py

@@ -8,7 +8,7 @@ from sqlalchemy.orm.session import Session
 router = APIRouter(tags=["Query All Recipes"])
 
 
-@router.get("/api/recipes/summary")
+@router.get("/api/recipes/summary", response_model=list[RecipeSummary])
 async def get_recipe_summary(
     start=0,
     limit=9999,
@@ -29,6 +29,16 @@ async def get_recipe_summary(
     return db.recipes.get_all(session, limit=limit, start=start, override_schema=RecipeSummary)
 
 
+@router.get("/api/recipes/summary/untagged", response_model=list[RecipeSummary])
+async def get_untagged_recipes(session: Session = Depends(generate_session)):
+    return db.recipes.count_untagged(session, False, override_schema=RecipeSummary)
+
+
+@router.get("/api/recipes/summary/uncategorized", response_model=list[RecipeSummary])
+async def get_uncategorized_recipes(session: Session = Depends(generate_session)):
+    return db.recipes.count_uncategorized(session, False, override_schema=RecipeSummary)
+
+
 @router.post("/api/recipes/category")
 def filter_by_category(categories: list, session: Session = Depends(generate_session)):
     """ pass a list of categories and get a list of recipes associated with those categories """

mealie/routes/recipe/recipe_crud_routes.py

@@ -4,7 +4,9 @@ from mealie.db.database import db
 from mealie.db.db_setup import generate_session
 from mealie.routes.deps import get_current_user
 from mealie.schema.recipe import Recipe, RecipeURLIn
-from mealie.services.image.image import delete_image, rename_image, scrape_image, write_image
+from mealie.services.events import create_recipe_event
+from mealie.services.image.image import scrape_image, write_image
+from mealie.services.recipe.media import check_assets, delete_assets
 from mealie.services.scraper.scraper import create_from_url
 from sqlalchemy.orm.session import Session
 
@@ -21,6 +23,8 @@ def create_from_json(
     """ Takes in a JSON string and loads data into the database as a new entry"""
     recipe: Recipe = db.recipes.create(session, data.dict())
 
+    create_recipe_event("Recipe Created", f"Recipe '{recipe.name}' created", session=session)
+
     return recipe.slug
 
 
@@ -34,6 +38,7 @@ def parse_recipe_url(
 
     recipe = create_from_url(url.url)
     recipe: Recipe = db.recipes.create(session, recipe.dict())
+    create_recipe_event("Recipe Created (URL)", f"'{recipe.name}' by {current_user.full_name}", session=session)
 
     return recipe.slug
 
@@ -57,8 +62,7 @@ def update_recipe(
     recipe: Recipe = db.recipes.update(session, recipe_slug, data.dict())
     print(recipe.assets)
 
-    if recipe_slug != recipe.slug:
-        rename_image(original_slug=recipe_slug, new_slug=recipe.slug)
+    check_assets(original_slug=recipe_slug, recipe=recipe)
 
     return recipe
 
@@ -75,8 +79,8 @@ def patch_recipe(
     recipe: Recipe = db.recipes.patch(
         session, recipe_slug, new_data=data.dict(exclude_unset=True, exclude_defaults=True)
     )
-    if recipe_slug != recipe.slug:
-        rename_image(original_slug=recipe_slug, new_slug=recipe.slug)
+
+    check_assets(original_slug=recipe_slug, recipe=recipe)
 
     return recipe
 
@@ -90,10 +94,10 @@ def delete_recipe(
     """ Deletes a recipe by slug """
 
     try:
-        delete_data = db.recipes.delete(session, recipe_slug)
-        delete_image(recipe_slug)
-
-        return delete_data
+        recipe: Recipe = db.recipes.delete(session, recipe_slug)
+        delete_assets(recipe_slug=recipe_slug)
+        create_recipe_event("Recipe Deleted", f"'{recipe.name}' deleted by {current_user.full_name}", session=session)
+        return recipe
     except Exception:
         raise HTTPException(status.HTTP_400_BAD_REQUEST)
 

mealie/routes/recipe/recipe_media.py

@@ -3,7 +3,6 @@ from enum import Enum
 
 from fastapi import APIRouter, Depends, File, Form, HTTPException, status
 from fastapi.datastructures import UploadFile
-from mealie.core.config import app_dirs
 from mealie.db.database import db
 from mealie.db.db_setup import generate_session
 from mealie.routes.deps import get_current_user
@@ -12,7 +11,7 @@ from slugify import slugify
 from sqlalchemy.orm.session import Session
 from starlette.responses import FileResponse
 
-router = APIRouter(prefix="/api/recipes", tags=["Recipe Media"])
+router = APIRouter(prefix="/api/recipes/media", tags=["Recipe Media"])
 
 
 class ImageType(str, Enum):
@@ -21,25 +20,30 @@ class ImageType(str, Enum):
     tiny = "tiny-original.webp"
 
 
-@router.get("/image/{recipe_slug}/{file_name}")
+@router.get("/{recipe_slug}/image/{file_name}")
 async def get_recipe_img(recipe_slug: str, file_name: ImageType = ImageType.original):
     """Takes in a recipe slug, returns the static image. This route is proxied in the docker image
     and should not hit the API in production"""
-    recipe_image = app_dirs.IMG_DIR.joinpath(recipe_slug, file_name.value)
+    recipe_image = Recipe(slug=recipe_slug).image_dir.joinpath(file_name.value)
+
     if recipe_image:
         return FileResponse(recipe_image)
     else:
         raise HTTPException(status.HTTP_404_NOT_FOUND)
 
 
-@router.get("/{recipe_slug}/asset")
-async def get_recipe_asset(recipe_slug, file_name: str):
+@router.get("/{recipe_slug}/assets/{file_name}")
+async def get_recipe_asset(recipe_slug: str, file_name: str):
     """ Returns a recipe asset """
-    file = app_dirs.RECIPE_DATA_DIR.joinpath(recipe_slug, file_name)
-    return FileResponse(file)
+    file = Recipe(slug=recipe_slug).asset_dir.joinpath(file_name)
+
+    try:
+        return FileResponse(file)
+    except Exception:
+        raise HTTPException(status.HTTP_404_NOT_FOUND)
 
 
-@router.post("/{recipe_slug}/asset", response_model=RecipeAsset)
+@router.post("/{recipe_slug}/assets", response_model=RecipeAsset)
 def upload_recipe_asset(
     recipe_slug: str,
     name: str = Form(...),
@@ -52,8 +56,7 @@ def upload_recipe_asset(
     """ Upload a file to store as a recipe asset """
     file_name = slugify(name) + "." + extension
     asset_in = RecipeAsset(name=name, icon=icon, file_name=file_name)
-    dest = app_dirs.RECIPE_DATA_DIR.joinpath(recipe_slug, file_name)
-    dest.parent.mkdir(exist_ok=True, parents=True)
+    dest = Recipe(slug=recipe_slug).asset_dir.joinpath(file_name)
 
     with dest.open("wb") as buffer:
         shutil.copyfileobj(file.file, buffer)

mealie/routes/users/crud.py

@@ -1,6 +1,6 @@
 import shutil
 
-from fastapi import APIRouter, Depends, File, UploadFile, status, HTTPException
+from fastapi import APIRouter, Depends, File, HTTPException, UploadFile, status
 from fastapi.responses import FileResponse
 from mealie.core import security
 from mealie.core.config import app_dirs, settings
@@ -9,6 +9,7 @@ from mealie.db.database import db
 from mealie.db.db_setup import generate_session
 from mealie.routes.deps import get_current_user
 from mealie.schema.user import ChangePassword, UserBase, UserIn, UserInDB, UserOut
+from mealie.services.events import create_sign_up_event
 from sqlalchemy.orm.session import Session
 
 router = APIRouter(prefix="/api/users", tags=["Users"])
@@ -22,7 +23,7 @@ async def create_user(
 ):
 
     new_user.password = get_password_hash(new_user.password)
-
+    create_sign_up_event("User Created", f"Created by {current_user.full_name}", session=session)
     return db.users.create(session, new_user.dict())
 
 

mealie/routes/users/sign_up.py

@@ -1,14 +1,14 @@
 import uuid
 
+from fastapi import APIRouter, Depends, HTTPException, status
 from mealie.core.security import get_password_hash
 from mealie.db.database import db
 from mealie.db.db_setup import generate_session
-from fastapi import APIRouter, Depends
 from mealie.routes.deps import get_current_user
 from mealie.schema.sign_up import SignUpIn, SignUpOut, SignUpToken
 from mealie.schema.user import UserIn, UserInDB
+from mealie.services.events import create_sign_up_event
 from sqlalchemy.orm.session import Session
-from fastapi import HTTPException, status
 
 router = APIRouter(prefix="/api/users/sign-ups", tags=["User Signup"])
 
@@ -20,9 +20,7 @@ async def get_all_open_sign_ups(
 ):
     """ Returns a list of open sign up links """
 
-    all_sign_ups = db.sign_ups.get_all(session)
-
-    return all_sign_ups
+    return db.sign_ups.get_all(session)
 
 
 @router.post("", response_model=SignUpToken)
@@ -41,6 +39,7 @@ async def create_user_sign_up_key(
         "name": key_data.name,
         "admin": key_data.admin,
     }
+    create_sign_up_event("Sign-up Token Created", f"Created by {current_user.full_name}", session=session)
     return db.sign_ups.create(session, sign_up)
 
 
@@ -63,6 +62,7 @@ async def create_user_with_token(
     db.users.create(session, new_user.dict())
 
     # DeleteToken
+    create_sign_up_event("Sign-up Token Used", f"New User {new_user.full_name}", session=session)
     db.sign_ups.delete(session, token)
 
 

mealie/schema/about.py

@@ -1,7 +1,16 @@
 from pathlib import Path
+
 from fastapi_camelcase import CamelModel
 
 
+class AppStatistics(CamelModel):
+    total_recipes: int
+    total_users: int
+    total_groups: int
+    uncategorized_recipes: int
+    untagged_recipes: int
+
+
 class AppInfo(CamelModel):
     production: bool
     version: str
@@ -11,5 +20,6 @@ class AppInfo(CamelModel):
 class DebugInfo(AppInfo):
     api_port: int
     api_docs: bool
+    db_type: str
     db_url: Path
     default_group: str

mealie/schema/events.py

@@ -0,0 +1,31 @@
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+from fastapi_camelcase import CamelModel
+from pydantic import Field
+
+
+class EventCategory(str, Enum):
+    general = "general"
+    recipe = "recipe"
+    backup = "backup"
+    scheduled = "scheduled"
+    migration = "migration"
+    sign_up = "signup"
+
+
+class Event(CamelModel):
+    id: Optional[int]
+    title: str
+    text: str
+    time_stamp: datetime = Field(default_factory=datetime.now)
+    category: EventCategory = EventCategory.general
+
+    class Config:
+        orm_mode = True
+
+
+class EventsOut(CamelModel):
+    total: int
+    events: list[Event]

mealie/schema/recipe.py

@@ -1,7 +1,9 @@
 import datetime
+from pathlib import Path
 from typing import Any, Optional
 
 from fastapi_camelcase import CamelModel
+from mealie.core.config import app_dirs
 from mealie.db.models.recipe.recipe import RecipeModel
 from pydantic import BaseModel, Field, validator
 from pydantic.utils import GetterDict
@@ -58,8 +60,8 @@ class Nutrition(CamelModel):
 
 class RecipeSummary(CamelModel):
     id: Optional[int]
-    name: str
-    slug: Optional[str] = ""
+    name: Optional[str]
+    slug: str = ""
     image: Optional[Any]
 
     description: Optional[str]
@@ -98,6 +100,28 @@ class Recipe(RecipeSummary):
     org_url: Optional[str] = Field(None, alias="orgURL")
     extras: Optional[dict] = {}
 
+    @staticmethod
+    def directory_from_slug(slug) -> Path:
+        return app_dirs.RECIPE_DATA_DIR.joinpath(slug)
+
+    @property
+    def directory(self) -> Path:
+        dir = app_dirs.RECIPE_DATA_DIR.joinpath(self.slug)
+        dir.mkdir(exist_ok=True, parents=True)
+        return dir
+
+    @property
+    def asset_dir(self) -> Path:
+        dir = self.directory.joinpath("assets")
+        dir.mkdir(exist_ok=True, parents=True)
+        return dir
+
+    @property
+    def image_dir(self) -> Path:
+        dir = self.directory.joinpath("images")
+        dir.mkdir(exist_ok=True, parents=True)
+        return dir
+
     class Config:
         orm_mode = True
 
@@ -140,6 +164,8 @@ class Recipe(RecipeSummary):
 
     @validator("slug", always=True, pre=True)
     def validate_slug(slug: str, values):
+        if not values["name"]:
+            return slug
         name: str = values["name"]
         calc_slug: str = slugify(name)
 

mealie/services/backups/exports.py

@@ -9,6 +9,7 @@ from mealie.core import root_logger
 from mealie.core.config import app_dirs
 from mealie.db.database import db
 from mealie.db.db_setup import create_session
+from mealie.services.events import create_backup_event
 from pathvalidate import sanitize_filename
 from pydantic.main import BaseModel
 
@@ -32,7 +33,7 @@ class ExportDatabase:
             export_tag = datetime.now().strftime("%Y-%b-%d")
 
         self.main_dir = app_dirs.TEMP_DIR.joinpath(export_tag)
-        self.img_dir = self.main_dir.joinpath("images")
+        self.recipes = self.main_dir.joinpath("recipes")
         self.templates_dir = self.main_dir.joinpath("templates")
 
         try:
@@ -43,7 +44,7 @@ class ExportDatabase:
 
         required_dirs = [
             self.main_dir,
-            self.img_dir,
+            self.recipes,
             self.templates_dir,
         ]
 
@@ -67,10 +68,10 @@ class ExportDatabase:
                 with open(out_file, "w") as f:
                     f.write(content)
 
-    def export_images(self):
-        shutil.copytree(app_dirs.IMG_DIR, self.img_dir, dirs_exist_ok=True)
+    def export_recipe_dirs(self):
+        shutil.copytree(app_dirs.RECIPE_DATA_DIR, self.recipes, dirs_exist_ok=True)
 
-    def export_items(self, items: list[BaseModel], folder_name: str, export_list=True):
+    def export_items(self, items: list[BaseModel], folder_name: str, export_list=True, slug_folder=False):
         items = [x.dict() for x in items]
         out_dir = self.main_dir.joinpath(folder_name)
         out_dir.mkdir(parents=True, exist_ok=True)
@@ -79,8 +80,10 @@ class ExportDatabase:
             ExportDatabase._write_json_file(items, out_dir.joinpath(f"{folder_name}.json"))
         else:
             for item in items:
-                filename = sanitize_filename(f"{item.get('name')}.json")
-                ExportDatabase._write_json_file(item, out_dir.joinpath(filename))
+                final_dest = out_dir if not slug_folder else out_dir.joinpath(item.get("slug"))
+                final_dest.mkdir(exist_ok=True)
+                filename = sanitize_filename(f"{item.get('slug')}.json")
+                ExportDatabase._write_json_file(item, final_dest.joinpath(filename))
 
     @staticmethod
     def _write_json_file(data: Union[dict, list], out_file: Path):
@@ -121,9 +124,9 @@ def backup_all(
 
     if export_recipes:
         all_recipes = db.recipes.get_all(session)
-        db_export.export_items(all_recipes, "recipes", export_list=False)
+        db_export.export_recipe_dirs()
+        db_export.export_items(all_recipes, "recipes", export_list=False, slug_folder=True)
         db_export.export_templates(all_recipes)
-        db_export.export_images()
 
     if export_settings:
         all_settings = db.settings.get_all(session)
@@ -148,3 +151,5 @@ def auto_backup_job():
     session = create_session()
     backup_all(session=session, tag="Auto", templates=templates)
     logger.info("Auto Backup Called")
+    create_backup_event("Automated Backup", "Automated backup created", session)
+    session.close()

mealie/services/backups/imports.py

@@ -2,7 +2,7 @@ import json
 import shutil
 import zipfile
 from pathlib import Path
-from typing import Callable, List
+from typing import Callable
 
 from mealie.core.config import app_dirs
 from mealie.db.database import db
@@ -49,7 +49,7 @@ class ImportDatabase:
     def import_recipes(self):
         recipe_dir: Path = self.import_dir.joinpath("recipes")
         imports = []
-        successful_imports = []
+        successful_imports = {}
 
         recipes = ImportDatabase.read_models_file(
             file_path=recipe_dir, model=Recipe, single_file=False, migrate=ImportDatabase._recipe_migration
@@ -68,7 +68,7 @@ class ImportDatabase:
             )
 
             if import_status.status:
-                successful_imports.append(recipe.slug)
+                successful_imports.update({recipe.slug: recipe})
 
             imports.append(import_status)
 
@@ -105,15 +105,25 @@ class ImportDatabase:
 
         return recipe_dict
 
-    def _import_images(self, successful_imports: List[str]):
+    def _import_images(self, successful_imports: list[Recipe]):
         image_dir = self.import_dir.joinpath("images")
-        for image in image_dir.iterdir():
-            if image.stem in successful_imports:
-                if image.is_dir():
-                    dest = app_dirs.IMG_DIR.joinpath(image.stem)
-                    shutil.copytree(image, dest, dirs_exist_ok=True)
-                if image.is_file():
-                    shutil.copy(image, app_dirs.IMG_DIR)
+
+        if image_dir.exists():  # Migrate from before v0.5.0
+            for image in image_dir.iterdir():
+                item: Recipe = successful_imports.get(image.stem)
+
+                if item:
+                    dest_dir = item.image_dir
+
+                    if image.is_dir():
+                        shutil.copytree(image, dest_dir, dirs_exist_ok=True)
+
+                    if image.is_file():
+                        shutil.copy(image, dest_dir)
+
+        else:
+            recipe_dir = self.import_dir.joinpath("recipes")
+            shutil.copytree(recipe_dir, app_dirs.RECIPE_DATA_DIR, dirs_exist_ok=True)
 
         minify.migrate_images()
 
@@ -227,7 +237,7 @@ class ImportDatabase:
             return [model(**g) for g in file_data]
 
         all_models = []
-        for file in file_path.glob("*.json"):
+        for file in file_path.glob("**/*.json"):
             with open(file, "r") as f:
                 file_data = json.loads(f.read())
 

mealie/services/events.py

@@ -0,0 +1,40 @@
+from mealie.db.database import db
+from mealie.db.db_setup import create_session
+from mealie.schema.events import Event, EventCategory
+from sqlalchemy.orm.session import Session
+
+
+def save_event(title, text, category, session: Session):
+    event = Event(title=title, text=text, category=category)
+    session = session or create_session()
+    db.events.create(session, event.dict())
+
+
+def create_general_event(title, text, session=None):
+    category = EventCategory.general
+    save_event(title=title, text=text, category=category, session=session)
+
+
+def create_recipe_event(title, text, session=None):
+    category = EventCategory.recipe
+    save_event(title=title, text=text, category=category, session=session)
+
+
+def create_backup_event(title, text, session=None):
+    category = EventCategory.backup
+    save_event(title=title, text=text, category=category, session=session)
+
+
+def create_scheduled_event(title, text, session=None):
+    category = EventCategory.scheduled
+    save_event(title=title, text=text, category=category, session=session)
+
+
+def create_migration_event(title, text, session=None):
+    category = EventCategory.migration
+    save_event(title=title, text=text, category=category, session=session)
+
+
+def create_sign_up_event(title, text, session=None):
+    category = EventCategory.sign_up
+    save_event(title=title, text=text, category=category, session=session)

mealie/services/image/image.py

@@ -4,7 +4,7 @@ from pathlib import Path
 
 import requests
 from mealie.core import root_logger
-from mealie.core.config import app_dirs
+from mealie.schema.recipe import Recipe
 from mealie.services.image import minify
 
 logger = root_logger.get_logger()
@@ -20,47 +20,11 @@ class ImageOptions:
 IMG_OPTIONS = ImageOptions()
 
 
-def read_image(recipe_slug: str, image_type: str = "original") -> Path:
-    """returns the path to the image file for the recipe base of image_type
-
-    Args:
-        recipe_slug (str): Recipe Slug
-        image_type (str, optional): Glob Style Matcher "original*" | "min-original* | "tiny-original*"
-
-    Returns:
-        Path: [description]
-    """
-    recipe_slug = recipe_slug.split(".")[0]  # Incase of File Name
-    recipe_image_dir = app_dirs.IMG_DIR.joinpath(recipe_slug)
-
-    for file in recipe_image_dir.glob(image_type):
-        return file
-
-    return None
-
-
-def rename_image(original_slug, new_slug) -> Path:
-    current_path = app_dirs.IMG_DIR.joinpath(original_slug)
-    new_path = app_dirs.IMG_DIR.joinpath(new_slug)
-
-    try:
-        new_path = current_path.rename(new_path)
-    except FileNotFoundError:
-        logger.error(f"Image Directory {original_slug} Doesn't Exist")
-
-    return new_path
-
-
 def write_image(recipe_slug: str, file_data: bytes, extension: str) -> Path:
-    try:
-        delete_image(recipe_slug)
-    except Exception:
-        pass
-
-    image_dir = Path(app_dirs.IMG_DIR.joinpath(f"{recipe_slug}"))
-    image_dir.mkdir(exist_ok=True, parents=True)
+    image_dir = Recipe(slug=recipe_slug).image_dir
     extension = extension.replace(".", "")
     image_path = image_dir.joinpath(f"original.{extension}")
+    image_path.unlink(missing_ok=True)
 
     if isinstance(file_data, Path):
         shutil.copy2(file_data, image_path)
@@ -77,12 +41,6 @@ def write_image(recipe_slug: str, file_data: bytes, extension: str) -> Path:
     return image_path
 
 
-def delete_image(recipe_slug: str) -> str:
-    recipe_slug = recipe_slug.split(".")[0]
-    for file in app_dirs.IMG_DIR.glob(f"{recipe_slug}*"):
-        return shutil.rmtree(file)
-
-
 def scrape_image(image_url: str, slug: str) -> Path:
     if isinstance(image_url, str):  # Handles String Types
         image_url = image_url
@@ -96,7 +54,7 @@ def scrape_image(image_url: str, slug: str) -> Path:
                 image_url = image_url.get("url")
 
     filename = slug + "." + image_url.split(".")[-1]
-    filename = app_dirs.IMG_DIR.joinpath(filename)
+    filename = Recipe(slug=slug).image_dir.joinpath(filename)
 
     try:
         r = requests.get(image_url, stream=True)

mealie/services/image/minify.py

@@ -4,10 +4,8 @@ from pathlib import Path
 
 from mealie.core import root_logger
 from mealie.core.config import app_dirs
-from mealie.db.database import db
-from mealie.db.db_setup import create_session
+from mealie.schema.recipe import Recipe
 from PIL import Image
-from sqlalchemy.orm.session import Session
 
 logger = root_logger.get_logger()
 
@@ -20,11 +18,7 @@ class ImageSizes:
 
 
 def get_image_sizes(org_img: Path, min_img: Path, tiny_img: Path) -> ImageSizes:
-    return ImageSizes(
-        org=sizeof_fmt(org_img),
-        min=sizeof_fmt(min_img),
-        tiny=sizeof_fmt(tiny_img),
-    )
+    return ImageSizes(org=sizeof_fmt(org_img), min=sizeof_fmt(min_img), tiny=sizeof_fmt(tiny_img))
 
 
 def minify_image(image_file: Path) -> ImageSizes:
@@ -110,28 +104,9 @@ def move_all_images():
             if new_file.is_file():
                 new_file.unlink()
             image_file.rename(new_file)
-
-
-def validate_slugs_in_database(session: Session = None):
-    def check_image_path(image_name: str, slug_path: str) -> bool:
-        existing_path: Path = app_dirs.IMG_DIR.joinpath(image_name)
-        slug_path: Path = app_dirs.IMG_DIR.joinpath(slug_path)
-
-        if existing_path.is_dir():
-            slug_path.rename(existing_path)
-        else:
-            logger.info("No Image Found")
-
-    session = session or create_session()
-    all_recipes = db.recipes.get_all(session)
-
-    slugs_and_images = [(x.slug, x.image) for x in all_recipes]
-
-    for slug, image in slugs_and_images:
-        image_slug = image.split(".")[0]  # Remove Extension
-        if slug != image_slug:
-            logger.info(f"{slug}, Doesn't Match '{image_slug}'")
-            check_image_path(image, slug)
+        if image_file.is_dir():
+            slug = image_file.name
+            image_file.rename(Recipe(slug=slug).image_dir)
 
 
 def migrate_images():
@@ -139,7 +114,7 @@ def migrate_images():
 
     move_all_images()
 
-    for image in app_dirs.IMG_DIR.glob("*/original.*"):
+    for image in app_dirs.RECIPE_DATA_DIR.glob("**/original.*"):
 
         minify_image(image)
 
@@ -148,4 +123,3 @@ def migrate_images():
 
 if __name__ == "__main__":
     migrate_images()
-    validate_slugs_in_database()

mealie/services/recipe/media.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+from shutil import copytree, rmtree
+
+from mealie.core.config import app_dirs
+from mealie.core.root_logger import get_logger
+from mealie.schema.recipe import Recipe
+
+logger = get_logger()
+
+
+def check_assets(original_slug, recipe: Recipe) -> None:
+    if original_slug != recipe.slug:
+        current_dir = app_dirs.RECIPE_DATA_DIR.joinpath(original_slug)
+
+        try:
+            copytree(current_dir, recipe.directory, dirs_exist_ok=True)
+
+        except FileNotFoundError:
+            logger.error(f"Recipe Directory not Found: {original_slug}")
+        logger.info(f"Renaming Recipe Directory: {original_slug} -> {recipe.slug}")
+
+    all_asset_files = [x.file_name for x in recipe.assets]
+    for file in recipe.asset_dir.iterdir():
+        file: Path
+        if file.is_dir():
+            continue
+        if file.name not in all_asset_files:
+            file.unlink()
+
+
+def delete_assets(recipe_slug):
+    recipe_dir = Recipe(slug=recipe_slug).directory
+    rmtree(recipe_dir, ignore_errors=True)
+    logger.info(f"Recipe Directory Removed: {recipe_slug}")

mealie/utils/post_webhooks.py

@@ -2,6 +2,7 @@ import requests
 from mealie.db.database import db
 from mealie.db.db_setup import create_session
 from mealie.schema.user import GroupInDB
+from mealie.services.events import create_scheduled_event
 from mealie.services.meal_services import get_todays_meal
 from sqlalchemy.orm.session import Session
 
@@ -21,4 +22,6 @@ def post_webhooks(group: int, session: Session = None):
     for url in group_settings.webhook_urls:
         requests.post(url, json=todays_recipe.json())
 
+        create_scheduled_event("Meal Plan Webhook", f"Meal plan webhook executed for group '{group}'")
+
     session.close()