Merge branch 'develop'

Currently translated at 48.1% (254 of 528 strings)

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

.dockerignore

@@ -1,4 +1,4 @@
-node_modules
+**/node_modules
 npm-debug.log
 Dockerfile*
 docker-compose*
@@ -12,6 +12,21 @@ LICENSE
 .env.template
 .github
 .idea
+.prettierignore
 LICENSE.md
 docs
-update.sh
+update.sh
+.pytest_cache
+cookbook/tests
+mediafiles
+staticfiles
+db.sqlite3
+pytest.ini
+vue/**/*.vue
+vue/**/*.ts
+**/.openapi-generator
+mkdocs.yml
+vue/babel.config*
+vue/package.json
+vue/tsconfig.json
+vue/src/utils/openapi

.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/
@@ -146,7 +151,12 @@ REVERSE_PROXY_AUTH=0
 #AUTH_LDAP_BIND_DN=
 #AUTH_LDAP_BIND_PASSWORD=
 #AUTH_LDAP_USER_SEARCH_BASE_DN=
+#AUTH_LDAP_TLS_CACERTFILE=
 
 # Enables exporting PDF (see export docs)
 # Disabled by default, uncomment to enable
 # ENABLE_PDF_EXPORT=1
+
+# Recipe exports are cached for a certain time by default, adjust time if needed
+# EXPORT_FILE_CACHE_DURATION=600
+

.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,48 @@ 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()
+        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 +245,62 @@ 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]
+
+        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):
@@ -205,9 +202,9 @@ class CustomIsShared(permissions.BasePermission):
         return request.user.is_authenticated
 
     def has_object_permission(self, request, view, obj):
-        # temporary hack to make old shopping list work with new shopping list
-        if obj.__class__.__name__ == 'ShoppingList':
-            return is_object_shared(request.user, obj) or obj.created_by in list(request.user.get_shopping_share())
+        # # temporary hack to make old shopping list work with new shopping list
+        # if obj.__class__.__name__ in ['ShoppingList', 'ShoppingListEntry']:
+        #     return is_object_shared(request.user, obj) or obj.created_by in list(request.user.get_shopping_share())
         return is_object_shared(request.user, obj)
 
 
@@ -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

@@ -8,7 +8,7 @@ from django.utils import timezone
 from django.utils.translation import gettext as _
 
 from cookbook.helper.HelperFunctions import Round, str2bool
-from cookbook.models import (Ingredient, ShoppingListEntry, ShoppingListRecipe,
+from cookbook.models import (Ingredient, MealPlan, Recipe, ShoppingListEntry, ShoppingListRecipe,
                              SupermarketCategoryRelation)
 from recipes import settings
 
@@ -35,121 +35,279 @@ 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')
 
 
-# TODO refactor as class
-def list_from_recipe(list_recipe=None, recipe=None, mealplan=None, servings=None, ingredients=None, created_by=None, space=None, append=False):
-    """
-    Creates ShoppingListRecipe and associated ShoppingListEntrys from a recipe or a meal plan with a recipe
-    :param list_recipe: Modify an existing ShoppingListRecipe
-    :param recipe: Recipe to use as list of ingredients.  One of [recipe, mealplan] are required
-    :param mealplan: alternatively use a mealplan recipe as source of ingredients
-    :param servings: Optional: Number of servings to use to scale shoppinglist.  If servings = 0 an existing recipe list will be deleted
-    :param ingredients: Ingredients, list of ingredient IDs to include on the shopping list.  When not provided all ingredients will be used
-    :param append: If False will remove any entries not included with ingredients, when True will append ingredients to the shopping list
-    """
-    r = recipe or getattr(mealplan, 'recipe', None) or getattr(list_recipe, 'recipe', None)
-    if not r:
-        raise ValueError(_("You must supply a recipe or mealplan"))
+class RecipeShoppingEditor():
+    def __init__(self, user, space, **kwargs):
+        self.created_by = user
+        self.space = space
+        self._kwargs = {**kwargs}
 
-    created_by = created_by or getattr(ShoppingListEntry.objects.filter(list_recipe=list_recipe).first(), 'created_by', None)
-    if not created_by:
-        raise ValueError(_("You must supply a created_by"))
+        self.mealplan = self._kwargs.get('mealplan', None)
+        if type(self.mealplan) in [int, float]:
+            self.mealplan = MealPlan.objects.filter(id=self.mealplan, space=self.space)
+        self.id = self._kwargs.get('id', None)
 
-    try:
-        servings = float(servings)
-    except (ValueError, TypeError):
-        servings = getattr(mealplan, 'servings', 1.0)
+        self._shopping_list_recipe = self.get_shopping_list_recipe(self.id, self.created_by, self.space)
 
-    servings_factor = servings / r.servings
+        if self._shopping_list_recipe:
+            # created_by needs to be sticky to original creator as it is 'their' shopping list
+            # changing shopping list created_by can shift some items to new owner which may not share in the other direction
+            self.created_by = getattr(self._shopping_list_recipe.entries.first(), 'created_by', self.created_by)
 
-    shared_users = list(created_by.get_shopping_share())
-    shared_users.append(created_by)
-    if list_recipe:
-        created = False
-    else:
-        list_recipe = ShoppingListRecipe.objects.create(recipe=r, mealplan=mealplan, servings=servings)
-        created = True
+        self.recipe = getattr(self._shopping_list_recipe, 'recipe', None) or self._kwargs.get('recipe', None) or getattr(self.mealplan, 'recipe', None)
+        if type(self.recipe) in [int, float]:
+            self.recipe = Recipe.objects.filter(id=self.recipe, space=self.space)
 
-    related_step_ing = []
-    if servings == 0 and not created:
-        list_recipe.delete()
-        return []
-    elif ingredients:
-        ingredients = Ingredient.objects.filter(pk__in=ingredients, space=space)
-    else:
-        ingredients = Ingredient.objects.filter(step__recipe=r, space=space)
+        try:
+            self.servings = float(self._kwargs.get('servings', None))
+        except (ValueError, TypeError):
+            self.servings = getattr(self._shopping_list_recipe, 'servings', None) or getattr(self.mealplan, 'servings', None) or getattr(self.recipe, 'servings', None)
 
-        if exclude_onhand := created_by.userpreference.mealplan_autoexclude_onhand:
-            ingredients = ingredients.exclude(food__onhand_users__id__in=[x.id for x in shared_users])
+    @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)
 
