Merge branch 'develop'

Update en.json

.dockerignore

@@ -3,7 +3,6 @@ npm-debug.log
 Dockerfile*
 docker-compose*
 .dockerignore
-.git
 .gitignore
 README.md
 LICENSE

.env.template

@@ -2,6 +2,10 @@
 # when unset: 1 (true) - dont unset this, just for development
 DEBUG=0
 SQL_DEBUG=0
+DEBUG_TOOLBAR=0
+# Gunicorn log level for debugging (default value is "info" when unset)
+# (see https://docs.gunicorn.org/en/stable/settings.html#loglevel for available settings)
+# GUNICORN_LOG_LEVEL="debug"
 
 # HTTP port to bind to
 # TANDOOR_PORT=8080
@@ -96,10 +100,12 @@ GUNICORN_MEDIA=0
 # 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/
+# allow authentication via the REMOTE-USER header (can be used for e.g. authelia).
+# ATTENTION: Leave off if you don't know what you are doing! Enabling this without proper configuration will enable anybody
+#   to login with any username!
+# See docs for additional information: https://docs.tandoor.dev/features/authentication/#reverse-proxy-authentication
 # when unset: 0 (false)
-REVERSE_PROXY_AUTH=0
+REMOTE_USER_AUTH=0
 
 # Default settings for spaces, apply per space and can be changed in the admin view
 # SPACE_DEFAULT_MAX_RECIPES=0 # 0=unlimited recipes
@@ -126,7 +132,7 @@ REVERSE_PROXY_AUTH=0
 # ENABLE_METRICS=0
 
 # allows you to setup OAuth providers
-# see docs for more information https://vabene1111.github.io/recipes/features/authentication/
+# see docs for more information https://docs.tandoor.dev/features/authentication/
 # SOCIAL_PROVIDERS = allauth.socialaccount.providers.github, allauth.socialaccount.providers.nextcloud,
 
 # Should a newly created user from a social provider get assigned to the default space and given permission by default ?
@@ -157,6 +163,7 @@ REVERSE_PROXY_AUTH=0
 #AUTH_LDAP_BIND_PASSWORD=
 #AUTH_LDAP_USER_SEARCH_BASE_DN=
 #AUTH_LDAP_TLS_CACERTFILE=
+#AUTH_LDAP_START_TLS=
 
 # Enables exporting PDF (see export docs)
 # Disabled by default, uncomment to enable

.github/dependabot.yml

@@ -14,3 +14,8 @@ updates:
     directory: "/vue/"
     schedule:
       interval: "monthly"
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"

.github/workflows/build-docker-open-data.yml

@@ -0,0 +1,110 @@
+name: Build Docker Container with open data plugin installed
+
+on: push
+
+jobs:
+  build-container:
+    name: Build ${{ matrix.name }} Container
+    runs-on: ubuntu-latest
+    if: github.repository_owner == 'TandoorRecipes'
+    continue-on-error: ${{ matrix.continue-on-error }}
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      matrix:
+        include:
+          # Standard build config
+          - name: Standard
+            dockerfile: Dockerfile
+            platforms: linux/amd64,linux/arm64
+            suffix: ""
+            continue-on-error: false
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Get version number
+        id: get_version
+        run: |
+          if [[ "$GITHUB_REF" = refs/tags/* ]]; then
+            echo "VERSION=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_OUTPUT
+          elif [[ "$GITHUB_REF" = refs/heads/beta ]]; then
+            echo VERSION=beta >> $GITHUB_OUTPUT
+          else
+            echo VERSION=develop >> $GITHUB_OUTPUT
+          fi
+
+      # clone open data plugin
+      - name: clone open data plugin repo
+        uses: actions/checkout@master
+        with:
+          repository: TandoorRecipes/open_data_plugin
+          ref: master
+          path: ./recipes/plugins/open_data_plugin
+
+      # Build Vue frontend
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+          cache: yarn
+          cache-dependency-path: vue/yarn.lock
+      - name: Install dependencies
+        working-directory: ./vue
+        run: yarn install --frozen-lockfile
+      - name: Build dependencies
+        working-directory: ./vue
+        run: yarn build
+
+      - name: Setup Open Data Plugin Links
+        working-directory: ./recipes/plugins/open_data_plugin
+        run: python setup_repo.py
+        
+      - name: Build Open Data Frontend
+        working-directory: ./recipes/plugins/open_data_plugin/vue
+        run: yarn build
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      - name: Set up Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        if: github.secret_source == 'Actions'
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        if: github.secret_source == 'Actions'
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ github.token }}
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            vabene1111/recipes
+            ghcr.io/TandoorRecipes/recipes
+          flavor: |
+            latest=false
+            suffix=${{ matrix.suffix }}
+          tags: |
+            type=raw,value=latest,suffix=-open-data-plugin,enable=${{ startsWith(github.ref, 'refs/tags/') }}
+            type=semver,suffix=-open-data-plugin,pattern={{version}}
+            type=semver,suffix=-open-data-plugin,pattern={{major}}.{{minor}}
+            type=semver,suffix=-open-data-plugin,pattern={{major}}
+            type=ref,suffix=-open-data-plugin,event=branch
+      - name: Build and Push
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          file: ${{ matrix.dockerfile }}
+          pull: true
+          push: ${{ github.secret_source == 'Actions' }}
+          platforms: ${{ matrix.platforms }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/build-docker.yml

@@ -0,0 +1,126 @@
+name: Build Docker Container
+
+on: push
+
+jobs:
+  build-container:
+    name: Build ${{ matrix.name }} Container
+    runs-on: ubuntu-latest
+    if: github.repository_owner == 'TandoorRecipes'
+    continue-on-error: ${{ matrix.continue-on-error }}
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      matrix:
+        include:
+          # Standard build config
+          - name: Standard
+            dockerfile: Dockerfile
+            platforms: linux/amd64,linux/arm64,linux/arm/v7
+            suffix: ""
+            continue-on-error: false
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Get version number
+        id: get_version
+        run: |
+          if [[ "$GITHUB_REF" = refs/tags/* ]]; then
+            echo "VERSION=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_OUTPUT
+          elif [[ "$GITHUB_REF" = refs/heads/beta ]]; then
+            echo VERSION=beta >> $GITHUB_OUTPUT
+          else
+            echo VERSION=develop >> $GITHUB_OUTPUT
+          fi
+
+      # Build Vue frontend
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+          cache: yarn
+          cache-dependency-path: vue/yarn.lock
+      - name: Install dependencies
+        working-directory: ./vue
+        run: yarn install --frozen-lockfile
+      - name: Build dependencies
+        working-directory: ./vue
+        run: yarn build
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      - name: Set up Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        if: github.secret_source == 'Actions'
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        if: github.secret_source == 'Actions'
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ github.token }}
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            vabene1111/recipes
+            ghcr.io/TandoorRecipes/recipes
+          flavor: |
+            latest=false
+            suffix=${{ matrix.suffix }}
+          tags: |
+            type=raw,value=latest,enable=${{ startsWith(github.ref, 'refs/tags/') }}
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=ref,event=branch
+      - name: Build and Push
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          file: ${{ matrix.dockerfile }}
+          pull: true
+          push: ${{ github.secret_source == 'Actions' }}
+          platforms: ${{ matrix.platforms }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+  notify-stable:
+    name: Notify Stable
+    runs-on: ubuntu-latest
+    needs: build-container
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - name: Set tag name
+        run: |
+          # Strip "refs/tags/" prefix
+          echo "VERSION=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
+      # Send stable discord notification
+      - name: Discord notification
+        env:
+          DISCORD_WEBHOOK: ${{ secrets.DISCORD_RELEASE_WEBHOOK }}
+        uses: Ilshidur/action-discord@0.3.2
+        with:
+          args: '🚀 Version {{ VERSION }} of tandoor has been released 🥳 Check it out https://github.com/vabene1111/recipes/releases/tag/{{ VERSION }}'
+
+  notify-beta:
+    name: Notify Beta
+    runs-on: ubuntu-latest
+    needs: build-container
+    if: github.ref == 'refs/heads/beta'
+    steps:
+      # Send beta 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/ci.yml

@@ -1,6 +1,6 @@
 name: Continuous Integration
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   build:
@@ -12,15 +12,15 @@ jobs:
         python-version: ['3.10']
 
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
     - name: Set up Python 3.10
-      uses: actions/setup-python@v1
+      uses: actions/setup-python@v4
       with:
         python-version: '3.10'
     # Build Vue frontend
-    - uses: actions/setup-node@v2
+    - uses: actions/setup-node@v3
       with:
-        node-version: '14'
+        node-version: '18'
     - name: Install Vue dependencies
       working-directory: ./vue
       run: yarn install
@@ -30,7 +30,7 @@ jobs:
     - name: Install Django dependencies
       run: |
         sudo apt-get -y update
-        sudo apt-get install -y libsasl2-dev python-dev libldap2-dev libssl-dev
+        sudo apt-get install -y libsasl2-dev python3-dev libldap2-dev libssl-dev
         python -m pip install --upgrade pip
         pip install -r requirements.txt
         python3 manage.py collectstatic --noinput

.github/workflows/codeql-analysis.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           # We must fetch at least the immediate parents so that if this is
           # a pull request then we can checkout the head.
@@ -25,7 +25,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v1
+        uses: github/codeql-action/init@v2
         # Override language selection by uncommenting this and choosing your languages
         with:
           languages: python, javascript
@@ -47,6 +47,6 @@ jobs:
       #   make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v1
+        uses: github/codeql-action/analyze@v2
         with:
           languages: javascript, python

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

@@ -1,48 +0,0 @@
-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

@@ -1,47 +0,0 @@
-name: publish beta 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
-          platform: linux/amd64,linux/arm64
-          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-dev.yml

@@ -1,42 +0,0 @@
-name: publish dev image docker
-on:
-  push:
-    branches:
-      - '*'
-      - '*/*'
-      - '!master'
-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 = 'develop'
-            BUILD_REF = '${{ github.sha }}'
-          write-mode: overwrite
-      # Build Vue frontend
-      - uses: actions/setup-node@v2
-        with:
-          node-version: '14'
-      - name: Clear Cache
-        working-directory: ./vue
-        run: yarn cache clean --all
-      - name: Install dependencies
-        working-directory: ./vue
-        run: yarn install
-      - name: Build dependencies
-        working-directory: ./vue
-        run: yarn build
-      # Build container
-      - name: Publish to Registry
-        uses: elgohr/Publish-Docker-Github-Action@2.13
-        with:
-          name: vabene1111/recipes
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}

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

@@ -1,45 +0,0 @@
-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

@@ -1,44 +0,0 @@
-name: publish latest 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\//}
-      # 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
-          platform: linux/amd64,linux/arm64
-          tag: latest
-          dockerUser: ${{ secrets.DOCKER_USERNAME }}
-          dockerPassword: ${{ secrets.DOCKER_PASSWORD }}

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

@@ -1,47 +0,0 @@
-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

@@ -1,53 +0,0 @@
-name: publish tagged 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
-          platform: linux/amd64,linux/arm64
-          tag: ${{ steps.get_version.outputs.VERSION }}
-          dockerUser: ${{ secrets.DOCKER_USERNAME }}
-          dockerPassword: ${{ secrets.DOCKER_PASSWORD }}
-      # Send discord notification
-      - name: Discord notification
-        env:
-          DISCORD_WEBHOOK: ${{ secrets.DISCORD_RELEASE_WEBHOOK }}
-        uses: Ilshidur/action-discord@0.3.2
-        with:
-          args: '🚀 Version {{ EVENT_PAYLOAD.release.tag_name }} of tandoor has been released 🥳 Check it out https://github.com/vabene1111/recipes/releases/tag/{{ EVENT_PAYLOAD.release.tag_name }}'

.github/workflows/docs.yml

@@ -9,8 +9,8 @@ jobs:
     if: github.repository_owner == 'TandoorRecipes'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
         with:
           python-version: 3.x
       - run: pip install mkdocs-material mkdocs-include-markdown-plugin

.gitignore

@@ -78,9 +78,11 @@ postgresql/
 
 /docker-compose.override.yml
 vue/node_modules
+plugins
 .vscode/
 vetur.config.js
 cookbook/static/vue
 vue/webpack-stats.json
 cookbook/templates/sw.js
 .prettierignore
+vue/.yarn

.idea/dictionaries/vaben.xml

@@ -0,0 +1,8 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="vaben">
+    <words>
+      <w>pinia</w>
+      <w>selfhosted</w>
+    </words>
+  </dictionary>
+</component>

.idea/recipes.iml

@@ -18,7 +18,7 @@
       <excludeFolder url="file://$MODULE_DIR$/staticfiles" />
       <excludeFolder url="file://$MODULE_DIR$/venv" />
     </content>
-    <orderEntry type="jdk" jdkName="Python 3.9 (recipes)" jdkType="Python SDK" />
+    <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
   <component name="TemplatesService">

.idea/vcs.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="" vcs="Git" />
   </component>
 </project>

Dockerfile

@@ -1,7 +1,7 @@
-FROM python:3.10-alpine3.15
+FROM python:3.10-alpine3.18
 
 #Install all dependencies.
-RUN apk add --no-cache postgresql-libs postgresql-client gettext zlib libjpeg libwebp libxml2-dev libxslt-dev py-cryptography openldap
+RUN apk add --no-cache postgresql-libs postgresql-client gettext zlib libjpeg libwebp libxml2-dev libxslt-dev openldap git
 
 #Print all logs without buffering it.
 ENV PYTHONUNBUFFERED 1
@@ -15,7 +15,11 @@ 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 openssl-dev libffi-dev cargo openldap-dev python3-dev git && \
+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 postgresql-dev zlib-dev jpeg-dev libwebp-dev openssl-dev libffi-dev cargo openldap-dev python3-dev && \
     echo -n "INPUT ( libldap.so )" > /usr/lib/libldap_r.so && \
     python -m venv venv && \
     /opt/recipes/venv/bin/python -m pip install --upgrade pip && \
@@ -26,5 +30,11 @@ RUN apk add --no-cache --virtual .build-deps gcc musl-dev postgresql-dev zlib-de
 
 #Copy project and execute it.
 COPY . ./
+
+# collect information from git repositories
+RUN /opt/recipes/venv/bin/python version.py
+# delete git repositories to reduce image size
+RUN find . -type d -name ".git" | xargs rm -rf
+
 RUN chmod +x boot.sh
 ENTRYPOINT ["/opt/recipes/boot.sh"]

Dockerfile-raspi

@@ -1,33 +0,0 @@
-# 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"]

SECURITY.md

@@ -6,5 +6,4 @@ Since this software is still considered beta/WIP support is always only given fo
 
 ## Reporting a Vulnerability
 
-Please open a normal public issue if you have any security related concerns. If you feel like the issue should not be discussed in 
-public just open a generic issue and we will discuss further communication there (since GitHub does not allow everyone to create a security advisory :/).
+Please use GitHub Security Advisories to report any kind of security vulnerabilities.

boot.sh

@@ -4,6 +4,7 @@ source venv/bin/activate
 TANDOOR_PORT="${TANDOOR_PORT:-8080}"
 GUNICORN_WORKERS="${GUNICORN_WORKERS:-3}"
 GUNICORN_THREADS="${GUNICORN_THREADS:-2}"
+GUNICORN_LOG_LEVEL="${GUNICORN_LOG_LEVEL:-'info'}"
 NGINX_CONF_FILE=/opt/recipes/nginx/conf.d/Recipes.conf
 
 display_warning() {
@@ -65,4 +66,4 @@ echo "Done"
 
 chmod -R 755 /opt/recipes/mediafiles
 
-exec gunicorn -b :$TANDOOR_PORT --workers $GUNICORN_WORKERS --threads $GUNICORN_THREADS --access-logfile - --error-logfile - --log-level INFO recipes.wsgi
+exec gunicorn -b :$TANDOOR_PORT --workers $GUNICORN_WORKERS --threads $GUNICORN_THREADS --access-logfile - --error-logfile - --log-level $GUNICORN_LOG_LEVEL recipes.wsgi

cookbook/admin.py

@@ -10,12 +10,13 @@ from treebeard.forms import movenodeform_factory
 
 from cookbook.managers import DICTIONARY
 
-from .models import (BookmarkletImport, Comment, CookLog, Food, FoodInheritField, ImportLog,
-                     Ingredient, InviteLink, Keyword, MealPlan, MealType, NutritionInformation,
-                     Recipe, RecipeBook, RecipeBookEntry, RecipeImport, SearchPreference, ShareLink,
-                     ShoppingList, ShoppingListEntry, ShoppingListRecipe, Space, Step, Storage,
-                     Supermarket, SupermarketCategory, SupermarketCategoryRelation, Sync, SyncLog,
-                     TelegramBot, Unit, UserFile, UserPreference, ViewLog, Automation, UserSpace)
+from .models import (Automation, BookmarkletImport, Comment, CookLog, Food, FoodInheritField,
+                     ImportLog, Ingredient, InviteLink, Keyword, MealPlan, MealType,
+                     NutritionInformation, Property, PropertyType, Recipe, RecipeBook,
+                     RecipeBookEntry, RecipeImport, SearchPreference, ShareLink, ShoppingList,
+                     ShoppingListEntry, ShoppingListRecipe, Space, Step, Storage, Supermarket,
+                     SupermarketCategory, SupermarketCategoryRelation, Sync, SyncLog, TelegramBot,
+                     Unit, UnitConversion, UserFile, UserPreference, UserSpace, ViewLog)
 
 
 class CustomUserAdmin(UserAdmin):
@@ -32,12 +33,14 @@ admin.site.unregister(Group)
 @admin.action(description='Delete all data from a space')
 def delete_space_action(modeladmin, request, queryset):
     for space in queryset:
-        space.save()
+        space.safe_delete()
 
 
 class SpaceAdmin(admin.ModelAdmin):
     list_display = ('name', 'created_by', 'max_recipes', 'max_users', 'max_file_storage_mb', 'allow_sharing')
     search_fields = ('name', 'created_by__username')
+    autocomplete_fields = ('created_by',)
+    filter_horizontal = ('food_inherit',)
     list_filter = ('max_recipes', 'max_users', 'max_file_storage_mb', 'allow_sharing')
     date_hierarchy = 'created_at'
     actions = [delete_space_action]
@@ -49,6 +52,8 @@ admin.site.register(Space, SpaceAdmin)
 class UserSpaceAdmin(admin.ModelAdmin):
     list_display = ('user', 'space',)
     search_fields = ('user__username', 'space__name',)
+    filter_horizontal = ('groups',)
+    autocomplete_fields = ('user', 'space',)
 
 
 admin.site.register(UserSpace, UserSpaceAdmin)
@@ -59,6 +64,7 @@ class UserPreferenceAdmin(admin.ModelAdmin):
     search_fields = ('user__username',)
     list_filter = ('theme', 'nav_color', 'default_page',)
     date_hierarchy = 'created_at'
+    filter_horizontal = ('plan_share', 'shopping_share',)
 
     @staticmethod
     def name(obj):
@@ -150,9 +156,16 @@ class KeywordAdmin(TreeAdmin):
 admin.site.register(Keyword, KeywordAdmin)
 
 
+@admin.action(description='Delete Steps not part of a Recipe.')
+def delete_unattached_steps(modeladmin, request, queryset):
+    with scopes_disabled():
+        Step.objects.filter(recipe=None).delete()
+
+
 class StepAdmin(admin.ModelAdmin):
     list_display = ('name', 'order',)
     search_fields = ('name',)
+    actions = [delete_unattached_steps]
 
 
 admin.site.register(Step, StepAdmin)
@@ -201,9 +214,24 @@ class FoodAdmin(TreeAdmin):
 admin.site.register(Food, FoodAdmin)
 
 
+class UnitConversionAdmin(admin.ModelAdmin):
+    list_display = ('base_amount', 'base_unit', 'food', 'converted_amount', 'converted_unit')
+    search_fields = ('food__name', 'unit__name')
+
+
+admin.site.register(UnitConversion, UnitConversionAdmin)
+
+
+@admin.action(description='Delete Ingredients not part of a Recipe.')
+def delete_unattached_ingredients(modeladmin, request, queryset):
+    with scopes_disabled():
+        Ingredient.objects.filter(step__recipe=None).delete()
+
+
 class IngredientAdmin(admin.ModelAdmin):
     list_display = ('food', 'amount', 'unit')
     search_fields = ('food__name', 'unit__name')
+    actions = [delete_unattached_ingredients]
 
 
 admin.site.register(Ingredient, IngredientAdmin)
@@ -286,6 +314,7 @@ admin.site.register(InviteLink, InviteLinkAdmin)
 
 class CookLogAdmin(admin.ModelAdmin):
     list_display = ('recipe', 'created_by', 'created_at', 'rating', 'servings')
+    search_fields = ('recipe__name', 'space__name',)
 
 
 admin.site.register(CookLog, CookLogAdmin)
@@ -319,6 +348,20 @@ class ShareLinkAdmin(admin.ModelAdmin):
 admin.site.register(ShareLink, ShareLinkAdmin)
 
 
+class PropertyTypeAdmin(admin.ModelAdmin):
+    list_display = ('id', 'name')
+
+
+admin.site.register(PropertyType, PropertyTypeAdmin)
+
+
+class PropertyAdmin(admin.ModelAdmin):
+    list_display = ('property_amount', 'property_type')
+
+
+admin.site.register(Property, PropertyAdmin)
+
+
 class NutritionInformationAdmin(admin.ModelAdmin):
     list_display = ('id',)
 

cookbook/forms.py

@@ -46,6 +46,7 @@ class UserPreferenceForm(forms.ModelForm):
         fields = (
             'default_unit', 'use_fractions', 'use_kj', 'theme', 'nav_color',
             'sticky_navbar', 'default_page', 'plan_share', 'ingredient_decimals', 'comments', 'left_handed',
+            'show_step_ingredients',
         )
 
         labels = {
@@ -60,7 +61,8 @@ class UserPreferenceForm(forms.ModelForm):
             'ingredient_decimals': _('Ingredient decimal places'),
             'shopping_auto_sync': _('Shopping list auto sync period'),
             'comments': _('Comments'),
-            'left_handed': _('Left-handed mode')
+            'left_handed': _('Left-handed mode'),
+            'show_step_ingredients': _('Show step ingredients table')
         }
 
         help_texts = {
@@ -82,7 +84,8 @@ class UserPreferenceForm(forms.ModelForm):
             'sticky_navbar': _('Makes the navbar stick to the top of the page.'),  
             '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.')
+            'left_handed': _('Will optimize the UI for use with your left hand.'),
+            'show_step_ingredients': _('Add ingredients table next to recipe steps. Applies at creation time for manually created and URL imported recipes. Individual steps can be overridden in the edit recipe view.')
         }
 
         widgets = {
@@ -154,6 +157,7 @@ class ImportExportBase(forms.Form):
     COOKBOOKAPP = 'COOKBOOKAPP'
     COPYMETHAT = 'COPYMETHAT'
     COOKMATE = 'COOKMATE'
+    REZEPTSUITEDE = 'REZEPTSUITEDE'
     PDF = 'PDF'
 
     type = forms.ChoiceField(choices=(
@@ -162,12 +166,29 @@ class ImportExportBase(forms.Form):
         (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'), (MELARECIPES, 'Melarecipes'),
-        (COOKMATE, 'Cookmate')
+        (COOKMATE, 'Cookmate'), (REZEPTSUITEDE, 'Recipesuite.de')
     ))
 
 
+class MultipleFileInput(forms.ClearableFileInput):
+    allow_multiple_selected = True
+
+
+class MultipleFileField(forms.FileField):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("widget", MultipleFileInput())
+        super().__init__(*args, **kwargs)
+
+    def clean(self, data, initial=None):
+        single_file_clean = super().clean
+        if isinstance(data, (list, tuple)):
+            result = [single_file_clean(d, initial) for d in data]
+        else:
+            result = single_file_clean(data, initial)
+        return result
+
 class ImportForm(ImportExportBase):
-    files = forms.FileField(required=True, widget=forms.ClearableFileInput(attrs={'multiple': True}))
+    files = MultipleFileField(required=True)
     duplicates = forms.BooleanField(help_text=_(
         'To prevent duplicates recipes with the same name as existing ones are ignored. Check this box to import everything.'),
         required=False)
@@ -533,11 +554,13 @@ class SpacePreferenceForm(forms.ModelForm):
     class Meta:
         model = Space
 
-        fields = ('food_inherit', 'reset_food_inherit', 'show_facet_count')
+        fields = ('food_inherit', 'reset_food_inherit', 'show_facet_count', 'use_plural')
 
         help_texts = {
             'food_inherit': _('Fields on food that should be inherited by default.'),
-            'show_facet_count': _('Show recipe counts on search filters'), }
+            'show_facet_count': _('Show recipe counts on search filters'), 
+            'use_plural': _('Use the plural form for units and food inside this space.'),
+        }
 
         widgets = {
             'food_inherit': MultiSelectWidget

cookbook/helper/cache_helper.py

@@ -0,0 +1,11 @@
+class CacheHelper:
+    space = None
+
+    BASE_UNITS_CACHE_KEY = None
+    PROPERTY_TYPE_CACHE_KEY = None
+
+    def __init__(self, space):
+        self.space = space
+
+        self.BASE_UNITS_CACHE_KEY = f'SPACE_{space.id}_BASE_UNITS'
+        self.PROPERTY_TYPE_CACHE_KEY = f'SPACE_{space.id}_PROPERTY_TYPES'

cookbook/helper/image_processing.py

@@ -40,7 +40,12 @@ def get_filetype(name):
 # TODO also add env variable to define which images sizes should be compressed
 # 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): 
+def handle_image(request, image_object, filetype):
+    try:
+        Image.open(image_object).verify()
+    except Exception:
+        return None
+
     if (image_object.size / 1000) > 500:  # if larger than 500 kb compress
         if filetype == '.jpeg' or filetype == '.jpg':
             return rescale_image_jpeg(image_object)

cookbook/helper/ingredient_parser.py

@@ -3,8 +3,10 @@ import string
 import unicodedata
 
 from django.core.cache import caches
+from django.db.models import Q
+from django.db.models.functions import Lower
 
-from cookbook.models import Unit, Food, Automation, Ingredient
+from cookbook.models import Automation, Food, Ingredient, Unit
 
 
 class IngredientParser:
@@ -12,6 +14,8 @@ class IngredientParser:
     ignore_rules = False
     food_aliases = {}
     unit_aliases = {}
+    never_unit = {}
+    transpose_words = {}
 
     def __init__(self, request, cache_mode, ignore_automations=False):
         """
@@ -28,8 +32,8 @@ class IngredientParser:
                 self.food_aliases = c
                 caches['default'].touch(FOOD_CACHE_KEY, 30)
             else:
-                for a in Automation.objects.filter(space=self.request.space, disabled=False, type=Automation.FOOD_ALIAS).only('param_1', 'param_2').all():
-                    self.food_aliases[a.param_1] = a.param_2
+                for a in Automation.objects.filter(space=self.request.space, disabled=False, type=Automation.FOOD_ALIAS).only('param_1', 'param_2').order_by('order').all():
+                    self.food_aliases[a.param_1.lower()] = a.param_2
                 caches['default'].set(FOOD_CACHE_KEY, self.food_aliases, 30)
 
             UNIT_CACHE_KEY = f'automation_unit_alias_{self.request.space.pk}'
@@ -37,12 +41,34 @@ class IngredientParser:
                 self.unit_aliases = c
                 caches['default'].touch(UNIT_CACHE_KEY, 30)
             else:
-                for a in Automation.objects.filter(space=self.request.space, disabled=False, type=Automation.UNIT_ALIAS).only('param_1', 'param_2').all():
-                    self.unit_aliases[a.param_1] = a.param_2
+                for a in Automation.objects.filter(space=self.request.space, disabled=False, type=Automation.UNIT_ALIAS).only('param_1', 'param_2').order_by('order').all():
+                    self.unit_aliases[a.param_1.lower()] = a.param_2
                 caches['default'].set(UNIT_CACHE_KEY, self.unit_aliases, 30)
+
+            NEVER_UNIT_CACHE_KEY = f'automation_never_unit_{self.request.space.pk}'
+            if c := caches['default'].get(NEVER_UNIT_CACHE_KEY, None):
+                self.never_unit = c
+                caches['default'].touch(NEVER_UNIT_CACHE_KEY, 30)
+            else:
+                for a in Automation.objects.filter(space=self.request.space, disabled=False, type=Automation.NEVER_UNIT).only('param_1', 'param_2').order_by('order').all():
+                    self.never_unit[a.param_1.lower()] = a.param_2
+                caches['default'].set(NEVER_UNIT_CACHE_KEY, self.never_unit, 30)
+
+            TRANSPOSE_WORDS_CACHE_KEY = f'automation_transpose_words_{self.request.space.pk}'
+            if c := caches['default'].get(TRANSPOSE_WORDS_CACHE_KEY, None):
+                self.transpose_words = c
+                caches['default'].touch(TRANSPOSE_WORDS_CACHE_KEY, 30)
+            else:
+                i = 0
+                for a in Automation.objects.filter(space=self.request.space, disabled=False, type=Automation.TRANSPOSE_WORDS).only('param_1', 'param_2').order_by('order').all():
+                    self.transpose_words[i] = [a.param_1.lower(), a.param_2.lower()]
+                    i += 1
+                caches['default'].set(TRANSPOSE_WORDS_CACHE_KEY, self.transpose_words, 30)
         else:
             self.food_aliases = {}
             self.unit_aliases = {}
+            self.never_unit = {}
+            self.transpose_words = {}
 
     def apply_food_automation(self, food):
         """
@@ -55,11 +81,11 @@ class IngredientParser:
         else:
             if self.food_aliases:
                 try:
-                    return self.food_aliases[food]
+                    return self.food_aliases[food.lower()]
                 except KeyError:
                     return food
             else:
-                if automation := Automation.objects.filter(space=self.request.space, type=Automation.FOOD_ALIAS, param_1=food, disabled=False).first():
+                if automation := Automation.objects.filter(space=self.request.space, type=Automation.FOOD_ALIAS, param_1__iexact=food, disabled=False).order_by('order').first():
                     return automation.param_2
         return food
 
@@ -72,13 +98,13 @@ class IngredientParser:
         if self.ignore_rules:
             return unit
         else:
-            if self.unit_aliases:
+            if self.transpose_words:
                 try:
-                    return self.unit_aliases[unit]
+                    return self.unit_aliases[unit.lower()]
                 except KeyError:
                     return unit
             else:
-                if automation := Automation.objects.filter(space=self.request.space, type=Automation.UNIT_ALIAS, param_1=unit, disabled=False).first():
+                if automation := Automation.objects.filter(space=self.request.space, type=Automation.UNIT_ALIAS, param_1__iexact=unit, disabled=False).order_by('order').first():
                     return automation.param_2
         return unit
 
@@ -126,15 +152,17 @@ class IngredientParser:
         amount = 0
         unit = None
         note = ''
+        if x.strip() == '':
+            return amount, unit, note
 
         did_check_frac = False
         end = 0
         while (end < len(x) and (x[end] in string.digits
                                  or (
-                                         (x[end] == '.' or x[end] == ',' or x[end] == '/')
-                                         and end + 1 < len(x)
-                                         and x[end + 1] in string.digits
-                                 ))):
+            (x[end] == '.' or x[end] == ',' or x[end] == '/')
+            and end + 1 < len(x)
+            and x[end + 1] in string.digits
+        ))):
             end += 1
         if end > 0:
             if "/" in x[:end]:
