feat: improved registration signup flow (#1188)

refactored signup flow for entire registration process. Utilized seed data option for optional seeding of Foods, Units, and Labels. Localized registration page.

mealie/repos/repository_generic.py

@@ -159,7 +159,7 @@ class RepositoryGeneric(Generic[T, D]):
 
         if any_case:
             search_attr = getattr(self.sql_model, key)
-            q = q.filter(func.lower(search_attr) == key.lower()).filter_by(**self._filter_builder())
+            q = q.filter(func.lower(search_attr) == str(value).lower()).filter_by(**self._filter_builder())
         else:
             q = self.session.query(self.sql_model).filter_by(**self._filter_builder(**{key: value}))
 

mealie/routes/users/registration.py

@@ -22,5 +22,5 @@ class RegistrationController(BasePublicController):
                 status_code=status.HTTP_403_FORBIDDEN, detail=ErrorResponse.respond("User Registration is Disabled")
             )
 
-        registration_service = RegistrationService(self.deps.logger, get_repositories(self.deps.session))
+        registration_service = RegistrationService(self.deps.logger, get_repositories(self.deps.session), self.deps.t)
         return registration_service.register_user(data)

mealie/routes/validators/validators.py

@@ -1,6 +1,7 @@
 from uuid import UUID
 
 from fastapi import APIRouter, Depends
+from slugify import slugify
 from sqlalchemy.orm.session import Session
 
 from mealie.db.db_setup import generate_session
@@ -10,15 +11,23 @@ from mealie.schema.response import ValidationResponse
 router = APIRouter()
 
 
-@router.get("/user/{name}", response_model=ValidationResponse)
+@router.get("/user/name", response_model=ValidationResponse)
 def validate_user(name: str, session: Session = Depends(generate_session)):
     """Checks if a user with the given name exists"""
     db = get_repositories(session)
-    existing_element = db.users.get_by_username(name)
+    existing_element = db.users.get_one(name, "username", any_case=True)
     return ValidationResponse(valid=existing_element is None)
 
 
-@router.get("/group/{name}", response_model=ValidationResponse)
+@router.get("/user/email", response_model=ValidationResponse)
+def validate_user_email(email: str, session: Session = Depends(generate_session)):
+    """Checks if a user with the given name exists"""
+    db = get_repositories(session)
+    existing_element = db.users.get_one(email, "email", any_case=True)
+    return ValidationResponse(valid=existing_element is None)
+
+
+@router.get("/group", response_model=ValidationResponse)
 def validate_group(name: str, session: Session = Depends(generate_session)):
     """Checks if a group with the given name exists"""
     db = get_repositories(session)
@@ -26,9 +35,10 @@ def validate_group(name: str, session: Session = Depends(generate_session)):
     return ValidationResponse(valid=existing_element is None)
 
 
-@router.get("/recipe/{group_id}/{slug}", response_model=ValidationResponse)
-def validate_recipe(group_id: UUID, slug: str, session: Session = Depends(generate_session)):
+@router.get("/recipe", response_model=ValidationResponse)
+def validate_recipe(group_id: UUID, name: str, session: Session = Depends(generate_session)):
     """Checks if a group with the given slug exists"""
     db = get_repositories(session)
+    slug = slugify(name)
     existing_element = db.recipes.get_by_slug(group_id, slug)
     return ValidationResponse(valid=existing_element is None)

mealie/schema/_mealie/validators.py

@@ -0,0 +1,38 @@
+def validate_locale(locale: str) -> bool:
+    valid = {
+        "el-GR",
+        "it-IT",
+        "ko-KR",
+        "es-ES",
+        "ja-JP",
+        "zh-CN",
+        "tr-TR",
+        "ar-SA",
+        "hu-HU",
+        "pt-PT",
+        "no-NO",
+        "sv-SE",
+        "ro-RO",
+        "sk-SK",
+        "uk-UA",
+        "fr-CA",
+        "pl-PL",
+        "da-DK",
+        "pt-BR",
+        "de-DE",
+        "ca-ES",
+        "sr-SP",
+        "cs-CZ",
+        "fr-FR",
+        "zh-TW",
+        "af-ZA",
+        "ru-RU",
+        "he-IL",
+        "nl-NL",
+        "en-US",
+        "en-GB",
+        "fi-FI",
+        "vi-VN",
+    }
+
+    return locale in valid