-        if related := created_by.userpreference.mealplan_autoinclude_related:
-            # TODO: add levels of related recipes (related recipes of related recipes) to use when auto-adding mealplans
-            related_recipes = r.get_related_recipes()
+    @property
+    def _servings_factor(self):
+        return Decimal(self.servings)/Decimal(self._recipe_servings)
 
-            for x in related_recipes:
-                # related recipe is a Step serving size is driven by recipe serving size
-                # TODO once/if Steps can have a serving size this needs to be refactored
-                if exclude_onhand:
-                    # if steps are used more than once in a recipe or subrecipe - I don' think this results in the desired behavior
-                    related_step_ing += Ingredient.objects.filter(step__recipe=x, space=space).exclude(food__onhand_users__id__in=[x.id for x in shared_users]).values_list('id', flat=True)
-                else:
-                    related_step_ing += Ingredient.objects.filter(step__recipe=x, space=space).values_list('id', flat=True)
+    @property
+    def _shared_users(self):
+        return [*list(self.created_by.get_shopping_share()), self.created_by]
 
-                x_ing = []
-                if ingredients.filter(food__recipe=x).exists():
-                    for ing in ingredients.filter(food__recipe=x):
-                        if exclude_onhand:
-                            x_ing = Ingredient.objects.filter(step__recipe=x,  space=space).exclude(food__onhand_users__id__in=[x.id for x in shared_users])
-                        else:
-                            x_ing = Ingredient.objects.filter(step__recipe=x, space=space)
-                        for i in [x for x in x_ing]:
-                            ShoppingListEntry.objects.create(
-                                list_recipe=list_recipe,
-                                food=i.food,
-                                unit=i.unit,
-                                ingredient=i,
-                                amount=i.amount * Decimal(servings_factor),
-                                created_by=created_by,
-                                space=space,
-                            )
-                # dont' add food to the shopping list that are actually recipes that will be added as ingredients
-                ingredients = ingredients.exclude(food__recipe=x)
+    @staticmethod
+    def get_shopping_list_recipe(id, user, space):
+        return ShoppingListRecipe.objects.filter(id=id).filter(Q(shoppinglist__space=space) | Q(entries__space=space)).filter(
+            Q(shoppinglist__created_by=user)
+            | Q(shoppinglist__shared=user)
+            | Q(entries__created_by=user)
+            | Q(entries__created_by__in=list(user.get_shopping_share()))
+        ).prefetch_related('entries').first()
 
-    add_ingredients = list(ingredients.values_list('id', flat=True)) + related_step_ing
-    if not append:
-        existing_list = ShoppingListEntry.objects.filter(list_recipe=list_recipe)
-        # delete shopping list entries not included in ingredients
-        existing_list.exclude(ingredient__in=ingredients).delete()
-        # add shopping list entries that did not previously exist
-        add_ingredients = set(add_ingredients) - set(existing_list.values_list('ingredient__id', flat=True))
-    add_ingredients = Ingredient.objects.filter(id__in=add_ingredients, space=space)
+    def get_recipe_ingredients(self, id, exclude_onhand=False):
+        if exclude_onhand:
+            return Ingredient.objects.filter(step__recipe__id=id,  food__ignore_shopping=False,  space=self.space).exclude(food__onhand_users__id__in=[x.id for x in self._shared_users])
+        else:
+            return Ingredient.objects.filter(step__recipe__id=id,  food__ignore_shopping=False,  space=self.space)
 
-    # if servings have changed, update the ShoppingListRecipe and existing Entries
-    if servings <= 0:
-        servings = 1
+    @property
+    def _include_related(self):
+        return self.created_by.userpreference.mealplan_autoinclude_related
 
-    if not created and list_recipe.servings != servings:
-        update_ingredients = set(ingredients.values_list('id', flat=True)) - set(add_ingredients.values_list('id', flat=True))
-        list_recipe.servings = servings
-        list_recipe.save()
-        for sle in ShoppingListEntry.objects.filter(list_recipe=list_recipe, ingredient__id__in=update_ingredients):
-            sle.amount = sle.ingredient.amount * Decimal(servings_factor)
+    @property
+    def _exclude_onhand(self):
+        return self.created_by.userpreference.mealplan_autoexclude_onhand
+
+    def create(self, **kwargs):
+        ingredients = kwargs.get('ingredients', None)
+        exclude_onhand = not ingredients and self._exclude_onhand
+        if servings := kwargs.get('servings', None):
+            self.servings = float(servings)
+
+        if mealplan := kwargs.get('mealplan', None):
+            self.mealplan = mealplan
+            self.recipe = mealplan.recipe
+        elif recipe := kwargs.get('recipe', None):
+            self.recipe = recipe
+
+        if not self.servings:
+            self.servings = getattr(self.mealplan, 'servings', None) or getattr(self.recipe, 'servings', 1.0)
+
+        self._shopping_list_recipe = ShoppingListRecipe.objects.create(recipe=self.recipe, mealplan=self.mealplan, servings=self.servings)
+
+        if ingredients:
+            self._add_ingredients(ingredients=ingredients)
+        else:
+            if self._include_related:
+                related = self.recipe.get_related_recipes()
+                self._add_ingredients(self.get_recipe_ingredients(self.recipe.id, exclude_onhand=exclude_onhand).exclude(food__recipe__in=related))
+                for r in related:
+                    self._add_ingredients(self.get_recipe_ingredients(r.id, exclude_onhand=exclude_onhand).exclude(food__recipe__in=related))
+            else:
+                self._add_ingredients(self.get_recipe_ingredients(self.recipe.id, exclude_onhand=exclude_onhand))
+
+        return True
+
+    def add(self, **kwargs):
+        return
+
+    def edit(self, servings=None, ingredients=None, **kwargs):
+        if servings:
+            self.servings = servings
+
+        self._delete_ingredients(ingredients=ingredients)
+        if self.servings != self._shopping_list_recipe.servings:
+            self.edit_servings()
+        self._add_ingredients(ingredients=ingredients)
+        return True
+
+    def edit_servings(self, servings=None, **kwargs):
+        if servings:
+            self.servings = servings
+        if id := kwargs.get('id', None):
+            self._shopping_list_recipe = self.get_shopping_list_recipe(id, self.created_by, self.space)
+        if not self.servings:
+            raise ValueError(_("You must supply a servings size"))
+
+        if self._shopping_list_recipe.servings == self.servings:
+            return True
+
+        for sle in ShoppingListEntry.objects.filter(list_recipe=self._shopping_list_recipe):
+            sle.amount = sle.ingredient.amount * Decimal(self._servings_factor)
             sle.save()
