feat(backend): ✨ basic support for background tasks

mealie/db/data_access_layer/_access_model.py

@@ -41,22 +41,41 @@ class AccessModel(Generic[T, D]):
     def get_all(self, limit: int = None, order_by: str = None, start=0, override_schema=None) -> list[T]:
         eff_schema = override_schema or self.schema
 
+        order_attr = None
         if order_by:
             order_attr = getattr(self.sql_model, str(order_by))
+            order_attr = order_attr.desc()
 
             return [
                 eff_schema.from_orm(x)
-                for x in self.session.query(self.sql_model).order_by(order_attr.desc()).offset(start).limit(limit).all()
+                for x in self.session.query(self.sql_model).order_by(order_attr).offset(start).limit(limit).all()
             ]
 
         return [eff_schema.from_orm(x) for x in self.session.query(self.sql_model).offset(start).limit(limit).all()]
 
-    def multi_query(self, query_by: dict[str, str], start=0, limit: int = None, override_schema=None) -> list[T]:
+    def multi_query(
+        self,
+        query_by: dict[str, str],
+        start=0,
+        limit: int = None,
+        override_schema=None,
+        order_by: str = None,
+    ) -> list[T]:
         eff_schema = override_schema or self.schema
 
+        order_attr = None
+        if order_by:
+            order_attr = getattr(self.sql_model, str(order_by))
+            order_attr = order_attr.desc()
+
         return [
             eff_schema.from_orm(x)
-            for x in self.session.query(self.sql_model).filter_by(**query_by).offset(start).limit(limit).all()
+            for x in self.session.query(self.sql_model)
+            .filter_by(**query_by)
+            .order_by(order_attr)
+            .offset(start)
+            .limit(limit)
+            .all()
         ]
 
     def get_all_limit_columns(self, fields: list[str], limit: int = None) -> list[D]:

mealie/db/data_access_layer/access_model_factory.py

@@ -13,6 +13,7 @@ from mealie.db.models.recipe.comment import RecipeComment
 from mealie.db.models.recipe.ingredient import IngredientFoodModel, IngredientUnitModel
 from mealie.db.models.recipe.recipe import RecipeModel
 from mealie.db.models.recipe.tag import Tag
+from mealie.db.models.server.task import ServerTaskModel
 from mealie.db.models.settings import SiteSettings
 from mealie.db.models.sign_up import SignUp
 from mealie.db.models.users import LongLiveToken, User
@@ -27,6 +28,7 @@ from mealie.schema.group.webhook import ReadWebhook
 from mealie.schema.meal_plan.new_meal import ReadPlanEntry
 from mealie.schema.recipe import CommentOut, Recipe, RecipeCategoryResponse, RecipeTagResponse
 from mealie.schema.recipe.recipe_ingredient import IngredientFood, IngredientUnit
+from mealie.schema.server import ServerTask
 from mealie.schema.user import GroupInDB, LongLiveTokenInDB, PrivateUser, SignUpOut
 from mealie.schema.user.user_passwords import PrivatePasswordResetToken
 
@@ -70,15 +72,15 @@ class Database:
         return RecipeDataAccessModel(self.session, pk_slug, RecipeModel, Recipe)
 
     @cached_property
-    def ingredient_foods(self) -> AccessModel:
+    def ingredient_foods(self) -> AccessModel[IngredientFood, IngredientFoodModel]:
         return AccessModel(self.session, pk_id, IngredientFoodModel, IngredientFood)
 
     @cached_property
-    def ingredient_units(self) -> AccessModel:
+    def ingredient_units(self) -> AccessModel[IngredientUnit, IngredientUnitModel]:
         return AccessModel(self.session, pk_id, IngredientUnitModel, IngredientUnit)
 
     @cached_property
-    def comments(self) -> AccessModel:
+    def comments(self) -> AccessModel[CommentOut, RecipeComment]:
         return AccessModel(self.session, pk_id, RecipeComment, CommentOut)
 
     @cached_property
@@ -93,19 +95,19 @@ class Database:
     # Site Items
 
     @cached_property
-    def settings(self) -> AccessModel:
+    def settings(self) -> AccessModel[SiteSettingsSchema, SiteSettings]:
         return AccessModel(self.session, pk_id, SiteSettings, SiteSettingsSchema)
 
     @cached_property
-    def sign_up(self) -> AccessModel:
+    def sign_up(self) -> AccessModel[SignUpOut, SignUp]:
         return AccessModel(self.session, pk_id, SignUp, SignUpOut)
 
     @cached_property
-    def event_notifications(self) -> AccessModel:
+    def event_notifications(self) -> AccessModel[EventNotificationIn, EventNotification]:
         return AccessModel(self.session, pk_id, EventNotification, EventNotificationIn)
 
     @cached_property