mealie/schema/group/group_seeder.py

@@ -1,46 +1,7 @@
 from pydantic import validator
 
 from mealie.schema._mealie.mealie_model import MealieModel
-
-
-def validate_locale(locale: str) -> bool:
-    valid = {
-        "el-GR",
-        "it-IT",
-        "ko-KR",
-        "es-ES",
-        "ja-JP",
-        "zh-CN",
-        "tr-TR",
-        "ar-SA",
-        "hu-HU",
-        "pt-PT",
-        "no-NO",
-        "sv-SE",
-        "ro-RO",
-        "sk-SK",
-        "uk-UA",
-        "fr-CA",
-        "pl-PL",
-        "da-DK",
-        "pt-BR",
-        "de-DE",
-        "ca-ES",
-        "sr-SP",
-        "cs-CZ",
-        "fr-FR",
-        "zh-TW",
-        "af-ZA",
-        "ru-RU",
-        "he-IL",
-        "nl-NL",
-        "en-US",
-        "en-GB",
-        "fi-FI",
-        "vi-VN",
-    }
-
-    return locale in valid
+from mealie.schema._mealie.validators import validate_locale
 
 
 class SeederConfig(MealieModel):
@@ -49,5 +10,5 @@ class SeederConfig(MealieModel):
     @validator("locale")
     def valid_locale(cls, v, values, **kwargs):
         if not validate_locale(v):
-            raise ValueError("passwords do not match")
+            raise ValueError("invalid locale")
         return v

mealie/schema/user/registration.py

@@ -2,6 +2,7 @@ from pydantic import validator
 from pydantic.types import NoneStr, constr
 
 from mealie.schema._mealie import MealieModel
+from mealie.schema._mealie.validators import validate_locale
 
 
 class CreateUserRegistration(MealieModel):
@@ -14,6 +15,15 @@ class CreateUserRegistration(MealieModel):
     advanced: bool = False
     private: bool = False
 
+    seed_data: bool = False
+    locale: str = "en-US"
+
+    @validator("locale")
+    def valid_locale(cls, v, values, **kwargs):
+        if not validate_locale(v):
+            raise ValueError("invalid locale")
+        return v
+
     @validator("password_confirm")
     @classmethod
     def passwords_match(cls, value, values):
@@ -24,7 +34,7 @@ class CreateUserRegistration(MealieModel):
     @validator("group_token", always=True)
     @classmethod
     def group_or_token(cls, value, values):
-        if bool(value) is False and bool(values["group"]) is False:
+        if not bool(value) and not bool(values["group"]):
             raise ValueError("group or group_token must be provided")
 
         return value

mealie/services/user_services/registration_service.py

@@ -4,22 +4,23 @@ from uuid import uuid4
 from fastapi import HTTPException, status
 
 from mealie.core.security import hash_password
-from mealie.lang import local_provider
+from mealie.lang.providers import Translator
 from mealie.repos.repository_factory import AllRepositories
 from mealie.schema.group.group_preferences import CreateGroupPreferences
 from mealie.schema.user.registration import CreateUserRegistration
 from mealie.schema.user.user import GroupBase, GroupInDB, PrivateUser, UserIn
 from mealie.services.group_services.group_service import GroupService
+from mealie.services.seeder.seeder_service import SeederService
 
 
 class RegistrationService:
     logger: Logger
     repos: AllRepositories
 
-    def __init__(self, logger: Logger, db: AllRepositories):
+    def __init__(self, logger: Logger, db: AllRepositories, t: Translator):
         self.logger = logger
         self.repos = db
-        self.t = local_provider()
+        self.t = t
 
     def _create_new_user(self, group: GroupInDB, new_group: bool) -> PrivateUser:
         new_user = UserIn(
@@ -79,6 +80,14 @@ class RegistrationService:
 
         user = self._create_new_user(group, new_group)
 
+        if new_group and registration.seed_data:
+
+            seeder_service = SeederService(self.repos, user, group)
+
+            seeder_service.seed_foods(registration.locale)
+            seeder_service.seed_labels(registration.locale)
+            seeder_service.seed_units(registration.locale)
+
         if token_entry and user:
             token_entry.uses_left = token_entry.uses_left - 1