+        self._shopping_list_recipe.servings = self.servings
+        self._shopping_list_recipe.save()
+        return True
 
-    # add any missing Entries
-    for i in [x for x in add_ingredients if x.food]:
+    def delete(self, **kwargs):
+        try:
+            self._shopping_list_recipe.delete()
+            return True
+        except:
+            return False
 
-        ShoppingListEntry.objects.create(
-            list_recipe=list_recipe,
-            food=i.food,
-            unit=i.unit,
-            ingredient=i,
-            amount=i.amount * Decimal(servings_factor),
-            created_by=created_by,
-            space=space,
-        )
+    def _add_ingredients(self, ingredients=None):
+        if not ingredients:
+            return
+        elif type(ingredients) == list:
+            ingredients = Ingredient.objects.filter(id__in=ingredients)
+        existing = self._shopping_list_recipe.entries.filter(ingredient__in=ingredients).values_list('ingredient__pk', flat=True)
+        add_ingredients = ingredients.exclude(id__in=existing)
 
-    # return all shopping list items
-    return list_recipe
+        for i in [x for x in add_ingredients if x.food]:
+            ShoppingListEntry.objects.create(
+                list_recipe=self._shopping_list_recipe,
+                food=i.food,
+                unit=i.unit,
+                ingredient=i,
+                amount=i.amount * Decimal(self._servings_factor),
+                created_by=self.created_by,
+                space=self.space,
+            )
+
+    # deletes shopping list entries not in ingredients list
+    def _delete_ingredients(self, ingredients=None):
+        if not ingredients:
+            return
+        to_delete = self._shopping_list_recipe.entries.exclude(ingredient__in=ingredients)
+        ShoppingListEntry.objects.filter(id__in=to_delete).delete()
+        self._shopping_list_recipe = self.get_shopping_list_recipe(self.id, self.created_by, self.space)
+
+
+# # TODO refactor as class
+# def list_from_recipe(list_recipe=None, recipe=None, mealplan=None, servings=None, ingredients=None, created_by=None, space=None, append=False):
+#     """
+#     Creates ShoppingListRecipe and associated ShoppingListEntrys from a recipe or a meal plan with a recipe
+#     :param list_recipe: Modify an existing ShoppingListRecipe
+#     :param recipe: Recipe to use as list of ingredients.  One of [recipe, mealplan] are required
+#     :param mealplan: alternatively use a mealplan recipe as source of ingredients
+#     :param servings: Optional: Number of servings to use to scale shoppinglist.  If servings = 0 an existing recipe list will be deleted
+#     :param ingredients: Ingredients, list of ingredient IDs to include on the shopping list.  When not provided all ingredients will be used
+#     :param append: If False will remove any entries not included with ingredients, when True will append ingredients to the shopping list
+#     """
+#     r = recipe or getattr(mealplan, 'recipe', None) or getattr(list_recipe, 'recipe', None)
+#     if not r:
+#         raise ValueError(_("You must supply a recipe or mealplan"))
+
+#     created_by = created_by or getattr(ShoppingListEntry.objects.filter(list_recipe=list_recipe).first(), 'created_by', None)
+#     if not created_by:
+#         raise ValueError(_("You must supply a created_by"))
+
+#     try:
+#         servings = float(servings)
+#     except (ValueError, TypeError):
+#         servings = getattr(mealplan, 'servings', 1.0)
+
+#     servings_factor = servings / r.servings
+
+#     shared_users = list(created_by.get_shopping_share())
+#     shared_users.append(created_by)
+#     if list_recipe:
+#         created = False
+#     else:
+#         list_recipe = ShoppingListRecipe.objects.create(recipe=r, mealplan=mealplan, servings=servings)
+#         created = True
+
+#     related_step_ing = []
+#     if servings == 0 and not created:
+#         list_recipe.delete()
+#         return []
+#     elif ingredients:
+#         ingredients = Ingredient.objects.filter(pk__in=ingredients, space=space)
+#     else:
+#         ingredients = Ingredient.objects.filter(step__recipe=r,  food__ignore_shopping=False, space=space)
+
+#         if exclude_onhand := created_by.userpreference.mealplan_autoexclude_onhand:
+#             ingredients = ingredients.exclude(food__onhand_users__id__in=[x.id for x in shared_users])
+
+#         if related := created_by.userpreference.mealplan_autoinclude_related:
+#             # TODO: add levels of related recipes (related recipes of related recipes) to use when auto-adding mealplans
+#             related_recipes = r.get_related_recipes()
+
+#             for x in related_recipes:
+#                 # related recipe is a Step serving size is driven by recipe serving size
+#                 # TODO once/if Steps can have a serving size this needs to be refactored
+#                 if exclude_onhand:
+#                     # if steps are used more than once in a recipe or subrecipe - I don' think this results in the desired behavior
+#                     related_step_ing += Ingredient.objects.filter(step__recipe=x, space=space).exclude(food__onhand_users__id__in=[x.id for x in shared_users]).values_list('id', flat=True)
+#                 else:
+#                     related_step_ing += Ingredient.objects.filter(step__recipe=x, space=space).values_list('id', flat=True)
+
+#                 x_ing = []
+#                 if ingredients.filter(food__recipe=x).exists():
+#                     for ing in ingredients.filter(food__recipe=x):
+#                         if exclude_onhand:
+#                             x_ing = Ingredient.objects.filter(step__recipe=x,  food__ignore_shopping=False, space=space).exclude(food__onhand_users__id__in=[x.id for x in shared_users])
+#                         else:
+#                             x_ing = Ingredient.objects.filter(step__recipe=x,  food__ignore_shopping=False, space=space).exclude(food__ignore_shopping=True)
+#                         for i in [x for x in x_ing]:
+#                             ShoppingListEntry.objects.create(
+#                                 list_recipe=list_recipe,
+#                                 food=i.food,
+#                                 unit=i.unit,
+#                                 ingredient=i,
+#                                 amount=i.amount * Decimal(servings_factor),
+#                                 created_by=created_by,
+#                                 space=space,
+#                             )
+#                 # dont' add food to the shopping list that are actually recipes that will be added as ingredients
+#                 ingredients = ingredients.exclude(food__recipe=x)
+
+#     add_ingredients = list(ingredients.values_list('id', flat=True)) + related_step_ing
+#     if not append:
+#         existing_list = ShoppingListEntry.objects.filter(list_recipe=list_recipe)
+#         # delete shopping list entries not included in ingredients
+#         existing_list.exclude(ingredient__in=ingredients).delete()
+#         # add shopping list entries that did not previously exist
+#         add_ingredients = set(add_ingredients) - set(existing_list.values_list('ingredient__id', flat=True))
+#     add_ingredients = Ingredient.objects.filter(id__in=add_ingredients, space=space)
+
+#     # if servings have changed, update the ShoppingListRecipe and existing Entries
+#     if servings <= 0:
+#         servings = 1
+
+#     if not created and list_recipe.servings != servings:
+#         update_ingredients = set(ingredients.values_list('id', flat=True)) - set(add_ingredients.values_list('id', flat=True))
+#         list_recipe.servings = servings
+#         list_recipe.save()
+#         for sle in ShoppingListEntry.objects.filter(list_recipe=list_recipe, ingredient__id__in=update_ingredients):
+#             sle.amount = sle.ingredient.amount * Decimal(servings_factor)
+#             sle.save()
+
+#     # add any missing Entries
+#     for i in [x for x in add_ingredients if x.food]:
+
+#         ShoppingListEntry.objects.create(
+#             list_recipe=list_recipe,
+#             food=i.food,
+#             unit=i.unit,
+#             ingredient=i,
+#             amount=i.amount * Decimal(servings_factor),
+#             created_by=created_by,
+#             space=space,
+#         )
+
+#     # return all shopping list items
+#     return list_recipe

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/default.py

