dont allow space manage page in demo

Add documentation for migrating from sqlite3 database to postgresql (Unraid)

.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/ci.yml

@@ -29,6 +29,7 @@ jobs:
       run: yarn build
     - name: Install Django dependencies
       run: |
+        sudo apt-get -y update
         sudo apt-get install -y libsasl2-dev python-dev libldap2-dev libssl-dev
         python -m pip install --upgrade pip
         pip install -r requirements.txt

.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:

.idea/dictionaries/vabene1111_PC.xml

@@ -6,6 +6,7 @@
       <w>csrftoken</w>
       <w>gunicorn</w>
       <w>ical</w>
+      <w>invitelink</w>
       <w>mealie</w>
       <w>pepperplate</w>
       <w>safron</w>

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 git && \
     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 git && \
+    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"]

README.md

@@ -61,6 +61,15 @@ a public page.
 
 Documentation can be found [here](https://docs.tandoor.dev/).
 
+## Support our work
+Tandoor is developed by volunteers in their free time just because its fun. That said earning 
+some money with the project allows us to spend more time on it and thus make improvements we otherwise couldn't.
+Because of that there are several ways you can support us
+
+- **GitHub Sponsors** You can sponsor contributors of this project on GitHub: [vabene1111](https://github.com/sponsors/vabene1111)
+- **Host at Hetzner** We have been very happy customers of Hetzner for multiple years for all of our projects. If you want to get into self-hosting or are tired of the expensive big providers, their cloud servers are a great place to get started. When you sign up via our [referral link](https://hetzner.cloud/?ref=ISdlrLmr9kGj) you will get 20€ worth of cloud credits and we get a small kickback too.
+- **Let us host for you** We are offering a [hosted version](https://app.tandoor.dev) where all profits support us and the development of tandoor (currently only available in germany).  
+
 ## Contributing
 
 You can help out with the ongoing development by looking for potential bugs in our code base, or by contributing new features. We are always welcoming new pull requests containing bug fixes, refactors and new features. We have a list of tasks and bugs on our issue tracker on Github. Please comment on issues if you want to contribute with, to avoid duplicating effort.

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

@@ -15,7 +15,7 @@ from .models import (BookmarkletImport, Comment, CookLog, Food, FoodInheritField
                      Recipe, RecipeBook, RecipeBookEntry, RecipeImport, SearchPreference, ShareLink,
                      ShoppingList, ShoppingListEntry, ShoppingListRecipe, Space, Step, Storage,
                      Supermarket, SupermarketCategory, SupermarketCategoryRelation, Sync, SyncLog,
-                     TelegramBot, Unit, UserFile, UserPreference, ViewLog, Automation)
+                     TelegramBot, Unit, UserFile, UserPreference, ViewLog, Automation, UserSpace)
 
 
 class CustomUserAdmin(UserAdmin):
@@ -32,41 +32,7 @@ admin.site.unregister(Group)
 @admin.action(description='Delete all data from a space')
 def delete_space_action(modeladmin, request, queryset):
     for space in queryset:
-        CookLog.objects.filter(space=space).delete()
-        ViewLog.objects.filter(space=space).delete()
-        ImportLog.objects.filter(space=space).delete()
-        BookmarkletImport.objects.filter(space=space).delete()
-
-        Comment.objects.filter(recipe__space=space).delete()
-        Keyword.objects.filter(space=space).delete()
-        Ingredient.objects.filter(space=space).delete()
-        Food.objects.filter(space=space).delete()
-        Unit.objects.filter(space=space).delete()
-        Step.objects.filter(space=space).delete()
-        NutritionInformation.objects.filter(space=space).delete()
-        RecipeBookEntry.objects.filter(book__space=space).delete()
-        RecipeBook.objects.filter(space=space).delete()
-        MealType.objects.filter(space=space).delete()
-        MealPlan.objects.filter(space=space).delete()
-        ShareLink.objects.filter(space=space).delete()
-        Recipe.objects.filter(space=space).delete()
-
-        RecipeImport.objects.filter(space=space).delete()
-        SyncLog.objects.filter(sync__space=space).delete()
-        Sync.objects.filter(space=space).delete()
-        Storage.objects.filter(space=space).delete()
-
-        ShoppingListEntry.objects.filter(shoppinglist__space=space).delete()
-        ShoppingListRecipe.objects.filter(shoppinglist__space=space).delete()
-        ShoppingList.objects.filter(space=space).delete()
-
-        SupermarketCategoryRelation.objects.filter(supermarket__space=space).delete()
-        SupermarketCategory.objects.filter(space=space).delete()
-        Supermarket.objects.filter(space=space).delete()
-
-        InviteLink.objects.filter(space=space).delete()
-        UserFile.objects.filter(space=space).delete()
-        Automation.objects.filter(space=space).delete()
+        space.save()
 
 
 class SpaceAdmin(admin.ModelAdmin):
@@ -80,9 +46,17 @@ class SpaceAdmin(admin.ModelAdmin):
 admin.site.register(Space, SpaceAdmin)
 
 
+class UserSpaceAdmin(admin.ModelAdmin):
+    list_display = ('user', 'space',)
+    search_fields = ('user', 'space',)
+
+
+admin.site.register(UserSpace, UserSpaceAdmin)
+
+
 class UserPreferenceAdmin(admin.ModelAdmin):
-    list_display = ('name', 'space', 'theme', 'nav_color', 'default_page', 'search_style',)  # TODO add new fields
-    search_fields = ('user__username', 'space__name')
+    list_display = ('name', 'theme', 'nav_color', 'default_page', 'search_style',)  # TODO add new fields
+    search_fields = ('user__username',)
     list_filter = ('theme', 'nav_color', 'default_page', 'search_style')
     date_hierarchy = 'created_at'
 
@@ -237,7 +211,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

@@ -37,19 +37,16 @@ class UserPreferenceForm(forms.ModelForm):
     prefix = 'preference'
 
     def __init__(self, *args, **kwargs):
-        if x := kwargs.get('instance', None):
-            space = x.space
-        else:
-            space = kwargs.pop('space')
+        space = kwargs.pop('space')
         super().__init__(*args, **kwargs)
-        self.fields['plan_share'].queryset = User.objects.filter(userpreference__space=space).all()
+        self.fields['plan_share'].queryset = User.objects.filter(userspace__space=space).all()
 
     class Meta:
         model = UserPreference
         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 +62,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 +87,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 +152,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 +166,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,51 @@ class IngredientParser:
                 raise ValueError
             elif start < 0:
                 # no opening bracket anywhere -> just ignore the last bracket
-                ingredient, note = self.parse_ingredient_with_comma(tokens)
+                food, note = self.parse_food_with_comma(tokens)
             else:
-                # opening bracket found -> split in ingredient and note, remove brackets from note  # noqa: E501
+                # opening bracket found -> split in food and note, remove brackets from note  # noqa: E501
                 note = ' '.join(tokens[start:])[1:-1]
-                ingredient = ' '.join(tokens[:start])
+                food = ' '.join(tokens[:start])
         else:
-            ingredient, note = self.parse_ingredient_with_comma(tokens)
-        return ingredient, note
+            food, note = self.parse_food_with_comma(tokens)
+        return food, note
 
-    def parse(self, x):
+    def parse(self, ingredient):
+        """
+        Main parsing function, takes an ingredient string (e.g. '1 l Water') and extracts amount, unit, food, ...
+        :param ingredient: string ingredient
+        :return: amount, unit (can be None), food, note (can be empty)
+        """
         # initialize default values
         amount = 0
-        unit = ''
-        ingredient = ''
+        unit = None
+        food = ''
         note = ''
         unit_note = ''
 
+        if len(ingredient) == 0:
+            raise ValueError('string to parse cannot be empty')
+
+        # some people/languages put amount and unit at the end of the ingredient string
+        # if something like this is detected move it to the beginning so the parser can handle it
+        if len(ingredient) < 1000 and re.search(r'^([A-z])+(.)*[1-9](\d)*\s([A-z])+', ingredient):
+            match = re.search(r'[1-9](\d)*\s([A-z])+', ingredient)
+            print(f'reording from {ingredient} to {ingredient[match.start():match.end()] + " " + ingredient.replace(ingredient[match.start():match.end()], "")}')
+            ingredient = ingredient[match.start():match.end()] + ' ' + ingredient.replace(ingredient[match.start():match.end()], '')
+
         # if the string contains parenthesis early on remove it and place it at the end
         # because its likely some kind of note
-        if re.match('(.){1,6}\s\((.[^\(\)])+\)\s', x):
-            match = re.search('\((.[^\(])+\)', x)
-            x = x[:match.start()] + x[match.end():] + ' ' + x[match.start():match.end()]
+        if re.match('(.){1,6}\s\((.[^\(\)])+\)\s', ingredient):
+            match = re.search('\((.[^\(])+\)', ingredient)
+            ingredient = ingredient[:match.start()] + ingredient[match.end():] + ' ' + ingredient[match.start():match.end()]
 
-        tokens = x.split()
+        # leading spaces before commas result in extra tokens, clean them out
+        ingredient = ingredient.replace(' ,', ',')
+
+        tokens = ingredient.split()  # split at each space into tokens
         if len(tokens) == 1:
-            # there only is one argument, that must be the ingredient
-            ingredient = tokens[0]
+            # there only is one argument, that must be the food
+            food = tokens[0]
         else:
             try:
                 # try to parse first argument as amount
@@ -227,48 +248,65 @@ class IngredientParser:
                 # a fraction for the amount
                 if len(tokens) > 2:
                     try:
-                        if not unit == '':
+                        if unit is not None:
                             # a unit is already found, no need to try the second argument for a fraction
-                            # probably not the best method to do it, but I didn't want to make an if check and paste the exact same thing in the else as already is in the except  # noqa: E501
+                            # probably not the best method to do it, but I didn't want to make an if check and paste the exact same thing in the else as already is in the except
                             raise ValueError
                         # try to parse second argument as amount and add that, in case of '2 1/2' or '2 ½'
                         amount += self.parse_fraction(tokens[1])
                         # assume that units can't end with a comma
                         if len(tokens) > 3 and not tokens[2].endswith(','):
-                            # try to use third argument as unit and everything else as ingredient, use everything as ingredient if it fails  # noqa: E501
+                            # try to use third argument as unit and everything else as food, use everything as food if it fails
                             try:
-                                ingredient, note = self.parse_ingredient(tokens[3:])
+                                food, note = self.parse_food(tokens[3:])
                                 unit = tokens[2]
                             except ValueError:
-                                ingredient, note = self.parse_ingredient(tokens[2:])
+                                food, note = self.parse_food(tokens[2:])
                         else:
-                            ingredient, note = self.parse_ingredient(tokens[2:])
+                            food, note = self.parse_food(tokens[2:])
                     except ValueError:
                         # assume that units can't end with a comma
                         if not tokens[1].endswith(','):
-                            # try to use second argument as unit and everything else as ingredient, use everything as ingredient if it fails  # noqa: E501
+                            # try to use second argument as unit and everything else as food, use everything as food if it fails
                             try:
-                                ingredient, note = self.parse_ingredient(tokens[2:])
-                                if unit == '':
+                                food, note = self.parse_food(tokens[2:])
+                                if unit is None:
                                     unit = tokens[1]
                                 else:
                                     note = tokens[1]
                             except ValueError:
-                                ingredient, note = self.parse_ingredient(tokens[1:])
+                                food, note = self.parse_food(tokens[1:])
                         else:
-                            ingredient, note = self.parse_ingredient(tokens[1:])
+                            food, note = self.parse_food(tokens[1:])
                 else:
                     # only two arguments, first one is the amount
-                    # which means this is the ingredient
-                    ingredient = tokens[1]
+                    # which means this is the food
+                    food = tokens[1]
             except ValueError:
                 try:
                     # can't parse first argument as amount
-                    # -> no unit -> parse everything as ingredient
-                    ingredient, note = self.parse_ingredient(tokens)
+                    # -> no unit -> parse everything as food
+                    food, note = self.parse_food(tokens)
                 except ValueError:
-                    ingredient = ' '.join(tokens[1:])
+                    food = ' '.join(tokens[1:])
 
         if unit_note not in note:
             note += ' ' + unit_note
-        return amount, self.apply_unit_automation(unit.strip()), self.apply_food_automation(ingredient.strip()), note.strip()
+
+        if unit:
+            unit = self.apply_unit_automation(unit.strip())
+
+        food = self.apply_food_automation(food.strip())
+        if len(food) > Food._meta.get_field('name').max_length:  # test if food name is to long
+            # try splitting it at a space and taking only the first arg
+            if len(food.split()) > 1 and len(food.split()[0]) < Food._meta.get_field('name').max_length:
+                note = ' '.join(food.split()[1:]) + ' ' + note
+                food = food.split()[0]
+            else:
+                note = food + ' ' + note
+                food = food[:Food._meta.get_field('name').max_length]
+
+        if len(food.strip()) == 0:
+            raise ValueError(f'Error parsing string {ingredient}, food cannot be empty')
+
+        return amount, unit, food, note[:Ingredient._meta.get_field('note').max_length].strip()

cookbook/helper/permission_helper.py

@@ -1,18 +1,15 @@
-"""
-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
 from django.core.cache import caches
-from django.core.exceptions import ValidationError
+from django.core.exceptions import ValidationError, ObjectDoesNotExist
 from django.http import HttpResponseRedirect
 from django.urls import reverse, reverse_lazy
 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, UserSpace
 
 
 def get_allowed_groups(groups_required):
@@ -43,8 +40,11 @@ def has_group_permission(user, groups):
         return False
     groups_allowed = get_allowed_groups(groups)
     if user.is_authenticated:
-        if bool(user.groups.filter(name__in=groups_allowed)):
-            return True
+        if user_space := user.userspace_set.filter(active=True):
+            if len(user_space) != 1:
+                return False  # do not allow any group permission if more than one space is active, needs to be changed when simultaneous multi-space-tenancy is added
+            if bool(user_space.first().groups.filter(name__in=groups_allowed)):
+                return True
     return False
 
 
@@ -53,7 +53,6 @@ def is_object_owner(user, obj):
     Tests if a given user is the owner of a given object
     test performed by checking user against the objects user
     and create_by field (if exists)
-    superusers bypass all checks, unauthenticated users cannot own anything
     :param user django auth user object
     :param obj any object that should be tested
     :return: true if user is owner of object, false otherwise
@@ -66,11 +65,25 @@ def is_object_owner(user, obj):
         return False
 
 
+def is_space_owner(user, obj):
+    """
+    Tests if a given user is the owner the space of a given object
+    :param user django auth user object
+    :param obj any object that should be tested
+    :return: true if user is owner of the objects space, false otherwise
+    """
+    if not user.is_authenticated:
+        return False
+    try:
+        return obj.get_space().get_owner() == user
+    except Exception:
+        return False
+
+
 def is_object_shared(user, obj):
     """
     Tests if a given user is shared for a given object
     test performed by checking user against the objects shared table
-    superusers bypass all checks, unauthenticated users cannot own anything
     :param user django auth user object
     :param obj any object that should be tested
     :return: true if user is shared for object, false otherwise
@@ -166,7 +179,7 @@ class OwnerRequiredMixin(object):
 
         try:
             obj = self.get_object()
-            if obj.get_space() != request.space:
+            if not request.user.userspace.filter(space=obj.get_space()).exists():
                 messages.add_message(request, messages.ERROR,
                                      _('You do not have the required permissions to view this page!'))
                 return HttpResponseRedirect(reverse_lazy('index'))
@@ -184,7 +197,7 @@ class CustomIsOwner(permissions.BasePermission):
     verifies user has ownership over object
     (either user or created_by or user is request user)
     """
-    message = _('You cannot interact with this object as it is not owned by you!')  # noqa: E501
+    message = _('You cannot interact with this object as it is not owned by you!')
 
     def has_permission(self, request, view):
         return request.user.is_authenticated
@@ -193,6 +206,28 @@ class CustomIsOwner(permissions.BasePermission):
         return is_object_owner(request.user, obj)
 
 
+class CustomIsOwnerReadOnly(CustomIsOwner):
+    def has_permission(self, request, view):
+        return super().has_permission(request, view) and request.method in SAFE_METHODS
+
+    def has_object_permission(self, request, view, obj):
+        return super().has_object_permission(request, view) and request.method in SAFE_METHODS
+
+
+class CustomIsSpaceOwner(permissions.BasePermission):
+    """
+    Custom permission class for django rest framework views
+    verifies if the user is the owner of the space the object belongs to
+    """
+    message = _('You cannot interact with this object as it is not owned by you!')
+
+    def has_permission(self, request, view):
+        return request.user.is_authenticated and request.space.created_by == request.user
+
+    def has_object_permission(self, request, view, obj):
+        return is_space_owner(request.user, obj)
+
+
 # TODO function duplicate/too similar name
 class CustomIsShared(permissions.BasePermission):
     """
@@ -262,3 +297,58 @@ 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 UserSpace.objects.filter(space=space).count() > space.max_users
+    if limit:
+        return True, _('You have more users than allowed in your space.')
+    return False, ''
+
+
+def switch_user_active_space(user, space):
+    """
+    Switch the currently active space of a user by setting all spaces to inactive and activating the one passed
+    :param user: user to change active space for
+    :param space: space to activate user for
+    :return user space object or none if not found/no permission
+    """
+    try:
+        us = UserSpace.objects.get(space=space, user=user)
+        if not us.active:
+            UserSpace.objects.filter(user=user).update(active=False)
+            us.active = True
+            us.save()
+            return us
+        else:
+            return us
+    except ObjectDoesNotExist:
+        return None

cookbook/helper/recipe_html_import.py

@@ -1,194 +1,191 @@
-import json
-import re
-from json import JSONDecodeError
-from urllib.parse import unquote
+# import json
+# import re
+# from json import JSONDecodeError
+# from urllib.parse import unquote
 
-from bs4 import BeautifulSoup
-from bs4.element import Tag
-from recipe_scrapers._utils import get_host_name, normalize_string
+# from bs4 import BeautifulSoup
+# from bs4.element import Tag
+# from recipe_scrapers import scrape_html, scrape_me
+# from recipe_scrapers._exceptions import NoSchemaFoundInWildMode
+# 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 cookbook.helper import recipe_url_import as helper
+# from cookbook.helper.scrapers.scrapers import text_scraper
 
 
-def get_recipe_from_source(text, url, request):
-    def build_node(k, v):
-        if isinstance(v, dict):
-            node = {
-                'name': k,
-                'value': k,
-                'children': get_children_dict(v)
-            }
-        elif isinstance(v, list):
-            node = {
-                'name': k,
-                'value': k,
-                'children': get_children_list(v)
-            }
-        else:
-            node = {
-                'name': k + ": " + normalize_string(str(v)),
-                'value': normalize_string(str(v))
-            }
-        return node
+# def get_recipe_from_source(text, url, request):
+#     def build_node(k, v):
+#         if isinstance(v, dict):
+#             node = {
+#                 'name': k,
+#                 'value': k,
+#                 'children': get_children_dict(v)
+#             }
+#         elif isinstance(v, list):
+#             node = {
+#                 'name': k,
+#                 'value': k,
+#                 'children': get_children_list(v)
+#             }
+#         else:
+#             node = {
+#                 'name': k + ": " + normalize_string(str(v)),
+#                 'value': normalize_string(str(v))
+#             }
+#         return node
 
-    def get_children_dict(children):
-        kid_list = []
-        for k, v in children.items():
-            kid_list.append(build_node(k, v))
-        return kid_list
+#     def get_children_dict(children):
+#         kid_list = []
+#         for k, v in children.items():
+#             kid_list.append(build_node(k, v))
+#         return kid_list
 
-    def get_children_list(children):
-        kid_list = []
-        for kid in children:
-            if type(kid) == list:
-                node = {
-                    'name': "unknown list",
-                    'value': "unknown list",
-                    'children': get_children_list(kid)
-                }
-                kid_list.append(node)
-            elif type(kid) == dict:
-                for k, v in kid.items():
-                    kid_list.append(build_node(k, v))
-            else:
-                kid_list.append({
-                    'name': normalize_string(str(kid)),
-                    'value': normalize_string(str(kid))
-                })
-        return kid_list
+#     def get_children_list(children):
+#         kid_list = []
+#         for kid in children:
+#             if type(kid) == list:
+#                 node = {
+#                     'name': "unknown list",
+#                     'value': "unknown list",
+#                     'children': get_children_list(kid)
+#                 }
+#                 kid_list.append(node)
+#             elif type(kid) == dict:
+#                 for k, v in kid.items():
+#                     kid_list.append(build_node(k, v))
+#             else:
+#                 kid_list.append({
+#                     'name': normalize_string(str(kid)),
+#                     'value': normalize_string(str(kid))
+#                 })
+#         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)
+#     recipe_tree = []
+#     parse_list = []
+#     soup = BeautifulSoup(text, "html.parser")
+#     html_data = get_from_html(soup)
+#     images = get_images_from_source(soup, url)
+#     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 and not text:
+#         try:
+#             scrape = scrape_me(url_path=url, wild_mode=True)
+#         except(NoSchemaFoundInWildMode):
+#             pass
 
-    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)
+#     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)
 
-    recipe_json = helper.get_from_scraper(scrape, request)
+#         except JSONDecodeError:
+#             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)
 
-    for el in parse_list:
-        temp_tree = []
-        if isinstance(el, Tag):
-            try:
-                el = json.loads(el.string)
-            except TypeError:
-                continue
+#     recipe_json = helper.get_from_scraper(scrape, request)
 
-        for k, v in el.items():
-            if isinstance(v, dict):
-                node = {
-                    'name': k,
-                    'value': k,
-                    'children': get_children_dict(v)
-                }
-            elif isinstance(v, list):
-                node = {
-                    'name': k,
-                    'value': k,
-                    'children': get_children_list(v)
-                }
-            else:
-                node = {
-                    'name': k + ": " + normalize_string(str(v)),
-                    'value': normalize_string(str(v))
-                }
-            temp_tree.append(node)
+#     # TODO: DEPRECATE recipe_tree & html_data.  first validate it isn't used anywhere
+#     for el in parse_list:
+#         temp_tree = []
+#         if isinstance(el, Tag):
+#             try:
+#                 el = json.loads(el.string)
+#             except TypeError:
+#                 continue
 
-        if '@type' in el and el['@type'] == 'Recipe':
-            recipe_tree += [{'name': 'ld+json', 'children': temp_tree}]
-        else:
-            recipe_tree += [{'name': 'json', 'children': temp_tree}]
+#         for k, v in el.items():
+#             if isinstance(v, dict):
+#                 node = {
+#                     'name': k,
+#                     'value': k,
+#                     'children': get_children_dict(v)
+#                 }
+#             elif isinstance(v, list):
+#                 node = {
+#                     'name': k,
+#                     'value': k,
+#                     'children': get_children_list(v)
+#                 }
+#             else:
+#                 node = {
+#                     'name': k + ": " + normalize_string(str(v)),
+#                     'value': normalize_string(str(v))
+#                 }
+#             temp_tree.append(node)
 
-    return recipe_json, recipe_tree, html_data, images
+#         if '@type' in el and el['@type'] == 'Recipe':
+#             recipe_tree += [{'name': 'ld+json', 'children': temp_tree}]
+#         else:
+#             recipe_tree += [{'name': 'json', 'children': temp_tree}]
+
+#     return recipe_json, recipe_tree, html_data, images
 
 
-def get_from_html(soup):
-    INVISIBLE_ELEMS = ('style', 'script', 'head', 'title')
-    html = []
-    for s in soup.strings:
-        if ((s.parent.name not in INVISIBLE_ELEMS) and (len(s.strip()) > 0)):
-            html.append(s)
-    return html
+# def get_from_html(soup):
+#     INVISIBLE_ELEMS = ('style', 'script', 'head', 'title')
+#     html = []
+#     for s in soup.strings:
+#         if ((s.parent.name not in INVISIBLE_ELEMS) and (len(s.strip()) > 0)):
+#             html.append(s)
+#     return html
 
 
-def get_images_from_source(soup, url):
-    sources = ['src', 'srcset', 'data-src']
-    images = []
-    img_tags = soup.find_all('img')
-    if url:
-        site = get_host_name(url)
-        prot = url.split(':')[0]
+# def get_images_from_source(soup, url):
+#     sources = ['src', 'srcset', 'data-src']
+#     images = []
+#     img_tags = soup.find_all('img')
+#     if url:
+#         site = get_host_name(url)
+#         prot = url.split(':')[0]
 
-    urls = []
-    for img in img_tags:
-        for src in sources:
-            try:
-                urls.append(img[src])
-            except KeyError:
-                pass
+#     urls = []
+#     for img in img_tags:
+#         for src in sources:
+#             try:
+#                 urls.append(img[src])
+#             except KeyError:
+#                 pass
 
-    for u in urls:
-        u = u.split('?')[0]
-        filename = re.search(r'/([\w_-]+[.](jpg|jpeg|gif|png))$', u)
-        if filename:
-            if (('http' not in u) and (url)):
-                # sometimes an image source can be relative
-                # if it is provide the base url
-                u = '{}://{}{}'.format(prot, site, u)
-            if 'http' in u:
-                images.append(u)
-    return images
+#     for u in urls:
+#         u = u.split('?')[0]
+#         filename = re.search(r'/([\w_-]+[.](jpg|jpeg|gif|png))$', u)
+#         if filename:
+#             if (('http' not in u) and (url)):
+#                 # sometimes an image source can be relative
+#                 # if it is provide the base url
+#                 u = '{}://{}{}'.format(prot, site, u)
+#             if 'http' in u:
+#                 images.append(u)
+#     return images
 
 
-def remove_graph(el):
-    # recipes type might be wrapped in @graph type
-    if isinstance(el, Tag):
-        try:
-            el = json.loads(el.string)
-            if '@graph' in el:
-                for x in el['@graph']:
-                    if '@type' in x and x['@type'] == 'Recipe':
-                        el = x
-        except (TypeError, JSONDecodeError):
-            pass
-    return el
+# def remove_graph(el):
+#     # recipes type might be wrapped in @graph type
+#     if isinstance(el, Tag):
+#         try:
+#             el = json.loads(el.string)
+#             if '@graph' in el:
+#                 for x in el['@graph']:
+#                     if '@type' in x and x['@type'] == 'Recipe':
+#                         el = x
+#         except (TypeError, JSONDecodeError):
+#             pass
+#     return el

cookbook/helper/recipe_search.py

@@ -4,7 +4,8 @@ from datetime import date, timedelta
 
 from django.contrib.postgres.search import SearchQuery, SearchRank, SearchVector, TrigramSimilarity
 from django.core.cache import caches
-from django.db.models import Avg, Case, Count, F, Func, Max, OuterRef, Q, Subquery, Sum, Value, When
+from django.db.models import (Avg, Case, Count, Exists, F, Func, Max, OuterRef, Q, Subquery, Sum,
+                              Value, When)
 from django.db.models.functions import Coalesce, Lower, Substr
 from django.utils import timezone, translation
 from django.utils.translation import gettext as _
@@ -147,7 +148,7 @@ class RecipeSearch():
 
     def _build_sort_order(self):
         if self._random:
-            self._queryset = self._queryset.order_by("?")
+            self.orderby = ['?']
         else:
             order = []
             # TODO add userpreference for default sort order and replace '-favorite'
@@ -525,16 +526,18 @@ class RecipeSearch():
     @ staticmethod
     def __children_substitute_filter(shopping_users=None):
         children_onhand_subquery = Food.objects.filter(
-            path__startswith=Substr(OuterRef('path'), 1, Food.steplen*OuterRef('depth')),
+            path__startswith=OuterRef('path'),
             depth__gt=OuterRef('depth'),
             onhand_users__in=shopping_users
-        ).annotate(child_onhand=Coalesce(Func('pk', function='Count'), 0)).values('child_onhand')
+        )
         return Food.objects.exclude(  # list of foods that are onhand and children of: foods that are not onhand and are set to use children as substitutes
             Q(onhand_users__in=shopping_users)
             | Q(ignore_shopping=True, recipe__isnull=True)
             | Q(substitute__onhand_users__in=shopping_users)
-        ).exclude(depth=1, numchild=0).filter(substitute_children=True
-                                              ).annotate(child_onhand=Coalesce(Subquery(children_onhand_subquery), 0)).exclude(child_onhand=0)
+        ).exclude(depth=1, numchild=0
+                  ).filter(substitute_children=True
+                           ).annotate(child_onhand_count=Exists(children_onhand_subquery)
+                                      ).filter(child_onhand_count=True)
 
     @ staticmethod
     def __sibling_substitute_filter(shopping_users=None):