@@ -158,7 +186,8 @@ class IngredientParser:
         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
+        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
@@ -203,6 +232,67 @@ class IngredientParser:
             food, note = self.parse_food_with_comma(tokens)
         return food, note
 
+    def apply_never_unit_automations(self, tokens):
+        """
+        Moves a string that should never be treated as a unit to next token and optionally replaced with default unit
+        e.g. NEVER_UNIT: param1: egg, param2: None would modify ['1', 'egg', 'white'] to ['1', '', 'egg', 'white']
+        or NEVER_UNIT: param1: egg, param2: pcs would modify ['1', 'egg', 'yolk'] to ['1', 'pcs', 'egg', 'yolk']
+        :param1 string: string that should never be considered a unit, will be moved to token[2]
+        :param2 (optional) unit as string: will insert unit string into token[1]
+        :return: unit as string (possibly changed by automation)
+        """
+
+        if self.ignore_rules:
+            return tokens
+
+        new_unit = None
+        alt_unit = self.apply_unit_automation(tokens[1])
+        never_unit = False
+        if self.never_unit:
+            try:
+                new_unit = self.never_unit[tokens[1].lower()]
+                never_unit = True
+            except KeyError:
+                return tokens
+
+        else:
+            if automation := Automation.objects.annotate(param_1_lower=Lower('param_1')).filter(space=self.request.space, type=Automation.NEVER_UNIT, param_1_lower__in=[
+                    tokens[1].lower(), alt_unit.lower()], disabled=False).order_by('order').first():
+                new_unit = automation.param_2
+                never_unit = True
+
+        if never_unit:
+            tokens.insert(1, new_unit)
+
+        return tokens
+
+    def apply_transpose_words_automations(self, ingredient):
+        """
+        If two words (param_1 & param_2) are detected in sequence, swap their position in the ingredient string
+        :param 1: first word to detect
+        :param 2: second word to detect
+        return: new ingredient string
+        """
+
+        if self.ignore_rules:
+            return ingredient
+
+        else:
+            tokens = [x.lower() for x in ingredient.replace(',', ' ').split()]
+            if self.transpose_words:
+                filtered_rules = {}
+                for key, value in self.transpose_words.items():
+                    if value[0] in tokens and value[1] in tokens:
+                        filtered_rules[key] = value
+                for k, v in filtered_rules.items():
+                    ingredient = re.sub(rf"\b({v[0]})\W*({v[1]})\b", r"\2 \1", ingredient, flags=re.IGNORECASE)
+            else:
+                for rule in Automation.objects.filter(space=self.request.space, type=Automation.TRANSPOSE_WORDS, disabled=False) \
+                        .annotate(param_1_lower=Lower('param_1'), param_2_lower=Lower('param_2')) \
+                        .filter(Q(Q(param_1_lower__in=tokens) | Q(param_2_lower__in=tokens))).order_by('order'):
+                    ingredient = re.sub(rf"\b({rule.param_1})\W*({rule.param_1})\b", r"\2 \1", ingredient, flags=re.IGNORECASE)
+        return ingredient
+
     def parse(self, ingredient):
         """
         Main parsing function, takes an ingredient string (e.g. '1 l Water') and extracts amount, unit, food, ...
@@ -228,13 +318,23 @@ class IngredientParser:
 
         # 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', ingredient):
-            match = re.search('\((.[^\(])+\)', ingredient)
+        if re.match('(.){1,6}\\s\\((.[^\\(\\)])+\\)\\s', ingredient):
+            match = re.search('\\((.[^\\(])+\\)', ingredient)
             ingredient = ingredient[:match.start()] + ingredient[match.end():] + ' ' + ingredient[match.start():match.end()]
 
         # leading spaces before commas result in extra tokens, clean them out
         ingredient = ingredient.replace(' ,', ',')
 
+        # handle "(from) - (to)" amounts by using the minimum amount and adding the range to the description
+        # "10.5 - 200 g XYZ" => "100 g XYZ (10.5 - 200)"
+        ingredient = re.sub("^(\\d+|\\d+[\\.,]\\d+) - (\\d+|\\d+[\\.,]\\d+) (.*)", "\\1 \\3 (\\1 - \\2)", ingredient)
+
+        # if amount and unit are connected add space in between
+        if re.match('([0-9])+([A-z])+\\s', ingredient):
+            ingredient = re.sub(r'(?<=([a-z])|\d)(?=(?(1)\d|[a-z]))', ' ', ingredient)
+
+        ingredient = self.apply_transpose_words_automations(ingredient)
+
         tokens = ingredient.split()  # split at each space into tokens
         if len(tokens) == 1:
             # there only is one argument, that must be the food
@@ -247,6 +347,7 @@ class IngredientParser:
                 # three arguments if it already has a unit there can't be
                 # a fraction for the amount
                 if len(tokens) > 2:
+                    tokens = self.apply_never_unit_automations(tokens)
                     try:
                         if unit is not None:
                             # a unit is already found, no need to try the second argument for a fraction

cookbook/helper/mdx_urlize.py

@@ -35,6 +35,7 @@ Negative examples:
 u'<p>del.icio.us</p>'
 
 """
+from xml.etree.ElementTree import Element
 
 import markdown
 
@@ -64,7 +65,7 @@ class UrlizePattern(markdown.inlinepatterns.Pattern):
             else:
                 url = 'http://' + url
 
-        el = markdown.util.etree.Element("a")
+        el = Element("a")
         el.set('href', url)
         el.text = markdown.util.AtomicString(text)
         return el

cookbook/helper/open_data_importer.py

