update recipe scrapers

Fix import with recipe-scrapers

.env.template

@@ -86,8 +86,10 @@ GUNICORN_MEDIA=0
 # EMAIL_HOST_PASSWORD=
 # EMAIL_USE_TLS=0
 # EMAIL_USE_SSL=0
-# DEFAULT_FROM_EMAIL= # email sender address (default 'webmaster@localhost')
-# ACCOUNT_EMAIL_SUBJECT_PREFIX= # prefix used for account related emails (default "[Tandoor Recipes] ")
+# email sender address (default 'webmaster@localhost')
+# DEFAULT_FROM_EMAIL=
+# prefix used for account related emails (default "[Tandoor Recipes] ")
+# ACCOUNT_EMAIL_SUBJECT_PREFIX=
 
 # allow authentication via reverse proxy (e.g. authelia), leave off if you dont know what you are doing
 # see docs for more information https://vabene1111.github.io/recipes/features/authentication/

.github/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,6 +35,7 @@ jobs:
           publish: true
           imageName: vabene1111/recipes
           tag: beta
+          platform: linux/amd64,linux/arm64
           dockerUser: ${{ secrets.DOCKER_USERNAME }}
           dockerPassword: ${{ secrets.DOCKER_PASSWORD }}
       # Send discord notification

.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
           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,6 +40,7 @@ jobs:
         with:
           publish: true
           imageName: vabene1111/recipes
+          platform: linux/amd64,linux/arm64
           tag: ${{ steps.get_version.outputs.VERSION }}
           dockerUser: ${{ secrets.DOCKER_USERNAME }}
           dockerPassword: ${{ secrets.DOCKER_PASSWORD }}

.github/workflows/docs.yml

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

CONTRIBUTERS.md

@@ -1,7 +1,10 @@
+# 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.
@@ -20,46 +23,61 @@ Below are some of the larger contributions made yet.
 
 ## 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]
+[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
 

Dockerfile

@@ -15,7 +15,7 @@ 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 python3-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 && \

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

@@ -34,7 +34,7 @@ if [ "${DB_ENGINE}" != 'django.db.backends.sqlite3' ]; 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} -q; status=$?; attempt=$((attempt+1)); [ $status -ne 0 ] && [ $attempt -le $max_attempts ]; do
+  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

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')
     ))
 
 

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):
@@ -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

@@ -14,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 = {}
@@ -28,7 +31,7 @@ def get_from_scraper(scrape, request):
             recipe_json['name'] = ''
 
     try:
-        description = scrape.description()  or None
+        description = scrape.description() or None
     except Exception:
         description = None
     if not description:
@@ -37,7 +40,7 @@ def get_from_scraper(scrape, request):
         except Exception:
             description = ''
 
-    recipe_json['description'] = parse_description(description)
+    recipe_json['internal'] = True
 
     try:
         servings = scrape.yields() or None
@@ -48,34 +51,31 @@ def get_from_scraper(scrape, request):
             servings = scrape.schema.data.get('recipeYield') or 1
         except Exception:
             servings = 1
-    if type(servings) != int:
-        try:
-            servings = int(re.findall(r'\b\d+\b', servings)[0])
-        except Exception:
-            servings = 1
-    recipe_json['servings'] = max(servings, 1)
+
+    recipe_json['servings'] = parse_servings(servings)
+    recipe_json['servings_text'] = parse_servings_text(servings)
 
     try:
-        recipe_json['prepTime'] = get_minutes(scrape.prep_time()) or 0
+        recipe_json['working_time'] = get_minutes(scrape.prep_time()) or 0
     except Exception:
         try:
-            recipe_json['prepTime'] = get_minutes(scrape.schema.data.get("prepTime")) or 0
+            recipe_json['working_time'] = get_minutes(scrape.schema.data.get("prepTime")) or 0
         except Exception:
-            recipe_json['prepTime'] = 0
+            recipe_json['working_time'] = 0
     try:
-        recipe_json['cookTime'] = get_minutes(scrape.cook_time()) or 0
+        recipe_json['waiting_time'] = get_minutes(scrape.cook_time()) or 0
     except Exception:
         try:
-            recipe_json['cookTime'] = get_minutes(scrape.schema.data.get("cookTime")) or 0
+            recipe_json['waiting_time'] = get_minutes(scrape.schema.data.get("cookTime")) or 0
         except Exception:
-            recipe_json['cookTime'] = 0
+            recipe_json['waiting_time'] = 0
 
-    if recipe_json['cookTime'] + recipe_json['prepTime'] == 0:
+    if recipe_json['working_time'] + recipe_json['waiting_time'] == 0:
         try:
-            recipe_json['prepTime'] = get_minutes(scrape.total_time()) or 0
+            recipe_json['working_time'] = get_minutes(scrape.total_time()) or 0
         except Exception:
             try:
-                recipe_json['prepTime'] = 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
 
@@ -113,6 +113,21 @@ def get_from_scraper(scrape, request):
                 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:
@@ -120,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_text': 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_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.canonical_url():
-        recipe_json['url'] = scrape.canonical_url()
-        recipe_json['recipeInstructions'] += "\n\n" + _("Imported from") + ": " + scrape.canonical_url()
     return recipe_json
 
 
@@ -180,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_text': 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_text': 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:
@@ -310,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):
@@ -353,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.name)})
+                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/template_helper.py

@@ -39,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,
@@ -48,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/cookmate.py

@@ -0,0 +1,77 @@
+import base64
+import json
+from io import BytesIO
+
+from gettext import gettext as _
+
+import requests
+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:
+                response = requests.get(recipe_xml.find('imageurl').text.strip())
+                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

@@ -32,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
 

cookbook/integration/integration.py

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

cookbook/integration/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

@@ -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
 

cookbook/integration/paprika.py

@@ -6,6 +6,7 @@ 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 Ingredient, Keyword, Recipe, Step
 
@@ -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]

cookbook/integration/plantoeat.py

@@ -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/recipesage.py

@@ -77,14 +77,13 @@ class RecipeSage(Integration):
         }
 
         for s in recipe.steps.all():
-            if s.type != Step.TIME:
-                data['recipeInstructions'].append({
-                    '@type': 'HowToStep',
-                    'text': s.instruction
-                })
+            data['recipeInstructions'].append({
+                '@type': 'HowToStep',
+                'text': s.instruction
+            })
 
-                for i in s.ingredients.all():
-                    data['recipeIngredient'].append(f'{float(i.amount)} {i.unit} {i.food}')
+            for i in s.ingredients.all():
+                data['recipeIngredient'].append(f'{float(i.amount)} {i.unit} {i.food}')
 
         return data
 

cookbook/integration/rezkonv.py

@@ -12,33 +12,33 @@ 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)
@@ -60,7 +60,8 @@ 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_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():
             try:

cookbook/integration/saffron.py

@@ -71,11 +71,10 @@ 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:

cookbook/locale/fi/LC_MESSAGES/django.po

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

cookbook/locale/ro/LC_MESSAGES/django.po

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

cookbook/locale/ru/LC_MESSAGES/django.po

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

cookbook/locale/sl/LC_MESSAGES/django.po

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

cookbook/locale/zh_Hant/LC_MESSAGES/django.po

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

cookbook/managers.py

@@ -16,6 +16,7 @@ DICTIONARY = {
     'it': 'italian',
     # 'lv': 'Latvian',
     'es': 'spanish',
+    'sv': 'swedish',
 }
 
 

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

@@ -241,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):
@@ -337,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)
@@ -496,11 +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')
+    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)
@@ -533,7 +533,7 @@ class Food(ExportModelOperationsMixin('food'), TreeModel, PermissionModelMixin):
         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)
+            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)
@@ -593,6 +593,8 @@ class Ingredient(ExportModelOperationsMixin('ingredient'), models.Model, Permiss
     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')
 
@@ -663,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)
@@ -675,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)

cookbook/serializer.py

@@ -10,7 +10,9 @@ from drf_writable_nested import UniqueFieldsMixin, WritableNestedModelSerializer
 from rest_framework import serializers
 from rest_framework.exceptions import NotFound, ValidationError
 
+from cookbook.helper.CustomStorageClass import CachedS3Boto3Storage
 from cookbook.helper.HelperFunctions import str2bool