@@ -542,13 +545,15 @@ class RecipeSearch():
             path__startswith=Substr(OuterRef('path'), 1, Food.steplen*(OuterRef('depth')-1)),
             depth=OuterRef('depth'),
             onhand_users__in=shopping_users
-        ).annotate(sibling_onhand=Coalesce(Func('pk', function='Count'), 0)).values('sibling_onhand')
+        )
         return Food.objects.exclude(  # list of foods that are onhand and siblings of: foods that are not onhand and are set to use siblings as substitutes
             Q(onhand_users__in=shopping_users)
             | Q(ignore_shopping=True, recipe__isnull=True)
             | Q(substitute__onhand_users__in=shopping_users)
-        ).exclude(depth=1, numchild=0).filter(substitute_siblings=True
-                                              ).annotate(sibling_onhand=Coalesce(Subquery(sibling_onhand_subquery), 0)).exclude(sibling_onhand=0)
+        ).exclude(depth=1, numchild=0
+                  ).filter(substitute_siblings=True
+                           ).annotate(sibling_onhand=Exists(sibling_onhand_subquery)
+                                      ).filter(sibling_onhand=True)
 
 
 class RecipeFacet():
@@ -760,6 +765,6 @@ def old_search(request):
         params = dict(request.GET)
         params['internal'] = None
         f = RecipeFilter(params,
-                         queryset=Recipe.objects.filter(space=request.user.userpreference.space).all().order_by(Lower('name').asc()),
+                         queryset=Recipe.objects.filter(space=request.space).all().order_by(Lower('name').asc()),
                          space=request.space)
         return f.qs