@@ -0,0 +1,214 @@
+from django.db.models import Q
+
+from cookbook.models import Unit, SupermarketCategory, Property, PropertyType, Supermarket, SupermarketCategoryRelation, Food, Automation, UnitConversion, FoodProperty
+
+
+class OpenDataImporter:
+    request = None
+    data = {}
+    slug_id_cache = {}
+    update_existing = False
+    use_metric = True
+
+    def __init__(self, request, data, update_existing=False, use_metric=True):
+        self.request = request
+        self.data = data
+        self.update_existing = update_existing
+        self.use_metric = use_metric
+
+    def _update_slug_cache(self, object_class, datatype):
+        self.slug_id_cache[datatype] = dict(object_class.objects.filter(space=self.request.space, open_data_slug__isnull=False).values_list('open_data_slug', 'id', ))
+
+    def import_units(self):
+        datatype = 'unit'
+
+        insert_list = []
+        for u in list(self.data[datatype].keys()):
+            insert_list.append(Unit(
+                name=self.data[datatype][u]['name'],
+                plural_name=self.data[datatype][u]['plural_name'],
+                base_unit=self.data[datatype][u]['base_unit'] if self.data[datatype][u]['base_unit'] != '' else None,
+                open_data_slug=u,
+                space=self.request.space
+            ))
+
+        if self.update_existing:
+            return Unit.objects.bulk_create(insert_list, update_conflicts=True, update_fields=('name', 'plural_name', 'base_unit', 'open_data_slug'), unique_fields=('space', 'name',))
+        else:
+            return Unit.objects.bulk_create(insert_list, update_conflicts=True, update_fields=('open_data_slug',), unique_fields=('space', 'name',))
+
+    def import_category(self):
+        datatype = 'category'
+
+        insert_list = []
+        for k in list(self.data[datatype].keys()):
+            insert_list.append(SupermarketCategory(
+                name=self.data[datatype][k]['name'],
+                open_data_slug=k,
+                space=self.request.space
+            ))
+
+        return SupermarketCategory.objects.bulk_create(insert_list, update_conflicts=True, update_fields=('open_data_slug',), unique_fields=('space', 'name',))
+
+    def import_property(self):
+        datatype = 'property'
+
+        insert_list = []
+        for k in list(self.data[datatype].keys()):
+            insert_list.append(PropertyType(
+                name=self.data[datatype][k]['name'],
+                unit=self.data[datatype][k]['unit'],
+                open_data_slug=k,
+                space=self.request.space
+            ))
+
+        return PropertyType.objects.bulk_create(insert_list, update_conflicts=True, update_fields=('open_data_slug',), unique_fields=('space', 'name',))
+
+    def import_supermarket(self):
+        datatype = 'store'
+
+        self._update_slug_cache(SupermarketCategory, 'category')
+        insert_list = []
+        for k in list(self.data[datatype].keys()):
+            insert_list.append(Supermarket(
+                name=self.data[datatype][k]['name'],
+                open_data_slug=k,
+                space=self.request.space
+            ))
+
+        # always add open data slug if matching supermarket is found, otherwise relation might fail
+        supermarkets = Supermarket.objects.bulk_create(insert_list, unique_fields=('space', 'name',), update_conflicts=True, update_fields=('open_data_slug',))
+        self._update_slug_cache(Supermarket, 'store')
+
+        insert_list = []
+        for k in list(self.data[datatype].keys()):
+            relations = []
+            order = 0
+            for c in self.data[datatype][k]['categories']:
+                relations.append(
+                    SupermarketCategoryRelation(
+                        supermarket_id=self.slug_id_cache[datatype][k],
+                        category_id=self.slug_id_cache['category'][c],
+                        order=order,
+                    )
+                )
+                order += 1
+
+            SupermarketCategoryRelation.objects.bulk_create(relations, ignore_conflicts=True, unique_fields=('supermarket', 'category',))
+
+        return supermarkets
+
+    def import_food(self):
+        identifier_list = []
+        datatype = 'food'
+        for k in list(self.data[datatype].keys()):
+            identifier_list.append(self.data[datatype][k]['name'])
+            identifier_list.append(self.data[datatype][k]['plural_name'])
+
+        existing_objects_flat = []
+        existing_objects = {}
+        for f in Food.objects.filter(space=self.request.space).filter(name__in=identifier_list).values_list('id', 'name', 'plural_name'):
+            existing_objects_flat.append(f[1])
+            existing_objects_flat.append(f[2])
+            existing_objects[f[1]] = f
+            existing_objects[f[2]] = f
+
+        self._update_slug_cache(Unit, 'unit')
+        self._update_slug_cache(PropertyType, 'property')
+
+        # pref_unit_key = 'preferred_unit_metric'
+        # pref_shopping_unit_key = 'preferred_packaging_unit_metric'
+        # if not self.use_metric:
+        #     pref_unit_key = 'preferred_unit_imperial'
+        #     pref_shopping_unit_key = 'preferred_packaging_unit_imperial'
+
+        insert_list = []
+        update_list = []
+        update_field_list = []
+        for k in list(self.data[datatype].keys()):
+            if not (self.data[datatype][k]['name'] in existing_objects_flat or self.data[datatype][k]['plural_name'] in existing_objects_flat):
+                insert_list.append({'data': {
+                    'name': self.data[datatype][k]['name'],
+                    'plural_name': self.data[datatype][k]['plural_name'] if self.data[datatype][k]['plural_name'] != '' else None,
+                    # 'preferred_unit_id': self.slug_id_cache['unit'][self.data[datatype][k][pref_unit_key]],
+                    # 'preferred_shopping_unit_id': self.slug_id_cache['unit'][self.data[datatype][k][pref_shopping_unit_key]],
+                    'supermarket_category_id': self.slug_id_cache['category'][self.data[datatype][k]['store_category']],
+                    'fdc_id': self.data[datatype][k]['fdc_id'] if self.data[datatype][k]['fdc_id'] != '' else None,
+                    'open_data_slug': k,
+                    'space': self.request.space.id,
+                }})
+            else:
+                if self.data[datatype][k]['name'] in existing_objects:
+                    existing_food_id = existing_objects[self.data[datatype][k]['name']][0]
+                else:
+                    existing_food_id = existing_objects[self.data[datatype][k]['plural_name']][0]
+
+                if self.update_existing:
+                    update_field_list = ['name', 'plural_name', 'preferred_unit_id', 'preferred_shopping_unit_id', 'supermarket_category_id', 'fdc_id', 'open_data_slug', ]
+                    update_list.append(Food(
+                        id=existing_food_id,
+                        name=self.data[datatype][k]['name'],
+                        plural_name=self.data[datatype][k]['plural_name'] if self.data[datatype][k]['plural_name'] != '' else None,
+                        # preferred_unit_id=self.slug_id_cache['unit'][self.data[datatype][k][pref_unit_key]],
+                        # preferred_shopping_unit_id=self.slug_id_cache['unit'][self.data[datatype][k][pref_shopping_unit_key]],
+                        supermarket_category_id=self.slug_id_cache['category'][self.data[datatype][k]['store_category']],
+                        fdc_id=self.data[datatype][k]['fdc_id'] if self.data[datatype][k]['fdc_id'] != '' else None,
+                        open_data_slug=k,
+                    ))
+                else:
+                    update_field_list = ['open_data_slug', ]
+                    update_list.append(Food(id=existing_food_id, open_data_slug=k, ))
+
+        Food.load_bulk(insert_list, None)
+        if len(update_list) > 0:
+            Food.objects.bulk_update(update_list, update_field_list)
+
+        self._update_slug_cache(Food, 'food')
+
+        food_property_list = []
+        alias_list = []
+        for k in list(self.data[datatype].keys()):
+            for fp in self.data[datatype][k]['properties']['type_values']:
+                food_property_list.append(Property(
+                    property_type_id=self.slug_id_cache['property'][fp['property_type']],
+                    property_amount=fp['property_value'],
+                    import_food_id=self.slug_id_cache['food'][k],
+                    space=self.request.space,
+                ))
+
+            # for a in self.data[datatype][k]['alias']:
+            #     alias_list.append(Automation(
+            #         param_1=a,
+            #         param_2=self.data[datatype][k]['name'],
+            #         space=self.request.space,
+            #         created_by=self.request.user,
+            #     ))
+
+        Property.objects.bulk_create(food_property_list, ignore_conflicts=True, unique_fields=('space', 'import_food_id', 'property_type',))
+
+        property_food_relation_list = []
+        for p in Property.objects.filter(space=self.request.space, import_food_id__isnull=False).values_list('import_food_id', 'id', ):
+            property_food_relation_list.append(Food.properties.through(food_id=p[0], property_id=p[1]))
+
+        FoodProperty.objects.bulk_create(property_food_relation_list, ignore_conflicts=True, unique_fields=('food_id', 'property_id',))
+
+        # Automation.objects.bulk_create(alias_list, ignore_conflicts=True, unique_fields=('space', 'param_1', 'param_2',))
+        return insert_list + update_list
+
+    def import_conversion(self):
+        datatype = 'conversion'
+
+        insert_list = []
+        for k in list(self.data[datatype].keys()):
+            insert_list.append(UnitConversion(
+                base_amount=self.data[datatype][k]['base_amount'],
+                base_unit_id=self.slug_id_cache['unit'][self.data[datatype][k]['base_unit']],
+                converted_amount=self.data[datatype][k]['converted_amount'],
+                converted_unit_id=self.slug_id_cache['unit'][self.data[datatype][k]['converted_unit']],
+                food_id=self.slug_id_cache['food'][self.data[datatype][k]['food']],
+                open_data_slug=k,
+                space=self.request.space,
+                created_by=self.request.user,
+            ))
+
+        return UnitConversion.objects.bulk_create(insert_list, ignore_conflicts=True, unique_fields=('space', 'base_unit', 'converted_unit', 'food', 'open_data_slug'))

cookbook/helper/permission_helper.py

@@ -52,7 +52,6 @@ def has_group_permission(user, groups, no_cache=False):
             return cached_result
 
     result = False
-    print('running check', user, groups_allowed)
     if user.is_authenticated:
         if user_space := user.userspace_set.filter(active=True):
             if len(user_space) != 1:
@@ -124,7 +123,7 @@ def share_link_valid(recipe, share):
             return c
 
         if link := ShareLink.objects.filter(recipe=recipe, uuid=share, abuse_blocked=False).first():
-            if 0 < settings.SHARING_LIMIT < link.request_count:
+            if 0 < settings.SHARING_LIMIT < link.request_count and not link.space.no_sharing_limit:
                 return False
             link.request_count += 1
             link.save()
@@ -323,7 +322,7 @@ class CustomRecipePermission(permissions.BasePermission):
 
     def has_permission(self, request, view):  # user is either at least a guest or a share link is given and the request is safe
         share = request.query_params.get('share', None)
-        return has_group_permission(request.user, ['guest']) or (share and request.method in SAFE_METHODS and 'pk' in view.kwargs)
+        return ((has_group_permission(request.user, ['guest']) and request.method in SAFE_METHODS) or has_group_permission(request.user, ['user'])) or (share and request.method in SAFE_METHODS and 'pk' in view.kwargs)
 
     def has_object_permission(self, request, view, obj):
         share = request.query_params.get('share', None)
@@ -333,7 +332,7 @@ class CustomRecipePermission(permissions.BasePermission):
             if obj.private:
                 return ((obj.created_by == request.user) or (request.user in obj.shared.all())) and obj.space == request.space
             else:
-                return has_group_permission(request.user, ['guest']) and obj.space == request.space
+                return ((has_group_permission(request.user, ['guest']) and request.method in SAFE_METHODS) or has_group_permission(request.user, ['user'])) and obj.space == request.space
 
 
 class CustomUserPermission(permissions.BasePermission):
@@ -435,3 +434,10 @@ def switch_user_active_space(user, space):
             return us
     except ObjectDoesNotExist:
         return None
+
+
+class IsReadOnlyDRF(permissions.BasePermission):
+    message = 'You cannot interact with this object as it is not owned by you!'
+
+    def has_permission(self, request, view):
+        return request.method in SAFE_METHODS

cookbook/helper/property_helper.py

@@ -0,0 +1,71 @@
+from django.core.cache import caches
+
+from cookbook.helper.cache_helper import CacheHelper
+from cookbook.helper.unit_conversion_helper import UnitConversionHelper
+from cookbook.models import PropertyType, Unit, Food, Property, Recipe, Step
+
+
+class FoodPropertyHelper:
+    space = None
+
+    def __init__(self, space):
+        """
+        Helper to perform food property calculations
+        :param space: space to limit scope to
+        """
+        self.space = space
+
+    def calculate_recipe_properties(self, recipe):
+        """
+        Calculate all food properties for a given recipe.
+        :param recipe: recipe to calculate properties for
+        :return: dict of with property keys and total/food values for each property available
+        """
+        ingredients = []
+        computed_properties = {}
+
+        for s in recipe.steps.all():
+            ingredients += s.ingredients.all()
+
+        property_types = caches['default'].get(CacheHelper(self.space).PROPERTY_TYPE_CACHE_KEY, None)
+
+        if not property_types:
+            property_types = PropertyType.objects.filter(space=self.space).all()
+            caches['default'].set(CacheHelper(self.space).PROPERTY_TYPE_CACHE_KEY, property_types, 60 * 60)  # cache is cleared on property type save signal so long duration is fine
+
+        for fpt in property_types:
+            computed_properties[fpt.id] = {'id': fpt.id, 'name': fpt.name, 'icon': fpt.icon, 'description': fpt.description, 'unit': fpt.unit, 'order': fpt.order, 'food_values': {}, 'total_value': 0, 'missing_value': False}
+
+        uch = UnitConversionHelper(self.space)
+
+        for i in ingredients:
+            if i.food is not None:
+                conversions = uch.get_conversions(i)
+                for pt in property_types:
+                    found_property = False
+                    if i.food.properties_food_amount == 0 or i.food.properties_food_unit is None:
+                        computed_properties[pt.id]['food_values'][i.food.id] = {'id': i.food.id, 'food': i.food.name, 'value': 0}
+                        computed_properties[pt.id]['missing_value'] = i.food.properties_food_unit is None
+                    else:
+                        for p in i.food.properties.all():
+                            if p.property_type == pt:
+                                for c in conversions:
+                                    if c.unit == i.food.properties_food_unit:
+                                        found_property = True
+                                        computed_properties[pt.id]['total_value'] += (c.amount / i.food.properties_food_amount) * p.property_amount
+                                        computed_properties[pt.id]['food_values'] = self.add_or_create(computed_properties[p.property_type.id]['food_values'], c.food.id, (c.amount / i.food.properties_food_amount) * p.property_amount, c.food)
+                    if not found_property:
+                        computed_properties[pt.id]['missing_value'] = True
+                        computed_properties[pt.id]['food_values'][i.food.id] = {'id': i.food.id, 'food': i.food.name, 'value': 0}
+
+        return computed_properties
+
+    # small dict helper to add to existing key or create new, probably a better way of doing this
+    # TODO move to central helper ?
+    @staticmethod
+    def add_or_create(d, key, value, food):
+        if key in d:
+            d[key]['value'] += value
+        else:
+            d[key] = {'id': food.id, 'food': food.name, 'value': value}
+        return d

cookbook/helper/recipe_search.py

@@ -3,9 +3,9 @@ from collections import Counter
 from datetime import date, timedelta
 
 from django.contrib.postgres.search import SearchQuery, SearchRank, SearchVector, TrigramSimilarity
-from django.core.cache import cache
-from django.core.cache import caches
-from django.db.models import (Avg, Case, Count, Exists, F, Func, Max, OuterRef, Q, Subquery, Value, When, FilteredRelation)
+from django.core.cache import cache, caches
+from django.db.models import (Avg, Case, Count, Exists, F, Func, Max, OuterRef, Q, Subquery, Value,
+                              When)
 from django.db.models.functions import Coalesce, Lower, Substr
 from django.utils import timezone, translation
 from django.utils.translation import gettext as _
@@ -20,7 +20,8 @@ from recipes import settings
 # TODO create extensive tests to make sure ORs ANDs and various filters, sorting, etc work as expected
 # TODO consider creating a simpleListRecipe API that only includes minimum of recipe info and minimal filtering
 class RecipeSearch():
-    _postgres = settings.DATABASES['default']['ENGINE'] in ['django.db.backends.postgresql_psycopg2', 'django.db.backends.postgresql']
+    _postgres = settings.DATABASES['default']['ENGINE'] in [
+        'django.db.backends.postgresql_psycopg2', 'django.db.backends.postgresql']
 
     def __init__(self, request, **params):
         self._request = request
@@ -31,6 +32,9 @@ class RecipeSearch():
             if custom_filter:
                 self._params = {**json.loads(custom_filter.search)}
                 self._original_params = {**(params or {})}
+                # json.loads casts rating as an integer, expecting string
+                if isinstance(self._params.get('rating', None), int):
+                    self._params['rating'] = str(self._params['rating'])
             else:
                 self._params = {**(params or {})}
         else:
@@ -45,7 +49,8 @@ class RecipeSearch():
             cache.set(CACHE_KEY, self._search_prefs, timeout=10)
         else:
             self._search_prefs = SearchPreference()