@@ -32,11 +32,12 @@ class Default(Integration):
         return None
 
     def get_file_from_recipe(self, recipe):
+
         export = RecipeExportSerializer(recipe).data
 
         return 'recipe.json', JSONRenderer().render(export).decode("utf-8")
 
-    def get_files_from_recipes(self, recipes, cookie):
+    def get_files_from_recipes(self, recipes, el, cookie):
         export_zip_stream = BytesIO()
         export_zip_obj = ZipFile(export_zip_stream, 'w')
 
@@ -50,13 +51,20 @@ class Default(Integration):
                 recipe_stream.write(data)
                 recipe_zip_obj.writestr(filename, recipe_stream.getvalue())
                 recipe_stream.close()
+
                 try:
                     recipe_zip_obj.writestr(f'image{get_filetype(r.image.file.name)}', r.image.file.read())
                 except ValueError:
                     pass
 
                 recipe_zip_obj.close()
+
                 export_zip_obj.writestr(str(r.pk) + '.zip', recipe_zip_stream.getvalue())
+
+            el.exported_recipes += 1
+            el.msg += self.get_recipe_processed_msg(r)
+            el.save()
+
         export_zip_obj.close()
 
-        return [[ 'export.zip', export_zip_stream.getvalue() ]]
+        return [[ self.get_export_file_name(), export_zip_stream.getvalue() ]]

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

@@ -1,3 +1,4 @@
+import time
 import datetime
 import json
 import traceback
@@ -5,6 +6,10 @@ import uuid
 from io import BytesIO, StringIO
 from zipfile import BadZipFile, ZipFile
 
+import lxml
+from django.core.cache import cache
+import datetime
+
 from bs4 import Tag
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.files import File
@@ -13,11 +18,13 @@ 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
 from cookbook.models import Keyword, Recipe
 from recipes.settings import DEBUG
+from recipes.settings import EXPORT_FILE_CACHE_DURATION
 
 
 class Integration:
@@ -61,35 +68,44 @@ class Integration:
                 space=request.space
             )
 
-    def do_export(self, recipes):
-        """
-        Perform the export based on a list of recipes
-        :param recipes: list of recipe objects
-        :return: HttpResponse with the file of the requested export format that is directly downloaded (When that format involve multiple files they are zipped together) 
-        """
 
-        files = self.get_files_from_recipes(recipes, self.request.COOKIES)
 
-        if len(files) == 1:
-            filename, file = files[0]
-            export_filename = filename
-            export_file = file
+    def do_export(self, recipes, el):
 
-        else:
-            export_filename = "export.zip"
-            export_stream = BytesIO()
-            export_obj = ZipFile(export_stream, 'w')
+        with scope(space=self.request.space):
+            el.total_recipes = len(recipes) 
+            el.cache_duration = EXPORT_FILE_CACHE_DURATION
+            el.save()
 
-            for filename, file in files:
-                export_obj.writestr(filename, file)
+            files = self.get_files_from_recipes(recipes, el, self.request.COOKIES)
 
-            export_obj.close()
-            export_file = export_stream.getvalue()
+            if len(files) == 1:
+                filename, file = files[0]
+                export_filename = filename
+                export_file = file
+
+            else:
+                #zip the files if there is more then one file
+                export_filename = self.get_export_file_name()
+                export_stream = BytesIO()
+                export_obj = ZipFile(export_stream, 'w')
+
+                for filename, file in files:
+                    export_obj.writestr(filename, file)
+
+                export_obj.close()
+                export_file = export_stream.getvalue()
+
+
+            cache.set('export_file_'+str(el.pk), {'filename': export_filename, 'file': export_file}, EXPORT_FILE_CACHE_DURATION)
+            el.running = False
+            el.save()
 
         response = HttpResponse(export_file, content_type='application/force-download')
         response['Content-Disposition'] = 'attachment; filename="' + export_filename + '"'
         return response
 