cookbook/helper/recipe_url_import.py

@@ -7,12 +7,15 @@ from django.utils.dateparse import parse_duration
 from django.utils.translation import gettext as _
 from isodate import parse_duration as iso_parse_duration
 from isodate.isoerror import ISO8601Error
-from recipe_scrapers._utils import get_minutes
+from pytube import YouTube
+from recipe_scrapers._utils import get_host_name, get_minutes
 
 from cookbook.helper import recipe_url_import as helper
 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
@@ -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,45 +40,37 @@ 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
+        servings = scrape.schema.data.get('recipeYield') or 1  # dont use scrape.yields() as this will always return "x servings" or "x items", should be improved in scrapers directly
     except Exception:
-        servings = None
-    if not servings:
-        try:
-            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)
+        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 +108,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,55 +130,84 @@ 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
+
+    return recipe_json
+
+
+def get_from_youtube_scraper(url, request):
+    """A YouTube Information Scraper."""
+    kw, created = Keyword.objects.get_or_create(name='YouTube', space=request.space)
+    default_recipe_json = {
+        'name': '',
+        'internal': True,
+        'description': '',
+        'servings': 1,
+        'working_time': 0,
+        'waiting_time': 0,
+        'image': "",
+        'keywords': [{'name': kw.name, 'label': kw.name, 'id': kw.pk}],
+        'source_url': url,
+        'steps': [
+            {
+                'ingredients': [],
+                'instruction': ''
+            }
+        ]
+    }
 
     try:
-        recipe_json['recipeInstructions'] = parse_instructions(scrape.instructions())
+        video = YouTube(url=url)
+        default_recipe_json['name'] = video.title
+        default_recipe_json['image'] = video.thumbnail_url
+        default_recipe_json['steps'][0]['instruction'] = video.description
     except Exception:
-        recipe_json['recipeInstructions'] = ""
+        pass
 
-    if scrape.canonical_url():
-        recipe_json['url'] = scrape.canonical_url()
-        recipe_json['recipeInstructions'] += "\n\n" + _("Imported from") + ": " + scrape.canonical_url()
-    return recipe_json
+    return default_recipe_json
 
 
 def parse_name(name):
@@ -180,102 +219,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 +293,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 str(servings)[:32]
+
+
+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 +327,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
 
@@ -393,3 +367,32 @@ def iso_duration_to_minutes(string):
         string
     ).groupdict()
     return int(match['days'] or 0) * 24 * 60 + int(match['hours'] or 0) * 60 + int(match['minutes'] or 0)
+
+
+def get_images_from_soup(soup, url):
+    sources = ['src', 'srcset', 'data-src']
+    images = []
+    img_tags = soup.find_all('img')
+    if url:
+        site = get_host_name(url)
+        prot = url.split(':')[0]
+
+    urls = []
+    for img in img_tags:
+        for src in sources:
+            try:
+                urls.append(img[src])
+            except KeyError:
+                pass
+
+    for u in urls:
+        u = u.split('?')[0]
+        filename = re.search(r'/([\w_-]+[.](jpg|jpeg|gif|png))$', u)
+        if filename:
+            if (('http' not in u) and (url)):
+                # sometimes an image source can be relative
+                # if it is provide the base url
+                u = '{}://{}{}'.format(prot, site, u)
+            if 'http' in u:
+                images.append(u)
+    return images

cookbook/helper/scope_middleware.py

@@ -14,6 +14,12 @@ class ScopeMiddleware:
 
     def __call__(self, request):
         prefix = settings.JS_REVERSE_SCRIPT_PREFIX or ''
+
+        # need to disable scopes for writing requests into userpref and enable for loading ?
+        if request.path.startswith(prefix + '/api/user-preference/'):
+            with scopes_disabled():
+                return self.get_response(request)
+
         if request.user.is_authenticated:
 
             if request.path.startswith(prefix + '/admin/'):
@@ -26,14 +32,23 @@ class ScopeMiddleware:
             if request.path.startswith(prefix + '/accounts/'):
                 return self.get_response(request)
 
-            with scopes_disabled():
-                if request.user.userpreference.space is None and not reverse('account_logout') in request.path:
-                    return views.no_space(request)
+            if request.path.startswith(prefix + '/switch-space/'):
+                return self.get_response(request)
 
-            if request.user.groups.count() == 0 and not reverse('account_logout') in request.path:
+            with scopes_disabled():
+                if request.user.userspace_set.count() == 0 and not reverse('account_logout') in request.path:
+                    return views.space_overview(request)
+
+            # get active user space, if for some reason more than one space is active select first (group permission checks will fail, this is not intended at this point)
+            user_space = request.user.userspace_set.filter(active=True).first()
+
+            if not user_space:
+                return views.space_overview(request)
+
+            if user_space.groups.count() == 0 and not reverse('account_logout') in request.path:
                 return views.no_groups(request)
 
-            request.space = request.user.userpreference.space
+            request.space = user_space.space
             # with scopes_disabled():
             with scope(space=request.space):
                 return self.get_response(request)
@@ -41,9 +56,11 @@ class ScopeMiddleware:
             if request.path.startswith(prefix + '/api/'):
                 try:
                     if auth := TokenAuthentication().authenticate(request):
-                        request.space = auth[0].userpreference.space
-                        with scope(space=request.space):
-                            return self.get_response(request)
+                        user_space = auth[0].userspace_set.filter(active=True).first()
+                        if user_space:
+                            request.space = user_space.space
+                            with scope(space=request.space):
+                                return self.get_response(request)
                 except AuthenticationFailed:
                     pass
 

cookbook/helper/scrapers/scrapers.py

@@ -1,5 +1,6 @@
-from bs4 import BeautifulSoup
 from json import JSONDecodeError
+
+from bs4 import BeautifulSoup
 from recipe_scrapers import SCRAPERS, get_host_name
 from recipe_scrapers._factory import SchemaScraperFactory
 from recipe_scrapers._schemaorg import SchemaOrg