-        self._string = self._params.get('query').strip() if self._params.get('query', None) else None
+        self._string = self._params.get('query').strip(
+        ) if self._params.get('query', None) else None
         self._rating = self._params.get('rating', None)
         self._keywords = {
             'or': self._params.get('keywords_or', None) or self._params.get('keywords', None),
@@ -74,7 +79,8 @@ class RecipeSearch():
         self._random = str2bool(self._params.get('random', False))
         self._new = str2bool(self._params.get('new', False))
         self._num_recent = int(self._params.get('num_recent', 0))
-        self._include_children = str2bool(self._params.get('include_children', None))
+        self._include_children = str2bool(
+            self._params.get('include_children', None))
         self._timescooked = self._params.get('timescooked', None)
         self._cookedon = self._params.get('cookedon', None)
         self._createdon = self._params.get('createdon', None)
@@ -82,9 +88,9 @@ class RecipeSearch():
         self._viewedon = self._params.get('viewedon', None)
         self._makenow = self._params.get('makenow', None)
         # this supports hidden feature to find recipes missing X ingredients
-        if type(self._makenow) == bool and self._makenow == True:
+        if isinstance(self._makenow, bool) and self._makenow == True:
             self._makenow = 0
-        elif type(self._makenow) == str and self._makenow in ["yes", "true"]:
+        elif isinstance(self._makenow, str) and self._makenow in ["yes", "true"]:
             self._makenow = 0
         else:
             try:
@@ -95,18 +101,24 @@ class RecipeSearch():
         self._search_type = self._search_prefs.search or 'plain'
         if self._string:
             if self._postgres:
-                self._unaccent_include = self._search_prefs.unaccent.values_list('field', flat=True)
+                self._unaccent_include = self._search_prefs.unaccent.values_list(
+                    'field', flat=True)
             else:
                 self._unaccent_include = []
-            self._icontains_include = [x + '__unaccent' if x in self._unaccent_include else x for x in self._search_prefs.icontains.values_list('field', flat=True)]
-            self._istartswith_include = [x + '__unaccent' if x in self._unaccent_include else x for x in self._search_prefs.istartswith.values_list('field', flat=True)]
+            self._icontains_include = [
+                x + '__unaccent' if x in self._unaccent_include else x for x in self._search_prefs.icontains.values_list('field', flat=True)]
+            self._istartswith_include = [
+                x + '__unaccent' if x in self._unaccent_include else x for x in self._search_prefs.istartswith.values_list('field', flat=True)]
             self._trigram_include = None
             self._fulltext_include = None
         self._trigram = False
         if self._postgres and self._string:
-            self._language = DICTIONARY.get(translation.get_language(), 'simple')
-            self._trigram_include = [x + '__unaccent' if x in self._unaccent_include else x for x in self._search_prefs.trigram.values_list('field', flat=True)]
-            self._fulltext_include = self._search_prefs.fulltext.values_list('field', flat=True) or None
+            self._language = DICTIONARY.get(
+                translation.get_language(), 'simple')
+            self._trigram_include = [
+                x + '__unaccent' if x in self._unaccent_include else x for x in self._search_prefs.trigram.values_list('field', flat=True)]
+            self._fulltext_include = self._search_prefs.fulltext.values_list(
+                'field', flat=True) or None
 
             if self._search_type not in ['websearch', 'raw'] and self._trigram_include:
                 self._trigram = True
@@ -141,7 +153,7 @@ class RecipeSearch():
         self.unit_filters(units=self._units)
         self._makenow_filter(missing=self._makenow)
         self.string_filters(string=self._string)
-        return self._queryset.filter(space=self._request.space).distinct().order_by(*self.orderby)
+        return self._queryset.filter(space=self._request.space).order_by(*self.orderby)
 
     def _sort_includes(self, *args):
         for x in args:
@@ -182,8 +194,10 @@ class RecipeSearch():
             # otherwise sort by the remaining order_by attributes or favorite by default
             else:
                 order += default_order
-            order[:] = [Lower('name').asc() if x == 'name' else x for x in order]
-            order[:] = [Lower('name').desc() if x == '-name' else x for x in order]
+            order[:] = [Lower('name').asc() if x ==
+                        'name' else x for x in order]
+            order[:] = [Lower('name').desc() if x ==
+                        '-name' else x for x in order]
             self.orderby = order
 
     def string_filters(self, string=None):
@@ -200,21 +214,28 @@ class RecipeSearch():
             for f in self._filters:
                 query_filter |= f
 
-            self._queryset = self._queryset.filter(query_filter).distinct()  # this creates duplicate records which can screw up other aggregates, see makenow for workaround
+            # this creates duplicate records which can screw up other aggregates, see makenow for workaround
+            self._queryset = self._queryset.filter(query_filter).distinct()
             if self._fulltext_include:
                 if self._fuzzy_match is None:
-                    self._queryset = self._queryset.annotate(score=Coalesce(Max(self.search_rank), 0.0))
+                    self._queryset = self._queryset.annotate(
+                        score=Coalesce(Max(self.search_rank), 0.0))
                 else:
-                    self._queryset = self._queryset.annotate(rank=Coalesce(Max(self.search_rank), 0.0))
+                    self._queryset = self._queryset.annotate(
+                        rank=Coalesce(Max(self.search_rank), 0.0))
 
             if self._fuzzy_match is not None:
-                simularity = self._fuzzy_match.filter(pk=OuterRef('pk')).values('simularity')
+                simularity = self._fuzzy_match.filter(
+                    pk=OuterRef('pk')).values('simularity')
                 if not self._fulltext_include:
-                    self._queryset = self._queryset.annotate(score=Coalesce(Subquery(simularity), 0.0))
+                    self._queryset = self._queryset.annotate(
+                        score=Coalesce(Subquery(simularity), 0.0))
                 else:
-                    self._queryset = self._queryset.annotate(simularity=Coalesce(Subquery(simularity), 0.0))
+                    self._queryset = self._queryset.annotate(
+                        simularity=Coalesce(Subquery(simularity), 0.0))
             if self._sort_includes('score') and self._fulltext_include and self._fuzzy_match is not None:
-                self._queryset = self._queryset.annotate(score=F('rank') + F('simularity'))
+                self._queryset = self._queryset.annotate(
+                    score=F('rank') + F('simularity'))
         else:
             query_filter = Q()
             for f in [x + '__unaccent__iexact' if x in self._unaccent_include else x + '__iexact' for x in SearchFields.objects.all().values_list('field', flat=True)]:
@@ -223,7 +244,8 @@ class RecipeSearch():
 
     def _cooked_on_filter(self, cooked_date=None):
         if self._sort_includes('lastcooked') or cooked_date:
-            lessthan = self._sort_includes('-lastcooked') or '-' in (cooked_date or [])[:1]
+            lessthan = self._sort_includes(
+                '-lastcooked') or '-' in (cooked_date or [])[:1]
             if lessthan:
                 default = timezone.now() - timedelta(days=100000)
             else:
@@ -233,32 +255,41 @@ class RecipeSearch():
         if cooked_date is None:
             return
 
-        cooked_date = date(*[int(x) for x in cooked_date.split('-') if x != ''])
+        cooked_date = date(*[int(x)
+                           for x in cooked_date.split('-') if x != ''])
 
         if lessthan:
-            self._queryset = self._queryset.filter(lastcooked__date__lte=cooked_date).exclude(lastcooked=default)
+            self._queryset = self._queryset.filter(
+                lastcooked__date__lte=cooked_date).exclude(lastcooked=default)
         else:
-            self._queryset = self._queryset.filter(lastcooked__date__gte=cooked_date).exclude(lastcooked=default)
+            self._queryset = self._queryset.filter(
+                lastcooked__date__gte=cooked_date).exclude(lastcooked=default)
 
     def _created_on_filter(self, created_date=None):
         if created_date is None:
             return
         lessthan = '-' in created_date[:1]
-        created_date = date(*[int(x) for x in created_date.split('-') if x != ''])
+        created_date = date(*[int(x)
+                            for x in created_date.split('-') if x != ''])
         if lessthan:
-            self._queryset = self._queryset.filter(created_at__date__lte=created_date)
+            self._queryset = self._queryset.filter(
+                created_at__date__lte=created_date)
         else:
-            self._queryset = self._queryset.filter(created_at__date__gte=created_date)
+            self._queryset = self._queryset.filter(
+                created_at__date__gte=created_date)
 
     def _updated_on_filter(self, updated_date=None):
         if updated_date is None:
             return
         lessthan = '-' in updated_date[:1]
-        updated_date = date(*[int(x) for x in updated_date.split('-') if x != ''])
+        updated_date = date(*[int(x)
+                            for x in updated_date.split('-') if x != ''])
         if lessthan:
-            self._queryset = self._queryset.filter(updated_at__date__lte=updated_date)
+            self._queryset = self._queryset.filter(
+                updated_at__date__lte=updated_date)
         else:
-            self._queryset = self._queryset.filter(updated_at__date__gte=updated_date)
+            self._queryset = self._queryset.filter(
+                updated_at__date__gte=updated_date)
 
     def _viewed_on_filter(self, viewed_date=None):
         if self._sort_includes('lastviewed') or viewed_date:
@@ -268,12 +299,15 @@ class RecipeSearch():
         if viewed_date is None:
             return
         lessthan = '-' in viewed_date[:1]
-        viewed_date = date(*[int(x) for x in viewed_date.split('-') if x != ''])
+        viewed_date = date(*[int(x)
+                           for x in viewed_date.split('-') if x != ''])
 
         if lessthan:
-            self._queryset = self._queryset.filter(lastviewed__date__lte=viewed_date).exclude(lastviewed=longTimeAgo)
+            self._queryset = self._queryset.filter(
+                lastviewed__date__lte=viewed_date).exclude(lastviewed=longTimeAgo)
         else:
-            self._queryset = self._queryset.filter(lastviewed__date__gte=viewed_date).exclude(lastviewed=longTimeAgo)
+            self._queryset = self._queryset.filter(
+                lastviewed__date__gte=viewed_date).exclude(lastviewed=longTimeAgo)
 
     def _new_recipes(self, new_days=7):
         # TODO make new days a user-setting
@@ -293,27 +327,32 @@ class RecipeSearch():
 
         num_recent_recipes = ViewLog.objects.filter(created_by=self._request.user, space=self._request.space).values(
             'recipe').annotate(recent=Max('created_at')).order_by('-recent')[:num_recent]
-        self._queryset = self._queryset.annotate(recent=Coalesce(Max(Case(When(pk__in=num_recent_recipes.values('recipe'), then='viewlog__pk'))), Value(0)))
+        self._queryset = self._queryset.annotate(recent=Coalesce(Max(Case(When(
+            pk__in=num_recent_recipes.values('recipe'), then='viewlog__pk'))), Value(0)))
 
     def _favorite_recipes(self, times_cooked=None):
         if self._sort_includes('favorite') or times_cooked:
-            less_than = '-' in (times_cooked or []) or not self._sort_includes('-favorite')
+            less_than = '-' in (times_cooked or []
+                                ) and not self._sort_includes('-favorite')
             if less_than:
                 default = 1000
             else:
                 default = 0
             favorite_recipes = CookLog.objects.filter(created_by=self._request.user, space=self._request.space, recipe=OuterRef('pk')
                                                       ).values('recipe').annotate(count=Count('pk', distinct=True)).values('count')
-            self._queryset = self._queryset.annotate(favorite=Coalesce(Subquery(favorite_recipes), default))
+            self._queryset = self._queryset.annotate(
+                favorite=Coalesce(Subquery(favorite_recipes), default))
         if times_cooked is None:
             return
 
         if times_cooked == '0':
             self._queryset = self._queryset.filter(favorite=0)
         elif less_than:
-            self._queryset = self._queryset.filter(favorite__lte=int(times_cooked[1:])).exclude(favorite=0)
+            self._queryset = self._queryset.filter(favorite__lte=int(
+                times_cooked.replace('-', ''))).exclude(favorite=0)
         else:
-            self._queryset = self._queryset.filter(favorite__gte=int(times_cooked))
+            self._queryset = self._queryset.filter(
+                favorite__gte=int(times_cooked))
 
     def keyword_filters(self, **kwargs):
         if all([kwargs[x] is None for x in kwargs]):
@@ -346,7 +385,8 @@ class RecipeSearch():
                     else:
                         self._queryset = self._queryset.filter(f_and)
                 if 'not' in kw_filter:
-                    self._queryset = self._queryset.exclude(id__in=recipes.values('id'))
+                    self._queryset = self._queryset.exclude(
+                        id__in=recipes.values('id'))
 
     def food_filters(self, **kwargs):
         if all([kwargs[x] is None for x in kwargs]):
@@ -360,7 +400,8 @@ class RecipeSearch():
             foods = Food.objects.filter(pk__in=kwargs[fd_filter])
             if 'or' in fd_filter:
                 if self._include_children:
-                    f_or = Q(steps__ingredients__food__in=Food.include_descendants(foods))
+                    f_or = Q(
+                        steps__ingredients__food__in=Food.include_descendants(foods))
                 else:
                     f_or = Q(steps__ingredients__food__in=foods)
 
@@ -372,7 +413,8 @@ class RecipeSearch():
                 recipes = Recipe.objects.all()
                 for food in foods:
                     if self._include_children:
-                        f_and = Q(steps__ingredients__food__in=food.get_descendants_and_self())
+                        f_and = Q(
+                            steps__ingredients__food__in=food.get_descendants_and_self())
                     else:
                         f_and = Q(steps__ingredients__food=food)
                     if 'not' in fd_filter:
@@ -380,7 +422,8 @@ class RecipeSearch():
                     else:
                         self._queryset = self._queryset.filter(f_and)
                 if 'not' in fd_filter:
-                    self._queryset = self._queryset.exclude(id__in=recipes.values('id'))
+                    self._queryset = self._queryset.exclude(
+                        id__in=recipes.values('id'))
 
     def unit_filters(self, units=None, operator=True):
         if operator != True:
@@ -389,12 +432,14 @@ class RecipeSearch():
             return
         if not isinstance(units, list):
             units = [units]
-        self._queryset = self._queryset.filter(steps__ingredients__unit__in=units)
+        self._queryset = self._queryset.filter(
+            steps__ingredients__unit__in=units)
 
     def rating_filter(self, rating=None):
         if rating or self._sort_includes('rating'):
-            lessthan = self._sort_includes('-rating') or '-' in (rating or [])
-            if lessthan:
+            lessthan = '-' in (rating or [])
+            reverse = 'rating' in (self._sort_order or []) and '-rating' not in (self._sort_order or [])
+            if lessthan or reverse:
                 default = 100
             else:
                 default = 0
@@ -434,11 +479,14 @@ class RecipeSearch():
                 recipes = Recipe.objects.all()
                 for book in kwargs[bk_filter]:
                     if 'not' in bk_filter:
-                        recipes = recipes.filter(recipebookentry__book__id=book)
+                        recipes = recipes.filter(
+                            recipebookentry__book__id=book)
                     else:
-                        self._queryset = self._queryset.filter(recipebookentry__book__id=book)
+                        self._queryset = self._queryset.filter(
+                            recipebookentry__book__id=book)
                 if 'not' in bk_filter:
-                    self._queryset = self._queryset.exclude(id__in=recipes.values('id'))
+                    self._queryset = self._queryset.exclude(
+                        id__in=recipes.values('id'))
 
     def step_filters(self, steps=None, operator=True):
         if operator != True:
@@ -446,7 +494,7 @@ class RecipeSearch():
         if not steps:
             return
         if not isinstance(steps, list):
-            steps = [unistepsts]
+            steps = [steps]
         self._queryset = self._queryset.filter(steps__id__in=steps)
 
     def build_fulltext_filters(self, string=None):
@@ -457,20 +505,25 @@ class RecipeSearch():
             rank = []
             if 'name' in self._fulltext_include:
                 vectors.append('name_search_vector')
-                rank.append(SearchRank('name_search_vector', self.search_query, cover_density=True))
+                rank.append(SearchRank('name_search_vector',
+                            self.search_query, cover_density=True))
             if 'description' in self._fulltext_include:
                 vectors.append('desc_search_vector')
-                rank.append(SearchRank('desc_search_vector', self.search_query, cover_density=True))
+                rank.append(SearchRank('desc_search_vector',
+                            self.search_query, cover_density=True))
             if 'steps__instruction' in self._fulltext_include:
                 vectors.append('steps__search_vector')
-                rank.append(SearchRank('steps__search_vector', self.search_query, cover_density=True))
+                rank.append(SearchRank('steps__search_vector',
+                            self.search_query, cover_density=True))
             if 'keywords__name' in self._fulltext_include:
                 # explicitly settings unaccent on keywords and foods so that they behave the same as search_vector fields
                 vectors.append('keywords__name__unaccent')
-                rank.append(SearchRank('keywords__name__unaccent', self.search_query, cover_density=True))
+                rank.append(SearchRank('keywords__name__unaccent',
+                            self.search_query, cover_density=True))
             if 'steps__ingredients__food__name' in self._fulltext_include:
                 vectors.append('steps__ingredients__food__name__unaccent')
-                rank.append(SearchRank('steps__ingredients__food__name', self.search_query, cover_density=True))
+                rank.append(SearchRank('steps__ingredients__food__name',
+                            self.search_query, cover_density=True))
 
             for r in rank:
                 if self.search_rank is None:
@@ -478,7 +531,8 @@ class RecipeSearch():
                 else:
                     self.search_rank += r
             # modifying queryset will annotation creates duplicate results
-            self._filters.append(Q(id__in=Recipe.objects.annotate(vector=SearchVector(*vectors)).filter(Q(vector=self.search_query))))
+            self._filters.append(Q(id__in=Recipe.objects.annotate(
+                vector=SearchVector(*vectors)).filter(Q(vector=self.search_query))))
 
     def build_text_filters(self, string=None):
         if not string:
@@ -508,25 +562,32 @@ class RecipeSearch():
             self._filters += [Q(pk__in=self._fuzzy_match.values('pk'))]
 
     def _makenow_filter(self, missing=None):
-        if missing is None or (type(missing) == bool and missing == False):
+        if missing is None or (isinstance(missing, bool) and missing == False):
             return
-        shopping_users = [*self._request.user.get_shopping_share(), self._request.user]
+        shopping_users = [
+            *self._request.user.get_shopping_share(), self._request.user]
 
         onhand_filter = (
-                Q(steps__ingredients__food__onhand_users__in=shopping_users)  # food onhand
-                | Q(steps__ingredients__food__substitute__onhand_users__in=shopping_users)  # or substitute food onhand
-                | Q(steps__ingredients__food__in=self.__children_substitute_filter(shopping_users))
-                | Q(steps__ingredients__food__in=self.__sibling_substitute_filter(shopping_users))
+            Q(steps__ingredients__food__onhand_users__in=shopping_users)  # food onhand
+            # or substitute food onhand
+            | Q(steps__ingredients__food__substitute__onhand_users__in=shopping_users)
+            | Q(steps__ingredients__food__in=self.__children_substitute_filter(shopping_users))
+            | Q(steps__ingredients__food__in=self.__sibling_substitute_filter(shopping_users))
         )
         makenow_recipes = Recipe.objects.annotate(
-            count_food=Count('steps__ingredients__food__pk', filter=Q(steps__ingredients__food__isnull=False), distinct=True),
-            count_onhand=Count('steps__ingredients__food__pk', filter=onhand_filter, distinct=True),
+            count_food=Count('steps__ingredients__food__pk', filter=Q(
+                steps__ingredients__food__isnull=False), distinct=True),
+            count_onhand=Count('steps__ingredients__food__pk',
+                               filter=onhand_filter, distinct=True),
             count_ignore_shopping=Count('steps__ingredients__food__pk', filter=Q(steps__ingredients__food__ignore_shopping=True,
                                                                                  steps__ingredients__food__recipe__isnull=True), distinct=True),
-            has_child_sub=Case(When(steps__ingredients__food__in=self.__children_substitute_filter(shopping_users), then=Value(1)), default=Value(0)),
-            has_sibling_sub=Case(When(steps__ingredients__food__in=self.__sibling_substitute_filter(shopping_users), then=Value(1)), default=Value(0))
+            has_child_sub=Case(When(steps__ingredients__food__in=self.__children_substitute_filter(
+                shopping_users), then=Value(1)), default=Value(0)),
+            has_sibling_sub=Case(When(steps__ingredients__food__in=self.__sibling_substitute_filter(
+                shopping_users), then=Value(1)), default=Value(0))
         ).annotate(missingfood=F('count_food') - F('count_onhand') - F('count_ignore_shopping')).filter(missingfood=missing)
-        self._queryset = self._queryset.distinct().filter(id__in=makenow_recipes.values('id'))
+        self._queryset = self._queryset.distinct().filter(
+            id__in=makenow_recipes.values('id'))
 
     @staticmethod
     def __children_substitute_filter(shopping_users=None):
@@ -547,7 +608,8 @@ class RecipeSearch():
     @staticmethod
     def __sibling_substitute_filter(shopping_users=None):
         sibling_onhand_subquery = Food.objects.filter(
-            path__startswith=Substr(OuterRef('path'), 1, Food.steplen * (OuterRef('depth') - 1)),
+            path__startswith=Substr(
+                OuterRef('path'), 1, Food.steplen * (OuterRef('depth') - 1)),
             depth=OuterRef('depth'),
             onhand_users__in=shopping_users
         )
@@ -586,7 +648,8 @@ class RecipeFacet():
         self.Recent = self._cache.get('Recent', None)
 
         if self._queryset is not None:
-            self._recipe_list = list(self._queryset.values_list('id', flat=True))
+            self._recipe_list = list(
+                self._queryset.values_list('id', flat=True))
             self._search_params = {
                 'keyword_list': self._request.query_params.getlist('keywords', []),
                 'food_list': self._request.query_params.getlist('foods', []),
@@ -618,7 +681,8 @@ class RecipeFacet():
             'Books': self.Books
 
         }
-        caches['default'].set(self._SEARCH_CACHE_KEY, self._cache, self._cache_timeout)
+        caches['default'].set(self._SEARCH_CACHE_KEY,
+                              self._cache, self._cache_timeout)
 
     def get_facets(self, from_cache=False):
         if from_cache:
@@ -655,13 +719,16 @@ class RecipeFacet():
     def get_keywords(self):
         if self.Keywords is None:
             if self._search_params['search_keywords_or']:
-                keywords = Keyword.objects.filter(space=self._request.space).distinct()
+                keywords = Keyword.objects.filter(
+                    space=self._request.space).distinct()
             else:
-                keywords = Keyword.objects.filter(Q(recipe__in=self._recipe_list) | Q(depth=1)).filter(space=self._request.space).distinct()
+                keywords = Keyword.objects.filter(Q(recipe__in=self._recipe_list) | Q(
+                    depth=1)).filter(space=self._request.space).distinct()
 
             # set keywords to root objects only
             keywords = self._keyword_queryset(keywords)
-            self.Keywords = [{**x, 'children': None} if x['numchild'] > 0 else x for x in list(keywords)]
+            self.Keywords = [{**x, 'children': None}
+                             if x['numchild'] > 0 else x for x in list(keywords)]
             self.set_cache('Keywords', self.Keywords)
         return self.Keywords
 
@@ -669,28 +736,28 @@ class RecipeFacet():
         if self.Foods is None:
             # # if using an OR search, will annotate all keywords, otherwise, just those that appear in results
             if self._search_params['search_foods_or']:
-                foods = Food.objects.filter(space=self._request.space).distinct()
+                foods = Food.objects.filter(
+                    space=self._request.space).distinct()
             else:
-                foods = Food.objects.filter(Q(ingredient__step__recipe__in=self._recipe_list) | Q(depth=1)).filter(space=self._request.space).distinct()
+                foods = Food.objects.filter(Q(ingredient__step__recipe__in=self._recipe_list) | Q(
+                    depth=1)).filter(space=self._request.space).distinct()
 
             # set keywords to root objects only
             foods = self._food_queryset(foods)
 
-            self.Foods = [{**x, 'children': None} if x['numchild'] > 0 else x for x in list(foods)]
+            self.Foods = [{**x, 'children': None}
+                          if x['numchild'] > 0 else x for x in list(foods)]
             self.set_cache('Foods', self.Foods)
         return self.Foods
 
-    def get_books(self):
-        if self.Books is None:
-            self.Books = []
-        return self.Books
-
     def get_ratings(self):
         if self.Ratings is None:
             if not self._request.space.demo and self._request.space.show_facet_count:
                 if self._queryset is None:
-                    self._queryset = Recipe.objects.filter(id__in=self._recipe_list)
-                rating_qs = self._queryset.annotate(rating=Round(Avg(Case(When(cooklog__created_by=self._request.user, then='cooklog__rating'), default=Value(0)))))
+                    self._queryset = Recipe.objects.filter(
+                        id__in=self._recipe_list)
+                rating_qs = self._queryset.annotate(rating=Round(Avg(Case(When(
+                    cooklog__created_by=self._request.user, then='cooklog__rating'), default=Value(0)))))
                 self.Ratings = dict(Counter(r.rating for r in rating_qs))
             else:
                 self.Rating = {}
@@ -715,10 +782,13 @@ class RecipeFacet():
         foods = self._food_queryset(food.get_children(), food)
         deep_search = self.Foods
         for node in nodes:
-            index = next((i for i, x in enumerate(deep_search) if x["id"] == node.id), None)
+            index = next((i for i, x in enumerate(
+                deep_search) if x["id"] == node.id), None)
             deep_search = deep_search[index]['children']
-        index = next((i for i, x in enumerate(deep_search) if x["id"] == food.id), None)
-        deep_search[index]['children'] = [{**x, 'children': None} if x['numchild'] > 0 else x for x in list(foods)]
+        index = next((i for i, x in enumerate(
+            deep_search) if x["id"] == food.id), None)
+        deep_search[index]['children'] = [
+            {**x, 'children': None} if x['numchild'] > 0 else x for x in list(foods)]
         self.set_cache('Foods', self.Foods)
         return self.get_facets()
 
@@ -731,10 +801,13 @@ class RecipeFacet():
         keywords = self._keyword_queryset(keyword.get_children(), keyword)
         deep_search = self.Keywords
         for node in nodes:
-            index = next((i for i, x in enumerate(deep_search) if x["id"] == node.id), None)
+            index = next((i for i, x in enumerate(
+                deep_search) if x["id"] == node.id), None)
             deep_search = deep_search[index]['children']
-        index = next((i for i, x in enumerate(deep_search) if x["id"] == keyword.id), None)
-        deep_search[index]['children'] = [{**x, 'children': None} if x['numchild'] > 0 else x for x in list(keywords)]
+        index = next((i for i, x in enumerate(deep_search)
+                     if x["id"] == keyword.id), None)
+        deep_search[index]['children'] = [
+            {**x, 'children': None} if x['numchild'] > 0 else x for x in list(keywords)]
         self.set_cache('Keywords', self.Keywords)
         return self.get_facets()
 

cookbook/helper/recipe_url_import.py

@@ -1,8 +1,9 @@
-import random
+# import random
 import re
+import traceback
 from html import unescape
-from unicodedata import decomposition
 
+from django.core.cache import caches
 from django.utils.dateparse import parse_duration
 from django.utils.translation import gettext as _
 from isodate import parse_duration as iso_parse_duration
@@ -10,9 +11,12 @@ from isodate.isoerror import ISO8601Error
 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 import recipe_url_import as helper
 from cookbook.helper.ingredient_parser import IngredientParser
-from cookbook.models import Keyword
+from cookbook.models import Automation, Keyword, PropertyType
+
+# from unicodedata import decomposition
+
 
 # from recipe_scrapers._utils import get_minutes  ## temporary until/unless upstream incorporates get_minutes() PR
 
@@ -30,6 +34,9 @@ def get_from_scraper(scrape, request):
         except Exception:
             recipe_json['name'] = ''
 
+    if isinstance(recipe_json['name'], list) and len(recipe_json['name']) > 0:
+        recipe_json['name'] = recipe_json['name'][0]
+
     try:
         description = scrape.description() or None
     except Exception:
@@ -43,7 +50,8 @@ def get_from_scraper(scrape, request):
     recipe_json['internal'] = True
 
     try:
-        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
+        # dont use scrape.yields() as this will always return "x servings" or "x items", should be improved in scrapers directly
+        servings = scrape.schema.data.get('recipeYield') or 1
     except Exception:
         servings = 1
 
@@ -121,7 +129,13 @@ def get_from_scraper(scrape, request):
         try:
             keywords.append(source_url.replace('http://', '').replace('https://', '').split('/')[0])
         except Exception:
-            pass
+            recipe_json['source_url'] = ''
+
+    try:
+        if scrape.author():
+            keywords.append(scrape.author())
+    except Exception:
+        pass
 
     try:
         recipe_json['keywords'] = parse_keywords(list(set(map(str.casefold, keywords))), request.space)
@@ -133,51 +147,112 @@ def get_from_scraper(scrape, request):
     recipe_json['steps'] = []
     try:
         for i in parse_instructions(scrape.instructions()):
-            recipe_json['steps'].append({'instruction': i, 'ingredients': [], })
+            recipe_json['steps'].append({'instruction': i, 'ingredients': [], 'show_ingredients_table': request.user.userpreference.show_step_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']
+    parsed_description = parse_description(description)
+    # TODO notify user about limit if reached
+    # limits exist to limit the attack surface for dos style attacks
+    automations = Automation.objects.filter(
+        type=Automation.DESCRIPTION_REPLACE,
+        space=request.space,
+        disabled=False).only(
+        'param_1',
+        'param_2',
+        'param_3').all().order_by('order')[
+            :512]
+    for a in automations:
+        if re.match(a.param_1, (recipe_json['source_url'])[:512]):
+            parsed_description = re.sub(a.param_2, a.param_3, parsed_description, count=1)
+
+    if len(parsed_description) > 256:  # split at 256 as long descriptions don't look good on recipe cards
+        recipe_json['steps'][0]['instruction'] = f'*{parsed_description}*  \n\n' + recipe_json['steps'][0]['instruction']
     else:
-        recipe_json['description'] = parse_description(description)[:512]
+        recipe_json['description'] = parsed_description[:512]
 
     try:
         for x in scrape.ingredients():
-            try:
-                amount, unit, ingredient, note = ingredient_parser.parse(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:
-                recipe_json['steps'][0]['ingredients'].append(
-                    {
-                        'amount': 0,
-                        'unit': None,
+            if x.strip() != '':
+                try:
+                    amount, unit, ingredient, note = ingredient_parser.parse(x)
+                    ingredient = {
+                        'amount': amount,
                         'food': {
-                            'name': x,
+                            'name': ingredient,
                         },
-                        'note': '',
+                        'unit': None,
+                        'note': note,
                         'original_text': x
                     }
-                )
+                    if unit:
+                        ingredient['unit'] = {'name': unit, }
+                    recipe_json['steps'][0]['ingredients'].append(ingredient)
+                except Exception:
+                    recipe_json['steps'][0]['ingredients'].append(
+                        {
+                            'amount': 0,
+                            'unit': None,
+                            'food': {
+                                'name': x,
+                            },
+                            'note': '',
+                            'original_text': x
+                        }
+                    )
     except Exception:
         pass
 
+    try:
+        recipe_json['properties'] = get_recipe_properties(request.space, scrape.schema.nutrients())
+        print(recipe_json['properties'])
+    except Exception:
+        traceback.print_exc()
+        pass
+
+    if 'source_url' in recipe_json and recipe_json['source_url']:
+        automations = Automation.objects.filter(
+            type=Automation.INSTRUCTION_REPLACE,
+            space=request.space,
+            disabled=False).only(
+            'param_1',
+            'param_2',
+            'param_3').order_by('order').all()[
+            :512]
+        for a in automations:
+            if re.match(a.param_1, (recipe_json['source_url'])[:512]):
+                for s in recipe_json['steps']:
+                    s['instruction'] = re.sub(a.param_2, a.param_3, s['instruction'])
+
     return recipe_json
 
 
+def get_recipe_properties(space, property_data):
+    # {'servingSize': '1', 'calories': '302 kcal', 'proteinContent': '7,66g', 'fatContent': '11,56g', 'carbohydrateContent': '41,33g'}
+    properties = {
+        "property-calories": "calories",
+        "property-carbohydrates": "carbohydrateContent",
+        "property-proteins": "proteinContent",
+        "property-fats": "fatContent",
+    }
+    recipe_properties = []
+    for pt in PropertyType.objects.filter(space=space, open_data_slug__in=list(properties.keys())).all():
+        for p in list(properties.keys()):
+            if pt.open_data_slug == p:
+                if properties[p] in property_data:
+                    recipe_properties.append({
+                        'property_type': {
+                            'id': pt.id,
+                            'name': pt.name,
+                        },
+                        'property_amount': parse_servings(property_data[properties[p]]) / float(property_data['servingSize']),
+                    })
+
+    return recipe_properties
+
+
 def get_from_youtube_scraper(url, request):
     """A YouTube Information Scraper."""
     kw, created = Keyword.objects.get_or_create(name='YouTube', space=request.space)
@@ -211,7 +286,7 @@ def get_from_youtube_scraper(url, request):
 
 
 def parse_name(name):
-    if type(name) == list:
+    if isinstance(name, list):
         try:
             name = name[0]
         except Exception:
@@ -224,10 +299,27 @@ def parse_description(description):
 
 
 def clean_instruction_string(instruction):
-    normalized_string = normalize_string(instruction)
+    # handle HTML tags that can be converted to markup
+    normalized_string = instruction \
+        .replace("<nobr>", "**") \
+        .replace("</nobr>", "**") \
+        .replace("<strong>", "**") \
+        .replace("</strong>", "**")
+    normalized_string = normalize_string(normalized_string)
     normalized_string = normalized_string.replace('\n', '  \n')
     normalized_string = normalized_string.replace('  \n  \n', '\n\n')
-    return normalized_string
+
+    # handle unsupported, special UTF8 character in Thermomix-specific instructions,
+    # that happen in nearly every recipe on Cookidoo, Zaubertopf Club, Rezeptwelt
+    # and in Thermomix-specific recipes on many other sites
+    return normalized_string \
+        .replace("", _('reverse rotation')) \
+        .replace("", _('careful rotation')) \
+        .replace("", _('knead')) \
+        .replace("Andicken ", _('thicken')) \
+        .replace("Erwärmen ", _('warm up')) \
+        .replace("Fermentieren ", _('ferment')) \
+        .replace("Sous-vide ", _("sous-vide"))
 
 
 def parse_instructions(instructions):
@@ -238,16 +330,16 @@ def parse_instructions(instructions):
     """
     instruction_list = []
 
-    if type(instructions) == list:
+    if isinstance(instructions, list):
         for i in instructions:
-            if type(i) == str:
+            if isinstance(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:
+                        if isinstance(ile, str):
                             instruction_list.append(clean_instruction_string(ile))
                         elif 'text' in ile:
                             instruction_list.append(clean_instruction_string(ile['text']))
@@ -263,13 +355,13 @@ def parse_image(image):
     # check if list of images is returned, take first if so
     if not image:
         return None
-    if type(image) == list:
+    if isinstance(image, list):
         for pic in image:
-            if (type(pic) == str) and (pic[:4] == 'http'):
+            if (isinstance(pic, str)) and (pic[:4] == 'http'):
                 image = pic
             elif 'url' in pic:
                 image = pic['url']
-    elif type(image) == dict:
+    elif isinstance(image, dict):
         if 'url' in image:
             image = image['url']
 
@@ -280,12 +372,12 @@ def parse_image(image):
 
 
 def parse_servings(servings):
-    if type(servings) == str:
+    if isinstance(servings, str):
         try:
             servings = int(re.search(r'\d+', servings).group())
         except AttributeError:
             servings = 1
-    elif type(servings) == list:
+    elif isinstance(servings, list):
         try:
             servings = int(re.findall(r'\b\d+\b', servings[0])[0])
         except KeyError:
@@ -294,11 +386,16 @@ def parse_servings(servings):
 
 
 def parse_servings_text(servings):
-    if type(servings) == str:
+    if isinstance(servings, str):
         try:
-            servings = re.sub("\d+", '', servings).strip()
+            servings = re.sub("\\d+", '', servings).strip()
         except Exception:
             servings = ''
+    if isinstance(servings, list):
+        try:
+            servings = parse_servings_text(servings[1])
+        except Exception:
+            pass
     return str(servings)[:32]
 
 
@@ -311,7 +408,7 @@ def parse_time(recipe_time):
                 recipe_time = round(iso_parse_duration(recipe_time).seconds / 60)
             except ISO8601Error:
                 try:
-                    if (type(recipe_time) == list and len(recipe_time) > 0):
+                    if (isinstance(recipe_time, list) and len(recipe_time) > 0):
                         recipe_time = recipe_time[0]
                     recipe_time = round(parse_duration(recipe_time).seconds / 60)
                 except AttributeError:
@@ -322,10 +419,28 @@ def parse_time(recipe_time):
 
 def parse_keywords(keyword_json, space):
     keywords = []
+    keyword_aliases = {}
+    # retrieve keyword automation cache if it exists, otherwise build from database
+    KEYWORD_CACHE_KEY = f'automation_keyword_alias_{space.pk}'
+    if c := caches['default'].get(KEYWORD_CACHE_KEY, None):
+        keyword_aliases = c
+        caches['default'].touch(KEYWORD_CACHE_KEY, 30)
+    else:
+        for a in Automation.objects.filter(space=space, disabled=False, type=Automation.KEYWORD_ALIAS).only('param_1', 'param_2').order_by('order').all():
+            keyword_aliases[a.param_1.lower()] = a.param_2
+        caches['default'].set(KEYWORD_CACHE_KEY, keyword_aliases, 30)
+
     # keywords as list
     for kw in keyword_json:
         kw = normalize_string(kw)
+        # if alias exists use that instead
+
         if len(kw) != 0:
+            if keyword_aliases:
+                try:
+                    kw = keyword_aliases[kw.lower()]
+                except KeyError:
+                    pass
             if k := Keyword.objects.filter(name=kw, space=space).first():
                 keywords.append({'label': str(k), 'name': k.name, 'id': k.id})
             else:
@@ -337,15 +452,15 @@ def parse_keywords(keyword_json, space):
 def listify_keywords(keyword_list):
     # keywords as string
     try:
-        if type(keyword_list[0]) == dict:
+        if isinstance(keyword_list[0], dict):
             return keyword_list
     except (KeyError, IndexError):
         pass
-    if type(keyword_list) == str:
+    if isinstance(keyword_list, str):
         keyword_list = keyword_list.split(',')
 
     # keywords as string in list
-    if (type(keyword_list) == list and len(keyword_list) == 1 and ',' in keyword_list[0]):
+    if (isinstance(keyword_list, list) and len(keyword_list) == 1 and ',' in keyword_list[0]):
         keyword_list = keyword_list[0].split(',')
     return [x.strip() for x in keyword_list]
 
@@ -396,3 +511,18 @@ def get_images_from_soup(soup, url):
             if 'http' in u:
                 images.append(u)
     return images
+
+
+def clean_dict(input_dict, key):
+    if isinstance(input_dict, dict):
+        for x in list(input_dict):
+            if x == key:
+                del input_dict[x]
+            elif isinstance(input_dict[x], dict):
+                input_dict[x] = clean_dict(input_dict[x], key)
+            elif isinstance(input_dict[x], list):
+                temp_list = []
+                for e in input_dict[x]:
+                    temp_list.append(clean_dict(e, key))
+
+    return input_dict

cookbook/helper/shopping_helper.py

@@ -47,6 +47,8 @@ class RecipeShoppingEditor():
         self.mealplan = self._kwargs.get('mealplan', None)
         if type(self.mealplan) in [int, float]:
             self.mealplan = MealPlan.objects.filter(id=self.mealplan, space=self.space)
+        if type(self.mealplan) == dict:
+            self.mealplan = MealPlan.objects.filter(id=self.mealplan['id'], space=self.space).first()
         self.id = self._kwargs.get('id', None)
 
         self._shopping_list_recipe = self.get_shopping_list_recipe(self.id, self.created_by, self.space)
@@ -107,7 +109,10 @@ class RecipeShoppingEditor():
             self.servings = float(servings)
 
         if mealplan := kwargs.get('mealplan', None):
-            self.mealplan = mealplan
+            if type(mealplan) == dict:
+                self.mealplan = MealPlan.objects.filter(id=mealplan['id'], space=self.space).first()
+            else:
+                self.mealplan = mealplan
             self.recipe = mealplan.recipe
         elif recipe := kwargs.get('recipe', None):
             self.recipe = recipe
@@ -310,4 +315,4 @@ class RecipeShoppingEditor():
 #         )
 
 #     # return all shopping list items
-#     return list_recipe
+#     return list_recipe

cookbook/helper/template_helper.py

@@ -2,7 +2,6 @@ from gettext import gettext as _
 
 import bleach
 import markdown as md
-from bleach_allowlist import markdown_attrs, markdown_tags
 from jinja2 import Template, TemplateSyntaxError, UndefinedError
 from markdown.extensions.tables import TableExtension
 
@@ -22,10 +21,25 @@ class IngredientObject(object):
         else:
             self.amount = f"<scalable-number v-bind:number='{bleach.clean(str(ingredient.amount))}' v-bind:factor='ingredient_factor'></scalable-number>"
         if ingredient.unit:
-            self.unit = bleach.clean(str(ingredient.unit))
+            if ingredient.unit.plural_name in (None, ""):
+                self.unit = bleach.clean(str(ingredient.unit))
+            else:
+                if ingredient.always_use_plural_unit or ingredient.amount > 1 and not ingredient.no_amount:
+                    self.unit = bleach.clean(ingredient.unit.plural_name)
+                else:
+                    self.unit = bleach.clean(str(ingredient.unit))
         else:
             self.unit = ""
-        self.food = bleach.clean(str(ingredient.food))
+        if ingredient.food:
+            if ingredient.food.plural_name in (None, ""):
+                self.food = bleach.clean(str(ingredient.food))
+            else:
+                if ingredient.always_use_plural_food or ingredient.amount > 1 and not ingredient.no_amount:
+                    self.food = bleach.clean(str(ingredient.food.plural_name))
+                else:
+                    self.food = bleach.clean(str(ingredient.food))
+        else:
+            self.food = ""
         self.note = bleach.clean(str(ingredient.note))
 
     def __str__(self):
@@ -38,9 +52,17 @@ class IngredientObject(object):
 def render_instructions(step):  # TODO deduplicate markdown cleanup code
     instructions = step.instruction
 
-    tags = markdown_tags + [
-        'pre', 'table', 'td', 'tr', 'th', 'tbody', 'style', 'thead', 'img'
-    ]
+    tags = {
+        "h1", "h2", "h3", "h4", "h5", "h6",
+        "b", "i", "strong", "em", "tt",
+        "p", "br",
+        "span", "div", "blockquote", "code", "pre", "hr",
+        "ul", "ol", "li", "dd", "dt",
+        "img",
+        "a",
+        "sub", "sup",
+        'pre', 'table', 'td', 'tr', 'th', 'tbody', 'style', 'thead'
+    }
     parsed_md = md.markdown(
         instructions,
         extensions=[
@@ -48,7 +70,11 @@ def render_instructions(step):  # TODO deduplicate markdown cleanup code
             UrlizeExtension(), MarkdownFormatExtension()
         ]
     )
-    markdown_attrs['*'] = markdown_attrs['*'] + ['class', 'width', 'height']
+    markdown_attrs = {
+        "*": ["id", "class", 'width', 'height'],
+        "img": ["src", "alt", "title"],
+        "a": ["href", "alt", "title"],
+    }
 
     instructions = bleach.clean(parsed_md, tags, markdown_attrs)
 

cookbook/helper/unit_conversion_helper.py

@@ -0,0 +1,141 @@
+from django.core.cache import caches
+from decimal import Decimal
+
+from cookbook.helper.cache_helper import CacheHelper
+from cookbook.models import Ingredient, Unit
+
+CONVERSION_TABLE = {
+    'weight': {
+        'g': 1000,
+        'kg': 1,
+        'ounce': 35.274,
+        'pound': 2.20462
+    },
+    'volume': {
+        'ml': 1000,
+        'l': 1,
+        'fluid_ounce': 33.814,
+        'pint': 2.11338,
+        'quart': 1.05669,
+        'gallon': 0.264172,
+        'tbsp': 67.628,
+        'tsp': 202.884,
+        'imperial_fluid_ounce': 35.1951,
+        'imperial_pint': 1.75975,
+        'imperial_quart': 0.879877,
+        'imperial_gallon': 0.219969,
+        'imperial_tbsp': 56.3121,
+        'imperial_tsp': 168.936,
+    },
+}
+
+BASE_UNITS_WEIGHT = list(CONVERSION_TABLE['weight'].keys())
+BASE_UNITS_VOLUME = list(CONVERSION_TABLE['volume'].keys())
+
+
+class ConversionException(Exception):
+    pass
+
+
+class UnitConversionHelper:
+    space = None
+
+    def __init__(self, space):
+        """
+        Initializes unit conversion helper
+        :param space: space to perform conversions on
+        """
+        self.space = space
+
+    @staticmethod
+    def convert_from_to(from_unit, to_unit, amount):
+        """
+        Convert from one base unit to another. Throws ConversionException if trying to convert between different systems (weight/volume) or if units are not supported.
+        :param from_unit: str unit to convert from
+        :param to_unit: str unit to convert to
+        :param amount: amount to convert
+        :return: Decimal converted amount
+        """
+        system = None
+        if from_unit in BASE_UNITS_WEIGHT and to_unit in BASE_UNITS_WEIGHT:
+            system = 'weight'
+        if from_unit in BASE_UNITS_VOLUME and to_unit in BASE_UNITS_VOLUME:
+            system = 'volume'
+
+        if not system:
+            raise ConversionException('Trying to convert units not existing or not in one unit system (weight/volume)')
+
+        return Decimal(amount / Decimal(CONVERSION_TABLE[system][from_unit] / CONVERSION_TABLE[system][to_unit]))
+
+    def base_conversions(self, ingredient_list):
+        """
+        Calculates all possible base unit conversions for each ingredient give.
+        Converts to all common base units IF they exist in the unit database of the space.
+        For useful results all ingredients passed should be of the same food, otherwise filtering afterwards might be required.
+        :param ingredient_list: list of ingredients to convert
+        :return: ingredient list with appended conversions
+        """
+        base_conversion_ingredient_list = ingredient_list.copy()
+        for i in ingredient_list:
+            try:
+                conversion_unit = i.unit.name
+                if i.unit.base_unit:
+                    conversion_unit = i.unit.base_unit
+
+                # TODO allow setting which units to convert to? possibly only once conversions become visible
+                units = caches['default'].get(CacheHelper(self.space).BASE_UNITS_CACHE_KEY, None)
+                if not units:
+                    units = Unit.objects.filter(space=self.space, base_unit__in=(BASE_UNITS_VOLUME + BASE_UNITS_WEIGHT)).all()
+                    caches['default'].set(CacheHelper(self.space).BASE_UNITS_CACHE_KEY, units, 60 * 60)  # cache is cleared on unit save signal so long duration is fine
+
+                for u in units:
+                    try:
+                        ingredient = Ingredient(amount=self.convert_from_to(conversion_unit, u.base_unit, i.amount), unit=u, food=ingredient_list[0].food, )
+                        if not any((x.unit.name == ingredient.unit.name or x.unit.base_unit == ingredient.unit.name) for x in base_conversion_ingredient_list):
+                            base_conversion_ingredient_list.append(ingredient)
+                    except ConversionException:
+                        pass
+            except Exception:
+                pass
+
+        return base_conversion_ingredient_list
+
+    def get_conversions(self, ingredient):
+        """
+        Converts an ingredient to all possible conversions based on the custom unit conversion database.
+        After that passes conversion to UnitConversionHelper.base_conversions() to get all base conversions possible.
+        :param ingredient: Ingredient object
+        :return: list of ingredients with all possible custom and base conversions
+        """
+        conversions = [ingredient]
+        if ingredient.unit:
+            for c in ingredient.unit.unit_conversion_base_relation.all():
+                if c.space == self.space:
+                    r = self._uc_convert(c, ingredient.amount, ingredient.unit, ingredient.food)
+                    if r and r not in conversions:
+                        conversions.append(r)
+            for c in ingredient.unit.unit_conversion_converted_relation.all():
+                if c.space == self.space:
+                    r = self._uc_convert(c, ingredient.amount, ingredient.unit, ingredient.food)
+                    if r and r not in conversions:
+                        conversions.append(r)
+
+        conversions = self.base_conversions(conversions)
+
+        return conversions
+
+    def _uc_convert(self, uc, amount, unit, food):
+        """
+        Helper to calculate values for custom unit conversions.
+        Converts given base values using the passed UnitConversion object into a converted Ingredient
+        :param uc: UnitConversion object
+        :param amount: base amount
+        :param unit: base unit
+        :param food: base food
+        :return: converted ingredient object from base amount/unit/food
+        """
+        if uc.food is None or uc.food == food:
+            if unit == uc.base_unit:
+                return Ingredient(amount=amount * (uc.converted_amount / uc.base_amount), unit=uc.converted_unit, food=food, space=self.space)
+            else:
+                return Ingredient(amount=amount * (uc.base_amount / uc.converted_amount), unit=uc.base_unit, food=food, space=self.space)

cookbook/integration/cheftap.py

@@ -36,7 +36,7 @@ class ChefTap(Integration):
 
         recipe = Recipe.objects.create(name=title, created_by=self.request.user, internal=True, space=self.request.space, )
 
-        step = Step.objects.create(instruction='\n'.join(directions), space=self.request.space,)
+        step = Step.objects.create(instruction='\n'.join(directions), space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,)
 
         if source_url != '':
             step.instruction += '\n' + source_url

cookbook/integration/chowdown.py

@@ -55,7 +55,7 @@ class Chowdown(Integration):
             recipe.keywords.add(keyword)
 
         step = Step.objects.create(
-            instruction='\n'.join(directions) + '\n\n' + '\n'.join(descriptions), space=self.request.space,
+            instruction='\n'.join(directions) + '\n\n' + '\n'.join(descriptions), space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,
         )
 
         ingredient_parser = IngredientParser(self.request, True)

cookbook/integration/cookbookapp.py

@@ -47,7 +47,7 @@ class CookBookApp(Integration):
             pass
 
         # assuming import files only contain single step
-        step = Step.objects.create(instruction=recipe_json['steps'][0]['instruction'], space=self.request.space, )
+        step = Step.objects.create(instruction=recipe_json['steps'][0]['instruction'], space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients, )
 
         if 'nutrition' in recipe_json:
             step.instruction = step.instruction + '\n\n' + recipe_json['nutrition']

cookbook/integration/cookmate.py

@@ -50,7 +50,7 @@ class Cookmate(Integration):
             for step in recipe_text.getchildren():
                 if step.text:
                     step = Step.objects.create(
-                        instruction=step.text.strip(), space=self.request.space,
+                        instruction=step.text.strip(), space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,
                     )
                     recipe.steps.add(step)
 

cookbook/integration/copymethat.py

@@ -51,7 +51,7 @@ class CopyMeThat(Integration):
         except AttributeError:
             pass
 
-        step = Step.objects.create(instruction='', space=self.request.space, )
+        step = Step.objects.create(instruction='', space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients, )
 
         ingredient_parser = IngredientParser(self.request, True)
 

cookbook/integration/default.py

@@ -1,4 +1,5 @@
 import json
+import traceback
 from io import BytesIO, StringIO
 from re import match
 from zipfile import ZipFile
@@ -19,7 +20,10 @@ class Default(Integration):
         recipe = self.decode_recipe(recipe_string)
         images = list(filter(lambda v: match('image.*', v), recipe_zip.namelist()))
         if images:
-            self.import_recipe_image(recipe, BytesIO(recipe_zip.read(images[0])), filetype=get_filetype(images[0]))
+            try:
+                self.import_recipe_image(recipe, BytesIO(recipe_zip.read(images[0])), filetype=get_filetype(images[0]))
+            except AttributeError as e:
+                traceback.print_exc()
         return recipe
 
     def decode_recipe(self, string):

cookbook/integration/domestica.py

@@ -28,7 +28,7 @@ class Domestica(Integration):
         recipe.save()
 
         step = Step.objects.create(
-            instruction=file['directions'], space=self.request.space,
+            instruction=file['directions'], space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,
         )
 
         if file['source'] != '':

cookbook/integration/integration.py

@@ -1,16 +1,12 @@
-import time
+import traceback
 import datetime
-import json
 import traceback
 import uuid
-from io import BytesIO, StringIO
+from io import BytesIO
 from zipfile import BadZipFile, ZipFile
 
-import lxml
-from django.core.cache import cache
-import datetime
-
 from bs4 import Tag
+from django.core.cache import cache
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.files import File
 from django.db import IntegrityError
@@ -20,8 +16,7 @@ from django.utils.translation import gettext as _
 from django_scopes import scope
 from lxml import etree
 
-from cookbook.forms import ImportExportBase
-from cookbook.helper.image_processing import get_filetype, handle_image
+from cookbook.helper.image_processing import handle_image
 from cookbook.models import Keyword, Recipe
 from recipes.settings import DEBUG
 from recipes.settings import EXPORT_FILE_CACHE_DURATION
@@ -182,7 +177,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'] or '.melarecipe' in f['name']:
+                    elif '.json' in f['name'] or '.xml' 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:

cookbook/integration/mealie.py

@@ -5,6 +5,7 @@ from zipfile import ZipFile
 
 from cookbook.helper.image_processing import get_filetype
 from cookbook.helper.ingredient_parser import IngredientParser
+from cookbook.helper.recipe_url_import import parse_servings, parse_servings_text, parse_time
 from cookbook.integration.integration import Integration
 from cookbook.models import Ingredient, Recipe, Step
 
@@ -23,41 +24,60 @@ class Mealie(Integration):
             name=recipe_json['name'].strip(), description=description,
             created_by=self.request.user, internal=True, space=self.request.space)
 
-        # TODO parse times (given in PT2H3M )
-        # @vabene check recipe_url_import.iso_duration_to_minutes  I think it does what you are looking for
-
-        ingredients_added = False
         for s in recipe_json['recipe_instructions']:
-            step = Step.objects.create(
-                instruction=s['text'], space=self.request.space,
-            )
-            if not ingredients_added:
-                ingredients_added = True
-
-                if len(recipe_json['description'].strip()) > 500:
-                    step.instruction = recipe_json['description'].strip() + '\n\n' + step.instruction
-
-                ingredient_parser = IngredientParser(self.request, True)
-                for ingredient in recipe_json['recipe_ingredient']:
-                    try:
-                        if ingredient['food']:
-                            f = ingredient_parser.get_food(ingredient['food'])
-                            u = ingredient_parser.get_unit(ingredient['unit'])
-                            amount = ingredient['quantity']
-                            note = ingredient['note']
-                            original_text = None
-                        else:
-                            amount, unit, food, note = ingredient_parser.parse(ingredient['note'])
-                            f = ingredient_parser.get_food(food)
-                            u = ingredient_parser.get_unit(unit)
-                            original_text = ingredient['note']
-                        step.ingredients.add(Ingredient.objects.create(
-                            food=f, unit=u, amount=amount, note=note, original_text=original_text, space=self.request.space,
-                        ))
-                    except Exception:
-                        pass
+            step = Step.objects.create(instruction=s['text'], space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients, )
             recipe.steps.add(step)
 
+        step = recipe.steps.first()
+        if not step:  # if there is no step in the exported data
+            step = Step.objects.create(instruction='', space=self.request.space, )
+            recipe.steps.add(step)
+
+        if len(recipe_json['description'].strip()) > 500:
+            step.instruction = recipe_json['description'].strip() + '\n\n' + step.instruction
+
+        ingredient_parser = IngredientParser(self.request, True)
+        for ingredient in recipe_json['recipe_ingredient']:
+            try:
+                if ingredient['food']:
+                    f = ingredient_parser.get_food(ingredient['food'])
+                    u = ingredient_parser.get_unit(ingredient['unit'])
+                    amount = ingredient['quantity']
+                    note = ingredient['note']
+                    original_text = None
+                else:
+                    amount, unit, food, note = ingredient_parser.parse(ingredient['note'])
+                    f = ingredient_parser.get_food(food)
+                    u = ingredient_parser.get_unit(unit)
+                    original_text = ingredient['note']
+                step.ingredients.add(Ingredient.objects.create(
+                    food=f, unit=u, amount=amount, note=note, original_text=original_text, space=self.request.space,
+                ))
+            except Exception:
+                pass
+
+        if 'notes' in recipe_json and len(recipe_json['notes']) > 0:
+            notes_text = "#### Notes  \n\n"
+            for n in recipe_json['notes']:
+                notes_text += f'{n["text"]}  \n'
+
+            step = Step.objects.create(
+                instruction=notes_text, space=self.request.space,
+            )
+            recipe.steps.add(step)
+
+        if 'recipe_yield' in recipe_json:
+            recipe.servings = parse_servings(recipe_json['recipe_yield'])
+            recipe.servings_text = parse_servings_text(recipe_json['recipe_yield'])
+
+        if 'total_time' in recipe_json and recipe_json['total_time'] is not None:
+            recipe.working_time = parse_time(recipe_json['total_time'])
+
+        if 'org_url' in recipe_json:
+            recipe.source_url = recipe_json['org_url']
+
+        recipe.save()
+
         for f in self.files:
             if '.zip' in f['name']:
                 import_zip = ZipFile(f['file'])

cookbook/integration/mealmaster.py

@@ -39,7 +39,7 @@ class MealMaster(Integration):
             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, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,
         )
 
         ingredient_parser = IngredientParser(self.request, True)

cookbook/integration/melarecipes.py

@@ -67,7 +67,7 @@ class MelaRecipes(Integration):
                 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,
+                    food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,
                 ))
         recipe.steps.add(step)
 

cookbook/integration/nextcloud_cookbook.py

@@ -1,13 +1,14 @@
 import json
 import re
-from io import BytesIO
+from io import BytesIO, StringIO
 from zipfile import ZipFile
+from PIL import Image
 
 from cookbook.helper.image_processing import get_filetype
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.helper.recipe_url_import import iso_duration_to_minutes
 from cookbook.integration.integration import Integration
-from cookbook.models import Ingredient, Keyword, Recipe, Step
+from cookbook.models import Ingredient, Keyword, Recipe, Step, NutritionInformation
 
 
 class NextcloudCookbook(Integration):
@@ -50,9 +51,15 @@ class NextcloudCookbook(Integration):
 
         ingredients_added = False
         for s in recipe_json['recipeInstructions']:
-            step = Step.objects.create(
-                instruction=s, space=self.request.space,
-            )
+            instruction_text = ''
+            if 'text' in s:
+                step = Step.objects.create(
+                    instruction=s['text'], name=s['name'], space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,
+                )
+            else:
+                step = Step.objects.create(
+                    instruction=s, space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,
+                )
             if not ingredients_added:
                 if len(recipe_json['description'].strip()) > 500:
                     step.instruction = recipe_json['description'].strip() + '\n\n' + step.instruction
@@ -70,12 +77,21 @@ class NextcloudCookbook(Integration):
             recipe.steps.add(step)
 
         if 'nutrition' in recipe_json:
+            nutrition = {}
             try:
-                recipe.nutrition.calories = recipe_json['nutrition']['calories'].replace(' kcal', '').replace(' ', '')
-                recipe.nutrition.proteins = recipe_json['nutrition']['calories'].replace(' g', '').replace(',', '.').replace(' ', '')
-                recipe.nutrition.fats = recipe_json['nutrition']['calories'].replace(' g', '').replace(',', '.').replace(' ', '')
-                recipe.nutrition.carbohydrates = recipe_json['nutrition']['calories'].replace(' g', '').replace(',', '.').replace(' ', '')
-            except Exception:
+                if 'calories' in recipe_json['nutrition']:
+                    nutrition['calories'] = int(re.search(r'\d+', recipe_json['nutrition']['calories']).group())
+                if 'proteinContent' in recipe_json['nutrition']:
+                    nutrition['proteins'] = int(re.search(r'\d+', recipe_json['nutrition']['proteinContent']).group())
+                if 'fatContent' in recipe_json['nutrition']:
+                    nutrition['fats'] = int(re.search(r'\d+', recipe_json['nutrition']['fatContent']).group())
+                if 'carbohydrateContent' in recipe_json['nutrition']:
+                    nutrition['carbohydrates'] = int(re.search(r'\d+', recipe_json['nutrition']['carbohydrateContent']).group())
+
+                if nutrition != {}:
+                    recipe.nutrition = NutritionInformation.objects.create(**nutrition, space=self.request.space)
+                    recipe.save()
+            except Exception as e:
                 pass
 
         for f in self.files:
@@ -87,5 +103,90 @@ class NextcloudCookbook(Integration):
 
         return recipe
 
+    def formatTime(self, min):
+        h = min // 60
+        m = min % 60
+        return f'PT{h}H{m}M0S'
+
     def get_file_from_recipe(self, recipe):
-        raise NotImplementedError('Method not implemented in storage integration')
+
+        export = {}
+        export['name'] = recipe.name
+        export['description'] = recipe.description
+        export['url'] = recipe.source_url
+        export['prepTime'] = self.formatTime(recipe.working_time)
+        export['cookTime'] = self.formatTime(recipe.waiting_time)
+        export['totalTime'] = self.formatTime(recipe.working_time + recipe.waiting_time)
+        export['recipeYield'] = recipe.servings
+        export['image'] = f'/Recipes/{recipe.name}/full.jpg'
+        export['imageUrl'] = f'/Recipes/{recipe.name}/full.jpg'
+
+        recipeKeyword = []
+        for k in recipe.keywords.all():
+            recipeKeyword.append(k.name)
+
+        export['keywords'] = recipeKeyword
+
+        recipeInstructions = []
+        recipeIngredient = []
+        for s in recipe.steps.all():
+            recipeInstructions.append(s.instruction)
+
+            for i in s.ingredients.all():
+                recipeIngredient.append(f'{float(i.amount)} {i.unit} {i.food}')
+
+        export['recipeIngredient'] = recipeIngredient
+        export['recipeInstructions'] = recipeInstructions
+
+        return "recipe.json", json.dumps(export)
+
+    def get_files_from_recipes(self, recipes, el, cookie):
+        export_zip_stream = BytesIO()
+        export_zip_obj = ZipFile(export_zip_stream, 'w')
+
+        for recipe in recipes:
+            if recipe.internal and recipe.space == self.request.space:
+
+                recipe_stream = StringIO()
+                filename, data = self.get_file_from_recipe(recipe)
+                recipe_stream.write(data)
+                export_zip_obj.writestr(f'{recipe.name}/{filename}', recipe_stream.getvalue())
+                recipe_stream.close()
+
+                try:
+                    imageByte = recipe.image.file.read()
+                    export_zip_obj.writestr(f'{recipe.name}/full.jpg', self.getJPEG(imageByte))
+                    export_zip_obj.writestr(f'{recipe.name}/thumb.jpg', self.getThumb(171, imageByte))
+                    export_zip_obj.writestr(f'{recipe.name}/thumb16.jpg', self.getThumb(16, imageByte))
+                except ValueError:
+                    pass
+
+            el.exported_recipes += 1
+            el.msg += self.get_recipe_processed_msg(recipe)
+            el.save()
+
+        export_zip_obj.close()
+
+        return [[self.get_export_file_name(), export_zip_stream.getvalue()]]
+
+    def getJPEG(self, imageByte):
+        image = Image.open(BytesIO(imageByte))
+        image = image.convert('RGB')
+
+        bytes = BytesIO()
+        image.save(bytes, "JPEG")
+        return bytes.getvalue()
+
+    def getThumb(self, size, imageByte):
+        image = Image.open(BytesIO(imageByte))
+
+        w, h = image.size
+        m = min(w, h)
+
+        image = image.crop(((w - m) // 2, (h - m) // 2, (w + m) // 2, (h + m) // 2))
+        image = image.resize([size, size], Image.Resampling.LANCZOS)
+        image = image.convert('RGB')
+
+        bytes = BytesIO()
+        image.save(bytes, "JPEG")
+        return bytes.getvalue()

cookbook/integration/openeats.py

@@ -2,26 +2,56 @@ import json
 
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
-from cookbook.models import Ingredient, Recipe, Step
-
+from cookbook.models import Ingredient, Recipe, Step, Keyword, Comment, CookLog
+from django.utils.translation import gettext as _
 
 class OpenEats(Integration):
 
     def get_recipe_from_file(self, file):
-        recipe = Recipe.objects.create(name=file['name'].strip(), created_by=self.request.user, internal=True,
+
+        description = file['info']
+        description_max_length = Recipe._meta.get_field('description').max_length
+        if len(description) > description_max_length:
+            description = description[0:description_max_length]
+
+        recipe = Recipe.objects.create(name=file['name'].strip(), description=description, created_by=self.request.user, internal=True,
                                        servings=file['servings'], space=self.request.space, waiting_time=file['cook_time'], working_time=file['prep_time'])
 
         instructions = ''
-        if file["info"] != '':
-            instructions += file["info"]
 
         if file["directions"] != '':
             instructions += file["directions"]
 
         if file["source"] != '':
-            instructions += file["source"]
+            instructions += '\n' + _('Recipe source:') + f'[{file["source"]}]({file["source"]})'
 
-        step = Step.objects.create(instruction=instructions, space=self.request.space,)
+        cuisine_keyword, created = Keyword.objects.get_or_create(name="Cuisine", space=self.request.space)      
+        if file["cuisine"] != '':
+            keyword, created = Keyword.objects.get_or_create(name=file["cuisine"].strip(), space=self.request.space)      
+            if created:
+                keyword.move(cuisine_keyword, pos="last-child")
+            recipe.keywords.add(keyword)
+
+        course_keyword, created = Keyword.objects.get_or_create(name="Course", space=self.request.space)      
+        if file["course"] != '':
+            keyword, created = Keyword.objects.get_or_create(name=file["course"].strip(), space=self.request.space)      
+            if created:
+                keyword.move(course_keyword, pos="last-child")
+            recipe.keywords.add(keyword)
+
+        for tag in file["tags"]:
+            keyword, created = Keyword.objects.get_or_create(name=tag.strip(), space=self.request.space)
+            recipe.keywords.add(keyword)
+
+        for comment in file['comments']:
+            Comment.objects.create(recipe=recipe, text=comment['text'], created_by=self.request.user)
+            CookLog.objects.create(recipe=recipe, rating=comment['rating'], created_by=self.request.user, space=self.request.space)
+
+        if file["photo"] != '':
+            recipe.image = f'recipes/openeats-import/{file["photo"]}'
+            recipe.save()
+
+        step = Step.objects.create(instruction=instructions, space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,)
 
         ingredient_parser = IngredientParser(self.request, True)
         for ingredient in file['ingredients']:
@@ -38,6 +68,9 @@ class OpenEats(Integration):
         recipe_json = json.loads(file.read())
         recipe_dict = {}
         ingredient_group_dict = {}
+        cuisine_group_dict = {}
+        course_group_dict = {}
+        tag_group_dict = {}
 
         for o in recipe_json:
             if o['model'] == 'recipe.recipe':
@@ -50,11 +83,27 @@ class OpenEats(Integration):
                     'cook_time': o['fields']['cook_time'],
                     'servings': o['fields']['servings'],
                     'ingredients': [],
+                    'photo': o['fields']['photo'],
+                    'cuisine': o['fields']['cuisine'],
+                    'course': o['fields']['course'],
+                    'tags': o['fields']['tags'],
+                    'comments': [],
                 }
             if o['model'] == 'ingredient.ingredientgroup':
                 ingredient_group_dict[o['pk']] = o['fields']['recipe']
+            if o['model'] == 'recipe_groups.cuisine':
+                cuisine_group_dict[o['pk']] = o['fields']['title']
+            if o['model'] == 'recipe_groups.course':
+                course_group_dict[o['pk']] = o['fields']['title']
+            if o['model'] == 'recipe_groups.tag':
+                tag_group_dict[o['pk']] = o['fields']['title']
 
         for o in recipe_json:
+            if o['model'] == 'rating.rating':
+                recipe_dict[o['fields']['recipe']]["comments"].append({
+                    "text": o['fields']['comment'],
+                    "rating": o['fields']['rating']
+                })
             if o['model'] == 'ingredient.ingredient':
                 ingredient = {
                     'food': o['fields']['title'],
@@ -63,6 +112,15 @@ class OpenEats(Integration):
                 }
                 recipe_dict[ingredient_group_dict[o['fields']['ingredient_group']]]['ingredients'].append(ingredient)
 
+        for k, r in recipe_dict.items():
+            if r["cuisine"] in cuisine_group_dict:
+                r["cuisine"] = cuisine_group_dict[r["cuisine"]]
+            if r["course"] in course_group_dict:
+                r["course"] = course_group_dict[r["course"]]
+            for index in range(len(r["tags"])):
+                if r["tags"][index] in tag_group_dict:
+                    r["tags"][index] = tag_group_dict[r["tags"][index]]
+
         return list(recipe_dict.values())
 
     def get_file_from_recipe(self, recipe):

cookbook/integration/paprika.py

@@ -5,6 +5,9 @@ import re
 from gettext import gettext as _
 from io import BytesIO
 
+import requests
+import validators
+
 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
@@ -55,7 +58,7 @@ class Paprika(Integration):
                 pass
 
             step = Step.objects.create(
-                instruction=instructions, space=self.request.space,
+                instruction=instructions, space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,
             )
 
             if 'description' in recipe_json and len(recipe_json['description'].strip()) > 500:
@@ -81,7 +84,14 @@ class Paprika(Integration):
 
             recipe.steps.add(step)
 
-            if recipe_json.get("photo_data", None):
-                self.import_recipe_image(recipe, BytesIO(base64.b64decode(recipe_json['photo_data'])), filetype='.jpeg')
+            try:
+                if recipe_json.get("image_url", None):
+                    url = recipe_json.get("image_url", None)
+                    if validators.url(url, public=True):
+                        response = requests.get(url)
+                        self.import_recipe_image(recipe, BytesIO(response.content))
+            except:
+                if recipe_json.get("photo_data", None):
+                    self.import_recipe_image(recipe, BytesIO(base64.b64decode(recipe_json['photo_data'])), filetype='.jpeg')
 
             return recipe

cookbook/integration/pepperplate.py

@@ -35,7 +35,7 @@ class Pepperplate(Integration):
         recipe = Recipe.objects.create(name=title, description=description, created_by=self.request.user, internal=True, space=self.request.space)
 
         step = Step.objects.create(
-            instruction='\n'.join(directions) + '\n\n', space=self.request.space,
+            instruction='\n'.join(directions) + '\n\n', space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,
         )
 
         ingredient_parser = IngredientParser(self.request, True)

cookbook/integration/plantoeat.py

@@ -1,6 +1,7 @@
 from io import BytesIO
 
 import requests
+import validators
 
 from cookbook.helper.ingredient_parser import IngredientParser
 from cookbook.integration.integration import Integration
@@ -45,7 +46,7 @@ class Plantoeat(Integration):
         recipe = Recipe.objects.create(name=title, description=description, created_by=self.request.user, internal=True, space=self.request.space)
 
         step = Step.objects.create(
-            instruction='\n'.join(directions) + '\n\n', space=self.request.space,
+            instruction='\n'.join(directions) + '\n\n', space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,
         )
 
         if tags:
@@ -67,8 +68,9 @@ class Plantoeat(Integration):
 
         if image_url:
             try:
-                response = requests.get(image_url)
-                self.import_recipe_image(recipe, BytesIO(response.content))
+                if validators.url(image_url, public=True):
+                    response = requests.get(image_url)
+                    self.import_recipe_image(recipe, BytesIO(response.content))
             except Exception as e:
                 print('failed to import image ', str(e))
 

cookbook/integration/recettetek.py

@@ -46,7 +46,7 @@ class RecetteTek(Integration):
         if not instructions:
             instructions = ''
 
-        step = Step.objects.create(instruction=instructions, space=self.request.space,)
+        step = Step.objects.create(instruction=instructions, space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,)
 
         # Append the original import url to the step (if it exists)
         try:
@@ -61,7 +61,7 @@ class RecetteTek(Integration):
             ingredient_parser = IngredientParser(self.request, True)
             for ingredient in file['ingredients'].split('\n'):
                 if len(ingredient.strip()) > 0:
-                    amount, unit, food, note = ingredient_parser.parse(food)
+                    amount, unit, food, note = ingredient_parser.parse(ingredient.strip())
                     f = ingredient_parser.get_food(ingredient)
                     u = ingredient_parser.get_unit(unit)
                     step.ingredients.add(Ingredient.objects.create(

cookbook/integration/recipekeeper.py

@@ -41,7 +41,7 @@ class RecipeKeeper(Integration):
         except AttributeError:
             pass
 
-        step = Step.objects.create(instruction='', space=self.request.space, )
+        step = Step.objects.create(instruction='', space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients, )
 
         ingredient_parser = IngredientParser(self.request, True)
         for ingredient in file.find("div", {"itemprop": "recipeIngredients"}).findChildren("p"):
@@ -58,6 +58,13 @@ class RecipeKeeper(Integration):
             if s.text == "":
                 continue
             step.instruction += s.text + ' \n'
+            step.save()
+
+        for s in file.find("div", {"itemprop": "recipeNotes"}).find_all("p"):
+            if s.text == "":
+                continue
+            step.instruction += s.text + ' \n'
+            step.save()
 
         if file.find("span", {"itemprop": "recipeSource"}).text != '':
             step.instruction += "\n\n" + _("Imported from") + ": " + file.find("span", {"itemprop": "recipeSource"}).text

cookbook/integration/recipesage.py

@@ -5,6 +5,7 @@ import requests
 import validators
 
 from cookbook.helper.ingredient_parser import IngredientParser
+from cookbook.helper.recipe_url_import import parse_servings, parse_servings_text, parse_time
 from cookbook.integration.integration import Integration
 from cookbook.models import Ingredient, Recipe, Step
 
@@ -18,19 +19,21 @@ class RecipeSage(Integration):
             created_by=self.request.user, internal=True,
             space=self.request.space)
 
+        if file['recipeYield'] != '':
+            recipe.servings = parse_servings(file['recipeYield'])
+            recipe.servings_text = parse_servings_text(file['recipeYield'])
+
         try:
-            if file['recipeYield'] != '':
-                recipe.servings = int(file['recipeYield'])
+            if 'totalTime' in file and file['totalTime'] != '':
+                recipe.working_time = parse_time(file['totalTime'])
 
-            if file['totalTime'] != '':
-                recipe.waiting_time = int(file['totalTime']) - int(file['timePrep'])
-
-            if file['prepTime'] != '':
-                recipe.working_time = int(file['timePrep'])
-
-            recipe.save()
+            if 'timePrep' in file and file['prepTime'] != '':
+                recipe.working_time = parse_time(file['timePrep'])
+                recipe.waiting_time = parse_time(file['totalTime']) - parse_time(file['timePrep'])
         except Exception as e:
-            print('failed to parse yield or time ', str(e))
+            print('failed to parse time ', str(e))
+
+        recipe.save()
 
         ingredient_parser = IngredientParser(self.request, True)
         ingredients_added = False
@@ -46,7 +49,7 @@ class RecipeSage(Integration):
                     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,
+                        food=f, unit=u, amount=amount, note=note, original_text=ingredient, space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,
                     ))
             recipe.steps.add(step)
 

cookbook/integration/rezeptsuitede.py

@@ -0,0 +1,77 @@
+import base64
+from io import BytesIO
+from xml import etree
+
+from lxml import etree
+
+from cookbook.helper.ingredient_parser import IngredientParser
+from cookbook.helper.recipe_url_import import parse_time, parse_servings, parse_servings_text
+from cookbook.integration.integration import Integration
+from cookbook.models import Ingredient, Recipe, Step, Keyword
+
+
+class Rezeptsuitede(Integration):
+
+    def split_recipe_file(self, file):
+        return etree.parse(file).getroot().getchildren()
+
+    def get_recipe_from_file(self, file):
+        recipe_xml = file
+
+        recipe = Recipe.objects.create(
+            name=recipe_xml.find('head').attrib['title'].strip(),
+            created_by=self.request.user, internal=True, space=self.request.space)
+
+        try:
+            if recipe_xml.find('head').attrib['servingtype']:
+                recipe.servings = parse_servings(recipe_xml.find('head').attrib['servingtype'].strip())
+                recipe.servings_text = parse_servings_text(recipe_xml.find('head').attrib['servingtype'].strip())
+        except KeyError:
+            pass
+
+        if recipe_xml.find('remark') is not None:  # description is a list of <li>'s with text
+            if recipe_xml.find('remark').find('line') is not None:
+                recipe.description = recipe_xml.find('remark').find('line').text[:512]
+
+        for prep in recipe_xml.findall('preparation'):
+            try:
+                if prep.find('step').text:
+                    step = Step.objects.create(
+                        instruction=prep.find('step').text.strip(), space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,
+                    )
+                    recipe.steps.add(step)
+            except Exception:
+                pass
+
+        ingredient_parser = IngredientParser(self.request, True)
+
+        if recipe_xml.find('part').find('ingredient') is not None:
+            ingredient_step = recipe.steps.first()
+            if ingredient_step is None:
+                ingredient_step = Step.objects.create(space=self.request.space, instruction='')
+
+            for ingredient in recipe_xml.find('part').findall('ingredient'):
+                f = ingredient_parser.get_food(ingredient.attrib['item'])
+                u = ingredient_parser.get_unit(ingredient.attrib['unit'])
+                amount = 0
+                if ingredient.attrib['qty'].strip() != '':
+                    amount, unit, note = ingredient_parser.parse_amount(ingredient.attrib['qty'])
+                ingredient_step.ingredients.add(Ingredient.objects.create(food=f, unit=u, amount=amount, space=self.request.space, ))
+
+        try:
+            k, created = Keyword.objects.get_or_create(name=recipe_xml.find('head').find('cat').text.strip(), space=self.request.space)
+            recipe.keywords.add(k)
+        except Exception as e:
+            pass
+
+        recipe.save()
+
+        try:
+            self.import_recipe_image(recipe, BytesIO(base64.b64decode(recipe_xml.find('head').find('picbin').text)), filetype='.jpeg')
+        except:
+            pass
+
+        return recipe
+
+    def get_file_from_recipe(self, recipe):
+        raise NotImplementedError('Method not implemented in storage integration')

cookbook/integration/rezkonv.py

@@ -38,7 +38,7 @@ class RezKonv(Integration):
             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, show_ingredients_table=self.request.user.userpreference.show_step_ingredients,
         )
 
         ingredient_parser = IngredientParser(self.request, True)

cookbook/integration/saffron.py

@@ -43,7 +43,7 @@ class Saffron(Integration):
 
         recipe = Recipe.objects.create(name=title, description=description, created_by=self.request.user, internal=True, space=self.request.space, )
 
-        step = Step.objects.create(instruction='\n'.join(directions), space=self.request.space, )
+        step = Step.objects.create(instruction='\n'.join(directions), space=self.request.space, show_ingredients_table=self.request.user.userpreference.show_step_ingredients, )
 
         ingredient_parser = IngredientParser(self.request, True)
         for ingredient in ingredients:

cookbook/locale/bg/LC_MESSAGES/django.po

@@ -8,8 +8,8 @@ msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2022-04-29 18:42+0200\n"
-"PO-Revision-Date: 2022-05-10 15:32+0000\n"
-"Last-Translator: zeon <zeonbg@gmail.com>\n"
+"PO-Revision-Date: 2023-04-12 11:55+0000\n"
+"Last-Translator: noxonad <noxonad@proton.me>\n"
 "Language-Team: Bulgarian <http://translate.tandoor.dev/projects/tandoor/"
 "recipes-backend/bg/>\n"
 "Language: bg\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.10.1\n"
+"X-Generator: Weblate 4.15\n"
 
 #: .\cookbook\filters.py:23 .\cookbook\templates\forms\ingredients.html:34
 #: .\cookbook\templates\space.html:49 .\cookbook\templates\stats.html:28
@@ -1433,7 +1433,7 @@ msgstr ""
 
 #: .\cookbook\templates\index.html:29
 msgid "Search recipe ..."
-msgstr "Търсете рецепта..."
+msgstr "Търсете рецепта ..."
 
 #: .\cookbook\templates\index.html:44
 msgid "New Recipe"
@@ -1818,7 +1818,7 @@ msgid ""
 msgstr ""
 " \n"
 "            Пълнотекстови търсения се опитват да нормализират предоставените "
-"думи, за да съответстват на често срещани варианти. Например: 'вили, "
+"думи, за да съответстват на често срещани варианти.  Например: 'вили, "
 "'вилица', 'вилици' всички ще се нормализират до 'вилиц'.\n"
 "             Има няколко налични метода, описани по-долу, които ще "
 "контролират как поведението при търсене трябва да реагира, когато се търсят "

cookbook/locale/cs/LC_MESSAGES/django.po

@@ -6,20 +6,22 @@
 # Translators:
 # Pavel Solař <pavelsolar86@gmail.com>, 2021
 # 
-#, fuzzy
 msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2021-02-09 18:01+0100\n"
-"PO-Revision-Date: 2020-06-02 19:28+0000\n"
-"Last-Translator: Pavel Solař <pavelsolar86@gmail.com>, 2021\n"
-"Language-Team: Czech (https://www.transifex.com/django-recipes/teams/110507/cs/)\n"
+"PO-Revision-Date: 2023-07-31 14:19+0000\n"
+"Last-Translator: Mára Štěpánek <stepanekm7@gmail.com>\n"
+"Language-Team: Czech <http://translate.tandoor.dev/projects/tandoor/"
+"recipes-backend/cs/>\n"
+"Language: cs\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Language: cs\n"
-"Plural-Forms: nplurals=4; plural=(n == 1 && n % 1 == 0) ? 0 : (n >= 2 && n <= 4 && n % 1 == 0) ? 1: (n % 1 != 0 ) ? 2 : 3;\n"
+"Plural-Forms: nplurals=4; plural=(n == 1 && n % 1 == 0) ? 0 : (n >= 2 && n "
+"<= 4 && n % 1 == 0) ? 1: (n % 1 != 0 ) ? 2 : 3;\n"
+"X-Generator: Weblate 4.15\n"
 
 #: .\cookbook\filters.py:22 .\cookbook\templates\base.html:87
 #: .\cookbook\templates\forms\edit_internal_recipe.html:219
@@ -34,7 +36,7 @@ msgid ""
 "try them out!"
 msgstr ""
 "Barva horního navigačního menu. Některé barvy neladí se všemi tématy a je "
-"třeba je vyzkoušet."
+"třeba je vyzkoušet!"
 
 #: .\cookbook\forms.py:45
 msgid "Default Unit to be used when inserting a new ingredient into a recipe."
@@ -48,7 +50,7 @@ msgid ""
 "to fractions automatically)"
 msgstr ""
 "Povolit podporu zlomků u množství ingrediencí (desetinná čísla budou "
-"automaticky převedena na zlomky)."
+"automaticky převedena na zlomky)"
 
 #: .\cookbook\forms.py:47
 msgid ""
@@ -173,7 +175,7 @@ msgstr "Potravina, která by měla být nahrazena."
 
 #: .\cookbook\forms.py:198
 msgid "Add your comment: "
-msgstr "Přidat  vlastní komentář:"
+msgstr "Přidat vlastní komentář: "
 
 #: .\cookbook\forms.py:229
 msgid "Leave empty for dropbox and enter app password for nextcloud."
@@ -551,7 +553,7 @@ msgstr "Cesta musí být v následujícím formátu"
 
 #: .\cookbook\templates\batch\monitor.html:27
 msgid "Sync Now!"
-msgstr "Zahájit synchronizaci"
+msgstr "Zahájit synchronizaci!"
 
 #: .\cookbook\templates\batch\waiting.html:4
 #: .\cookbook\templates\batch\waiting.html:10
@@ -1034,7 +1036,7 @@ msgstr "Tento text je kurzívou"
 #: .\cookbook\templates\markdown_info.html:61
 #: .\cookbook\templates\markdown_info.html:77
 msgid "Blockquotes are also possible"
-msgstr "Lze použít i kvotace "
+msgstr "Lze použít i kvotace"
 
 #: .\cookbook\templates\markdown_info.html:84
 msgid "Lists"
@@ -1104,8 +1106,8 @@ msgid ""
 "rel=\"noreferrer noopener\" target=\"_blank\">this one.</a>"
 msgstr ""
 "Ruční vytváření tabulek pomocí značek je složité. Doporučujeme použít "
-"například <a href=\"https://www.tablesgenerator.com/markdown_tables\" "
-"rel=\"noreferrer noopener\" target=\"_blank\">tento tabulkový editor</a>."
+"například <a href=\"https://www.tablesgenerator.com/markdown_tables\" rel="
+"\"noreferrer noopener\" target=\"_blank\">tento tabulkový editor.</a>"
 
 #: .\cookbook\templates\markdown_info.html:155
 #: .\cookbook\templates\markdown_info.html:157
@@ -1254,22 +1256,36 @@ msgid ""
 "                        "
 msgstr ""
 "\n"
-"                            <p>Modul jídelníčku umožňuje plánovat jídlo pomocí receptů i poznámek.</p>\n"
-"                            <p>Jednoduše vyberte recept ze seznamu naposledy navštívených receptů, nebo ho vyhledejte\n"
-"                                s přetáhněte na požadovaný den v rozvrhu. Můžete také přidat poznámku s popiskem\n"
-"                                a poté přetáhnout recept pro vytvoření plánu s vlatními popisky. Vytvořením samotné poznámky\n"
-"                                je možné přetažením pole poznámky do rozvrhu.</p>\n"
-"                            <p>Kliknutím na recept zobrazíte detailní náhled. Odtud lze také přidat položky\n"
-"                                do nákupního seznamu. Do nákupního seznamu můžete také přidat všechny recepty na daný den\n"
-"                                kliknutím na ikonu nákupního košíku na horní straně tabulky.</p>\n"
-"                            <p>V běžném případě se jídelníček plánuje hromadně, proto můžete v nastavení definovat\n"
-"                                se kterými uživateli si přejete jídelníčky sdílet.\n"
+"                            <p>Modul jídelníčku umožňuje plánovat jídlo "
+"pomocí receptů i poznámek.</p>\n"
+"                            <p>Jednoduše vyberte recept ze seznamu naposledy "
+"navštívených receptů, nebo ho vyhledejte\n"
+"                                s přetáhněte na požadovaný den v rozvrhu. "
+"Můžete také přidat poznámku s popiskem\n"
+"                                a poté přetáhnout recept pro vytvoření plánu "
+"s vlatními popisky. Vytvořením samotné poznámky\n"
+"                                je možné přetažením pole poznámky do "
+"rozvrhu.</p>\n"
+"                            <p>Kliknutím na recept zobrazíte detailní "
+"náhled. Odtud lze také přidat položky\n"
+"                                do nákupního seznamu. Do nákupního seznamu "
+"můžete také přidat všechny recepty na daný den\n"
+"                                kliknutím na ikonu nákupního košíku na horní "
+"straně tabulky.</p>\n"
+"                            <p>V běžném případě se jídelníček plánuje "
+"hromadně, proto můžete v nastavení definovat\n"
+"                                se kterými uživateli si přejete jídelníčky "
+"sdílet.\n"
 "                            </p>\n"
-"                            <p>Můžete také upravovat typy jídel, které si přejete naplánovat. Pokud budete sdílet jídelníček \n"
+"                            <p>Můžete také upravovat typy jídel, které si "
+"přejete naplánovat. Pokud budete sdílet jídelníček \n"
 "                                s někým, kdo\n"
-"                                má přidána jiná jídla, jeho typy jídel se objeví i ve vašem seznamu. Pro předcházení\n"
+"                                má přidána jiná jídla, jeho typy jídel se "
+"objeví i ve vašem seznamu. Pro předcházení\n"
 "                                duplicitám (např. Ostatní, Jiná)\n"
-"                                pojmenujte váš typ jídla stejně, jako uživatel se kterým své seznamy sdílíte. Tím budou seznamy sloučeny.</p>\n"
+"                                pojmenujte váš typ jídla stejně, jako "
+"uživatel se kterým své seznamy sdílíte. Tím budou seznamy\n"
+"                                sloučeny.</p>\n"
 "                        "
 
 #: .\cookbook\templates\meal_plan_entry.html:6
@@ -1331,12 +1347,12 @@ msgstr "Obrázek receptu"
 #: .\cookbook\templates\recipes_table.html:46
 #: .\cookbook\templates\url_import.html:55
 msgid "Preparation time ca."
-msgstr "Doba přípravy cca"
+msgstr "Doba přípravy cca."
 
 #: .\cookbook\templates\recipes_table.html:52
 #: .\cookbook\templates\url_import.html:60
 msgid "Waiting time ca."
-msgstr "Doba čekání cca"
+msgstr "Doba čekání cca."
 
 #: .\cookbook\templates\recipes_table.html:55
 msgid "External"
@@ -1384,7 +1400,7 @@ msgid ""
 " in the following examples:"
 msgstr ""
 "Použijte tajný klíč jako autorizační hlavičku definovanou slovním klíčem, "
-"jak je uvedeno v následujících příkladech."
+"jak je uvedeno v následujících příkladech:"
 
 #: .\cookbook\templates\settings.html:94
 msgid "or"
@@ -1806,7 +1822,7 @@ msgstr "Import není pro tohoto poskytovatele implementován!"
 
 #: .\cookbook\views\import_export.py:58
 msgid "Exporting is not implemented for this provider"
-msgstr "Eport není pro tohoto poskytovatele implementován!"
+msgstr "Export není pro tohoto poskytovatele implementován!"
 
 #: .\cookbook\views\lists.py:42
 msgid "Import Log"
@@ -1838,7 +1854,7 @@ msgstr "Komentář uložen!"
 
 #: .\cookbook\views\views.py:152
 msgid "This recipe is already linked to the book!"
-msgstr "Tento recept už v kuchařce existuje."
+msgstr "Tento recept už v kuchařce existuje!"
 
 #: .\cookbook\views\views.py:158
 msgid "Bookmark saved!"

cookbook/locale/da/LC_MESSAGES/django.po

@@ -8,8 +8,8 @@ msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2022-04-29 18:42+0200\n"
-"PO-Revision-Date: 2022-08-18 14:32+0000\n"
-"Last-Translator: Mathias Rasmussen <math625f@gmail.com>\n"
+"PO-Revision-Date: 2023-04-12 11:55+0000\n"
+"Last-Translator: noxonad <noxonad@proton.me>\n"
 "Language-Team: Danish <http://translate.tandoor.dev/projects/tandoor/"
 "recipes-backend/da/>\n"
 "Language: da\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.10.1\n"
+"X-Generator: Weblate 4.15\n"
 
 #: .\cookbook\filters.py:23 .\cookbook\templates\forms\ingredients.html:34
 #: .\cookbook\templates\space.html:49 .\cookbook\templates\stats.html:28
@@ -1806,7 +1806,7 @@ msgid ""
 msgstr ""
 " \n"
 "            Heltekstsøgning forsøger at normalisere de givne ord så de "
-"matcher stammevarianter. F.eks: 'skeen', 'skeer' og 'sket' vil alt "
+"matcher stammevarianter.  F.eks: 'skeen', 'skeer' og 'sket' vil alt "
 "normaliseres til 'ske'.\n"
 "        Der er flere metoder tilgængelige, beskrevet herunder, som vil "
 "bestemme hvordan søgningen skal opfører sig når flere søgeord er angivet.\n"
@@ -2122,9 +2122,9 @@ msgid ""
 "return more results than needed to make sure you find what you are looking "
 "for."
 msgstr ""
-"Find hvad du har brug for selvom opskriften har stavefejl. Kan måske "
-"returnere flere resultater end du har brug for, for at være sikker på at du "
-"finder hvad du leder efter."
+"Find hvad du har brug for, selvom opskriften har stavefejl. Kan måske "
+"returnere flere resultater end du har brug for, for at være sikker på, at du "
+"finder, hvad du leder efter."
 
 #: .\cookbook\templates\settings.html:182
 msgid "This is the default behavior"
@@ -2196,8 +2196,7 @@ msgid ""
 "You can sign in to your account using any of the following third party\n"
 "            accounts:"
 msgstr ""
-"Du kan logge ind på din konto med enhver af de følgende tredjepartsapps\n"
-"        kontoer:"
+"Du kan logge ind på din konto med enhver af de følgende tredjepartskontoer:"
 
 #: .\cookbook\templates\socialaccount\connections.html:52
 msgid ""
@@ -2212,7 +2211,7 @@ msgstr "Tilføj en tredjepartskonto"
 
 #: .\cookbook\templates\socialaccount\signup.html:5
 msgid "Signup"
-msgstr "Registrering"
+msgstr "Registrer"
 
 #: .\cookbook\templates\socialaccount\signup.html:10
 #, python-format

cookbook/locale/hy/LC_MESSAGES/django.po

@@ -11,8 +11,8 @@ msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2021-02-09 18:01+0100\n"
-"PO-Revision-Date: 2021-10-13 12:50+0000\n"
-"Last-Translator: Hrachya Kocharyan <hkocharyan@ctemplar.com>\n"
+"PO-Revision-Date: 2023-01-08 17:55+0000\n"
+"Last-Translator: Joachim Weber <joachim.weber@gmx.de>\n"
 "Language-Team: Armenian <http://translate.tandoor.dev/projects/tandoor/"
 "recipes-backend/hy/>\n"
 "Language: hy\n"
@@ -20,7 +20,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.15\n"
 
 #: .\cookbook\filters.py:22 .\cookbook\templates\base.html:87
 #: .\cookbook\templates\forms\edit_internal_recipe.html:219
@@ -410,7 +410,7 @@ msgstr "Դուրս գալ"
 
 #: .\cookbook\templates\account\logout.html:11
 msgid "Are you sure you want to sign out?"
-msgstr "Համոզվա՞ծ եք, որ ցանկանում եք դուրս գալ:"
+msgstr "Համոզվա՞ծ եք, որ ցանկանում եք դուրս գալ՞"
 
 #: .\cookbook\templates\account\password_reset.html:5
 #: .\cookbook\templates\account\password_reset_done.html:5

cookbook/locale/pt_BR/LC_MESSAGES/django.po

@@ -8,8 +8,8 @@ msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2022-02-11 08:52+0100\n"
-"PO-Revision-Date: 2022-03-08 01:31+0000\n"
-"Last-Translator: Felipe Castro <felipefcastro@gmail.com>\n"
+"PO-Revision-Date: 2023-04-12 11:55+0000\n"
+"Last-Translator: noxonad <noxonad@proton.me>\n"
 "Language-Team: Portuguese (Brazil) <http://translate.tandoor.dev/projects/"
 "tandoor/recipes-backend/pt_BR/>\n"
 "Language: pt_BR\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.10.1\n"
+"X-Generator: Weblate 4.15\n"
 
 #: .\cookbook\filters.py:23 .\cookbook\templates\forms\ingredients.html:34
 #: .\cookbook\templates\space.html:50 .\cookbook\templates\stats.html:28
@@ -158,7 +158,7 @@ msgstr ""
 #: .\cookbook\templates\url_import.html:195
 #: .\cookbook\templates\url_import.html:585 .\cookbook\views\lists.py:97
 msgid "Keywords"
-msgstr ""
+msgstr "Palavras-chave"
 
 #: .\cookbook\forms.py:131
 msgid "Preparation time in minutes"
@@ -513,7 +513,7 @@ msgstr ""
 #: .\cookbook\templates\url_import.html:231
 #: .\cookbook\templates\url_import.html:462
 msgid "Servings"
-msgstr ""
+msgstr "Porções"
 
 #: .\cookbook\integration\saffron.py:25
 msgid "Waiting time"
@@ -585,7 +585,7 @@ msgstr ""
 
 #: .\cookbook\models.py:302 .\cookbook\templates\base.html:90
 msgid "Books"
-msgstr ""
+msgstr "Livros"
 
 #: .\cookbook\models.py:310
 msgid "Small"
@@ -598,7 +598,7 @@ msgstr ""
 #: .\cookbook\models.py:310 .\cookbook\templates\generic\new_template.html:6
 #: .\cookbook\templates\generic\new_template.html:14
 msgid "New"
-msgstr ""
+msgstr "Novo"
 
 #: .\cookbook\models.py:513
 msgid " is part of a recipe step and cannot be deleted"
@@ -677,7 +677,7 @@ msgstr ""
 #: .\cookbook\templates\shopping_list.html:37
 #: .\cookbook\templates\space.html:109
 msgid "Edit"
-msgstr ""
+msgstr "Editar"
 
 #: .\cookbook\tables.py:115 .\cookbook\tables.py:138
 #: .\cookbook\templates\generic\delete_template.html:7
@@ -715,7 +715,7 @@ msgstr ""
 #: .\cookbook\templates\settings.html:17
 #: .\cookbook\templates\socialaccount\connections.html:10
 msgid "Settings"
-msgstr ""
+msgstr "Configurações"
 
 #: .\cookbook\templates\account\email.html:13
 msgid "Email"
@@ -937,7 +937,7 @@ msgstr ""
 #: .\cookbook\templates\account\signup.html:48
 #: .\cookbook\templates\socialaccount\signup.html:39
 msgid "and"
-msgstr ""
+msgstr "e"
 
 #: .\cookbook\templates\account\signup.html:52
 #: .\cookbook\templates\socialaccount\signup.html:43
@@ -989,7 +989,7 @@ msgstr ""
 #: .\cookbook\templates\shopping_list.html:208
 #: .\cookbook\templates\supermarket.html:7
 msgid "Supermarket"
-msgstr ""
+msgstr "Supermercado"
 
 #: .\cookbook\templates\base.html:163
 msgid "Supermarket Category"
@@ -1027,7 +1027,7 @@ msgstr ""
 #: .\cookbook\templates\shopping_list.html:165
 #: .\cookbook\templates\shopping_list.html:188
 msgid "Create"
-msgstr ""
+msgstr "Criar"
 
 #: .\cookbook\templates\base.html:259
 #: .\cookbook\templates\generic\list_template.html:14
@@ -1190,7 +1190,7 @@ msgstr ""
 
 #: .\cookbook\templates\generic\delete_template.html:26
 msgid "Protected"
-msgstr ""
+msgstr "Protegido"
 
 #: .\cookbook\templates\generic\delete_template.html:41
 msgid "Cascade"
@@ -1268,7 +1268,7 @@ msgstr ""
 
 #: .\cookbook\templates\include\recipe_open_modal.html:18
 msgid "Close"
-msgstr ""
+msgstr "Fechar"
 
 #: .\cookbook\templates\include\recipe_open_modal.html:32
 msgid "Open Recipe"
@@ -1821,7 +1821,7 @@ msgstr ""
 
 #: .\cookbook\templates\settings.html:162
 msgid "or"
-msgstr ""
+msgstr "ou"
 
 #: .\cookbook\templates\settings.html:173
 msgid ""
@@ -2062,7 +2062,7 @@ msgstr ""
 
 #: .\cookbook\templates\space.html:120
 msgid "user"
-msgstr ""
+msgstr "usuário"
 
 #: .\cookbook\templates\space.html:121
 msgid "guest"
@@ -2208,7 +2208,7 @@ msgstr ""
 
 #: .\cookbook\templates\url_import.html:38
 msgid "URL"
-msgstr ""
+msgstr "URL"
 
 #: .\cookbook\templates\url_import.html:40
 msgid "App"
@@ -2273,7 +2273,7 @@ msgstr ""
 
 #: .\cookbook\templates\url_import.html:214
 msgid "Image"
-msgstr ""
+msgstr "Imagem"
 
 #: .\cookbook\templates\url_import.html:246
 msgid "Prep Time"
@@ -2359,7 +2359,7 @@ msgstr ""
 
 #: .\cookbook\templates\url_import.html:640
 msgid "Information"
-msgstr ""
+msgstr "Informação"
 
 #: .\cookbook\templates\url_import.html:642
 msgid ""