+
     def import_file_name_filter(self, zip_info_object):
         """
         Since zipfile.namelist() returns all files in all subdirectories this function allows filtering of files
@@ -126,12 +142,12 @@ class Integration:
                             for d in data_list:
                                 recipe = self.get_recipe_from_file(d)
                                 recipe.keywords.add(self.keyword)
-                                il.msg += f'{recipe.pk} - {recipe.name} \n'
+                                il.msg += self.get_recipe_processed_msg(recipe)
                                 self.handle_duplicates(recipe, import_duplicates)
                                 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:
@@ -144,14 +160,21 @@ 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)))
                                 recipe.keywords.add(self.keyword)
-                                il.msg += f'{recipe.pk} - {recipe.name} \n'
+                                il.msg += self.get_recipe_processed_msg(recipe)
                                 self.handle_duplicates(recipe, import_duplicates)
                                 il.imported_recipes += 1
                                 il.save()
@@ -159,14 +182,14 @@ 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:
                             try:
                                 recipe = self.get_recipe_from_file(d)
                                 recipe.keywords.add(self.keyword)
-                                il.msg += f'{recipe.pk} - {recipe.name} \n'
+                                il.msg += self.get_recipe_processed_msg(recipe)
                                 self.handle_duplicates(recipe, import_duplicates)
                                 il.imported_recipes += 1
                                 il.save()
@@ -183,7 +206,7 @@ class Integration:
                                     try:
                                         recipe = self.get_recipe_from_file(d)
                                         recipe.keywords.add(self.keyword)
-                                        il.msg += f'{recipe.pk} - {recipe.name} \n'
+                                        il.msg += self.get_recipe_processed_msg(recipe)
                                         self.handle_duplicates(recipe, import_duplicates)
                                         il.imported_recipes += 1
                                         il.save()
@@ -193,7 +216,7 @@ class Integration:
                     else:
                         recipe = self.get_recipe_from_file(f['file'])
                         recipe.keywords.add(self.keyword)
-                        il.msg += f'{recipe.pk} - {recipe.name} \n'
+                        il.msg += self.get_recipe_processed_msg(recipe)
                         self.handle_duplicates(recipe, import_duplicates)
             except BadZipFile:
                 il.msg += 'ERROR ' + _(
@@ -230,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):
@@ -260,7 +283,7 @@ class Integration:
         """
         raise NotImplementedError('Method not implemented in integration')
 