@@ -26,17 +27,17 @@ def text_scraper(text, url=None):
     class TextScraper(scraper_class):
         def __init__(
             self,
-            page_data,
-            url=None
+            html=None,
+            url=None,
         ):
             self.wild_mode = False
             self.meta_http_equiv = False
-            self.soup = BeautifulSoup(page_data, "html.parser")
+            self.soup = BeautifulSoup(html, "html.parser")
             self.url = url
             self.recipe = None
             try:
-                self.schema = SchemaOrg(page_data)
+                self.schema = SchemaOrg(html)
             except (JSONDecodeError, AttributeError):
                 pass
 
-    return TextScraper(text, url)
+    return TextScraper(url=url, html=text)

cookbook/integration/cookbookapp.py

@@ -6,11 +6,13 @@ from gettext import gettext as _
 from io import BytesIO
 
 import requests
+import validators
 import yaml
 
 from cookbook.helper.ingredient_parser import IngredientParser
-from cookbook.helper.recipe_html_import import get_recipe_from_source
-from cookbook.helper.recipe_url_import import iso_duration_to_minutes
+from cookbook.helper.recipe_url_import import (get_from_scraper, get_images_from_soup,
+                                               iso_duration_to_minutes)
+from cookbook.helper.scrapers.scrapers import text_scraper
 from cookbook.integration.integration import Integration
 from cookbook.models import Ingredient, Keyword, Recipe, Step
 
@@ -23,7 +25,10 @@ class CookBookApp(Integration):
     def get_recipe_from_file(self, file):
         recipe_html = file.getvalue().decode("utf-8")
 
-        recipe_json, recipe_tree, html_data, images = get_recipe_from_source(recipe_html, 'CookBookApp', self.request)
+        # recipe_json, recipe_tree, html_data, images = get_recipe_from_source(recipe_html, 'CookBookApp', self.request)
+        scrape = text_scraper(text=recipe_html)
+        recipe_json = get_from_scraper(scrape, self.request)
+        images = list(dict.fromkeys(get_images_from_soup(scrape.soup, None)))
 
         recipe = Recipe.objects.create(
             name=recipe_json['name'].strip(),
@@ -41,7 +46,8 @@ class CookBookApp(Integration):
         except Exception:
             pass
 
-        step = Step.objects.create(instruction=recipe_json['recipeInstructions'], space=self.request.space, )
+        # assuming import files only contain single step
+        step = Step.objects.create(instruction=recipe_json['steps'][0]['instruction'], space=self.request.space, )
 
         if 'nutrition' in recipe_json:
             step.instruction = step.instruction + '\n\n' + recipe_json['nutrition']
@@ -50,17 +56,21 @@ class CookBookApp(Integration):
         recipe.steps.add(step)
 
         ingredient_parser = IngredientParser(self.request, True)
-        for ingredient in recipe_json['recipeIngredient']:
-            f = ingredient_parser.get_food(ingredient['ingredient']['text'])
-            u = ingredient_parser.get_unit(ingredient['unit']['text'])
+        for ingredient in recipe_json['steps'][0]['ingredients']:
+            f = ingredient_parser.get_food(ingredient['food']['name'])
+            u = None
+            if unit := ingredient.get('unit', None):
+                u = ingredient_parser.get_unit(unit.get('name', None))
             step.ingredients.add(Ingredient.objects.create(
-                food=f, unit=u, amount=ingredient['amount'], note=ingredient['note'],  space=self.request.space,
+                food=f, unit=u, amount=ingredient.get('amount', None), note=ingredient.get('note', None),  original_text=ingredient.get('original_text', None), space=self.request.space,
             ))
 
         if len(images) > 0:
             try:
-                response = requests.get(images[0])
-                self.import_recipe_image(recipe, BytesIO(response.content))
+                url = images[0]
+                if validators.url(url, public=True):
+                    response = requests.get(url)
+                    self.import_recipe_image(recipe, BytesIO(response.content))
             except Exception as e:
                 print('failed to import image ', str(e))
 

cookbook/integration/cookmate.py

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

cookbook/integration/copymethat.py

@@ -3,10 +3,9 @@ from io import BytesIO
 from zipfile import ZipFile
 
 from bs4 import BeautifulSoup
-
 from django.utils.translation import gettext as _
+
 from cookbook.helper.ingredient_parser import IngredientParser
-from cookbook.helper.recipe_html_import import get_recipe_from_source
 from cookbook.helper.recipe_url_import import iso_duration_to_minutes, parse_servings
 from cookbook.integration.integration import Integration
 from cookbook.models import Ingredient, Keyword, Recipe, Step
@@ -32,7 +31,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') or type(z) == Tag:
                                     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

@@ -49,6 +49,7 @@ class Plantoeat(Integration):
         )
 
         if tags:
+            tags = tags.replace('^',',')
             for k in tags.split(','):
                 keyword, created = Keyword.objects.get_or_create(name=k.strip(), space=self.request.space)
                 recipe.keywords.add(keyword)
@@ -78,7 +79,11 @@ class Plantoeat(Integration):
         current_recipe = ''
 
         for fl in file.readlines():
-            line = fl.decode("windows-1250")
+            try:
+                line = fl.decode("utf-8")
+            except UnicodeDecodeError:
+                line = fl.decode("windows-1250")
+
             if line.startswith('--------------'):
                 if current_recipe != '':
                     recipe_list.append(current_recipe)

cookbook/integration/recettetek.py

@@ -5,6 +5,7 @@ from io import BytesIO
 from zipfile import ZipFile
 
 import requests
+import validators
 
 from django.utils.translation import gettext as _
 from cookbook.helper.image_processing import get_filetype
@@ -123,11 +124,13 @@ class RecetteTek(Integration):
                         self.import_recipe_image(recipe, BytesIO(import_zip.read(image_file_name)), filetype=get_filetype(image_file_name))
             else:
                 if file['originalPicture'] != '':
-                    response = requests.get(file['originalPicture'])
-                    if imghdr.what(BytesIO(response.content)) is not None:
-                        self.import_recipe_image(recipe, BytesIO(response.content), filetype=get_filetype(file['originalPicture']))
-                    else:
-                        raise Exception("Original image failed to download.")
+                    url = file['originalPicture']
+                    if validators.url(url, public=True):
+                        response = requests.get(url)
+                        if imghdr.what(BytesIO(response.content)) is not None:
+                            self.import_recipe_image(recipe, BytesIO(response.content), filetype=get_filetype(file['originalPicture']))
+                        else:
+                            raise Exception("Original image failed to download.")
         except Exception as e:
             print(recipe.name, ': failed to import image ', str(e))
 

cookbook/integration/recipesage.py

@@ -2,6 +2,7 @@ import json
 from io import BytesIO
 
 import requests
+import validators
 
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
@@ -51,8 +52,10 @@ class RecipeSage(Integration):
 
         if len(file['image']) > 0:
             try:
-                response = requests.get(file['image'][0])
-                self.import_recipe_image(recipe, BytesIO(response.content))
+                url = file['image'][0]
+                if validators.url(url, public=True):
+                    response = requests.get(url)
+                    self.import_recipe_image(recipe, BytesIO(response.content))
             except Exception as e:
                 print('failed to import image ', str(e))
 
@@ -77,14 +80,13 @@ class RecipeSage(Integration):
         }
 
         for s in recipe.steps.all():
-            if s.type != Step.TIME:
-                data['recipeInstructions'].append({
-                    '@type': 'HowToStep',
-                    'text': s.instruction
-                })
+            data['recipeInstructions'].append({
+                '@type': 'HowToStep',
+                'text': s.instruction
+            })
 
-                for i in s.ingredients.all():
-                    data['recipeIngredient'].append(f'{float(i.amount)} {i.unit} {i.food}')
+            for i in s.ingredients.all():
+                data['recipeIngredient'].append(f'{float(i.amount)} {i.unit} {i.food}')
 
         return data
 

cookbook/integration/rezkonv.py

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

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"

cookbook/management/commands/export.py

@@ -0,0 +1,8 @@
+from django.core.management.commands.dumpdata import Command as DumpdataCommand
+from django_scopes import scopes_disabled
+
+
+class Command(DumpdataCommand):
+    def handle(self, *args, **options):
+        with scopes_disabled():
+            return super().handle(*args, **options)

cookbook/management/commands/import.py

@@ -0,0 +1,8 @@
+from django.core.management.commands.loaddata import Command as LoaddataCommand
+from django_scopes import scopes_disabled
+
+
+class Command(LoaddataCommand):
+    def handle(self, *args, **options):
+        with scopes_disabled():
+            return super().handle(*args, **options)

cookbook/managers.py

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

cookbook/migrations/0084_auto_20200922_1233.py

@@ -4,11 +4,12 @@ from django.db import migrations
 
 
 def create_default_space(apps, schema_editor):
-    Space = apps.get_model('cookbook', 'Space')
-    Space.objects.create(
-        name='Default',
-        message=''
-    )
+    # Space = apps.get_model('cookbook', 'Space')
+    # Space.objects.create(
+    #     name='Default',
+    #     message=''
+    # )
+    pass # Beginning with the multi space tenancy version (~something around 1.3) a default space is no longer needed as the first user can create it after setup
 
 
 class Migration(migrations.Migration):

cookbook/migrations/0143_build_full_text_index.py

@@ -9,8 +9,15 @@ from django.utils import translation
 from django_scopes import scopes_disabled
 
 from cookbook.managers import DICTIONARY
-from cookbook.models import (Index, PermissionModelMixin, Recipe, Step, allSearchFields,
-                             nameSearchField)
+from cookbook.models import (Index, PermissionModelMixin, Recipe, Step, SearchFields)
+
+
+def allSearchFields():
+    return list(SearchFields.objects.values_list('id', flat=True))
+
+
+def nameSearchField():
+    return [SearchFields.objects.get(name='Name').id]
 
 
 def set_default_search_vector(apps, schema_editor):

cookbook/migrations/0157_alter_searchpreference_trigram.py

@@ -2,7 +2,12 @@
 from django_scopes import scopes_disabled
 
 from django.db import migrations, models
-from cookbook.models import nameSearchField
+
+from cookbook.models import SearchFields
+
+
+def nameSearchField():
+    return [SearchFields.objects.get(name='Name').id]
 
 
 def add_default_trigram(apps, schema_editor):

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/migrations/0174_alter_food_substitute_userspace.py

@@ -0,0 +1,45 @@
+# Generated by Django 4.0.4 on 2022-05-31 14:10
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+from django_scopes import scopes_disabled
+
+
+def migrate_space_permissions(apps, schema_editor):
+    with scopes_disabled():
+        UserPreference = apps.get_model('cookbook', 'UserPreference')
+        UserSpace = apps.get_model('cookbook', 'UserSpace')
+
+        for up in UserPreference.objects.exclude(space=None).all():
+            us = UserSpace.objects.create(user=up.user, space=up.space, active=True)
+            us.groups.set(up.user.groups.all())
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ('auth', '0012_alter_user_first_name_max_length'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('cookbook', '0173_recipe_source_url'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='food',
+            name='substitute',
+            field=models.ManyToManyField(blank=True, to='cookbook.food'),
+        ),
+        migrations.CreateModel(
+            name='UserSpace',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('active', models.BooleanField(default=False)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('groups', models.ManyToManyField(to='auth.group')),
+                ('space', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='cookbook.space')),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+            ],
+        ),
+        migrations.RunPython(migrate_space_permissions)
+    ]

cookbook/migrations/0175_remove_userpreference_space.py

@@ -0,0 +1,17 @@
+# Generated by Django 4.0.4 on 2022-05-31 14:56
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cookbook', '0174_alter_food_substitute_userspace'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='userpreference',
+            name='space',
+        ),
+    ]

cookbook/migrations/0176_alter_searchpreference_icontains_and_more.py

@@ -0,0 +1,28 @@
+# Generated by Django 4.0.4 on 2022-06-14 14:48
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cookbook', '0175_remove_userpreference_space'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='searchpreference',
+            name='icontains',
+            field=models.ManyToManyField(blank=True, related_name='icontains_fields', to='cookbook.searchfields'),
+        ),
+        migrations.AlterField(
+            model_name='searchpreference',
+            name='trigram',
+            field=models.ManyToManyField(blank=True, related_name='trigram_fields', to='cookbook.searchfields'),
+        ),
+        migrations.AlterField(
+            model_name='searchpreference',
+            name='unaccent',
+            field=models.ManyToManyField(blank=True, related_name='unaccent_fields', to='cookbook.searchfields'),
+        ),
+    ]

cookbook/migrations/0177_recipe_show_ingredient_overview.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.0.4 on 2022-06-26 10:26
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cookbook', '0176_alter_searchpreference_icontains_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='recipe',
+            name='show_ingredient_overview',
+            field=models.BooleanField(default=True),
+        ),
+    ]

cookbook/models.py

@@ -2,9 +2,7 @@ import operator
 import pathlib
 import re
 import uuid
-from collections import OrderedDict
 from datetime import date, timedelta
-from decimal import Decimal
 
 from annoying.fields import AutoOneToOneField
 from django.contrib import auth
@@ -14,10 +12,9 @@ from django.contrib.postgres.search import SearchVectorField
 from django.core.files.uploadedfile import InMemoryUploadedFile, UploadedFile
 from django.core.validators import MinLengthValidator
 from django.db import IntegrityError, models
-from django.db.models import Index, ProtectedError, Q, Subquery
+from django.db.models import Index, ProtectedError, Q
 from django.db.models.fields.related import ManyToManyField
 from django.db.models.functions import Substr
-from django.db.transaction import atomic
 from django.utils import timezone
 from django.utils.translation import gettext as _
 from django_prometheus.models import ExportModelOperationsMixin
@@ -35,6 +32,19 @@ def get_user_name(self):
         return self.username
 
 
+def get_active_space(self):
+    """
+    Returns the active space of a user or in case no space is actives raises an *** exception
+    CAREFUL: cannot be used in django scopes with scope() function because passing None as a scope context means no space checking is enforced (at least I think)!!
+    :param self: user
+    :return: space currently active for user
+    """
+    try:
+        return self.userspace_set.filter(active=True).first().space
+    except AttributeError:
+        return None
+
+
 def get_shopping_share(self):
     # get list of users that shared shopping list with user. Django ORM forbids this type of query, so raw is required
     return User.objects.raw(' '.join([
@@ -49,6 +59,7 @@ def get_shopping_share(self):
 
 auth.models.User.add_to_class('get_user_name', get_user_name)
 auth.models.User.add_to_class('get_shopping_share', get_shopping_share)
+auth.models.User.add_to_class('get_active_space', get_active_space)
 
 
 def get_model_name(model):
@@ -241,9 +252,57 @@ 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 safe_delete(self):
+        """
+        Safely deletes a space by deleting all objects belonging to the space first and then deleting the space itself
+        """
+        CookLog.objects.filter(space=self).delete()
+        ViewLog.objects.filter(space=self).delete()
+        ImportLog.objects.filter(space=self).delete()
+        BookmarkletImport.objects.filter(space=self).delete()
+        CustomFilter.objects.filter(space=self).delete()
+
+        Comment.objects.filter(recipe__space=self).delete()
+        Keyword.objects.filter(space=self).delete()
+        Ingredient.objects.filter(space=self).delete()
+        Food.objects.filter(space=self).delete()
+        Unit.objects.filter(space=self).delete()
+        Step.objects.filter(space=self).delete()
+        NutritionInformation.objects.filter(space=self).delete()
+        RecipeBookEntry.objects.filter(book__space=self).delete()
+        RecipeBook.objects.filter(space=self).delete()
+        MealType.objects.filter(space=self).delete()
+        MealPlan.objects.filter(space=self).delete()
+        ShareLink.objects.filter(space=self).delete()
+        Recipe.objects.filter(space=self).delete()
+
+        RecipeImport.objects.filter(space=self).delete()
+        SyncLog.objects.filter(sync__space=self).delete()
+        Sync.objects.filter(space=self).delete()
+        Storage.objects.filter(space=self).delete()
+
+        ShoppingListEntry.objects.filter(shoppinglist__space=self).delete()
+        ShoppingListRecipe.objects.filter(shoppinglist__space=self).delete()
+        ShoppingList.objects.filter(space=self).delete()
+
+        SupermarketCategoryRelation.objects.filter(supermarket__space=self).delete()
+        SupermarketCategory.objects.filter(space=self).delete()
+        Supermarket.objects.filter(space=self).delete()
+
+        InviteLink.objects.filter(space=self).delete()
+        UserFile.objects.filter(space=self).delete()
+        Automation.objects.filter(space=self).delete()
+        self.delete()
+
+    def get_owner(self):
+        return self.created_by
+
+    def get_space(self):
+        return self
+
     def __str__(self):
         return self.name
 
@@ -337,16 +396,28 @@ 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)
     objects = ScopedManager(space='space')
 
     def __str__(self):
         return str(self.user)
 
 
+class UserSpace(models.Model, PermissionModelMixin):
+    user = models.ForeignKey(User, on_delete=models.CASCADE)
+    space = models.ForeignKey(Space, on_delete=models.CASCADE)
+    groups = models.ManyToManyField(Group)
+
+    # there should always only be one active space although permission methods are written in such a way
+    # that having more than one active space should just break certain parts of the application and not leak any data
+    active = models.BooleanField(default=False)
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+
 class Storage(models.Model, PermissionModelMixin):
     DROPBOX = 'DB'
     NEXTCLOUD = 'NEXTCLOUD'
@@ -496,11 +567,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,20 +604,21 @@ 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)
 
         # remove all inherited fields from food
-        Through = Food.objects.filter(tree_filter).first().inherit_fields.through
-        Through.objects.all().delete()
+        trough = Food.inherit_fields.through
+        trough.objects.all().delete()
+        
         # food is going to inherit attributes
         if len(inherit) > 0:
             # ManyToMany cannot be updated through an UPDATE operation
             for i in inherit:
-                Through.objects.bulk_create([
-                    Through(food_id=x, foodinheritfield_id=i['id'])
+                trough.objects.bulk_create([
+                    trough(food_id=x, foodinheritfield_id=i['id'])
                     for x in Food.objects.filter(tree_filter).values_list('id', flat=True)
                 ])
 
@@ -593,6 +665,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 +737,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 +747,10 @@ 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)
+    show_ingredient_overview = models.BooleanField(default=True)
+
+    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)
@@ -1078,14 +1151,6 @@ class SearchFields(models.Model, PermissionModelMixin):
         return _(self.name)
 
 
-def allSearchFields():
-    return list(SearchFields.objects.values_list('id', flat=True))
-
-
-def nameSearchField():
-    return [SearchFields.objects.get(name='Name').id]
-
-
 class SearchPreference(models.Model, PermissionModelMixin):
     # Search Style (validation parsleyjs.org)
     # phrase or plain or raw (websearch and trigrams are mutually exclusive)
@@ -1104,10 +1169,10 @@ class SearchPreference(models.Model, PermissionModelMixin):
     search = models.CharField(choices=SEARCH_STYLE, max_length=32, default=SIMPLE)
 
     lookup = models.BooleanField(default=False)
-    unaccent = models.ManyToManyField(SearchFields, related_name="unaccent_fields", blank=True, default=allSearchFields)
-    icontains = models.ManyToManyField(SearchFields, related_name="icontains_fields", blank=True, default=nameSearchField)
+    unaccent = models.ManyToManyField(SearchFields, related_name="unaccent_fields", blank=True)
+    icontains = models.ManyToManyField(SearchFields, related_name="icontains_fields", blank=True)
     istartswith = models.ManyToManyField(SearchFields, related_name="istartswith_fields", blank=True)
-    trigram = models.ManyToManyField(SearchFields, related_name="trigram_fields", blank=True, default=nameSearchField)
+    trigram = models.ManyToManyField(SearchFields, related_name="trigram_fields", blank=True)
     fulltext = models.ManyToManyField(SearchFields, related_name="fulltext_fields", blank=True)
     trigram_threshold = models.DecimalField(default=0.2, decimal_places=2, max_digits=3)
 

cookbook/provider/dropbox.py

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

cookbook/provider/nextcloud.py

@@ -4,6 +4,7 @@ import tempfile
 from datetime import datetime
 
 import requests
+import validators
 import webdav3.client as wc
 from cookbook.models import Recipe, RecipeImport, SyncLog
 from cookbook.provider.provider import Provider
@@ -92,20 +93,21 @@ class Nextcloud(Provider):
             "Content-Type": "application/json"
         }
 
-        r = requests.get(
-            url,
-            headers=headers,
-            auth=HTTPBasicAuth(
-                recipe.storage.username, recipe.storage.password
+        if validators.url(url, public=True):
+            r = requests.get(
+                url,
+                headers=headers,
+                auth=HTTPBasicAuth(
+                    recipe.storage.username, recipe.storage.password
+                )
             )
-        )
 
-        response_json = r.json()
-        for element in response_json['ocs']['data']:
-            if element['share_type'] == '3':
-                return element['url']
+            response_json = r.json()
+            for element in response_json['ocs']['data']:
+                if element['share_type'] == '3':
+                    return element['url']
 
-        return Nextcloud.create_share_link(recipe)
+            return Nextcloud.create_share_link(recipe)
 
     @staticmethod
     def get_file(recipe):

cookbook/serializer.py

@@ -1,26 +1,35 @@
-from datetime import timedelta
+import traceback
+from datetime import datetime, timedelta
 from decimal import Decimal
 from gettext import gettext as _
+from html import escape
+from smtplib import SMTPException
 
-from django.contrib.auth.models import User
+from django.contrib.auth.models import Group, User
+from django.core.mail import send_mail
 from django.db.models import Avg, Q, QuerySet, Sum
+from django.http import BadHeaderError
 from django.urls import reverse
 from django.utils import timezone
+from django_scopes import scopes_disabled
 from drf_writable_nested import UniqueFieldsMixin, WritableNestedModelSerializer
+from PIL import Image
 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,
-                             MealPlan, MealType, NutritionInformation, Recipe, RecipeBook,
+                             ExportLog, Food, FoodInheritField, ImportLog, Ingredient, InviteLink,
+                             Keyword, MealPlan, MealType, NutritionInformation, Recipe, RecipeBook,
                              RecipeBookEntry, RecipeImport, ShareLink, ShoppingList,
-                             ShoppingListEntry, ShoppingListRecipe, Step, Storage, Supermarket,
-                             SupermarketCategory, SupermarketCategoryRelation, Sync, SyncLog, Unit,
-                             UserFile, UserPreference, ViewLog)
+                             ShoppingListEntry, ShoppingListRecipe, Space, Step, Storage,
+                             Supermarket, SupermarketCategory, SupermarketCategoryRelation, Sync,
+                             SyncLog, Unit, UserFile, UserPreference, UserSpace, ViewLog)
 from cookbook.templatetags.custom_tags import markdown
-from recipes.settings import MEDIA_URL
+from recipes.settings import AWS_ENABLED, MEDIA_URL
 
 
 class ExtendedRecipeMixin(serializers.ModelSerializer):
@@ -41,7 +50,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 +64,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 +105,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()
@@ -108,12 +124,98 @@ class SpaceFilterSerializer(serializers.ListSerializer):
             # if query is sliced it came from api request not nested serializer
             return super().to_representation(data)
         if self.child.Meta.model == User:
-            data = data.filter(userpreference__space=self.context['request'].space)
+            data = data.filter(userspace__space=self.context['request'].user.get_active_space()).all()
         else:
             data = data.filter(**{'__'.join(data.model.get_space_key()): self.context['request'].space})
         return super().to_representation(data)
 
 
+class UserNameSerializer(WritableNestedModelSerializer):
+    username = serializers.SerializerMethodField('get_user_label')
+
+    def get_user_label(self, obj):
+        return obj.get_user_name()
+
+    class Meta:
+        list_serializer_class = SpaceFilterSerializer
+        model = User
+        fields = ('id', 'username')
+
+
+class GroupSerializer(UniqueFieldsMixin, WritableNestedModelSerializer):
+    def create(self, validated_data):
+        raise ValidationError('Cannot create using this endpoint')
+
+    def update(self, instance, validated_data):
+        return instance  # cannot update group
+
+    class Meta:
+        model = Group
+        fields = ('id', 'name')
+
+
+class FoodInheritFieldSerializer(UniqueFieldsMixin, WritableNestedModelSerializer):
+    name = serializers.CharField(allow_null=True, allow_blank=True, required=False)
+    field = serializers.CharField(allow_null=True, allow_blank=True, required=False)
+
+    def create(self, validated_data):
+        raise ValidationError('Cannot create using this endpoint')
+
+    def update(self, instance, validated_data):
+        return instance
+
+    class Meta:
+        model = FoodInheritField
+        fields = ('id', 'name', 'field',)
+        read_only_fields = ['id']
+
+
+class SpaceSerializer(WritableNestedModelSerializer):
+    user_count = serializers.SerializerMethodField('get_user_count')
+    recipe_count = serializers.SerializerMethodField('get_recipe_count')
+    file_size_mb = serializers.SerializerMethodField('get_file_size_mb')
+    food_inherit = FoodInheritFieldSerializer(many=True)
+
+    def get_user_count(self, obj):
+        return UserSpace.objects.filter(space=obj).count()
+
+    def get_recipe_count(self, obj):
+        return Recipe.objects.filter(space=obj).count()
+
+    def get_file_size_mb(self, obj):
+        try:
+            return UserFile.objects.filter(space=obj).aggregate(Sum('file_size_kb'))['file_size_kb__sum'] / 1000
+        except TypeError:
+            return 0
+
+    def create(self, validated_data):
+        raise ValidationError('Cannot create using this endpoint')
+
+    class Meta:
+        model = Space
+        fields = ('id', 'name', 'created_by', 'created_at', 'message', 'max_recipes', 'max_file_storage_mb', 'max_users',
+                  'allow_sharing', 'demo', 'food_inherit', 'show_facet_count', 'user_count', 'recipe_count', 'file_size_mb',)
+        read_only_fields = ('id', 'created_by', 'created_at', 'max_recipes', 'max_file_storage_mb', 'max_users', 'allow_sharing', 'demo',)
+
+
+class UserSpaceSerializer(WritableNestedModelSerializer):
+    user = UserNameSerializer(read_only=True)
+    groups = GroupSerializer(many=True)
+
+    def validate(self, data):
+        if self.instance.user == self.context['request'].space.created_by:  # can't change space owner permission
+            raise serializers.ValidationError(_('Cannot modify Space owner permission.'))
+        return super().validate(data)
+
+    def create(self, validated_data):
+        raise ValidationError('Cannot create using this endpoint')
+
+    class Meta:
+        model = UserSpace
+        fields = ('id', 'user', 'space', 'groups', 'active', 'created_at', 'updated_at',)
+        read_only_fields = ('id', 'created_at', 'updated_at', 'space')
+
+
 class SpacedModelSerializer(serializers.ModelSerializer):
     def create(self, validated_data):
         validated_data['space'] = self.context['request'].space
@@ -133,64 +235,54 @@ class MealTypeSerializer(SpacedModelSerializer, WritableNestedModelSerializer):
         read_only_fields = ('created_by',)
 
 
-class UserNameSerializer(WritableNestedModelSerializer):
-    username = serializers.SerializerMethodField('get_user_label')
-
-    def get_user_label(self, obj):
-        return obj.get_user_name()
-
-    class Meta:
-        list_serializer_class = SpaceFilterSerializer
-        model = User
-        fields = ('id', 'username')
-
-
-class FoodInheritFieldSerializer(WritableNestedModelSerializer):
-    name = serializers.CharField(allow_null=True, allow_blank=True, required=False)
-    field = serializers.CharField(allow_null=True, allow_blank=True, required=False)
-
-    def create(self, validated_data):
-        # don't allow writing to FoodInheritField via API
-        return FoodInheritField.objects.get(**validated_data)
-
-    def update(self, instance, validated_data):
-        # don't allow writing to FoodInheritField via API
-        return FoodInheritField.objects.get(**validated_data)
-
-    class Meta:
-        model = FoodInheritField
-        fields = ('id', 'name', 'field',)
-        read_only_fields = ['id']
-
-
 class UserPreferenceSerializer(WritableNestedModelSerializer):
-    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)
+    food_inherit_default = serializers.SerializerMethodField('get_food_inherit_defaults')
+    plan_share = UserNameSerializer(many=True, allow_null=True, required=False)
     shopping_share = UserNameSerializer(many=True, allow_null=True, required=False)
     food_children_exist = serializers.SerializerMethodField('get_food_children_exist')
 
+    def get_food_inherit_defaults(self, obj):
+        return FoodInheritFieldSerializer(obj.user.get_active_space().food_inherit.all(), many=True).data
+
     def get_food_children_exist(self, obj):
         space = getattr(self.context.get('request', None), 'space', None)
         return Food.objects.filter(depth__gt=0, space=space).exists()
 
+    def update(self, instance, validated_data):
+        with scopes_disabled():
+            return super().update(instance, validated_data)
+
     def create(self, validated_data):
-        if not validated_data.get('user', None):
-            raise ValidationError(_('A user is required'))
-        if (validated_data['user'] != self.context['request'].user):
-            raise NotFound()
-        return super().create(validated_data)
+        raise ValidationError('Cannot create using this endpoint')
 
     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'
         )
 
 
 class UserFileSerializer(serializers.ModelSerializer):
+    file = serializers.FileField(write_only=True)
+    file_download = serializers.SerializerMethodField('get_download_link')
+    preview = serializers.SerializerMethodField('get_preview_link')
+
+    def get_download_link(self, obj):
+        return self.context['request'].build_absolute_uri(reverse('api_download_file', args={obj.pk}))
+
+    def get_preview_link(self, obj):
+        try:
+            img = Image.open(obj.file.file.file)
+            return self.context['request'].build_absolute_uri(obj.file.url)
+        except Exception:
+            traceback.print_exc()
+            return ""
 
     def check_file_limit(self, validated_data):
         if 'file' in validated_data:
@@ -220,12 +312,25 @@ class UserFileSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = UserFile
-        fields = ('name', 'file', 'file_size_kb', 'id',)
+        fields = ('id', 'name', 'file', 'file_download', 'preview', 'file_size_kb')
         read_only_fields = ('id', 'file_size_kb')
         extra_kwargs = {"file": {"required": False, }}
 
 
 class UserFileViewSerializer(serializers.ModelSerializer):
+    file_download = serializers.SerializerMethodField('get_download_link')
+    preview = serializers.SerializerMethodField('get_preview_link')
+
+    def get_download_link(self, obj):
+        return self.context['request'].build_absolute_uri(reverse('api_download_file', args={obj.pk}))
+
+    def get_preview_link(self, obj):
+        try:
+            img = Image.open(obj.file.file.file)
+            return self.context['request'].build_absolute_uri(obj.file.url)
+        except Exception:
+            traceback.print_exc()
+            return ""
 
     def create(self, validated_data):
         raise ValidationError('Cannot create File over this view')
@@ -235,7 +340,7 @@ class UserFileViewSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = UserFile
-        fields = ('name', 'file', 'id',)
+        fields = ('id', 'name', 'file_download', 'preview')
         read_only_fields = ('id', 'file')
 
 
@@ -364,23 +469,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 +514,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 +539,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 +586,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 +607,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 +737,17 @@ class RecipeSerializer(RecipeBaseSerializer):
         model = Recipe
         fields = (
             'id', 'name', 'description', 'image', 'keywords', 'steps', 'working_time',
-            'waiting_time', 'created_by', 'created_at', 'updated_at',
-            'internal', 'nutrition', 'servings', 'file_path', 'servings_text', 'rating', 'last_cooked',
+            'waiting_time', 'created_by', 'created_at', 'updated_at', 'source_url',
+            'internal', 'show_ingredient_overview', '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 +755,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 +815,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 +845,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,7 +869,8 @@ 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)
@@ -814,7 +947,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 +1046,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',)
 
 
@@ -930,15 +1067,59 @@ class AutomationSerializer(serializers.ModelSerializer):
         read_only_fields = ('created_by',)
 
 
+class InviteLinkSerializer(WritableNestedModelSerializer):
+    group = GroupSerializer()
+
+    def create(self, validated_data):
+        validated_data['created_by'] = self.context['request'].user
+        validated_data['space'] = self.context['request'].space
+        obj = super().create(validated_data)
+
+        if obj.email:
+            try:
+                if InviteLink.objects.filter(space=self.context['request'].space, created_at__gte=datetime.now() - timedelta(hours=4)).count() < 20:
+                    message = _('Hello') + '!\n\n' + _('You have been invited by ') + escape(self.context['request'].user.username)
+                    message += _(' to join their Tandoor Recipes space ') + escape(self.context['request'].space.name) + '.\n\n'
+                    message += _('Click the following link to activate your account: ') + self.context['request'].build_absolute_uri(reverse('view_invite', args=[str(obj.uuid)])) + '\n\n'
+                    message += _('If the link does not work use the following code to manually join the space: ') + str(obj.uuid) + '\n\n'
+                    message += _('The invitation is valid until ') + str(obj.valid_until) + '\n\n'
+                    message += _('Tandoor Recipes is an Open Source recipe manager. Check it out on GitHub ') + 'https://github.com/vabene1111/recipes/'
+
+                    send_mail(
+                        _('Tandoor Recipes Invite'),
+                        message,
+                        None,
+                        [obj.email],
+                        fail_silently=True,
+                    )
+            except (SMTPException, BadHeaderError, TimeoutError):
+                pass
+
+        return obj
+
+    class Meta:
+        model = InviteLink
+        fields = (
+            'id', 'uuid', 'email', 'group', 'valid_until', 'used_by', 'created_by', 'created_at',)
+        read_only_fields = ('id', 'uuid', 'created_by', 'created_at',)
+
+
 # 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
+        validated_data['space'] = self.context['request'].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 +1205,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,10 +1218,21 @@ 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
         fields = ['id', 'amount', 'unit', 'delete', ]
+
+
+# non model serializers
+
+class RecipeFromSourceSerializer(serializers.Serializer):
+    url = serializers.CharField(max_length=4096, required=False, allow_null=True, allow_blank=True)
+    data = serializers.CharField(required=False, allow_null=True, allow_blank=True)
+    bookmarklet = serializers.IntegerField(required=False, allow_null=True, )

cookbook/signals.py

@@ -2,16 +2,17 @@ from decimal import Decimal
 from functools import wraps
 
 from django.conf import settings
+from django.contrib.auth.models import User
 from django.contrib.postgres.search import SearchVector
 from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.utils import translation
-from django_scopes import scope
+from django_scopes import scope, scopes_disabled
 
 from cookbook.helper.shopping_helper import RecipeShoppingEditor
 from cookbook.managers import DICTIONARY
 from cookbook.models import (Food, FoodInheritField, Ingredient, MealPlan, Recipe,
-                             ShoppingListEntry, Step)
+                             ShoppingListEntry, Step, UserPreference, SearchPreference, SearchFields)
 
 SQLITE = True
 if settings.DATABASES['default']['ENGINE'] in ['django.db.backends.postgresql_psycopg2',
@@ -28,9 +29,26 @@ def skip_signal(signal_func):
         if hasattr(instance, 'skip_signal'):
             return None
         return signal_func(sender, instance, **kwargs)
+
     return _decorator
 
 
+@receiver(post_save, sender=User)
+def create_user_preference(sender, instance=None, created=False, **kwargs):
+    if created:
+        with scopes_disabled():
+            UserPreference.objects.get_or_create(user=instance)
+
+
+@receiver(post_save, sender=SearchPreference)
+def create_search_preference(sender, instance=None, created=False, **kwargs):
+    if created:
+        with scopes_disabled():
+            instance.unaccent.add(SearchFields.objects.get(name='Name'))
+            instance.icontains.add(SearchFields.objects.get(name='Name'))
+            instance.trigram.add(SearchFields.objects.get(name='Name'))
+
+
 @receiver(post_save, sender=Recipe)
 @skip_signal
 def update_recipe_search_vector(sender, instance=None, created=False, **kwargs):
@@ -104,21 +122,30 @@ 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");