Coverage for opt/mealie/lib/python3.12/site-packages/mealie/schema/cookbook/cookbook.py: 96%

1from typing import Annotated 

2 

3import sqlalchemy as sa 

4from pydantic import UUID4, ConfigDict, Field, ValidationInfo, field_validator 

5from slugify import slugify 

6from sqlalchemy.orm import joinedload 

7from sqlalchemy.orm.interfaces import LoaderOption 

8 

9from mealie.core.root_logger import get_logger 

10from mealie.db.models.household.cookbook import CookBook 

11from mealie.db.models.recipe import RecipeModel 

12from mealie.schema._mealie import MealieModel 

13from mealie.schema.response.pagination import PaginationBase 

14from mealie.schema.response.query_filter import QueryFilterBuilder, QueryFilterJSON 

15 

16logger = get_logger() 

17 

18 

19class CookbookHousehold(MealieModel): 

20 id: UUID4 

21 name: str 

22 model_config = ConfigDict(from_attributes=True) 

23 

24 

25class CreateCookBook(MealieModel): 

26 name: str 

27 description: str = "" 

28 slug: Annotated[str | None, Field(validate_default=True)] = None 

29 position: int = 1 

30 public: Annotated[bool, Field(validate_default=True)] = False 

31 query_filter_string: str = "" 

32 

33 @field_validator("public", mode="before") 

34 def validate_public(public: bool | None) -> bool: 

35 return False if public is None else public 

36 

37 @field_validator("name") 

38 def validate_name(name: str) -> str: 

39 name = name.strip() 

40 

41 # we calculate the slug later leveraging the database, 

42 # but we still need to validate the name can be slugified 

43 possible_slug = slugify(name) 

44 if not (name and possible_slug): 

45 raise ValueError("Name cannot be empty") 

46 

47 return name 

48 

49 @field_validator("query_filter_string") 

50 def validate_query_filter_string(value: str) -> str: 

51 # The query filter builder does additional validations while building the 

52 # database query, so we make sure constructing the query is successful 

53 builder = QueryFilterBuilder(value) 

54 

55 try: 

56 builder.filter_query(sa.select(RecipeModel), RecipeModel) 

57 except Exception as e: 

58 raise ValueError("Invalid query filter string") from e 

59 

60 return value 

61 

62 

63class SaveCookBook(CreateCookBook): 

64 group_id: UUID4 

65 household_id: UUID4 

66 

67 

68class UpdateCookBook(SaveCookBook): 

69 id: UUID4 

70 

71 

72class ReadCookBook(UpdateCookBook): 

73 query_filter: Annotated[QueryFilterJSON, Field(validate_default=True)] = None # type: ignore 

74 household: CookbookHousehold | None = None 

75 

76 model_config = ConfigDict(from_attributes=True) 

77 

78 @field_validator("query_filter_string") 

79 def validate_query_filter_string(value: str) -> str: 

80 # Skip validation since we are not updating the query filter string 

81 return value 

82 

83 @field_validator("query_filter", mode="before") 

84 def validate_query_filter(cls, _, info: ValidationInfo) -> QueryFilterJSON: 

85 try: 

86 query_filter_string: str = info.data.get("query_filter_string") or "" 

87 builder = QueryFilterBuilder(query_filter_string) 

88 return builder.as_json_model() 

89 except Exception: 

90 logger.exception(f"Invalid query filter string: {query_filter_string}") 

91 return QueryFilterJSON() 

92 

93 @classmethod 

94 def loader_options(cls) -> list[LoaderOption]: 

95 return [joinedload(CookBook.household)] 

96 

97 

98class CookBookPagination(PaginationBase): 

99 items: list[ReadCookBook]