-    def get_files_from_recipes(self, recipes, cookie):
+    def get_files_from_recipes(self, recipes, el, cookie):
         """
         Takes a list of recipe object and converts it to a array containing each file.
         Each file is represented as an array [filename, data] where data is a string of the content of the file.
@@ -279,3 +302,10 @@ class Integration:
                 log.msg += exception.msg
         if DEBUG:
             traceback.print_exc()
+
+
+    def get_export_file_name(self, format='zip'):
+        return "export_{}.{}".format(datetime.datetime.now().strftime("%Y-%m-%d"), format)
+
+    def get_recipe_processed_msg(self, recipe):
+        return f'{recipe.pk} - {recipe.name} \n'

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/pdfexport.py

@@ -11,22 +11,25 @@ from cookbook.helper.image_processing import get_filetype
 from cookbook.integration.integration import Integration
 from cookbook.serializer import RecipeExportSerializer
 
-import django.core.management.commands.runserver as runserver
+from cookbook.models import ExportLog
+from asgiref.sync import sync_to_async
 
+import django.core.management.commands.runserver as runserver
+import logging
 
 class PDFexport(Integration):
 
     def get_recipe_from_file(self, file):
         raise NotImplementedError('Method not implemented in storage integration')
 
-    async def get_files_from_recipes_async(self, recipes, cookie):
+    async def get_files_from_recipes_async(self, recipes, el, cookie):
         cmd = runserver.Command()
 
         browser = await launch(
             handleSIGINT=False,
             handleSIGTERM=False,
             handleSIGHUP=False,
-            ignoreHTTPSErrors=True
+            ignoreHTTPSErrors=True,
         )
 
         cookies = {'domain': cmd.default_addr, 'name': 'sessionid', 'value': cookie['sessionid'], }
@@ -39,17 +42,28 @@ class PDFexport(Integration):
                    }
                    }
 
-        page = await browser.newPage()
-        await page.emulateMedia('print')
-        await page.setCookie(cookies)
 
         files = []
         for recipe in recipes:
-            await page.goto('http://' + cmd.default_addr + ':' + cmd.default_port + '/view/recipe/' + str(recipe.id), {'waitUntil': 'networkidle0', })
+
+            page = await browser.newPage()
+            await page.emulateMedia('print')
+            await page.setCookie(cookies)
+
+            await page.goto('http://'+cmd.default_addr+':'+cmd.default_port+'/view/recipe/'+str(recipe.id), {'waitUntil': 'domcontentloaded'})
+            await page.waitForSelector('#printReady');
+
             files.append([recipe.name + '.pdf', await page.pdf(options)])
+            await page.close();
+
+            el.exported_recipes += 1
+            el.msg += self.get_recipe_processed_msg(recipe)
+            await sync_to_async(el.save, thread_sensitive=True)()
+
 
         await browser.close()
         return files
 
-    def get_files_from_recipes(self, recipes, cookie):
-        return asyncio.run(self.get_files_from_recipes_async(recipes, cookie))
+
+    def get_files_from_recipes(self, recipes, el, cookie):
+        return asyncio.run(self.get_files_from_recipes_async(recipes, el, cookie))

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):
@@ -56,11 +56,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 +78,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,23 +80,26 @@ 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
 
-    def get_files_from_recipes(self, recipes, cookie):
+    def get_files_from_recipes(self, recipes, el, cookie):
         json_list = []
         for r in recipes:
             json_list.append(self.get_file_from_recipe(r))
 
-        return [['export.json', json.dumps(json_list)]]
+            el.exported_recipes += 1
+            el.msg += self.get_recipe_processed_msg(r)
+            el.save()
+
+        return [[self.get_export_file_name('json'), json.dumps(json_list)]]
 
     def split_recipe_file(self, file):
         return json.loads(file.read().decode("utf-8"))

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"
@@ -87,10 +86,14 @@ class Saffron(Integration):
 
         return recipe.name+'.txt', data
 
-    def get_files_from_recipes(self, recipes, cookie):
+    def get_files_from_recipes(self, recipes, el, cookie):
         files = []
         for r in recipes:
             filename, data = self.get_file_from_recipe(r)
-            files.append([ filename, data ])
+            files.append([filename, data])
 
-        return files
+            el.exported_recipes += 1
+            el.msg += self.get_recipe_processed_msg(r)
+            el.save()
+
+        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

@@ -8,8 +8,8 @@ msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2021-11-08 16:27+0100\n"
-"PO-Revision-Date: 2021-11-16 06:06+0000\n"
-"Last-Translator: Luka <storek00@gmail.com>\n"
+"PO-Revision-Date: 2022-02-02 15:31+0000\n"
+"Last-Translator: Mario Dvorsek <mario.dvorsek@gmail.com>\n"
 "Language-Team: Slovenian <http://translate.tandoor.dev/projects/tandoor/"
 "recipes-backend/sl/>\n"
 "Language: sl\n"
@@ -18,7 +18,7 @@ msgstr ""
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=4; plural=n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n"
 "%100==4 ? 2 : 3;\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
@@ -33,47 +33,47 @@ msgstr "Privzeta enota"
 
 #: .\cookbook\forms.py:55
 msgid "Use fractions"
-msgstr ""
+msgstr "Uporabi ulomke/frakcije"
 
 #: .\cookbook\forms.py:56
 msgid "Use KJ"
-msgstr ""
+msgstr "Uporabi KJ"
 
 #: .\cookbook\forms.py:57
 msgid "Theme"
-msgstr ""
+msgstr "Tema"
 
 #: .\cookbook\forms.py:58
 msgid "Navbar color"
-msgstr ""
+msgstr "Barva navigacijske vrstice"
 
 #: .\cookbook\forms.py:59
 msgid "Sticky navbar"
-msgstr ""
+msgstr "Lepljiva navigacijska vrstica"
 
 #: .\cookbook\forms.py:60
 msgid "Default page"
-msgstr ""
+msgstr "Privzeta stran"
 
 #: .\cookbook\forms.py:61
 msgid "Show recent recipes"
-msgstr ""
+msgstr "Prikaži nedavne recepte"
 
 #: .\cookbook\forms.py:62
 msgid "Search style"
-msgstr ""
+msgstr "Vrsta iskalnika"
 
 #: .\cookbook\forms.py:63
 msgid "Plan sharing"
-msgstr ""
+msgstr "Deli planer"
 
 #: .\cookbook\forms.py:64
 msgid "Ingredient decimal places"
-msgstr ""
+msgstr "Decimalno mesto pri sestavini"
 
 #: .\cookbook\forms.py:65
 msgid "Shopping list auto sync period"
-msgstr ""
+msgstr "Čas avtomatske sinhronizacije pri nakupovalnem listku"
 
 #: .\cookbook\forms.py:66 .\cookbook\templates\recipe_view.html:21
 #: .\cookbook\templates\space.html:62 .\cookbook\templates\stats.html:47
@@ -85,38 +85,44 @@ msgid ""
 "Color of the top navigation bar. Not all colors work with all themes, just "
 "try them out!"
 msgstr ""
+"Barva zgornje vrstice za krmarjenje. Ne delujejo vse barve z vsemi temami!"
 
 #: .\cookbook\forms.py:72
 msgid "Default Unit to be used when inserting a new ingredient into a recipe."
 msgstr ""
+"Privzeta enota, ki se uporablja pri vstavljanju nove sestavine v recept."
 
 #: .\cookbook\forms.py:74
 msgid ""
 "Enables support for fractions in ingredient amounts (e.g. convert decimals "
 "to fractions automatically)"
 msgstr ""
+"Omogoča podporo ulomkom/frakcijam v količinah sestavin (npr. samodejno "
+"pretvori decimalke v ulomke)"
 
 #: .\cookbook\forms.py:76
 msgid "Display nutritional energy amounts in joules instead of calories"
-msgstr ""
+msgstr "Prikazuj hranilne energijske količine v joules namesto v kalorijah"
 
 #: .\cookbook\forms.py:78
 msgid ""
 "Users with whom newly created meal plan/shopping list entries should be "
 "shared by default."
 msgstr ""
+"Uporabniki, s katerimi je privzeto deljen novo ustvarjen načrt ali "
+"nakupovalni listek."
 
 #: .\cookbook\forms.py:80
 msgid "Show recently viewed recipes on search page."
-msgstr ""
+msgstr "Prikaži nedavno videne recepte na iskalniku."
 
 #: .\cookbook\forms.py:81
 msgid "Number of decimals to round ingredients."
-msgstr ""
+msgstr "Število decimalk, ki so zaokrožene pri sestavinah."
 
 #: .\cookbook\forms.py:82
 msgid "If you want to be able to create and see comments underneath recipes."
-msgstr ""
+msgstr "V primeru, da želite ustvariti in videti komentarje pod recepti."
 
 #: .\cookbook\forms.py:84
 msgid ""
@@ -125,21 +131,28 @@ msgid ""
 "Useful when shopping with multiple people but might use a little bit of "
 "mobile data. If lower than instance limit it is reset when saving."
 msgstr ""
+"Nastavitev na 0 bo onemogočila avtomatsko sinhronizacijo. V pogledu "
+"nakupovalnega listka, se seznam osvežuje vsake toliko sekund, če nekdo drug "
+"naredi spremembo. To je najbolj uporabno, če nakupovalni listek delimo z "
+"večimi osebami. Paziti je potrebno, saj porabi nekaj podatkov v mobilnem "
+"omrežju."
 
 #: .\cookbook\forms.py:87
 msgid "Makes the navbar stick to the top of the page."
-msgstr ""
+msgstr "Nastavi navigacijsko vrstico na vrh strani."
 
 #: .\cookbook\forms.py:103
 msgid ""
 "Both fields are optional. If none are given the username will be displayed "
 "instead"
 msgstr ""
+"Obe polji sta opcijski. V primeru, da ju pustimo prazni bo prikazano "
+"uporabniško ime"
 
 #: .\cookbook\forms.py:124 .\cookbook\forms.py:289
 #: .\cookbook\templates\url_import.html:158
 msgid "Name"
-msgstr ""
+msgstr "Ime"
 
 #: .\cookbook\forms.py:125 .\cookbook\forms.py:290
 #: .\cookbook\templates\space.html:39 .\cookbook\templates\stats.html:24
@@ -150,47 +163,51 @@ msgstr "Ključne besede"
 
 #: .\cookbook\forms.py:126
 msgid "Preparation time in minutes"
-msgstr ""
+msgstr "Priprava v minutah"
 
 #: .\cookbook\forms.py:127
 msgid "Waiting time (cooking/baking) in minutes"
-msgstr ""
+msgstr "Čas čakanja v minutah"
 
 #: .\cookbook\forms.py:128 .\cookbook\forms.py:259 .\cookbook\forms.py:291
 msgid "Path"
-msgstr ""
+msgstr "Pot"
 
 #: .\cookbook\forms.py:129
 msgid "Storage UID"
-msgstr ""
+msgstr "UID shrambe"
 
 #: .\cookbook\forms.py:157
 msgid "Default"
-msgstr ""
+msgstr "Privzeto"
 
 #: .\cookbook\forms.py:168 .\cookbook\templates\url_import.html:94
 msgid ""
 "To prevent duplicates recipes with the same name as existing ones are "
 "ignored. Check this box to import everything."
 msgstr ""
+"V primeru, da želite preprečiti dvojnike receptov z enakim imenom kot so "
+"obstoječi. Če želite uvoziti vse, potrdite to polje."
 
 #: .\cookbook\forms.py:190
 msgid "Add your comment: "
-msgstr ""
+msgstr "Dodaj komentar: "
 
 #: .\cookbook\forms.py:205
 msgid "Leave empty for dropbox and enter app password for nextcloud."
-msgstr ""
+msgstr "Pusti prazno za dropbox in vnesi geslo za nextcloud."
 
 #: .\cookbook\forms.py:212
 msgid "Leave empty for nextcloud and enter api token for dropbox."
-msgstr ""
+msgstr "Pusti prazno za nextcloud in vnesi API žeton za dropbox."
 
 #: .\cookbook\forms.py:221
 msgid ""
 "Leave empty for dropbox and enter only base url for nextcloud (<code>/remote."
 "php/webdav/</code> is added automatically)"
 msgstr ""
+"Pusti prazno za dropbox in vnesi URL za nextcloud (<code>/remote.php/webdav/"
+"</code> je dodano avtomatsko)"
 
 #: .\cookbook\forms.py:258 .\cookbook\views\edit.py:166
 msgid "Storage"
@@ -198,33 +215,35 @@ msgstr "Shramba"
 
 #: .\cookbook\forms.py:260
 msgid "Active"
-msgstr ""
+msgstr "Aktivno"
 
 #: .\cookbook\forms.py:265
 msgid "Search String"
-msgstr ""
+msgstr "Iskalni niz"
 
 #: .\cookbook\forms.py:292
 msgid "File ID"
-msgstr ""
+msgstr "ID datoteke"
 
 #: .\cookbook\forms.py:313
 msgid "You must provide at least a recipe or a title."
-msgstr ""
+msgstr "Vpisati moraš vsaj recept ali naslov."
 
 #: .\cookbook\forms.py:326
 msgid "You can list default users to share recipes with in the settings."
-msgstr ""
+msgstr "Seznam uporabnikov za deljenje receptov lahko vidiš v nastavitvah."
 
 #: .\cookbook\forms.py:327
 msgid ""
 "You can use markdown to format this field. See the <a href=\"/docs/markdown/"
 "\">docs here</a>"
 msgstr ""
+"Lahko uporabiš \"markdown\", da urediš to polje. Preveri <a href=\"/docs/"
+"markdown/\">tukaj</a>"
 
 #: .\cookbook\forms.py:353
 msgid "Maximum number of users for this space reached."
-msgstr ""
+msgstr "Maksimalno število uporabnikov za ta prostor je doseženo."
 
 #: .\cookbook\forms.py:359
 msgid "Email address already taken!"
@@ -235,56 +254,71 @@ msgid ""
 "An email address is not required but if present the invite link will be sent "
 "to the user."
 msgstr ""
+"E-poštni naslov ni potreben, vendar če je vnešeno, bo povabilo poslano do "
+"uporabnika."
 
 #: .\cookbook\forms.py:382
 msgid "Name already taken."
-msgstr ""
+msgstr "Ime je že zasedeno."
 
 #: .\cookbook\forms.py:393
 msgid "Accept Terms and Privacy"
-msgstr ""
+msgstr "Sprejmi pogoje uporabe"
 
 #: .\cookbook\forms.py:425
 msgid ""
 "Determines how fuzzy a search is if it uses trigram similarity matching (e."
 "g. low values mean more typos are ignored)."
 msgstr ""
+"Določa, kakšno je iskanje, če uporablja trigram podobnost ujemanje (npr. "
+"nizke vrednosti pomenijo več, tipkanje se prezre)."
 
 #: .\cookbook\forms.py:435
 msgid ""
 "Select type method of search.  Click <a href=\"/docs/search/\">here</a> for "
 "full desciption of choices."
 msgstr ""
+"Izberi metodo iskanja. Klikni  <a href=\"/docs/search/\">tukaj</a>  za "
+"prikaz vseh izbir."
 
 #: .\cookbook\forms.py:436
 msgid ""
 "Use fuzzy matching on units, keywords and ingredients when editing and "
 "importing recipes."
 msgstr ""
+"Pri urejanju in uvozu receptov uporabite mehka ujemanja na enotah, ključnih "
+"besedah in sestavinah."
 
 #: .\cookbook\forms.py:438
 msgid ""
 "Fields to search ignoring accents.  Selecting this option can improve or "
 "degrade search quality depending on language"
 msgstr ""
+"Polja za iskanje prezrtih naglasov. Če izberete to možnost, lahko izboljšate "
+"ali poslabšate kakovost iskanja, odvisno od jezika"
 
 #: .\cookbook\forms.py:440
 msgid ""
 "Fields to search for partial matches.  (e.g. searching for 'Pie' will return "
 "'pie' and 'piece' and 'soapie')"
 msgstr ""
+"Polja za iskanje delnih ujemajev. (npr. iskanje \"Pie\" vrne \"pie\" in "
+"\"piece\" in \"soapie\")"
 
 #: .\cookbook\forms.py:442
 msgid ""
 "Fields to search for beginning of word matches. (e.g. searching for 'sa' "
 "will return 'salad' and 'sandwich')"
 msgstr ""
+"Polja za iskanje začetka ujemanja besed. (npr. iskanje \"sa\" vrne \"salad\" "
+"in \"sandwich\")"
 
 #: .\cookbook\forms.py:444
 msgid ""
 "Fields to 'fuzzy' search. (e.g. searching for 'recpie' will find 'recipe'.)  "
 "Note: this option will conflict with 'web' and 'raw' methods of search."
 msgstr ""
+"Polja za \"mehko\" iskanje. (npr. iskanje \"recpie\" bo našlo \"recipe\".)"
 
 #: .\cookbook\forms.py:446
 msgid ""
@@ -2496,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/0159_add_shoppinglistentry_fields.py

@@ -140,5 +140,10 @@ class Migration(migrations.Migration):
             old_name='ignore_shopping',
             new_name='food_onhand',
         ),
+        migrations.AddField(
+            model_name='space',
+            name='show_facet_count',
+            field=models.BooleanField(default=False),
+        ),
         migrations.RunPython(copy_values_to_sle),
     ]

cookbook/migrations/0164_space_show_facet_count.py

@@ -10,9 +10,10 @@ class Migration(migrations.Migration):
     ]
 
     operations = [
-        migrations.AddField(
-            model_name='space',
-            name='show_facet_count',
-            field=models.BooleanField(default=False),
-        ),
+        # migrations.AddField(
+        #     model_name='space',
+        #     name='show_facet_count',
+        #     field=models.BooleanField(default=False),
+        # ),
+        # removed due to quick fix in 0159 migration to maintain correct order
     ]

cookbook/migrations/0168_add_unit_searchfields.py

@@ -0,0 +1,20 @@
+from django.db import migrations
+
+from cookbook.models import SearchFields
+
+
+def create_searchfields(apps, schema_editor):
+    SearchFields.objects.create(name='Units', field='steps__ingredients__unit__name')
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cookbook', '0167_userpreference_left_handed'),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            create_searchfields
+        ),
+    ]

cookbook/migrations/0169_exportlog.py

@@ -0,0 +1,35 @@
+# Generated by Django 3.2.11 on 2022-02-03 15:03
+
+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', '0168_add_unit_searchfields'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ExportLog',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('type', models.CharField(max_length=32)),
+                ('running', models.BooleanField(default=True)),
+                ('msg', models.TextField(default='')),
+                ('total_recipes', models.IntegerField(default=0)),
+                ('exported_recipes', models.IntegerField(default=0)),
+                ('cache_duration', models.IntegerField(default=0)),
+                ('possibly_not_expired', models.BooleanField(default=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('created_by', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+                ('space', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='cookbook.space')),
+            ],
+            bases=(models.Model, cookbook.models.PermissionModelMixin),
+        ),
+    ]

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')
@@ -609,7 +641,7 @@ class NutritionInformation(models.Model, PermissionModelMixin):
     )
     proteins = models.DecimalField(default=0, decimal_places=16, max_digits=32)
     calories = models.DecimalField(default=0, decimal_places=16, max_digits=32)
-    source = models.CharField( max_length=512, default="", null=True, blank=True)
+    source = models.CharField(max_length=512, default="", null=True, blank=True)
 
     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')
@@ -852,11 +883,12 @@ class ShoppingListEntry(ExportModelOperationsMixin('shopping_list_entry'), model
     def __str__(self):
         return f'Shopping list entry {self.id}'
 
-    # TODO deprecate
     def get_shared(self):
-        return self.shoppinglist_set.first().shared.all()
+        try:
+            return self.shoppinglist_set.first().shared.all()
+        except AttributeError:
+            return self.created_by.userpreference.shopping_share.all()
 
-    # TODO deprecate
     def get_owner(self):
         try:
             return self.created_by or self.shoppinglist_set.first().created_by
@@ -881,6 +913,12 @@ class ShoppingList(ExportModelOperationsMixin('shopping_list'), models.Model, Pe
     def __str__(self):
         return f'Shopping list {self.id}'
 
+    def get_shared(self):
+        try:
+            return self.shared.all() or self.created_by.userpreference.shopping_share.all()
+        except AttributeError:
+            return []
+
 
 class ShareLink(ExportModelOperationsMixin('share_link'), models.Model, PermissionModelMixin):
     recipe = models.ForeignKey(Recipe, on_delete=models.CASCADE)
@@ -996,6 +1034,26 @@ class ImportLog(models.Model, PermissionModelMixin):
         return f"{self.created_at}:{self.type}"
 
 
+class ExportLog(models.Model, PermissionModelMixin):
+    type = models.CharField(max_length=32)
+    running = models.BooleanField(default=True)
+    msg = models.TextField(default="")
+
+    total_recipes = models.IntegerField(default=0)
+    exported_recipes = models.IntegerField(default=0)
+    cache_duration = models.IntegerField(default=0)
+    possibly_not_expired = models.BooleanField(default=True)
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    created_by = models.ForeignKey(User, on_delete=models.CASCADE)
+
+    objects = ScopedManager(space='space')
+    space = models.ForeignKey(Space, on_delete=models.CASCADE)
+
+    def __str__(self):
+        return f"{self.created_at}:{self.type}"
+
+
 class BookmarkletImport(ExportModelOperationsMixin('bookmarklet_import'), models.Model, PermissionModelMixin):
     html = models.TextField()
     url = models.CharField(max_length=256, null=True, blank=True)
@@ -1051,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):
@@ -1093,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')
+        ]