+from cookbook.helper.permission_helper import above_space_limit
 from cookbook.helper.shopping_helper import RecipeShoppingEditor
 from cookbook.models import (Automation, BookmarkletImport, Comment, CookLog, CustomFilter,
                              ExportLog, Food, FoodInheritField, ImportLog, Ingredient, Keyword,
@@ -20,7 +22,7 @@ from cookbook.models import (Automation, BookmarkletImport, Comment, CookLog, Cu
                              SupermarketCategory, SupermarketCategoryRelation, Sync, SyncLog, Unit,
                              UserFile, UserPreference, ViewLog)
 from cookbook.templatetags.custom_tags import markdown
-from recipes.settings import MEDIA_URL
+from recipes.settings import MEDIA_URL, AWS_ENABLED
 
 
 class ExtendedRecipeMixin(serializers.ModelSerializer):
@@ -41,7 +43,8 @@ class ExtendedRecipeMixin(serializers.ModelSerializer):
             api_serializer = None
         # extended values are computationally expensive and not needed in normal circumstances
         try:
-            if str2bool(self.context['request'].query_params.get('extended', False)) and self.__class__ == api_serializer:
+            if str2bool(
+                    self.context['request'].query_params.get('extended', False)) and self.__class__ == api_serializer:
                 return fields
         except (AttributeError, KeyError) as e:
             pass
@@ -54,7 +57,12 @@ class ExtendedRecipeMixin(serializers.ModelSerializer):
 
     def get_image(self, obj):
         if obj.recipe_image:
-            return MEDIA_URL + obj.recipe_image
+            if AWS_ENABLED:
+                storage = CachedS3Boto3Storage()
+                path = storage.url(obj.recipe_image)
+            else:
+                path = MEDIA_URL + obj.recipe_image
+            return path
 
 
 class CustomDecimalField(serializers.Field):
@@ -90,7 +98,8 @@ class CustomOnHandField(serializers.Field):
             shared_users = getattr(request, '_shared_users', None)
         if shared_users is None:
             try:
-                shared_users = [x.id for x in list(self.context['request'].user.get_shopping_share())] + [self.context['request'].user.id]
+                shared_users = [x.id for x in list(self.context['request'].user.get_shopping_share())] + [
+                    self.context['request'].user.id]
             except AttributeError:  # Anonymous users (using share links) don't have shared users
                 shared_users = []
         return obj.onhand_users.filter(id__in=shared_users).exists()
@@ -164,7 +173,8 @@ class FoodInheritFieldSerializer(WritableNestedModelSerializer):
 
 
 class UserPreferenceSerializer(WritableNestedModelSerializer):
-    food_inherit_default = FoodInheritFieldSerializer(source='space.food_inherit', many=True, allow_null=True, required=False, read_only=True)
+    food_inherit_default = FoodInheritFieldSerializer(source='space.food_inherit', many=True, allow_null=True,
+                                                      required=False, read_only=True)
     plan_share = UserNameSerializer(many=True, allow_null=True, required=False, read_only=True)
     shopping_share = UserNameSerializer(many=True, allow_null=True, required=False)
     food_children_exist = serializers.SerializerMethodField('get_food_children_exist')
@@ -183,9 +193,12 @@ class UserPreferenceSerializer(WritableNestedModelSerializer):
     class Meta:
         model = UserPreference
         fields = (
-            'user', 'theme', 'nav_color', 'default_unit', 'default_page', 'use_fractions', 'use_kj', 'search_style', 'show_recent', 'plan_share',
-            'ingredient_decimals', 'comments', 'shopping_auto_sync', 'mealplan_autoadd_shopping', 'food_inherit_default', 'default_delay',
-            'mealplan_autoinclude_related', 'mealplan_autoexclude_onhand', 'shopping_share', 'shopping_recent_days', 'csv_delim', 'csv_prefix',
+            'user', 'theme', 'nav_color', 'default_unit', 'default_page', 'use_fractions', 'use_kj', 'search_style',
+            'show_recent', 'plan_share',
+            'ingredient_decimals', 'comments', 'shopping_auto_sync', 'mealplan_autoadd_shopping',
+            'food_inherit_default', 'default_delay',
+            'mealplan_autoinclude_related', 'mealplan_autoexclude_onhand', 'shopping_share', 'shopping_recent_days',
+            'csv_delim', 'csv_prefix',
             'filter_to_supermarket', 'shopping_add_onhand', 'left_handed', 'food_children_exist'
         )
 
@@ -364,23 +377,29 @@ class SupermarketSerializer(UniqueFieldsMixin, SpacedModelSerializer):
         fields = ('id', 'name', 'description', 'category_to_supermarket')
 
 
-class RecipeSimpleSerializer(serializers.ModelSerializer):
+class RecipeSimpleSerializer(WritableNestedModelSerializer):
     url = serializers.SerializerMethodField('get_url')
 
     def get_url(self, obj):
         return reverse('view_recipe', args=[obj.id])
 
+    def create(self, validated_data):
+        # don't allow writing to Recipe via this API
+        return Recipe.objects.get(**validated_data)
+
+    def update(self, instance, validated_data):
+        # don't allow writing to Recipe via this API
+        return Recipe.objects.get(**validated_data)
+
     class Meta:
         model = Recipe
         fields = ('id', 'name', 'url')
-        read_only_fields = ['id', 'name', 'url']
 
 
 class FoodSimpleSerializer(serializers.ModelSerializer):
     class Meta:
         model = Food
         fields = ('id', 'name')
-        read_only_fields = ['id', 'name']
 
 
 class FoodSerializer(UniqueFieldsMixin, WritableNestedModelSerializer, ExtendedRecipeMixin):
@@ -403,7 +422,8 @@ class FoodSerializer(UniqueFieldsMixin, WritableNestedModelSerializer, ExtendedR
             shared_users = getattr(request, '_shared_users', None)
         if shared_users is None:
             try:
-                shared_users = [x.id for x in list(self.context['request'].user.get_shopping_share())] + [self.context['request'].user.id]
+                shared_users = [x.id for x in list(self.context['request'].user.get_shopping_share())] + [
+                    self.context['request'].user.id]
             except AttributeError:
                 shared_users = []
         filter = Q(id__in=obj.substitute.all())
@@ -427,6 +447,8 @@ class FoodSerializer(UniqueFieldsMixin, WritableNestedModelSerializer, ExtendedR
                 name=sc_name,
                 space=space, defaults=sm_category)
         onhand = validated_data.pop('food_onhand', None)
+        if recipe := validated_data.get('recipe', None):
+            validated_data['recipe'] = Recipe.objects.get(**recipe)
 
         # assuming if on hand for user also onhand for shopping_share users
         if not onhand is None:
@@ -472,11 +494,15 @@ class FoodSerializer(UniqueFieldsMixin, WritableNestedModelSerializer, ExtendedR
         read_only_fields = ('id', 'numchild', 'parent', 'image', 'numrecipe')
 
 
-class IngredientSerializer(WritableNestedModelSerializer):
-    food = FoodSerializer(allow_null=True)
+class IngredientSimpleSerializer(WritableNestedModelSerializer):
+    food = FoodSimpleSerializer(allow_null=True)
     unit = UnitSerializer(allow_null=True)
+    used_in_recipes = serializers.SerializerMethodField('get_used_in_recipes')
     amount = CustomDecimalField()
 
+    def get_used_in_recipes(self, obj):
+        return list(Recipe.objects.filter(steps__ingredients=obj.id).values('id', 'name'))
+
     def create(self, validated_data):
         validated_data['space'] = self.context['request'].space
         return super().create(validated_data)
@@ -489,10 +515,14 @@ class IngredientSerializer(WritableNestedModelSerializer):
         model = Ingredient
         fields = (
             'id', 'food', 'unit', 'amount', 'note', 'order',
-            'is_header', 'no_amount', 'original_text'
+            'is_header', 'no_amount', 'original_text', 'used_in_recipes',
         )
 
 
+class IngredientSerializer(IngredientSimpleSerializer):
+    food = FoodSerializer(allow_null=True)
+
+
 class StepSerializer(WritableNestedModelSerializer, ExtendedRecipeMixin):
     ingredients = IngredientSerializer(many=True)
     ingredients_markdown = serializers.SerializerMethodField('get_ingredients_markdown')
@@ -615,11 +645,17 @@ class RecipeSerializer(RecipeBaseSerializer):
         model = Recipe
         fields = (
             'id', 'name', 'description', 'image', 'keywords', 'steps', 'working_time',
-            'waiting_time', 'created_by', 'created_at', 'updated_at',
+            'waiting_time', 'created_by', 'created_at', 'updated_at','source_url',
             'internal', 'nutrition', 'servings', 'file_path', 'servings_text', 'rating', 'last_cooked',
         )
         read_only_fields = ['image', 'created_by', 'created_at']
 
+    def validate(self, data):
+        above_limit, msg = above_space_limit(self.context['request'].space)
+        if above_limit:
+            raise serializers.ValidationError(msg)
+        return super().validate(data)
+
     def create(self, validated_data):
         validated_data['created_by'] = self.context['request'].user
         validated_data['space'] = self.context['request'].space
@@ -627,9 +663,12 @@ class RecipeSerializer(RecipeBaseSerializer):
 
 
 class RecipeImageSerializer(WritableNestedModelSerializer):
+    image = serializers.ImageField(required=False, allow_null=True)
+    image_url = serializers.CharField(max_length=4096, required=False, allow_null=True)
+
     class Meta:
         model = Recipe
-        fields = ['image', ]
+        fields = ['image', 'image_url', ]
 
 
 class RecipeImportSerializer(SpacedModelSerializer):
@@ -684,7 +723,8 @@ class RecipeBookEntrySerializer(serializers.ModelSerializer):
     def create(self, validated_data):
         book = validated_data['book']
         recipe = validated_data['recipe']
-        if not book.get_owner() == self.context['request'].user and not self.context['request'].user in book.get_shared():
+        if not book.get_owner() == self.context['request'].user and not self.context[
+                                                                            'request'].user in book.get_shared():
             raise NotFound(detail=None, code=None)
         obj, created = RecipeBookEntry.objects.get_or_create(book=book, recipe=recipe)
         return obj
@@ -713,7 +753,7 @@ class MealPlanSerializer(SpacedModelSerializer, WritableNestedModelSerializer):
     def create(self, validated_data):
         validated_data['created_by'] = self.context['request'].user
         mealplan = super().create(validated_data)
-        if self.context['request'].data.get('addshopping', False):
+        if self.context['request'].data.get('addshopping', False) and self.context['request'].data.get('recipe', None):
             SLR = RecipeShoppingEditor(user=validated_data['created_by'], space=validated_data['space'])
             SLR.create(mealplan=mealplan, servings=validated_data['servings'])
         return mealplan
@@ -737,13 +777,14 @@ class ShoppingListRecipeSerializer(serializers.ModelSerializer):
     def get_name(self, obj):
         if not isinstance(value := obj.servings, Decimal):
             value = Decimal(value)
-        value = value.quantize(Decimal(1)) if value == value.to_integral() else value.normalize()  # strips trailing zero
+        value = value.quantize(
+            Decimal(1)) if value == value.to_integral() else value.normalize()  # strips trailing zero
         return (
-            obj.name
-            or getattr(obj.mealplan, 'title', None)
-            or (d := getattr(obj.mealplan, 'date', None)) and ': '.join([obj.mealplan.recipe.name, str(d)])
-            or obj.recipe.name
-        ) + f' ({value:.2g})'
+                       obj.name
+                       or getattr(obj.mealplan, 'title', None)
+                       or (d := getattr(obj.mealplan, 'date', None)) and ': '.join([obj.mealplan.recipe.name, str(d)])
+                       or obj.recipe.name
+               ) + f' ({value:.2g})'
 
     def update(self, instance, validated_data):
         # TODO remove once old shopping list
@@ -814,7 +855,8 @@ class ShoppingListEntrySerializer(WritableNestedModelSerializer):
     class Meta:
         model = ShoppingListEntry
         fields = (
-            'id', 'list_recipe', 'food', 'unit', 'ingredient', 'ingredient_note', 'amount', 'order', 'checked', 'recipe_mealplan',
+            'id', 'list_recipe', 'food', 'unit', 'ingredient', 'ingredient_note', 'amount', 'order', 'checked',
+            'recipe_mealplan',
             'created_by', 'created_at', 'completed_at', 'delay_until'
         )
         read_only_fields = ('id', 'created_by', 'created_at',)
@@ -912,7 +954,10 @@ class ExportLogSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = ExportLog
-        fields = ('id', 'type', 'msg', 'running', 'total_recipes', 'exported_recipes', 'cache_duration', 'possibly_not_expired', 'created_by', 'created_at')
+        fields = (
+            'id', 'type', 'msg', 'running', 'total_recipes', 'exported_recipes', 'cache_duration',
+            'possibly_not_expired',
+            'created_by', 'created_at')
         read_only_fields = ('created_by',)
 
 
@@ -933,12 +978,19 @@ class AutomationSerializer(serializers.ModelSerializer):
 # CORS, REST and Scopes aren't currently working
 # Scopes are evaluating before REST has authenticated the user assigning a None space
 # I've made the change below to fix the bookmarklet, other serializers likely need a similar/better fix
-class BookmarkletImportSerializer(serializers.ModelSerializer):
+class BookmarkletImportListSerializer(serializers.ModelSerializer):
     def create(self, validated_data):
         validated_data['created_by'] = self.context['request'].user
         validated_data['space'] = self.context['request'].user.userpreference.space
         return super().create(validated_data)
 
+    class Meta:
+        model = BookmarkletImport
+        fields = ('id', 'url', 'created_by', 'created_at')
+        read_only_fields = ('created_by', 'space')
+
+
+class BookmarkletImportSerializer(BookmarkletImportListSerializer):
     class Meta:
         model = BookmarkletImport
         fields = ('id', 'url', 'html', 'created_by', 'created_at')
@@ -1024,10 +1076,12 @@ class RecipeExportSerializer(WritableNestedModelSerializer):
 
 
 class RecipeShoppingUpdateSerializer(serializers.ModelSerializer):
-    list_recipe = serializers.IntegerField(write_only=True, allow_null=True, required=False, help_text=_("Existing shopping list to update"))
+    list_recipe = serializers.IntegerField(write_only=True, allow_null=True, required=False,
+                                           help_text=_("Existing shopping list to update"))
     ingredients = serializers.IntegerField(write_only=True, allow_null=True, required=False, help_text=_(
         "List of ingredient IDs from the recipe to add, if not provided all ingredients will be added."))
-    servings = serializers.IntegerField(default=1, write_only=True, allow_null=True, required=False, help_text=_("Providing a list_recipe ID and servings of 0 will delete that shopping list."))
+    servings = serializers.IntegerField(default=1, write_only=True, allow_null=True, required=False, help_text=_(
+        "Providing a list_recipe ID and servings of 0 will delete that shopping list."))
 
     class Meta:
         model = Recipe
@@ -1035,9 +1089,12 @@ class RecipeShoppingUpdateSerializer(serializers.ModelSerializer):
 
 
 class FoodShoppingUpdateSerializer(serializers.ModelSerializer):
-    amount = serializers.IntegerField(write_only=True, allow_null=True, required=False, help_text=_("Amount of food to add to the shopping list"))
-    unit = serializers.IntegerField(write_only=True, allow_null=True, required=False, help_text=_("ID of unit to use for the shopping list"))
-    delete = serializers.ChoiceField(choices=['true'], write_only=True, allow_null=True, allow_blank=True, help_text=_("When set to true will delete all food from active shopping lists."))
+    amount = serializers.IntegerField(write_only=True, allow_null=True, required=False,
+                                      help_text=_("Amount of food to add to the shopping list"))
+    unit = serializers.IntegerField(write_only=True, allow_null=True, required=False,
+                                    help_text=_("ID of unit to use for the shopping list"))
+    delete = serializers.ChoiceField(choices=['true'], write_only=True, allow_null=True, allow_blank=True,
+                                     help_text=_("When set to true will delete all food from active shopping lists."))
 
     class Meta:
         model = Recipe

cookbook/signals.py

@@ -104,21 +104,32 @@ def update_food_inheritance(sender, instance=None, created=False, **kwargs):
 
 @receiver(post_save, sender=MealPlan)
 def auto_add_shopping(sender, instance=None, created=False, weak=False, **kwargs):
+    print("MEAL_AUTO_ADD Signal trying to auto add to shopping")
     if not instance:
-        return
-    user = instance.get_owner()
-    with scope(space=instance.space):
-        slr_exists = instance.shoppinglistrecipe_set.exists()
-
-    if not created and slr_exists:
-        for x in instance.shoppinglistrecipe_set.all():
-            # assuming that permissions checks for the MealPlan have happened upstream
-            if instance.servings != x.servings:
-                SLR = RecipeShoppingEditor(id=x.id, user=user, space=instance.space)
-                SLR.edit_servings(servings=instance.servings)
-    elif not user.userpreference.mealplan_autoadd_shopping or not instance.recipe:
+        print("MEAL_AUTO_ADD Instance is none")
         return
 
-    if created:
-        SLR = RecipeShoppingEditor(user=user, space=instance.space)
-        SLR.create(mealplan=instance, servings=instance.servings)
+    try:
+        space = instance.get_space()
+        user = instance.get_owner()
+        with scope(space=space):
+            slr_exists = instance.shoppinglistrecipe_set.exists()
+
+        if not created and slr_exists:
+            for x in instance.shoppinglistrecipe_set.all():
+                # assuming that permissions checks for the MealPlan have happened upstream
+                if instance.servings != x.servings:
+                    SLR = RecipeShoppingEditor(id=x.id, user=user, space=instance.space)
+                    SLR.edit_servings(servings=instance.servings)
+        elif not user.userpreference.mealplan_autoadd_shopping or not instance.recipe:
+            print("MEAL_AUTO_ADD No recipe or no setting")
+            return
+
+        if created:
+            SLR = RecipeShoppingEditor(user=user, space=space)
+            SLR.create(mealplan=instance, servings=instance.servings)
+            print("MEAL_AUTO_ADD Created SLR")
+    except AttributeError:
+        pass
+
+

cookbook/static/css/app.min.css

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

cookbook/tables.py

@@ -3,8 +3,8 @@ from django.utils.html import format_html
 from django.utils.translation import gettext as _
 from django_tables2.utils import A
 
-from .models import (CookLog, InviteLink, Keyword, Recipe, RecipeImport,
-                     ShoppingList, Storage, Sync, SyncLog, ViewLog)
+from .models import (CookLog, InviteLink, Recipe, RecipeImport,
+                     Storage, Sync, SyncLog, ViewLog)
 
 
 class ImageUrlColumn(tables.Column):
@@ -121,14 +121,6 @@ class RecipeImportTable(tables.Table):
         fields = ('id', 'name', 'file_path')
 
 
-class ShoppingListTable(tables.Table):
-    id = tables.LinkColumn('view_shopping', args=[A('id')])
-
-    class Meta:
-        model = ShoppingList
-        template_name = 'generic/table_template.html'
-        fields = ('id', 'finished', 'created_by', 'created_at')
-
 
 class InviteLinkTable(tables.Table):
     link = tables.TemplateColumn(

cookbook/templates/account/login.html

@@ -68,6 +68,7 @@
 
     <script>
         $('#id_login').focus()
+        $('#id_remember').prop('checked', true);
     </script>
 
 {% endblock %}

cookbook/templates/base.html

@@ -56,21 +56,46 @@
     {% block extra_head %} <!-- block for templates to put stuff into header -->
     {% endblock %}
 
+    <style>
+        {% if request.user.userpreference.left_handed %}
+            @media screen and (max-width: 600px) {
+                #switcher .btn-circle {
+                    left: 80px !important;
+                }
+            }
+        {% endif %}
+    </style>
+
 </head>
 <body>
 
-<nav class="navbar navbar-expand-lg navbar-dark bg-{% nav_color request %} bg-header" id="id_main_nav"
+<nav class="navbar navbar-expand-lg navbar-dark bg-{% nav_color request %} bg-header"
+     id="id_main_nav"
      style="{% sticky_nav request %}">
+
+    {% if not request.user.userpreference.left_handed %}
+        {% if not request.user.is_authenticated or request.user.userpreference.theme == request.user.userpreference.TANDOOR %}
+            <a class="navbar-brand p-0 me-2 justify-content-center" href="{% base_path request 'base' %}"
+               aria-label="Tandoor">
+                <img class="brand-icon" src="{% static 'assets/brand_logo.png' %}" alt="Logo">
+            </a>
+        {% endif %}
+    {% endif %}
+
     <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarText"
             aria-controls="navbarText" aria-expanded="false" aria-label="Toggle navigation">
         <span class="navbar-toggler-icon"></span>
     </button>
 
-    {% if not request.user.is_authenticated or request.user.userpreference.theme == request.user.userpreference.TANDOOR %}
-        <a class="navbar-brand p-0 me-2 justify-content-center" href="{% base_path request 'base' %}" aria-label="Tandoor">
-            <img class="brand-icon" src="{% static 'assets/brand_logo.png' %}" alt="" style="height: 5vh;">
-        </a>
+    {% if request.user.userpreference.left_handed %}
+        {% if not request.user.is_authenticated or request.user.userpreference.theme == request.user.userpreference.TANDOOR %}
+            <a class="navbar-brand p-0 me-2 justify-content-center" href="{% base_path request 'base' %}"
+               aria-label="Tandoor">
+                <img class="brand-icon" src="{% static 'assets/brand_logo.svg' %}" alt="Logo">
+            </a>
+        {% endif %}
     {% endif %}
+
     <div class="collapse navbar-collapse" id="navbarText">
         <ul class="navbar-nav mr-auto">
             <li class="nav-item {% if request.resolver_match.url_name in 'view_search' %}active{% endif %}">
@@ -102,129 +127,140 @@
                         <i class="fas fa-toolbox fa-lg"></i>
                     </a>
                     <div class="dropdown-menu dropdown-menu-center dropdown-menu-center-large">
-                        <div class="row m-0">
+                        <div class="row m-0 mt-2 mt-md-0">
                             <div class="col-4">
-                                <a href="{% url 'list_keyword' %}" class="p-1">
+                                <a href="{% url 'list_keyword' %}" class="p-0 p-md-1">
                                     <div class="card p-0 no-gutters border-0">
                                         <div class="card-body text-center p-0 no-gutters">
                                             <i class="fas fa-tags fa-2x"></i>
                                         </div>
-                                        <div class="card-body text-break text-center p-0 no-gutters text-muted">
+                                        <div class="card-body text-break text-center p-0 no-gutters text-muted menu-dropdown-text">
                                             {% trans 'Keyword' %}
                                         </div>
                                     </div>
                                 </a>
                             </div>
                             <div class="col-4">
-                                <a href="{% url 'list_food' %}" class="p-1">
+                                <a href="{% url 'list_food' %}" class="p-0 p-md-1">
                                     <div class="card p-0 no-gutters border-0">
                                         <div class="card-body text-center p-0 no-gutters">
                                             <i class="fas fa-leaf fa-2x"></i>
                                         </div>
-                                        <div class="card-body text-break text-center p-0 no-gutters text-muted">
+                                        <div class="card-body text-break text-center p-0 no-gutters text-muted menu-dropdown-text">
                                             {% trans 'Foods' %}
                                         </div>
                                     </div>
                                 </a>
                             </div>
                             <div class="col-4">
-                                <a href="{% url 'list_unit' %}" class="p-1">
+                                <a href="{% url 'list_unit' %}" class="p-0 p-md-1">
                                     <div class="card p-0 no-gutters border-0">
                                         <div class="card-body text-center p-0 no-gutters">
                                             <i class="fas fa-balance-scale fa-2x"></i>
                                         </div>
-                                        <div class="card-body text-break text-center p-0 no-gutters text-muted">
+                                        <div class="card-body text-break text-center p-0 no-gutters text-muted menu-dropdown-text">
                                             {% trans 'Units' %}
                                         </div>
                                     </div>
                                 </a>
                             </div>
                         </div>
-                        <div class="row m-0">
+                        <div class="row m-0 mt-2 mt-md-0">
                             <div class="col-4">
-                                <a href="{% url 'list_supermarket' %}" class="p-1">
+                                <a href="{% url 'list_supermarket' %}" class="p-0 p-md-1">
                                     <div class="card p-0 no-gutters border-0">
                                         <div class="card-body text-center p-0 no-gutters">
                                             <i class="fas fa-store-alt fa-2x"></i>
                                         </div>
-                                        <div class="card-body text-break text-center p-0 no-gutters text-muted">
+                                        <div class="card-body text-break text-center p-0 no-gutters text-muted menu-dropdown-text">
                                             {% trans 'Supermarket' %}
                                         </div>
                                     </div>
                                 </a>
                             </div>
                             <div class="col-4">
-                                <a href="{% url 'list_supermarket_category' %}" class="p-1">
+                                <a href="{% url 'list_supermarket_category' %}" class="p-0 p-md-1">
                                     <div class="card p-0 no-gutters border-0">
                                         <div class="card-body text-center p-0 no-gutters">
                                             <i class="fas fa-cubes fa-2x"></i>
                                         </div>
-                                        <div class="card-body text-break text-center p-0 no-gutters text-muted">
+                                        <div class="card-body text-break text-center p-0 no-gutters text-muted menu-dropdown-text">
                                             {% trans 'Supermarket Category' %}
                                         </div>
                                     </div>
                                 </a>
                             </div>
                             <div class="col-4">
-                                <a href="{% url 'list_automation' %}" class="p-1">
+                                <a href="{% url 'list_automation' %}" class="p-0 p-md-1">
                                     <div class="card p-0 no-gutters border-0">
                                         <div class="card-body text-center p-0 no-gutters">
                                             <i class="fas fa-robot fa-2x"></i>
                                         </div>
-                                        <div class="card-body text-break text-center p-0 no-gutters text-muted">
+                                        <div class="card-body text-break text-center p-0 no-gutters text-muted menu-dropdown-text">
                                             {% trans 'Automations' %}
                                         </div>
                                     </div>
                                 </a>
                             </div>
                         </div>
-                        <div class="row m-0">
+                        <div class="row m-0 mt-2 mt-md-0">
                             <div class="col-4">
-                                <a href="{% url 'list_user_file' %}" class="p-1">
+                                <a href="{% url 'list_user_file' %}" class="p-0 p-md-1">
                                     <div class="card p-0 no-gutters border-0">
                                         <div class="card-body text-center p-0 no-gutters">
                                             <i class="fas fa-file fa-2x"></i>
                                         </div>
-                                        <div class="card-body text-break text-center p-0 no-gutters text-muted">
+                                        <div class="card-body text-break text-center p-0 no-gutters text-muted menu-dropdown-text">
                                             {% trans 'Files' %}
                                         </div>
                                     </div>
                                 </a>
                             </div>
                             <div class="col-4">
-                                <a href="{% url 'data_batch_edit' %}" class="p-1">
+                                <a href="{% url 'data_batch_edit' %}" class="p-0 p-md-1">
                                     <div class="card p-0 no-gutters border-0">
                                         <div class="card-body text-center p-0 no-gutters">
                                             <i class="fas fa-edit fa-2x"></i>
                                         </div>
-                                        <div class="card-body text-break text-center p-0 no-gutters text-muted">
+                                        <div class="card-body text-break text-center p-0 no-gutters text-muted menu-dropdown-text">
                                             {% trans 'Batch Edit' %}
                                         </div>
                                     </div>
                                 </a>
                             </div>
                             <div class="col-4">
-                                <a href="{% url 'view_history' %}" class="p-1">
+                                <a href="{% url 'view_history' %}" class="p-0 p-md-1">
                                     <div class="card p-0 no-gutters border-0">
                                         <div class="card-body text-center p-0 no-gutters">
                                             <i class="fas fa-history fa-2x"></i>
                                         </div>
-                                        <div class="card-body text-break text-center p-0 no-gutters text-muted">
+                                        <div class="card-body text-break text-center p-0 no-gutters text-muted menu-dropdown-text">
                                             {% trans 'History' %}
                                         </div>
                                     </div>
                                 </a>
                             </div>
-
                         </div>
-                        <div class="row m-0">
+                        <div class="row m-0 mt-2 mt-md-0">
                             <div class="col-4">
-                                <a href="{% url 'view_export' %}" class="p-1">
+                                <a href="{% url 'view_ingredient_editor' %}" class="p-0 p-md-1">
+                                    <div class="card p-0 no-gutters border-0">
+                                        <div class="card-body text-center p-0 no-gutters">
+                                            <i class="fas fa-th-list fa-2x"></i>
+                                        </div>
+                                        <div class="card-body text-break text-center p-0 no-gutters text-muted menu-dropdown-text">
+                                            {% trans 'Ingredient Editor' %}
+                                        </div>
+                                    </div>
+                                </a>
+                            </div>
+                            <div class="col-4">
+                                <a href="{% url 'view_export' %}" class="p-0 p-md-1">
                                     <div class="card p-0 no-gutters border-0">
                                         <div class="card-body text-center p-0 no-gutters">
                                             <i class="fas fa-file-export fa-2x"></i>
                                         </div>
-                                        <div class="card-body text-break text-center p-0 no-gutters text-muted">
+                                        <div class="card-body text-break text-center p-0 no-gutters text-muted menu-dropdown-text">
                                             {% trans 'Export' %}
                                         </div>
                                     </div>
@@ -301,7 +337,14 @@
     </div>
 {% endif %}
 
-<div class="container-fluid mt-2 mt-md-5 mt-xl-5 mt-lg-5" id="id_base_container">
+{% if HOSTED and request.space.max_recipes == 10 %}
+    <div class="bg-warning" style=" width: 100%; text-align: center!important; color: #ffffff; padding: 8px">
+        {% trans 'You are using the free version of Tandor' %} <a class="btn-success btn-sm" href="https://tandoor.dev/manage">{% trans 'Upgrade Now' %}</a>
+    </div>
+{% endif %}
+
+<div class="container-fluid mt-2 mt-md-5 mt-xl-5 mt-lg-5{% if request.user.userpreference.left_handed %} left-handed {% endif %}"
+     id="id_base_container">
     <div class="row">
         <div class="col-xl-2 d-none d-xl-block">
             {% block content_xl_left %}
@@ -336,7 +379,7 @@
     {% block content_fluid %}
     {% endblock %}
 
-    {% user_prefs request as prefs%}
+    {% user_prefs request as prefs %}
     {{ prefs|json_script:'user_preference' }}
 
 </div>

cookbook/templates/generic/list_template.html

@@ -26,15 +26,6 @@
                 {% endif %}
             </h3>
         </span>
-        {% if request.resolver_match.url_name in 'list_shopping_list' %}
-            <span class="col-md-3">
-                <a href="{% url 'view_shopping_new' %}" class="float-right">
-                    <button class="btn btn-outline-secondary shadow-none">
-                        <i class="fas fa-star"></i> {% trans 'Try the new shopping list' %}
-                    </button>
-                </a>
-            </span>
-        {% endif %}
 
         {% if filter %}
             <br/>

cookbook/templates/ingredient_editor.html

@@ -4,12 +4,18 @@
 {% load i18n %}
 {% load l10n %}
 
-{% block title %}{% trans 'Meal-Plan' %}{% endblock %}
+{% block title %}{% trans 'Ingredient Editor' %}{% endblock %}
 
-{% block content_fluid %}
+{% block content %}
 
+    <div class="row">
+        <div class="col col-md-12">
+            <h3>{% trans 'Ingredient Editor' %}</h3>
+        </div>
+    </div>
     <div id="app">
-        <meal-plan-view></meal-plan-view>
+
+        <ingredient-editor-view></ingredient-editor-view>
     </div>
 
 
@@ -24,13 +30,10 @@
     {% endif %}
 
     <script type="application/javascript">
-        window.IMAGE_PLACEHOLDER = "{% static 'assets/recipe_no_image.svg' %}"
-
+        window.DEFAULT_FOOD = {{ food_id }}
+        window.DEFAULT_UNIT = {{ unit_id }}
         window.CUSTOM_LOCALE = '{{ request.LANGUAGE_CODE }}'
-
-        window.ICAL_URL = '{% url 'api_get_plan_ical' 12345 6789 %}'
-        window.SHOPPING_URL = '{% url 'view_shopping' %}'
     </script>
 
-    {% render_bundle 'meal_plan_view' %}
+    {% render_bundle 'ingredient_editor_view' %}
 {% endblock %}

cookbook/templates/openid/login.html

@@ -0,0 +1,39 @@
+{% extends "base.html" %}
+{% load crispy_forms_filters %}
+{% load i18n %}
+{% load static %}
+
+{% load account socialaccount %}
+
+{% block title %}OpenID {% trans 'Login' %}{% endblock %}
+
+{% block content %}
+
+
+    <div class="row">
+        <div class="col-12" style="text-align: center">
+            <h3>{% trans "Sign In" %}</h3>
+        </div>
+    </div>
+
+
+    <div class="row">
+        <div class="col-sm-12 col-lg-6 col-md-6 offset-lg-3 offset-md-3">
+            <hr>
+            <form id="openid_login_form" class="openid_login" method="post" action="{% url 'openid_login' %}">
+                {% csrf_token %}
+                {{ form | crispy }}
+                <button class="btn btn-success" type="submit">{% trans "Sign In" %}</button>
+                <a class="btn btn-secondary" href="{% url 'account_login' %}">{% trans "Back" %}</a>
+            </form>
+        </div>
+    </div>
+
+
+    <script>
+        $('#id_openid').focus()
+    </script>
+
+{% endblock %}
+
+

cookbook/templates/setup.html

@@ -20,4 +20,8 @@
         <button class="btn btn-success" type="submit"><i class="fas fa-save"></i> {% trans 'Create Superuser account' %}</button>
     </form>
 
+     <script>
+        $('#id_name').focus()
+    </script>
+
 {% endblock %}

cookbook/templates/shopping_list.html

@@ -1,921 +0,0 @@
-{% extends "base.html" %}
-{% comment %} TODO: Deprecate {% endcomment %}
-{% load django_tables2 %}
-{% load crispy_forms_tags %}
-{% load static %}
-{% load i18n %}
-{% block title %}{% trans "Shopping List" %}{% endblock %}
-{% block extra_head %}
-{% include 'include/vue_base.html' %}
-
-<link rel="stylesheet" href="{% static 'css/vue-multiselect-bs4.min.css' %}" />
-<script src="{% static 'js/vue-multiselect.min.js' %}"></script>
-
-<script src="{% static 'js/Sortable.min.js' %}"></script>
-<script src="{% static 'js/vuedraggable.umd.min.js' %}"></script>
-
-<script src="{% static 'js/vue-cookies.js' %}"></script>
-
-<script src="{% static 'js/js.cookie.min.js' %}"></script>
-
-<link rel="stylesheet" href="{% static 'css/pretty-checkbox.min.css' %}" />
-{% endblock %}
-
-{% block content %}
-
-<div class="row">
-    <span class="col col-md-9">
-        <h2>{% trans 'Shopping List' %}</h2>
-    </span>
-    <span class="col-md-3">
-        <a href="{% url 'view_shopping_new' %}" class="float-right">
-            <button class="btn btn-outline-secondary shadow-none"><i class="fas fa-star"></i> {% trans 'Try the new shopping list' %}</button>
-        </a>
-    </span>
-    <div class="col col-mdd-3 text-right">
-        <b-form-checkbox switch size="lg" v-model="edit_mode" @change="$forceUpdate()">{% trans 'Edit' %}</b-form-checkbox>
-    </div>
-</div>
-
-<template v-if="shopping_list !== undefined">
-    <div class="text-center" v-if="loading">
-        {% if not request.user.is_authenticated or request.user.userpreference.theme == request.user.userpreference.TANDOOR %}
-        <img class="spinner-tandoor" />
-        {% else %}
-        <i class="fas fa-spinner fa-spin fa-8x"></i>
-        {% endif %}
-    </div>
-    <div v-else-if="edit_mode">
-        <div class="row">
-            <div class="col col-md-6">
-                <div class="card">
-                    <div class="card-header"><i class="fa fa-search"></i> {% trans 'Search' %}</div>
-                    <div class="card-body">
-                        <input type="text" class="form-control" v-model="recipe_query" @keyup="getRecipes" placeholder="{% trans 'Search Recipe' %}" />
-                        <ul class="list-group" style="margin-top: 8px">
-                            <li class="list-group-item" v-for="x in recipes">
-                                <div class="row flex-row" style="padding-left: 0.5vw; padding-right: 0.5vw">
-                                    <div class="flex-column flex-fill my-auto"><a v-bind:href="getRecipeUrl(x.id)" target="_blank" rel="nofollow norefferer">[[x.name]]</a></div>
-                                    <div class="flex-column align-self-end">
-                                        <button class="btn btn-outline-primary shadow-none" @click="addRecipeToList(x)"><i class="fa fa-plus"></i></button>
-                                    </div>
-                                </div>
-                            </li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-
-            <div class="col col-md-6">
-                <div class="card">
-                    <div class="card-header"><i class="fa fa-shopping-cart"></i> {% trans 'Shopping Recipes' %}</div>
-                    <div class="card-body">
-                        <template v-if="shopping_list.recipes.length < 1"> {% trans 'No recipes selected' %} </template>
-                        <template v-else>
-                            <div class="row flex-row my-auto" v-for="x in shopping_list.recipes" style="margin-top: 1vh !important">
-                                <div class="flex-column align-self-start" style="margin-right: 0.4vw">
-                                    <button class="btn btn-outline-danger" @click="removeRecipeFromList(x)"><i class="fa fa-trash"></i></button>
-                                </div>
-                                <div class="flex-grow-1 flex-column my-auto">
-                                    <a v-bind:href="getRecipeUrl(x.recipe)" target="_blank" rel="nofollow norefferer">[[x.recipe_name]]</a>
-                                </div>
-                                <div class="flex-column align-self-end">
-                                    <div class="input-group input-group-sm my-auto">
-                                        <div class="input-group-prepend">
-                                            <button class="text-muted btn btn-outline-primary shadow-none" @click="((x.servings - 1) > 0) ? x.servings -= 1 : 1">-</button>
-                                        </div>
-                                        <input class="form-control" type="number" v-model="x.servings" />
-                                        <div class="input-group-append">
-                                            <button class="text-muted btn btn-outline-primary shadow-none" @click="x.servings += 1">+</button>
-                                        </div>
-                                    </div>
-                                </div>
-                            </div>
-                        </template>
-                    </div>
-                </div>
-            </div>
-        </div>
-
-        <table class="table table-sm" style="margin-top: 1vh">
-            <template v-for="c in display_categories">
-                <thead>
-                    <tr>
-                        <th colspan="5">[[c.name]]</th>
-                    </tr>
-                </thead>
-                <tbody is="draggable" :list="c.entries" tag="tbody" group="people" @sort="sortEntries" @change="dragChanged(c, $event)" handle=".handle">
-                    <tr v-for="(element, index) in c.entries" :key="element.id" v-bind:class="{ 'text-muted': element.checked }">
-                        <td class="handle"><i class="fas fa-sort"></i></td>
-                        <td>[[element.amount.toFixed(2)]]</td>
-                        <td>[[element.unit.name]]</td>
-                        <td>[[element.food.name]]</td>
-                        <td>
-                            <button
-                                class="btn btn-sm btn-outline-danger"
-                                v-if="element.list_recipe === null"
-                                @click="shopping_list.entries = shopping_list.entries.filter(item => item.id !== element.id)"
-                            >
-                                <i class="fa fa-trash"></i>
-                            </button>
-                        </td>
-                    </tr>
-                </tbody>
-            </template>
-        </table>
-
-        <div class="row" style="text-align: right">
-            <div class="col">
-                <b-form-checkbox switch v-model="entry_mode_simple" @change="$cookies.set('shopping_entry_mode_simple',!entry_mode_simple, -1)"
-                    >{% trans 'Entry Mode' %}</b-form-checkbox
-                >
-            </div>
-        </div>
-
-        <div class="row" v-if="entry_mode_simple" style="margin-top: 2vh">
-            <div class="col-12">
-                <form v-on:submit.prevent="addSimpleEntry()">
-                    <label for="id_simple_entry">{% trans 'Add Entry' %}</label>
-                    <div class="input-group">
-                        <input id="id_simple_entry" class="form-control" v-model="simple_entry" />
-                        <div class="input-group-append">
-                            <button class="btn btn-outline-secondary" type="button" @click="addSimpleEntry()"><i class="fa fa-plus"></i></button>
-                        </div>
-                    </div>
-                </form>
-            </div>
-        </div>
-
-        <div class="row" v-if="!entry_mode_simple" style="margin-top: 2vh">
-            <div class="col-12 col-lg-3">
-                <input id="id_advanced_entry" class="form-control" type="number" placeholder="{% trans 'Amount' %}" v-model="new_entry.amount" ref="new_entry_amount" />
-            </div>
-            <div class="col-12 col-lg-4">
-                <multiselect
-                    v-tabindex
-                    ref="unit"
-                    v-model="new_entry.unit"
-                    :options="units"
-                    :close-on-select="true"
-                    :clear-on-select="true"
-                    :allow-empty="true"
-                    :preserve-search="true"
-                    placeholder="{% trans 'Select Unit' %}"
-                    tag-placeholder="{% trans 'Create' %}"
-                    select-label="{% trans 'Select' %}"
-                    :taggable="true"
-                    @tag="addUnitType"
-                    label="name"
-                    track-by="name"
-                    :multiple="false"
-                    :loading="units_loading"
-                    @search-change="searchUnits"
-                >
-                </multiselect>
-            </div>
-            <div class="col-12 col-lg-4">
-                <multiselect
-                    v-tabindex
-                    ref="food"
-                    v-model="new_entry.food"
-                    :options="foods"
-                    :close-on-select="true"
-                    :clear-on-select="true"
-                    :allow-empty="true"
-                    :preserve-search="true"
-                    placeholder="{% trans 'Select Food' %}"
-                    tag-placeholder="{% trans 'Create' %}"
-                    select-label="{% trans 'Select' %}"
-                    :taggable="true"
-                    @tag="addFoodType"
-                    label="name"
-                    track-by="name"
-                    :multiple="false"
-                    :loading="foods_loading"
-                    @search-change="searchFoods"
-                >
-                </multiselect>
-            </div>
-
-            <div class="col-12 col-lg-1 my-auto text-right">
-                <button class="btn btn-success btn-lg" @click="addEntry()"><i class="fa fa-plus"></i></button>
-            </div>
-        </div>
-
-        <div class="row">
-            <div class="col" style="margin-top: 1vh">
-                <label for="id_supermarket">{% trans 'Supermarket' %}</label>
-                <multiselect
-                    id="id_supermarket"
-                    v-tabindex
-                    v-model="shopping_list.supermarket"
-                    :options="supermarkets"
-                    :close-on-select="true"
-                    :clear-on-select="true"
-                    :allow-empty="true"
-                    :preserve-search="true"
-                    placeholder="{% trans 'Select Supermarket' %}"
-                    select-label="{% trans 'Select' %}"
-                    label="name"
-                    track-by="id"
-                    :multiple="false"
-                    :loading="supermarkets_loading"
-                    @search-change="searchSupermarket"
-                >
-                </multiselect>
-            </div>
-        </div>
-
-        <div class="row">
-            <div class="col" style="margin-top: 1vh">
-                <label for="id_select_shared">{% trans 'Shared with' %}</label>
-                <multiselect
-                    id="id_select_shared"
-                    v-tabindex
-                    v-model="shopping_list.shared"
-                    :options="users"
-                    :close-on-select="true"
-                    :clear-on-select="true"
-                    :allow-empty="true"
-                    :preserve-search="true"
-                    placeholder="{% trans 'Select User' %}"
-                    select-label="{% trans 'Select' %}"
-                    label="username"
-                    track-by="id"
-                    :multiple="true"
-                    :loading="users_loading"
-                    @search-change="searchUsers"
-                >
-                </multiselect>
-            </div>
-        </div>
-
-        <div class="row">
-            <div class="col" style="text-align: right; margin-top: 1vh">
-                <div class="form-group form-check form-group-lg">
-                    <input class="form-check-input" style="zoom: 1.3" type="checkbox" v-model="shopping_list.finished" id="id_finished" />
-                    <label class="form-check-label" style="zoom: 1.3" for="id_finished"> {% trans 'Finished' %}</label>
-                </div>
-            </div>
-        </div>
-    </div>
-    <div v-else>
-        {% if request.user.userpreference.shopping_auto_sync > 0 %}
-        <div class="row" v-if="!onLine">
-            <div class="col col-md-12">
-                <div class="alert alert-warning" role="alert">{% trans 'You are offline, shopping list might not synchronize.' %}</div>
-            </div>
-        </div>
-        {% endif %}
-
-        <div class="row" style="margin-top: 8px">
-            <div class="col col-md-12">
-                <table class="table">
-                    <template v-for="c in display_categories">
-                        <template v-if="c.entries.filter(item => item.checked === false).length > 0">
-                            <tr>
-                                <td colspan="4">[[c.name]]</td>
-                            </tr>
-                            <tr v-for="x in c.entries">
-                                <template v-if="!x.checked">
-                                    <td><input type="checkbox" style="zoom: 1.4" v-model="x.checked" @change="entryChecked(x)" /></td>
-                                    <td>[[x.amount.toFixed(2)]]</td>
-                                    <td>[[x.unit.name]]</td>
-                                    <td>[[x.food.name]] <span class="text-muted" v-if="x.recipes.length > 0">([[x.recipes.join(', ')]])</span></td>
-                                </template>
-                            </tr>
-                        </template>
-                    </template>
-                    <tr>
-                        <td colspan="4"></td>
-                    </tr>
-                    <template v-for="c in display_categories">
-                        <tr v-for="x in c.entries" class="text-muted">
-                            <template v-if="x.checked">
-                                <td><input type="checkbox" style="zoom: 1.4" v-model="x.checked" @change="entryChecked(x)" /></td>
-                                <td>[[x.amount]]</td>
-                                <td>[[x.unit.name]]</td>
-                                <td>[[x.food.name]]</td>
-                            </template>
-                        </tr>
-                    </template>
-                </table>
-            </div>
-        </div>
-    </div>
-
-    <div class="row" style="margin-top: 2vh">
-        <div class="col" style="text-align: right">
-            <b-button class="btn btn-info" v-b-modal.id_modal_export><i class="fas fa-file-export"></i> {% trans 'Export' %}</b-button>
-            <button class="btn btn-success" @click="updateShoppingList()" v-if="edit_mode"><i class="fas fa-save"></i> {% trans 'Save' %}</button>
-        </div>
-    </div>
-
-    <br />
-    <br />
-
-    <b-modal id="id_modal_export" title="{% trans 'Copy/Export' %}">
-        <div class="row">
-            <div class="col col-12">
-                <label>
-                    {% trans 'List Prefix' %}
-                    <input class="form-control" v-model="export_text_prefix" />
-                </label>
-            </div>
-        </div>
-
-        <div class="row">
-            <div class="col col-12">
-                <b-form-textarea class="form-control" max-rows="8" v-model="export_text"> </b-form-textarea>
-            </div>
-        </div>
-    </b-modal>
-</template>
-
-{% endblock %} {% block script %}
-
-<script src="{% url 'javascript-catalog' %}"></script>
-<script type="application/javascript">
-    let csrftoken = Cookies.get('csrftoken');
-    Vue.http.headers.common['X-CSRFToken'] = csrftoken;
-
-    Vue.component('vue-multiselect', window.VueMultiselect.default)
-
-    let app = new Vue({
-        components: {
-            Multiselect: window.VueMultiselect.default
-        },
-        delimiters: ['[[', ']]'],
-        el: '#id_base_container',
-        data: {
-            shopping_list_id: {% if shopping_list_id  %}{{ shopping_list_id }}{% else %}null{% endif %},
-            loading: true,
-            {% if edit %}
-                edit_mode: true,
-            {% else %}
-                edit_mode: false,
-            {% endif %}
-            export_text_prefix: '',
-            recipe_query: '',
-            recipes: [],
-            shopping_list: undefined,
-            new_entry: {
-                unit: undefined,
-                amount: undefined,
-                food: undefined,
-            },
-            unchecked_entries: 0,
-            foods: [],
-            foods_loading: false,
-            units: [],
-            units_loading: false,
-            supermarkets: [],
-            supermarkets_loading: false,
-            users: [],
-            users_loading: false,
-            onLine: navigator.onLine,
-            simple_entry: '',
-            auto_sync_blocked: false,
-            auto_sync_running: false,
-            entry_mode_simple: $cookies.isKey('shopping_entry_mode_simple') ? ($cookies.get('shopping_entry_mode_simple') === 'true') : true,
-        },
-        directives: {
-            tabindex: {
-                inserted(el) {
-                    el.setAttribute('tabindex', 0);
-                }
-            }
-        },
-        computed: {
-            servings_cache() {
-                let cache = {}
-                this.shopping_list.recipes.forEach((r) => {
-                    cache[r.id] = r.servings;
-                })
-                return cache
-            },
-            recipe_cache() {
-                let cache = {}
-                this.shopping_list.recipes.forEach((r) => {
-                    cache[r.id] = r.recipe_name;
-                })
-                return cache
-            },
-            display_categories() {
-                this.unchecked_entries = 0
-                let categories = {
-                    no_category: {
-                        name: gettext('Uncategorized'),
-                        id: -1,
-                        entries: [],
-                        order: -1
-                    }
-                }
-
-                this.shopping_list.entries.forEach((e) => {
-                    if (e.food.supermarket_category !== null) {
-                        categories[e.food.supermarket_category.id] = {
-                            name: e.food.supermarket_category.name,
-                            id: e.food.supermarket_category.id,
-                            order: 0,
-                            entries: []
-                        };
-                    }
-                })
-
-                if (this.shopping_list.supermarket !== null) {
-                    this.shopping_list.supermarket.category_to_supermarket.forEach(el => {
-                        categories[el.category.id] = {
-                            name: el.category.name,
-                            id: el.category.id,
-                            order: el.order,
-                            entries: []
-                        };
-                    })
-                }
-
-                this.shopping_list.entries.forEach(element => {
-                    let item = {}
-                    Object.assign(item, element);
-                    item.recipes = []
-
-                    let entry = this.findMergeEntry(categories, item)
-                    if (entry !== undefined) {
-                        let servings = 1
-                        if (item.list_recipe in this.servings_cache) {
-                            servings = this.servings_cache[item.list_recipe]
-                        }
-
-                        entry.amount += item.amount * servings
-
-                        if (item.list_recipe !== null && entry.recipes.indexOf(this.recipe_cache[item.list_recipe]) === -1) {
-                            entry.recipes.push(this.recipe_cache[item.list_recipe])
-                        }
-
-                        entry.entries.push(item.id)
-                    } else {
-                        if (item.list_recipe !== null) {
-                            item.amount = item.amount * this.servings_cache[item.list_recipe]
-                        }
-                        item.unit = ((element.unit !== undefined && element.unit !== null) ? element.unit : {'name': ''})
-                        item.entries = [element.id]
-                        if (element.list_recipe !== null) {
-                            item.recipes.push(this.recipe_cache[element.list_recipe])
-                        }
-                        if (item.food.supermarket_category !== null) {
-                            categories[item.food.supermarket_category.id].entries.push(item)
-                        } else {
-                            categories['no_category'].entries.push(item)
-                        }
-                    }
-                    if (!item.checked) {
-                        this.unchecked_entries += 1
-                    }
-                });
-
-                let ordered_categories = []
-                for (let [i, v] of Object.entries(categories)) {
-                    ordered_categories.push(v)
-                }
-
-                ordered_categories.sort(function (a, b) {
-                    if (a.order < b.order) {
-                        return -1
-                    } else if (a.order > b.order) {
-                        return 1
-                    } else {
-                        return 0
-                    }
-                })
-
-                return ordered_categories
-            },
-            export_text() {
-                let text = ''
-                for (let c of this.display_categories) {
-                    for (let e of c.entries.filter(item => item.checked === false)) {
-                        text += `${this.export_text_prefix}${e.amount} ${e.unit.name} ${e.food.name} \n`
-                    }
-                }
-
-                return text
-            }
-        },
-        mounted: function () {
-            this.loadShoppingList()
-
-            {% if recipes %}
-
-                this.loading = true
-                this.edit_mode = true
-                let loadingRecipes = []
-                {% for r in recipes %}
-                    loadingRecipes.push(this.loadInitialRecipe({{ r.recipe }}, {{ r.servings }}))
-                {% endfor %}
-
-                Promise.allSettled(loadingRecipes).then(() => {
-                    this.loading = false
-                })
-            {% endif %}
-
-            {% if request.user.userpreference.shopping_auto_sync > 0 %}
-                setInterval(() => {
-                    if ((this.shopping_list_id !== null) && !this.edit_mode && window.navigator.onLine && !this.auto_sync_blocked && !this.auto_sync_running) {
-                        this.auto_sync_running = true
-                        this.loadShoppingList(true)
-                    }
-                }, {% widthratio request.user.userpreference.shopping_auto_sync 1 1000 %})
-
-                window.addEventListener('online', this.updateOnlineStatus);
-                window.addEventListener('offline', this.updateOnlineStatus);
-            {% endif %}
-
-            this.searchUsers('')
-            this.searchSupermarket('')
-            this.searchUnits('')
-            this.searchFoods('')
-        },
-        methods: {
-            findMergeEntry: function (categories, entry) {
-                for (let [i, e] of Object.entries(categories)) {
-                    let found_entry = e.entries.find(item => {
-                        if (entry.food.id === item.food.id && entry.food.name === item.food.name) {
-                            if (entry.unit === null && item.unit === null) {
-                                return true
-                            } else if (entry.unit !== null && item.unit !== null && entry.unit.id === item.unit.id && entry.unit.name === item.unit.name) {
-                                return true
-                            }
-                        }
-                    })
-
-                    if (found_entry !== undefined) {
-                        return found_entry
-                    }
-                }
-                return undefined
-            },
-            updateOnlineStatus(e) {
-                const {
-                    type
-                } = e;
-                this.onLine = type === 'online';
-            },
-            makeToast: function (title, message, variant = null) {
-                this.$bvToast.toast(message, {
-                    title: title,
-                    variant: variant,
-                    toaster: 'b-toaster-top-center',
-                    solid: true
-                })
-            },
-            loadInitialRecipe: function (recipe, servings) {
-                servings = 1
-                return this.$http.get('{% url 'api:recipe-detail' 123456 %}'.replace('123456', recipe)).then((response) => {
-                    this.addRecipeToList(response.data, servings)
-                }).catch((err) => {
-                    console.log("getRecipes error: ", err);
-                    this.makeToast(gettext('Error'), gettext("There was an error loading a resource!") + err.bodyText, 'danger')
-                })
-            },
-            loadShoppingList: function (autosync = false) {
-
-                if (this.shopping_list_id) {
-                    this.$http.get("{% url 'api:shoppinglist-detail' 123456 %}".replace('123456', this.shopping_list_id) + ((autosync) ? '?autosync=true' : '')).then((response) => {
-                        if (!autosync) {
-                            this.shopping_list = response.body
-                            this.loading = false
-                        } else {
-                            if (!this.auto_sync_blocked) {
-                                let check_map = {}
-                                for (let e of response.body.entries) {
-                                    check_map[e.id] = {checked: e.checked}
-                                }
-
-                                for (let se of this.shopping_list.entries) {
-                                    if (check_map[se.id] !== undefined) {
-                                        se.checked = check_map[se.id].checked
-                                    }
-                                }
-                            }
-                            this.auto_sync_running = false
-                        }
-                        if (this.shopping_list.entries.length === 0) {
-                            this.edit_mode = true
-                        }
-                        console.log(response.data)
-                    }).catch((err) => {
-                        console.log(err)
-                        this.makeToast(gettext('Error'), gettext("There was an error loading a resource!") + err.bodyText, 'danger')
-                    })
-                } else {
-                    this.shopping_list = {
-                        "recipes": [],
-                        "entries": [],
-                        "entries_display": [],
-                        "shared": [{% for u in request.user.userpreference.plan_share.all %}
-                            {'id': {{ u.pk }}, 'username': '{{ u.get_user_name }}'},
-                        {% endfor %}],
-                        "created_by": {{ request.user.pk }},
-                        "supermarket": null
-                    }
-                    this.loading = false
-
-                    if (this.shopping_list.entries.length === 0) {
-                        this.edit_mode = true
-                    }
-                }
-            },
-            updateShoppingList: function () {
-                this.loading = true
-                let recipe_promises = []
-
-                for (let i in this.shopping_list.recipes) {
-                    if (this.shopping_list.recipes[i].created) {
-                        console.log('updating recipe', this.shopping_list.recipes[i])
-                        recipe_promises.push(this.$http.post("{% url 'api:shoppinglistrecipe-list' %}", this.shopping_list.recipes[i], {}).then((response) => {
-                            let old_id = this.shopping_list.recipes[i].id
-                            console.log("list recipe create response ", response.body)
-                            this.$set(this.shopping_list.recipes, i, response.body)
-                            for (let e of this.shopping_list.entries.filter(item => item.list_recipe === old_id)) {
-                                console.log("found recipe updating ID")
-                                e.list_recipe = this.shopping_list.recipes[i].id
-                            }
-                        }).catch((err) => {
-                            console.log(err)
-                            this.makeToast(gettext('Error'), gettext("There was an error updating a resource!") + err.bodyText, 'danger')
-                        }))
-                    }
-                }
-
-                Promise.allSettled(recipe_promises).then(() => {
-                    console.log("proceeding to update shopping list", this.shopping_list)
-
-                    if (this.shopping_list.id === undefined) {
-                        return this.$http.post("{% url 'api:shoppinglist-list' %}", this.shopping_list, {}).then((response) => {
-                            console.log(response)
-                            this.makeToast(gettext('Updated'), gettext("Object created successfully!"), 'success')
-                            this.loading = false
-
-                            this.shopping_list = response.body
-                            this.shopping_list_id = this.shopping_list.id
-
-                            window.history.pushState('shopping_list', '{% trans 'Shopping List' %}', "{% url 'view_shopping' 123456 %}".replace('123456', this.shopping_list_id));
-                        }).catch((err) => {
-                            console.log(err)
-                            this.makeToast(gettext('Error'), gettext("There was an error creating a resource!") + err.bodyText, 'danger')
-                            this.loading = false
-                        })
-                    } else {
-                        return this.$http.put("{% url 'api:shoppinglist-detail' 123456 %}".replace('123456', this.shopping_list.id), this.shopping_list, {}).then((response) => {
-                            console.log(response)
-                            this.shopping_list = response.body
-                            this.makeToast(gettext('Updated'), gettext("Changes saved successfully!"), 'success')
-                            this.loading = false
-                        }).catch((err) => {
-                            console.log(err)
-                            this.makeToast(gettext('Error'), gettext("There was an error updating a resource!") + err.bodyText, 'danger')
-                            this.loading = false
-                        })
-                    }
-
-
-                })
-            },
-            sortEntries: function (a, b) {
-
-            },
-            dragChanged: function (category, evt) {
-                if (evt.added !== undefined) {
-                    if (evt.added.element.id === undefined) {
-                        this.makeToast(gettext('Warning'), gettext('This feature is only available after saving the shopping list'), 'warning')
-                    } else {
-                        this.shopping_list.entries.forEach(entry => {
-                            if (entry.id === evt.added.element.id) {
-                                if (category.id === -1) {
-                                    entry.food.supermarket_category = null
-                                } else {
-                                    entry.food.supermarket_category = {
-                                        name: category.name,
-                                        id: category.id
-                                    }
-                                }
-                                this.$http.put(("{% url 'api:food-detail' 123456 %}").replace('123456', entry.food.id), entry.food).then((response) => {
-
-                                }).catch((err) => {
-                                    this.makeToast(gettext('Error'), gettext('There was an error updating a resource!') + err.bodyText, 'danger')
-                                })
-                            }
-                        })
-                    }
-
-
-                }
-            },
-            entryChecked: function (entry) {
-                this.auto_sync_blocked = true
-                let updates = []
-                this.shopping_list.entries.forEach((item) => {
-                    if (entry.entries.includes(item.id)) {
-                        item.checked = entry.checked
-                        updates.push(this.$http.put("{% url 'api:shoppinglistentry-detail' 123456 %}".replace('123456', item.id), item, {}).then((response) => {
-
-                        }).catch((err) => {
-                            console.log(err)
-                            this.makeToast(gettext('Error'), gettext('There was an error updating a resource!') + err.bodyText, 'danger')
-                            this.loading = false
-                        }))
-                    }
-                })
-
-                Promise.allSettled(updates).then(() => {
-                    this.auto_sync_blocked = false
-                    if (this.unchecked_entries < 1) {
-                        this.shopping_list.finished = true
-
-                        this.$http.put("{% url 'api:shoppinglist-detail' 123456 %}".replace('123456', this.shopping_list.id), this.shopping_list, {}).then((response) => {
-                            this.makeToast(gettext('Finished'), gettext('Shopping list finished!'), 'success')
-                        }).catch((err) => {
-                            console.log(err)
-                            this.makeToast(gettext('Error'), gettext("There was an error updating a resource!") + err.bodyText, 'danger')
-                        })
-                    } else {
-                        if (this.unchecked_entries > 0 && this.shopping_list.finished) {
-                            this.shopping_list.finished = false
-
-                            this.$http.put("{% url 'api:shoppinglist-detail' 123456 %}".replace('123456', this.shopping_list.id), this.shopping_list, {}).then((response) => {
-                                this.makeToast(gettext('Open'), gettext('Shopping list reopened!'), 'success')
-                            }).catch((err) => {
-                                console.log(err)
-                                this.makeToast(gettext('Error'), gettext("There was an error updating a resource!") + err.bodyText, 'danger')
-                            })
-                        }
-                    }
-                })
-            },
-            addEntry: function () {
-                if (this.new_entry.food !== undefined) {
-                    this.shopping_list.entries.push({
-                        'list_recipe': null,
-                        'food': this.new_entry.food,
-                        'unit': this.new_entry.unit,
-                        'amount': parseFloat(this.new_entry.amount),
-                        'order': 0,
-                        'checked': false,
-                    })
-
-                    this.new_entry = {
-                        unit: undefined,
-                        amount: undefined,
-                        food: undefined,
-                    }
-
-                    this.$refs.new_entry_amount.focus();
-                } else {
-                    this.makeToast(gettext('Error'), gettext('Please enter a valid food'), 'danger')
-                }
-            },
-            addSimpleEntry: function () {
-                if (this.simple_entry !== '') {
-
-                    this.$http.post('{% url 'api_ingredient_from_string' %}', {text: this.simple_entry}, {emulateJSON: true}).then((response) => {
-
-                        console.log(response)
-
-                        let unit = null
-                        if (response.body.unit !== '') {
-                            unit = {'name': response.body.unit}
-                        }
-
-                        this.shopping_list.entries.push({
-                            'list_recipe': null,
-                            'food': {'name': response.body.food, supermarket_category: null},
-                            'unit': unit,
-                            'amount': response.body.amount,
-                            'order': 0,
-                            'checked': false,
-                        })
-
-                        this.simple_entry = ''
-                    }).catch((err) => {
-                        console.log(err)
-                        this.makeToast(gettext('Error'), gettext('Something went wrong while trying to add the simple entry.'), 'danger')
-                    })
-                }
-            },
-            getRecipes: function () {
-                let url = "{% url 'api:recipe-list' %}?page_size=5&internal=true"
-                if (this.recipe_query !== '') {
-                    url += '&query=' + this.recipe_query;
-                } else {
-                    this.recipes = []
-                    return
-                }
-
-                this.$http.get(url).then((response) => {
-                    this.recipes = response.data.results;
-                }).catch((err) => {
-                    console.log("getRecipes error: ", err);
-                    this.makeToast(gettext('Error'), gettext("There was an error loading a resource!") + err.bodyText, 'danger')
-                })
-            },
-            getRecipeUrl: function (id) {
-                return '{% url 'view_recipe' 123456 %}'.replace('123456', id)
-            },
-            addRecipeToList: function (recipe, servings = 1) {
-                let slr = {
-                    "created": true,
-                    "id": Math.random() * 1000,
-                    "recipe": recipe.id,
-                    "recipe_name": recipe.name,
-                    "servings": servings,
-                }
-                this.shopping_list.recipes.push(slr)
-
-                this.$http.get('{% url 'api:recipe-detail' 123456 %}'.replace('123456', recipe.id)).then((response) => {
-                    for (let s of response.data.steps) {
-                        for (let i of s.ingredients) {
-                            if (!i.is_header && i.food !== null && !i.food.ignore_food) {
-                                this.shopping_list.entries.push({
-                                    'list_recipe': slr.id,
-                                    'food': i.food,
-                                    'unit': i.unit,
-                                    'amount': i.amount,
-                                    'order': 0
-                                })
-                            }
-                        }
-                    }
-                }).catch((err) => {
-                    this.makeToast(gettext('Error'), gettext("There was an error loading a resource!") + err.bodyText, 'danger')
-                })
-            },
-            removeRecipeFromList: function (slr) {
-                this.shopping_list.entries = this.shopping_list.entries.filter(item => item.list_recipe !== slr.id)
-                this.shopping_list.recipes = this.shopping_list.recipes.filter(item => item !== slr)
-            },
-            searchKeywords: function (query) {
-                this.keywords_loading = true
-                this.$http.get("{% url 'api:keyword-list' %}" + '?query=' + query + '&limit=10').then((response) => {
-                    this.keywords = response.data.results;
-                    this.keywords_loading = false
-                }).catch((err) => {
-                    console.log(err)
-                    this.makeToast(gettext('Error'), gettext("There was an error loading a resource!") + err.bodyText, 'danger')
-                })
-            },
-
-            searchUnits: function (query) {
-                this.units_loading = true
-                this.$http.get("{% url 'api:unit-list' %}" + '?query=' + query + '&limit=10').then((response) => {
-                    this.units = response.data.results;
-                    this.units_loading = false
-                }).catch((err) => {
-                    this.makeToast(gettext('Error'), gettext("There was an error loading a resource!") + err.bodyText, 'danger')
-                })
-            },
-            searchFoods: function (query) {
-                this.foods_loading = true
-                this.$http.get("{% url 'api:food-list' %}" + '?query=' + query + '&limit=10').then((response) => {
-                    this.foods = response.data.results
-                    this.foods_loading = false
-                }).catch((err) => {
-                    this.makeToast(gettext('Error'), gettext("There was an error loading a resource!") + err.bodyText, 'danger')
-                })
-            },
-            addFoodType: function (tag, index) {
-                let new_food = {'name': tag, supermarket_category: null}
-                this.foods.push(new_food)
-                this.new_entry.food = new_food
-            },
-            addUnitType: function (tag, index) {
-                let new_unit = {'name': tag}
-                this.units.push(new_unit)
-                this.new_entry.unit = new_unit
-            },
-            searchUsers: function (query) {
-                this.users_loading = true
-                this.$http.get("{% url 'api:username-list' %}" + '?query=' + query + '&limit=10').then((response) => {
-                    this.users = response.data
-                    this.users_loading = false
-                }).catch((err) => {
-                    this.makeToast(gettext('Error'), gettext("There was an error loading a resource!") + err.bodyText, 'danger')
-                })
-            },
-            searchSupermarket: function (query) {
-                this.supermarkets_loading = true
-                this.$http.get("{% url 'api:supermarket-list' %}" + '?query=' + query + '&limit=10').then((response) => {
-                    this.supermarkets = response.data
-                    this.supermarkets_loading = false
-                }).catch((err) => {
-                    this.makeToast(gettext('Error'), gettext("There was an error loading a resource!") + err.bodyText, 'danger')
-                })
-            },
-        },
-        beforeDestroy() {
-            window.removeEventListener('online', this.updateOnlineStatus);
-            window.removeEventListener('offline', this.updateOnlineStatus);
-        }
-    });
-</script>
-
-{% endblock %}

cookbook/templates/socialaccount/authentication_error.html

@@ -0,0 +1,33 @@
+{% extends "base.html" %}
+{% load i18n %}
+{% load static %}
+
+{% load account socialaccount %}
+
+{% block head_title %}{% trans "Social Network Login Failure" %}{% endblock %}
+
+
+{% block content %}
+
+
+    <div class="row">
+        <div class="col-12" style="text-align: center">
+            <h3>{% trans "Sign In" %}</h3>
+        </div>
+    </div>
+
+
+    <div class="row">
+        <div class="col-sm-12 col-lg-6 col-md-6 offset-lg-3 offset-md-3">
+            <hr>
+            <h6>{% trans "Social Network Login Failure" %}</h6>
+
+            <p>{% trans "An error occurred while attempting to login via your social network account." %}</p>
+
+            <a class="btn btn-secondary" href="{% url 'account_login' %}">{% trans "Back" %}</a>
+        </div>
+    </div>
+
+
+
+{% endblock %}

cookbook/templates/space.html

@@ -36,8 +36,7 @@
                 <li class="list-group-item">
                     {% trans 'Recipes' %} :
                     <span class="badge badge-pill badge-info"
-                        >{{ counts.recipes }} / {% if request.space.max_recipes > 0 %} {{ request.space.max_recipes }}{%
-                        else %}∞{% endif %}</span
+                        >{{ counts.recipes }} / {% if request.space.max_recipes > 0 %} {{ request.space.max_recipes }}{% else %}∞{% endif %}</span
                     >
                 </li>
                 <li class="list-group-item">

cookbook/templates/system.html

@@ -105,7 +105,7 @@
     <br/>
     <h4>Debug</h4>
     <textarea class="form-control" rows="20">
-Gunicoren Media: {{ gunicorn_media }}
+Gunicorn Media: {{ gunicorn_media }}
 Sqlite: {{ postgres }}
 Debug: {{ debug }}
 

cookbook/templates/test.html

@@ -1,26 +1,20 @@
 {% extends "base.html" %}
-{% load crispy_forms_filters %}
-{% load i18n %}
+{% load render_bundle from webpack_loader %}
 {% load static %}
+{% load i18n %}
+{% load l10n %}
+{% load custom_tags %}
 
-{% block title %}{% trans 'Import Recipes' %}{% endblock %}
+{% block title %}Test{% endblock %}
+
+
+{% block content_fluid %}
+
+    {{ data }}
 
-{% block extra_head %}
-    {{ form.media }}
 {% endblock %}
 
 
-{% block content %}
-    <h2>{% trans 'Import' %}</h2>
-    <div class="row">
-        <div class="col col-md-12">
-            <form action="." method="post" enctype="multipart/form-data">
-                {% csrf_token %}
-                {{ form|crispy }}
-                <button class="btn btn-success" type="submit"><i class="fas fa-file-import"></i> {% trans 'Import' %}
-                </button>
-            </form>
-        </div>
-    </div>
+{% block script %}
 
 {% endblock %}

cookbook/templatetags/custom_tags.py

@@ -15,6 +15,7 @@ from cookbook.helper.mdx_attributes import MarkdownFormatExtension
 from cookbook.helper.mdx_urlize import UrlizeExtension
 from cookbook.models import Space, get_model_name
 from recipes import settings
+from recipes.settings import STATIC_URL
 
 register = template.Library()
 
@@ -136,7 +137,7 @@ def bookmarklet(request):
     if (api_token := Token.objects.filter(user=request.user).first()) is None:
         api_token = Token.objects.create(user=request.user)
 
-    bookmark = "javascript: \
+    bookmark = "<a href='javascript: \
     (function(){ \
         if(window.bookmarkletTandoor!==undefined){ \
             bookmarkletTandoor(); \
@@ -146,8 +147,8 @@ def bookmarklet(request):
             localStorage.setItem('token', '" + api_token.__str__() + "'); \
             document.body.appendChild(document.createElement(\'script\')).src=\'" \
                + server + prefix + static('js/bookmarklet.js') + "? \
-            r=\'+Math.floor(Math.random()*999999999);}})();"
-    return re.sub(r"[\n\t\s]*", "", bookmark)
+            r=\'+Math.floor(Math.random()*999999999);}})();'>Test</a>"
+    return re.sub(r"[\n\t]*", "", bookmark)
 
 
 @register.simple_tag
@@ -157,7 +158,7 @@ def base_path(request, path_type):
     elif path_type == 'script':
         return request.META.get('HTTP_X_SCRIPT_NAME', '')
     elif path_type == 'static_base':
-        return static('vue/manifest.json').replace('vue/manifest.json', '')
+        return STATIC_URL
 
 
 @register.simple_tag

cookbook/tests/api/test_api_ingredient.py

@@ -23,8 +23,8 @@ def test_list_permission(arg, request):
 
 
 def test_list_space(recipe_1_s1, u1_s1, u1_s2, space_2):
-    assert len(json.loads(u1_s1.get(reverse(LIST_URL)).content)) == 10
-    assert len(json.loads(u1_s2.get(reverse(LIST_URL)).content)) == 0
+    assert len(json.loads(u1_s1.get(reverse(LIST_URL)).content)['results']) == 10
+    assert len(json.loads(u1_s2.get(reverse(LIST_URL)).content)['results']) == 0
 
     with scopes_disabled():
         recipe_1_s1.space = space_2
@@ -32,8 +32,8 @@ def test_list_space(recipe_1_s1, u1_s1, u1_s2, space_2):
         Step.objects.update(space=Subquery(Step.objects.filter(pk=OuterRef('pk')).values('recipe__space')[:1]))
         Ingredient.objects.update(space=Subquery(Ingredient.objects.filter(pk=OuterRef('pk')).values('step__recipe__space')[:1]))
 
-    assert len(json.loads(u1_s1.get(reverse(LIST_URL)).content)) == 0
-    assert len(json.loads(u1_s2.get(reverse(LIST_URL)).content)) == 10
+    assert len(json.loads(u1_s1.get(reverse(LIST_URL)).content)['results']) == 0
+    assert len(json.loads(u1_s2.get(reverse(LIST_URL)).content)['results']) == 10
 
 
 @pytest.mark.parametrize("arg", [

cookbook/tests/api/test_api_shopping_recipe.py

@@ -230,4 +230,4 @@ def test_shopping_with_header_ingredient(u1_s1, recipe):
     #     recipe.step_set.first().ingredient_set.add(IngredientFactory(ingredients__header=1))
     u1_s1.put(reverse(SHOPPING_RECIPE_URL, args={recipe.id}))
     assert len(json.loads(u1_s1.get(reverse(SHOPPING_LIST_URL)).content)) == 10
-    assert len(json.loads(u1_s1.get(reverse('api:ingredient-list')).content)) == 11
+    assert len(json.loads(u1_s1.get(reverse('api:ingredient-list')).content)['results']) == 11

cookbook/tests/conftest.py

@@ -133,6 +133,7 @@ def validate_recipe(expected, recipe):
     for key in expected_lists:
         for k in expected_lists[key]:
             try:
+                print('comparing ', any([dict_compare(k, i) for i in target_lists[key]]))
                 assert any([dict_compare(k, i) for i in target_lists[key]])
             except AssertionError:
                 for result in [dict_compare(k, i, details=True) for i in target_lists[key]]: