Merge pull request 'testing' (#24) from testing into main

Reviewed-on: #24

.gitea/python_build/dockerfile

@@ -1,16 +0,0 @@
-FROM gitea.tryton.geeraert.eu/pi-ux-ce/python:3
-
-ENV PYTHONUNBUFFERED 1
-
-WORKDIR /code/
-
-# Copy only the requirements file first (Changes infrequently)
-COPY requirements.txt ./
-
-
-RUN --mount=type=cache,target=/root/.cache/pip pip install --upgrade pip 
-RUN --mount=type=cache,target=/root/.cache/pip pip list --outdated
-RUN --mount=type=cache,target=/root/.cache/pip pip install --upgrade wheel
-RUN --mount=type=cache,target=/root/.cache/pip pip install --upgrade setuptools
-RUN --mount=type=cache,target=/root/.cache/pip pip install -r requirements.txt
-

.gitea/python_build/requirements.txt

@@ -1,15 +0,0 @@
-django
-psycopg2
-requests
-proxmoxer
-docker
-kubernetes
-ruamel.yaml
-pyyaml
-django-bootstrap-v5
-jinja2
-watchdog
-celery
-redis
-lxml
-requests

.gitea/workflows/dockerfile_runner.yaml

@@ -2,96 +2,46 @@ name: Gitea Actions Demo
 run-name: ${{ gitea.actor }} is testing out Gitea Actions 🚀
 on:
   push:
-  #paths-ignore:
-  #  - 'requirements.txt'
+    branches:
+      - main
+    paths-ignore:
+      - 'infra/production/dockerfile'
   issue_comment:
     types: [created]
+  workflow_dispatch: # Enables the manual run UI button
 
 jobs:
-  # Job to check for file changes and set an output
-  changes:
-    runs-on: ubuntu-latest
-    outputs:
-      requirements_changed: ${{ steps.filter.outputs.requirements }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dorny/paths-filter@v3
-        id: filter
-        with:
-          filters: |
-            requirements:
-              - 'requirements.txt'
-
-  Build-dockerfile:
-    runs-on: ubuntu-latest
-    needs: changes
-    if: ${{ needs.changes.outputs.requirements_changed == 'true' }}
-    steps:
-      - run: echo "🔎 The name of your branch is ${{ gitea.ref }} and your repository is ${{ gitea.repository }}."
-      - name: Check out repository code
-        uses: actions/checkout@v4
-      - run: echo "💡 The ${{ gitea.repository }} repository has been cloned to the runner."
-      - name: List files in the repository
-        run: |
-          ls ${{ gitea.workspace }}
-
-      - name: Compute next version
-        id: versioning
-        run: |
-          latest="${{ vars.PYTHON_VERSION }}"
-          next_version=$(echo "$latest" | awk -F. -v OFS=. '{$NF += 1 ; print}')
-          echo "next_version=$next_version" >> $GITHUB_ENV
-          echo "Variables used :"
-          echo "------------------------------------------------"
-          echo "Next version: $next_version"
-
-      - uses: actions/cache@v3
-        with:
-          path: /root/.cache/pip
-          key: ${{ runner.os }}-pip-${{ hashFiles('requirements.txt') }}
-          restore-keys: |
-            ${{ runner.os }}-pip-
-
-
-      - name: inject cache into docker
-        uses: reproducible-containers/buildkit-cache-dance@v3.1.0
-        with:
-          cache-source: /root/.cache/pip
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Login to gitea
-        uses: docker/login-action@v3
-        with:
-          registry: gitea.tryton.geeraert.eu
-          username: ${{ secrets.USERNAME_GITEA }}
-          password: ${{ secrets.PASSWORD_GITEA }}
-
-      - name: Build and push
-        uses: docker/build-push-action@v6
-        with:
-          context: "{{defaultContext}}:.gitea/python_build"
-          push: true
-          tags: |
-            gitea.tryton.geeraert.eu/pi-ux-ce/modified-python:latest
-            gitea.tryton.geeraert.eu/pi-ux-ce/modified-python:${{ env.next_version }}
-          cache-from: type=registry,ref=gitea.tryton.geeraert.eu/pi-ux-ce/modified-python:buildcache
-          cache-to: type=registry,ref=gitea.tryton.geeraert.eu/pi-ux-ce/modified-python:buildcache,mode=max
-
-      - name: update version in the variable
-        run: |
-          curl  -X PUT -H "Content-Type: application/json" \
-          --user ${{ secrets.USERNAME_GITEA }}:${{ secrets.PASSWORD_GITEA }} \
-          https://gitea.tryton.geeraert.eu/api/v1/repos/pi-ux-ce/${{ github.event.repository.name }}/actions/variables/PYTHON_VERSION \
-          -d "{\"Value\":\"$next_version\"}"
   Explore-Gitea-Actions:
-    runs-on: ubuntu-latest
+    env:
+      RUNNER_TOOL_CACHE: /toolcache
+      DEBUG: True
+      ALLOWED_HOSTS: "django.tryton.geeraert.eu"
+    container:
+      image: gitea.tryton.geeraert.eu/pi-ux-ce/custom-runner-debian-slim:1.0.6
+      volumes:
+        - act-toolcache:/opt/hostedtoolcache # this is where Runner store their cache default
+    runs-on: host-runner
     steps:
+
       - run: echo "🔎 The name of your branch is ${{ gitea.ref }} and your repository is ${{ gitea.repository }}."
+
+      - name: restore git folder if exist
+        run: if [ -d "/opt/hostedtoolcache/${{ github.event.repository.name }}/" ]; then cp -r /opt/hostedtoolcache/${{ github.event.repository.name }}/ ${{ gitea.workspace }}; fi
+
+      - name: Check Docker Version
+        run: whereis docker
+
       - name: Check out repository code
         uses: actions/checkout@v4
+        clean: false
+        fetch-depth: 1
+        ref: 'main'
+
+#      - name: Manually check out repository code
+#        run: cd ${{ gitea.workspace }} ; git pull origin main
+
       - run: echo "💡 The ${{ gitea.repository }} repository has been cloned to the runner."
+
       - name: List files in the repository
         run: |
           ls ${{ gitea.workspace }}
@@ -106,18 +56,19 @@ jobs:
           echo "------------------------------------------------"
           echo "Next version: $next_version"
 
-      - uses: actions/cache@v3
+      - name: Cache Docker layers
+        uses: actions/cache@v4
         with:
-          path: /root/.cache/pip
-          key: ${{ runner.os }}-pip-${{ hashFiles('requirements.txt') }}
+          path: /opt/hostedtoolcache/.buildx-cache
+          key: ${{ runner.os }}-buildx-${{ github.sha }}
           restore-keys: |
-            ${{ runner.os }}-pip-
+            ${{ runner.os }}-buildx-
 
 
       - name: inject cache into docker
         uses: reproducible-containers/buildkit-cache-dance@v3.1.0
         with:
-           cache-source: /root/.cache/pip
+          cache-source: /opt/hostedtoolcache/pip
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
@@ -132,12 +83,21 @@ jobs:
       - name: Build and push
         uses: docker/build-push-action@v6
         with:
+          context: infra/production/
           push: true
+          build-args: |
+            ALLOWED_HOSTS='django.tryton.geeraert.eu'
+            DEBUG='True'
           tags: |
-             gitea.tryton.geeraert.eu/pi-ux-ce/django-python:latest
-             gitea.tryton.geeraert.eu/pi-ux-ce/django-python:${{ env.next_version }}
-          cache-from: type=registry,ref=gitea.tryton.geeraert.eu/pi-ux-ce/django-python:buildcache
-          cache-to: type=registry,ref=gitea.tryton.geeraert.eu/pi-ux-ce/django-python:buildcache,mode=max
+            gitea.tryton.geeraert.eu/pi-ux-ce/django-python:latest
+            gitea.tryton.geeraert.eu/pi-ux-ce/django-python:${{ env.next_version }}
+          cache-from: type=local,src=/opt/hostedtoolcache/.buildx-cache
+          cache-to: type=local,dest=/opt/hostedtoolcache/.buildx-cache-new,mode=max
+
+      - name: Move cache
+        run: |
+          rm -rf /opt/hostedtoolcache/.buildx-cache
+          mv /opt/hostedtoolcache/.buildx-cache-new /opt/hostedtoolcache/.buildx-cache
 
       - name: Rollout Django to force pulling the new image
         uses: actions-hub/kubectl@master
@@ -160,3 +120,6 @@ jobs:
           --user ${{ secrets.USERNAME_GITEA }}:${{ secrets.PASSWORD_GITEA }} \
           https://gitea.tryton.geeraert.eu/api/v1/repos/pi-ux-ce/${{ github.event.repository.name }}/actions/variables/VERSION \
           -d "{\"Value\":\"$next_version\"}"
+
+      - name: backup git for future use
+        run: cp -r ${{ gitea.workspace }} /opt/hostedtoolcache/${{ github.event.repository.name }}/

.gitea/workflows/dockerfile_testing_runner.yaml

@@ -0,0 +1,74 @@
+name: Gitea Actions Demo
+run-name: ${{ gitea.actor }} is testing out Gitea Actions 🚀
+on:
+  push:
+    branches:
+      - "testing"
+    paths:
+      - 'infra/testing/dockerfile'
+    tags-ignore:
+      - '*'
+  workflow_dispatch: # Enables the manual run UI button
+
+
+jobs:
+  Explore-Gitea-Actions:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo "🔎 The name of your branch is ${{ gitea.ref }} and your repository is ${{ gitea.repository }}."
+      - name: Check out repository code
+        uses: actions/checkout@v4
+      - run: echo "💡 The ${{ gitea.repository }} repository has been cloned to the runner."
+      - name: List files in the repository
+        run: |
+          ls ${{ gitea.workspace }}
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Compute next version
+        id: versioning
+        run: |
+          latest="${{ vars.VERSION_TESTING }}"
+          next_version=$(echo "$latest" | awk -F. -v OFS=. '{$NF += 1 ; print}')
+          echo "next_version=$next_version" >> $GITHUB_ENV
+          echo "Variables used :"
+          echo "------------------------------------------------"
+          echo "Next version: $next_version"
+
+
+      - name: Login to gitea
+        uses: docker/login-action@v3
+        with:
+          registry: gitea.tryton.geeraert.eu
+          username: ${{ secrets.USERNAME_GITEA }}
+          password: ${{ secrets.PASSWORD_GITEA }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          context: infra/testing/
+          push: true
+          build-args: |
+            ALLOWED_HOSTS='django-testing.tryton.geeraert.eu'
+            DEBUG='True'
+          tags: |
+            gitea.tryton.geeraert.eu/pi-ux-ce/django-testing:latest
+            gitea.tryton.geeraert.eu/pi-ux-ce/django-testing:${{ env.next_version }}
+          cache-from: type=registry,ref=gitea.tryton.geeraert.eu/pi-ux-ce/django-testing:buildcache
+          cache-to: type=registry,ref=gitea.tryton.geeraert.eu/pi-ux-ce/django-testing:buildcache,mode=max
+
+      - name: update version in the variable
+        run: |
+          curl  -X PUT -H "Content-Type: application/json" \
+          --user ${{ secrets.USERNAME_GITEA }}:${{ secrets.PASSWORD_GITEA }} \
+          https://gitea.tryton.geeraert.eu/api/v1/repos/pi-ux-ce/${{ github.event.repository.name }}/actions/variables/VERSION_TESTING \
+          -d "{\"Value\":\"$next_version\"}"
+
+      - name: Rollout Django to force pulling the new image
+        uses: actions-hub/kubectl@master
+        env:
+          KUBE_CONFIG: ${{ secrets.KUBE_CONFIG }}
+        with:
+          args: rollout restart deployment django-testing -n django-testing
+
+      - run: echo "🍏 This job's status is ${{ job.status }}."

.gitea/workflows/kubectl_testing_runner.yaml

@@ -0,0 +1,23 @@
+name: Gitea Actions Demo
+run-name: ${{ gitea.actor }} is testing out Gitea Actions 🚀
+on:
+  push:
+    branches:
+      - "testing"
+    tags-ignore:
+      - '*'
+
+jobs:
+  Explore-Gitea-Actions:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo "🔎 The name of your branch is ${{ gitea.ref }} and your repository is ${{ gitea.repository }}."
+
+      - name: Rollout Django to force pulling the new image
+        uses: actions-hub/kubectl@master
+        env:
+          KUBE_CONFIG: ${{ secrets.KUBE_CONFIG }}
+        with:
+          args: rollout restart deployment django-testing -n django-testing
+
+      - run: echo "🍏 This job's status is ${{ job.status }}."

.gitignore

@@ -1,6 +1,229 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+*.lcov
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi/*
+!.pixi/config.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule*
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
 */__pycache__/*
-*/.idea
-venv/*
-*__pycache__*
+*/.idea/*
+*/venv/*
+*/.env/*
 Webcal-python/*
 .idea/*
+django_code/db.sqlite3 
+

Django_webserver.kube.yaml

@@ -1,67 +0,0 @@
-apiVersion: v1
-kind: Namespace
-metadata:
-  name: django-python
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: django-webserver
-  namespace: django-python
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: django-python
-  template:
-    metadata:
-      labels:
-        app: django-python
-    spec:
-      containers:
-      - name: django-python
-        image: gitea.tryton.geeraert.eu/pi-ux-ce/django-python:latest
-        imagePullPolicy: Always
-        ports:
-        - containerPort: 8000
-          name: webserver-port
-        volumeMounts:
-##        - name: django-python-code
-#          mountPath: /code
-        - name: servarr-data
-          mountPath: /data
-          readOnly: true
-        - name: secret-kubeconfig
-          mountPath: /kubeconfig
-
-
-        resources:
-            limits:
-              cpu: 100m
-              memory: 200Mi
-      volumes:
-      - name: django-python-code
-        persistentVolumeClaim:
-          claimName: django-python-code
-      - name: servarr-data
-        hostPath:
-           path: /data
-      - name: secret-kubeconfig
-        secret:
-          defaultMode: 420
-          secretName: kubeconfig
-
-
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: webserver
-  namespace: django-python
-spec:
-  ports:
-    - name: http
-      port: 8000
-      protocol: TCP
-  selector:
-    app: django-python

README.md

@@ -1,13 +1,65 @@
 =======
 # Django_kube
-test
-
-
 ## Getting started
+### Database migration
+
+```
+python django_code/manage.py makemigrations
+python django_code/manage.py makemigrations redirect
+python django_code/manage.py makemigrations cloudmanager 
+python django_code/manage.py makemigrations simpsons
+python django_code/manage.py makemigrations job
+python django_code/manage.py makemigrations telegram
+python django_code/manage.py makemigrations podcast
+
+python django_code/manage.py migrate
+python django_code/manage.py migrate --database=cloudmanager_db
+python django_code/manage.py migrate --database=simpsons_db 
+python django_code/manage.py migrate --database=redirect_db
+python django_code/manage.py migrate --database=job_db
+python django_code/manage.py migrate --database=telegram_db
+python django_code/manage.py migrate --database=podcast_db
+```
+### Database debug
+
+```
+create database django;
+create database redirect;
+create database cloudmanager;
+create database simpsons;
+create database job;
+create database telegram;
+create database podcast;
+
+
+
+drop database redirect;
+drop database cloudmanager;
+drop database simpsons;
+drop database job;
+drop database telegram;
+drop database podcast;
+```
+
+
+### Setup virtualenv variables
+edit venv/bin/activate or .env/bin/activate
+
+and add the following code
+```
+export DB_HOST=localhost
+export DB_PORT=5432
+export DB_USERNAME=postgres
+export DB_PASSWORD=example
+export DB_DATABASE=cloudmanager
+export CUSTOM_DB_DATABASE=cloudmanager
+export ALLOWED_HOSTS="0.0.0.0,localhost,127.0.0.1"
+export DEBUG=true
+export bitwarden_access_token="PROVIDED IN BITWARDEN ADMIN INTERFACE"
+export bitwarden_organization_id=""
+```
 
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
 
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
 
 ## Add your files
 

django_code/apps/betaserie/utils.py

@@ -0,0 +1,125 @@
+import requests
+import hashlib
+from apps.bitwarden.utils import bitwardenUtils
+import os
+
+class betaserieUtils():
+    url = "https://api.betaseries.com/members/auth"
+
+    username_UID="7bc7ebd2-9c95-487f-9ba2-b47301591ef0"
+    password_UID="262c3246-203b-44e0-854b-b47301599730"
+    token_UID="2cf4be0f-f26f-473f-b8f1-b473016139e4"
+    
+    #Adding __ to make the variable private and can't be access outside the class, 
+    # only by the class itself ot the subclass
+    
+    __bitwarden_access_token = os.environ.get('bitwarden_access_token')
+    __bitwarden_organization_id = os.environ.get('bitwarden_organization_id')
+    
+    bw = bitwardenUtils(__bitwarden_access_token,__bitwarden_organization_id)
+
+    __betaserie_username = bw.read_value_secret(username_UID)
+    __betaserie_md5_password = bw.read_value_secret(password_UID)
+    __betaserie_apikey = bw.read_value_secret(token_UID)
+   
+    payload = {
+        'login': __betaserie_username,       # username or email
+        'password': __betaserie_md5_password      # MD5 hashed password
+    }
+
+    headers = {
+        'X-BetaSeries-Key': __betaserie_apikey,
+    }
+    response = requests.post(url, headers=headers, data=payload)
+    
+    #now set with the correct value
+    __betaserie_token = response.json()['token']
+    
+    #set the __betaserie_token to the doct headers now
+    headers.update({'X-BetaSeries-Token': __betaserie_token})    
+    
+    def status_code(self):
+        print("Status code:", self.response.status_code)
+        print("Response:", self.response.json())
+
+
+    def identify_serie(self,serie_name,verbose=False):
+        #
+        #   Usage
+        #   show_id = beta.identify_serie("The simpsons")
+        #   show_id = beta.identify_serie("The simpsons",verbose=True)
+        #
+        url = "https://api.betaseries.com/shows/search?title="+serie_name
+        
+        response = requests.request("GET", url, headers=self.headers, data=self.payload)
+        if verbose:
+            print("Url request: "+str(url))
+            print(response.text)
+
+        show_id = response.json()['shows'][0]['id']
+
+        return show_id
+    
+    def identify_episode(self,show_id,episode_number,verbose=False):
+        #
+        #   Usage
+        #   episode_id = beta.identify_episode(show_id,"S01E01",True)
+        #
+        url = "https://api.betaseries.com/episodes/search?show_id="+str(show_id)+"&number="+str(episode_number)
+        
+        response = requests.request("GET", url, headers=self.headers, data=self.payload)
+
+        episode_id = response.json()['episode']['id']
+        if verbose:
+            print("Url request: "+str(url))
+            print(response.text)
+
+        return episode_id
+
+    def mark_episodes_watched(self,episode_id,verbose=False):
+        #
+        #   Usage
+        #   response = beta.mark_episodes_watched(episode_id,True)
+        #
+        url = "https://api.betaseries.com/episodes/watched?id="+str(episode_id)+"&bulk=false"
+        
+        response = requests.request("POST", url, headers=self.headers, data=self.payload)
+        if verbose:
+            print("Url request: "+str(url))
+            print(response.text)
+
+        return response.status_code
+    
+    def unmark_episodes_watched(self,episode_id,verbose=False):
+        #
+        #   Usage
+        #   response = beta.unmark_episodes_watched(episode_id,True)        
+        # 
+        url = "https://api.betaseries.com/episodes/watched?id="+str(episode_id)
+        
+        response = requests.request("DELETE", url, headers=self.headers, data=self.payload)
+
+        if verbose:
+            print("Url request: "+str(url))
+            print(response.text)
+
+        return response.status_code
+
+    def series_information(self,show_id,verbose=False):
+        #
+        #   Usage
+        #
+        url = "https://api.betaseries.com/shows/display?id="+str(show_id)
+        response = requests.request("GET", url, headers=self.headers, data=self.payload)
+        
+        maximum_number_seasons = response.json()['show']['seasons']
+        if verbose : print("maximum_number_seasons: "+str(maximum_number_seasons))
+        
+        seasons_details = response.json()['show']['seasons_details']
+        
+        if verbose:
+            print("Url request: "+str(url))
+            print(response.text)
+
+        return seasons_details,maximum_number_seasons
+        

django_code/apps/bitwarden/utils.py

@@ -0,0 +1,87 @@
+import logging
+import os
+from datetime import datetime, timezone
+
+from bitwarden_sdk import BitwardenClient, DeviceType, client_settings_from_dict
+
+
+class bitwardenUtils():
+    #documentation
+    #https://github.com/external-secrets/bitwarden-sdk-server
+    state_path = "/tmp/state_file.txt"
+    client = BitwardenClient(
+        client_settings_from_dict(
+            {
+                "apiUrl": os.getenv("API_URL", "https://bitwarden.tryton.geeraert.eu/api"),
+                "deviceType": DeviceType.SDK,
+                "identityUrl": os.getenv("IDENTITY_URL", "https://bitwarden.tryton.geeraert.eu/identity"),
+                "userAgent": "Python",
+            }
+        )
+    )
+    
+    def verbose(self):
+        logging.basicConfig(level=logging.DEBUG)
+
+
+    def __init__(self, __access_token, __organization_id):
+        self.__access_token = __access_token
+        self.__organization_id = __organization_id
+        self.client.auth().login_access_token(self.__access_token, self.state_path)
+        
+    def create_project(self,project_name):
+        project = self.client.projects().create(self.__organization_id, project_name)
+        return project.data.id
+
+    def generate_strong_password(self):
+        # Note: using the generator does not require authentication with a server
+        return self.client.generators().generate()  # using default params
+
+    def create_secret(self,project_id,secret_name,secret_value,description="description"):
+        secret = self.client.secrets().create(
+            self.__organization_id,
+            secret_name,
+            secret_value,
+            description,
+            [project_id],
+        )
+        return secret.data.id
+
+    
+    def read_value_secret(self,secret_id):
+        return self.client.secrets().get_by_ids([secret_id]).data.data[0].value
+    
+    def read_value_secrets(self,list_secret_id):
+        if not(isinstance(list_secret_id, list)):
+            print("this is not a list")
+            return 1
+        list_secret_value = []
+        for secret_value in self.client.secrets().get_by_ids(list_secret_id).data.data:
+            list_secret_value.append(secret_value.value)
+        return list_secret_value
+    
+    def delete_secrets(self,list_secret_id):
+        if not(isinstance(list_secret_id, list)):
+            print("this is not a list")
+            return 1    
+        try:
+            self.client.secrets().delete(list_secret_id)
+            status=0
+        except:
+            print("Cannot delete the secrets")
+            status=1
+        return status
+    
+    def delete_projects(self,list_project_id):
+        if not(isinstance(list_project_id, list)):
+            print("this is not a list")
+            return 1
+        try:
+            self.client.projects().delete(list_project_id)
+            status=0
+        except:
+            print("Cannot delete the project")
+            status=1
+        return status
+
+

django_code/apps/cloudmanager/admin.py

@@ -0,0 +1,112 @@
+from django.contrib import admin,messages
+from django.utils.translation import ngettext
+from .models import Deployment_Data,Schedule_Day_Data,Schedule_Week_Data,Namespace_Data,namespace_cmm_data_object
+from .utils import import_namespace
+from apps.kubernetes_connection.utils import scale_up,scale_down
+
+DB = 'cloudmanager_db'
+
+
+@admin.action(description="scale up")
+def scale_up_deploy(modeladmin, request, queryset):
+    for query in queryset.values():
+        scale_up(namespace_name=query['namespace'],deploy_name=query['name'],replicas=query['replicas'])
+    modeladmin.message_user(
+        request,
+        ngettext(
+            "%d server was successfully scaled up.",
+            "%d servers were successfully scaled up.",
+            queryset.values().count(),
+        )
+        % queryset.values().count(),
+        messages.SUCCESS,
+        )
+
+
+@admin.action(description="scale down")
+def scale_down_deploy(modeladmin, request, queryset):
+    for query in queryset.values():
+        scale_down(namespace_name=query['namespace'],deploy_name=query['name'])
+    modeladmin.message_user(
+        request,
+        ngettext(
+            "%d server was successfully scaled down.",
+            "%d servers were successfully scaled down.",
+            queryset.values().count(),
+        )
+        % queryset.values().count(),
+        messages.SUCCESS,
+        )
+
+@admin.action(description="create_entry")
+def create_entry(modeladmin, request, queryset):
+    print("simpsons_data_object.create(season=2, episode=3, url='google.com'', seen=True)")
+    #call function to trigger refresh of all deploy
+
+@admin.action(description="import namespace")
+def import_namespace_admin(modeladmin, request, queryset):
+    #
+    #
+    #
+    #       don't forgot to clear thge quyeryset before running this
+    #
+    import_namespace(namespace_cmm_data_object)
+    print("simpsons_data_object.create(season=2, episode=3, url='google.com'', seen=True)")
+    #call function to trigger refresh of all deploy
+
+
+class ActiveAtHourFilter(admin.SimpleListFilter):
+    title = 'Active at hour'
+    parameter_name = 'active_at_hour'
+
+    def lookups(self, request, model_admin):
+        return [(str(h), f'{h:02d}:00') for h in range(24)]
+
+    def queryset(self, request, queryset):
+        if self.value() is not None:
+            hour = self.value()
+            return queryset.filter(**{f'schedule_day__state_at_{hour}': True})
+        return queryset
+
+
+class MultiDBModelAdmin(admin.ModelAdmin):
+    """Base class that pins all admin operations to DB."""
+    db = DB
+
+    def get_queryset(self, request):
+        return super().get_queryset(request).using(self.db)
+
+    def save_model(self, request, obj, form, change):
+        obj.save(using=self.db)
+
+    def delete_model(self, request, obj):
+        obj.delete(using=self.db)
+
+    def delete_queryset(self, request, queryset):
+        queryset.using(self.db).delete()
+
+
+@admin.register(Deployment_Data)
+class DeploymentDataAdmin(MultiDBModelAdmin):
+    list_display = ('name', 'namespace', 'schedule_week', 'schedule_day', 'replicas')
+    list_filter = (ActiveAtHourFilter,)
+    actions = [scale_up_deploy,scale_down_deploy]
+
+
+@admin.register(Schedule_Day_Data)
+class ScheduleDayAdmin(MultiDBModelAdmin):
+    list_display = ['name_schedule'] + [f'state_at_{h}' for h in range(24)]
+
+
+@admin.register(Schedule_Week_Data)
+class ScheduleWeekAdmin(MultiDBModelAdmin):
+    list_display = (
+        'name_schedule',
+        'state_Monday', 'state_Tuesday', 'state_Wednesday',
+        'state_Thursday', 'state_Friday', 'state_Saturday', 'state_Sunday',
+    )
+
+@admin.register(Namespace_Data)
+class NamespaceAdmin(MultiDBModelAdmin):
+    list_display = ('namespace',)
+    actions = [import_namespace_admin]

django_code/apps/cloudmanager/apps.py

@@ -0,0 +1,37 @@
+from django.apps import AppConfig
+from django.http import HttpResponse
+from django.http import HttpResponseRedirect
+from django.shortcuts import render
+import os
+import psycopg2
+from apps.cloudmanager.db_interaction import DB_generation,Check_server_supposed_XXX,Give_current_weekday,Give_current_hour
+
+
+class CloudmanagerConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.cloudmanager'
+    label = 'cloudmanager'
+
+def coucou(request):
+    return HttpResponse('<h1>Hello cmm!</h1>')
+
+def hello(request):
+    list_schedule = ['schedule1','schedule2']
+    list_servers_up = [['wiki', 'wikijs', 2], ['book', 'bookstack-db', 1]]
+    return render(request, 'cloudmanager/index.html', {'list_schedule':list_schedule,'list_servers_up':list_servers_up})
+
+def redirect(request):
+    db_host = os.environ.get('DB_HOST')
+    db_port = os.environ.get('DB_PORT')
+    db_user = os.environ.get('DB_USERNAME')
+    db_password = os.environ.get('DB_PASSWORD')
+    db_name = os.environ.get('CUSTOM_DB_DATABASE',os.environ.get('DB_DATABASE'))
+
+    generated_db = DB_generation(db_host, db_port, db_user, db_password,db_name)
+    ##operation:
+    ## Server(s) supposed to be UP
+
+    list_servers_up = Check_server_supposed_XXX(generated_db, "up", Give_current_hour(),Give_current_weekday())
+    print(list_servers_up)
+    return render(request, 'cloudmanager/cmm_blank_page.html', {'list_servers_up':list_servers_up})
+

django_code/apps/cloudmanager/credentials.py

@@ -0,0 +1,7 @@
+
+class sql:
+    url = 'localhost'
+    port = 5432
+    user = 'postgres'
+    password = 'example'
+    database = 'cloudmanager'

django_code/apps/cloudmanager/db_interaction.py

@@ -0,0 +1,167 @@
+import psycopg2
+from django.http import HttpResponse
+from django.views.decorators.http import require_POST
+from apps.kubernetes_connection import apps as kubernetes_connection
+import datetime
+from apps.cloudmanager import credentials
+import os
+
+def hello(request):
+    kubernetes_connection.echoHello();
+    return HttpResponse('<h1>Hello cmm !</h1>')
+
+def DB_generation(host_in,port_in,user_in,password_in,db_in):
+    db = psycopg2.connect(host=host_in, port=port_in, user=user_in, password=password_in,database=db_in)
+    return db
+
+@require_POST
+def change_schedule(request):
+    # HTMX sends these via standard POST data
+    schedule_id = request.POST.get('schedule_id')
+    server_name = request.POST.get('server_name')
+
+    if not schedule_id or not server_name:
+        return HttpResponse("<span style='color: red;'>Missing parameters.</span>", status=400)
+
+    try:
+        # --- Your Core Logic Here ---
+        # e.g., Server.objects.filter(name=server_name).update(schedule_id=schedule_id)
+        print(f"Updating {server_name} to schedule profile {schedule_id}")
+
+        # Return a success message that will instantly inject into the server's status div
+        return HttpResponse("<span style='color: green;'>✓ Updated successfully!</span>")
+
+    except Exception as e:
+        return HttpResponse(f"<span style='color: red;'>Error: {str(e)}</span>", status=500)
+
+def Launch_sql_query(sql,db):
+    # prepare a cursor object using cursor() method
+    cursor = db.cursor()
+
+    try:
+        # Execute the SQL command
+        cursor.execute(sql)
+        # Fetch all the rows in a list of lists.
+        results = cursor.fetchall()
+        result_machine = []
+        #result_machine_type = []
+        for row in results:
+            result_machine_type = []
+            namespace = row[0]
+            name = row[1]
+            replicas = row[2]
+
+            result_machine_type.append(namespace)
+            result_machine_type.append(name)
+            result_machine_type.append(replicas)
+            result_machine.append(result_machine_type)
+        return result_machine
+
+    except:
+        print ("Error: unable to fetch data")
+
+
+#Return the day of the week as an integer, where Monday is 0 and Sunday is 6.
+def Give_current_weekday():
+    days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday','Saturday', 'Sunday']
+    weekday = days[datetime.datetime.today().weekday()]
+    return weekday
+
+def Give_current_hour():
+    now = datetime.datetime.now()
+    return now.hour
+
+
+def Check_server_supposed_XXX(generated_db_in,wanted_status,Wanted_hour,Wanted_day):
+    sql_in=""
+    if wanted_status == "up":
+        sql_in = "select machine.namespace, machine.name, machine.replicas from scenario_hour,machine ,scenario_day_of_week where state_at_" + str(Wanted_hour) + "='1' and state_" + str(Wanted_day) + "='1' and machine.hour_behaviour_id=scenario_hour.id_scenario and machine.day_behaviour_id=scenario_day_of_week.id_scenario;"
+    elif wanted_status == "down":
+        sql_in = "select machine.namespace, machine.name, machine.replicas from scenario_hour,machine ,scenario_day_of_week where not(state_at_" + str(Wanted_hour) + "='1' and state_" + str(Wanted_day) + "='1') and machine.hour_behaviour_id=scenario_hour.id_scenario and machine.day_behaviour_id=scenario_day_of_week.id_scenario;"
+    else:
+        print("error value")
+    print(sql_in)
+    return_value = Launch_sql_query(sql_in, generated_db_in)
+    return return_value
+
+def Is_the_server_already_wanted_state(id_machine, wanted_state,instance_type):
+    #stopped/running
+    bool_result = ""
+    proxmox = function.proxmox_connection(credentials.proxmox.zeus.url_proxmox,credentials.proxmox.zeus.user,credentials.proxmox.zeus.password)
+    if str(function.check_state_mix(id_machine,wanted_state,proxmox,instance_type)) == str(wanted_state):
+        bool_result = True
+    else:
+        bool_result = False
+    return bool_result
+
+def all_operations(request,wanted_state,list_machine):
+    for machine_target in list_machine:
+        print(machine_target[1])
+
+        info_to_display = ""
+        if wanted_state == "up":
+            kubernetes_connection.scale_up(request,namespace_name=machine_target[0],deploy_name=machine_target[1],replicas=machine_target[2]);
+        elif wanted_state == "down":
+            kubernetes_connection.scale_down(request,namespace_name=machine_target[0],deploy_name=machine_target[1]);
+        else:
+            print("Incorrect wanted state")
+
+
+        
+        # if not(Is_the_server_already_wanted_state(machine_target[0], wanted_state,machine_target[1])):
+        #     function.action(False,machine_target[0],operation_to_perform,machine_target[1])
+        #     print(str(machine_target[0])+" is now "+str(wanted_state))
+        # elif Is_the_server_already_wanted_state(machine_target[0], wanted_state,machine_target[1]):
+        #     info_to_display = "operation already performed for "+machine_target[2]
+        #     print(info_to_display)
+    #return info_to_display
+    return ""
+
+def main(request):
+    
+    #get credentials from the env
+    db_host = os.environ.get('DB_HOST')
+    db_port = os.environ.get('DB_PORT')
+    db_user = os.environ.get('DB_USERNAME')
+    db_password = os.environ.get('DB_PASSWORD')
+    db_name = os.environ.get('CUSTOM_DB_DATABASE',os.environ.get('DB_DATABASE'))
+
+    generated_db = DB_generation(db_host, db_port, db_user, db_password,db_name)
+    ##operation:
+    ## Server(s) supposed to be UP
+
+    list_servers_up = Check_server_supposed_XXX(generated_db, "up", Give_current_hour(),Give_current_weekday())
+    print("------------------------------------------")
+    print("-----------------UP-----------------------")
+    print("------------------------------------------")
+    print(list_servers_up)
+    print(all_operations(request,"up", list_servers_up))
+
+
+    ## Server(s) supposed to be DOWN
+    list_servers_down = Check_server_supposed_XXX(generated_db, "down", Give_current_hour(),Give_current_weekday())
+    
+    print("------------------------------------------")
+    print("----------------DOWN----------------------")
+    print("------------------------------------------")
+    print(list_servers_down)
+    print(all_operations(request,"down",list_servers_down))
+     
+     
+    # disconnect from server
+    generated_db.close()
+
+    #print(Is_the_server_already_wanted_state(112, "stopped"))
+    return HttpResponse('<h1>CMM executed!</h1>')
+    
+if __name__ == "__main__":
+    main()
+
+
+"""
+TO DO:
+ EXTRACT TYPE OF MACHINE
+ CREATE FUNCTION TO CHECK IF A MACHINE IS ALREADY DOWN OR NOT
+ ADD FIELD IN SQL WITH PROJECT AND PUT DESCRIPTION -> ATTACH MACHINE TO PROJECT
+
+"""

django_code/apps/cloudmanager/migrations/0001_initial.py

@@ -0,0 +1,90 @@
+# Generated by Django 4.2.29 on 2026-06-22 20:21
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Namespace_Data',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('namespace', models.CharField(max_length=100)),
+            ],
+            options={
+                'db_table': 'namespace',
+            },
+        ),
+        migrations.CreateModel(
+            name='Schedule_Day_Data',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name_schedule', models.CharField(max_length=100, unique=True)),
+                ('state_at_0', models.BooleanField()),
+                ('state_at_1', models.BooleanField()),
+                ('state_at_2', models.BooleanField()),
+                ('state_at_3', models.BooleanField()),
+                ('state_at_4', models.BooleanField()),
+                ('state_at_5', models.BooleanField()),
+                ('state_at_6', models.BooleanField()),
+                ('state_at_7', models.BooleanField()),
+                ('state_at_8', models.BooleanField()),
+                ('state_at_9', models.BooleanField()),
+                ('state_at_10', models.BooleanField()),
+                ('state_at_11', models.BooleanField()),
+                ('state_at_12', models.BooleanField()),
+                ('state_at_13', models.BooleanField()),
+                ('state_at_14', models.BooleanField()),
+                ('state_at_15', models.BooleanField()),
+                ('state_at_16', models.BooleanField()),
+                ('state_at_17', models.BooleanField()),
+                ('state_at_18', models.BooleanField()),
+                ('state_at_19', models.BooleanField()),
+                ('state_at_20', models.BooleanField()),
+                ('state_at_21', models.BooleanField()),
+                ('state_at_22', models.BooleanField()),
+                ('state_at_23', models.BooleanField()),
+            ],
+            options={
+                'db_table': 'schedule_day',
+            },
+        ),
+        migrations.CreateModel(
+            name='Schedule_Week_Data',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name_schedule', models.CharField(max_length=100, unique=True)),
+                ('state_Monday', models.BooleanField()),
+                ('state_Tuesday', models.BooleanField()),
+                ('state_Wednesday', models.BooleanField()),
+                ('state_Thursday', models.BooleanField()),
+                ('state_Friday', models.BooleanField()),
+                ('state_Saturday', models.BooleanField()),
+                ('state_Sunday', models.BooleanField()),
+            ],
+            options={
+                'db_table': 'schedule_week',
+            },
+        ),
+        migrations.CreateModel(
+            name='Deployment_Data',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=100)),
+                ('namespace', models.CharField(max_length=100)),
+                ('replicas', models.IntegerField()),
+                ('schedule_day', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='cloudmanager.schedule_day_data')),
+                ('schedule_week', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='cloudmanager.schedule_week_data')),
+            ],
+            options={
+                'db_table': 'machine',
+            },
+        ),
+    ]

django_code/apps/cloudmanager/models.py

@@ -0,0 +1,65 @@
+from django.db import models
+
+
+
+class Schedule_Week_Data(models.Model):
+    name_schedule = models.CharField(max_length=100,unique=True)
+    state_Monday = models.BooleanField()
+    state_Tuesday = models.BooleanField()
+    state_Wednesday = models.BooleanField()
+    state_Thursday = models.BooleanField()
+    state_Friday = models.BooleanField()
+    state_Saturday = models.BooleanField()
+    state_Sunday = models.BooleanField()
+    class Meta:
+        db_table = 'schedule_week'
+    def __str__(self):
+        return self.name_schedule
+    
+class Schedule_Day_Data(models.Model):
+    name_schedule = models.CharField(max_length=100,unique=True)
+    state_at_0 = models.BooleanField()
+    state_at_1 = models.BooleanField()
+    state_at_2 = models.BooleanField()
+    state_at_3 = models.BooleanField()
+    state_at_4 = models.BooleanField()
+    state_at_5 = models.BooleanField()
+    state_at_6 = models.BooleanField()
+    state_at_7 = models.BooleanField()
+    state_at_8 = models.BooleanField()
+    state_at_9 = models.BooleanField()
+    state_at_10 = models.BooleanField()
+    state_at_11 = models.BooleanField()
+    state_at_12 = models.BooleanField()
+    state_at_13 = models.BooleanField()
+    state_at_14 = models.BooleanField()
+    state_at_15 = models.BooleanField()
+    state_at_16 = models.BooleanField()
+    state_at_17 = models.BooleanField()
+    state_at_18 = models.BooleanField()
+    state_at_19 = models.BooleanField()
+    state_at_20 = models.BooleanField()
+    state_at_21 = models.BooleanField()
+    state_at_22 = models.BooleanField()
+    state_at_23 = models.BooleanField()
+    class Meta:
+        db_table = 'schedule_day'
+    def __str__(self):
+        return self.name_schedule
+
+class Deployment_Data(models.Model):
+    name = models.CharField(max_length=100)
+    namespace  = models.CharField(max_length=100)
+    schedule_week = models.ForeignKey(Schedule_Week_Data,null=True, blank=True, on_delete=models.SET_NULL)
+    schedule_day = models.ForeignKey(Schedule_Day_Data,null=True, blank=True, on_delete=models.SET_NULL)
+    replicas = models.IntegerField()
+    class Meta:
+        db_table = 'machine'
+
+class Namespace_Data(models.Model):
+    namespace  = models.CharField(max_length=100)
+    #deployments = models.ForeignKey(Schedule_Week_Data,null=True, blank=True, on_delete=models.SET_NULL)
+    class Meta:
+        db_table = 'namespace'
+
+namespace_cmm_data_object = Namespace_Data.objects.using('cloudmanager_db')

django_code/apps/cloudmanager/utils.py

@@ -0,0 +1,13 @@
+from apps.kubernetes_connection.utils import get_namespace
+
+
+def import_namespace(queryset):
+    namespaces_list = get_namespace()
+    for namespace in namespaces_list:
+        queryset.create(namespace=namespace)
+
+def import_deployment(queryset):
+    namespaces_list = get_namespace()
+    #for namespace in namespaces_list:
+    #    queryset.create(namespace=namespace)
+                

django_code/apps/cloudmanager/views.py

@@ -0,0 +1,25 @@
+from django.http import HttpResponse
+
+#  IMPORT AT THE TOP HERE: This is completely safe!
+from apps.cloudmanager.models import Deployment_Data,Schedule_Week_Data
+
+def coucou(request):
+    # 1. Prepare the data inside the function
+    data = CmmData(
+        name="test",
+        namespace="testspace",
+        schedule_hour="1",
+        schedule_day="deux",
+        replicas=3
+    )
+
+    # 2. This line actually pushes the data into your cloudmanager_db!
+    data.save()
+
+    return HttpResponse('<h1>Hello cmm! Data saved successfully!</h1>')
+
+def display(request):
+    data = CmmData.objects.all()
+    print(data[0].namespace)
+    return HttpResponse(data)
+

django_code/apps/dashboard/views.py

@@ -0,0 +1,21 @@
+from django.shortcuts import render
+
+
+def home(request):
+    thislist = ["apple", "banana", "cherry"]
+    return render(request, 'dashboard/home.html',{'thislist': thislist})
+
+def about(request):
+    thislist = ["apple", "banana", "cherry"]
+    return render(request, 'dashboard/about.html',{'thislist': thislist})
+
+def success(request):
+    return render(request, 'dashboard/start.html',{'deployment': 'django','url':'https://google.com'})
+
+def scale_up(request,namespace_name,deploy_name):
+    baseurl = "{0}://{1}{2}".format(request.scheme, request.get_host(), request.path)
+    return render(request, 'dashboard/start.html', {'namespace':namespace_name,'deployment': deploy_name, 'url': 'https://namespace.com','baseurl': baseurl})
+
+def scale_down(request,namespace_name,deploy_name):
+    baseurl = "{0}://{1}{2}".format(request.scheme, request.get_host(), request.path)
+    return render(request, 'dashboard/shutdown.html', {'namespace':namespace_name,'deployment': deploy_name, 'url': 'https://namespace.com','baseurl': baseurl})

django_code/apps/job_dashboard/admin.py

@@ -0,0 +1,40 @@
+from django.contrib import admin
+from import_export.admin import ImportExportModelAdmin
+from import_export import resources
+from import_export.fields import Field
+from .models import JobData
+from django.utils.text import Truncator
+
+# Register your models here.
+
+
+class JobResource(resources.ModelResource):
+    # Map 'csv_column_name' from the file to 'model_variable_name' in your DB
+    job_position = Field(attribute='job_position',column_name='Job Position')
+    company = Field(attribute='company',column_name='Company')
+    URL = Field(attribute='URL',column_name='URL')
+    status = Field(attribute='status',column_name='Status')
+    date_saved = Field(attribute='date_saved',column_name='Date Saved')
+    date_applied = Field(attribute='date_applied',column_name='Date Applied')
+    type = Field(attribute='type',column_name='Type')
+    resume = Field(attribute='resume',column_name='Resume')
+    #cover_letter = Field(attribute='cover_letter',column_name='Cover Letter')
+    location = Field(attribute='location',column_name='Location')
+    job_description = Field(attribute='job_description',column_name='Job Description')
+    salary = Field(attribute='salary',column_name='Salary')
+    contact = Field(attribute='contact',column_name='Contact')
+    source = Field(attribute='source',column_name='Source')
+
+    class Meta:
+        model = JobData
+
+
+
+@admin.register(JobData)
+class JobAdmin(ImportExportModelAdmin):
+    list_display = ('job_position','company','URL','status','date_saved','date_applied','type','resume','location','short_description','salary','contact','source')
+    #fields = ['job_position','company','URL','status','date_saved','date_applied','type','resume','cover_letter','location','job_description','salary ','contact','source']
+    resource_classes = [JobResource]
+    def short_description(self, obj):
+        return Truncator(obj.job_description).words(10, truncate=' ...')
+

django_code/apps/job_dashboard/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+class JobDashboardConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.job_dashboard'
+    label = 'job'

django_code/apps/job_dashboard/migrations/0001_initial.py

@@ -0,0 +1,36 @@
+# Generated by Django 4.2.29 on 2026-06-22 20:21
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='JobData',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('job_position', models.CharField(max_length=100, null=True)),
+                ('company', models.CharField(max_length=100, null=True)),
+                ('URL', models.URLField(max_length=1000, null=True)),
+                ('status', models.CharField(choices=[('Rejected', 'Rejected'), ('Applied', 'Applied'), ('Negotiating', 'Negotiating'), ('Bookmarked', 'Bookmarked'), ('Accepted', 'Accepted')], max_length=100, null=True)),
+                ('date_saved', models.CharField(max_length=100, null=True)),
+                ('date_applied', models.CharField(max_length=100, null=True)),
+                ('type', models.CharField(max_length=100, null=True)),
+                ('resume', models.URLField(null=True)),
+                ('location', models.CharField(max_length=100, null=True)),
+                ('job_description', models.CharField(null=True)),
+                ('salary', models.CharField(null=True)),
+                ('contact', models.CharField(max_length=100, null=True)),
+                ('source', models.CharField(max_length=100, null=True)),
+            ],
+            options={
+                'db_table': 'job',
+            },
+        ),
+    ]

django_code/apps/job_dashboard/models.py

@@ -0,0 +1,29 @@
+from django.db import models
+
+
+status_CHOICES = (
+    ('Rejected','Rejected'),
+    ('Applied','Applied'),
+    ('Negotiating','Negotiating'),
+     ('Bookmarked','Bookmarked'),
+      ('Accepted','Accepted')
+)
+
+class JobData(models.Model):
+    job_position = models.CharField(max_length=100, null=True)
+    company = models.CharField(max_length=100, null=True)
+    URL = models.URLField(max_length=1000,null=True)
+    status = models.CharField(max_length=100,choices=status_CHOICES, null=True)
+    date_saved = models.CharField(max_length=100, null=True)
+    date_applied = models.CharField(max_length=100, null=True)
+    type = models.CharField(max_length=100, null=True)
+    resume  = models.URLField(max_length=200, null=True)
+    #cover_letter = models.URLField(max_length=200, null=True)
+    location = models.CharField(max_length=100, null=True)
+    job_description = models.CharField(null=True)
+    salary = models.CharField(null=True)
+    contact = models.CharField(max_length=100, null=True)
+    source  = models.CharField(max_length=100, null=True)
+    class Meta:
+        db_table = 'job'
+

django_code/apps/job_dashboard/urls.py

@@ -0,0 +1,23 @@
+"""
+URL configuration for django_code project.
+
+The `urlpatterns` list routes URLs to views. For more information please see:
+    https://docs.djangoproject.com/en/4.2/topics/http/urls/
+Examples:
+Function views
+    1. Add an import:  from my_app import views
+    2. Add a URL to urlpatterns:  path('', views.home, name='home')
+Class-based views
+    1. Add an import:  from other_app.views import Home
+    2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')
+Including another URLconf
+    1. Import the include() function: from django.urls import include, path
+    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
+"""
+from django.contrib import admin
+from django.urls import path
+
+
+urlpatterns = [
+    path('', admin.site.urls),
+]

django_code/apps/job_dashboard/views.py

@@ -0,0 +1,3 @@
+from django.shortcuts import render
+
+# Create your views here.

django_code/apps/kubernetes_connection/apps.py

@@ -14,18 +14,23 @@ import ruamel.yaml
 import yaml
 import urllib.request
 
+
 def hello(request):
     return HttpResponse('<h1>Hello k8s!</h1>')
 
-def scale_up(request,namespace_name,deploy_name):
+def echoHello():
+    print("hello from k8s")
+    return "returned from k8s"
+
+def scale_up(request,namespace_name,deploy_name,replicas=1):
     config.load_kube_config(config_file='/kubeconfig/config')
     api = client.AppsV1Api()
     deployment = api.read_namespaced_deployment(name=deploy_name, namespace=namespace_name)
-    deployment.spec.replicas = 1
+    deployment.spec.replicas = replicas
     resp = api.patch_namespaced_deployment(
         name=deploy_name, namespace=namespace_name, body=deployment);
     #return HttpResponse('<h1>Scaled up  !</h1>')
-    return render(request, 'start.html', {'namespace':namespace_name,'deployment': deploy_name, 'url': 'https://namespace.com'})
+    return render(request, 'dashboard/start.html', {'namespace':namespace_name,'deployment': deploy_name, 'url': 'https://namespace.com'})
 
 
 def scale_down(request,namespace_name,deploy_name):
@@ -36,7 +41,7 @@ def scale_down(request,namespace_name,deploy_name):
     resp = api.patch_namespaced_deployment(
         name=deploy_name, namespace=namespace_name, body=deployment);
     #return HttpResponse('<h1>Scaled down  !</h1>')
-    return render(request, 'shutdown.html',
+    return render(request, 'dashboard/shutdown.html',
                   {'namespace': namespace_name, 'deployment': deploy_name, 'url': 'https://namespace.com'})
 
 def nodes(request):

django_code/apps/kubernetes_connection/utils.py

@@ -0,0 +1,57 @@
+from kubernetes import client, config
+
+
+def scale_up(namespace_name,deploy_name,replicas=1):
+    config.load_kube_config(config_file='/kubeconfig/config')
+
+    api = client.AppsV1Api()
+    deployment = api.read_namespaced_deployment(name=deploy_name, namespace=namespace_name)
+    deployment.spec.replicas = replicas
+    resp = api.patch_namespaced_deployment(
+        name=deploy_name, namespace=namespace_name, body=deployment);
+    return 0
+
+def scale_down(namespace_name,deploy_name):
+    config.load_kube_config(config_file='/kubeconfig/config')
+    api = client.AppsV1Api()
+    deployment = api.read_namespaced_deployment(name=deploy_name, namespace=namespace_name)
+    deployment.spec.replicas = 0
+    resp = api.patch_namespaced_deployment(
+        name=deploy_name, namespace=namespace_name, body=deployment);
+    return 0
+
+def import_Deployments():
+    config.load_kube_config(config_file='/kubeconfig/config')
+    api = client.AppsV1Api()
+    deployment = api.list_deployment_for_all_namespaces()
+    for i in range(1,len(deployment.items)):
+        print(deployment.items[i].spec.template.spec.containers[0].name)
+
+    len(deployment.items) #list all deployment inside the namespace
+    test.items[0].spec.template.spec.containers[0].name # name the first deploy within the  namespace
+    test.items[2].spec.template.spec.containers[0].name # name the third deploy within the  namespace
+    return 0
+
+def get_namespace():
+    config.load_kube_config(config_file='/kubeconfig/config')
+    core = client.CoreV1Api()
+    namespace = core.list_namespace()
+    namespace_list = []
+    for i in range(0,len(namespace.items)):
+        print(namespace.items[i].metadata.name)
+        namespace_list.append(namespace.items[i].metadata.name)
+    return namespace_list
+
+def get_deployments():
+    config.load_kube_config(config_file='/kubeconfig/config')
+    api = client.AppsV1Api()
+    namespaces_list = get_namespace()
+    deployments_list = []
+    for namespace in namespaces_list:
+        print(namespace)
+        deployments = api.list_namespaced_deployment(namespace)
+        for deployment_index in range(0,len(deployments.items)):
+            deployment = deployments.items[deployment_index].metadata.name
+            print("     "+str(deployment))
+            deployments_list.append([namespace,deployment])
+    return deployments_list

django_code/apps/podcast_aggregator/admin.py

@@ -0,0 +1,9 @@
+from django.contrib import admin
+from import_export.admin import ImportExportModelAdmin
+from import_export import resources
+from .models import podcastData
+
+# Register your models here.
+@admin.register(podcastData)
+class JobAdmin(ImportExportModelAdmin):
+    list_display = ('podcast_name','podcast_url','enabled')

django_code/apps/podcast_aggregator/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class PodcastAggregatorConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.podcast_aggregator'
+    label = 'podcast'

django_code/apps/podcast_aggregator/migrations/0001_initial.py

@@ -0,0 +1,25 @@
+# Generated by Django 4.2.29 on 2026-06-30 22:05
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='podcastData',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('podcast_name', models.CharField(max_length=100, null=True)),
+                ('podcast_url', models.CharField(max_length=100, null=True)),
+            ],
+            options={
+                'db_table': 'podcasts',
+            },
+        ),
+    ]

django_code/apps/podcast_aggregator/migrations/0002_podcastdata_enabled.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.29 on 2026-06-30 22:08
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('podcast', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='podcastdata',
+            name='enabled',
+            field=models.BooleanField(default=True),
+        ),
+    ]

django_code/apps/podcast_aggregator/models.py

@@ -0,0 +1,8 @@
+from django.db import models
+
+class podcastData(models.Model):
+    podcast_name = models.CharField(max_length=100, null=True)
+    podcast_url = models.CharField(max_length=100, null=True)
+    enabled = models.BooleanField(default=True)
+    class Meta:
+        db_table = 'podcasts'

django_code/apps/podcast_aggregator/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

django_code/apps/podcast_aggregator/utils.py

@@ -0,0 +1,89 @@
+import requests
+import xmltodict
+from urllib import request as urlrequest
+import tempfile
+#Django import
+from apps.telegram_communication.utils import telegramUtils
+from .models import podcastData
+
+
+
+
+proxy_url = 'http://gluetun-svc.gluetun.svc:8888'
+proxy = urlrequest.ProxyHandler({
+    'http': proxy_url,
+    'https': proxy_url  # Add the handler for HTTPS
+})
+
+proxies = {
+    "http"  : proxy_url,
+    "https" : proxy_url
+}
+
+def rss_to_dict(url):
+    response = requests.get(url)
+    data = xmltodict.parse(response.content)
+    
+    print(data['rss'])
+    
+    title = data['rss']['channel']['title']
+    
+    #Get the keys if needed of debug 
+    #print(data['rss'].keys())
+    
+    #use first object as it's ordered in a chronological order
+    
+    
+    today_object = data['rss']['channel']['item']
+    if isinstance(today_object, list):
+        today_object = data['rss']['channel']['item'][0]
+        
+    today_title = today_object['title']
+    today_podcast_url = today_object['enclosure']['@url']
+        
+    return title,today_title,today_podcast_url
+
+def download_news_mp3(url_mp3, filename):
+
+    opener = urlrequest.build_opener(proxy)
+
+    urlrequest.install_opener(opener)
+    
+    print("Downloading : " + filename +" -- " + url_mp3)
+    try:
+
+        urlrequest.urlretrieve(url_mp3, filename)
+        
+    except:
+        print("Can't download " + filename +" -- " + url_mp3 + "  == Cancelling")
+    return 0
+
+def pretty_filename(filename,extension=''):
+    filename = filename.replace(' ', '_')
+    pretty_filename = filename.replace('/', '_')
+    if extension != '':
+        extension = str('.'+extension)
+    return pretty_filename+extension
+
+def podcasts():
+    telegram = telegramUtils()
+    
+    #clear all expired messages before
+    telegram.clear_expired_messages()
+
+    podcasts = podcastData.objects.filter(enabled=True)
+    for podcast in podcasts:
+        url = podcast.podcast_url
+       
+        today_podcast = rss_to_dict(url)
+        print(today_podcast)
+        pretty_file_name = pretty_filename(today_podcast[1],'mp3')
+
+        temp = tempfile.TemporaryDirectory()
+        temp_path = temp.name.replace("\\", "/")
+        file_path = temp_path+"/"+pretty_file_name
+        download_news_mp3(today_podcast[2],file_path)
+        print(file_path)
+        telegram.send_document(file_path,str(today_podcast[0])+" "+str(today_podcast[1]))
+
+#main()

django_code/apps/podcast_aggregator/views.py

@@ -0,0 +1,7 @@
+from django.http import HttpResponse
+from .utils import podcasts
+
+# Create your views here.
+def execute_podcast(request):
+    podcasts()
+    return HttpResponse('<h1>Generating the podcast!</h1>')

django_code/apps/random_simpsons/admin.py

@@ -0,0 +1,97 @@
+from django.contrib import admin,messages
+from django.utils.translation import ngettext
+from prompt_toolkit.shortcuts import print_container
+from .models import SimpsonsData,simpsons_data_object,urlData
+from .utils import mark_episode_watched,unwatch_all_episodes,generate_new_urls_for_episode
+from import_export import resources
+from import_export.admin import ImportExportModelAdmin
+from django.utils import timezone
+# Register your models here.
+
+DB = 'simpsons_db'
+
+@admin.action(description="Mark episode as seen")
+def make_seen(modeladmin, request, queryset):
+    updated = queryset.update(seen="True",modified_at=timezone.now())
+    
+    for query in queryset.values():
+        print(query)
+        season_number = query.get('season')
+        episode_number = query.get('episode')
+        mark_episode_watched(season_number,episode_number,"watched")
+
+    modeladmin.message_user(
+        request,
+        ngettext(
+            "%d episode was successfully marked as seen.",
+            "%d episodes were successfully marked as seen.",
+            updated,
+        )
+        % updated,
+        messages.SUCCESS,
+    )
+
+@admin.action(description="Mark episode as not seen")
+def make_unseen(modeladmin, request, queryset):
+    updated = queryset.update(seen="False")
+    for query in queryset.values():
+        print(query)
+        season_number = query.get('season')
+        episode_number = query.get('episode')
+        mark_episode_watched(season_number,episode_number,"unwatched")
+        
+    modeladmin.message_user(
+        request,
+        ngettext(
+            "%d episode was successfully marked as not seen.",
+            "%d episodes were successfully marked as not seen.",
+            updated,
+        )
+        % updated,
+        messages.SUCCESS,
+    )
+
+@admin.action(description="mark all of them as unseen on betaserie")
+def unseen_betaserie(modeladmin, request, queryset):
+    unwatch_all_episodes()
+
+@admin.action(description="generate new urls for episode")
+def generate_new_urls(modeladmin, request, queryset):
+    generate_new_urls_for_episode()
+
+
+
+@admin.register(SimpsonsData)
+class EpisodeAdmin(ImportExportModelAdmin):
+    list_display = [field.name for field in SimpsonsData._meta.fields if field.name != 'id']
+    list_filter = ['seen','modified_at']
+    #list_filter = ['seen']
+    fields = ['season', 'episode', 'url', 'seen']
+    actions = [make_seen,make_unseen,unseen_betaserie,generate_new_urls]
+    search_fields = ['season', 'episode', 'url', 'seen']
+
+    def get_queryset(self, request):
+        return super().get_queryset(request).using(DB)
+    
+    def save_model(self, request, obj, form, change):
+        obj.save(using=DB)
+    
+    def delete_model(self, request, obj):
+        obj.delete(using=DB)
+    
+    def delete_queryset(self, request, queryset):
+        queryset.using(DB).delete()
+
+@admin.register(urlData)
+class urldataAdmin(ImportExportModelAdmin):
+    list_display = ('url_example', 'prefix', 'infix', 'suffix','addedDate')
+
+
+    fieldsets = [
+    (
+        None,
+        {
+            'fields': (('prefix', 'infix', 'suffix'), 'url_example')
+        },
+    )
+    ]

django_code/apps/random_simpsons/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+class RandomSimpsonsConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.random_simpsons'
+    label = 'simpsons'

django_code/apps/random_simpsons/migrations/0001_initial.py

@@ -0,0 +1,27 @@
+# Generated by Django 4.2.29 on 2026-06-22 20:21
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='SimpsonsData',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('season', models.IntegerField()),
+                ('episode', models.IntegerField()),
+                ('url', models.CharField(max_length=1000)),
+                ('seen', models.BooleanField()),
+            ],
+            options={
+                'db_table': 'episodes',
+            },
+        ),
+    ]

django_code/apps/random_simpsons/migrations/0002_simpsonsdata_modified_at.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.29 on 2026-07-05 13:32
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('simpsons', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='simpsonsdata',
+            name='modified_at',
+            field=models.DateTimeField(auto_now=True),
+        ),
+    ]

django_code/apps/random_simpsons/migrations/0003_alter_simpsonsdata_modified_at.py

@@ -0,0 +1,19 @@
+# Generated by Django 4.2.29 on 2026-07-05 13:40
+
+import datetime
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('simpsons', '0002_simpsonsdata_modified_at'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='simpsonsdata',
+            name='modified_at',
+            field=models.DateTimeField(default=datetime.datetime(1970, 1, 1, 0, 0)),
+        ),
+    ]

django_code/apps/random_simpsons/migrations/0004_remove_simpsonsdata_modified_at.py

@@ -0,0 +1,17 @@
+# Generated by Django 4.2.29 on 2026-07-05 13:43
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('simpsons', '0003_alter_simpsonsdata_modified_at'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='simpsonsdata',
+            name='modified_at',
+        ),
+    ]

django_code/apps/random_simpsons/migrations/0005_simpsonsdata_modified_at.py

@@ -0,0 +1,19 @@
+# Generated by Django 4.2.30 on 2026-07-07 08:35
+
+import datetime
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('simpsons', '0004_remove_simpsonsdata_modified_at'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='simpsonsdata',
+            name='modified_at',
+            field=models.DateTimeField(default=datetime.datetime(1970, 1, 1, 0, 0)),
+        ),
+    ]

django_code/apps/random_simpsons/migrations/0006_urldata.py

@@ -0,0 +1,27 @@
+# Generated by Django 4.2.30 on 2026-07-07 08:40
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('simpsons', '0005_simpsonsdata_modified_at'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='urlData',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('url_example', models.CharField(max_length=1000)),
+                ('prefix', models.CharField(max_length=1000)),
+                ('infix', models.CharField(max_length=1000)),
+                ('suffix', models.CharField(max_length=1000)),
+                ('addedDate', models.DateField(auto_now_add=True, null=True, verbose_name='Published')),
+            ],
+            options={
+                'db_table': 'redirectUrl',
+            },
+        ),
+    ]

django_code/apps/random_simpsons/migrations/0007_alter_urldata_infix_alter_urldata_prefix_and_more.py

@@ -0,0 +1,28 @@
+# Generated by Django 4.2.30 on 2026-07-07 08:59
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('simpsons', '0006_urldata'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='urldata',
+            name='infix',
+            field=models.CharField(help_text='8&episode=', max_length=1000),
+        ),
+        migrations.AlterField(
+            model_name='urldata',
+            name='prefix',
+            field=models.CharField(help_text='https://www.1shows.org/tv/456-the-simpsons?streaming=true&season=', max_length=1000),
+        ),
+        migrations.AlterField(
+            model_name='urldata',
+            name='url_example',
+            field=models.CharField(help_text='https://www.1shows.org/tv/456-the-simpsons?streaming=true&season=18&episode=5', max_length=1000),
+        ),
+    ]

django_code/apps/random_simpsons/migrations/0008_alter_simpsonsdata_modified_at_alter_urldata_infix_and_more.py

@@ -0,0 +1,34 @@
+# Generated by Django 4.2.30 on 2026-07-07 09:28
+
+import datetime
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('simpsons', '0007_alter_urldata_infix_alter_urldata_prefix_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='simpsonsdata',
+            name='modified_at',
+            field=models.DateTimeField(default=datetime.datetime(1970, 1, 1, 0, 0, tzinfo=datetime.timezone.utc)),
+        ),
+        migrations.AlterField(
+            model_name='urldata',
+            name='infix',
+            field=models.CharField(blank=True, help_text='&episode=', max_length=1000, null=True),
+        ),
+        migrations.AlterField(
+            model_name='urldata',
+            name='prefix',
+            field=models.CharField(blank=True, help_text='https://www.1shows.org/tv/456-the-simpsons?streaming=true&season=', max_length=1000, null=True),
+        ),
+        migrations.AlterField(
+            model_name='urldata',
+            name='suffix',
+            field=models.CharField(blank=True, max_length=1000, null=True),
+        ),
+    ]

django_code/apps/random_simpsons/models.py

@@ -0,0 +1,27 @@
+from django.db import models
+from datetime import datetime
+from django.utils.timezone import make_aware
+
+EPOCH = make_aware(datetime(1970, 1, 1))
+
+class SimpsonsData(models.Model):
+    season = models.IntegerField()
+    episode  = models.IntegerField()
+    url = models.CharField(max_length=1000)
+    seen = models.BooleanField()
+    modified_at = models.DateTimeField(default=EPOCH)
+
+    class Meta:
+        db_table = 'episodes'
+
+class urlData(models.Model):
+    url_example = models.CharField(max_length=1000, help_text="https://www.1shows.org/tv/456-the-simpsons?streaming=true&season=18&episode=5")
+    prefix = models.CharField(max_length=1000, help_text="https://www.1shows.org/tv/456-the-simpsons?streaming=true&season=",blank=True, null=True)
+    infix = models.CharField(max_length=1000, help_text="&episode=",blank=True, null=True)
+    suffix = models.CharField(max_length=1000, help_text="" ,blank=True, null=True)
+    addedDate = models.DateField('Published', blank=True, null=True, auto_now_add=True)
+    
+    class Meta:
+        db_table = 'redirectUrl'
+
+simpsons_data_object = SimpsonsData.objects.using('simpsons_db')

django_code/apps/random_simpsons/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

django_code/apps/random_simpsons/utils.py

@@ -0,0 +1,92 @@
+from django.db.models import Count
+from django.core.exceptions import MultipleObjectsReturned
+from celery.worker.state import active_requests
+from requests.compat import str
+from django.utils import timezone
+from apps.betaserie.utils import betaserieUtils
+from .models import simpsons_data_object,urlData
+
+betaserie = betaserieUtils()
+
+simpsons_id = 12
+
+
+def mark_episode_watched(season,episode,action,verbose=False):
+    #mark episode as seen in DB
+    simpsons_data_object.filter(season=season, episode=episode).values('seen').update(seen=True,modified_at=timezone.now())
+
+
+    if verbose : print("season_number: "+str(season))
+    if verbose : print("episode_number: "+str(episode))
+
+    #mark episode as seen in betaserie
+    episode_number = "S"+str(season)+"E"+str(episode)
+    
+    episode_id = betaserie.identify_episode(simpsons_id,episode_number)
+
+    if action == "watched":
+        betaserie.mark_episodes_watched(episode_id)
+    elif action == "unwatched":
+        betaserie.unmark_episodes_watched(episode_id)
+    else:
+        print("Parameter action not in range")
+
+
+
+def unwatch_all_episodes():
+    maximum_number_of_seasons = simpsons_data_object.aggregate(unique_season=Count('season', distinct=True))['unique_season']
+    print("maximum_number_of_seasons: "+str(maximum_number_of_seasons))
+    for season in range(1,maximum_number_of_seasons+1):
+        maximum_number_of_episodes = simpsons_data_object.filter(season=season).count()
+        print("maximum_number_of_episodes for "+str(season)+": "+str(maximum_number_of_episodes))
+        for episode in range(1,maximum_number_of_episodes+1):
+            print("S"+str(season)+"E"+str(episode))
+            mark_episode_watched(season,episode,"unwatched")
+
+
+def generate_new_urls_for_episode(verbose=False):
+    # kisscartoons didn't work anymore so moving to another website with the format:
+    # URL.com/simpsons/season=XX&episode=XX
+    # example
+    # https://www.1shows.org/tv/456-the-simpsons?streaming=true&season=33&episode=18
+    
+    simpsons_series_information = betaserie.series_information(simpsons_id)
+    seasons_information = simpsons_series_information[0]    
+    
+    #for the simpsons, there is a season 0 which increase the count of seasons by 1
+    # we need to remove this entry , 
+    # so we cannot trust the maximum_number_season coming from simpsons_series_information
+    
+    season_0_to_remove = seasons_information[0]
+    
+    if verbose : print(season_0_to_remove)
+    
+    seasons_information.remove(season_0_to_remove)
+    maximum_number_season = len(seasons_information)
+    
+    for season in range(1,maximum_number_season+1):
+        # the list doesn't start with season 0 anymore so we cannot use the season number as index 
+        # we need to add -1
+    
+        number_episodes_in_season = int(seasons_information[season-1]['episodes'])
+    
+        for episode in range(1,number_episodes_in_season+1):
+            if verbose : print("Season: "+str(season))
+            if verbose : print("episode: "+str(episode))
+
+            new_url_object = urlData.objects.all().order_by('-addedDate').first()
+            new_url = str(new_url_object.prefix)+str(season)+str(new_url_object.infix)+str(episode)+str(new_url_object.suffix)
+    
+            if verbose : print(new_url)
+            try:
+                obj,created = simpsons_data_object.get_or_create(
+                    season=season,
+                    episode=episode,
+                    defaults={"url":new_url,"seen":"False"}
+                )
+                obj.url=new_url
+                obj.save()
+            except MultipleObjectsReturned:
+                print("duplicated object for season: "+str(episode)+" episode: "+str(episode)+", ignoring")
+    
+    return 0

django_code/apps/random_simpsons/views.py

@@ -0,0 +1,75 @@
+from django.http import HttpResponse
+from django.db.models import Count
+from django.shortcuts import redirect
+from .models import SimpsonsData,simpsons_data_object
+from .utils import mark_episode_watched
+import random
+import threading
+
+def hello(request):
+    return HttpResponse('<h1>Hello Simpsons view!</h1>')
+
+def episode_generator(request):
+    boolean_restart = True;
+    simpsons_object = {}
+    while (boolean_restart):
+        maximum_number_of_seasons = simpsons_data_object.aggregate(unique_season=Count('season', distinct=True))['unique_season']
+        
+        random_season = random.randint(1, maximum_number_of_seasons)
+        print("random season: " + str(random_season))
+        
+        simpsons_object = simpsons_data_object.filter(season=random_season)
+        
+        maximum_number_of_episodes = simpsons_object.count()
+        
+        random_episode = random.randint(1, maximum_number_of_episodes)    
+        print("random episode: " + str(random_episode))
+
+        simpsons_object = simpsons_object.filter(episode=random_episode)
+        
+        episode_seen = simpsons_object.values('seen')[0]['seen']
+ 
+        if not(episode_seen):
+            boolean_restart = False
+        else:
+            print("episode "+str(random_episode)+" from season "+str(random_season)+" already seen")
+            
+        
+        #Set episode as seen
+        # It will still update an already seem episode but it works and I'm lazy
+        
+        
+        #Mark episode as seen on betaseries
+        thread = threading.Thread(
+            target=mark_episode_watched,
+            args=(random_season, random_episode, "watched"),
+            daemon=True,
+        )
+        thread.start()
+        
+    random_url = simpsons_object.values('url')[0]['url']
+   
+    return redirect(str(random_url))
+
+def download_file(request):
+    # fill these variables with real values
+    fl_path = '/data/download/sonarr'
+    filename = 'The.Boys.2019.S04E05.2160p.HDR10Plus.WEBRip.6CH.x265.HEVC-PSA.mkv'
+
+    #    fl = open(fl_path, 'r')
+    #    mime_type, _ = mimetypes.guess_type(fl_path)
+
+    #    response = HttpResponse(fl, content_type=mime_type)
+    #    response['Content-Disposition'] = "attachment; filename=%s" % filename
+    some_file = open('/data/kubernetes/Backup/nextcloud/notes/2024-07-28/Course.md', "r")
+    django_file = File(some_file)
+    return HttpResponse("<h1>Hello download!</h1><h1><a href='{{ MEDIA_URL }}{{ django_file.relative_path }}'>{{ django_file.name }}</a></h1><h1>bye download!</h1>")
+#    return response
+
+def download_mo(request,file):
+    path_to_file = os.path.realpath(file)
+    response = FileResponse(open(path_to_file, 'rb'))
+    file_name = file[5:]
+    response['Content-Disposition'] = 'inline; filename=' + file_name
+    return response
+

django_code/apps/stash_management/apps.py

@@ -2,7 +2,6 @@ from django.apps import AppConfig
 from django.http import HttpResponse
 from django.shortcuts import render
 from django.shortcuts import redirect
-#from jinja2 import Environment, FileSystemLoader
 from django.core.files import File 
 from kubernetes import client, config
 from celery import shared_task
@@ -10,6 +9,7 @@ from celery import shared_task
 from lxml import html
 import requests
 import os
+import json
 import time
 import random
 import mimetypes
@@ -33,15 +33,16 @@ proxies = {
               "https" : proxy_url
             }
 
-destination_folder = "/tmp/stash/" 
+destination_folder = "/stash/"
 
 def hello(request):
     return HttpResponse('<h1>Hello stash!</h1>')
 def form(request):
-    return render(request, 'stash_form.html',{})
+    return render(request, 'stash/stash_form.html',{})
 def album(request):
-    return render(request, 'album_form.html',{})
-
+    return render(request, 'stash/album_form.html',{})
+def simple(request):
+    return render(request, 'stash/simple_form.html',{})
 def check_and_create_destination_folder(name):
     #check if the output directory exist and create if not
     if not os.path.isdir(destination_folder):
@@ -116,12 +117,69 @@ def images_downloader(name,images_url_list,destination_named_folder):
         opener = urlrequest.build_opener(proxy)
         
         urlrequest.install_opener(opener)
-        urlrequest.urlretrieve(image_url, filename )
+        try:
+          urlrequest.urlretrieve(image_url, filename )
+        except:
+          print("Can't download "+filename+" -- "+image_url)
+          individual_image_downloader.delay(image_url=image_url, filename=filename)
         
     return 0
 
+@shared_task()
+def individual_image_downloader(image_url, filename ):
+    print("Downloading again: "+filename+" -- "+image_url)
+    
+    opener = urlrequest.build_opener(proxy)
+    
+    urlrequest.install_opener(opener)
+    try:
+      urlrequest.urlretrieve(image_url, filename )
+    except:
+      print("Still Can't download "+filename+" -- "+image_url+"  == Cancelling")  
+    return 0
+
+def simple_form(request):
+    name = request.GET.get('name')
+    reddit_downloader(username=name)
+
+    text_generated = "successfully sent to the reddit downloader"
+    return HttpResponse(text_generated, content_type="text/plain")
+
+def reddit_downloader(username):
+    
+    #create the prerequisites folder
+    destination_named_folder = check_and_create_destination_folder(name=username)
+
+
+
+    url = "https://www.reddit.com/user/"+username+"/submitted/.json?limit=1000"
+    opener = urlrequest.build_opener(proxy)
+    urlrequest.install_opener(opener)
+
+    req = urlrequest.Request(url)
+    urlcurl = urlrequest.urlopen(req).read()
+    data = json.loads(urlcurl)
+    
+    picture_list=[]
+    for children in data['data']['children']:
+        print("adding to the list : "+children['data']['url'])
+        picture_list.append(children['data']['url'])
+        
+    images_downloader.delay(name=username,images_url_list=picture_list,destination_named_folder=destination_named_folder)
+
+    return 0
+
+def redgif_donloader(username):
+    #on te front page of the user , https://www.redgifs.com/users/princesspizookie
+    # F12 and search network , find something that start as api.redgifs.com
+    # and the file is search?order=new&count=40&type=g
+    # copy as curl and you got the bearer
+    
+    #curl curl 'https://api.redgifs.com/v2/users/princesspizookie/search?order=new&count=40&type=g' 
+    #and you get the URLS , needs to be parsedw
+    return 0
 def incremental(request):
-    return render(request, 'incremental_form.html',{})
+    return render(request, 'stash/incremental_form.html',{})
 
 def incremental_form(request):
     name = request.GET.get('name')
@@ -165,9 +223,10 @@ def increment_and_download(minimum_increment,maximum_increment,url,url_suffix,na
             increment_generated ='000' + str(increment)
 
         url_generated = url+increment_generated+url_suffix
+        print(url_generated)
         destination_filename = increment_generated+url_suffix
         destination_file = os.path.join(destination_named_folder,destination_filename)
-        
+        print(destination_file)
         opener = urlrequest.build_opener(proxy)
         urlrequest.install_opener(opener)
         urlrequest.urlretrieve(url_generated, destination_file )

django_code/apps/stash_management/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

django_code/apps/stash_management/views.py

@@ -9,4 +9,4 @@ def hello(request):
 
 
 def home(request):
-    return render(request, 'listing.html')
+    return render(request, 'stash/listing.html')

django_code/apps/telegram_communication/admin.py

@@ -0,0 +1,26 @@
+from django.contrib import admin
+from import_export.admin import ImportExportModelAdmin
+from .models import TelegramData
+from .utils import telegramUtils 
+
+@admin.action(description="Clear all expired messages")
+def messages_cleaning(modeladmin, request, queryset):
+    telegram = telegramUtils()
+    telegram.clear_expired_messages()
+
+# Register your models here.
+@admin.register(TelegramData)
+class JobAdmin(ImportExportModelAdmin):
+    list_display = ('message_id','chat_id','description','creation_date','expiration_date')
+    actions = [messages_cleaning]
+
+    def delete_queryset(self, request, queryset):
+        """Given a queryset, delete it from the database."""
+        print("here")
+        telegram = telegramUtils()
+        list_of_message_id = list(queryset.all().values_list('message_id',flat=True))
+        telegram.delete_message(list_of_message_id)
+        #no queryset.delete() because it is specified in delete_message function already
+
+
+

django_code/apps/telegram_communication/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class TelegramCommunicationConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.telegram_communication'
+    label = 'telegram'

django_code/apps/telegram_communication/management/commands/new_database.py

@@ -0,0 +1,47 @@
+from django.core.management.base import BaseCommand
+from django.conf import settings
+import os
+#import jinja2
+from jinja2 import Environment, FileSystemLoader
+
+router_path = os.path.join(settings.BASE_DIR,'core','routers.py')
+
+class Command(BaseCommand):
+    args = '<team_id>'
+    help = 'Affiche la liste des backlogs'
+
+    def extract_settings_database(self):
+        settings_databases = []
+        for database in settings.DATABASES:
+            if database == 'default':
+                continue
+            print(database)
+
+            database_label = database.split('_db')[0]
+            
+            settings_databases.append([database,database_label])
+        return settings_databases
+
+    def coucou(self):
+        self.stdout.write('Coucou !')        
+
+    def templating(self,databases_list):
+        template_dir = os.path.join(settings.BASE_DIR, 'templates','routers')
+        env = Environment(loader=FileSystemLoader(template_dir))
+        template = env.get_template('routers.jinja.py')
+        output = template.render(databases_list = databases_list)
+    
+        with open(router_path, 'w') as f:
+            print(output, file = f)
+        
+        print(output)
+
+    def main(self):
+        databases_list = self.extract_settings_database()
+        print(databases_list)
+        self.templating(databases_list)
+        self.coucou()
+
+
+    def handle(self, *args, **options):
+        self.main()

django_code/apps/telegram_communication/management/commands/test_message.py

@@ -0,0 +1,19 @@
+from apps.telegram_communication.utils import telegramUtils
+from django.core.management.base import BaseCommand
+import datetime
+
+
+class Command(BaseCommand):
+    telegram = telegramUtils()
+
+    date_now = datetime.datetime.now()
+    
+    message = "Test message sent at "+str(date_now)
+
+    
+    telegram.send_message(message)
+    args = '<team_id>'
+    help = 'Affiche la liste des backlogs'
+
+    def handle(self, *args, **options):
+        self.stdout.write('Message sent !')

django_code/apps/telegram_communication/migrations/0001_initial.py

@@ -0,0 +1,28 @@
+# Generated by Django 4.2.30 on 2026-06-30 12:13
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='TelegramData',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('message_id', models.IntegerField(max_length=100, null=True)),
+                ('chat_id', models.IntegerField(max_length=100, null=True)),
+                ('description', models.CharField(max_length=100, null=True)),
+                ('creation_date', models.DateField(blank=True, null=True, verbose_name='Published')),
+                ('expiration_date', models.DateField(blank=True, null=True, verbose_name='Published')),
+            ],
+            options={
+                'db_table': 'messages',
+            },
+        ),
+    ]

django_code/apps/telegram_communication/migrations/0002_alter_telegramdata_chat_id_and_more.py

@@ -0,0 +1,33 @@
+# Generated by Django 4.2.30 on 2026-06-30 12:14
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('telegram', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='telegramdata',
+            name='chat_id',
+            field=models.IntegerField(),
+        ),
+        migrations.AlterField(
+            model_name='telegramdata',
+            name='creation_date',
+            field=models.DateField(blank=True, verbose_name='Published'),
+        ),
+        migrations.AlterField(
+            model_name='telegramdata',
+            name='expiration_date',
+            field=models.DateField(blank=True, verbose_name='Published'),
+        ),
+        migrations.AlterField(
+            model_name='telegramdata',
+            name='message_id',
+            field=models.IntegerField(),
+        ),
+    ]

django_code/apps/telegram_communication/models.py

@@ -0,0 +1,12 @@
+from django.db import models
+
+
+class TelegramData(models.Model):
+    message_id = models.IntegerField(null=False)
+    chat_id = models.IntegerField(null=False)
+    description = models.CharField(max_length=100, null=True)
+    creation_date = models.DateField(blank=True, null=False, verbose_name='Published')
+    expiration_date = models.DateField(blank=True, null=False, verbose_name='Published')
+    class Meta:
+        db_table = 'messages'
+

django_code/apps/telegram_communication/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

django_code/apps/telegram_communication/utils.py

@@ -0,0 +1,86 @@
+import os
+import requests
+from apps.bitwarden.utils import bitwardenUtils
+from .models import TelegramData
+from datetime import datetime, timedelta
+
+class telegramUtils():
+
+    token_uid = "a88dbe52-b862-422a-a116-b479009733ab"
+    chat_id_uid = "13e948ab-494a-4b09-bb3a-b47900974cef"
+    
+    __bitwarden_access_token = os.environ.get('bitwarden_access_token')
+    __bitwarden_organization_id = os.environ.get('bitwarden_organization_id')
+    
+    bw = bitwardenUtils(__bitwarden_access_token,__bitwarden_organization_id)
+    
+    __TOKEN = bw.read_value_secret(token_uid)
+    __CHAT_ID = bw.read_value_secret(chat_id_uid)
+    
+    
+    
+    def get_chat_id(self):
+        # Source - https://stackoverflow.com/a/75118239
+        # Posted by Yasantha Biyuranga, modified by community. See post 'Timeline' for change history
+        # Retrieved 2026-06-30, License - CC BY-SA 4.0
+    
+        url = f"https://api.telegram.org/bot{self.__TOKEN}/getUpdates"
+        print(requests.get(url).json())
+        return 0
+    
+    def send_message(self,message):
+        # Source - https://stackoverflow.com/a/75118239
+        # Posted by Yasantha Biyuranga, modified by community. See post 'Timeline' for change history
+        # Retrieved 2026-06-30, License - CC BY-SA 4.0
+    
+        url = f"https://api.telegram.org/bot{self.__TOKEN}/sendMessage?chat_id={self.__CHAT_ID}&text={message}"
+       
+        result = requests.get(url).json() # this sends the message
+        send_result = result['ok']
+        TelegramData.objects.create(message_id=result['result']['message_id'],chat_id=self.__CHAT_ID,description=message[0:99],creation_date=datetime.now(),expiration_date=datetime.now()+timedelta(days=1))
+        return send_result
+    
+    def send_document(self,file,message=''):
+        url = 'https://api.telegram.org/bot{}/sendDocument'.format(self.__TOKEN)
+        data = {'chat_id': self.__CHAT_ID ,'caption': message}
+        document = open(file, 'rb')
+        files = {'document': document}
+        response = requests.post(url, data=data, files=files)
+        result = response.json()
+        
+        #Create data , for the dercsription use a message of set , or use the filename , cut it to grab the end if the filename is more then 99 characters  
+        TelegramData.objects.create(message_id=result['result']['message_id'],chat_id=self.__CHAT_ID,description=message[0:99] or str(file)[-99:],creation_date=datetime.now(),expiration_date=datetime.now()+timedelta(days=1))
+        return result['ok'],result['result']['message_id'],result
+        
+        #example send_document('apps/Le_journal_10h00_du_30_06_2026.mp3')
+    
+    def delete_message(self,message_id_list):
+        send_result = []
+        for message_id in message_id_list:
+            url = f"https://api.telegram.org/bot{self.__TOKEN}/deleteMessage?chat_id={self.__CHAT_ID}&message_id={message_id}"
+            
+            result = requests.get(url).json()
+            send_result.append(["Message id: "+str(message_id),result['ok']])
+            if result['ok']:
+                message = TelegramData.objects.filter(message_id=message_id)
+                message.delete()
+        return send_result
+
+    def clear_expired_messages(self):
+        today = datetime.now()
+        #filter all the messages that expired yesterday or before
+        expired_messages_list = [] 
+        expired_messages = TelegramData.objects.filter(expiration_date__lte=today)
+        
+        #leave if the list is empty 
+        if len(expired_messages) == 0:
+            return 1
+        
+        #create a list with only the message_id
+        for expired_message in expired_messages:
+            expired_messages_list.append(expired_message.message_id)
+            
+        #run the delete query with the list created before    
+        result = self.delete_message(expired_messages_list)
+        return result[0]
+

django_code/apps/telegram_communication/views.py

@@ -0,0 +1,3 @@
+from django.shortcuts import render
+
+# Create your views here.

django_code/apps/website_redirection/admin.py

@@ -0,0 +1,25 @@
+from django.contrib import admin
+from .models import redirectData
+from .utils import redirect_method
+from import_export.admin import ImportExportModelAdmin
+
+# Register your models here.
+
+@admin.action(description="Add this episode back to its key")
+def re_redirect(modeladmin, request, queryset):
+    output_generated = ""
+    for query in queryset.values():
+        print(query)
+        key = query.get('key')
+        value = query.get('url')
+        output_generated = output_generated + redirect_method(key,value)+";"
+
+    modeladmin.message_user(
+        request,
+        output_generated
+        )
+
+@admin.register(redirectData)
+class redirectAdmin(ImportExportModelAdmin):
+    list_display = [field.name for field in redirectData._meta.fields if field.name != 'id']
+    actions = [re_redirect]

django_code/apps/website_redirection/apps.py

@@ -0,0 +1,11 @@
+import redis
+from django.http import HttpResponse
+from django.http import HttpResponseRedirect
+from django.shortcuts import render
+from django.apps import AppConfig
+
+
+class redirectConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.website_redirection'
+    label = 'redirect'

django_code/apps/website_redirection/migrations/0001_initial.py

@@ -0,0 +1,26 @@
+# Generated by Django 4.2.29 on 2026-06-22 20:21
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='redirectData',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('url', models.CharField(max_length=1000)),
+                ('addedDate', models.DateField(blank=True, null=True, verbose_name='Published')),
+                ('seenDate', models.DateField(blank=True, null=True, verbose_name='Published')),
+            ],
+            options={
+                'db_table': 'redirect',
+            },
+        ),
+    ]

django_code/apps/website_redirection/migrations/0002_alter_redirectdata_addeddate.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.29 on 2026-07-05 13:32
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('redirect', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='redirectdata',
+            name='addedDate',
+            field=models.DateField(auto_now_add=True, null=True, verbose_name='Published'),
+        ),
+    ]

django_code/apps/website_redirection/migrations/0003_redirectdata_key.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.29 on 2026-07-14 21:41
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('redirect', '0002_alter_redirectdata_addeddate'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='redirectdata',
+            name='key',
+            field=models.CharField(default='streaming', max_length=1000),
+        ),
+    ]

django_code/apps/website_redirection/models.py

@@ -0,0 +1,10 @@
+from django.db import models
+
+class redirectData(models.Model):
+    url = models.CharField(max_length=1000)
+    key = models.CharField(max_length=1000,default="streaming")
+    addedDate = models.DateField('Published', blank=True, null=True, auto_now_add=True)
+    seenDate = models.DateField('Published', blank=True, null=True)
+
+    class Meta:
+        db_table = 'redirect'