-    def events(self) -> AccessModel:
+    def events(self) -> AccessModel[EventSchema, Event]:
         return AccessModel(self.session, pk_id, Event, EventSchema)
 
     # ================================================================
@@ -116,7 +118,7 @@ class Database:
         return UserDataAccessModel(self.session, pk_id, User, PrivateUser)
 
     @cached_property
-    def api_tokens(self) -> AccessModel:
+    def api_tokens(self) -> AccessModel[LongLiveTokenInDB, LongLiveToken]:
         return AccessModel(self.session, pk_id, LongLiveToken, LongLiveTokenInDB)
 
     @cached_property
@@ -126,16 +128,20 @@ class Database:
     # ================================================================
     # Group Items
 
+    @cached_property
+    def server_tasks(self) -> AccessModel[ServerTask, ServerTaskModel]:
+        return AccessModel(self.session, pk_id, ServerTaskModel, ServerTask)
+
     @cached_property
     def groups(self) -> GroupDataAccessModel:
         return GroupDataAccessModel(self.session, pk_id, Group, GroupInDB)
 
     @cached_property
-    def group_invite_tokens(self) -> AccessModel:
+    def group_invite_tokens(self) -> AccessModel[ReadInviteToken, GroupInviteToken]:
         return AccessModel(self.session, pk_token, GroupInviteToken, ReadInviteToken)
 
     @cached_property
-    def group_preferences(self) -> AccessModel:
+    def group_preferences(self) -> AccessModel[ReadGroupPreferences, GroupPreferencesModel]:
         return AccessModel(self.session, "group_id", GroupPreferencesModel, ReadGroupPreferences)
 
     @cached_property
@@ -143,9 +149,9 @@ class Database:
         return MealDataAccessModel(self.session, pk_id, GroupMealPlan, ReadPlanEntry)
 
     @cached_property
-    def cookbooks(self) -> AccessModel:
+    def cookbooks(self) -> AccessModel[ReadCookBook, CookBook]:
         return AccessModel(self.session, pk_id, CookBook, ReadCookBook)
 
     @cached_property
-    def webhooks(self) -> AccessModel:
+    def webhooks(self) -> AccessModel[ReadWebhook, GroupWebhooksModel]:
         return AccessModel(self.session, pk_id, GroupWebhooksModel, ReadWebhook)

mealie/db/models/_all_models.py

@@ -1,6 +1,7 @@
 from .event import *
 from .group import *
 from .recipe.recipe import *
+from .server import *
 from .settings import *
 from .sign_up import *
 from .users import *

mealie/db/models/_model_base.py

@@ -9,8 +9,8 @@ from sqlalchemy.orm.session import Session
 @as_declarative()
 class Base:
     id = Column(Integer, primary_key=True)
-    created_at = Column(DateTime, default=datetime.now())
-    update_at = Column(DateTime, default=datetime.now(), onupdate=datetime.now())
+    created_at = Column(DateTime, default=datetime.now)
+    update_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
 
 
 class BaseMixins:

mealie/db/models/group/group.py

@@ -4,6 +4,7 @@ from sqlalchemy.orm.session import Session
 
 from mealie.core.config import get_app_settings
 from mealie.db.models.group.invite_tokens import GroupInviteToken
+from mealie.db.models.server.task import ServerTaskModel
 
 from .._model_base import BaseMixins, SqlAlchemyBase
 from .._model_utils import auto_init
@@ -42,6 +43,7 @@ class Group(SqlAlchemyBase, BaseMixins):
     )
     webhooks = orm.relationship(GroupWebhooksModel, uselist=True, cascade="all, delete-orphan")
     cookbooks = orm.relationship(CookBook, back_populates="group", single_parent=True)
+    server_tasks = orm.relationship(ServerTaskModel, back_populates="group", single_parent=True)
     shopping_lists = orm.relationship("ShoppingList", back_populates="group", single_parent=True)
 
     @auto_init({"users", "webhooks", "shopping_lists", "cookbooks", "preferences", "invite_tokens", "mealplans"})

mealie/db/models/server/__init__.py

@@ -0,0 +1 @@
+from .task import *

mealie/db/models/server/task.py

@@ -0,0 +1,20 @@
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, orm
+
+from mealie.db.models._model_base import BaseMixins, SqlAlchemyBase
+
+from .._model_utils import auto_init
+
+
+class ServerTaskModel(SqlAlchemyBase, BaseMixins):
+    __tablename__ = "server_tasks"
+    name = Column(String, nullable=False)
+    completed_date = Column(DateTime, nullable=True)
+    status = Column(String, nullable=False)
+    log = Column(String, nullable=True)
+
+    group_id = Column(Integer, ForeignKey("groups.id"))
+    group = orm.relationship("Group", back_populates="server_tasks")
+
+    @auto_init()
+    def __init__(self, **_) -> None:
+        pass