Merge branch 'develop'

Currently translated at 92.2% (487 of 528 strings)

Translation: Tandoor/Recipes Backend
Translate-URL: http://translate.tandoor.dev/projects/tandoor/recipes-backend/hu/

.env.template

@@ -3,6 +3,9 @@
 DEBUG=0
 SQL_DEBUG=0
 
+# HTTP port to bind to
+# TANDOOR_PORT=8080
+
 # hosts the application can run under e.g. recipes.mydomain.com,cooking.mydomain.com,...
 ALLOWED_HOSTS=*
 
@@ -83,8 +86,10 @@ GUNICORN_MEDIA=0
 # EMAIL_HOST_PASSWORD=
 # EMAIL_USE_TLS=0
 # EMAIL_USE_SSL=0
-# DEFAULT_FROM_EMAIL= # email sender address (default 'webmaster@localhost')
-# ACCOUNT_EMAIL_SUBJECT_PREFIX= # prefix used for account related emails (default "[Tandoor Recipes] ")
+# email sender address (default 'webmaster@localhost')
+# DEFAULT_FROM_EMAIL=
+# prefix used for account related emails (default "[Tandoor Recipes] ")
+# ACCOUNT_EMAIL_SUBJECT_PREFIX=
 
 # allow authentication via reverse proxy (e.g. authelia), leave off if you dont know what you are doing
 # see docs for more information https://vabene1111.github.io/recipes/features/authentication/

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -29,11 +29,3 @@ body:
     attributes:
       label: "Additional context"
       description: "Add any other context or screenshots about the feature request here."
-  - type: checkboxes
-    attributes:
-      label: "Contribute"
-      description: "Are you willing and able to help develop this feature?"
-      options:
-        - label: "Yes"
-        - label: "Partly"
-        - label: "No"

.github/workflows/docker-publish-beta-raspi.yml

@@ -0,0 +1,48 @@
+name: publish beta raspi image docker
+on:
+  push:
+    branches:
+      - 'beta'
+jobs:
+  build:
+    if: github.repository_owner == 'TandoorRecipes'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@master
+      # Update Version number
+      - name: Update version file
+        uses: DamianReeves/write-file-action@v1.0
+        with:
+          path: recipes/version.py
+          contents: |
+            VERSION_NUMBER = 'beta'
+            BUILD_REF = '${{ github.sha }}'
+          write-mode: overwrite
+      # Build Vue frontend
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '14'
+      - name: Install dependencies
+        working-directory: ./vue
+        run: yarn install
+      - name: Build dependencies
+        working-directory: ./vue
+        run: yarn build
+      # Build container
+      - name: Build and publish image
+        uses: ilteoood/docker_buildx@master
+        with:
+          publish: true
+          imageName: vabene1111/recipes
+          tag: beta-raspi
+          dockerFile: Dockerfile-raspi
+          platform: linux/arm/v7
+          dockerUser: ${{ secrets.DOCKER_USERNAME }}
+          dockerPassword: ${{ secrets.DOCKER_PASSWORD }}
+      # Send discord notification
+      - name: Discord notification
+        env:
+          DISCORD_WEBHOOK: ${{ secrets.DISCORD_BETA_WEBHOOK }}
+        uses: Ilshidur/action-discord@0.3.2
+        with:
+          args: '🚀 The BETA Image has been updated! 🥳'

.github/workflows/docker-publish-beta.yml

@@ -35,8 +35,9 @@ jobs:
           publish: true
           imageName: vabene1111/recipes
           tag: beta
-          dockerHubUser: ${{ secrets.DOCKER_USERNAME }}
-          dockerHubPassword: ${{ secrets.DOCKER_PASSWORD }}
+          platform: linux/amd64,linux/arm64
+          dockerUser: ${{ secrets.DOCKER_USERNAME }}
+          dockerPassword: ${{ secrets.DOCKER_PASSWORD }}
       # Send discord notification
       - name: Discord notification
         env:

.github/workflows/docker-publish-latest-raspi.yml

@@ -0,0 +1,45 @@
+name: publish latest raspi image docker
+on:
+  push:
+    tags:
+    - '*'
+
+jobs:
+  build:
+    if: github.repository_owner == 'TandoorRecipes'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@master
+      - name: Get version number
+        id: get_version
+        run: echo ::set-output name=VERSION::${GITHUB_REF/refs\/tags\//}-raspi
+      # Update Version number
+      - name: Update version file
+        uses: DamianReeves/write-file-action@v1.0
+        with:
+          path: recipes/version.py
+          contents: |
+            VERSION_NUMBER = '${{ steps.get_version.outputs.VERSION }}-raspi'
+            BUILD_REF = '${{ github.sha }}'
+          write-mode: overwrite
+      # Build Vue frontend
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '14'
+      - name: Install dependencies
+        working-directory: ./vue
+        run: yarn install
+      - name: Build dependencies
+        working-directory: ./vue
+        run: yarn build
+      # Build container
+      - name: Build and publish image
+        uses: ilteoood/docker_buildx@master
+        with:
+          publish: true
+          imageName: vabene1111/recipes
+          dockerFile: Dockerfile-raspi
+          platform: linux/arm/v7
+          tag: latest-raspi
+          dockerUser: ${{ secrets.DOCKER_USERNAME }}
+          dockerPassword: ${{ secrets.DOCKER_PASSWORD }}

.github/workflows/docker-publish-latest.yml

@@ -38,6 +38,7 @@ jobs:
         with:
           publish: true
           imageName: vabene1111/recipes
+          platform: linux/amd64,linux/arm64
           tag: latest
-          dockerHubUser: ${{ secrets.DOCKER_USERNAME }}
-          dockerHubPassword: ${{ secrets.DOCKER_PASSWORD }}
+          dockerUser: ${{ secrets.DOCKER_USERNAME }}
+          dockerPassword: ${{ secrets.DOCKER_PASSWORD }}

.github/workflows/docker-publish-release-raspi.yml

@@ -0,0 +1,47 @@
+name: publish tagged raspi release docker
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build:
+    if: github.repository_owner == 'TandoorRecipes'
+    runs-on: ubuntu-latest
+    name: Build image job
+    steps:
+      - name: Checkout master
+        uses: actions/checkout@master
+      - name: Get version number
+        id: get_version
+        run: echo ::set-output name=VERSION::${GITHUB_REF/refs\/tags\//}
+      # Update Version number
+      - name: Update version file
+        uses: DamianReeves/write-file-action@v1.0
+        with:
+          path: recipes/version.py
+          contents: |
+            VERSION_NUMBER = '${{ steps.get_version.outputs.VERSION }}'
+            BUILD_REF = '${{ github.sha }}'
+          write-mode: overwrite
+      # Build Vue frontend
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '14'
+      - name: Install dependencies
+        working-directory: ./vue
+        run: yarn install
+      - name: Build dependencies
+        working-directory: ./vue
+        run: yarn build
+      # Build container
+      - name: Build and publish image
+        uses: ilteoood/docker_buildx@master
+        with:
+          publish: true
+          imageName: vabene1111/recipes
+          dockerFile: Dockerfile-raspi
+          platform: linux/arm/v7
+          tag: ${{ steps.get_version.outputs.VERSION }}-raspi
+          dockerUser: ${{ secrets.DOCKER_USERNAME }}
+          dockerPassword: ${{ secrets.DOCKER_PASSWORD }}

.github/workflows/docker-publish-release.yml

@@ -40,9 +40,10 @@ jobs:
         with:
           publish: true
           imageName: vabene1111/recipes
+          platform: linux/amd64,linux/arm64
           tag: ${{ steps.get_version.outputs.VERSION }}
-          dockerHubUser: ${{ secrets.DOCKER_USERNAME }}
-          dockerHubPassword: ${{ secrets.DOCKER_PASSWORD }}
+          dockerUser: ${{ secrets.DOCKER_USERNAME }}
+          dockerPassword: ${{ secrets.DOCKER_PASSWORD }}
       # Send discord notification
       - name: Discord notification
         env:

.github/workflows/docs.yml

@@ -3,7 +3,6 @@ on:
   push:
     branches:
       - master
-      - develop
 
 jobs:
   deploy:

CONTRIBUTERS.md

@@ -1,58 +1,83 @@
+# Contributers
+
 Many thanks to everyone who contributed to this project! If you add something or help out feel free to add yourself
 to this list.
 
 ## Code/Features
+
 Please have a look at the [list of pull requests](https://github.com/vabene1111/recipes/pulls) for 
 a complete list of contributions.
 Below are some of the larger contributions made yet.
 
-
-- @tourn provided the serving feature and **several** other improvements!
-- @l0c4lh057 provided a much improved ingredient text parser in [#277](https://github.com/vabene1111/recipes/pull/277)
-- @sebimarkgraf added nutritional information [#199](https://github.com/vabene1111/recipes/pull/199)
-- @cazier added reverse proxy authentication [#88](https://github.com/vabene1111/recipes/pull/88)
+- [vabene1111]
+- [Kaibu]
+- [smilerz]
+- [MaxJa4] Docker builds and other improvements
+- [tourn] provided the serving feature and **several** other improvements!
+- [l0c4lh057] provided a much improved ingredient text parser in [#277](https://github.com/vabene1111/recipes/pull/277)
+- [sebimarkgraf] added nutritional information [#199](https://github.com/vabene1111/recipes/pull/199)
+- [cazier] added reverse proxy authentication [#88](https://github.com/vabene1111/recipes/pull/88)
+- [murphy83] added support for IPv6 #1490
+- [TheHaf] added custom serving size component #1411
+- [lostlont] added LDAP support #960
 
 ## Translations
 
-### Catalan 
+### Catalan
+
 [Rubenix](https://www.transifex.com/user/profile/rubenix/)
 
 ### Dutch
-[D0T1X](https://www.transifex.com/user/profile/D0T1X/)  
-[ikbenfrank](https://www.transifex.com/user/profile/ikbenfrank/)  
-[kampsj](https://www.transifex.com/user/profile/kampsj/)  
+
+[D0T1X](https://www.transifex.com/user/profile/D0T1X/)
+[ikbenfrank](https://www.transifex.com/user/profile/ikbenfrank/)
+[kampsj](https://www.transifex.com/user/profile/kampsj/)
 
 ### French
-[jt117](https://www.transifex.com/user/profile/jt117/)  
-[nerdinator](https://www.transifex.com/user/profile/nerdinator/)  
-[agaume](https://www.transifex.com/user/profile/agaume/)  
+
+[jt117](https://www.transifex.com/user/profile/jt117/)
+[nerdinator](https://www.transifex.com/user/profile/nerdinator/)
+[agaume](https://www.transifex.com/user/profile/agaume/)
 
 ### German
+
 [eTaurus](https://www.transifex.com/user/profile/eTaurus/)
 [l0c4lh057](https://www.transifex.com/user/profile/l0c4lh057/)
+[hyperbit00](https://github.com/hyperbit00)
 
 ### Hungarian
+
 [igazka](https://www.transifex.com/user/profile/igazka/)
 
 ### Italian
-[SK3LA](https://www.transifex.com/user/profile/SK3LA/)  
-[auanasgheps](https://www.transifex.com/user/profile/auanasgheps/)  
+
+[SK3LA](https://www.transifex.com/user/profile/SK3LA/)
+[auanasgheps](https://www.transifex.com/user/profile/auanasgheps/)
 
 ### Latvian
+
 [melkypie](https://github.com/melkypie)
 
 ### Portuguese
 
-[hds](https://www.transifex.com/user/profile/hds/)  
-[mlopezifu](https://www.transifex.com/user/profile/mlopezifu/)  
-[stormsz](https://www.transifex.com/user/profile/stormsz/)  
+[hds](https://www.transifex.com/user/profile/hds/)
+[mlopezifu](https://www.transifex.com/user/profile/mlopezifu/)
+[stormsz](https://www.transifex.com/user/profile/stormsz/)
+
+### Russian
+
+[amillerr](https://github.com/amillerr)
 
 ### Spanish
 
-[albertocp](https://www.transifex.com/user/profile/albertocp/)  
-[alfa5](https://www.transifex.com/user/profile/alfa5/)  
-[mlopezifu](https://www.transifex.com/user/profile/mlopezifu/)  
-[sergio.laya](https://www.transifex.com/user/profile/sergio.laya/)  
+[albertocp](https://www.transifex.com/user/profile/albertocp/)
+[alfa5](https://www.transifex.com/user/profile/alfa5/)
+[mlopezifu](https://www.transifex.com/user/profile/mlopezifu/)
+[sergio.laya](https://www.transifex.com/user/profile/sergio.laya/)
+
+### Swedish
+
+[makanz](https://github.com/makanz)
 
 ### Turkish
 
@@ -60,4 +85,4 @@ Below are some of the larger contributions made yet.
 
 ### Vietnamese
 
-[vuongtrunghieu](https://www.transifex.com/user/profile/vuongtrunghieu/)
+[vuongtrunghieu](https://www.transifex.com/user/profile/vuongtrunghieu/)

Dockerfile

@@ -1,7 +1,7 @@
-FROM python:3.9-alpine3.12
+FROM python:3.10-alpine3.15
 
 #Install all dependencies.
-RUN apk add --no-cache postgresql-libs gettext zlib libjpeg libwebp libxml2-dev libxslt-dev py-cryptography
+RUN apk add --no-cache postgresql-libs postgresql-client gettext zlib libjpeg libwebp libxml2-dev libxslt-dev py-cryptography openldap
 
 #Print all logs without buffering it.
 ENV PYTHONUNBUFFERED 1
@@ -15,10 +15,12 @@ WORKDIR /opt/recipes
 
 COPY requirements.txt ./
 
-RUN apk add --no-cache --virtual .build-deps gcc musl-dev postgresql-dev zlib-dev jpeg-dev libwebp-dev libressl-dev libffi-dev cargo openssl-dev openldap-dev && \
+RUN apk add --no-cache --virtual .build-deps gcc musl-dev postgresql-dev zlib-dev jpeg-dev libwebp-dev openssl-dev libffi-dev cargo openldap-dev python3-dev && \
+    echo -n "INPUT ( libldap.so )" > /usr/lib/libldap_r.so && \
     python -m venv venv && \
     /opt/recipes/venv/bin/python -m pip install --upgrade pip && \
-    venv/bin/pip install wheel==0.36.2 && \
+    venv/bin/pip install wheel==0.37.1 && \
+    venv/bin/pip install setuptools_rust==1.1.2 && \
     venv/bin/pip install -r requirements.txt --no-cache-dir &&\
     apk --purge del .build-deps
 

Dockerfile-raspi

@@ -0,0 +1,33 @@
+# builds of cryptography for raspberry pi (or better arm v7) fail for some
+FROM python:3.9-alpine3.15
+
+#Install all dependencies.
+RUN apk add --no-cache postgresql-libs postgresql-client gettext zlib libjpeg libwebp libxml2-dev libxslt-dev py-cryptography openldap gcompat
+
+#Print all logs without buffering it.
+ENV PYTHONUNBUFFERED 1
+
+#This port will be used by gunicorn.
+EXPOSE 8080
+
+#Create app dir and install requirements.
+RUN mkdir /opt/recipes
+WORKDIR /opt/recipes
+
+COPY requirements.txt ./
+RUN \
+    if [ `apk --print-arch` = "armv7" ]; then \
+    printf "[global]\nextra-index-url=https://www.piwheels.org/simple\n" > /etc/pip.conf ; \
+    fi
+RUN apk add --no-cache --virtual .build-deps gcc musl-dev zlib-dev jpeg-dev libwebp-dev python3-dev && \
+    echo -n "INPUT ( libldap.so )" > /usr/lib/libldap_r.so && \
+    python -m venv venv && \
+    /opt/recipes/venv/bin/python -m pip install --upgrade pip && \
+    venv/bin/pip install wheel==0.37.1 && \
+    venv/bin/pip install -r requirements.txt --no-cache-dir --no-binary=Pillow && \
+    apk --purge del .build-deps
+
+#Copy project and execute it.
+COPY . ./
+RUN chmod +x boot.sh
+ENTRYPOINT ["/opt/recipes/boot.sh"]

boot.sh

@@ -1,12 +1,66 @@
 #!/bin/sh
 source venv/bin/activate
 
-echo "Updating database"
+TANDOOR_PORT="${TANDOOR_PORT:-8080}"
+NGINX_CONF_FILE=/opt/recipes/nginx/conf.d/Recipes.conf
+
+display_warning() {
+    echo "[WARNING]"
+    echo -e "$1"
+}
+
+echo "Checking configuration..."
+
+# Nginx config file must exist if gunicorn is not active
+if [ ! -f "$NGINX_CONF_FILE" ] && [ $GUNICORN_MEDIA -eq 0 ]; then
+    display_warning "Nginx configuration file could not be found at the default location!\nPath: ${NGINX_CONF_FILE}"
+fi
+
+# SECRET_KEY must be set in .env file
+if [ -z "${SECRET_KEY}" ]; then
+    display_warning "The environment variable 'SECRET_KEY' is not set but REQUIRED for running Tandoor!"
+fi
+
+
+echo "Waiting for database to be ready..."
+
+attempt=0
+max_attempts=20
+
+if [ "${DB_ENGINE}" != 'django.db.backends.sqlite3' ]; then
+
+  # POSTGRES_PASSWORD must be set in .env file
+  if [ -z "${POSTGRES_PASSWORD}" ]; then
+      display_warning "The environment variable 'POSTGRES_PASSWORD' is not set but REQUIRED for running Tandoor!"
+  fi
+
+  while pg_isready --host=${POSTGRES_HOST} --port=${POSTGRES_PORT} --user=${POSTGRES_USER} -q; status=$?; attempt=$((attempt+1)); [ $status -ne 0 ] && [ $attempt -le $max_attempts ]; do
+      sleep 5
+  done
+fi
+
+if [ $attempt -gt $max_attempts ]; then
+    echo -e "\nDatabase not reachable. Maximum attempts exceeded."
+    echo "Please check logs above - misconfiguration is very likely."
+    echo "Make sure the DB container is up and POSTGRES_HOST is set properly."
+    echo "Shutting down container."
+    exit 1 # exit with error to make the container stop
+fi
+
+echo "Database is ready"
+
+echo "Migrating database"
+
+
 python manage.py migrate
+
+echo "Generating static files"
+
 python manage.py collectstatic_js_reverse
 python manage.py collectstatic --noinput
+
 echo "Done"
 
 chmod -R 755 /opt/recipes/mediafiles
 
-exec gunicorn -b :8080 --access-logfile - --error-logfile - --log-level INFO recipes.wsgi
+exec gunicorn -b :$TANDOOR_PORT --access-logfile - --error-logfile - --log-level INFO recipes.wsgi

cookbook/admin.py

@@ -237,7 +237,7 @@ admin.site.register(Ingredient, IngredientAdmin)
 
 class CommentAdmin(admin.ModelAdmin):
     list_display = ('recipe', 'name', 'created_at')
-    search_fields = ('text', 'user__username')
+    search_fields = ('text', 'created_by__username')
     date_hierarchy = 'created_at'
 
     @staticmethod

cookbook/filters.py

@@ -6,7 +6,7 @@ from django.utils.translation import gettext as _
 from django_scopes import scopes_disabled
 
 from cookbook.forms import MultiSelectWidget
-from cookbook.models import Food, Keyword, Recipe, ShoppingList
+from cookbook.models import Food, Keyword, Recipe
 
 with scopes_disabled():
     class RecipeFilter(django_filters.FilterSet):
@@ -60,22 +60,3 @@ with scopes_disabled():
         class Meta:
             model = Recipe
             fields = ['name', 'keywords', 'foods', 'internal']
-
-    # class FoodFilter(django_filters.FilterSet):
-    #     name = django_filters.CharFilter(lookup_expr='icontains')
-
-    #     class Meta:
-    #         model = Food
-    #         fields = ['name']
-
-    class ShoppingListFilter(django_filters.FilterSet):
-
-        def __init__(self, data=None, *args, **kwargs):
-            if data is not None:
-                data = data.copy()
-                data.setdefault("finished", False)
-            super().__init__(data, *args, **kwargs)
-
-        class Meta:
-            model = ShoppingList
-            fields = ['finished']

cookbook/forms.py

@@ -49,7 +49,7 @@ class UserPreferenceForm(forms.ModelForm):
         fields = (
             'default_unit', 'use_fractions', 'use_kj', 'theme', 'nav_color',
             'sticky_navbar', 'default_page', 'show_recent', 'search_style',
-            'plan_share', 'ingredient_decimals', 'comments',
+            'plan_share', 'ingredient_decimals', 'comments', 'left_handed',
         )
 
         labels = {
@@ -65,7 +65,8 @@ class UserPreferenceForm(forms.ModelForm):
             'plan_share': _('Plan sharing'),
             'ingredient_decimals': _('Ingredient decimal places'),
             'shopping_auto_sync': _('Shopping list auto sync period'),
-            'comments': _('Comments')
+            'comments': _('Comments'),
+            'left_handed': _('Left-handed mode')
         }
 
         help_texts = {
@@ -89,6 +90,7 @@ class UserPreferenceForm(forms.ModelForm):
             'sticky_navbar': _('Makes the navbar stick to the top of the page.'),  # noqa: E501
             'mealplan_autoadd_shopping': _('Automatically add meal plan ingredients to shopping list.'),
             'mealplan_autoexclude_onhand': _('Exclude ingredients that are on hand.'),
+            'left_handed': _('Will optimize the UI for use with your left hand.')
         }
 
         widgets = {
@@ -153,11 +155,13 @@ class ImportExportBase(forms.Form):
     RECIPESAGE = 'RECIPESAGE'
     DOMESTICA = 'DOMESTICA'
     MEALMASTER = 'MEALMASTER'
+    MELARECIPES = 'MELARECIPES'
     REZKONV = 'REZKONV'
     OPENEATS = 'OPENEATS'
     PLANTOEAT = 'PLANTOEAT'
     COOKBOOKAPP = 'COOKBOOKAPP'
     COPYMETHAT = 'COPYMETHAT'
+    COOKMATE = 'COOKMATE'
     PDF = 'PDF'
 
     type = forms.ChoiceField(choices=(
@@ -165,7 +169,8 @@ class ImportExportBase(forms.Form):
         (MEALIE, 'Mealie'), (CHOWDOWN, 'Chowdown'), (SAFFRON, 'Saffron'), (CHEFTAP, 'ChefTap'),
         (PEPPERPLATE, 'Pepperplate'), (RECETTETEK, 'RecetteTek'), (RECIPESAGE, 'Recipe Sage'), (DOMESTICA, 'Domestica'),
         (MEALMASTER, 'MealMaster'), (REZKONV, 'RezKonv'), (OPENEATS, 'Openeats'), (RECIPEKEEPER, 'Recipe Keeper'),
-        (PLANTOEAT, 'Plantoeat'), (COOKBOOKAPP, 'CookBookApp'), (COPYMETHAT, 'CopyMeThat'), (PDF, 'PDF'),
+        (PLANTOEAT, 'Plantoeat'), (COOKBOOKAPP, 'CookBookApp'), (COPYMETHAT, 'CopyMeThat'), (PDF, 'PDF'), (MELARECIPES, 'Melarecipes'),
+        (COOKMATE, 'Cookmate')
     ))
 
 
@@ -179,6 +184,7 @@ class ImportForm(ImportExportBase):
 class ExportForm(ImportExportBase):
     recipes = forms.ModelMultipleChoiceField(widget=MultiSelectWidget, queryset=Recipe.objects.none(), required=False)
     all = forms.BooleanField(required=False)
+    custom_filter = forms.IntegerField(required=False)
 
     def __init__(self, *args, **kwargs):
         space = kwargs.pop('space')

cookbook/helper/image_processing.py

@@ -38,10 +38,12 @@ def get_filetype(name):
 
 # TODO this whole file needs proper documentation, refactoring, and testing
 # TODO also add env variable to define which images sizes should be compressed
-def handle_image(request, image_object, filetype='.jpeg'):
+# filetype argument can not be optional, otherwise this function will treat all images as if they were a jpeg
+# Because it's no longer optional, no reason to return it
+def handle_image(request, image_object, filetype): 
     if (image_object.size / 1000) > 500:  # if larger than 500 kb compress
         if filetype == '.jpeg' or filetype == '.jpg':
-            return rescale_image_jpeg(image_object), filetype
+            return rescale_image_jpeg(image_object)
         if filetype == '.png':
-            return rescale_image_png(image_object), filetype
-    return image_object, filetype
+            return rescale_image_png(image_object)
+    return image_object

cookbook/helper/ingredient_parser.py

@@ -4,7 +4,7 @@ import unicodedata
 
 from django.core.cache import caches
 
-from cookbook.models import Unit, Food, Automation
+from cookbook.models import Unit, Food, Automation, Ingredient
 
 
 class IngredientParser:
@@ -46,7 +46,7 @@ class IngredientParser:
 
     def apply_food_automation(self, food):
         """
-        Apply food alias automations to passed foood
+        Apply food alias automations to passed food
         :param food: unit as string
         :return: food as string (possibly changed by automation)
         """
@@ -124,7 +124,7 @@ class IngredientParser:
 
     def parse_amount(self, x):
         amount = 0
-        unit = ''
+        unit = None
         note = ''
 
         did_check_frac = False
@@ -155,33 +155,36 @@ class IngredientParser:
                 except ValueError:
                     unit = x[end:]
 
-        if unit.startswith('(') or unit.startswith('-'):  # i dont know any unit that starts with ( or - so its likely an alternative like 1L (500ml) Water or 2-3
-            unit = ''
+        if unit is not None and unit.strip() == '':
+            unit = None
+
+        if unit is not None and (unit.startswith('(') or unit.startswith('-')):  # i dont know any unit that starts with ( or - so its likely an alternative like 1L (500ml) Water or 2-3
+            unit = None
             note = x
         return amount, unit, note
 
-    def parse_ingredient_with_comma(self, tokens):
-        ingredient = ''
+    def parse_food_with_comma(self, tokens):
+        food = ''
         note = ''
         start = 0
         # search for first occurrence of an argument ending in a comma
         while start < len(tokens) and not tokens[start].endswith(','):
             start += 1
         if start == len(tokens):
-            # no token ending in a comma found -> use everything as ingredient
-            ingredient = ' '.join(tokens)
+            # no token ending in a comma found -> use everything as food
+            food = ' '.join(tokens)
         else:
-            ingredient = ' '.join(tokens[:start + 1])[:-1]
+            food = ' '.join(tokens[:start + 1])[:-1]
             note = ' '.join(tokens[start + 1:])
-        return ingredient, note
+        return food, note
 
-    def parse_ingredient(self, tokens):
-        ingredient = ''
+    def parse_food(self, tokens):
+        food = ''
         note = ''
         if tokens[-1].endswith(')'):
             # Check if the matching opening bracket is in the same token
             if (not tokens[-1].startswith('(')) and ('(' in tokens[-1]):
-                return self.parse_ingredient_with_comma(tokens)
+                return self.parse_food_with_comma(tokens)
             # last argument ends with closing bracket -> look for opening bracket
             start = len(tokens) - 1
             while not tokens[start].startswith('(') and not start == 0:
@@ -191,33 +194,51 @@ class IngredientParser:
                 raise ValueError
             elif start < 0:
                 # no opening bracket anywhere -> just ignore the last bracket
-                ingredient, note = self.parse_ingredient_with_comma(tokens)
+                food, note = self.parse_food_with_comma(tokens)
             else:
-                # opening bracket found -> split in ingredient and note, remove brackets from note  # noqa: E501
+                # opening bracket found -> split in food and note, remove brackets from note  # noqa: E501
                 note = ' '.join(tokens[start:])[1:-1]
-                ingredient = ' '.join(tokens[:start])
+                food = ' '.join(tokens[:start])
         else:
-            ingredient, note = self.parse_ingredient_with_comma(tokens)
-        return ingredient, note
+            food, note = self.parse_food_with_comma(tokens)
+        return food, note
 
-    def parse(self, x):
+    def parse(self, ingredient):
+        """
+        Main parsing function, takes an ingredient string (e.g. '1 l Water') and extracts amount, unit, food, ...
+        :param ingredient: string ingredient
+        :return: amount, unit (can be None), food, note (can be empty)
+        """
         # initialize default values
         amount = 0
-        unit = ''
-        ingredient = ''
+        unit = None
+        food = ''
         note = ''
         unit_note = ''
 
+        if len(ingredient) == 0:
+            raise ValueError('string to parse cannot be empty')
+
+        # some people/languages put amount and unit at the end of the ingredient string
+        # if something like this is detected move it to the beginning so the parser can handle it
+        if len(ingredient) < 1000 and re.search(r'^([A-z])+(.)*[1-9](\d)*\s([A-z])+', ingredient):
+            match = re.search(r'[1-9](\d)*\s([A-z])+', ingredient)
+            print(f'reording from {ingredient} to {ingredient[match.start():match.end()] + " " + ingredient.replace(ingredient[match.start():match.end()], "")}')
+            ingredient = ingredient[match.start():match.end()] + ' ' + ingredient.replace(ingredient[match.start():match.end()], '')
+
         # if the string contains parenthesis early on remove it and place it at the end
         # because its likely some kind of note
-        if re.match('(.){1,6}\s\((.[^\(\)])+\)\s', x):
-            match = re.search('\((.[^\(])+\)', x)
-            x = x[:match.start()] + x[match.end():] + ' ' + x[match.start():match.end()]
+        if re.match('(.){1,6}\s\((.[^\(\)])+\)\s', ingredient):
+            match = re.search('\((.[^\(])+\)', ingredient)
+            ingredient = ingredient[:match.start()] + ingredient[match.end():] + ' ' + ingredient[match.start():match.end()]
 
-        tokens = x.split()
+        # leading spaces before commas result in extra tokens, clean them out
+        ingredient = ingredient.replace(' ,', ',')
+
+        tokens = ingredient.split()  # split at each space into tokens
         if len(tokens) == 1:
-            # there only is one argument, that must be the ingredient
-            ingredient = tokens[0]
+            # there only is one argument, that must be the food
+            food = tokens[0]
         else:
             try:
                 # try to parse first argument as amount
@@ -227,48 +248,65 @@ class IngredientParser:
                 # a fraction for the amount
                 if len(tokens) > 2:
                     try:
-                        if not unit == '':
+                        if unit is not None:
                             # a unit is already found, no need to try the second argument for a fraction
-                            # probably not the best method to do it, but I didn't want to make an if check and paste the exact same thing in the else as already is in the except  # noqa: E501
+                            # probably not the best method to do it, but I didn't want to make an if check and paste the exact same thing in the else as already is in the except
                             raise ValueError
                         # try to parse second argument as amount and add that, in case of '2 1/2' or '2 ½'
                         amount += self.parse_fraction(tokens[1])
                         # assume that units can't end with a comma
                         if len(tokens) > 3 and not tokens[2].endswith(','):
-                            # try to use third argument as unit and everything else as ingredient, use everything as ingredient if it fails  # noqa: E501
+                            # try to use third argument as unit and everything else as food, use everything as food if it fails
                             try:
-                                ingredient, note = self.parse_ingredient(tokens[3:])
+                                food, note = self.parse_food(tokens[3:])
                                 unit = tokens[2]
                             except ValueError:
-                                ingredient, note = self.parse_ingredient(tokens[2:])
+                                food, note = self.parse_food(tokens[2:])
                         else:
-                            ingredient, note = self.parse_ingredient(tokens[2:])
+                            food, note = self.parse_food(tokens[2:])
                     except ValueError:
                         # assume that units can't end with a comma
                         if not tokens[1].endswith(','):
-                            # try to use second argument as unit and everything else as ingredient, use everything as ingredient if it fails  # noqa: E501
+                            # try to use second argument as unit and everything else as food, use everything as food if it fails
                             try:
-                                ingredient, note = self.parse_ingredient(tokens[2:])
-                                if unit == '':
+                                food, note = self.parse_food(tokens[2:])
+                                if unit is None:
                                     unit = tokens[1]
                                 else:
                                     note = tokens[1]
                             except ValueError:
-                                ingredient, note = self.parse_ingredient(tokens[1:])
+                                food, note = self.parse_food(tokens[1:])
                         else:
-                            ingredient, note = self.parse_ingredient(tokens[1:])
+                            food, note = self.parse_food(tokens[1:])
                 else:
                     # only two arguments, first one is the amount
-                    # which means this is the ingredient
-                    ingredient = tokens[1]
+                    # which means this is the food
+                    food = tokens[1]
             except ValueError:
                 try:
                     # can't parse first argument as amount
-                    # -> no unit -> parse everything as ingredient
-                    ingredient, note = self.parse_ingredient(tokens)
+                    # -> no unit -> parse everything as food
+                    food, note = self.parse_food(tokens)
                 except ValueError:
-                    ingredient = ' '.join(tokens[1:])
+                    food = ' '.join(tokens[1:])
 
         if unit_note not in note:
             note += ' ' + unit_note
-        return amount, self.apply_unit_automation(unit.strip()), self.apply_food_automation(ingredient.strip()), note.strip()
+
+        if unit:
+            unit = self.apply_unit_automation(unit.strip())
+
+        food = self.apply_food_automation(food.strip())
+        if len(food) > Food._meta.get_field('name').max_length:  # test if food name is to long
+            # try splitting it at a space and taking only the first arg
+            if len(food.split()) > 1 and len(food.split()[0]) < Food._meta.get_field('name').max_length:
+                note = ' '.join(food.split()[1:]) + ' ' + note
+                food = food.split()[0]
+            else:
+                note = food + ' ' + note
+                food = food[:Food._meta.get_field('name').max_length]
+
+        if len(food.strip()) == 0:
+            raise ValueError(f'Error parsing string {ingredient}, food cannot be empty')
+
+        return amount, unit, food, note[:Ingredient._meta.get_field('note').max_length].strip()

cookbook/helper/permission_helper.py

@@ -1,6 +1,3 @@
-"""
-Source: https://djangosnippets.org/snippets/1703/
-"""
 from django.conf import settings
 from django.contrib import messages
 from django.contrib.auth.decorators import user_passes_test
@@ -12,7 +9,7 @@ from django.utils.translation import gettext as _
 from rest_framework import permissions
 from rest_framework.permissions import SAFE_METHODS
 
-from cookbook.models import ShareLink
+from cookbook.models import ShareLink, Recipe, UserPreference
 
 
 def get_allowed_groups(groups_required):
@@ -262,3 +259,38 @@ class CustomIsShare(permissions.BasePermission):
         if share:
             return share_link_valid(obj, share)
         return False
+
+
+def above_space_limit(space):  # TODO add file storage limit
+    """
+    Test if the space has reached any limit (e.g. max recipes, users, ..)
+    :param space: Space to test for limits
+    :return: Tuple (True if above or equal any limit else false, message)
+    """
+    r_limit, r_msg = above_space_recipe_limit(space)
+    u_limit, u_msg = above_space_user_limit(space)
+    return r_limit or u_limit, (r_msg + ' ' + u_msg).strip()
+
+
+def above_space_recipe_limit(space):
+    """
+    Test if a space has reached its recipe limit
+    :param space: Space to test for limits
+    :return: Tuple (True if above or equal limit else false, message)
+    """
+    limit = space.max_recipes != 0 and Recipe.objects.filter(space=space).count() >= space.max_recipes
+    if limit:
+        return True, _('You have reached the maximum number of recipes for your space.')
+    return False, ''
+
+
+def above_space_user_limit(space):
+    """
+    Test if a space has reached its user limit
+    :param space: Space to test for limits
+    :return: Tuple (True if above or equal limit else false, message)
+    """
+    limit = space.max_users != 0 and UserPreference.objects.filter(space=space).count() > space.max_users
+    if limit:
+        return True, _('You have more users than allowed in your space.')
+    return False, ''

cookbook/helper/recipe_html_import.py

@@ -9,6 +9,8 @@ from recipe_scrapers._utils import get_host_name, normalize_string
 
 from cookbook.helper import recipe_url_import as helper
 from cookbook.helper.scrapers.scrapers import text_scraper
+from recipe_scrapers import scrape_me
+from recipe_scrapers._exceptions import NoSchemaFoundInWildMode
 
 
 def get_recipe_from_source(text, url, request):
@@ -58,51 +60,46 @@ def get_recipe_from_source(text, url, request):
                 })
         return kid_list
 
-    recipe_json = {
-        'name': '',
-                'url': '',
-                'description': '',
-                'image': '',
-                'keywords': [],
-                'recipeIngredient': [],
-                'recipeInstructions': '',
-                'servings': '',
-                'prepTime': '',
-                'cookTime': ''
-    }
     recipe_tree = []
     parse_list = []
     html_data = []
     images = []
     text = unquote(text)
+    scrape = None
 
-    try:
-        parse_list.append(remove_graph(json.loads(text)))
-        if not url and 'url' in parse_list[0]:
-            url = parse_list[0]['url']
-        scrape = text_scraper("<script type='application/ld+json'>" + text + "</script>", url=url)
+    if url:
+        try:
+            scrape = scrape_me(url_path=url, wild_mode=True)
+        except(NoSchemaFoundInWildMode):
+            pass
+    if not scrape:
+        try:
+            parse_list.append(remove_graph(json.loads(text)))
+            if not url and 'url' in parse_list[0]:
+                url = parse_list[0]['url']
+            scrape = text_scraper("<script type='application/ld+json'>" + text + "</script>", url=url)
 
-    except JSONDecodeError:
-        soup = BeautifulSoup(text, "html.parser")
-        html_data = get_from_html(soup)
-        images += get_images_from_source(soup, url)
-        for el in soup.find_all('script', type='application/ld+json'):
-            el = remove_graph(el)
-            if not url and 'url' in el:
-                url = el['url']
-            if type(el) == list:
-                for le in el:
-                    parse_list.append(le)
-            elif type(el) == dict:
-                parse_list.append(el)
-        for el in soup.find_all(type='application/json'):
-            el = remove_graph(el)
-            if type(el) == list:
-                for le in el:
-                    parse_list.append(le)
-            elif type(el) == dict:
-                parse_list.append(el)
-        scrape = text_scraper(text, url=url)
+        except JSONDecodeError:
+            soup = BeautifulSoup(text, "html.parser")
+            html_data = get_from_html(soup)
+            images += get_images_from_source(soup, url)
+            for el in soup.find_all('script', type='application/ld+json'):
+                el = remove_graph(el)
+                if not url and 'url' in el:
+                    url = el['url']
+                if type(el) == list:
+                    for le in el:
+                        parse_list.append(le)
+                elif type(el) == dict:
+                    parse_list.append(el)
+            for el in soup.find_all(type='application/json'):
+                el = remove_graph(el)
+                if type(el) == list:
+                    for le in el:
+                        parse_list.append(le)
+                elif type(el) == dict:
+                    parse_list.append(el)
+            scrape = text_scraper(text, url=url)
 
     recipe_json = helper.get_from_scraper(scrape, request)
 

cookbook/helper/recipe_url_import.py

@@ -1,8 +1,10 @@
 import random
 import re
 from html import unescape
+from unicodedata import decomposition
 
 from django.utils.dateparse import parse_duration
+from django.utils.translation import gettext as _
 from isodate import parse_duration as iso_parse_duration
 from isodate.isoerror import ISO8601Error
 from recipe_scrapers._utils import get_minutes
@@ -12,6 +14,9 @@ from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.models import Keyword
 
 
+# from recipe_scrapers._utils import get_minutes  ## temporary until/unless upstream incorporates get_minutes() PR
+
+
 def get_from_scraper(scrape, request):
     # converting the scrape_me object to the existing json format based on ld+json
     recipe_json = {}
@@ -26,11 +31,16 @@ def get_from_scraper(scrape, request):
             recipe_json['name'] = ''
 
     try:
-        description = scrape.schema.data.get("description") or ''
+        description = scrape.description() or None
     except Exception:
-        description = ''
+        description = None
+    if not description:
+        try:
+            description = scrape.schema.data.get("description") or ''
+        except Exception:
+            description = ''
 
-    recipe_json['description'] = parse_description(description)
+    recipe_json['internal'] = True
 
     try:
         servings = scrape.yields() or None
@@ -41,28 +51,31 @@ def get_from_scraper(scrape, request):
             servings = scrape.schema.data.get('recipeYield') or 1
         except Exception:
             servings = 1
-    if type(servings) != int:
+
+    recipe_json['servings'] = parse_servings(servings)
+    recipe_json['servings_text'] = parse_servings_text(servings)
+
+    try:
+        recipe_json['working_time'] = get_minutes(scrape.prep_time()) or 0
+    except Exception:
         try:
-            servings = int(re.findall(r'\b\d+\b', servings)[0])
+            recipe_json['working_time'] = get_minutes(scrape.schema.data.get("prepTime")) or 0
         except Exception:
-            servings = 1
-    recipe_json['servings'] = max(servings, 1)
-
+            recipe_json['working_time'] = 0
     try:
-        recipe_json['prepTime'] = get_minutes(scrape.schema.data.get("prepTime")) or 0
+        recipe_json['waiting_time'] = get_minutes(scrape.cook_time()) or 0
     except Exception:
-        recipe_json['prepTime'] = 0
-    try:
-        recipe_json['cookTime'] = get_minutes(scrape.schema.data.get("cookTime")) or 0
-    except Exception:
-        recipe_json['cookTime'] = 0
-
-    if recipe_json['cookTime'] + recipe_json['prepTime'] == 0:
         try:
-            recipe_json['prepTime'] = get_minutes(scrape.total_time()) or 0
+            recipe_json['waiting_time'] = get_minutes(scrape.schema.data.get("cookTime")) or 0
+        except Exception:
+            recipe_json['waiting_time'] = 0
+
+    if recipe_json['working_time'] + recipe_json['waiting_time'] == 0:
+        try:
+            recipe_json['working_time'] = get_minutes(scrape.total_time()) or 0
         except Exception:
             try:
-                get_minutes(scrape.schema.data.get("totalTime")) or 0
+                recipe_json['working_time'] = get_minutes(scrape.schema.data.get("totalTime")) or 0
             except Exception:
                 pass
 
@@ -83,15 +96,38 @@ def get_from_scraper(scrape, request):
     except Exception:
         pass
     try:
-        if scrape.schema.data.get('recipeCategory'):
-            keywords += listify_keywords(scrape.schema.data.get("recipeCategory"))
+        if scrape.category():
+            keywords += listify_keywords(scrape.category())
     except Exception:
-        pass
+        try:
+            if scrape.schema.data.get('recipeCategory'):
+                keywords += listify_keywords(scrape.schema.data.get("recipeCategory"))
+        except Exception:
+            pass
     try:
-        if scrape.schema.data.get('recipeCuisine'):
-            keywords += listify_keywords(scrape.schema.data.get("recipeCuisine"))
+        if scrape.cuisine():
+            keywords += listify_keywords(scrape.cuisine())
     except Exception:
-        pass
+        try:
+            if scrape.schema.data.get('recipeCuisine'):
+                keywords += listify_keywords(scrape.schema.data.get("recipeCuisine"))
+        except Exception:
+            pass
+
+    try:
+        source_url = scrape.canonical_url()
+    except Exception:
+        try: 
+            source_url = scrape.url
+        except Exception:
+            pass
+    if source_url:
+        recipe_json['source_url'] = source_url
+        try:
+            keywords.append(source_url.replace('http://', '').replace('https://', '').split('/')[0])
+        except Exception:
+            pass
+
     try:
         recipe_json['keywords'] = parse_keywords(list(set(map(str.casefold, keywords))), request.space)
     except AttributeError:
@@ -99,54 +135,51 @@ def get_from_scraper(scrape, request):
 
     ingredient_parser = IngredientParser(request, True)
 
-    ingredients = []
+    recipe_json['steps'] = []
+    try:
+        for i in parse_instructions(scrape.instructions()):
+            recipe_json['steps'].append({'instruction': i, 'ingredients': [], })
+    except Exception:
+        pass
+    if len(recipe_json['steps']) == 0:
+        recipe_json['steps'].append({'instruction': '', 'ingredients': [], })
+
+    if len(parse_description(description)) > 256:  # split at 256 as long descriptions dont look good on recipe cards
+        recipe_json['steps'][0]['instruction'] = f'*{parse_description(description)}*  \n\n' + recipe_json['steps'][0]['instruction']
+    else:
+        recipe_json['description'] = parse_description(description)[:512]
+
     try:
         for x in scrape.ingredients():
             try:
                 amount, unit, ingredient, note = ingredient_parser.parse(x)
-                ingredients.append(
-                    {
-                        'amount': amount,
-                        'unit': {
-                            'text': unit,
-                            'id': random.randrange(10000, 99999)
-                        },
-                        'ingredient': {
-                            'text': ingredient,
-                            'id': random.randrange(10000, 99999)
-                        },
-                        'note': note,
-                        'original': x
-                    }
-                )
+                ingredient = {
+                    'amount': amount,
+                    'food': {
+                        'name': ingredient,
+                    },
+                    'unit': None,
+                    'note': note,
+                    'original_text': x
+                }
+                if unit:
+                    ingredient['unit'] = {'name': unit, }
+                recipe_json['steps'][0]['ingredients'].append(ingredient)
             except Exception:
-                ingredients.append(
+                recipe_json['steps'][0]['ingredients'].append(
                     {
                         'amount': 0,
-                        'unit': {
-                            'text': '',
-                            'id': random.randrange(10000, 99999)
-                        },
-                        'ingredient': {
-                            'text': x,
-                            'id': random.randrange(10000, 99999)
+                        'unit': None,
+                        'food': {
+                            'name': x,
                         },
                         'note': '',
-                        'original': x
+                        'original_text': x
                     }
                 )
-        recipe_json['recipeIngredient'] = ingredients
     except Exception:
-        recipe_json['recipeIngredient'] = ingredients
+        pass
 
-    try:
-        recipe_json['recipeInstructions'] = parse_instructions(scrape.instructions())
-    except Exception:
-        recipe_json['recipeInstructions'] = ""
-
-    if scrape.url:
-        recipe_json['url'] = scrape.url
-        recipe_json['recipeInstructions'] += "\n\nImported from " + scrape.url
     return recipe_json
 
 
@@ -159,102 +192,46 @@ def parse_name(name):
     return normalize_string(name)
 
 
-def parse_ingredients(ingredients):
-    # some pages have comma separated ingredients in a single array entry
-    try:
-        if type(ingredients[0]) == dict:
-            return ingredients
-    except (KeyError, IndexError):
-        pass
-
-    if (len(ingredients) == 1 and type(ingredients) == list):
-        ingredients = ingredients[0].split(',')
-    elif type(ingredients) == str:
-        ingredients = ingredients.split(',')
-
-    for x in ingredients:
-        if '\n' in x:
-            ingredients.remove(x)
-            for i in x.split('\n'):
-                ingredients.insert(0, i)
-
-    ingredient_list = []
-
-    for x in ingredients:
-        if x.replace(' ', '') != '':
-            x = x.replace('½', "0.5").replace('¼', "0.25").replace('¾', "0.75")
-            try:
-                amount, unit, ingredient, note = parse_single_ingredient(x)
-                if ingredient:
-                    ingredient_list.append(
-                        {
-                            'amount': amount,
-                            'unit': {
-                                'text': unit,
-                                'id': random.randrange(10000, 99999)
-                            },
-                            'ingredient': {
-                                'text': ingredient,
-                                'id': random.randrange(10000, 99999)
-                            },
-                            'note': note,
-                            'original': x
-                        }
-                    )
-            except Exception:
-                ingredient_list.append(
-                    {
-                        'amount': 0,
-                        'unit': {
-                            'text': '',
-                            'id': random.randrange(10000, 99999)
-                        },
-                        'ingredient': {
-                            'text': x,
-                            'id': random.randrange(10000, 99999)
-                        },
-                        'note': '',
-                        'original': x
-                    }
-                )
-
-            ingredients = ingredient_list
-        else:
-            ingredients = []
-    return ingredients
-
-
 def parse_description(description):
     return normalize_string(description)
 
 
-def parse_instructions(instructions):
-    instruction_text = ''
-
-    # flatten instructions if they are in a list
-    if type(instructions) == list:
-        for i in instructions:
-            if type(i) == str:
-                instruction_text += i
-            else:
-                if 'text' in i:
-                    instruction_text += i['text'] + '\n\n'
-                elif 'itemListElement' in i:
-                    for ile in i['itemListElement']:
-                        if type(ile) == str:
-                            instruction_text += ile + '\n\n'
-                        elif 'text' in ile:
-                            instruction_text += ile['text'] + '\n\n'
-                else:
-                    instruction_text += str(i)
-        instructions = instruction_text
-
-    normalized_string = normalize_string(instructions)
+def clean_instruction_string(instruction):
+    normalized_string = normalize_string(instruction)
     normalized_string = normalized_string.replace('\n', '  \n')
     normalized_string = normalized_string.replace('  \n  \n', '\n\n')
     return normalized_string
 
 
+def parse_instructions(instructions):
+    """
+    Convert arbitrary instructions object from website import and turn it into a flat list of strings
+    :param instructions: any instructions object from import
+    :return: list of strings (from one to many elements depending on website)
+    """
+    instruction_list = []
+
+    if type(instructions) == list:
+        for i in instructions:
+            if type(i) == str:
+                instruction_list.append(clean_instruction_string(i))
+            else:
+                if 'text' in i:
+                    instruction_list.append(clean_instruction_string(i['text']))
+                elif 'itemListElement' in i:
+                    for ile in i['itemListElement']:
+                        if type(ile) == str:
+                            instruction_list.append(clean_instruction_string(ile))
+                        elif 'text' in ile:
+                            instruction_list.append(clean_instruction_string(ile['text']))
+                else:
+                    instruction_list.append(clean_instruction_string(str(i)))
+    else:
+        instruction_list.append(clean_instruction_string(instructions))
+
+    return instruction_list
+
+
 def parse_image(image):
     # check if list of images is returned, take first if so
     if not image:
@@ -289,40 +266,31 @@ def parse_servings(servings):
     return servings
 
 
-def parse_cooktime(cooktime):
-    if type(cooktime) not in [int, float]:
+def parse_servings_text(servings):
+    if type(servings) == str:
         try:
-            cooktime = float(re.search(r'\d+', cooktime).group())
+            servings = re.sub("\d+", '', servings).strip()
+        except Exception:
+            servings = ''
+    return servings
+
+
+def parse_time(recipe_time):
+    if type(recipe_time) not in [int, float]:
+        try:
+            recipe_time = float(re.search(r'\d+', recipe_time).group())
         except (ValueError, AttributeError):
             try:
-                cooktime = round(iso_parse_duration(cooktime).seconds / 60)
+                recipe_time = round(iso_parse_duration(recipe_time).seconds / 60)
             except ISO8601Error:
                 try:
-                    if (type(cooktime) == list and len(cooktime) > 0):
-                        cooktime = cooktime[0]
-                    cooktime = round(parse_duration(cooktime).seconds / 60)
+                    if (type(recipe_time) == list and len(recipe_time) > 0):
+                        recipe_time = recipe_time[0]
+                    recipe_time = round(parse_duration(recipe_time).seconds / 60)
                 except AttributeError:
-                    cooktime = 0
+                    recipe_time = 0
 
-    return cooktime
-
-
-def parse_preptime(preptime):
-    if type(preptime) not in [int, float]:
-        try:
-            preptime = float(re.search(r'\d+', preptime).group())
-        except ValueError:
-            try:
-                preptime = round(iso_parse_duration(preptime).seconds / 60)
-            except ISO8601Error:
-                try:
-                    if (type(preptime) == list and len(preptime) > 0):
-                        preptime = preptime[0]
-                    preptime = round(parse_duration(preptime).seconds / 60)
-                except AttributeError:
-                    preptime = 0
-
-    return preptime
+    return recipe_time
 
 
 def parse_keywords(keyword_json, space):
@@ -332,9 +300,9 @@ def parse_keywords(keyword_json, space):
         kw = normalize_string(kw)
         if len(kw) != 0:
             if k := Keyword.objects.filter(name=kw, space=space).first():
-                keywords.append({'id': str(k.id), 'text': str(k)})
+                keywords.append({'label': str(k), 'name': k.name, 'id': k.id})
             else:
-                keywords.append({'id': random.randrange(1111111, 9999999, 1), 'text': kw})
+                keywords.append({'label': kw, 'name': kw})
 
     return keywords
 

cookbook/helper/scrapers/scrapers.py

@@ -1,6 +1,6 @@
 from bs4 import BeautifulSoup
 from json import JSONDecodeError
-from recipe_scrapers import SCRAPERS, get_host_name
+from recipe_scrapers import SCRAPERS 
 from recipe_scrapers._factory import SchemaScraperFactory
 from recipe_scrapers._schemaorg import SchemaOrg
 
@@ -15,13 +15,7 @@ SCRAPERS.update(CUSTOM_SCRAPERS)
 
 
 def text_scraper(text, url=None):
-    domain = None
-    if url:
-        domain = get_host_name(url)
-    if domain in SCRAPERS:
-        scraper_class = SCRAPERS[domain]
-    else:
-        scraper_class = SchemaScraperFactory.SchemaScraper
+    scraper_class = SchemaScraperFactory.SchemaScraper
 
     class TextScraper(scraper_class):
         def __init__(

cookbook/helper/shopping_helper.py

@@ -35,7 +35,7 @@ def shopping_helper(qs, request):
         qs = qs.filter(Q(checked=False) | Q(completed_at__gte=week_ago))
         supermarket_order = ['checked'] + supermarket_order
 
-    return qs.order_by(*supermarket_order).select_related('unit', 'food', 'ingredient', 'created_by', 'list_recipe', 'list_recipe__mealplan', 'list_recipe__recipe')
+    return qs.distinct().order_by(*supermarket_order).select_related('unit', 'food', 'ingredient', 'created_by', 'list_recipe', 'list_recipe__mealplan', 'list_recipe__recipe')
 
 
 class RecipeShoppingEditor():
@@ -65,9 +65,13 @@ class RecipeShoppingEditor():
         except (ValueError, TypeError):
             self.servings = getattr(self._shopping_list_recipe, 'servings', None) or getattr(self.mealplan, 'servings', None) or getattr(self.recipe, 'servings', None)
 
+    @property
+    def _recipe_servings(self):
+        return getattr(self.recipe, 'servings', None) or getattr(getattr(self.mealplan, 'recipe', None), 'servings', None) or getattr(getattr(self._shopping_list_recipe, 'recipe', None), 'servings', None)
+
     @property
     def _servings_factor(self):
-        return self.servings / self.recipe.servings
+        return Decimal(self.servings)/Decimal(self._recipe_servings)
 
     @property
     def _shared_users(self):

cookbook/helper/template_helper.py

@@ -1,11 +1,14 @@
+from gettext import gettext as _
+
 import bleach
 import markdown as md
 from bleach_allowlist import markdown_attrs, markdown_tags
+from jinja2 import Template, TemplateSyntaxError, UndefinedError
+from markdown.extensions.tables import TableExtension
+
 from cookbook.helper.mdx_attributes import MarkdownFormatExtension
 from cookbook.helper.mdx_urlize import UrlizeExtension
-from jinja2 import Template, TemplateSyntaxError, UndefinedError
-from gettext import gettext as _
-from markdown.extensions.tables import TableExtension
+
 
 class IngredientObject(object):
     amount = ""
@@ -36,7 +39,7 @@ def render_instructions(step):  # TODO deduplicate markdown cleanup code
     instructions = step.instruction
 
     tags = markdown_tags + [
-        'pre', 'table', 'td', 'tr', 'th', 'tbody', 'style', 'thead'
+        'pre', 'table', 'td', 'tr', 'th', 'tbody', 'style', 'thead', 'img'
     ]
     parsed_md = md.markdown(
         instructions,
@@ -45,7 +48,7 @@ def render_instructions(step):  # TODO deduplicate markdown cleanup code
             UrlizeExtension(), MarkdownFormatExtension()
         ]
     )
-    markdown_attrs['*'] = markdown_attrs['*'] + ['class']
+    markdown_attrs['*'] = markdown_attrs['*'] + ['class', 'width', 'height']
 
     instructions = bleach.clean(parsed_md, tags, markdown_attrs)
 

cookbook/integration/cheftap.py

@@ -2,14 +2,14 @@ import re
 
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient
+from cookbook.models import Ingredient, Recipe, Step
 
 
 class ChefTap(Integration):
 
     def import_file_name_filter(self, zip_info_object):
         print("testing", zip_info_object.filename)
-        return re.match(r'^cheftap_export/([A-Za-z\d\w\s-])+.txt$', zip_info_object.filename) or re.match(r'^([A-Za-z\d\w\s-])+.txt$', zip_info_object.filename)
+        return re.match(r'^cheftap_export/([A-Za-z\d\s\-_()\[\]\u00C0-\u017F])+.txt$', zip_info_object.filename) or re.match(r'^([A-Za-z\d\s\-_()\[\]\u00C0-\u017F])+.txt$', zip_info_object.filename)
 
     def get_recipe_from_file(self, file):
         source_url = ''
@@ -45,11 +45,11 @@ class ChefTap(Integration):
         ingredient_parser = IngredientParser(self.request, True)
         for ingredient in ingredients:
             if len(ingredient.strip()) > 0:
-                amount, unit, ingredient, note = ingredient_parser.parse(ingredient)
-                f = ingredient_parser.get_food(ingredient)
+                amount, unit, food, note = ingredient_parser.parse(ingredient)
+                f = ingredient_parser.get_food(food)
                 u = ingredient_parser.get_unit(unit)
                 step.ingredients.add(Ingredient.objects.create(
-                    food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                    food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
                 ))
         recipe.steps.add(step)
 

cookbook/integration/chowdown.py

@@ -5,14 +5,14 @@ from zipfile import ZipFile
 from cookbook.helper.image_processing import get_filetype
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient, Keyword
+from cookbook.models import Ingredient, Keyword, Recipe, Step
 
 
 class Chowdown(Integration):
 
     def import_file_name_filter(self, zip_info_object):
         print("testing", zip_info_object.filename)
-        return re.match(r'^(_)*recipes/([A-Za-z\d\s-])+.md$', zip_info_object.filename)
+        return re.match(r'^(_)*recipes/([A-Za-z\d\s\-_()\[\]\u00C0-\u017F])+.md$', zip_info_object.filename)
 
     def get_recipe_from_file(self, file):
         ingredient_mode = False
@@ -60,12 +60,13 @@ class Chowdown(Integration):
 
         ingredient_parser = IngredientParser(self.request, True)
         for ingredient in ingredients:
-            amount, unit, ingredient, note = ingredient_parser.parse(ingredient)
-            f = ingredient_parser.get_food(ingredient)
-            u = ingredient_parser.get_unit(unit)
-            step.ingredients.add(Ingredient.objects.create(
-                food=f, unit=u, amount=amount, note=note, space=self.request.space,
-            ))
+            if len(ingredient.strip()) > 0:
+                amount, unit, food, note = ingredient_parser.parse(ingredient)
+                f = ingredient_parser.get_food(food)
+                u = ingredient_parser.get_unit(unit)
+                step.ingredients.add(Ingredient.objects.create(
+                    food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
+                ))
         recipe.steps.add(step)
 
         for f in self.files:

cookbook/integration/cookbookapp.py

@@ -2,17 +2,18 @@ import base64
 import gzip
 import json
 import re
+from gettext import gettext as _
 from io import BytesIO
 
 import requests
+import validators
 import yaml
 
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.helper.recipe_html_import import get_recipe_from_source
 from cookbook.helper.recipe_url_import import iso_duration_to_minutes
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient, Keyword
-from gettext import gettext as _
+from cookbook.models import Ingredient, Keyword, Recipe, Step
 
 
 class CookBookApp(Integration):
@@ -51,16 +52,18 @@ class CookBookApp(Integration):
 
         ingredient_parser = IngredientParser(self.request, True)
         for ingredient in recipe_json['recipeIngredient']:
-                f = ingredient_parser.get_food(ingredient['ingredient']['text'])
-                u = ingredient_parser.get_unit(ingredient['unit']['text'])
-                step.ingredients.add(Ingredient.objects.create(
-                    food=f, unit=u, amount=ingredient['amount'], note=ingredient['note'], space=self.request.space,
-                ))
+            f = ingredient_parser.get_food(ingredient['ingredient']['text'])
+            u = ingredient_parser.get_unit(ingredient['unit']['text'])
+            step.ingredients.add(Ingredient.objects.create(
+                food=f, unit=u, amount=ingredient['amount'], note=ingredient['note'],  space=self.request.space,
+            ))
 
         if len(images) > 0:
             try:
-                response = requests.get(images[0])
-                self.import_recipe_image(recipe, BytesIO(response.content))
+                url = images[0]
+                if validators.url(url, public=True):
+                    response = requests.get(url)
+                    self.import_recipe_image(recipe, BytesIO(response.content))
             except Exception as e:
                 print('failed to import image ', str(e))
 

cookbook/integration/cookmate.py

@@ -0,0 +1,80 @@
+import base64
+import json
+from io import BytesIO
+
+from gettext import gettext as _
+
+import requests
+import validators
+from lxml import etree
+
+from cookbook.helper.ingredient_parser import IngredientParser
+from cookbook.helper.recipe_url_import import parse_servings, parse_time, parse_servings_text
+from cookbook.integration.integration import Integration
+from cookbook.models import Ingredient, Keyword, Recipe, Step
+
+
+class Cookmate(Integration):
+
+    def import_file_name_filter(self, zip_info_object):
+        return zip_info_object.filename.endswith('.xml')
+
+    def get_files_from_recipes(self, recipes, el, cookie):
+        raise NotImplementedError('Method not implemented in storage integration')
+
+    def get_recipe_from_file(self, file):
+        recipe_xml = file
+
+        recipe = Recipe.objects.create(
+            name=recipe_xml.find('title').text.strip(),
+            created_by=self.request.user, internal=True, space=self.request.space)
+
+        if recipe_xml.find('preptime') is not None and recipe_xml.find('preptime').text is not None:
+            recipe.working_time = parse_time(recipe_xml.find('preptime').text.strip())
+
+        if recipe_xml.find('cooktime') is not None and recipe_xml.find('cooktime').text is not None:
+            recipe.waiting_time = parse_time(recipe_xml.find('cooktime').text.strip())
+
+        if recipe_xml.find('quantity') is not None and recipe_xml.find('quantity').text is not None:
+            recipe.servings = parse_servings(recipe_xml.find('quantity').text.strip())
+            recipe.servings_text = parse_servings_text(recipe_xml.find('quantity').text.strip())
+
+        if recipe_xml.find('url') is not None and recipe_xml.find('url').text is not None:
+            recipe.source_url = recipe_xml.find('url').text.strip()
+
+        if recipe_xml.find('description') is not None:  # description is a list of <li>'s with text
+            if len(recipe_xml.find('description')) > 0:
+                recipe.description = recipe_xml.find('description')[0].text[:512]
+
+        for step in recipe_xml.find('recipetext').getchildren():
+            step = Step.objects.create(
+                instruction=step.text.strip(), space=self.request.space,
+            )
+            recipe.steps.add(step)
+
+        ingredient_parser = IngredientParser(self.request, True)
+
+        for ingredient in recipe_xml.find('ingredient').getchildren():
+            if ingredient.text.strip() != '':
+                amount, unit, food, note = ingredient_parser.parse(ingredient.text.strip())
+                f = ingredient_parser.get_food(food)
+                u = ingredient_parser.get_unit(unit)
+                recipe.steps.first().ingredients.add(Ingredient.objects.create(
+                    food=f, unit=u, amount=amount, note=note, original_text=ingredient.text.strip(), space=self.request.space,
+                ))
+
+        if recipe_xml.find('imageurl') is not None:
+            try:
+                url = recipe_xml.find('imageurl').text.strip()
+                if validators.url(url, public=True):
+                    response = requests.get(url)
+                self.import_recipe_image(recipe, BytesIO(response.content))
+            except Exception as e:
+                print('failed to import image ', str(e))
+
+        recipe.save()
+
+        return recipe
+
+    def get_file_from_recipe(self, recipe):
+        raise NotImplementedError('Method not implemented in storage integration')

cookbook/integration/copymethat.py

@@ -4,11 +4,12 @@ from zipfile import ZipFile
 
 from bs4 import BeautifulSoup
 
+from django.utils.translation import gettext as _
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.helper.recipe_html_import import get_recipe_from_source
 from cookbook.helper.recipe_url_import import iso_duration_to_minutes, parse_servings
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient, Keyword
+from cookbook.models import Ingredient, Keyword, Recipe, Step
 from recipes.settings import DEBUG
 
 
@@ -31,7 +32,14 @@ class CopyMeThat(Integration):
             recipe.servings = parse_servings(file.find("a", {"id": "recipeYield"}).text.strip())
             recipe.working_time = iso_duration_to_minutes(file.find("span", {"meta": "prepTime"}).text.strip())
             recipe.waiting_time = iso_duration_to_minutes(file.find("span", {"meta": "cookTime"}).text.strip())
-            recipe.save()
+            recipe.description = (file.find("div ", {"id": "description"}).text.strip())[:512]
+
+        except AttributeError:
+            pass
+
+        try:
+            if len(file.find("span", {"id": "starred"}).text.strip()) > 0:
+                recipe.keywords.add(Keyword.objects.get_or_create(space=self.request.space, name=_('Favorite'))[0])
         except AttributeError:
             pass
 
@@ -41,11 +49,11 @@ class CopyMeThat(Integration):
         for ingredient in file.find_all("li", {"class": "recipeIngredient"}):
             if ingredient.text == "":
                 continue
-            amount, unit, ingredient, note = ingredient_parser.parse(ingredient.text.strip())
-            f = ingredient_parser.get_food(ingredient)
+            amount, unit, food, note = ingredient_parser.parse(ingredient.text.strip())
+            f = ingredient_parser.get_food(food)
             u = ingredient_parser.get_unit(unit)
             step.ingredients.add(Ingredient.objects.create(
-                food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                food=f, unit=u, amount=amount, note=note, original_text=ingredient.text.strip(), space=self.request.space,
             ))
 
         for s in file.find_all("li", {"class": "instruction"}):
@@ -60,7 +68,7 @@ class CopyMeThat(Integration):
 
         try:
             if file.find("a", {"id": "original_link"}).text != '':
-                step.instruction += "\n\nImported from: " + file.find("a", {"id": "original_link"}).text
+                step.instruction += "\n\n" + _("Imported from") + ": " + file.find("a", {"id": "original_link"}).text
                 step.save()
         except AttributeError:
             pass

cookbook/integration/domestica.py

@@ -4,7 +4,7 @@ from io import BytesIO
 
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient
+from cookbook.models import Ingredient, Recipe, Step
 
 
 class Domestica(Integration):
@@ -37,11 +37,11 @@ class Domestica(Integration):
         ingredient_parser = IngredientParser(self.request, True)
         for ingredient in file['ingredients'].split('\n'):
             if len(ingredient.strip()) > 0:
-                amount, unit, ingredient, note = ingredient_parser.parse(ingredient)
-                f = ingredient_parser.get_food(ingredient)
+                amount, unit, food, note = ingredient_parser.parse(ingredient)
+                f = ingredient_parser.get_food(food)
                 u = ingredient_parser.get_unit(unit)
                 step.ingredients.add(Ingredient.objects.create(
-                    food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                    food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
                 ))
         recipe.steps.add(step)
 

cookbook/integration/integration.py

@@ -5,6 +5,8 @@ import traceback
 import uuid
 from io import BytesIO, StringIO
 from zipfile import BadZipFile, ZipFile
+
+import lxml
 from django.core.cache import cache
 import datetime
 
@@ -16,6 +18,7 @@ from django.http import HttpResponse
 from django.utils.formats import date_format
 from django.utils.translation import gettext as _
 from django_scopes import scope
+from lxml import etree
 
 from cookbook.forms import ImportExportBase
 from cookbook.helper.image_processing import get_filetype, handle_image
@@ -144,7 +147,7 @@ class Integration:
                                 il.imported_recipes += 1
                                 il.save()
                         import_zip.close()
-                    elif '.zip' in f['name'] or '.paprikarecipes' in f['name']:
+                    elif '.zip' in f['name'] or '.paprikarecipes' in f['name'] or '.mcb' in f['name']:
                         import_zip = ZipFile(f['file'])
                         file_list = []
                         for z in import_zip.filelist:
@@ -157,9 +160,16 @@ class Integration:
                             file_list = self.split_recipe_file(BytesIO(import_zip.read('recipes.html')))
                             il.total_recipes += len(file_list)
 
+                        if isinstance(self, cookbook.integration.cookmate.Cookmate):
+                            new_file_list = []
+                            for file in file_list:
+                                new_file_list += etree.parse(BytesIO(import_zip.read(file.filename))).getroot().getchildren()
+                            il.total_recipes = len(new_file_list)
+                            file_list = new_file_list
+
                         for z in file_list:
                             try:
-                                if isinstance(z, Tag):
+                                if not hasattr(z, 'filename'):
                                     recipe = self.get_recipe_from_file(z)
                                 else:
                                     recipe = self.get_recipe_from_file(BytesIO(import_zip.read(z.filename)))
@@ -172,7 +182,7 @@ class Integration:
                                 traceback.print_exc()
                                 self.handle_exception(e, log=il, message=f'-------------------- \nERROR \n{e}\n--------------------\n')
                         import_zip.close()
-                    elif '.json' in f['name'] or '.txt' in f['name'] or '.mmf' in f['name']:
+                    elif '.json' in f['name'] or '.txt' in f['name'] or '.mmf' in f['name'] or '.rk' in f['name'] or '.melarecipe' in f['name']:
                         data_list = self.split_recipe_file(f['file'])
                         il.total_recipes += len(data_list)
                         for d in data_list:
@@ -243,7 +253,7 @@ class Integration:
         :param image_file: ByteIO stream containing the image
         :param filetype: type of file to write bytes to, default to .jpeg if unknown
         """
-        recipe.image = File(handle_image(self.request, File(image_file, name='image'), filetype=filetype)[0], name=f'{uuid.uuid4()}_{recipe.pk}{filetype}')
+        recipe.image = File(handle_image(self.request, File(image_file, name='image'), filetype=filetype), name=f'{uuid.uuid4()}_{recipe.pk}{filetype}')
         recipe.save()
 
     def get_recipe_from_file(self, file):

cookbook/integration/mealie.py

@@ -6,13 +6,13 @@ from zipfile import ZipFile
 from cookbook.helper.image_processing import get_filetype
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient
+from cookbook.models import Ingredient, Recipe, Step
 
 
 class Mealie(Integration):
 
     def import_file_name_filter(self, zip_info_object):
-        return re.match(r'^recipes/([A-Za-z\d-])+/([A-Za-z\d-])+.json$', zip_info_object.filename)
+        return re.match(r'^recipes/([A-Za-z\d\s\-_()\[\]\u00C0-\u017F])+/([A-Za-z\d\s\-_()\[\]\u00C0-\u017F])+.json$', zip_info_object.filename)
 
     def get_recipe_from_file(self, file):
         recipe_json = json.loads(file.getvalue().decode("utf-8"))
@@ -45,12 +45,14 @@ class Mealie(Integration):
                             u = ingredient_parser.get_unit(ingredient['unit'])
                             amount = ingredient['quantity']
                             note = ingredient['note']
+                            original_text = None
                         else:
-                            amount, unit, ingredient, note = ingredient_parser.parse(ingredient['note'])
-                            f = ingredient_parser.get_food(ingredient)
+                            amount, unit, food, note = ingredient_parser.parse(ingredient['note'])
+                            f = ingredient_parser.get_food(food)
                             u = ingredient_parser.get_unit(unit)
+                            original_text = ingredient['note']
                         step.ingredients.add(Ingredient.objects.create(
-                            food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                            food=f, unit=u, amount=amount, note=note, original_text=original_text, space=self.request.space,
                         ))
                     except Exception:
                         pass
@@ -60,7 +62,8 @@ class Mealie(Integration):
             if '.zip' in f['name']:
                 import_zip = ZipFile(f['file'])
                 try:
-                    self.import_recipe_image(recipe, BytesIO(import_zip.read(f'recipes/{recipe_json["slug"]}/images/min-original.webp')), filetype=get_filetype(f'recipes/{recipe_json["slug"]}/images/original'))
+                    self.import_recipe_image(recipe, BytesIO(import_zip.read(f'recipes/{recipe_json["slug"]}/images/min-original.webp')),
+                                             filetype=get_filetype(f'recipes/{recipe_json["slug"]}/images/original'))
                 except Exception:
                     pass
 

cookbook/integration/mealmaster.py

@@ -2,7 +2,7 @@ import re
 
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient, Keyword
+from cookbook.models import Ingredient, Keyword, Recipe, Step
 
 
 class MealMaster(Integration):
@@ -45,11 +45,11 @@ class MealMaster(Integration):
         ingredient_parser = IngredientParser(self.request, True)
         for ingredient in ingredients:
             if len(ingredient.strip()) > 0:
-                amount, unit, ingredient, note = ingredient_parser.parse(ingredient)
+                amount, unit, food, note = ingredient_parser.parse(ingredient)
                 f = ingredient_parser.get_food(ingredient)
                 u = ingredient_parser.get_unit(unit)
                 step.ingredients.add(Ingredient.objects.create(
-                    food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                    food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
                 ))
         recipe.steps.add(step)
 

cookbook/integration/melarecipes.py

@@ -0,0 +1,83 @@
+import base64
+import json
+from io import BytesIO
+
+from gettext import gettext as _
+from cookbook.helper.ingredient_parser import IngredientParser
+from cookbook.helper.recipe_url_import import parse_servings, parse_time
+from cookbook.integration.integration import Integration
+from cookbook.models import Ingredient, Keyword, Recipe, Step
+
+
+class MelaRecipes(Integration):
+
+    def split_recipe_file(self, file):
+        return [json.loads(file.getvalue().decode("utf-8"))]
+
+    def get_files_from_recipes(self, recipes, el, cookie):
+        raise NotImplementedError('Method not implemented in storage integration')
+
+    def get_recipe_from_file(self, file):
+        recipe_json = file
+
+        recipe = Recipe.objects.create(
+            name=recipe_json['title'].strip(),
+            created_by=self.request.user, internal=True, space=self.request.space)
+
+        if 'yield' in recipe_json:
+            recipe.servings = parse_servings(recipe_json['yield'])
+
+        if 'cookTime' in recipe_json:
+            recipe.waiting_time = parse_time(recipe_json['cookTime'])
+
+        if 'prepTime' in recipe_json:
+            recipe.working_time = parse_time(recipe_json['prepTime'])
+
+        if 'favorite' in recipe_json and recipe_json['favorite']:
+            recipe.keywords.add(Keyword.objects.get_or_create(space=self.request.space, name=_('Favorite'))[0])
+
+        if 'categories' in recipe_json:
+            try:
+                for x in recipe_json['categories']:
+                    recipe.keywords.add(Keyword.objects.get_or_create(space=self.request.space, name=x)[0])
+            except Exception:
+                pass
+
+        instruction = ''
+        if 'text' in recipe_json:
+            instruction += f'*{recipe_json["text"].strip()}*  \n'
+
+        if 'instructions' in recipe_json:
+            instruction += recipe_json["instructions"].strip() + '  \n'
+
+        if 'notes' in recipe_json:
+            instruction += recipe_json["notes"].strip() + '  \n'
+
+        if 'link' in recipe_json:
+            recipe.source_url = recipe_json['link']
+
+        step = Step.objects.create(
+            instruction=instruction, space=self.request.space,
+        )
+
+        ingredient_parser = IngredientParser(self.request, True)
+        for ingredient in recipe_json['ingredients'].split('\n'):
+            if ingredient.strip() != '':
+                amount, unit, food, note = ingredient_parser.parse(ingredient)
+                f = ingredient_parser.get_food(food)
+                u = ingredient_parser.get_unit(unit)
+                step.ingredients.add(Ingredient.objects.create(
+                    food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
+                ))
+        recipe.steps.add(step)
+
+        if recipe_json.get("images", None):
+            try:
+                self.import_recipe_image(recipe, BytesIO(base64.b64decode(recipe_json['images'][0])), filetype='.jpeg')
+            except Exception:
+                pass
+
+        return recipe
+
+    def get_file_from_recipe(self, recipe):
+        raise NotImplementedError('Method not implemented in storage integration')

cookbook/integration/nextcloud_cookbook.py

@@ -7,7 +7,7 @@ from cookbook.helper.image_processing import get_filetype
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.helper.recipe_url_import import iso_duration_to_minutes
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient, Keyword
+from cookbook.models import Ingredient, Keyword, Recipe, Step
 
 
 class NextcloudCookbook(Integration):
@@ -31,6 +31,9 @@ class NextcloudCookbook(Integration):
         except Exception:
             pass
 
+        if 'url' in recipe_json:
+            recipe.source_url = recipe_json['url'].strip()
+
         if 'recipeCategory' in recipe_json:
             try:
                 recipe.keywords.add(Keyword.objects.get_or_create(space=self.request.space, name=recipe_json['recipeCategory'])[0])
@@ -40,7 +43,8 @@ class NextcloudCookbook(Integration):
         if 'keywords' in recipe_json:
             try:
                 for x in recipe_json['keywords'].split(','):
-                    recipe.keywords.add(Keyword.objects.get_or_create(space=self.request.space, name=x)[0])
+                    if x.strip() != '':
+                        recipe.keywords.add(Keyword.objects.get_or_create(space=self.request.space, name=x)[0])
             except Exception:
                 pass
 
@@ -57,11 +61,11 @@ class NextcloudCookbook(Integration):
 
                 ingredient_parser = IngredientParser(self.request, True)
                 for ingredient in recipe_json['recipeIngredient']:
-                    amount, unit, ingredient, note = ingredient_parser.parse(ingredient)
-                    f = ingredient_parser.get_food(ingredient)
+                    amount, unit, food, note = ingredient_parser.parse(ingredient)
+                    f = ingredient_parser.get_food(food)
                     u = ingredient_parser.get_unit(unit)
                     step.ingredients.add(Ingredient.objects.create(
-                        food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                        food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
                     ))
             recipe.steps.add(step)
 

cookbook/integration/openeats.py

@@ -2,7 +2,7 @@ import json
 
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient
+from cookbook.models import Ingredient, Recipe, Step
 
 
 class OpenEats(Integration):

cookbook/integration/paprika.py

@@ -2,12 +2,13 @@ import base64
 import gzip
 import json
 import re
+from gettext import gettext as _
 from io import BytesIO
 
 from cookbook.helper.ingredient_parser import IngredientParser
+from cookbook.helper.recipe_url_import import parse_servings, parse_servings_text
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient, Keyword
-from gettext import gettext as _
+from cookbook.models import Ingredient, Keyword, Recipe, Step
 
 
 class Paprika(Integration):
@@ -26,10 +27,9 @@ class Paprika(Integration):
                 recipe.description = '' if len(recipe_json['description'].strip()) > 500 else recipe_json['description'].strip()
 
             try:
-                if re.match(r'([0-9])+\s(.)*', recipe_json['servings']):
-                    s = recipe_json['servings'].split(' ')
-                    recipe.servings = s[0]
-                    recipe.servings_text = s[1]
+                if 'servings' in recipe_json:
+                    recipe.servings = parse_servings(recipe_json['servings'])
+                    recipe.servings_text = parse_servings_text(recipe_json['servings'])
 
                 if len(recipe_json['cook_time'].strip()) > 0:
                     recipe.waiting_time = re.findall(r'\d+', recipe_json['cook_time'])[0]
@@ -70,11 +70,11 @@ class Paprika(Integration):
             try:
                 for ingredient in recipe_json['ingredients'].split('\n'):
                     if len(ingredient.strip()) > 0:
-                        amount, unit, ingredient, note = ingredient_parser.parse(ingredient)
-                        f = ingredient_parser.get_food(ingredient)
+                        amount, unit, food, note = ingredient_parser.parse(ingredient)
+                        f = ingredient_parser.get_food(food)
                         u = ingredient_parser.get_unit(unit)
                         step.ingredients.add(Ingredient.objects.create(
-                            food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                            food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
                         ))
             except AttributeError:
                 pass

cookbook/integration/pepperplate.py

@@ -1,6 +1,6 @@
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient
+from cookbook.models import Ingredient, Recipe, Step
 
 
 class Pepperplate(Integration):
@@ -41,11 +41,11 @@ class Pepperplate(Integration):
         ingredient_parser = IngredientParser(self.request, True)
         for ingredient in ingredients:
             if len(ingredient.strip()) > 0:
-                amount, unit, ingredient, note = ingredient_parser.parse(ingredient)
-                f = ingredient_parser.get_food(ingredient)
+                amount, unit, food, note = ingredient_parser.parse(ingredient)
+                f = ingredient_parser.get_food(food)
                 u = ingredient_parser.get_unit(unit)
                 step.ingredients.add(Ingredient.objects.create(
-                    food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                    food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
                 ))
         recipe.steps.add(step)
 

cookbook/integration/plantoeat.py

@@ -4,7 +4,7 @@ import requests
 
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient, Keyword
+from cookbook.models import Ingredient, Keyword, Recipe, Step
 
 
 class Plantoeat(Integration):
@@ -49,6 +49,7 @@ class Plantoeat(Integration):
         )
 
         if tags:
+            tags = tags.replace('^',',')
             for k in tags.split(','):
                 keyword, created = Keyword.objects.get_or_create(name=k.strip(), space=self.request.space)
                 recipe.keywords.add(keyword)
@@ -56,11 +57,11 @@ class Plantoeat(Integration):
         ingredient_parser = IngredientParser(self.request, True)
         for ingredient in ingredients:
             if len(ingredient.strip()) > 0:
-                amount, unit, ingredient, note = ingredient_parser.parse(ingredient)
-                f = ingredient_parser.get_food(ingredient)
+                amount, unit, food, note = ingredient_parser.parse(ingredient)
+                f = ingredient_parser.get_food(food)
                 u = ingredient_parser.get_unit(unit)
                 step.ingredients.add(Ingredient.objects.create(
-                    food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                    food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
                 ))
         recipe.steps.add(step)
 
@@ -78,7 +79,11 @@ class Plantoeat(Integration):
         current_recipe = ''
 
         for fl in file.readlines():
-            line = fl.decode("windows-1250")
+            try:
+                line = fl.decode("utf-8")
+            except UnicodeDecodeError:
+                line = fl.decode("windows-1250")
+
             if line.startswith('--------------'):
                 if current_recipe != '':
                     recipe_list.append(current_recipe)

cookbook/integration/recettetek.py

@@ -1,14 +1,17 @@
-import re
+import imghdr
 import json
-import requests
+import re
 from io import BytesIO
 from zipfile import ZipFile
-import imghdr
 
+import requests
+import validators
+
+from django.utils.translation import gettext as _
 from cookbook.helper.image_processing import get_filetype
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient, Keyword
+from cookbook.models import Ingredient, Keyword, Recipe, Step
 
 
 class RecetteTek(Integration):
@@ -48,7 +51,7 @@ class RecetteTek(Integration):
         # Append the original import url to the step (if it exists)
         try:
             if file['url'] != '':
-                step.instruction += '\n\nImported from: ' + file['url']
+                step.instruction += '\n\n' + _('Imported from') + ': ' + file['url']
                 step.save()
         except Exception as e:
             print(recipe.name, ': failed to import source url ', str(e))
@@ -58,11 +61,11 @@ class RecetteTek(Integration):
             ingredient_parser = IngredientParser(self.request, True)
             for ingredient in file['ingredients'].split('\n'):
                 if len(ingredient.strip()) > 0:
-                    amount, unit, ingredient, note = ingredient_parser.parse(ingredient)
+                    amount, unit, food, note = ingredient_parser.parse(food)
                     f = ingredient_parser.get_food(ingredient)
                     u = ingredient_parser.get_unit(unit)
                     step.ingredients.add(Ingredient.objects.create(
-                        food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                        food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
                     ))
         except Exception as e:
             print(recipe.name, ': failed to parse recipe ingredients ', str(e))
@@ -121,11 +124,13 @@ class RecetteTek(Integration):
                         self.import_recipe_image(recipe, BytesIO(import_zip.read(image_file_name)), filetype=get_filetype(image_file_name))
             else:
                 if file['originalPicture'] != '':
-                    response = requests.get(file['originalPicture'])
-                    if imghdr.what(BytesIO(response.content)) is not None:
-                        self.import_recipe_image(recipe, BytesIO(response.content), filetype=get_filetype(file['originalPicture']))
-                    else:
-                        raise Exception("Original image failed to download.")
+                    url = file['originalPicture']
+                    if validators.url(url, public=True):
+                        response = requests.get(url)
+                        if imghdr.what(BytesIO(response.content)) is not None:
+                            self.import_recipe_image(recipe, BytesIO(response.content), filetype=get_filetype(file['originalPicture']))
+                        else:
+                            raise Exception("Original image failed to download.")
         except Exception as e:
             print(recipe.name, ': failed to import image ', str(e))
 

cookbook/integration/recipekeeper.py

@@ -1,12 +1,14 @@
 import re
-from bs4 import BeautifulSoup
 from io import BytesIO
 from zipfile import ZipFile
 
+from bs4 import BeautifulSoup
+
+from django.utils.translation import gettext as _
 from cookbook.helper.ingredient_parser import IngredientParser
-from cookbook.helper.recipe_url_import import parse_servings, iso_duration_to_minutes
+from cookbook.helper.recipe_url_import import iso_duration_to_minutes, parse_servings
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient, Keyword
+from cookbook.models import Ingredient, Keyword, Recipe, Step
 
 
 class RecipeKeeper(Integration):
@@ -45,11 +47,11 @@ class RecipeKeeper(Integration):
         for ingredient in file.find("div", {"itemprop": "recipeIngredients"}).findChildren("p"):
             if ingredient.text == "":
                 continue
-            amount, unit, ingredient, note = ingredient_parser.parse(ingredient.text.strip())
-            f = ingredient_parser.get_food(ingredient)
+            amount, unit, food, note = ingredient_parser.parse(ingredient.text.strip())
+            f = ingredient_parser.get_food(food)
             u = ingredient_parser.get_unit(unit)
             step.ingredients.add(Ingredient.objects.create(
-                food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
             ))
 
         for s in file.find("div", {"itemprop": "recipeDirections"}).find_all("p"):
@@ -58,7 +60,7 @@ class RecipeKeeper(Integration):
             step.instruction += s.text + ' \n'
 
         if file.find("span", {"itemprop": "recipeSource"}).text != '':
-            step.instruction += "\n\nImported from: " + file.find("span", {"itemprop": "recipeSource"}).text
+            step.instruction += "\n\n" + _("Imported from") + ": " + file.find("span", {"itemprop": "recipeSource"}).text
             step.save()
 
         recipe.steps.add(step)

cookbook/integration/recipesage.py

@@ -2,10 +2,11 @@ import json
 from io import BytesIO
 
 import requests
+import validators
 
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient
+from cookbook.models import Ingredient, Recipe, Step
 
 
 class RecipeSage(Integration):
@@ -31,7 +32,7 @@ class RecipeSage(Integration):
         except Exception as e:
             print('failed to parse yield or time ', str(e))
 
-        ingredient_parser = IngredientParser(self.request,True)
+        ingredient_parser = IngredientParser(self.request, True)
         ingredients_added = False
         for s in file['recipeInstructions']:
             step = Step.objects.create(
@@ -41,18 +42,20 @@ class RecipeSage(Integration):
                 ingredients_added = True
 
                 for ingredient in file['recipeIngredient']:
-                    amount, unit, ingredient, note = ingredient_parser.parse(ingredient)
-                    f = ingredient_parser.get_food(ingredient)
+                    amount, unit, food, note = ingredient_parser.parse(ingredient)
+                    f = ingredient_parser.get_food(food)
                     u = ingredient_parser.get_unit(unit)
                     step.ingredients.add(Ingredient.objects.create(
-                        food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                        food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
                     ))
             recipe.steps.add(step)
 
         if len(file['image']) > 0:
             try:
-                response = requests.get(file['image'][0])
-                self.import_recipe_image(recipe, BytesIO(response.content))
+                url = file['image'][0]
+                if validators.url(url, public=True):
+                    response = requests.get(url)
+                    self.import_recipe_image(recipe, BytesIO(response.content))
             except Exception as e:
                 print('failed to import image ', str(e))
 
@@ -77,14 +80,13 @@ class RecipeSage(Integration):
         }
 
         for s in recipe.steps.all():
-            if s.type != Step.TIME:
-                data['recipeInstructions'].append({
-                    '@type': 'HowToStep',
-                    'text': s.instruction
-                })
+            data['recipeInstructions'].append({
+                '@type': 'HowToStep',
+                'text': s.instruction
+            })
 
-                for i in s.ingredients.all():
-                    data['recipeIngredient'].append(f'{float(i.amount)} {i.unit} {i.food}')
+            for i in s.ingredients.all():
+                data['recipeIngredient'].append(f'{float(i.amount)} {i.unit} {i.food}')
 
         return data
 

cookbook/integration/rezkonv.py

@@ -1,6 +1,6 @@
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient, Keyword
+from cookbook.models import Ingredient, Keyword, Recipe, Step
 
 
 class RezKonv(Integration):
@@ -12,43 +12,43 @@ class RezKonv(Integration):
 
         ingredients = []
         directions = []
-        for line in file.replace('\r', '').split('\n'):
+        for line in file.replace('\r', '').replace('\n\n', '\n').split('\n'):
             if 'Titel:' in line:
                 title = line.replace('Titel:', '').strip()
             if 'Kategorien:' in line:
                 tags = line.replace('Kategorien:', '').strip()
-            if ingredient_mode and ('quelle' in line.lower() or 'source' in line.lower()):
+            if ingredient_mode and (
+                    'quelle' in line.lower() or 'source' in line.lower() or (line == '' and len(ingredients) > 0)):
                 ingredient_mode = False
+                direction_mode = True
             if ingredient_mode:
                 if line != '' and '===' not in line and 'Zubereitung' not in line:
                     ingredients.append(line.strip())
             if direction_mode:
                 if line.strip() != '' and line.strip() != '=====':
                     directions.append(line.strip())
-            if 'Zutaten:' in line:
+            if 'Zutaten:' in line or 'Ingredients' in line or 'Menge:' in line:
                 ingredient_mode = True
-            if 'Zubereitung:' in line:
-                ingredient_mode = False
-                direction_mode = True
 
-        recipe = Recipe.objects.create(name=title, created_by=self.request.user, internal=True, space=self.request.space)
+        recipe = Recipe.objects.create(name=title, created_by=self.request.user, internal=True,
+                                       space=self.request.space)
 
         for k in tags.split(','):
             keyword, created = Keyword.objects.get_or_create(name=k.strip(), space=self.request.space)
             recipe.keywords.add(keyword)
 
         step = Step.objects.create(
-            instruction='\n'.join(directions) + '\n\n', space=self.request.space,
+            instruction='  \n'.join(directions) + '\n\n', space=self.request.space,
         )
 
         ingredient_parser = IngredientParser(self.request, True)
         for ingredient in ingredients:
             if len(ingredient.strip()) > 0:
-                amount, unit, ingredient, note = ingredient_parser.parse(ingredient)
-                f = ingredient_parser.get_food(ingredient)
+                amount, unit, food, note = ingredient_parser.parse(ingredient)
+                f = ingredient_parser.get_food(food)
                 u = ingredient_parser.get_unit(unit)
                 step.ingredients.add(Ingredient.objects.create(
-                    food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                    food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
                 ))
         recipe.steps.add(step)
 
@@ -60,9 +60,15 @@ class RezKonv(Integration):
     def split_recipe_file(self, file):
         recipe_list = []
         current_recipe = ''
-
+        encoding_list = ['windows-1250',
+                         'latin-1']  # TODO build algorithm to try trough encodings and fail if none work, use for all importers
+        encoding = 'windows-1250'
         for fl in file.readlines():
-            line = fl.decode("windows-1250")
+            try:
+                line = fl.decode(encoding)
+            except UnicodeDecodeError:
+                encoding = 'latin-1'
+                line = fl.decode(encoding)
             if line.startswith('=====') and 'rezkonv' in line.lower():
                 if current_recipe != '':
                     recipe_list.append(current_recipe)

cookbook/integration/saffron.py

@@ -2,7 +2,7 @@ from django.utils.translation import gettext as _
 
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
-from cookbook.models import Recipe, Step, Ingredient
+from cookbook.models import Ingredient, Recipe, Step
 
 
 class Saffron(Integration):
@@ -47,11 +47,11 @@ class Saffron(Integration):
 
         ingredient_parser = IngredientParser(self.request, True)
         for ingredient in ingredients:
-            amount, unit, ingredient, note = ingredient_parser.parse(ingredient)
-            f = ingredient_parser.get_food(ingredient)
+            amount, unit, food, note = ingredient_parser.parse(ingredient)
+            f = ingredient_parser.get_food(food)
             u = ingredient_parser.get_unit(unit)
             step.ingredients.add(Ingredient.objects.create(
-                food=f, unit=u, amount=amount, note=note, space=self.request.space,
+                food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space,
             ))
         recipe.steps.add(step)
 
@@ -71,12 +71,11 @@ class Saffron(Integration):
         recipeInstructions = []
         recipeIngredient = []
         for s in recipe.steps.all():
-            if s.type != Step.TIME:
-                recipeInstructions.append(s.instruction)
+            recipeInstructions.append(s.instruction)
+
+            for i in s.ingredients.all():
+                recipeIngredient.append(f'{float(i.amount)} {i.unit} {i.food}')
 
-                for i in s.ingredients.all():
-                    recipeIngredient.append(f'{float(i.amount)} {i.unit} {i.food}')
-       
         data += "Ingredients: \n"
         for ingredient in recipeIngredient:
             data += ingredient+"\n"
@@ -91,10 +90,10 @@ class Saffron(Integration):
         files = []
         for r in recipes:
             filename, data = self.get_file_from_recipe(r)
-            files.append([ filename, data ])
+            files.append([filename, data])
 
             el.exported_recipes += 1
             el.msg += self.get_recipe_processed_msg(r)
             el.save()
-            
-        return files
+
+        return files

cookbook/locale/fi/LC_MESSAGES/django.po

@@ -8,8 +8,8 @@ msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2021-11-04 12:31+0100\n"
-"PO-Revision-Date: 2021-11-06 14:06+0000\n"
-"Last-Translator: Nicklas Yli-Länttä <admin@timanttikuutio.eu>\n"
+"PO-Revision-Date: 2022-03-18 16:31+0000\n"
+"Last-Translator: Stefan Werner <werner@iki.fi>\n"
 "Language-Team: Finnish <http://translate.tandoor.dev/projects/tandoor/"
 "recipes-backend/fi/>\n"
 "Language: fi\n"
@@ -17,7 +17,7 @@ msgstr ""
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=n != 1;\n"
-"X-Generator: Weblate 4.8\n"
+"X-Generator: Weblate 4.10.1\n"
 
 #: .\cookbook\filters.py:23 .\cookbook\templates\base.html:125
 #: .\cookbook\templates\forms\ingredients.html:34
@@ -31,10 +31,12 @@ msgid ""
 "Color of the top navigation bar. Not all colors work with all themes, just "
 "try them out!"
 msgstr ""
+"Ylänavigointipalkin väri. Ei kaikki värit toimi kaikkien teemojen kanssa; "
+"kokeile!"
 
 #: .\cookbook\forms.py:55
 msgid "Default Unit to be used when inserting a new ingredient into a recipe."
-msgstr ""
+msgstr "Oletusmittayksikkö uuden aineksen lisäämisessä."
 
 #: .\cookbook\forms.py:57
 msgid ""
@@ -2435,7 +2437,7 @@ msgid ""
 msgstr ""
 
 #: .\cookbook\views\new.py:225
-msgid "Email to user could not be send, please share link manually."
+msgid "Email could not be sent to user. Please share the link manually."
 msgstr ""
 
 #: .\cookbook\views\views.py:127

cookbook/locale/ro/LC_MESSAGES/django.po

@@ -2493,7 +2493,7 @@ msgid ""
 msgstr ""
 
 #: .\cookbook\views\new.py:229
-msgid "Email to user could not be send, please share link manually."
+msgid "Email could not be sent to user. Please share the link manually."
 msgstr ""
 
 #: .\cookbook\views\views.py:127

cookbook/locale/ru/LC_MESSAGES/django.po

@@ -8,8 +8,8 @@ msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2021-09-13 22:40+0200\n"
-"PO-Revision-Date: 2021-10-23 09:06+0000\n"
-"Last-Translator: rustam <uzbekr@gmail.com>\n"
+"PO-Revision-Date: 2022-04-07 19:32+0000\n"
+"Last-Translator: Artem Aksenov <artemmillerr@gmail.com>\n"
 "Language-Team: Russian <http://translate.tandoor.dev/projects/tandoor/"
 "recipes-backend/ru/>\n"
 "Language: ru\n"
@@ -18,14 +18,14 @@ msgstr ""
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
 "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n"
-"X-Generator: Weblate 4.8\n"
+"X-Generator: Weblate 4.10.1\n"
 
 #: .\cookbook\filters.py:23 .\cookbook\templates\base.html:125
 #: .\cookbook\templates\forms\ingredients.html:34
 #: .\cookbook\templates\space.html:43 .\cookbook\templates\stats.html:28
 #: .\cookbook\templates\url_import.html:270
 msgid "Ingredients"
-msgstr "ингредиенты"
+msgstr "Ингредиенты"
 
 #: .\cookbook\forms.py:50
 msgid ""
@@ -95,14 +95,14 @@ msgstr ""
 #: .\cookbook\forms.py:103 .\cookbook\forms.py:334
 #: .\cookbook\templates\url_import.html:154
 msgid "Name"
-msgstr "Имя"
+msgstr "Название"
 
 #: .\cookbook\forms.py:104 .\cookbook\forms.py:335
 #: .\cookbook\templates\space.html:39 .\cookbook\templates\stats.html:24
 #: .\cookbook\templates\url_import.html:188
 #: .\cookbook\templates\url_import.html:573 .\cookbook\views\lists.py:112
 msgid "Keywords"
-msgstr "Ключевые поля"
+msgstr "Ключевые слова"
 
 #: .\cookbook\forms.py:105
 msgid "Preparation time in minutes"
@@ -2501,7 +2501,7 @@ msgid ""
 msgstr ""
 
 #: .\cookbook\views\new.py:245
-msgid "Email to user could not be send, please share link manually."
+msgid "Email could not be sent to user. Please share the link manually."
 msgstr ""
 
 #: .\cookbook\views\views.py:128

cookbook/locale/sl/LC_MESSAGES/django.po

@@ -2530,7 +2530,7 @@ msgid ""
 msgstr ""
 
 #: .\cookbook\views\new.py:229
-msgid "Email to user could not be send, please share link manually."
+msgid "Email could not be sent to user. Please share the link manually."
 msgstr ""
 
 #: .\cookbook\views\views.py:127

cookbook/locale/zh_Hant/LC_MESSAGES/django.po

@@ -2254,7 +2254,7 @@ msgid ""
 msgstr ""
 
 #: .\cookbook\views\new.py:246
-msgid "Email to user could not be send, please share link manually."
+msgid "Email could not be sent to user. Please share the link manually."
 msgstr ""
 
 #: .\cookbook\views\views.py:125

cookbook/managers.py

@@ -1,7 +1,5 @@
 from django.contrib.postgres.aggregates import StringAgg
-from django.contrib.postgres.search import (
-    SearchQuery, SearchRank, SearchVector,
-)
+from django.contrib.postgres.search import SearchQuery, SearchRank, SearchVector
 from django.db import models
 from django.db.models import Q
 from django.utils import translation
@@ -18,6 +16,7 @@ DICTIONARY = {
     'it': 'italian',
     # 'lv': 'Latvian',
     'es': 'spanish',
+    'sv': 'swedish',
 }
 
 

cookbook/migrations/0169_exportlog.py

@@ -1,9 +1,10 @@
 # Generated by Django 3.2.11 on 2022-02-03 15:03
 
-import cookbook.models
+import django.db.models.deletion
 from django.conf import settings
 from django.db import migrations, models
-import django.db.models.deletion
+
+import cookbook.models
 
 
 class Migration(migrations.Migration):

cookbook/migrations/0170_auto_20220207_1848.py

@@ -0,0 +1,66 @@
+# Generated by Django 3.2.11 on 2022-02-07 17:48
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+import cookbook.models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('cookbook', '0169_exportlog'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='food',
+            name='child_inherit_fields',
+            field=models.ManyToManyField(blank=True, related_name='child_inherit', to='cookbook.FoodInheritField'),
+        ),
+        migrations.AddField(
+            model_name='food',
+            name='substitute',
+            field=models.ManyToManyField(blank=True, related_name='_cookbook_food_substitute_+', to='cookbook.Food'),
+        ),
+        migrations.AddField(
+            model_name='food',
+            name='substitute_children',
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name='food',
+            name='substitute_siblings',
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AlterField(
+            model_name='ingredient',
+            name='unit',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='cookbook.unit'),
+        ),
+        migrations.CreateModel(
+            name='CustomFilter',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=128)),
+                ('type', models.CharField(choices=[('RECIPE', 'Recipe'), ('FOOD', 'Food'), ('KEYWORD', 'Keyword')], default=('RECIPE', 'Recipe'), max_length=128)),
+                ('search', models.TextField()),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('created_by', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+                ('shared', models.ManyToManyField(blank=True, related_name='f_shared_with', to=settings.AUTH_USER_MODEL)),
+                ('space', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='cookbook.space')),
+            ],
+            bases=(models.Model, cookbook.models.PermissionModelMixin),
+        ),
+        migrations.AddField(
+            model_name='recipebook',
+            name='filter',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='cookbook.customfilter'),
+        ),
+        migrations.AddConstraint(
+            model_name='customfilter',
+            constraint=models.UniqueConstraint(fields=('space', 'name'), name='cf_unique_name_per_space'),
+        ),
+    ]

cookbook/migrations/0171_alter_searchpreference_trigram_threshold.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.2.12 on 2022-02-15 00:08
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cookbook', '0170_auto_20220207_1848'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='searchpreference',
+            name='trigram_threshold',
+            field=models.DecimalField(decimal_places=2, default=0.2, max_digits=3),
+        ),
+    ]

cookbook/migrations/0172_ingredient_original_text.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.2.12 on 2022-02-25 15:19
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cookbook', '0171_alter_searchpreference_trigram_threshold'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='ingredient',
+            name='original_text',
+            field=models.CharField(blank=True, default=None, max_length=512, null=True),
+        ),
+    ]

cookbook/migrations/0173_recipe_source_url.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.2.12 on 2022-03-04 13:39
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cookbook', '0172_ingredient_original_text'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='recipe',
+            name='source_url',
+            field=models.CharField(blank=True, default=None, max_length=1024, null=True),
+        ),
+    ]

cookbook/models.py

@@ -62,9 +62,10 @@ class TreeManager(MP_NodeManager):
     # model.Manager get_or_create() is not compatible with MP_Tree
     def get_or_create(self, *args, **kwargs):
         kwargs['name'] = kwargs['name'].strip()
-        try:
-            return self.get(name__exact=kwargs['name'], space=kwargs['space']), False
-        except self.model.DoesNotExist:
+
+        if obj := self.filter(name__iexact=kwargs['name'], space=kwargs['space']).first():
+            return obj, False
+        else:
             with scopes_disabled():
                 try:
                     defaults = kwargs.pop('defaults', None)
@@ -97,13 +98,6 @@ class TreeModel(MP_Node):
         else:
             return f"{self.name}"
 
-    # MP_Tree move uses raw SQL to execute move, override behavior to force a save triggering post_save signal
-    def move(self, *args, **kwargs):
-        super().move(*args, **kwargs)
-        # treebeard bypasses ORM, need to retrieve the object again to avoid writing previous state back to disk
-        obj = self.__class__.objects.get(id=self.id)
-        obj.save()
-
     @property
     def parent(self):
         parent = self.get_parent()
@@ -247,7 +241,7 @@ class Space(ExportModelOperationsMixin('space'), models.Model):
     max_users = models.IntegerField(default=0)
     allow_sharing = models.BooleanField(default=True)
     demo = models.BooleanField(default=False)
-    food_inherit = models.ManyToManyField(FoodInheritField,  blank=True)
+    food_inherit = models.ManyToManyField(FoodInheritField, blank=True)
     show_facet_count = models.BooleanField(default=False)
 
     def __str__(self):
@@ -343,7 +337,7 @@ class UserPreference(models.Model, PermissionModelMixin):
     default_delay = models.DecimalField(default=4, max_digits=8, decimal_places=4)
     shopping_recent_days = models.PositiveIntegerField(default=7)
     csv_delim = models.CharField(max_length=2, default=",")
-    csv_prefix = models.CharField(max_length=10, blank=True,)
+    csv_prefix = models.CharField(max_length=10, blank=True, )
 
     created_at = models.DateTimeField(auto_now_add=True)
     space = models.ForeignKey(Space, on_delete=models.CASCADE, null=True)
@@ -488,8 +482,10 @@ class Unit(ExportModelOperationsMixin('unit'), models.Model, PermissionModelMixi
 
 
 class Food(ExportModelOperationsMixin('food'), TreeModel, PermissionModelMixin):
+    # TODO when savings a food as substitute children - assume children and descednants are also substitutes for siblings
     # exclude fields not implemented yet
-    inheritable_fields = FoodInheritField.objects.exclude(field__in=['diet', 'substitute', 'substitute_children', 'substitute_siblings'])
+    inheritable_fields = FoodInheritField.objects.exclude(field__in=['diet', 'substitute', ])
+    # TODO add inherit children_inherit, parent_inherit, Do Not Inherit
 
     # WARNING: Food inheritance relies on post_save signals, avoid using UPDATE to update Food objects unless you intend to bypass those signals
     if SORT_TREE_BY_NAME:
@@ -500,7 +496,11 @@ class Food(ExportModelOperationsMixin('food'), TreeModel, PermissionModelMixin):
     ignore_shopping = models.BooleanField(default=False)  # inherited field
     onhand_users = models.ManyToManyField(User, blank=True)
     description = models.TextField(default='', blank=True)
-    inherit_fields = models.ManyToManyField(FoodInheritField,  blank=True)
+    inherit_fields = models.ManyToManyField(FoodInheritField, blank=True)
+    substitute = models.ManyToManyField("self", blank=True)
+    substitute_siblings = models.BooleanField(default=False)
+    substitute_children = models.BooleanField(default=False)
+    child_inherit_fields = models.ManyToManyField(FoodInheritField, blank=True, related_name='child_inherit')
 
     space = models.ForeignKey(Space, on_delete=models.CASCADE)
     objects = ScopedManager(space='space', _manager_class=TreeManager)
@@ -514,34 +514,63 @@ class Food(ExportModelOperationsMixin('food'), TreeModel, PermissionModelMixin):
         else:
             return super().delete()
 
+    # MP_Tree move uses raw SQL to execute move, override behavior to force a save triggering post_save signal
+
+    def move(self, *args, **kwargs):
+        super().move(*args, **kwargs)
+        # treebeard bypasses ORM, need to explicity save to trigger post save signals retrieve the object again to avoid writing previous state back to disk
+        obj = self.__class__.objects.get(id=self.id)
+        if parent := obj.get_parent():
+            # child should inherit what the parent defines it should inherit
+            fields = list(parent.child_inherit_fields.all() or parent.inherit_fields.all())
+            if len(fields) > 0:
+                obj.inherit_fields.set(fields)
+        obj.save()
+
     @staticmethod
-    def reset_inheritance(space=None):
+    def reset_inheritance(space=None, food=None):
         # resets inherited fields to the space defaults and updates all inherited fields to root object values
-        inherit = space.food_inherit.all()
+        if food:
+            # if child inherit fields is preset children should be set to that, otherwise inherit this foods inherited fields
+            inherit = list((food.child_inherit_fields.all() or food.inherit_fields.all()).values('id', 'field'))
+            tree_filter = Q(path__startswith=food.path, space=space, depth=food.depth + 1)
+        else:
+            inherit = list(space.food_inherit.all().values('id', 'field'))
+            tree_filter = Q(space=space)
 
         # remove all inherited fields from food
-        Through = Food.objects.filter(space=space).first().inherit_fields.through
+        Through = Food.objects.filter(tree_filter).first().inherit_fields.through
         Through.objects.all().delete()
         # food is going to inherit attributes
-        if space.food_inherit.all().count() > 0:
+        if len(inherit) > 0:
             # ManyToMany cannot be updated through an UPDATE operation
             for i in inherit:
                 Through.objects.bulk_create([
-                    Through(food_id=x, foodinheritfield_id=i.id)
-                    for x in Food.objects.filter(space=space).values_list('id', flat=True)
+                    Through(food_id=x, foodinheritfield_id=i['id'])
+                    for x in Food.objects.filter(tree_filter).values_list('id', flat=True)
                 ])
 
-            inherit = inherit.values_list('field', flat=True)
-            if 'ignore_shopping' in inherit:
-                # get food at root that have children that need updated
-                Food.include_descendants(queryset=Food.objects.filter(depth=1, numchild__gt=0, space=space, ignore_shopping=True)).update(ignore_shopping=True)
-                Food.include_descendants(queryset=Food.objects.filter(depth=1, numchild__gt=0, space=space, ignore_shopping=False)).update(ignore_shopping=False)
+            inherit = [x['field'] for x in inherit]
+            for field in ['ignore_shopping', 'substitute_children', 'substitute_siblings']:
+                if field in inherit:
+                    if food and getattr(food, field, None):
+                        food.get_descendants().update(**{f"{field}": True})
+                    elif food and not getattr(food, field, True):
+                        food.get_descendants().update(**{f"{field}": False})
+                    else:
+                        # get food at root that have children that need updated
+                        Food.include_descendants(queryset=Food.objects.filter(depth=1, numchild__gt=0, **{f"{field}": True}, space=space)).update(**{f"{field}": True})
+                        Food.include_descendants(queryset=Food.objects.filter(depth=1, numchild__gt=0, **{f"{field}": False}, space=space)).update(**{f"{field}": False})
+
             if 'supermarket_category' in inherit:
                 # when supermarket_category is null or blank assuming it is not set and not intended to be blank for all descedants
-                # find top node that has category set
-                category_roots = Food.exclude_descendants(queryset=Food.objects.filter(supermarket_category__isnull=False, numchild__gt=0, space=space))
-                for root in category_roots:
-                    root.get_descendants().update(supermarket_category=root.supermarket_category)
+                if food and food.supermarket_category:
+                    food.get_descendants().update(supermarket_category=food.supermarket_category)
+                elif food is None:
+                    # find top node that has category set
+                    category_roots = Food.exclude_descendants(queryset=Food.objects.filter(supermarket_category__isnull=False, numchild__gt=0, space=space))
+                    for root in category_roots:
+                        root.get_descendants().update(supermarket_category=root.supermarket_category)
 
     class Meta:
         constraints = [
@@ -554,14 +583,17 @@ class Food(ExportModelOperationsMixin('food'), TreeModel, PermissionModelMixin):
 
 
 class Ingredient(ExportModelOperationsMixin('ingredient'), models.Model, PermissionModelMixin):
-    # a pre-delete signal on Food checks if the Ingredient is part of a Step, if it is raises a ProtectedError instead of cascading the delete
+    # delete method on Food and Unit checks if they are part of a Recipe, if it is raises a ProtectedError instead of cascading the delete
     food = models.ForeignKey(Food, on_delete=models.CASCADE, null=True, blank=True)
-    unit = models.ForeignKey(Unit, on_delete=models.PROTECT, null=True, blank=True)
+    unit = models.ForeignKey(Unit, on_delete=models.SET_NULL, null=True, blank=True)
     amount = models.DecimalField(default=0, decimal_places=16, max_digits=32)
     note = models.CharField(max_length=256, null=True, blank=True)
     is_header = models.BooleanField(default=False)
     no_amount = models.BooleanField(default=False)
     order = models.IntegerField(default=0)
+    original_text = models.CharField(max_length=512, null=True, blank=True, default=None)
+
+    original_text = models.CharField(max_length=512, null=True, blank=True, default=None)
 
     space = models.ForeignKey(Space, on_delete=models.CASCADE)
     objects = ScopedManager(space='space')
@@ -633,9 +665,7 @@ class Recipe(ExportModelOperationsMixin('recipe'), models.Model, PermissionModel
     servings = models.IntegerField(default=1)
     servings_text = models.CharField(default='', blank=True, max_length=32)
     image = models.ImageField(upload_to='recipes/', blank=True, null=True)
-    storage = models.ForeignKey(
-        Storage, on_delete=models.PROTECT, blank=True, null=True
-    )
+    storage = models.ForeignKey(Storage, on_delete=models.PROTECT, blank=True, null=True)
     file_uid = models.CharField(max_length=256, default="", blank=True)
     file_path = models.CharField(max_length=512, default="", blank=True)
     link = models.CharField(max_length=512, null=True, blank=True)
@@ -645,9 +675,9 @@ class Recipe(ExportModelOperationsMixin('recipe'), models.Model, PermissionModel
     working_time = models.IntegerField(default=0)
     waiting_time = models.IntegerField(default=0)
     internal = models.BooleanField(default=False)
-    nutrition = models.ForeignKey(
-        NutritionInformation, blank=True, null=True, on_delete=models.CASCADE
-    )
+    nutrition = models.ForeignKey(NutritionInformation, blank=True, null=True, on_delete=models.CASCADE)
+
+    source_url = models.CharField(max_length=1024, default=None, blank=True, null=True)
     created_by = models.ForeignKey(User, on_delete=models.PROTECT)
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
@@ -725,6 +755,7 @@ class RecipeBook(ExportModelOperationsMixin('book'), models.Model, PermissionMod
     icon = models.CharField(max_length=16, blank=True, null=True)
     shared = models.ManyToManyField(User, blank=True, related_name='shared_with')
     created_by = models.ForeignKey(User, on_delete=models.CASCADE)
+    filter = models.ForeignKey('cookbook.CustomFilter', null=True, blank=True, on_delete=models.SET_NULL)
 
     space = models.ForeignKey(Space, on_delete=models.CASCADE)
     objects = ScopedManager(space='space')
@@ -1002,6 +1033,7 @@ class ImportLog(models.Model, PermissionModelMixin):
     def __str__(self):
         return f"{self.created_at}:{self.type}"
 
+
 class ExportLog(models.Model, PermissionModelMixin):
     type = models.CharField(max_length=32)
     running = models.BooleanField(default=True)
@@ -1077,7 +1109,7 @@ class SearchPreference(models.Model, PermissionModelMixin):
     istartswith = models.ManyToManyField(SearchFields, related_name="istartswith_fields", blank=True)
     trigram = models.ManyToManyField(SearchFields, related_name="trigram_fields", blank=True, default=nameSearchField)
     fulltext = models.ManyToManyField(SearchFields, related_name="fulltext_fields", blank=True)
-    trigram_threshold = models.DecimalField(default=0.1, decimal_places=2, max_digits=3)
+    trigram_threshold = models.DecimalField(default=0.2, decimal_places=2, max_digits=3)
 
 
 class UserFile(ExportModelOperationsMixin('user_files'), models.Model, PermissionModelMixin):
@@ -1119,3 +1151,34 @@ class Automation(ExportModelOperationsMixin('automations'), models.Model, Permis
 
     objects = ScopedManager(space='space')
     space = models.ForeignKey(Space, on_delete=models.CASCADE)
+
+
+class CustomFilter(models.Model, PermissionModelMixin):
+    RECIPE = 'RECIPE'
+    FOOD = 'FOOD'
+    KEYWORD = 'KEYWORD'
+
+    MODELS = (
+        (RECIPE, _('Recipe')),
+        (FOOD, _('Food')),
+        (KEYWORD, _('Keyword')),
+    )
+
+    name = models.CharField(max_length=128, null=False, blank=False)
+    type = models.CharField(max_length=128, choices=(MODELS), default=MODELS[0])
+    # could use JSONField, but requires installing extension on SQLite,  don't need to search the objects, so seems unecessary
+    search = models.TextField(blank=False, null=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    created_by = models.ForeignKey(User, on_delete=models.CASCADE)
+    shared = models.ManyToManyField(User, blank=True, related_name='f_shared_with')
+
+    objects = ScopedManager(space='space')
+    space = models.ForeignKey(Space, on_delete=models.CASCADE)
+
+    def __str__(self):
+        return self.name
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(fields=['space', 'name'], name='cf_unique_name_per_space')
+        ]

cookbook/provider/dropbox.py

@@ -4,6 +4,8 @@ import os
 from datetime import datetime
 
 import requests
+import validators
+
 from cookbook.models import Recipe, RecipeImport, SyncLog
 from cookbook.provider.provider import Provider
 
@@ -104,9 +106,11 @@ class Dropbox(Provider):
             recipe.link = Dropbox.get_share_link(recipe)
             recipe.save()
 
-        response = requests.get(recipe.link.replace('www.dropbox.', 'dl.dropboxusercontent.'))
+        url = recipe.link.replace('www.dropbox.', 'dl.dropboxusercontent.')
+        if validators.url(url, public=True):
+            response = requests.get(url)
 
-        return io.BytesIO(response.content)
+            return io.BytesIO(response.content)
 
     @staticmethod
     def rename_file(recipe, new_name):

cookbook/provider/nextcloud.py

@@ -4,11 +4,14 @@ import tempfile
 from datetime import datetime
 
 import requests
+import validators
 import webdav3.client as wc
 from cookbook.models import Recipe, RecipeImport, SyncLog
 from cookbook.provider.provider import Provider
 from requests.auth import HTTPBasicAuth
 
+from recipes.settings import DEBUG
+
 
 class Nextcloud(Provider):
 
@@ -28,15 +31,18 @@ class Nextcloud(Provider):
     def import_all(monitor):
         client = Nextcloud.get_client(monitor.storage)
 
+        if DEBUG:
+            print(f'TANDOOR_PROVIDER_DEBUG checking path  {monitor.path} with client {client}')
+
         files = client.list(monitor.path)
 
-        try:
-            files.pop(0)  # remove first element because its the folder itself
-        except IndexError:
-            pass # folder is empty, no recipes will be imported
+        if DEBUG:
+            print(f'TANDOOR_PROVIDER_DEBUG file list  {files}')
 
         import_count = 0
         for file in files:
+            if DEBUG:
+                print(f'TANDOOR_PROVIDER_DEBUG importing file {file}')
             path = monitor.path + '/' + file
             if not Recipe.objects.filter(file_path__iexact=path, space=monitor.space).exists() and not RecipeImport.objects.filter(file_path=path, space=monitor.space).exists():
                 name = os.path.splitext(file)[0]
@@ -87,20 +93,21 @@ class Nextcloud(Provider):
             "Content-Type": "application/json"
         }
 
-        r = requests.get(
-            url,
-            headers=headers,
-            auth=HTTPBasicAuth(
-                recipe.storage.username, recipe.storage.password
+        if validators.url(url, public=True):
+            r = requests.get(
+                url,
+                headers=headers,
+                auth=HTTPBasicAuth(
+                    recipe.storage.username, recipe.storage.password
+                )
             )
-        )
 
-        response_json = r.json()
-        for element in response_json['ocs']['data']:
-            if element['share_type'] == '3':
-                return element['url']
+            response_json = r.json()
+            for element in response_json['ocs']['data']:
+                if element['share_type'] == '3':
+                    return element['url']
 
-        return Nextcloud.create_share_link(recipe)
+            return Nextcloud.create_share_link(recipe)
 
     @staticmethod
     def get_file(recipe):

cookbook/serializer.py

@@ -1,28 +1,28 @@
-import random
 from datetime import timedelta
 from decimal import Decimal
 from gettext import gettext as _
 
 from django.contrib.auth.models import User
-from django.db.models import Avg, QuerySet, Sum
+from django.db.models import Avg, Q, QuerySet, Sum
 from django.urls import reverse
 from django.utils import timezone
 from drf_writable_nested import UniqueFieldsMixin, WritableNestedModelSerializer
 from rest_framework import serializers
 from rest_framework.exceptions import NotFound, ValidationError
-from rest_framework.fields import empty
 
+from cookbook.helper.CustomStorageClass import CachedS3Boto3Storage
 from cookbook.helper.HelperFunctions import str2bool
+from cookbook.helper.permission_helper import above_space_limit
 from cookbook.helper.shopping_helper import RecipeShoppingEditor
-from cookbook.models import (Automation, BookmarkletImport, Comment, CookLog, Food,
-                             FoodInheritField, ImportLog, ExportLog, Ingredient, Keyword, MealPlan, MealType,
-                             NutritionInformation, Recipe, RecipeBook, RecipeBookEntry,
-                             RecipeImport, ShareLink, ShoppingList, ShoppingListEntry,
-                             ShoppingListRecipe, Step, Storage, Supermarket, SupermarketCategory,
-                             SupermarketCategoryRelation, Sync, SyncLog, Unit, UserFile,
-                             UserPreference, ViewLog)
+from cookbook.models import (Automation, BookmarkletImport, Comment, CookLog, CustomFilter,
+                             ExportLog, Food, FoodInheritField, ImportLog, Ingredient, Keyword,
+                             MealPlan, MealType, NutritionInformation, Recipe, RecipeBook,
+                             RecipeBookEntry, RecipeImport, ShareLink, ShoppingList,
+                             ShoppingListEntry, ShoppingListRecipe, Step, Storage, Supermarket,
+                             SupermarketCategory, SupermarketCategoryRelation, Sync, SyncLog, Unit,
+                             UserFile, UserPreference, ViewLog)
 from cookbook.templatetags.custom_tags import markdown
-from recipes.settings import MEDIA_URL
+from recipes.settings import MEDIA_URL, AWS_ENABLED
 
 
 class ExtendedRecipeMixin(serializers.ModelSerializer):
@@ -43,7 +43,8 @@ class ExtendedRecipeMixin(serializers.ModelSerializer):
             api_serializer = None
         # extended values are computationally expensive and not needed in normal circumstances
         try:
-            if str2bool(self.context['request'].query_params.get('extended', False)) and self.__class__ == api_serializer:
+            if str2bool(
+                    self.context['request'].query_params.get('extended', False)) and self.__class__ == api_serializer:
                 return fields
         except (AttributeError, KeyError) as e:
             pass
@@ -56,7 +57,12 @@ class ExtendedRecipeMixin(serializers.ModelSerializer):
 
     def get_image(self, obj):
         if obj.recipe_image:
-            return MEDIA_URL + obj.recipe_image
+            if AWS_ENABLED:
+                storage = CachedS3Boto3Storage()
+                path = storage.url(obj.recipe_image)
+            else:
+                path = MEDIA_URL + obj.recipe_image
+            return path
 
 
 class CustomDecimalField(serializers.Field):
@@ -91,7 +97,11 @@ class CustomOnHandField(serializers.Field):
         if request := self.context.get('request', None):
             shared_users = getattr(request, '_shared_users', None)
         if shared_users is None:
-            shared_users = [x.id for x in list(self.context['request'].user.get_shopping_share())] + [self.context['request'].user.id]
+            try:
+                shared_users = [x.id for x in list(self.context['request'].user.get_shopping_share())] + [
+                    self.context['request'].user.id]
+            except AttributeError:  # Anonymous users (using share links) don't have shared users
+                shared_users = []
         return obj.onhand_users.filter(id__in=shared_users).exists()
 
     def to_internal_value(self, data):
@@ -163,7 +173,8 @@ class FoodInheritFieldSerializer(WritableNestedModelSerializer):
 
 
 class UserPreferenceSerializer(WritableNestedModelSerializer):
-    food_inherit_default = FoodInheritFieldSerializer(source='space.food_inherit', many=True, allow_null=True, required=False, read_only=True)
+    food_inherit_default = FoodInheritFieldSerializer(source='space.food_inherit', many=True, allow_null=True,
+                                                      required=False, read_only=True)
     plan_share = UserNameSerializer(many=True, allow_null=True, required=False, read_only=True)
     shopping_share = UserNameSerializer(many=True, allow_null=True, required=False)
     food_children_exist = serializers.SerializerMethodField('get_food_children_exist')
@@ -182,9 +193,12 @@ class UserPreferenceSerializer(WritableNestedModelSerializer):
     class Meta:
         model = UserPreference
         fields = (
-            'user', 'theme', 'nav_color', 'default_unit', 'default_page', 'use_fractions', 'use_kj', 'search_style', 'show_recent', 'plan_share',
-            'ingredient_decimals', 'comments', 'shopping_auto_sync', 'mealplan_autoadd_shopping', 'food_inherit_default', 'default_delay',
-            'mealplan_autoinclude_related', 'mealplan_autoexclude_onhand', 'shopping_share', 'shopping_recent_days', 'csv_delim', 'csv_prefix',
+            'user', 'theme', 'nav_color', 'default_unit', 'default_page', 'use_fractions', 'use_kj', 'search_style',
+            'show_recent', 'plan_share',
+            'ingredient_decimals', 'comments', 'shopping_auto_sync', 'mealplan_autoadd_shopping',
+            'food_inherit_default', 'default_delay',
+            'mealplan_autoinclude_related', 'mealplan_autoexclude_onhand', 'shopping_share', 'shopping_recent_days',
+            'csv_delim', 'csv_prefix',
             'filter_to_supermarket', 'shopping_add_onhand', 'left_handed', 'food_children_exist'
         )
 
@@ -299,9 +313,9 @@ class KeywordSerializer(UniqueFieldsMixin, ExtendedRecipeMixin):
     def create(self, validated_data):
         # since multi select tags dont have id's
         # duplicate names might be routed to create
-        validated_data['name'] = validated_data['name'].strip()
-        validated_data['space'] = self.context['request'].space
-        obj, created = Keyword.objects.get_or_create(**validated_data)
+        name = validated_data.pop('name').strip()
+        space = validated_data.pop('space', self.context['request'].space)
+        obj, created = Keyword.objects.get_or_create(name=name, space=space, defaults=validated_data)
         return obj
 
     class Meta:
@@ -316,9 +330,9 @@ class UnitSerializer(UniqueFieldsMixin, ExtendedRecipeMixin):
     recipe_filter = 'steps__ingredients__unit'
 
     def create(self, validated_data):
-        validated_data['name'] = validated_data['name'].strip()
-        validated_data['space'] = self.context['request'].space
-        obj, created = Unit.objects.get_or_create(**validated_data)
+        name = validated_data.pop('name').strip()
+        space = validated_data.pop('space', self.context['request'].space)
+        obj, created = Unit.objects.get_or_create(name=name, space=space, defaults=validated_data)
         return obj
 
     def update(self, instance, validated_data):
@@ -334,9 +348,9 @@ class UnitSerializer(UniqueFieldsMixin, ExtendedRecipeMixin):
 class SupermarketCategorySerializer(UniqueFieldsMixin, WritableNestedModelSerializer):
 
     def create(self, validated_data):
-        validated_data['name'] = validated_data['name'].strip()
-        validated_data['space'] = self.context['request'].space
-        obj, created = SupermarketCategory.objects.get_or_create(**validated_data)
+        name = validated_data.pop('name').strip()
+        space = validated_data.pop('space', self.context['request'].space)
+        obj, created = SupermarketCategory.objects.get_or_create(name=name, space=space)
         return obj
 
     def update(self, instance, validated_data):
@@ -363,16 +377,29 @@ class SupermarketSerializer(UniqueFieldsMixin, SpacedModelSerializer):
         fields = ('id', 'name', 'description', 'category_to_supermarket')
 
 
-class RecipeSimpleSerializer(serializers.ModelSerializer):
+class RecipeSimpleSerializer(WritableNestedModelSerializer):
     url = serializers.SerializerMethodField('get_url')
 
     def get_url(self, obj):
         return reverse('view_recipe', args=[obj.id])
 
+    def create(self, validated_data):
+        # don't allow writing to Recipe via this API
+        return Recipe.objects.get(**validated_data)
+
+    def update(self, instance, validated_data):
+        # don't allow writing to Recipe via this API
+        return Recipe.objects.get(**validated_data)
+
     class Meta:
         model = Recipe
         fields = ('id', 'name', 'url')
-        read_only_fields = ['id', 'name', 'url']
+
+
+class FoodSimpleSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Food
+        fields = ('id', 'name')
 
 
 class FoodSerializer(UniqueFieldsMixin, WritableNestedModelSerializer, ExtendedRecipeMixin):
@@ -381,23 +408,47 @@ class FoodSerializer(UniqueFieldsMixin, WritableNestedModelSerializer, ExtendedR
     # shopping = serializers.SerializerMethodField('get_shopping_status')
     shopping = serializers.ReadOnlyField(source='shopping_status')
     inherit_fields = FoodInheritFieldSerializer(many=True, allow_null=True, required=False)
+    child_inherit_fields = FoodInheritFieldSerializer(many=True, allow_null=True, required=False)
     food_onhand = CustomOnHandField(required=False, allow_null=True)
+    substitute_onhand = serializers.SerializerMethodField('get_substitute_onhand')
+    substitute = FoodSimpleSerializer(many=True, allow_null=True, required=False)
 
     recipe_filter = 'steps__ingredients__food'
     images = ['recipe__image']
 
+    def get_substitute_onhand(self, obj):
+        shared_users = None
+        if request := self.context.get('request', None):
+            shared_users = getattr(request, '_shared_users', None)
+        if shared_users is None:
+            try:
+                shared_users = [x.id for x in list(self.context['request'].user.get_shopping_share())] + [
+                    self.context['request'].user.id]
+            except AttributeError:
+                shared_users = []
+        filter = Q(id__in=obj.substitute.all())
+        if obj.substitute_siblings:
+            filter |= Q(path__startswith=obj.path[:Food.steplen * (obj.depth - 1)], depth=obj.depth)
+        if obj.substitute_children:
+            filter |= Q(path__startswith=obj.path, depth__gt=obj.depth)
+        return Food.objects.filter(filter).filter(onhand_users__id__in=shared_users).exists()
+
     # def get_shopping_status(self, obj):
     #     return ShoppingListEntry.objects.filter(space=obj.space, food=obj, checked=False).count() > 0
 
     def create(self, validated_data):
-        validated_data['name'] = validated_data['name'].strip()
-        validated_data['space'] = self.context['request'].space
+        name = validated_data.pop('name').strip()
+        space = validated_data.pop('space', self.context['request'].space)
         # supermarket category needs to be handled manually as food.get or create does not create nested serializers unlike a super.create of serializer
         if 'supermarket_category' in validated_data and validated_data['supermarket_category']:
+            sm_category = validated_data['supermarket_category']
+            sc_name = sm_category.pop('name', None)
             validated_data['supermarket_category'], sc_created = SupermarketCategory.objects.get_or_create(
-                name=validated_data.pop('supermarket_category')['name'],
-                space=self.context['request'].space)
+                name=sc_name,
+                space=space, defaults=sm_category)
         onhand = validated_data.pop('food_onhand', None)
+        if recipe := validated_data.get('recipe', None):
+            validated_data['recipe'] = Recipe.objects.get(**recipe)
 
         # assuming if on hand for user also onhand for shopping_share users
         if not onhand is None:
@@ -411,7 +462,7 @@ class FoodSerializer(UniqueFieldsMixin, WritableNestedModelSerializer, ExtendedR
             else:
                 validated_data['onhand_users'] = list(set(onhand_users) - set(shared_users))
 
-        obj, created = Food.objects.get_or_create(**validated_data)
+        obj, created = Food.objects.get_or_create(name=name, space=space, defaults=validated_data)
         return obj
 
     def update(self, instance, validated_data):
@@ -419,40 +470,59 @@ class FoodSerializer(UniqueFieldsMixin, WritableNestedModelSerializer, ExtendedR
             validated_data['name'] = name.strip()
         # assuming if on hand for user also onhand for shopping_share users
         onhand = validated_data.get('food_onhand', None)
+        reset_inherit = self.initial_data.get('reset_inherit', False)
         if not onhand is None:
             shared_users = [user := self.context['request'].user] + list(user.userpreference.shopping_share.all())
             if onhand:
                 validated_data['onhand_users'] = list(self.instance.onhand_users.all()) + shared_users
             else:
                 validated_data['onhand_users'] = list(set(self.instance.onhand_users.all()) - set(shared_users))
-        return super(FoodSerializer, self).update(instance, validated_data)
+
+        # update before resetting inheritance
+        saved_instance = super(FoodSerializer, self).update(instance, validated_data)
+        if reset_inherit and (r := self.context.get('request', None)):
+            Food.reset_inheritance(food=saved_instance, space=r.space)
+        return saved_instance
 
     class Meta:
         model = Food
         fields = (
             'id', 'name', 'description', 'shopping', 'recipe', 'food_onhand', 'supermarket_category',
-            'image', 'parent', 'numchild', 'numrecipe', 'inherit_fields', 'full_name', 'ignore_shopping'
+            'image', 'parent', 'numchild', 'numrecipe', 'inherit_fields', 'full_name', 'ignore_shopping',
+            'substitute', 'substitute_siblings', 'substitute_children', 'substitute_onhand', 'child_inherit_fields'
         )
         read_only_fields = ('id', 'numchild', 'parent', 'image', 'numrecipe')
 
 
-class IngredientSerializer(WritableNestedModelSerializer):
-    food = FoodSerializer(allow_null=True)
+class IngredientSimpleSerializer(WritableNestedModelSerializer):
+    food = FoodSimpleSerializer(allow_null=True)
     unit = UnitSerializer(allow_null=True)
+    used_in_recipes = serializers.SerializerMethodField('get_used_in_recipes')
     amount = CustomDecimalField()
 
+    def get_used_in_recipes(self, obj):
+        return list(Recipe.objects.filter(steps__ingredients=obj.id).values('id', 'name'))
+
     def create(self, validated_data):
         validated_data['space'] = self.context['request'].space
         return super().create(validated_data)
 
+    def update(self, instance, validated_data):
+        validated_data.pop('original_text', None)
+        return super().update(instance, validated_data)
+
     class Meta:
         model = Ingredient
         fields = (
             'id', 'food', 'unit', 'amount', 'note', 'order',
-            'is_header', 'no_amount'
+            'is_header', 'no_amount', 'original_text', 'used_in_recipes',
         )
 
 
+class IngredientSerializer(IngredientSimpleSerializer):
+    food = FoodSerializer(allow_null=True)
+
+
 class StepSerializer(WritableNestedModelSerializer, ExtendedRecipeMixin):
     ingredients = IngredientSerializer(many=True)
     ingredients_markdown = serializers.SerializerMethodField('get_ingredients_markdown')
@@ -575,11 +645,17 @@ class RecipeSerializer(RecipeBaseSerializer):
         model = Recipe
         fields = (
             'id', 'name', 'description', 'image', 'keywords', 'steps', 'working_time',
-            'waiting_time', 'created_by', 'created_at', 'updated_at',
+            'waiting_time', 'created_by', 'created_at', 'updated_at','source_url',
             'internal', 'nutrition', 'servings', 'file_path', 'servings_text', 'rating', 'last_cooked',
         )
         read_only_fields = ['image', 'created_by', 'created_at']
 
+    def validate(self, data):
+        above_limit, msg = above_space_limit(self.context['request'].space)
+        if above_limit:
+            raise serializers.ValidationError(msg)
+        return super().validate(data)
+
     def create(self, validated_data):
         validated_data['created_by'] = self.context['request'].user
         validated_data['space'] = self.context['request'].space
@@ -587,9 +663,12 @@ class RecipeSerializer(RecipeBaseSerializer):
 
 
 class RecipeImageSerializer(WritableNestedModelSerializer):
+    image = serializers.ImageField(required=False, allow_null=True)
+    image_url = serializers.CharField(max_length=4096, required=False, allow_null=True)
+
     class Meta:
         model = Recipe
-        fields = ['image', ]
+        fields = ['image', 'image_url', ]
 
 
 class RecipeImportSerializer(SpacedModelSerializer):
@@ -604,8 +683,22 @@ class CommentSerializer(serializers.ModelSerializer):
         fields = '__all__'
 
 
+class CustomFilterSerializer(SpacedModelSerializer, WritableNestedModelSerializer):
+    shared = UserNameSerializer(many=True, required=False)
+
+    def create(self, validated_data):
+        validated_data['created_by'] = self.context['request'].user
+        return super().create(validated_data)
+
+    class Meta:
+        model = CustomFilter
+        fields = ('id', 'name', 'search', 'shared', 'created_by')
+        read_only_fields = ('created_by',)
+
+
 class RecipeBookSerializer(SpacedModelSerializer, WritableNestedModelSerializer):
     shared = UserNameSerializer(many=True)
+    filter = CustomFilterSerializer(allow_null=True, required=False)
 
     def create(self, validated_data):
         validated_data['created_by'] = self.context['request'].user
@@ -613,7 +706,7 @@ class RecipeBookSerializer(SpacedModelSerializer, WritableNestedModelSerializer)
 
     class Meta:
         model = RecipeBook
-        fields = ('id', 'name', 'description', 'icon', 'shared', 'created_by')
+        fields = ('id', 'name', 'description', 'icon', 'shared', 'created_by', 'filter')
         read_only_fields = ('created_by',)
 
 
@@ -630,7 +723,8 @@ class RecipeBookEntrySerializer(serializers.ModelSerializer):
     def create(self, validated_data):
         book = validated_data['book']
         recipe = validated_data['recipe']
-        if not book.get_owner() == self.context['request'].user:
+        if not book.get_owner() == self.context['request'].user and not self.context[
+                                                                            'request'].user in book.get_shared():
             raise NotFound(detail=None, code=None)
         obj, created = RecipeBookEntry.objects.get_or_create(book=book, recipe=recipe)
         return obj
@@ -659,7 +753,7 @@ class MealPlanSerializer(SpacedModelSerializer, WritableNestedModelSerializer):
     def create(self, validated_data):
         validated_data['created_by'] = self.context['request'].user
         mealplan = super().create(validated_data)
-        if self.context['request'].data.get('addshopping', False):
+        if self.context['request'].data.get('addshopping', False) and self.context['request'].data.get('recipe', None):
             SLR = RecipeShoppingEditor(user=validated_data['created_by'], space=validated_data['space'])
             SLR.create(mealplan=mealplan, servings=validated_data['servings'])
         return mealplan
@@ -674,7 +768,6 @@ class MealPlanSerializer(SpacedModelSerializer, WritableNestedModelSerializer):
         read_only_fields = ('created_by',)
 
 
-# TODO deprecate
 class ShoppingListRecipeSerializer(serializers.ModelSerializer):
     name = serializers.SerializerMethodField('get_name')  # should this be done at the front end?
     recipe_name = serializers.ReadOnlyField(source='recipe.name')
@@ -684,13 +777,14 @@ class ShoppingListRecipeSerializer(serializers.ModelSerializer):
     def get_name(self, obj):
         if not isinstance(value := obj.servings, Decimal):
             value = Decimal(value)
-        value = value.quantize(Decimal(1)) if value == value.to_integral() else value.normalize()  # strips trailing zero
+        value = value.quantize(
+            Decimal(1)) if value == value.to_integral() else value.normalize()  # strips trailing zero
         return (
-            obj.name
-            or getattr(obj.mealplan, 'title', None)
-            or (d := getattr(obj.mealplan, 'date', None)) and ': '.join([obj.mealplan.recipe.name, str(d)])
-            or obj.recipe.name
-        ) + f' ({value:.2g})'
+                       obj.name
+                       or getattr(obj.mealplan, 'title', None)
+                       or (d := getattr(obj.mealplan, 'date', None)) and ': '.join([obj.mealplan.recipe.name, str(d)])
+                       or obj.recipe.name
+               ) + f' ({value:.2g})'
 
     def update(self, instance, validated_data):
         # TODO remove once old shopping list
@@ -761,7 +855,8 @@ class ShoppingListEntrySerializer(WritableNestedModelSerializer):
     class Meta:
         model = ShoppingListEntry
         fields = (
-            'id', 'list_recipe', 'food', 'unit', 'ingredient', 'ingredient_note', 'amount', 'order', 'checked', 'recipe_mealplan',
+            'id', 'list_recipe', 'food', 'unit', 'ingredient', 'ingredient_note', 'amount', 'order', 'checked',
+            'recipe_mealplan',
             'created_by', 'created_at', 'completed_at', 'delay_until'
         )
         read_only_fields = ('id', 'created_by', 'created_at',)
@@ -859,11 +954,13 @@ class ExportLogSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = ExportLog
-        fields = ('id', 'type', 'msg', 'running', 'total_recipes', 'exported_recipes', 'cache_duration', 'possibly_not_expired', 'created_by', 'created_at')
+        fields = (
+            'id', 'type', 'msg', 'running', 'total_recipes', 'exported_recipes', 'cache_duration',
+            'possibly_not_expired',
+            'created_by', 'created_at')
         read_only_fields = ('created_by',)
 
 
-
 class AutomationSerializer(serializers.ModelSerializer):
 
     def create(self, validated_data):
@@ -881,12 +978,19 @@ class AutomationSerializer(serializers.ModelSerializer):
 # CORS, REST and Scopes aren't currently working
 # Scopes are evaluating before REST has authenticated the user assigning a None space
 # I've made the change below to fix the bookmarklet, other serializers likely need a similar/better fix
-class BookmarkletImportSerializer(serializers.ModelSerializer):
+class BookmarkletImportListSerializer(serializers.ModelSerializer):
     def create(self, validated_data):
         validated_data['created_by'] = self.context['request'].user
         validated_data['space'] = self.context['request'].user.userpreference.space
         return super().create(validated_data)
 
+    class Meta:
+        model = BookmarkletImport
+        fields = ('id', 'url', 'created_by', 'created_at')
+        read_only_fields = ('created_by', 'space')
+
+
+class BookmarkletImportSerializer(BookmarkletImportListSerializer):
     class Meta:
         model = BookmarkletImport
         fields = ('id', 'url', 'html', 'created_by', 'created_at')
@@ -972,10 +1076,12 @@ class RecipeExportSerializer(WritableNestedModelSerializer):
 
 
 class RecipeShoppingUpdateSerializer(serializers.ModelSerializer):
-    list_recipe = serializers.IntegerField(write_only=True, allow_null=True, required=False, help_text=_("Existing shopping list to update"))
+    list_recipe = serializers.IntegerField(write_only=True, allow_null=True, required=False,
+                                           help_text=_("Existing shopping list to update"))
     ingredients = serializers.IntegerField(write_only=True, allow_null=True, required=False, help_text=_(
         "List of ingredient IDs from the recipe to add, if not provided all ingredients will be added."))
-    servings = serializers.IntegerField(default=1, write_only=True, allow_null=True, required=False, help_text=_("Providing a list_recipe ID and servings of 0 will delete that shopping list."))
+    servings = serializers.IntegerField(default=1, write_only=True, allow_null=True, required=False, help_text=_(
+        "Providing a list_recipe ID and servings of 0 will delete that shopping list."))
 
     class Meta:
         model = Recipe
@@ -983,9 +1089,12 @@ class RecipeShoppingUpdateSerializer(serializers.ModelSerializer):
 
 
 class FoodShoppingUpdateSerializer(serializers.ModelSerializer):
-    amount = serializers.IntegerField(write_only=True, allow_null=True, required=False, help_text=_("Amount of food to add to the shopping list"))
-    unit = serializers.IntegerField(write_only=True, allow_null=True, required=False, help_text=_("ID of unit to use for the shopping list"))
-    delete = serializers.ChoiceField(choices=['true'], write_only=True, allow_null=True, allow_blank=True, help_text=_("When set to true will delete all food from active shopping lists."))
+    amount = serializers.IntegerField(write_only=True, allow_null=True, required=False,
+                                      help_text=_("Amount of food to add to the shopping list"))
+    unit = serializers.IntegerField(write_only=True, allow_null=True, required=False,
+                                    help_text=_("ID of unit to use for the shopping list"))
+    delete = serializers.ChoiceField(choices=['true'], write_only=True, allow_null=True, allow_blank=True,
+                                     help_text=_("When set to true will delete all food from active shopping lists."))
 
     class Meta:
         model = Recipe

cookbook/signals.py

@@ -18,9 +18,8 @@ if settings.DATABASES['default']['ENGINE'] in ['django.db.backends.postgresql_ps
                                                'django.db.backends.postgresql']:
     SQLITE = False
 
+
 # wraps a signal with the ability to set 'skip_signal' to avoid creating recursive signals
-
-
 def skip_signal(signal_func):
     @wraps(signal_func)
     def _decorator(sender, instance, **kwargs):
@@ -38,6 +37,7 @@ def update_recipe_search_vector(sender, instance=None, created=False, **kwargs):
     if SQLITE:
         return
     language = DICTIONARY.get(translation.get_language(), 'simple')
+    # these indexed fields are space wide, reading user preferences would lead to inconsistent behavior
     instance.name_search_vector = SearchVector('name__unaccent', weight='A', config=language)
     instance.desc_search_vector = SearchVector('description__unaccent', weight='C', config=language)
     try:
@@ -76,8 +76,9 @@ def update_food_inheritance(sender, instance=None, created=False, **kwargs):
     # apply changes from parent to instance for each inherited field
     if instance.parent and inherit.count() > 0:
         parent = instance.get_parent()
-        if 'ignore_shopping' in inherit:
-            instance.ignore_shopping = parent.ignore_shopping
+        for field in ['ignore_shopping', 'substitute_children', 'substitute_siblings']:
+            if field in inherit:
+                setattr(instance, field, getattr(parent, field, None))
         # if supermarket_category is not set, do not cascade - if this becomes non-intuitive can change
         if 'supermarket_category' in inherit and parent.supermarket_category:
             instance.supermarket_category = parent.supermarket_category
@@ -87,49 +88,48 @@ def update_food_inheritance(sender, instance=None, created=False, **kwargs):
         finally:
             del instance.skip_signal
 
-    # TODO figure out how to generalize this
     # apply changes to direct children - depend on save signals for those objects to cascade inheritance down
-    _save = []
-    for child in instance.get_children().filter(inherit_fields__field='ignore_shopping'):
-        child.ignore_shopping = instance.ignore_shopping
-        _save.append(child)
-    # don't cascade empty supermarket category
-    if instance.supermarket_category:
-        # apply changes to direct children - depend on save signals for those objects to cascade inheritance down
-        for child in instance.get_children().filter(inherit_fields__field='supermarket_category'):
-            child.supermarket_category = instance.supermarket_category
-            _save.append(child)
-    for child in set(_save):
+    for child in instance.get_children().filter(inherit_fields__in=Food.inheritable_fields):
+        # set inherited field values
+        for field in (inherit_fields := ['ignore_shopping', 'substitute_children', 'substitute_siblings']):
+            if field in instance.inherit_fields.values_list('field', flat=True):
+                setattr(child, field, getattr(instance, field, None))
+
+        # don't cascade empty supermarket category
+        if instance.supermarket_category and 'supermarket_category' in inherit_fields:
+            setattr(child, 'supermarket_category', getattr(instance, 'supermarket_category', None))
+
         child.save()
 
 
 @receiver(post_save, sender=MealPlan)
 def auto_add_shopping(sender, instance=None, created=False, weak=False, **kwargs):
+    print("MEAL_AUTO_ADD Signal trying to auto add to shopping")
     if not instance:
-        return
-    user = instance.get_owner()
-    with scope(space=instance.space):
-        slr_exists = instance.shoppinglistrecipe_set.exists()
-
-    if not created and slr_exists:
-        for x in instance.shoppinglistrecipe_set.all():
-            # assuming that permissions checks for the MealPlan have happened upstream
-            if instance.servings != x.servings:
-                SLR = RecipeShoppingEditor(id=x.id, user=user, space=instance.space)
-                SLR.edit_servings(servings=instance.servings)
-                # list_recipe = list_from_recipe(list_recipe=x, servings=instance.servings, space=instance.space)
-    elif not user.userpreference.mealplan_autoadd_shopping or not instance.recipe:
+        print("MEAL_AUTO_ADD Instance is none")
         return
 
-    if created:
-        # if creating a mealplan - perform shopping list activities
-        # kwargs = {
-        #     'mealplan': instance,
-        #     'space': instance.space,
-        #     'created_by': user,
-        #     'servings': instance.servings
-        # }
-        SLR = RecipeShoppingEditor(user=user, space=instance.space)
-        SLR.create(mealplan=instance, servings=instance.servings)
+    try:
+        space = instance.get_space()
+        user = instance.get_owner()
+        with scope(space=space):
+            slr_exists = instance.shoppinglistrecipe_set.exists()
+
+        if not created and slr_exists:
+            for x in instance.shoppinglistrecipe_set.all():
+                # assuming that permissions checks for the MealPlan have happened upstream
+                if instance.servings != x.servings:
+                    SLR = RecipeShoppingEditor(id=x.id, user=user, space=instance.space)
+                    SLR.edit_servings(servings=instance.servings)
+        elif not user.userpreference.mealplan_autoadd_shopping or not instance.recipe:
+            print("MEAL_AUTO_ADD No recipe or no setting")
+            return
+
+        if created:
+            SLR = RecipeShoppingEditor(user=user, space=space)
+            SLR.create(mealplan=instance, servings=instance.servings)
+            print("MEAL_AUTO_ADD Created SLR")
+    except AttributeError:
+        pass
+
 
-        # list_recipe = list_from_recipe(**kwargs)

cookbook/static/css/app.min.css

@@ -1,3 +1,15 @@
+.brand-icon {
+    height: 40px;
+}
+
+@media (max-width: 991.98px) {
+    .menu-dropdown-text {
+        font-size: 14px;
+        font-weight: 200;
+    }
+}
+
+
 .spinner-tandoor {
     animation: rotation 3s infinite linear;
     content: url("../assets/spinner.svg");