Add tests

feat(net-worth): display consolidated amounts for currencies without transactions

.env.example

@@ -1,6 +1,7 @@
 SERVER_NAME=wygiwyh_server
 DB_NAME=wygiwyh_pg
-PROCRASTINATE_NAME=wygiwyh_procrastinate
+
+TZ=UTC # Change to your timezone. This only affects some async tasks.
 
 DEBUG=false
 URL = https://...
@@ -9,6 +10,11 @@ SECRET_KEY=<GENERATE A SAFE SECRET KEY AND PLACE IT HERE>
 DJANGO_ALLOWED_HOSTS=localhost 127.0.0.1 [::1]
 OUTBOUND_PORT=9005
 
+# Uncomment these variables to automatically create an admin account using these credentials on startup.
+# After your first successfull login you can remove these variables from your file for safety reasons.
+#ADMIN_EMAIL=<ENTER YOUR EMAIL>
+#ADMIN_PASSWORD=<YOUR SAFE PASSWORD>
+
 SQL_DATABASE=wygiwyh
 SQL_USER=wygiwyh
 SQL_PASSWORD=<INSERT A SAFE PASSWORD HERE>
@@ -23,3 +29,5 @@ WEB_CONCURRENCY=4
 ENABLE_SOFT_DELETE=false
 # If ENABLE_SOFT_DELETE is true, transactions deleted for more than KEEP_DELETED_TRANSACTIONS_FOR days will be truly deleted. Set to 0 to keep all.
 KEEP_DELETED_TRANSACTIONS_FOR=365
+
+TASK_WORKERS=1 # This only work if you're using the single container option. Increase to have more open queues via procrastinate, you probably don't need to increase this.

.github/FUNDING.yml

@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+github: eitchtee
+custom: ["https://www.paypal.com/donate/?hosted_button_id=FFWM4W9NQDMM6"]

.github/workflows/release.yml

@@ -2,11 +2,28 @@ name: Release Pipeline
 
 on:
   release:
-    types: [created]
+    types: [ created ]
+  push:
+    branches: [ main ]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Custom tag name for the image'
+        required: true
+        type: string
+      ref:
+        description: 'Git ref to checkout (branch, tag, or SHA)'
+        required: true
+        default: 'main'
+        type: string
 
 env:
   IMAGE_NAME: wygiwyh
 
+concurrency:
+  group: release
+  cancel-in-progress: false
+
 jobs:
   build-and-push:
     runs-on: ubuntu-latest
@@ -16,6 +33,13 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.inputs.ref }}
+        if: github.event_name == 'workflow_dispatch'
+
+      - name: Checkout code (non-manual)
+        uses: actions/checkout@v4
+        if: github.event_name != 'workflow_dispatch'
 
       - name: Log in to Docker Hub
         uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1
@@ -29,16 +53,49 @@ jobs:
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
 
-      - name: Build and push image
+      - name: Build and push nightly image
+        if: github.event_name == 'push'
         uses: docker/build-push-action@v6
         with:
           context: .
           file: ./docker/prod/django/Dockerfile
           push: true
           provenance: false
+          build-args: |
+            VERSION=nightly
+          tags: ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.IMAGE_NAME }}:nightly
+          platforms: linux/amd64,linux/arm64
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Build and push release image
+        if: github.event_name == 'release'
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./docker/prod/django/Dockerfile
+          push: true
+          provenance: false
+          build-args: |
+            VERSION=${{ github.event.release.tag_name }}
           tags: |
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.IMAGE_NAME }}:latest
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.IMAGE_NAME }}:${{ github.event.release.tag_name }}
           platforms: linux/amd64,linux/arm64
           cache-from: type=gha
           cache-to: type=gha,mode=max
+
+      - name: Build and push custom image
+        if: github.event_name == 'workflow_dispatch'
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./docker/prod/django/Dockerfile
+          push: true
+          provenance: false
+          build-args: |
+            VERSION=${{ github.event.inputs.tag }}
+          tags: ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.IMAGE_NAME }}:${{ github.event.inputs.tag }}
+          platforms: linux/amd64,linux/arm64
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/translations.yml

@@ -0,0 +1,72 @@
+name: Django Translation Update
+
+on:
+  push:
+    branches: [ main ]
+  # Add manual trigger
+  workflow_dispatch:
+    inputs:
+      reason:
+        description: 'Reason for running'
+        required: false
+        default: 'Manual update of translation files'
+
+# Ensure only one translation job runs at a time
+concurrency:
+  group: django-translations
+  cancel-in-progress: false
+
+jobs:
+  update-translations:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    # Skip on PRs from forks (which don't have write permissions)
+    # Allow manual runs and pushes to main
+    if: github.event_name == 'workflow_dispatch' || github.event_name == 'push' || (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository)
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.PAT }}
+          ref: ${{ github.head_ref }}
+
+      - name: Set up Python 3.11
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.11'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+
+      - name: Install gettext
+        run: sudo apt-get install -y gettext
+
+      - name: Run makemessages
+        run: |
+          cd app
+          python manage.py makemessages -a
+
+      - name: Check for changes
+        id: check_changes
+        run: |
+          if git diff --exit-code --quiet app/locale/; then
+            echo "No translation changes detected"
+          else
+            echo "changes_detected=true" >> $GITHUB_OUTPUT
+            echo "Translation changes detected"
+          fi
+
+      - name: Commit translation files
+        if: steps.check_changes.outputs.changes_detected == 'true'
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          push_options: --force
+          commit_message: |
+            chore(locale): update translation files
+            
+            [skip ci] Automatically generated by Django makemessages workflow
+          file_pattern: "app/locale/**/*.po"

README.md

@@ -13,6 +13,7 @@
   <a href="#key-features">Features</a> •
   <a href="#how-to-use">Usage</a> •
   <a href="#how-it-works">How</a> •
+  <a href="#help-us-translate-wygiwyh">Translate</a> •
   <a href="#caveats-and-warnings">Caveats and Warnings</a> •
   <a href="#built-with">Built with</a>
 </p>
@@ -50,6 +51,17 @@ Frustrated by the lack of comprehensive options, I set out to build **WYGIWYH**
 * **Built-in Dollar-Cost Average (DCA) tracker**: Essential for tracking recurring investments, especially for crypto and stocks.
 * **API support for automation**: Seamlessly integrate with existing services to synchronize transactions.
 
+# Demo
+
+You can try WYGIWYH on [wygiwyh-demo.herculino.com](https://wygiwyh-demo.herculino.com/) with the credentials below:
+
+> [!NOTE]
+> E-mail: `demo@demo.com`
+> 
+> Password: `wygiwyhdemo`
+
+Keep in mind that **any data you add will be wiped in 24 hours or less**. And that **most automation features like the API, Rules, Automatic Exchange Rates and Import/Export are disabled**.
+
 # How To Use
 
 To run this application, you'll need [Docker](https://docs.docker.com/engine/install/) with [docker-compose](https://docs.docker.com/compose/install/).
@@ -75,10 +87,13 @@ $ nano .env # or any other editor you want to use
 # Run the app
 $ docker compose up -d
 
-# Create the first admin account
+# Create the first admin account. This isn't required if you set the enviroment variables: ADMIN_EMAIL and ADMIN_PASSWORD.
 $ docker compose exec -it web python manage.py createsuperuser
 ```
 
+> [!NOTE]
+> If you're using Unraid, you don't need to follow these steps, use the app on the store. Make sure to read the [Unraid section](#unraid) and [Environment Variables](#environment-variables) for an explanation of all available variables
+
 ## Running locally
 
 If you want to run WYGIWYH locally, on your env file:
@@ -90,471 +105,57 @@ If you want to run WYGIWYH locally, on your env file:
 You can now access localhost:OUTBOUND_PORT
 
 > [!NOTE]
-> If you're planning on running this behind Tailscale or other similar service also add your machine given IP to `DJANGO_ALLOWED_HOSTS`
-
-> [!NOTE]
-> If you're going to use another IP that isn't localhost, add it to `DJANGO_ALLOWED_HOSTS`, without `http://`
+> - If you're planning on running this behind Tailscale or other similar service also add your machine given IP to `DJANGO_ALLOWED_HOSTS`
+> - If you're going to use another IP that isn't localhost, add it to `DJANGO_ALLOWED_HOSTS`, without `http://`
 
 
-## Building from source
+## Latest changes
+Features are only added to `main` when ready, if you want to run the latest version, you must build from source or use the `:nightly` tag on docker. Keep in mind that there can be undocumented breaking changes.
 
-Features are only added to `main` when ready, if you want to run the latest version, you must build from source.
+All the required Dockerfiles are [here](https://github.com/eitchtee/WYGIWYH/tree/main/docker/prod).
 
-```bash
-# Create a folder for WYGIWYH (optional)
-$ mkdir WYGIWYH
+## Unraid
 
-# Go into the folder
-$ cd WYGIWYH
+[nwithan8](https://github.com/nwithan8) has kindly provided a Unraid template for WYGIWYH, have a look at the [unraid_templates](https://github.com/nwithan8/unraid_templates) repo.
 
-# Clone this repository
-$ git clone https://github.com/eitchtee/WYGIWYH.git .
+WYGIWYH is available on the Unraid Store. You'll need to provision your own postgres (version 15 or up) database.
 
-$ cp docker-compose.prod.yml docker-compose.yml
-$ cp .env.example .env
-# Now edit both files as you see fit
+To create the first user, open the container's console using Unraid's UI, by clicking on WYGIWYH icon on the Docker page and selecting `Console`, then type `python manage.py createsuperuser`, you'll them be prompted to input your e-mail and password.
 
-# Run the app
-$ docker compose up -d --build
+## Environment Variables
 
-# Create the first admin account
-$ docker compose exec -it web python manage.py createsuperuser
-```
+| variable                      | type        | default                           | explanation                                                                                                                                                                                                                              |
+|-------------------------------|-------------|-----------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| DJANGO_ALLOWED_HOSTS          | string      | localhost 127.0.0.1               | A list of space separated domains and IPs representing the host/domain names that WYGIWYH site can serve. [Click here](https://docs.djangoproject.com/en/5.1/ref/settings/#allowed-hosts) for more details                               |
+| HTTPS_ENABLED                 | true\|false | false                             | Whether to use secure cookies. If this is set to true, the cookie will be marked as “secure”, which means browsers may ensure that the cookie is only sent under an HTTPS connection                                                     |
+| URL                           | string      | http://localhost http://127.0.0.1 | A list of space separated domains and IPs (with the protocol) representing the trusted origins for unsafe requests (e.g. POST). [Click here](https://docs.djangoproject.com/en/5.1/ref/settings/#csrf-trusted-origins ) for more details |
+| SECRET_KEY                    | string      | ""                                | This is used to provide cryptographic signing, and should be set to a unique, unpredictable value.                                                                                                                                       |
+| DEBUG                         | true\|false | false                             | Turns DEBUG mode on or off, this is useful to gather more data about possible errors you're having. Don't use in production.                                                                                                             |
+| SQL_DATABASE                  | string      | None *required                    | The name of your postgres database                                                                                                                                                                                                       |
+| SQL_USER                      | string      | user                              | The username used to connect to your postgres database                                                                                                                                                                                   |
+| SQL_PASSWORD                  | string      | password                          | The password used to connect to your postgres database                                                                                                                                                                                   |
+| SQL_HOST                      | string      | localhost                         | The address used to connect to your postgres database                                                                                                                                                                                    |
+| SQL_PORT                      | string      | 5432                              | The port used to connect to your postgres database                                                                                                                                                                                       |
+| SESSION_EXPIRY_TIME           | int         | 2678400 (31 days)                 | The age of session cookies, in seconds. E.g. how long you will stay logged in                                                                                                                                                            |
+| ENABLE_SOFT_DELETE            | true\|false | false                             | Whether to enable transactions soft delete, if enabled, deleted transactions will remain in the database. Useful for imports and avoiding duplicate entries.                                                                             |
+| KEEP_DELETED_TRANSACTIONS_FOR | int         | 365                               | Time in days to keep soft deleted transactions for. If 0, will keep all transactions indefinitely. Only works if ENABLE_SOFT_DELETE is true.                                                                                             |
+| TASK_WORKERS                  | int         | 1                                 | How many workers to have for async tasks. One should be enough for most use cases                                                                                                                                                        |
+| DEMO                          | true\|false         | false                             | If demo mode is enabled.                                                                                                                                                                                                                 |
+| ADMIN_EMAIL                   | string         | None                              | Automatically creates an admin account with this email. Must have `ADMIN_PASSWORD` also set.                                                                                                                                             |
+| ADMIN_PASSWORD                | string         | None                              | Automatically creates an admin account with this password. Must have `ADMIN_EMAIL` also set.                                                                                                                                             |
 
 # How it works
 
-## Models
+Check out our [Wiki](https://github.com/eitchtee/WYGIWYH/wiki) for more information.
 
-### Transactions
-
-Transactions are the core feature of WYGIWYH, representing expenses or income in your accounts. Each transaction consists of the following fields:
-
-#### Type
-
-- **Income**: A positive amount entering your account
-- **Expense**: A negative amount exiting your account
-
-#### Paid Status
-
-A transaction can be either:
-
-- **Current**: When marked as paid
-- **Projected**: When marked as unpaid
-
-#### Account
-
-The account associated with the transaction. Required, limited to one account per transaction.
-
-#### Entity
-
-The party involved in the transaction:
-
-- For **Income**: The paying entity
-- For **Expense**: The receiving entity
-
-Optional field.
-
-#### Date
-
-The date when the transaction occurred. Required.
-
-#### Reference Date
-
-One of **WYGIWYH**'s key features. The reference date determines which month a transaction should count towards. For example, you can have a transaction that occurred on January 26th count towards February's finances.
-
-Optional - defaults to the transaction date's month if not specified.
-
-> [!CAUTION]
-> While designed primarily for credit card closing dates, this feature allows for debt rolling across months. Use responsibly to maintain accurate financial tracking.
-
-#### Type
-
-- Income, meaning a positive amount (usually) entering your account
-- Expense, meaning a negative amount exiting your account
-
-#### Description
-
-The name or purpose of the transaction. Required.
-
-#### Amount
-
-The monetary value of the transaction. Required.
-
-#### Category
-
-The primary classification of the transaction. Optional.
-
-#### Tags
-
-Additional labels for transaction categorization. Optional.
-
-#### Notes
-
-Additional information about the transaction. Optional.
-
-![img_4.png](.github/img/readme_transaction.png)
-
-### Installment Plan
-
-An Installment Plan is a helper model that generates a series of recurring transactions over a fixed period.
-
-#### Core Fields
-
-- **Account**: The account for all transactions in the plan. Required.
-- **Entity**: The paying or receiving party for all transactions. Optional.
-- **Description**: The name of the installment plan, used for all transactions. Required.
-- **Notes**: Additional information applied to all transactions. Optional.
-
-#### Installment Configuration
-
-- **Number of Installments**: Total number of transactions to create (e.g., 1/10, 2/10)
-- **Installment Start**: Initial counting point
-- **Start Date**: Date of the first transaction
-- **Reference Date**: Reference date for the first transaction
-- **Recurrence**: Frequency of transactions (e.g., Monthly)
-
-![img_1.png](.github/img/readme_installment_plan.png)
-
-### Transaction Details
-
-- **Amount**: Value for each transaction. Required.
-- **Category**: Primary classification for all transactions. Optional.
-- **Tags**: Labels applied to all transactions. Optional.
-
-### Recurring Transaction
-A Recurring Transaction is a helper model that generates recurring transactions indefinitely or until a certain date.
-
-#### Core Fields
-
-- **Account**: The account for all transactions in the plan. Required.
-- **Entity**: The paying or receiving party for all transactions. Optional.
-- **Description**: The name of the recurring transaction, used for all transactions. Required.
-- **Notes**: Additional information applied to all transactions. Optional.
-
-#### Recurring Transaction Configuration
-
-- **Start Date**: Date of the first transaction. Required.
-- **Reference Date**: Reference date for the first transaction. Optional.
-- **Recurrence Type**: Frequency of transactions (e.g., Monthly). Required.
-- **Recurrence Interval**: The interval between transactions (e.g. every 1 month, every 2 weeks, etc.). Required.
-- **End date**: When new transactions should stop being created. Optional.
-
-#### Transaction Details
-
-- **Amount**: Value for each transaction. Required.
-- **Category**: Primary classification for all transactions. Optional.
-- **Tags**: Labels applied to all transactions. Optional.
-
-#### Other information
-
-- Recurring transactions are checked and created every midnight using Procrastinate.
-- **WYGIWYH** tries to keep at most **6** future transactions created at any time.
-- If you delete a recurring transaction it will not be recreated.
-- You can stop or pause a recurring transaction at any time on the config page (/recurring-trasanctions/)
-
-![img_3.png](.github/img/readme_recurring_transaction.png)
-
-### Account
-
-Accounts represent different financial entities where transactions occur. They have the following attributes:
-
-- **Name**: A unique identifier for the account.
-- **Group**: An optional [account group](#account-groups) the account belongs to for organizational purposes.
-- **Currency**: The primary [currency](#currency) of the account.
-- **Exchange Currency**: An optional currency used for exchange rate calculations.
-- **Is Asset**: A boolean indicating if the account is considered an asset (counts towards net worth).
-- **Is Archived**: A boolean indicating if the account is archived (doesn't show up in active lists or count towards net worth).
-
-### Account Groups
-
-Account Groups are used to organize accounts into logical categories. They consist of:
-
-- **Name**: A unique identifier for the group.
-
-### Currency
-
-Currencies represent different monetary units. They include:
-
-* **Code**: A unique identifier for the currency (e.g., USD, EUR).
-* **Name**: The full name of the currency.
-* **Decimal Place**: The number of decimal places used for the currency.
-* **Prefix**: An optional symbol or text that comes before the amount.
-* **Suffix**: An optional symbol or text that comes after the amount.
-
-### Exchange Rate
-
-Exchange Rates store conversion rates between currencies:
-
-* **From Currency**: The source currency.
-* **To Currency**: The target currency.
-* **Rate**: The conversion rate.
-* **Date**: The date the rate was recorded or is valid for.
-
-### Category
-
-Categories are used to classify transactions:
-
-* **Name**: A unique identifier for the category.
-* **Muted**: Muted categories won't count towards your monthly total.
-* **Active**: A boolean indicating if the category is currently in use. This will disable its use on new transactions.
-
-### Tag
-
-Tags provide additional labeling for transactions:
-
-* **Name**: A unique identifier for the tag.
-* **Active**: A boolean indicating if the category is currently in use. This will disable its use on new transactions.
-
-### Entity
-
-Entities represent parties involved in transactions:
-
-* **Name**: A unique identifier for the entity.
-* **Active**: A boolean indicating if the entity is currently in use. This will disable its use on new transactions.
-
----
-
-## Helper actions
-
-### Transfer
-
-A transfer happens when you move a monetary value from one account to another. This will create two transactions, one expense and one income with the values set by the user.
-
-Contrary to other finance trackers, due to our multi-currency support, **WYGIWYH**'s transfer system allows for non-zero transfers.
-
-![img.png](.github/img/readme_transfer.png)
-
-### Balance (Account Reconciliation)
-
-A balance is a easy way of updating your accounts balance. It creates a transaction with the difference between the balance currently in **WYGIWYH** and the new balance informed by you.
-
-This can be useful for savings accounts or other interest accruing investments.![img_2.png](.github/img/readme_balance.png)
-
----
-
-## Views
-
-### Monthly
-
-The Monthly view provides an overview of your financial activity for a specific month. It includes:
-
-* Total income and expenses for the month
-* Daily spending allowance calculation
-* List of transactions for the month
+# Help us translate WYGIWYH!
+<a href="https://translations.herculino.com/engage/wygiwyh/">
+<img src="https://translations.herculino.com/widget/wygiwyh/open-graph.png" alt="Translation status" />
+</a>
 
 > [!NOTE]
-> Reference dates are taken into account here.
+> Login with your github account
 
-### Yearly by currency
-
-This view gives you a yearly summary of your finances grouped by currency. It shows:
-
-* Total income and expenses for each currency
-* Monthly breakdown of income and expenses
-
-### Yearly by account
-
-Similar to the [yearly by currency](#yearly-by-currency) view, but groups the data by account instead.
-
-### Calendar
-
-The Calendar view presents your transactions in a monthly calendar format, allowing you to see your financial activity day by day. It includes:
-
-* Visual representation of daily transaction totals
-* Ability to view details of transactions for each day
-
-> [!NOTE]
-> Reference dates are **not** taken into account here.
-
-### Networh
-
-#### Current
-
-The Current Net Worth view shows your present financial standing, including:
-
-* Total value of all asset accounts
-* Breakdown of assets by account and currency
-* Historical net worth trend
-
-#### Projected
-
-The Projected Net Worth view estimates your future financial position based on current data and recurring transactions. It includes:
-
-* Your total net worth with projected and current transactions
-* Breakdown of assets by account and currency
-* Historical and future net worth trend
-
-### All Transactions
-
-This view provides a comprehensive list of all transactions across all accounts. Features include:
-
-* Advanced filtering and sorting options
-* Detailed information
-
-You can use this to see how much you spent on a given category, or a given day, etc..
-
-### Configuration and Management
-
-#### Management
-The Management section in the navbar allows you to add and edit most elements of WYGIWYH, including:
-
-* Accounts and Groups
-* Currencies and Exchange Rates
-* Categories, Tags and Entities
-* Rules
-
-#### User Settings
-
-WYGIWYH allows users to personalize their experience through customizable settings. Each user can configure:
-
-* **Language**: Choose your preferred interface language.
-* **Timezone**: Set your local timezone for accurate date and time display.
-* **Start Page**: Select which page you want to see first when you log in.
-* **Sound Preferences**: Toggle sound effects on or off.
-* **Amount Display**: Choose to show or hide monetary amounts by default.
-
-To access and modify these settings:
-
-1. Click on your username in the top-right corner of the page.
-2. Select "Settings" from the dropdown menu.
-3. Adjust your preferences as desired.
-4. Click "Save" to apply your changes.
-
-These settings ensure that WYGIWYH adapts to your personal preferences and working style.
-
-#### Django Admin
-From here you can also access Django's own admin site.
-
-> [!WARNING]
-> Most side effects aren't triggered from the admin.
-> Only use it if you know what you're doing or were told by a developer to do so.
-
----
-
-## Tools
-
-### Calculator
-
-The calculator is a floating widget that can be toggled by clicking the calculator icon on the navbar or by pressing <kbd>Alt</kbd> + <kbd>C</kbd> on any page.
-
-It allows for any math expression supported by [math.js](https://mathjs.org).
-
-![calculator](.github/img/readme_calculator.gif)
-
-### Dollar Cost Average Tracker
-
-The DCA Tracker can be accessed from the navbar's **Tools** menu.
-
-It allows for tracking DCA strategies and getting helpful information and insights.
-
-> [!IMPORTANT]
-> Currently DCA exists separately from your main transactions. You will need to add your entries manually.
-
-<img src=".github/img/readme_dca_1.png" width="45%"></img> <img src=".github/img/readme_dca_2.png" width="45%"></img>
-
-### Unit Price Calculator
-
-The Unit Price Calculator can be accessed from the navbar's **Tools** menu.
-
-This is a self-contained tool for comparing and finding the most cost-efficient item quickly and easily.
-
-Input the price and the amount of each item, the cheapeast will be highlighted in green, and the most expensive in red.
-
-You can add additional items by clicking the _Add_ button at the end of the page.
-
-> [!NOTE]
-> This doesn't do unit convertion. The amount of all items needs to be on the same the unit for proper functioning.
-
-![img.png](.github/img/readme_unit_price_calculator.png)
-
-### Currency Converter
-
-The Currency Converter is a tool that allows you to quickly convert amounts between different currencies.
-
-> [!NOTE]
-> There's no external Exchange Rate fetching. This uses the Exchange Rates configured in the [Management](#configuration-and-management) page for [Exchange Rates](#exchange-rate)
-
-## Automation
-
-### API
-
-WYGIWYH has a comprehensive API, it's documentation can be accessed on `<your-wygiwyh-url>/api/docs/`
-
-> [!NOTE]
-> While the API works, there's still much to be added to it to equipare functionality with the main web app.
-
-### Transaction Rules
-
-Transaction Rules are a powerful feature in WYGIWYH that allow for automatic modification of transactions based on specified criteria. This can save time and ensure consistency in your financial tracking.
-
-Key Aspects of Transaction Rules:
-
-* **Conditions**: Set specific criteria that a transaction must meet for the rule to apply. This can include attributes like description, amount, account, etc.
-* **Actions**: Define what changes should be made to a transaction when the conditions are met. This can include setting categories, tags, or modifying other fields.
-* **Activation Options**: Rules can be set to apply when transactions are created, updated, or both.
-
-#### Actions and Conditions
-
-When creating a new rule, you will need to add a Condition and, later, Actions.
-
-Both use a limited subset of Python, via [SimpleEval](https://github.com/danthedeckie/simpleeval).
-
-The Condition must evaluate to True or False, and the Action must evaluate to a value that will be set on the selected field.
-
-You may use any of the available [variables](#available-variables) and [functions](#available-functions).
-
-#### Available variables
-
-* `account_name`
-* `account_id`
-* `account_group_name`
-* `account_group_id`
-* `is_asset_account`
-* `is_archived_account`
-* `category_name`
-* `category_id`
-* `tag_names`
-* `tag_ids`
-* `entities_names`
-* `entities_ids`
-* `is_expense`
-* `is_income`
-* `is_paid`
-* `description`
-* `amount`
-* `notes`
-* `date`
-* `reference_date`
-
-#### Available functions
-
-* `relativedelta`
-
-#### Examples
-
-Add a tag to an income transaction if it happens in a specific account
-
-```
-If...
-account_name == "My Investing Account" and is_income
-
-Then...
-Set Tags to
-tag_names + ["Yield"]
-```
-
----
-
-Move credit card transactions to next month when they happen at a cutoff date
-
-```
-If...
-account_name == "My credit card" and date.day >= 26 and reference_date.month == date.month
-
-Then...
-Set Reference Date to
-reference_date + relativedelta(months=1)).replace(day=1)
-```
 # Caveats and Warnings
 
 - I'm not an accountant, some terms and even calculations might be wrong. Make sure to open an issue if you see anything that could be improved.

app/WYGIWYH/settings.py

@@ -31,10 +31,8 @@ SECRET_KEY = os.getenv("SECRET_KEY", "")
 # SECURITY WARNING: don't run with debug turned on in production!
 DEBUG = os.getenv("DEBUG", "false").lower() == "true"
 
-ALLOWED_HOSTS = os.environ.get("DJANGO_ALLOWED_HOSTS", "localhost 127.0.0.1").split(" ")
-CSRF_TRUSTED_ORIGINS = os.environ.get("URL", "http://localhost http://127.0.0.1").split(
-    " "
-)
+ALLOWED_HOSTS = os.getenv("DJANGO_ALLOWED_HOSTS", "localhost 127.0.0.1").split(" ")
+CSRF_TRUSTED_ORIGINS = os.getenv("URL", "http://localhost http://127.0.0.1").split(" ")
 
 # Application definition
 
@@ -57,6 +55,7 @@ INSTALLED_APPS = [
     "hijack",
     "hijack.contrib.admin",
     "django_filters",
+    "import_export",
     "apps.users.apps.UsersConfig",
     "procrastinate.contrib.django",
     "apps.transactions.apps.TransactionsConfig",
@@ -65,6 +64,7 @@ INSTALLED_APPS = [
     "apps.common.apps.CommonConfig",
     "apps.net_worth.apps.NetWorthConfig",
     "apps.import_app.apps.ImportConfig",
+    "apps.export_app.apps.ExportConfig",
     "apps.api.apps.ApiConfig",
     "cachalot",
     "rest_framework",
@@ -77,6 +77,8 @@ INSTALLED_APPS = [
 ]
 
 MIDDLEWARE = [
+    "django_browser_reload.middleware.BrowserReloadMiddleware",
+    "apps.common.middleware.thread_local.ThreadLocalMiddleware",
     "debug_toolbar.middleware.DebugToolbarMiddleware",
     "django.middleware.security.SecurityMiddleware",
     "whitenoise.middleware.WhiteNoiseMiddleware",
@@ -88,7 +90,6 @@ MIDDLEWARE = [
     "apps.common.middleware.localization.LocalizationMiddleware",
     "django.contrib.messages.middleware.MessageMiddleware",
     "django.middleware.clickjacking.XFrameOptionsMiddleware",
-    "django_browser_reload.middleware.BrowserReloadMiddleware",
     "hijack.middleware.HijackUserMiddleware",
 ]
 
@@ -127,11 +128,11 @@ WSGI_APPLICATION = "WYGIWYH.wsgi.application"
 DATABASES = {
     "default": {
         "ENGINE": "django.db.backends.postgresql",
-        "NAME": os.environ.get("SQL_DATABASE"),
-        "USER": os.environ.get("SQL_USER", "user"),
-        "PASSWORD": os.environ.get("SQL_PASSWORD", "password"),
-        "HOST": os.environ.get("SQL_HOST", "localhost"),
-        "PORT": os.environ.get("SQL_PORT", "5432"),
+        "NAME": os.getenv("SQL_DATABASE"),
+        "USER": os.getenv("SQL_USER", "user"),
+        "PASSWORD": os.getenv("SQL_PASSWORD", "password"),
+        "HOST": os.getenv("SQL_HOST", "localhost"),
+        "PORT": os.getenv("SQL_PORT", "5432"),
     }
 }
 
@@ -162,12 +163,108 @@ AUTH_USER_MODEL = "users.User"
 
 LANGUAGE_CODE = "en"
 LANGUAGES = (
+    ("af", "Afrikaans"),
+    ("ar", "العربية"),
+    ("ar-dz", "العربية (الجزائر)"),  # Algerian Arabic often uses the base name + region
+    ("ast", "Asturianu"),
+    ("az", "Azərbaycan"),
+    ("bg", "Български"),
+    ("be", "Беларуская"),
+    ("bn", "বাংলা"),
+    ("br", "Brezhoneg"),
+    ("bs", "Bosanski"),
+    ("ca", "Català"),
+    ("ckb", "کوردیی ناوەندی"),  # Central Kurdish (Sorani)
+    ("cs", "Čeština"),
+    ("cy", "Cymraeg"),
+    ("da", "Dansk"),
+    ("de", "Deutsch"),
+    ("dsb", "Dolnoserbšćina"),
+    ("el", "Ελληνικά"),
     ("en", "English"),
+    ("en-au", "English (Australia)"),
+    ("en-gb", "English (UK)"),
+    ("eo", "Esperanto"),
+    ("es", "Español"),
+    ("es-ar", "Español (Argentina)"),
+    ("es-co", "Español (Colombia)"),
+    ("es-mx", "Español (México)"),
+    ("es-ni", "Español (Nicaragua)"),
+    ("es-ve", "Español (Venezuela)"),
+    ("et", "Eesti"),
+    ("eu", "Euskara"),
+    ("fa", "فارسی"),
+    ("fi", "Suomi"),
+    ("fr", "Français"),
+    ("fy", "Frysk"),
+    ("ga", "Gaeilge"),
+    ("gd", "Gàidhlig"),
+    ("gl", "Galego"),
+    ("he", "עברית"),
+    ("hi", "हिन्दी"),
+    ("hr", "Hrvatski"),
+    ("hsb", "Hornjoserbšćina"),
+    ("hu", "Magyar"),
+    ("hy", "Հայերեն"),
+    ("ia", "Interlingua"),
+    ("id", "Bahasa Indonesia"),
+    ("ig", "Igbo"),
+    ("io", "Ido"),
+    ("is", "Íslenska"),
+    ("it", "Italiano"),
+    ("ja", "日本語"),
+    ("ka", "ქართული"),
+    ("kab", "Taqbaylit"),
+    ("kk", "Қазақша"),
+    ("km", "ខ្មែរ"),
+    ("kn", "ಕನ್ನಡ"),
+    ("ko", "한국어"),
+    ("ky", "Кыргызча"),
+    ("lb", "Lëtzebuergesch"),
+    ("lt", "Lietuvių"),
+    ("lv", "Latviešu"),
+    ("mk", "Македонски"),
+    ("ml", "മലയാളം"),
+    ("mn", "Монгол"),
+    ("mr", "मराठी"),
+    ("ms", "Bahasa Melayu"),
+    ("my", "မြန်မာဘာသာ"),
+    ("nb", "Norsk (Bokmål)"),
+    ("ne", "नेपाली"),
     ("nl", "Nederlands"),
+    ("nn", "Norsk (Nynorsk)"),
+    ("os", "Ирон"),  # Ossetic
+    ("pa", "ਪੰਜਾਬੀ"),
+    ("pl", "Polski"),
+    ("pt", "Português"),
     ("pt-br", "Português (Brasil)"),
+    ("ro", "Română"),
+    ("ru", "Русский"),
+    ("sk", "Slovenčina"),
+    ("sl", "Slovenščina"),
+    ("sq", "Shqip"),
+    ("sr", "Српски"),
+    ("sr-latn", "Srpski (Latinica)"),
+    ("sv", "Svenska"),
+    ("sw", "Kiswahili"),
+    ("ta", "தமிழ்"),
+    ("te", "తెలుగు"),
+    ("tg", "Тоҷикӣ"),
+    ("th", "ไทย"),
+    ("tk", "Türkmençe"),
+    ("tr", "Türkçe"),
+    ("tt", "Татарча"),
+    ("udm", "Удмурт"),
+    ("ug", "ئۇيغۇرچە"),
+    ("uk", "Українська"),
+    ("ur", "اردو"),
+    ("uz", "Oʻzbekcha"),
+    ("vi", "Tiếng Việt"),
+    ("zh-hans", "简体中文"),
+    ("zh-hant", "繁體中文"),
 )
 
-TIME_ZONE = "UTC"
+TIME_ZONE = os.getenv("TZ", "UTC")
 
 USE_I18N = True
 
@@ -221,7 +318,7 @@ SESSION_COOKIE_SECURE = os.getenv("HTTPS_ENABLED", "false").lower() == "true"
 
 DEBUG_TOOLBAR_CONFIG = {
     "ROOT_TAG_EXTRA_ATTRS": "hx-preserve",
-    "SHOW_TOOLBAR_CALLBACK": lambda r: False,  # disables it}
+    # "SHOW_TOOLBAR_CALLBACK": lambda r: False,  # disables it
 }
 DEBUG_TOOLBAR_PANELS = [
     "debug_toolbar.panels.history.HistoryPanel",
@@ -259,7 +356,10 @@ if DEBUG:
 REST_FRAMEWORK = {
     # Use Django's standard `django.contrib.auth` permissions,
     # or allow read-only access for unauthenticated users.
-    "DEFAULT_PERMISSION_CLASSES": ["rest_framework.permissions.DjangoModelPermissions"],
+    "DEFAULT_PERMISSION_CLASSES": [
+        "apps.api.permissions.NotInDemoMode",
+        "rest_framework.permissions.DjangoModelPermissions",
+    ],
     "DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.PageNumberPagination",
     "PAGE_SIZE": 10,
     "DEFAULT_SCHEMA_CLASS": "drf_spectacular.openapi.AutoSchema",
@@ -278,29 +378,32 @@ if "procrastinate" in sys.argv:
         "version": 1,
         "disable_existing_loggers": False,
         "formatters": {
-            "procrastinate": {
-                "format": "%(asctime)s %(levelname)-7s %(name)s %(message)s"
+            "standard": {
+                "format": "[%(asctime)s] - %(levelname)s - %(name)s - %(message)s",
+                "datefmt": "%Y-%m-%d %H:%M:%S",
             },
         },
         "handlers": {
             "procrastinate": {
-                "level": "DEBUG",
+                "level": "INFO",
                 "class": "logging.StreamHandler",
-                "formatter": "procrastinate",
+                "formatter": "standard",
             },
             "console": {
                 "class": "logging.StreamHandler",
+                "formatter": "standard",
+                "level": "INFO",
             },
         },
         "loggers": {
             "procrastinate": {
                 "handlers": ["procrastinate"],
-                "level": "INFO",
                 "propagate": False,
             },
             "root": {
                 "handlers": ["console"],
                 "level": "INFO",
+                "propagate": False,
             },
         },
     }
@@ -309,24 +412,25 @@ else:
         "version": 1,
         "disable_existing_loggers": False,
         "formatters": {
-            "procrastinate": {
-                "format": "%(asctime)s %(levelname)-7s %(name)s %(message)s"
+            "standard": {
+                "format": "[%(asctime)s] - %(levelname)s - %(name)s - %(message)s",
+                "datefmt": "%Y-%m-%d %H:%M:%S",
             },
         },
         "handlers": {
-            "procrastinate": {
-                "level": "DEBUG",
-                "class": "logging.StreamHandler",
-                "formatter": "procrastinate",
-            },
             "console": {
                 "class": "logging.StreamHandler",
+                "formatter": "standard",
+                "level": "INFO",
+            },
+            "procrastinate": {
+                "level": "INFO",
+                "class": "logging.StreamHandler",
             },
         },
         "loggers": {
             "procrastinate": {
                 "handlers": None,
-                "level": "INFO",
                 "propagate": False,
             },
             "root": {
@@ -387,3 +491,5 @@ PWA_SERVICE_WORKER_PATH = BASE_DIR / "templates" / "pwa" / "serviceworker.js"
 
 ENABLE_SOFT_DELETE = os.getenv("ENABLE_SOFT_DELETE", "false").lower() == "true"
 KEEP_DELETED_TRANSACTIONS_FOR = int(os.getenv("KEEP_DELETED_ENTRIES_FOR", "365"))
+APP_VERSION = os.getenv("APP_VERSION", "unknown")
+DEMO = os.getenv("DEMO", "false").lower() == "true"

app/WYGIWYH/urls.py

@@ -49,4 +49,6 @@ urlpatterns = [
     path("", include("apps.dca.urls")),
     path("", include("apps.mini_tools.urls")),
     path("", include("apps.import_app.urls")),
+    path("", include("apps.export_app.urls")),
+    path("", include("apps.insights.urls")),
 ]

app/apps/accounts/admin.py

@@ -1,6 +1,14 @@
 from django.contrib import admin
 
-from apps.accounts.models import Account
+from apps.accounts.models import Account, AccountGroup
+from apps.common.admin import SharedObjectModelAdmin
 
 
-admin.site.register(Account)
+@admin.register(Account)
+class AccountModelAdmin(SharedObjectModelAdmin):
+    pass
+
+
+@admin.register(AccountGroup)
+class AccountGroupModelAdmin(SharedObjectModelAdmin):
+    pass

app/apps/accounts/forms.py

@@ -77,6 +77,8 @@ class AccountForm(forms.ModelForm):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
+        self.fields["group"].queryset = AccountGroup.objects.all()
+
         self.helper = FormHelper()
         self.helper.form_tag = False
         self.helper.form_method = "post"
@@ -151,5 +153,11 @@ class AccountBalanceForm(forms.Form):
             decimal_places=self.currency_decimal_places
         )
 
+        self.fields["category"].queryset = TransactionCategory.objects.filter(
+            active=True
+        )
+
+        self.fields["tags"].queryset = TransactionTag.objects.filter(active=True)
+
 
 AccountBalanceFormSet = forms.formset_factory(AccountBalanceForm, extra=0)

app/apps/accounts/migrations/0009_account_owner_account_shared_with_accountgroup_owner.py

@@ -0,0 +1,31 @@
+# Generated by Django 5.1.6 on 2025-03-04 15:07
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('accounts', '0008_alter_account_name'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='account',
+            name='owner',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='owned_accounts', to=settings.AUTH_USER_MODEL, verbose_name='Owner'),
+        ),
+        migrations.AddField(
+            model_name='account',
+            name='shared_with',
+            field=models.ManyToManyField(blank=True, related_name='shared_accounts', to=settings.AUTH_USER_MODEL, verbose_name='Shared With'),
+        ),
+        migrations.AddField(
+            model_name='accountgroup',
+            name='owner',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='owned_account_groups', to=settings.AUTH_USER_MODEL, verbose_name='Owner'),
+        ),
+    ]

app/apps/accounts/migrations/0010_alter_account_managers_alter_accountgroup_managers_and_more.py

@@ -0,0 +1,46 @@
+# Generated by Django 5.1.6 on 2025-03-05 02:42
+
+import django.db.models.manager
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('accounts', '0009_account_owner_account_shared_with_accountgroup_owner'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AlterModelManagers(
+            name='account',
+            managers=[
+                ('all_objects', django.db.models.manager.Manager()),
+            ],
+        ),
+        migrations.AlterModelManagers(
+            name='accountgroup',
+            managers=[
+                ('all_objects', django.db.models.manager.Manager()),
+            ],
+        ),
+        migrations.AlterField(
+            model_name='account',
+            name='name',
+            field=models.CharField(max_length=255, verbose_name='Name'),
+        ),
+        migrations.AlterField(
+            model_name='accountgroup',
+            name='name',
+            field=models.CharField(max_length=255, verbose_name='Name'),
+        ),
+        migrations.AlterUniqueTogether(
+            name='account',
+            unique_together={('owner', 'name')},
+        ),
+        migrations.AlterUniqueTogether(
+            name='accountgroup',
+            unique_together={('owner', 'name')},
+        ),
+    ]

app/apps/accounts/migrations/0011_alter_account_owner_alter_accountgroup_owner.py

@@ -0,0 +1,26 @@
+# Generated by Django 5.1.6 on 2025-03-05 04:19
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('accounts', '0010_alter_account_managers_alter_accountgroup_managers_and_more'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='account',
+            name='owner',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='owned_accounts', to=settings.AUTH_USER_MODEL, verbose_name='Owner'),
+        ),
+        migrations.AlterField(
+            model_name='accountgroup',
+            name='owner',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='owned_account_groups', to=settings.AUTH_USER_MODEL, verbose_name='Owner'),
+        ),
+    ]

app/apps/accounts/migrations/0012_alter_account_managers_alter_accountgroup_managers_and_more.py

@@ -0,0 +1,56 @@
+# Generated by Django 5.1.6 on 2025-03-05 23:46
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('accounts', '0011_alter_account_owner_alter_accountgroup_owner'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AlterModelManagers(
+            name='account',
+            managers=[
+            ],
+        ),
+        migrations.AlterModelManagers(
+            name='accountgroup',
+            managers=[
+            ],
+        ),
+        migrations.AddField(
+            model_name='account',
+            name='visibility',
+            field=models.CharField(choices=[('private', 'Private'), ('shared', 'Shared'), ('public', 'Public')], default='private', max_length=10),
+        ),
+        migrations.AddField(
+            model_name='accountgroup',
+            name='shared_with',
+            field=models.ManyToManyField(blank=True, related_name='%(class)s_shared', to=settings.AUTH_USER_MODEL),
+        ),
+        migrations.AddField(
+            model_name='accountgroup',
+            name='visibility',
+            field=models.CharField(choices=[('private', 'Private'), ('shared', 'Shared'), ('public', 'Public')], default='private', max_length=10),
+        ),
+        migrations.AlterField(
+            model_name='account',
+            name='owner',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='%(class)s_owned', to=settings.AUTH_USER_MODEL),
+        ),
+        migrations.AlterField(
+            model_name='account',
+            name='shared_with',
+            field=models.ManyToManyField(blank=True, related_name='%(class)s_shared', to=settings.AUTH_USER_MODEL),
+        ),
+        migrations.AlterField(
+            model_name='accountgroup',
+            name='owner',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='%(class)s_owned', to=settings.AUTH_USER_MODEL),
+        ),
+    ]

app/apps/accounts/migrations/0013_alter_account_visibility_and_more.py

@@ -0,0 +1,23 @@
+# Generated by Django 5.1.6 on 2025-03-06 01:47
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('accounts', '0012_alter_account_managers_alter_accountgroup_managers_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='account',
+            name='visibility',
+            field=models.CharField(choices=[('private', 'Private'), ('public', 'Public')], default='private', max_length=10),
+        ),
+        migrations.AlterField(
+            model_name='accountgroup',
+            name='visibility',
+            field=models.CharField(choices=[('private', 'Private'), ('public', 'Public')], default='private', max_length=10),
+        ),
+    ]

app/apps/accounts/migrations/0014_alter_account_options_alter_accountgroup_options.py

@@ -0,0 +1,21 @@
+# Generated by Django 5.1.7 on 2025-03-09 21:54
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('accounts', '0013_alter_account_visibility_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='account',
+            options={'ordering': ['name', 'id'], 'verbose_name': 'Account', 'verbose_name_plural': 'Accounts'},
+        ),
+        migrations.AlterModelOptions(
+            name='accountgroup',
+            options={'ordering': ['name', 'id'], 'verbose_name': 'Account Group', 'verbose_name_plural': 'Account Groups'},
+        ),
+    ]

app/apps/accounts/models.py

@@ -1,24 +1,32 @@
+from django.conf import settings
 from django.core.exceptions import ValidationError
 from django.db import models
+from django.db.models import Q
 from django.utils.translation import gettext_lazy as _
 
 from apps.transactions.models import Transaction
+from apps.common.models import SharedObject, SharedObjectManager
 
 
-class AccountGroup(models.Model):
-    name = models.CharField(max_length=255, verbose_name=_("Name"), unique=True)
+class AccountGroup(SharedObject):
+    name = models.CharField(max_length=255, verbose_name=_("Name"))
+
+    objects = SharedObjectManager()
+    all_objects = models.Manager()  # Unfiltered manager
 
     class Meta:
         verbose_name = _("Account Group")
         verbose_name_plural = _("Account Groups")
         db_table = "account_groups"
+        unique_together = (("owner", "name"),)
+        ordering = ["name", "id"]
 
     def __str__(self):
         return self.name
 
 
-class Account(models.Model):
-    name = models.CharField(max_length=255, verbose_name=_("Name"), unique=True)
+class Account(SharedObject):
+    name = models.CharField(max_length=255, verbose_name=_("Name"))
     group = models.ForeignKey(
         AccountGroup,
         on_delete=models.SET_NULL,
@@ -55,9 +63,14 @@ class Account(models.Model):
         help_text=_("Archived accounts don't show up nor count towards your net worth"),
     )
 
+    objects = SharedObjectManager()
+    all_objects = models.Manager()  # Unfiltered manager
+
     class Meta:
         verbose_name = _("Account")
         verbose_name_plural = _("Accounts")
+        unique_together = (("owner", "name"),)
+        ordering = ["name", "id"]
 
     def __str__(self):
         return self.name

app/apps/accounts/tests.py

@@ -1,19 +1,33 @@
-from django.test import TestCase
+from django.test import TestCase, Client
+from django.core.exceptions import ValidationError
+from django.contrib.auth.models import User
+from django.db import IntegrityError, models
+from django.utils import timezone
+from django.urls import reverse
+from decimal import Decimal
 
 from apps.accounts.models import Account, AccountGroup
 from apps.currencies.models import Currency
+from apps.accounts.forms import AccountForm
+from apps.transactions.models import Transaction, TransactionCategory
 
 
 class AccountTests(TestCase):
     def setUp(self):
         """Set up test data"""
+        self.owner1 = User.objects.create_user(username='testowner', password='password123')
+        self.client = Client()
+        self.client.login(username='testowner', password='password123')
+
         self.currency = Currency.objects.create(
             code="USD", name="US Dollar", decimal_places=2, prefix="$ "
         )
-        self.exchange_currency = Currency.objects.create(
+        self.eur = Currency.objects.create(
             code="EUR", name="Euro", decimal_places=2, prefix="€ "
         )
-        self.account_group = AccountGroup.objects.create(name="Test Group")
+        self.account_group = AccountGroup.objects.create(name="Test Group", owner=self.owner1)
+        self.reconciliation_category = TransactionCategory.objects.create(name='Reconciliation', owner=self.owner1, type='INFO')
+
 
     def test_account_creation(self):
         """Test basic account creation"""
@@ -35,7 +49,262 @@ class AccountTests(TestCase):
         """Test account creation with exchange currency"""
         account = Account.objects.create(
             name="Exchange Account",
+            owner=self.owner1, # Added owner
+            group=self.account_group, # Added group
             currency=self.currency,
-            exchange_currency=self.exchange_currency,
+            exchange_currency=self.eur, # Changed to self.eur
         )
-        self.assertEqual(account.exchange_currency, self.exchange_currency)
+        self.assertEqual(account.exchange_currency, self.eur) # Changed to self.eur
+
+    def test_account_archiving(self):
+        """Test archiving and unarchiving an account"""
+        account = Account.objects.create(
+            name="Archivable Account",
+            owner=self.owner1, # Added owner
+            group=self.account_group,
+            currency=self.currency,
+            is_asset=True, # Assuming default, can be anything for this test
+            is_archived=False,
+        )
+        self.assertFalse(account.is_archived, "Account should initially be unarchived")
+
+        # Archive the account
+        account.is_archived = True
+        account.save()
+
+        archived_account = Account.objects.get(pk=account.pk)
+        self.assertTrue(archived_account.is_archived, "Account should be archived")
+
+        # Unarchive the account
+        archived_account.is_archived = False
+        archived_account.save()
+
+        unarchived_account = Account.objects.get(pk=account.pk)
+        self.assertFalse(unarchived_account.is_archived, "Account should be unarchived")
+
+    def test_account_exchange_currency_cannot_be_same_as_currency(self):
+        """Test that exchange_currency cannot be the same as currency."""
+        with self.assertRaises(ValidationError) as cm:
+            account = Account(
+                name="Same Currency Account",
+                owner=self.owner1, # Added owner
+                group=self.account_group,
+                currency=self.currency,
+                exchange_currency=self.currency,  # Same as currency
+            )
+            account.full_clean()
+        self.assertIn('exchange_currency', cm.exception.error_dict)
+        # To check for a specific message (optional, might make test brittle):
+        # self.assertTrue(any("cannot be the same as the main currency" in e.message
+        #                     for e in cm.exception.error_dict['exchange_currency']))
+
+    def test_account_name_unique_per_owner(self):
+        """Test that account name is unique per owner."""
+        owner1 = User.objects.create_user(username='owner1', password='password123')
+        owner2 = User.objects.create_user(username='owner2', password='password123')
+
+        # Initial account for self.owner1 (owner1 from setUp)
+        Account.objects.create(
+            name="Unique Name Test",
+            owner=self.owner1, # Changed to self.owner1
+            group=self.account_group,
+            currency=self.currency,
+        )
+
+        # Attempt to create another account with the same name and self.owner1 - should fail
+        with self.assertRaises(IntegrityError):
+            Account.objects.create(
+                name="Unique Name Test",
+                owner=self.owner1, # Changed to self.owner1
+                group=self.account_group,
+                currency=self.currency,
+            )
+
+        # Create account with the same name but for owner2 - should succeed
+        try:
+            Account.objects.create(
+                name="Unique Name Test",
+                owner=owner2, # owner2 is locally defined here, that's fine for this test
+                group=self.account_group,
+                currency=self.currency,
+            )
+        except IntegrityError:
+            self.fail("Creating account with same name but different owner failed unexpectedly.")
+
+        # Create account with a different name for self.owner1 - should succeed
+        try:
+            Account.objects.create(
+                name="Another Name Test",
+                owner=self.owner1, # Changed to self.owner1
+                group=self.account_group,
+                currency=self.currency,
+            )
+        except IntegrityError:
+            self.fail("Creating account with different name for the same owner failed unexpectedly.")
+
+    def test_account_form_valid_data(self):
+        """Test AccountForm with valid data."""
+        form_data = {
+            'name': 'Form Test Account',
+            'group': self.account_group.pk,
+            'currency': self.currency.pk,
+            'exchange_currency': self.eur.pk,
+            'is_asset': True,
+            'is_archived': False,
+            'description': 'A valid test account from form.'
+        }
+        form = AccountForm(data=form_data)
+        self.assertTrue(form.is_valid(), form.errors.as_text())
+
+        account = form.save(commit=False)
+        account.owner = self.owner1
+        account.save()
+
+        self.assertEqual(account.name, 'Form Test Account')
+        self.assertEqual(account.owner, self.owner1)
+        self.assertEqual(account.group, self.account_group)
+        self.assertEqual(account.currency, self.currency)
+        self.assertEqual(account.exchange_currency, self.eur)
+        self.assertTrue(account.is_asset)
+        self.assertFalse(account.is_archived)
+
+    def test_account_form_missing_name(self):
+        """Test AccountForm with missing name."""
+        form_data = {
+            'group': self.account_group.pk,
+            'currency': self.currency.pk,
+        }
+        form = AccountForm(data=form_data)
+        self.assertFalse(form.is_valid())
+        self.assertIn('name', form.errors)
+
+    def test_account_form_exchange_currency_same_as_currency(self):
+        """Test AccountForm where exchange_currency is the same as currency."""
+        form_data = {
+            'name': 'Same Currency Form Account',
+            'group': self.account_group.pk,
+            'currency': self.currency.pk,
+            'exchange_currency': self.currency.pk,  # Same as currency
+        }
+        form = AccountForm(data=form_data)
+        self.assertFalse(form.is_valid())
+        self.assertIn('exchange_currency', form.errors)
+
+
+class AccountGroupTests(TestCase):
+    def setUp(self):
+        """Set up test data for AccountGroup tests."""
+        self.owner1 = User.objects.create_user(username='groupowner1', password='password123')
+        self.owner2 = User.objects.create_user(username='groupowner2', password='password123')
+
+    def test_account_group_creation(self):
+        """Test basic AccountGroup creation."""
+        group = AccountGroup.objects.create(name="Test Group", owner=self.owner1)
+        self.assertEqual(group.name, "Test Group")
+        self.assertEqual(group.owner, self.owner1)
+        self.assertEqual(str(group), "Test Group") # Assuming __str__ returns the name
+
+    def test_account_group_name_unique_per_owner(self):
+        """Test that AccountGroup name is unique per owner."""
+        # Initial group for owner1
+        AccountGroup.objects.create(name="Unique Group Name", owner=self.owner1)
+
+        # Attempt to create another group with the same name and owner1 - should fail
+        with self.assertRaises(IntegrityError):
+            AccountGroup.objects.create(name="Unique Group Name", owner=self.owner1)
+
+        # Create group with the same name but for owner2 - should succeed
+        try:
+            AccountGroup.objects.create(name="Unique Group Name", owner=self.owner2)
+        except IntegrityError:
+            self.fail("Creating group with same name but different owner failed unexpectedly.")
+
+        # Create group with a different name for owner1 - should succeed
+        try:
+            AccountGroup.objects.create(name="Another Group Name", owner=self.owner1)
+        except IntegrityError:
+            self.fail("Creating group with different name for the same owner failed unexpectedly.")
+
+    def test_account_reconciliation_creates_transaction(self):
+        """Test that account_reconciliation view creates a transaction for the difference."""
+
+        # Helper function to get balance
+        def get_balance(account):
+            balance = account.transactions.filter(is_paid=True).aggregate(
+                total_income=models.Sum('amount', filter=models.Q(type=Transaction.Type.INCOME)),
+                total_expense=models.Sum('amount', filter=models.Q(type=Transaction.Type.EXPENSE)),
+                total_transfer_in=models.Sum('amount', filter=models.Q(type=Transaction.Type.TRANSFER, transfer_to_account=account)),
+                total_transfer_out=models.Sum('amount', filter=models.Q(type=Transaction.Type.TRANSFER, account=account))
+            )['total_income'] or Decimal('0.00')
+            balance -= account.transactions.filter(is_paid=True).aggregate(
+                total_expense=models.Sum('amount', filter=models.Q(type=Transaction.Type.EXPENSE))
+            )['total_expense'] or Decimal('0.00')
+            # For transfers, a more complete logic might be needed if transfers are involved in reconciliation scope
+            return balance
+
+        account_usd = Account.objects.create(
+            name="USD Account for Recon",
+            owner=self.owner1,
+            currency=self.currency,
+            group=self.account_group
+        )
+        account_eur = Account.objects.create(
+            name="EUR Account for Recon",
+            owner=self.owner1,
+            currency=self.eur,
+            group=self.account_group
+        )
+
+        # Initial transactions
+        Transaction.objects.create(account=account_usd, type=Transaction.Type.INCOME, amount=Decimal('100.00'), date=timezone.localdate(timezone.now()), description='Initial USD', category=self.reconciliation_category, owner=self.owner1, is_paid=True)
+        Transaction.objects.create(account=account_eur, type=Transaction.Type.INCOME, amount=Decimal('200.00'), date=timezone.localdate(timezone.now()), description='Initial EUR', category=self.reconciliation_category, owner=self.owner1, is_paid=True)
+        Transaction.objects.create(account=account_eur, type=Transaction.Type.EXPENSE, amount=Decimal('50.00'), date=timezone.localdate(timezone.now()), description='EUR Expense', category=self.reconciliation_category, owner=self.owner1, is_paid=True)
+
+        initial_usd_balance = get_balance(account_usd) # Should be 100.00
+        initial_eur_balance = get_balance(account_eur) # Should be 150.00
+        self.assertEqual(initial_usd_balance, Decimal('100.00'))
+        self.assertEqual(initial_eur_balance, Decimal('150.00'))
+
+        initial_transaction_count = Transaction.objects.filter(owner=self.owner1).count() # Should be 3
+
+        formset_data = {
+            'form-TOTAL_FORMS': '2',
+            'form-INITIAL_FORMS': '2', # Based on view logic, it builds initial data for all accounts
+            'form-MAX_NUM_FORMS': '', # Can be empty or a number >= TOTAL_FORMS
+            'form-0-account_id': account_usd.id,
+            'form-0-new_balance': '120.00', # New balance for USD account (implies +20 adjustment)
+            'form-0-category': self.reconciliation_category.id,
+            'form-1-account_id': account_eur.id,
+            'form-1-new_balance': '150.00', # Same as current balance for EUR account (no adjustment)
+            'form-1-category': self.reconciliation_category.id,
+        }
+
+        response = self.client.post(
+            reverse('accounts:account_reconciliation'),
+            data=formset_data,
+            HTTP_HX_REQUEST='true' # Required if view uses @only_htmx
+        )
+
+        self.assertEqual(response.status_code, 204, response.content.decode()) # 204 No Content for successful HTMX POST
+
+        # Check that only one new transaction was created
+        self.assertEqual(Transaction.objects.filter(owner=self.owner1).count(), initial_transaction_count + 1)
+
+        # Get the newly created transaction
+        new_transaction = Transaction.objects.filter(
+            account=account_usd,
+            description="Balance reconciliation"
+        ).first()
+
+        self.assertIsNotNone(new_transaction)
+        self.assertEqual(new_transaction.type, Transaction.Type.INCOME)
+        self.assertEqual(new_transaction.amount, Decimal('20.00'))
+        self.assertEqual(new_transaction.category, self.reconciliation_category)
+        self.assertEqual(new_transaction.owner, self.owner1)
+        self.assertTrue(new_transaction.is_paid)
+        self.assertEqual(new_transaction.date, timezone.localdate(timezone.now()))
+
+
+        # Verify final balances
+        self.assertEqual(get_balance(account_usd), Decimal('120.00'))
+        self.assertEqual(get_balance(account_eur), Decimal('150.00'))

app/apps/accounts/urls.py

@@ -16,11 +16,21 @@ urlpatterns = [
         views.account_edit,
         name="account_edit",
     ),
+    path(
+        "account/<int:pk>/share/",
+        views.account_share,
+        name="account_share_settings",
+    ),
     path(
         "account/<int:pk>/delete/",
         views.account_delete,
         name="account_delete",
     ),
+    path(
+        "account/<int:pk>/take-ownership/",
+        views.account_take_ownership,
+        name="account_take_ownership",
+    ),
     path("account-groups/", views.account_groups_index, name="account_groups_index"),
     path("account-groups/list/", views.account_groups_list, name="account_groups_list"),
     path("account-groups/add/", views.account_group_add, name="account_group_add"),
@@ -34,4 +44,14 @@ urlpatterns = [
         views.account_group_delete,
         name="account_group_delete",
     ),
+    path(
+        "account-groups/<int:pk>/take-ownership/",
+        views.account_group_take_ownership,
+        name="account_group_take_ownership",
+    ),
+    path(
+        "account-groups/<int:pk>/share/",
+        views.account_group_share,
+        name="account_group_share_settings",
+    ),
 ]

app/apps/accounts/views/account_groups.py

@@ -8,6 +8,8 @@ from django.views.decorators.http import require_http_methods
 from apps.accounts.forms import AccountGroupForm
 from apps.accounts.models import AccountGroup
 from apps.common.decorators.htmx import only_htmx
+from apps.common.models import SharedObject
+from apps.common.forms import SharedObjectForm
 
 
 @login_required
@@ -63,6 +65,16 @@ def account_group_add(request, **kwargs):
 def account_group_edit(request, pk):
     account_group = get_object_or_404(AccountGroup, id=pk)
 
+    if account_group.owner and account_group.owner != request.user:
+        messages.error(request, _("Only the owner can edit this"))
+
+        return HttpResponse(
+            status=204,
+            headers={
+                "HX-Trigger": "updated, hide_offcanvas",
+            },
+        )
+
     if request.method == "POST":
         form = AccountGroupForm(request.POST, instance=account_group)
         if form.is_valid():
@@ -91,9 +103,15 @@ def account_group_edit(request, pk):
 def account_group_delete(request, pk):
     account_group = get_object_or_404(AccountGroup, id=pk)
 
-    account_group.delete()
-
-    messages.success(request, _("Account Group deleted successfully"))
+    if (
+        account_group.owner != request.user
+        and request.user in account_group.shared_with.all()
+    ):
+        account_group.shared_with.remove(request.user)
+        messages.success(request, _("Item no longer shared with you"))
+    else:
+        account_group.delete()
+        messages.success(request, _("Account Group deleted successfully"))
 
     return HttpResponse(
         status=204,
@@ -101,3 +119,62 @@ def account_group_delete(request, pk):
             "HX-Trigger": "updated, hide_offcanvas",
         },
     )
+
+
+@only_htmx
+@login_required
+@require_http_methods(["GET"])
+def account_group_take_ownership(request, pk):
+    account_group = get_object_or_404(AccountGroup, id=pk)
+
+    if not account_group.owner:
+        account_group.owner = request.user
+        account_group.visibility = SharedObject.Visibility.private
+        account_group.save()
+
+        messages.success(request, _("Ownership taken successfully"))
+
+    return HttpResponse(
+        status=204,
+        headers={
+            "HX-Trigger": "updated, hide_offcanvas",
+        },
+    )
+
+
+@only_htmx
+@login_required
+@require_http_methods(["GET", "POST"])
+def account_group_share(request, pk):
+    obj = get_object_or_404(AccountGroup, id=pk)
+
+    if obj.owner and obj.owner != request.user:
+        messages.error(request, _("Only the owner can edit this"))
+
+        return HttpResponse(
+            status=204,
+            headers={
+                "HX-Trigger": "updated, hide_offcanvas",
+            },
+        )
+
+    if request.method == "POST":
+        form = SharedObjectForm(request.POST, instance=obj, user=request.user)
+        if form.is_valid():
+            form.save()
+            messages.success(request, _("Configuration saved successfully"))
+
+            return HttpResponse(
+                status=204,
+                headers={
+                    "HX-Trigger": "updated, hide_offcanvas",
+                },
+            )
+    else:
+        form = SharedObjectForm(instance=obj, user=request.user)
+
+    return render(
+        request,
+        "accounts/fragments/share.html",
+        {"form": form, "object": obj},
+    )

app/apps/accounts/views/accounts.py

@@ -8,6 +8,8 @@ from django.views.decorators.http import require_http_methods
 from apps.accounts.forms import AccountForm
 from apps.accounts.models import Account
 from apps.common.decorators.htmx import only_htmx
+from apps.common.models import SharedObject
+from apps.common.forms import SharedObjectForm
 
 
 @login_required
@@ -62,6 +64,15 @@ def account_add(request, **kwargs):
 @require_http_methods(["GET", "POST"])
 def account_edit(request, pk):
     account = get_object_or_404(Account, id=pk)
+    if account.owner and account.owner != request.user:
+        messages.error(request, _("Only the owner can edit this"))
+
+        return HttpResponse(
+            status=204,
+            headers={
+                "HX-Trigger": "updated, hide_offcanvas",
+            },
+        )
 
     if request.method == "POST":
         form = AccountForm(request.POST, instance=account)
@@ -85,15 +96,77 @@ def account_edit(request, pk):
     )
 
 
+@only_htmx
+@login_required
+@require_http_methods(["GET", "POST"])
+def account_share(request, pk):
+    obj = get_object_or_404(Account, id=pk)
+
+    if obj.owner and obj.owner != request.user:
+        messages.error(request, _("Only the owner can edit this"))
+
+        return HttpResponse(
+            status=204,
+            headers={
+                "HX-Trigger": "updated, hide_offcanvas",
+            },
+        )
+
+    if request.method == "POST":
+        form = SharedObjectForm(request.POST, instance=obj, user=request.user)
+        if form.is_valid():
+            form.save()
+            messages.success(request, _("Configuration saved successfully"))
+
+            return HttpResponse(
+                status=204,
+                headers={
+                    "HX-Trigger": "updated, hide_offcanvas",
+                },
+            )
+    else:
+        form = SharedObjectForm(instance=obj, user=request.user)
+
+    return render(
+        request,
+        "accounts/fragments/share.html",
+        {"form": form, "object": obj},
+    )
+
+
 @only_htmx
 @login_required
 @require_http_methods(["DELETE"])
 def account_delete(request, pk):
     account = get_object_or_404(Account, id=pk)
 
-    account.delete()
-
-    messages.success(request, _("Account deleted successfully"))
+    if account.owner != request.user and request.user in account.shared_with.all():
+        account.shared_with.remove(request.user)
+        messages.success(request, _("Item no longer shared with you"))
+    else:
+        account.delete()
+        messages.success(request, _("Account deleted successfully"))
+
+    return HttpResponse(
+        status=204,
+        headers={
+            "HX-Trigger": "updated, hide_offcanvas",
+        },
+    )
+
+
+@only_htmx
+@login_required
+@require_http_methods(["GET"])
+def account_take_ownership(request, pk):
+    account = get_object_or_404(Account, id=pk)
+
+    if not account.owner:
+        account.owner = request.user
+        account.visibility = SharedObject.Visibility.private
+        account.save()
+
+        messages.success(request, _("Ownership taken successfully"))
 
     return HttpResponse(
         status=204,

app/apps/accounts/views/balance.py

@@ -38,9 +38,9 @@ def account_reconciliation(request):
             "prefix": account.currency.prefix,
             "current_balance": get_account_balance(account),
         }
-        for account in Account.objects.filter(is_archived=False).select_related(
-            "currency", "group"
-        )
+        for account in Account.objects.filter(is_archived=False)
+        .select_related("currency", "group")
+        .order_by("group", "name")
     ]
 
     if request.method == "POST":

app/apps/api/custom/pagination.py

@@ -0,0 +1,6 @@
+from rest_framework.pagination import PageNumberPagination
+
+
+class CustomPageNumberPagination(PageNumberPagination):
+    page_size = 100
+    page_size_query_param = "page_size"

app/apps/api/fields/transactions.py

@@ -1,8 +1,6 @@
-from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema_field
 from rest_framework import serializers
 from django.utils.translation import gettext_lazy as _
-
 from apps.transactions.models import (
     TransactionCategory,
     TransactionTag,
@@ -29,7 +27,11 @@ class TransactionCategoryField(serializers.Field):
                     _("Category with this ID does not exist.")
                 )
         elif isinstance(data, str):
-            category, created = TransactionCategory.objects.get_or_create(name=data)
+            try:
+                category = TransactionCategory.objects.get(name=data)
+            except TransactionCategory.DoesNotExist:
+                category = TransactionCategory(name=data)
+                category.save()
             return category
         raise serializers.ValidationError(
             _("Invalid category data. Provide an ID or name.")
@@ -39,7 +41,10 @@ class TransactionCategoryField(serializers.Field):
     def get_schema():
         return {
             "type": "array",
-            "items": {"type": "string", "description": "TransactionTag ID or name"},
+            "items": {
+                "type": "string",
+                "description": "TransactionCategory ID or name",
+            },
         }
 
 
@@ -65,7 +70,11 @@ class TransactionTagField(serializers.Field):
                         _("Tag with this ID does not exist.")
                     )
             elif isinstance(item, str):
-                tag, created = TransactionTag.objects.get_or_create(name=item)
+                try:
+                    tag = TransactionTag.objects.get(name=item)
+                except TransactionTag.DoesNotExist:
+                    tag = TransactionTag(name=item)
+                    tag.save()
             else:
                 raise serializers.ValidationError(
                     _("Invalid tag data. Provide an ID or name.")
@@ -74,6 +83,13 @@ class TransactionTagField(serializers.Field):
         return tags
 
 
+@extend_schema_field(
+    {
+        "type": "array",
+        "items": {"oneOf": [{"type": "string"}, {"type": "integer"}]},
+        "description": "TransactionEntity ID or name. If the name doesn't exist, a new one will be created",
+    }
+)
 class TransactionEntityField(serializers.Field):
     def to_representation(self, value):
         return [{"id": entity.id, "name": entity.name} for entity in value.all()]
@@ -84,12 +100,16 @@ class TransactionEntityField(serializers.Field):
             if isinstance(item, int):
                 try:
                     entity = TransactionEntity.objects.get(pk=item)
-                except TransactionTag.DoesNotExist:
+                except TransactionEntity.DoesNotExist:
                     raise serializers.ValidationError(
                         _("Entity with this ID does not exist.")
                     )
             elif isinstance(item, str):
-                entity, created = TransactionEntity.objects.get_or_create(name=item)
+                try:
+                    entity = TransactionEntity.objects.get(name=item)
+                except TransactionEntity.DoesNotExist:
+                    entity = TransactionEntity(name=item)
+                    entity.save()
             else:
                 raise serializers.ValidationError(
                     _("Invalid entity data. Provide an ID or name.")

app/apps/api/permissions.py

@@ -0,0 +1,10 @@
+from rest_framework.permissions import BasePermission
+from django.conf import settings
+
+
+class NotInDemoMode(BasePermission):
+    def has_permission(self, request, view):
+        if settings.DEMO and not request.user.is_superuser:
+            return False
+        else:
+            return True

app/apps/api/serializers/accounts.py

@@ -1,3 +1,4 @@
+from django.db.models import Q
 from rest_framework import serializers
 from rest_framework.permissions import IsAuthenticated
 
@@ -22,6 +23,7 @@ class AccountSerializer(serializers.ModelSerializer):
         write_only=True,
         allow_null=True,
     )
+
     currency = CurrencySerializer(read_only=True)
     currency_id = serializers.PrimaryKeyRelatedField(
         queryset=Currency.objects.all(), source="currency", write_only=True
@@ -50,6 +52,13 @@ class AccountSerializer(serializers.ModelSerializer):
             "is_asset",
         ]
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        request = self.context.get("request")
+        if request and request.user.is_authenticated:
+            # Reload the queryset to get an updated version with the requesting user
+            self.fields["group_id"].queryset = AccountGroup.objects.all()
+
     def create(self, validated_data):
         return Account.objects.create(**validated_data)
 

app/apps/api/serializers/transactions.py

@@ -1,3 +1,5 @@
+from decimal import Decimal
+
 from django.utils.translation import gettext_lazy as _
 from drf_spectacular import openapi
 from drf_spectacular.types import OpenApiTypes
@@ -21,6 +23,7 @@ from apps.transactions.models import (
     TransactionEntity,
     RecurringTransaction,
 )
+from apps.common.middleware.thread_local import get_current_user
 
 
 class TransactionCategorySerializer(serializers.ModelSerializer):
@@ -29,6 +32,10 @@ class TransactionCategorySerializer(serializers.ModelSerializer):
     class Meta:
         model = TransactionCategory
         fields = "__all__"
+        read_only_fields = [
+            "id",
+            "owner",
+        ]
 
 
 class TransactionTagSerializer(serializers.ModelSerializer):
@@ -37,6 +44,10 @@ class TransactionTagSerializer(serializers.ModelSerializer):
     class Meta:
         model = TransactionTag
         fields = "__all__"
+        read_only_fields = [
+            "id",
+            "owner",
+        ]
 
 
 class TransactionEntitySerializer(serializers.ModelSerializer):
@@ -45,12 +56,16 @@ class TransactionEntitySerializer(serializers.ModelSerializer):
     class Meta:
         model = TransactionEntity
         fields = "__all__"
+        read_only_fields = [
+            "id",
+            "owner",
+        ]
 
 
 class InstallmentPlanSerializer(serializers.ModelSerializer):
-    category = TransactionCategoryField(required=False)
-    tags = TransactionTagField(required=False)
-    entities = TransactionEntityField(required=False)
+    category: str | int = TransactionCategoryField(required=False)
+    tags: str | int = TransactionTagField(required=False)
+    entities: str | int = TransactionEntityField(required=False)
 
     permission_classes = [IsAuthenticated]
 
@@ -88,9 +103,9 @@ class InstallmentPlanSerializer(serializers.ModelSerializer):
 
 
 class RecurringTransactionSerializer(serializers.ModelSerializer):
-    category = TransactionCategoryField(required=False)
-    tags = TransactionTagField(required=False)
-    entities = TransactionEntityField(required=False)
+    category: str | int = TransactionCategoryField(required=False)
+    tags: str | int = TransactionTagField(required=False)
+    entities: str | int = TransactionEntityField(required=False)
 
     class Meta:
         model = RecurringTransaction
@@ -127,9 +142,9 @@ class RecurringTransactionSerializer(serializers.ModelSerializer):
 
 
 class TransactionSerializer(serializers.ModelSerializer):
-    category = TransactionCategoryField(required=False)
-    tags = TransactionTagField(required=False)
-    entities = TransactionEntityField(required=False)
+    category: str | int = TransactionCategoryField(required=False)
+    tags: str | int = TransactionTagField(required=False)
+    entities: str | int = TransactionEntityField(required=False)
 
     exchanged_amount = serializers.SerializerMethodField()
 
@@ -155,8 +170,16 @@ class TransactionSerializer(serializers.ModelSerializer):
             "installment_plan",
             "recurring_transaction",
             "installment_id",
+            "owner",
+            "deleted_at",
+            "deleted",
         ]
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.fields["account_id"].queryset = Account.objects.all()
+
     def validate(self, data):
         if not self.partial:
             if "date" in data and "reference_date" not in data:
@@ -192,5 +215,5 @@ class TransactionSerializer(serializers.ModelSerializer):
         return instance
 
     @staticmethod
-    def get_exchanged_amount(obj):
+    def get_exchanged_amount(obj) -> Decimal:
         return obj.exchanged_amount()

app/apps/api/tests.py

@@ -0,0 +1,124 @@
+from django.test import TestCase
+from django.contrib.auth.models import User
+from rest_framework.test import APIClient
+from django.urls import reverse
+from datetime import date
+from decimal import Decimal
+from unittest.mock import patch
+
+from apps.accounts.models import Account, AccountGroup # Added AccountGroup
+from apps.currencies.models import Currency
+from apps.transactions.models import TransactionCategory, Transaction
+from apps.rules.signals import transaction_created # Assuming this is the correct path
+
+# Default page size for pagination, adjust if your project's default is different
+DEFAULT_PAGE_SIZE = 10
+
+class APITestCase(TestCase):
+    def setUp(self):
+        self.user = User.objects.create_user(username='testuser', email='test@example.com', password='testpassword')
+        self.client = APIClient()
+        self.client.force_authenticate(user=self.user)
+
+        self.currency = Currency.objects.create(code="USD", name="US Dollar Test API", decimal_places=2)
+        # Account model requires an AccountGroup
+        self.account_group = AccountGroup.objects.create(name="API Test Group", owner=self.user)
+        self.account = Account.objects.create(
+            name="Test API Account",
+            currency=self.currency,
+            owner=self.user,
+            group=self.account_group
+        )
+        self.category = TransactionCategory.objects.create(
+            name="Test API Category",
+            owner=self.user,
+            type=TransactionCategory.TransactionType.EXPENSE # Default type, can be adjusted
+        )
+        # Remove the example test if it's no longer needed or update it
+        # self.assertEqual(1 + 1, 2) # from test_example
+
+    def test_transactions_endpoint_authenticated_user(self):
+        # User and client are now set up in self.setUp
+        url = reverse('api:transaction-list') # Using 'api:' namespace
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, 200)
+
+    @patch('apps.rules.signals.transaction_created.send')
+    def test_create_transaction_api_success(self, mock_signal_send):
+        url = reverse('api:transaction-list')
+        data = {
+            'account': self.account.pk, # Changed from account_id to account to match typical DRF serializer field names
+            'type': Transaction.Type.EXPENSE.value, # Use enum value
+            'date': date(2023, 1, 15).isoformat(),
+            'amount': '123.45',
+            'description': 'API Test Expense',
+            'category': self.category.pk,
+            'tags': [],
+            'entities': []
+        }
+
+        initial_transaction_count = Transaction.objects.count()
+        response = self.client.post(url, data, format='json')
+
+        self.assertEqual(response.status_code, 201, response.data) # Print response.data on failure
+        self.assertEqual(Transaction.objects.count(), initial_transaction_count + 1)
+
+        created_transaction = Transaction.objects.latest('id') # Get the latest transaction
+
+        self.assertEqual(created_transaction.description, 'API Test Expense')
+        self.assertEqual(created_transaction.amount, Decimal('123.45'))
+        self.assertEqual(created_transaction.owner, self.user)
+        self.assertEqual(created_transaction.account, self.account)
+        self.assertEqual(created_transaction.category, self.category)
+
+        mock_signal_send.assert_called_once()
+        # Check sender argument of the signal call
+        self.assertEqual(mock_signal_send.call_args.kwargs['sender'], Transaction)
+        self.assertEqual(mock_signal_send.call_args.kwargs['instance'], created_transaction)
+
+
+    def test_create_transaction_api_invalid_data(self):
+        url = reverse('api:transaction-list')
+        data = {
+            'account': self.account.pk,
+            'type': 'INVALID_TYPE', # Invalid type
+            'date': date(2023, 1, 15).isoformat(),
+            'amount': 'not_a_number', # Invalid amount
+            'description': 'API Test Invalid Data',
+            'category': self.category.pk
+        }
+        response = self.client.post(url, data, format='json')
+
+        self.assertEqual(response.status_code, 400)
+        self.assertIn('type', response.data)
+        self.assertIn('amount', response.data)
+
+    def test_transaction_list_pagination(self):
+        # Create more transactions than page size (e.g., DEFAULT_PAGE_SIZE + 5)
+        num_to_create = DEFAULT_PAGE_SIZE + 5
+        for i in range(num_to_create):
+            Transaction.objects.create(
+                account=self.account,
+                type=Transaction.Type.EXPENSE,
+                date=date(2023, 1, 1) + timedelta(days=i),
+                amount=Decimal(f"{10 + i}.00"),
+                description=f"Pag Test Transaction {i+1}",
+                owner=self.user,
+                category=self.category
+            )
+
+        url = reverse('api:transaction-list')
+        response = self.client.get(url)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('count', response.data)
+        self.assertEqual(response.data['count'], num_to_create)
+
+        self.assertIn('next', response.data)
+        self.assertIsNotNone(response.data['next']) # Assuming count > page size
+
+        self.assertIn('previous', response.data) # Will be None for the first page
+        # self.assertIsNone(response.data['previous']) # For the first page
+
+        self.assertIn('results', response.data)
+        self.assertEqual(len(response.data['results']), DEFAULT_PAGE_SIZE)

app/apps/api/views/accounts.py

@@ -1,4 +1,6 @@
 from rest_framework import viewsets
+
+from apps.api.custom.pagination import CustomPageNumberPagination
 from apps.accounts.models import AccountGroup, Account
 from apps.api.serializers import AccountGroupSerializer, AccountSerializer
 
@@ -6,12 +8,20 @@ from apps.api.serializers import AccountGroupSerializer, AccountSerializer
 class AccountGroupViewSet(viewsets.ModelViewSet):
     queryset = AccountGroup.objects.all()
     serializer_class = AccountGroupSerializer
+    pagination_class = CustomPageNumberPagination
+
+    def get_queryset(self):
+        return AccountGroup.objects.all().order_by("id")
 
 
 class AccountViewSet(viewsets.ModelViewSet):
     queryset = Account.objects.all()
     serializer_class = AccountSerializer
+    pagination_class = CustomPageNumberPagination
 
     def get_queryset(self):
-        queryset = super().get_queryset()
-        return queryset.select_related("group", "currency", "exchange_currency")
+        return (
+            Account.objects.all()
+            .order_by("id")
+            .select_related("group", "currency", "exchange_currency")
+        )

app/apps/api/views/transactions.py

@@ -1,5 +1,6 @@
 from rest_framework import viewsets
 
+from apps.api.custom.pagination import CustomPageNumberPagination
 from apps.api.serializers import (
     TransactionSerializer,
     TransactionCategorySerializer,
@@ -22,6 +23,7 @@ from apps.rules.signals import transaction_updated, transaction_created
 class TransactionViewSet(viewsets.ModelViewSet):
     queryset = Transaction.objects.all()
     serializer_class = TransactionSerializer
+    pagination_class = CustomPageNumberPagination
 
     def perform_create(self, serializer):
         instance = serializer.save()
@@ -35,27 +37,50 @@ class TransactionViewSet(viewsets.ModelViewSet):
         kwargs["partial"] = True
         return self.update(request, *args, **kwargs)
 
+    def get_queryset(self):
+        return Transaction.objects.all().order_by("-id")
+
 
 class TransactionCategoryViewSet(viewsets.ModelViewSet):
     queryset = TransactionCategory.objects.all()
     serializer_class = TransactionCategorySerializer
+    pagination_class = CustomPageNumberPagination
+
+    def get_queryset(self):
+        return TransactionCategory.objects.all().order_by("id")
 
 
 class TransactionTagViewSet(viewsets.ModelViewSet):
     queryset = TransactionTag.objects.all()
     serializer_class = TransactionTagSerializer
+    pagination_class = CustomPageNumberPagination
+
+    def get_queryset(self):
+        return TransactionTag.objects.all().order_by("id")
 
 
 class TransactionEntityViewSet(viewsets.ModelViewSet):
     queryset = TransactionEntity.objects.all()
     serializer_class = TransactionEntitySerializer
+    pagination_class = CustomPageNumberPagination
+
+    def get_queryset(self):
+        return TransactionEntity.objects.all().order_by("id")
 
 
 class InstallmentPlanViewSet(viewsets.ModelViewSet):
     queryset = InstallmentPlan.objects.all()
     serializer_class = InstallmentPlanSerializer
+    pagination_class = CustomPageNumberPagination
+
+    def get_queryset(self):
+        return InstallmentPlan.objects.all().order_by("-id")
 
 
 class RecurringTransactionViewSet(viewsets.ModelViewSet):
     queryset = RecurringTransaction.objects.all()
     serializer_class = RecurringTransactionSerializer
+    pagination_class = CustomPageNumberPagination
+
+    def get_queryset(self):
+        return RecurringTransaction.objects.all().order_by("-id")

app/apps/calendar_view/tests.py

@@ -0,0 +1,100 @@
+from django.test import TestCase, Client
+from django.contrib.auth.models import User
+from django.urls import reverse
+from django.utils import timezone # Though specific dates are used, good for general test setup
+from decimal import Decimal
+from datetime import date
+
+from apps.accounts.models import Account, AccountGroup
+from apps.currencies.models import Currency
+from apps.transactions.models import TransactionCategory, Transaction
+# from apps.calendar_view.utils.calendar import get_transactions_by_day # Not directly testing this util here
+
+class CalendarViewTests(TestCase): # Renamed from CalendarViewTestCase to CalendarViewTests
+    def setUp(self):
+        self.user = User.objects.create_user(username='testcalendaruser', password='password')
+        self.client = Client()
+        self.client.login(username='testcalendaruser', password='password')
+
+        self.currency_usd = Currency.objects.create(name="CV USD", code="CVUSD", decimal_places=2, prefix="$CV ")
+        self.account_group = AccountGroup.objects.create(name="CV Group", owner=self.user)
+        self.account_usd1 = Account.objects.create(
+            name="CV Account USD 1",
+            currency=self.currency_usd,
+            owner=self.user,
+            group=self.account_group
+        )
+        self.category_cv = TransactionCategory.objects.create(
+            name="CV Cat",
+            owner=self.user,
+            type=TransactionCategory.TransactionType.INFO # Using INFO as a generic type
+        )
+
+        # Transactions for specific dates
+        self.t1 = Transaction.objects.create(
+            owner=self.user, account=self.account_usd1, category=self.category_cv,
+            date=date(2023, 3, 5), amount=Decimal("10.00"),
+            type=Transaction.Type.EXPENSE, is_paid=True, description="March 5th Tx"
+        )
+        self.t2 = Transaction.objects.create(
+            owner=self.user, account=self.account_usd1, category=self.category_cv,
+            date=date(2023, 3, 10), amount=Decimal("20.00"),
+            type=Transaction.Type.EXPENSE, is_paid=True, description="March 10th Tx"
+        )
+        self.t3 = Transaction.objects.create(
+            owner=self.user, account=self.account_usd1, category=self.category_cv,
+            date=date(2023, 4, 5), amount=Decimal("30.00"),
+            type=Transaction.Type.EXPENSE, is_paid=True, description="April 5th Tx"
+        )
+
+    def test_calendar_list_view_context_data(self):
+        # Assumes 'calendar_view:calendar_list' is the correct URL name for the main calendar view
+        # The previous test used 'calendar_view:calendar'. I'll assume 'calendar_list' is the new/correct one.
+        # If the view that shows the grid is named 'calendar', this should be adjusted.
+        # Based on subtask, this is for calendar_list view.
+        url = reverse('calendar_view:calendar_list', kwargs={'month': 3, 'year': 2023})
+        response = self.client.get(url)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('dates', response.context)
+
+        dates_context = response.context['dates']
+
+        entry_mar5 = next((d for d in dates_context if d['date'] == date(2023, 3, 5)), None)
+        self.assertIsNotNone(entry_mar5, "Date March 5th not found in context.")
+        self.assertIn(self.t1, entry_mar5['transactions'], "Transaction t1 not in March 5th transactions.")
+
+        entry_mar10 = next((d for d in dates_context if d['date'] == date(2023, 3, 10)), None)
+        self.assertIsNotNone(entry_mar10, "Date March 10th not found in context.")
+        self.assertIn(self.t2, entry_mar10['transactions'], "Transaction t2 not in March 10th transactions.")
+
+        for day_data in dates_context:
+            self.assertNotIn(self.t3, day_data['transactions'], f"Transaction t3 (April 5th) found in March {day_data['date']} transactions.")
+
+    def test_calendar_transactions_list_view_specific_day(self):
+        url = reverse('calendar_view:calendar_transactions_list', kwargs={'day': 5, 'month': 3, 'year': 2023})
+        response = self.client.get(url)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('transactions', response.context)
+
+        transactions_context = response.context['transactions']
+
+        self.assertIn(self.t1, transactions_context, "Transaction t1 (March 5th) not found in context for specific day view.")
+        self.assertNotIn(self.t2, transactions_context, "Transaction t2 (March 10th) found in context for March 5th.")
+        self.assertNotIn(self.t3, transactions_context, "Transaction t3 (April 5th) found in context for March 5th.")
+        self.assertEqual(len(transactions_context), 1)
+
+    def test_calendar_view_authenticated_user_generic_month(self):
+        # This is similar to the old test_calendar_view_authenticated_user.
+        # It tests general access to the main calendar view (which might be 'calendar_list' or 'calendar')
+        # Let's use the 'calendar' name as it was in the old test, assuming it's the main monthly view.
+        # If 'calendar_list' is the actual main monthly view, this might be slightly redundant
+        # with the setup of test_calendar_list_view_context_data but still good for general access check.
+        url = reverse('calendar_view:calendar', args=[2023, 1]) # e.g. Jan 2023
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, 200)
+        # Further context checks could be added here if this view has a different structure than 'calendar_list'
+        self.assertIn('dates', response.context) # Assuming it also provides 'dates'
+        self.assertIn('current_month_date', response.context)
+        self.assertEqual(response.context['current_month_date'], date(2023,1,1))

app/apps/common/admin.py

@@ -0,0 +1,7 @@
+from django.contrib import admin
+
+
+class SharedObjectModelAdmin(admin.ModelAdmin):
+    def get_queryset(self, request):
+        # Use the all_objects manager to show all transactions, including deleted ones
+        return self.model.all_objects.all()

app/apps/common/decorators/demo.py

@@ -0,0 +1,15 @@
+from functools import wraps
+
+from django.conf import settings
+from django.core.exceptions import PermissionDenied
+
+
+def disabled_on_demo(view):
+    @wraps(view)
+    def _view(request, *args, **kwargs):
+        if settings.DEMO and not request.user.is_superuser:
+            raise PermissionDenied
+
+        return view(request, *args, **kwargs)
+
+    return _view

app/apps/common/decorators/user.py

@@ -0,0 +1,78 @@
+from functools import wraps
+
+from django.conf import settings
+from django.core.exceptions import PermissionDenied
+from django.http import HttpResponse
+from django.shortcuts import redirect
+from django.urls import reverse, NoReverseMatch
+
+
+def is_superuser(view):
+    @wraps(view)
+    def _view(request, *args, **kwargs):
+        if not request.user.is_superuser:
+            raise PermissionDenied
+
+        return view(request, *args, **kwargs)
+
+    return _view
+
+
+def htmx_login_required(function=None, login_url=None):
+    """
+    Decorator that checks if the user is logged in.
+
+    Allows overriding the default login URL.
+
+    If the user is not logged in:
+    - If "hx-request" is present in the request header, it returns a 200 response
+      with a "HX-Redirect" header containing the determined login URL (including the "next" parameter).
+    - If "hx-request" is not present, it redirects to the determined login page normally.
+
+    Args:
+        function: The view function to decorate.
+        login_url: Optional. The URL or URL name to redirect to for login.
+                   Defaults to settings.LOGIN_URL.
+    """
+
+    def decorator(view_func):
+        # Simplified @wraps usage - it handles necessary attribute assignments by default
+        @wraps(view_func)
+        def wrapped_view(request, *args, **kwargs):
+            if request.user.is_authenticated:
+                return view_func(request, *args, **kwargs)
+            else:
+                # Determine the login URL
+                resolved_login_url = login_url
+                if not resolved_login_url:
+                    resolved_login_url = settings.LOGIN_URL
+
+                # Try to reverse the URL name if it's not a path
+                try:
+                    # Check if it looks like a URL path already
+                    if "/" not in resolved_login_url and "." not in resolved_login_url:
+                        login_url_path = reverse(resolved_login_url)
+                    else:
+                        login_url_path = resolved_login_url
+                except NoReverseMatch:
+                    # If reverse fails, assume it's already a URL path
+                    login_url_path = resolved_login_url
+
+                # Construct the full redirect path with 'next' parameter
+                # Ensure request.path is URL-encoded if needed, though Django usually handles this
+                redirect_path = f"{login_url_path}?next={request.get_full_path()}"  # Use get_full_path() to include query params
+
+                if request.headers.get("hx-request"):
+                    # For HTMX requests, return a 200 with the HX-Redirect header.
+                    response = HttpResponse()
+                    response["HX-Redirect"] = login_url_path
+                    return response
+                else:
+                    # For regular requests, redirect to the login page.
+                    return redirect(redirect_path)
+
+        return wrapped_view
+
+    if function:
+        return decorator(function)
+    return decorator

app/apps/common/fields/forms/dynamic_select.py

@@ -4,6 +4,7 @@ from django.db import transaction
 from django.utils.translation import gettext_lazy as _
 
 from apps.common.widgets.tom_select import TomSelect, TomSelectMultiple
+from apps.common.middleware.thread_local import get_current_user
 
 
 class DynamicModelChoiceField(forms.ModelChoiceField):
@@ -12,15 +13,14 @@ class DynamicModelChoiceField(forms.ModelChoiceField):
         self.to_field_name = kwargs.pop("to_field_name", "pk")
 
         self.create_field = kwargs.pop("create_field", None)
-        if not self.create_field:
-            raise ValueError("The 'create_field' parameter is required.")
 
         self.queryset = kwargs.pop("queryset", model.objects.all())
-        super().__init__(queryset=self.queryset, *args, **kwargs)
-        self._created_instance = None
 
         self.widget = TomSelect(clear_button=True, create=True)
 
+        super().__init__(queryset=self.queryset, *args, **kwargs)
+        self._created_instance = None
+
     def to_python(self, value):
         if value in self.empty_values:
             return None
@@ -53,17 +53,27 @@ class DynamicModelChoiceField(forms.ModelChoiceField):
                 else:
                     raise self.model.DoesNotExist
             except self.model.DoesNotExist:
-                try:
-                    with transaction.atomic():
-                        instance, _ = self.model.objects.update_or_create(
-                            **{self.create_field: value}
-                        )
-                        self._created_instance = instance
-                        return instance
-                except Exception as e:
+                if self.create_field:
+                    try:
+                        with transaction.atomic():
+                            # First try to get the object
+                            lookup = {self.create_field: value}
+                            try:
+                                instance = self.model.objects.get(**lookup)
+                            except self.model.DoesNotExist:
+                                # Create a new instance directly
+                                instance = self.model(**lookup)
+                                instance.save()
+
+                            self._created_instance = instance
+                            return instance
+                    except Exception as e:
+                        raise ValidationError(_("Error creating new instance"))
+                else:
                     raise ValidationError(
                         self.error_messages["invalid_choice"], code="invalid_choice"
                     )
+
         return super().clean(value)
 
     def bound_data(self, data, initial):
@@ -86,8 +96,6 @@ class DynamicModelMultipleChoiceField(forms.ModelMultipleChoiceField):
 
     def __init__(self, model, **kwargs):
         """
-        Initialize the CreateIfNotExistsModelMultipleChoiceField.
-
         Args:
             create_field (str): The name of the field to use when creating new instances.
             *args: Variable length argument list.
@@ -119,33 +127,28 @@ class DynamicModelMultipleChoiceField(forms.ModelMultipleChoiceField):
         """
         try:
             with transaction.atomic():
-                instance, _ = self.model.objects.update_or_create(
-                    **{self.create_field: value}
-                )
-            return instance
+                # Check if exists first without using update_or_create
+                lookup = {self.create_field: value}
+                try:
+                    # Use base manager to bypass distinct filters
+                    instance = self.model.objects.get(**lookup)
+                    return instance
+                except self.model.DoesNotExist:
+                    # Create a new instance directly
+                    instance = self.model(**lookup)
+                    instance.save()
+                    return instance
         except Exception as e:
+            print(e)
             raise ValidationError(_("Error creating new instance"))
 
     def clean(self, value):
-        """
-        Clean and validate the field value.
-
-        This method checks if each selected choice exists in the database.
-        If a choice doesn't exist, it creates a new instance of the model.
-
-        Args:
-            value (list): List of selected values.
-
-        Returns:
-            list: A list containing all selected and newly created model instances.
-
-        Raises:
-            ValidationError: If there's an error during the cleaning process.
-        """
         if not value:
             return []
 
         string_values = set(str(v) for v in value)
+
+        # Get existing objects first
         existing_objects = list(
             self.queryset.filter(**{f"{self.create_field}__in": string_values})
         )
@@ -153,13 +156,11 @@ class DynamicModelMultipleChoiceField(forms.ModelMultipleChoiceField):
             str(getattr(obj, self.create_field)) for obj in existing_objects
         )
 
+        # Create new objects for missing values
         new_values = string_values - existing_values
         new_objects = []
 
         for new_value in new_values:
-            try:
-                new_objects.append(self._create_new_instance(new_value))
-            except ValidationError as e:
-                raise ValidationError(_("Error creating new instance"))
+            new_objects.append(self._create_new_instance(new_value))
 
         return existing_objects + new_objects

app/apps/common/fields/month_year.py

@@ -20,7 +20,15 @@ class MonthYearModelField(models.DateField):
             # Set the day to 1
             return date.replace(day=1).date()
         except ValueError:
-            raise ValidationError(_("Invalid date format. Use YYYY-MM."))
+            try:
+                # Also accept YYYY-MM-DD format (for loaddata)
+                return (
+                    datetime.datetime.strptime(value, "%Y-%m-%d").replace(day=1).date()
+                )
+            except ValueError:
+                raise ValidationError(
+                    _("Invalid date format. Use YYYY-MM or YYYY-MM-DD.")
+                )
 
     def formfield(self, **kwargs):
         kwargs["widget"] = MonthYearWidget

app/apps/common/forms.py

@@ -0,0 +1,113 @@
+from crispy_forms.bootstrap import FormActions
+from django import forms
+from django.contrib.auth import get_user_model
+from django.utils.translation import gettext_lazy as _
+from django.core.exceptions import ValidationError
+from crispy_forms.helper import FormHelper
+from crispy_forms.layout import Layout, Field, Submit, Div, HTML
+
+from apps.common.widgets.tom_select import TomSelect, TomSelectMultiple
+from apps.common.models import SharedObject
+from apps.common.widgets.crispy.submit import NoClassSubmit
+
+User = get_user_model()
+
+
+class SharedObjectForm(forms.Form):
+    """
+    Generic form for editing visibility and sharing settings
+    for models inheriting from SharedObject.
+    """
+
+    owner = forms.ModelChoiceField(
+        queryset=User.objects.all(),
+        required=False,
+        label=_("Owner"),
+        widget=TomSelect(clear_button=False),
+        help_text=_(
+            "The owner of this object, if empty all users can see, edit and take ownership."
+        ),
+    )
+    shared_with_users = forms.ModelMultipleChoiceField(
+        queryset=User.objects.all(),
+        required=False,
+        widget=TomSelectMultiple(clear_button=True),
+        label=_("Shared with users"),
+        help_text=_("Select users to share this object with"),
+    )
+    visibility = forms.ChoiceField(
+        choices=SharedObject.Visibility.choices,
+        required=True,
+        label=_("Visibility"),
+        help_text=_(
+            "Private: Only shown for the owner and shared users. Only editable by the owner."
+            "<br/>"
+            "Public: Shown for all users. Only editable by the owner."
+        ),
+    )
+
+    class Meta:
+        fields = ["visibility", "shared_with_users"]
+        widgets = {
+            "visibility": TomSelect(clear_button=False),
+        }
+
+    def __init__(self, *args, **kwargs):
+        # Get the current user to filter available sharing options
+        self.user = kwargs.pop("user", None)
+        self.instance = kwargs.pop("instance", None)
+
+        super().__init__(*args, **kwargs)
+
+        # Pre-populate shared users if instance exists
+        if self.instance:
+            self.fields["shared_with_users"].initial = self.instance.shared_with.all()
+            self.fields["visibility"].initial = self.instance.visibility
+            self.fields["owner"].initial = self.instance.owner
+
+        # Set up crispy form helper
+        self.helper = FormHelper()
+        self.helper.form_method = "post"
+        self.helper.form_tag = False
+
+        self.helper.layout = Layout(
+            Field("owner"),
+            Field("visibility"),
+            HTML("<hr>"),
+            Field("shared_with_users"),
+            FormActions(
+                NoClassSubmit(
+                    "submit", _("Save"), css_class="btn btn-outline-primary w-100"
+                ),
+            ),
+        )
+
+    def clean(self):
+        cleaned_data = super().clean()
+        owner = cleaned_data.get("owner")
+        shared_with_users = cleaned_data.get("shared_with_users", [])
+
+        # Raise validation error if owner is in shared_with_users
+        if owner and owner in shared_with_users:
+            self.add_error(
+                "shared_with_users",
+                ValidationError(
+                    _("You cannot share this item with its owner."),
+                    code="invalid_share",
+                ),
+            )
+
+        return cleaned_data
+
+    def save(self):
+        instance = self.instance
+
+        instance.visibility = self.cleaned_data["visibility"]
+        instance.owner = self.cleaned_data["owner"]
+
+        instance.save()
+
+        # Clear and set shared_with users
+        instance.shared_with.set(self.cleaned_data.get("shared_with_users", []))
+
+        return instance

app/apps/common/functions/format.py

@@ -0,0 +1,31 @@
+from apps.common.middleware.thread_local import get_current_user
+from django.utils.formats import get_format as original_get_format
+
+
+def get_format(format_type=None, lang=None, use_l10n=None):
+    user = get_current_user()
+
+    if user and user.is_authenticated and hasattr(user, "settings"):
+        user_settings = user.settings
+        if format_type == "THOUSAND_SEPARATOR":
+            number_format = getattr(user_settings, "number_format", None)
+            if number_format == "DC":
+                return "."
+            elif number_format == "CD":
+                return ","
+        elif format_type == "DECIMAL_SEPARATOR":
+            number_format = getattr(user_settings, "number_format", None)
+            if number_format == "DC":
+                return ","
+            elif number_format == "CD":
+                return "."
+        elif format_type == "SHORT_DATE_FORMAT":
+            date_format = getattr(user_settings, "date_format", None)
+            if date_format and date_format != "SHORT_DATE_FORMAT":
+                return date_format
+        elif format_type == "SHORT_DATETIME_FORMAT":
+            datetime_format = getattr(user_settings, "datetime_format", None)
+            if datetime_format and datetime_format != "SHORT_DATETIME_FORMAT":
+                return datetime_format
+
+    return original_get_format(format_type, lang, use_l10n)

app/apps/common/management/commands/setup_users.py

@@ -0,0 +1,137 @@
+import os
+from django.core.management.base import BaseCommand, CommandError
+from django.contrib.auth import get_user_model
+from django.conf import settings
+from django.db import IntegrityError
+
+# Get the custom User model if defined, otherwise the default User model
+User = get_user_model()
+
+
+class Command(BaseCommand):
+    help = (
+        "Creates a superuser from environment variables (ADMIN_EMAIL, ADMIN_PASSWORD) "
+        "and optionally creates a demo user (demo@demo.com) if settings.DEMO is True."
+    )
+
+    def handle(self, *args, **options):
+        self.stdout.write("Starting user setup...")
+
+        # --- Create Superuser ---
+        admin_email = os.environ.get("ADMIN_EMAIL")
+        admin_password = os.environ.get("ADMIN_PASSWORD")
+
+        if admin_email and admin_password:
+            self.stdout.write(f"Attempting to create superuser: {admin_email}")
+            # Use email as username for simplicity, requires USERNAME_FIELD='email'
+            # or adapt if your USERNAME_FIELD is different.
+            # If USERNAME_FIELD is 'username', you might need ADMIN_USERNAME env var.
+            username_field = User.USERNAME_FIELD  # Get the actual username field name
+
+            # Check if the user already exists by email or username
+            user_exists_kwargs = {"email": admin_email}
+            if username_field != "email":
+                # Assume username should also be the email if not explicitly provided
+                user_exists_kwargs[username_field] = admin_email
+
+            if User.objects.filter(**user_exists_kwargs).exists():
+                self.stdout.write(
+                    self.style.WARNING(
+                        f"Superuser with email '{admin_email}' (or corresponding username) already exists. Skipping creation."
+                    )
+                )
+            else:
+                try:
+                    create_kwargs = {
+                        username_field: admin_email,  # Use email as username by default
+                        "email": admin_email,
+                        "password": admin_password,
+                    }
+                    User.objects.create_superuser(**create_kwargs)
+                    self.stdout.write(
+                        self.style.SUCCESS(
+                            f"Superuser '{admin_email}' created successfully."
+                        )
+                    )
+                except IntegrityError as e:
+                    self.stdout.write(
+                        self.style.ERROR(
+                            f"Failed to create superuser '{admin_email}'. IntegrityError: {e}"
+                        )
+                    )
+                except Exception as e:
+                    self.stdout.write(
+                        self.style.ERROR(
+                            f"An unexpected error occurred creating superuser '{admin_email}': {e}"
+                        )
+                    )
+        else:
+            self.stdout.write(
+                self.style.NOTICE(
+                    "ADMIN_EMAIL or ADMIN_PASSWORD environment variables not set. Skipping superuser creation."
+                )
+            )
+
+        self.stdout.write("---")  # Separator
+
+        # --- Create Demo User ---
+        # Use getattr to safely check for the DEMO setting, default to False if not present
+        create_demo_user = getattr(settings, "DEMO", False)
+
+        if create_demo_user:
+            demo_email = "demo@demo.com"
+            demo_password = (
+                "wygiwyhdemo"  # Consider making this an env var too for security
+            )
+            demo_username = demo_email  # Using email as username for consistency
+
+            self.stdout.write(
+                f"DEMO setting is True. Attempting to create demo user: {demo_email}"
+            )
+
+            username_field = User.USERNAME_FIELD  # Get the actual username field name
+
+            # Check if the user already exists by email or username
+            user_exists_kwargs = {"email": demo_email}
+            if username_field != "email":
+                user_exists_kwargs[username_field] = demo_username
+
+            if User.objects.filter(**user_exists_kwargs).exists():
+                self.stdout.write(
+                    self.style.WARNING(
+                        f"Demo user with email '{demo_email}' (or corresponding username) already exists. Skipping creation."
+                    )
+                )
+            else:
+                try:
+                    create_kwargs = {
+                        username_field: demo_username,
+                        "email": demo_email,
+                        "password": demo_password,
+                    }
+                    User.objects.create_user(**create_kwargs)
+                    self.stdout.write(
+                        self.style.SUCCESS(
+                            f"Demo user '{demo_email}' created successfully."
+                        )
+                    )
+                except IntegrityError as e:
+                    self.stdout.write(
+                        self.style.ERROR(
+                            f"Failed to create demo user '{demo_email}'. IntegrityError: {e}"
+                        )
+                    )
+                except Exception as e:
+                    self.stdout.write(
+                        self.style.ERROR(
+                            f"An unexpected error occurred creating demo user '{demo_email}': {e}"
+                        )
+                    )
+        else:
+            self.stdout.write(
+                self.style.NOTICE(
+                    "DEMO setting is not True (or not set). Skipping demo user creation."
+                )
+            )
+
+        self.stdout.write(self.style.SUCCESS("User setup command finished."))

app/apps/common/middleware/localization.py

@@ -1,14 +1,17 @@
 import zoneinfo
 
+from django.utils import formats
 from django.utils import timezone, translation
-from django.utils.translation import activate
+from django.utils.functional import lazy
 
+from apps.common.functions.format import get_format as custom_get_format
 from apps.users.models import UserSettings
 
 
 class LocalizationMiddleware:
     def __init__(self, get_response):
         self.get_response = get_response
+        self.patch_get_format()
 
     def __call__(self, request):
         tz = request.COOKIES.get("mytz")
@@ -33,9 +36,14 @@ class LocalizationMiddleware:
             timezone.activate(zoneinfo.ZoneInfo("UTC"))
 
         if user_language and user_language != "auto":
-            activate(user_language)
+            translation.activate(user_language)
         else:
             detected_language = translation.get_language_from_request(request)
-            activate(detected_language)
+            translation.activate(detected_language)
 
         return self.get_response(request)
+
+    @staticmethod
+    def patch_get_format():
+        formats.get_format = custom_get_format
+        formats.get_format_lazy = lazy(custom_get_format, str, list, tuple)

app/apps/common/middleware/thread_local.py

@@ -0,0 +1,83 @@
+"""
+    threadlocals middleware
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    make the request object everywhere available (e.g. in model instance).
+
+    based on: http://code.djangoproject.com/wiki/CookBookThreadlocalsAndUser
+
+    Put this into your settings:
+    --------------------------------------------------------------------------
+        MIDDLEWARE_CLASSES = (
+            ...
+            'django_tools.middlewares.ThreadLocal.ThreadLocalMiddleware',
+            ...
+        )
+    --------------------------------------------------------------------------
+
+
+    Usage:
+    --------------------------------------------------------------------------
+    from django_tools.middlewares import ThreadLocal
+
+    # Get the current request object:
+    request = ThreadLocal.get_current_request()
+
+    # You can get the current user directly with:
+    user = ThreadLocal.get_current_user()
+    --------------------------------------------------------------------------
+
+    :copyleft: 2009-2017 by the django-tools team, see AUTHORS for more details.
+    :license: GNU GPL v3 or above, see LICENSE for more details.
+"""
+
+try:
+    from threading import local
+except ImportError:
+    from django.utils._threading_local import local
+
+try:
+    from django.utils.deprecation import MiddlewareMixin
+except ImportError:
+    MiddlewareMixin = object  # fallback for Django < 1.10
+
+
+_thread_locals = local()
+
+
+def get_current_request():
+    """returns the request object for this thread"""
+    return getattr(_thread_locals, "request", None)
+
+
+def get_current_user():
+    """returns the current user, if exist, otherwise returns None"""
+    request = get_current_request()
+    if request:
+        return getattr(request, "user", None)
+
+    return getattr(_thread_locals, "user", None)
+
+
+def write_current_user(user):
+    _thread_locals.user = user
+
+
+def delete_current_user():
+    del _thread_locals.user
+
+
+class ThreadLocalMiddleware(MiddlewareMixin):
+    """Simple middleware that adds the request object in thread local storage."""
+
+    def process_request(self, request):
+        _thread_locals.request = request
+
+    def process_response(self, request, response):
+        if hasattr(_thread_locals, "request"):
+            del _thread_locals.request
+        return response
+
+    def process_exception(self, request, exception):
+        if hasattr(_thread_locals, "request"):
+            del _thread_locals.request

app/apps/common/models.py

@@ -0,0 +1,84 @@
+from django.db import models
+from django.conf import settings
+from django.db.models import Q
+from django.utils.translation import gettext_lazy as _
+
+from apps.common.middleware.thread_local import get_current_user
+
+
+class SharedObjectManager(models.Manager):
+    def get_queryset(self):
+        """Return only objects the user can access"""
+        user = get_current_user()
+        base_qs = super().get_queryset()
+
+        if user and user.is_authenticated:
+            return base_qs.filter(
+                Q(visibility="public")
+                | Q(owner=user)
+                | Q(shared_with=user)
+                | Q(visibility="private", owner=None)
+            ).distinct()
+
+        return base_qs.filter(visibility="public")
+
+
+class SharedObject(models.Model):
+    # Access control enum
+    class Visibility(models.TextChoices):
+        private = "private", _("Private")
+        is_paid = "public", _("Public")
+
+    # Core sharing fields
+    owner = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="%(class)s_owned",
+        null=True,
+        blank=True,
+    )
+    visibility = models.CharField(
+        max_length=10, choices=Visibility.choices, default=Visibility.private
+    )
+    shared_with = models.ManyToManyField(
+        settings.AUTH_USER_MODEL, related_name="%(class)s_shared", blank=True
+    )
+
+    # Use as abstract base class
+    class Meta:
+        abstract = True
+        indexes = [
+            models.Index(fields=["visibility"]),
+        ]
+
+    def is_accessible_by(self, user):
+        """Check if a user can access this object"""
+        return (
+            self.visibility == "public"
+            or self.owner == user
+            or (self.visibility == "shared" and user in self.shared_with.all())
+        )
+
+    def save(self, *args, **kwargs):
+        if not self.pk and not self.owner:
+            self.owner = get_current_user()
+        super().save(*args, **kwargs)
+
+
+class OwnedObject(models.Model):
+    owner = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="%(class)s_owned",
+        null=True,
+        blank=True,
+    )
+
+    # Use as abstract base class
+    class Meta:
+        abstract = True
+
+    def save(self, *args, **kwargs):
+        if not self.pk and not self.owner:
+            self.owner = get_current_user()
+        super().save(*args, **kwargs)

app/apps/common/tasks.py

@@ -1,5 +1,10 @@
 import logging
 
+from asgiref.sync import sync_to_async
+from django.conf import settings
+from django.core import management
+from django.db import DEFAULT_DB_ALIAS
+
 from procrastinate import builtin_tasks
 from procrastinate.contrib.django import app
 
@@ -8,7 +13,7 @@ logger = logging.getLogger(__name__)
 
 
 @app.periodic(cron="0 4 * * *")
-@app.task(queueing_lock="remove_old_jobs", pass_context=True)
+@app.task(queueing_lock="remove_old_jobs", pass_context=True, name="remove_old_jobs")
 async def remove_old_jobs(context, timestamp):
     try:
         return await builtin_tasks.remove_old_jobs(
@@ -24,3 +29,53 @@ async def remove_old_jobs(context, timestamp):
             exc_info=True,
         )
         raise e
+
+
+@app.periodic(cron="0 6 1 * *")
+@app.task(queueing_lock="remove_expired_sessions", name="remove_expired_sessions")
+async def remove_expired_sessions(timestamp=None):
+    """Cleanup expired sessions by using Django management command."""
+    try:
+        await sync_to_async(management.call_command)("clearsessions", verbosity=0)
+    except Exception:
+        logger.error(
+            "Error while executing 'remove_expired_sessions' task",
+            exc_info=True,
+        )
+
+
+@app.periodic(cron="0 8 * * *")
+@app.task(name="reset_demo_data")
+def reset_demo_data(timestamp=None):
+    """
+    Wipes the database and loads fresh demo data if DEMO mode is active.
+    Runs daily at 8:00 AM.
+    """
+    if not settings.DEMO:
+        return  # Exit if not in demo mode
+
+    logger.info("Demo mode active. Starting daily data reset...")
+
+    try:
+        # 1. Flush the database (wipe all data)
+        logger.info("Flushing the database...")
+
+        management.call_command(
+            "flush", "--noinput", database=DEFAULT_DB_ALIAS, verbosity=1
+        )
+        logger.info("Database flushed successfully.")
+
+        # 2. Load data from the fixture
+        # TO-DO: Roll dates over based on today's date
+        fixture_name = "fixtures/demo_data.json"
+        logger.info(f"Loading data from fixture: {fixture_name}...")
+        management.call_command(
+            "loaddata", fixture_name, database=DEFAULT_DB_ALIAS, verbosity=1
+        )
+        logger.info(f"Data loaded successfully from {fixture_name}.")
+
+        logger.info("Daily demo data reset completed.")
+
+    except Exception as e:
+        logger.exception(f"Error during daily demo data reset: {e}")
+        raise

app/apps/common/templatetags/date.py

@@ -1,32 +0,0 @@
-from django import template
-from django.template.defaultfilters import date as date_filter
-from django.utils import formats, timezone
-
-register = template.Library()
-
-
-@register.filter
-def custom_date(value, user=None):
-    if not value:
-        return ""
-
-    # Determine if the value is a datetime or just a date
-    is_datetime = hasattr(value, "hour")
-
-    # Convert to current timezone if it's a datetime
-    if is_datetime and timezone.is_aware(value):
-        value = timezone.localtime(value)
-
-    if user and user.is_authenticated:
-        user_settings = user.settings
-
-        if is_datetime:
-            format_setting = user_settings.datetime_format
-        else:
-            format_setting = user_settings.date_format
-
-        return formats.date_format(value, format_setting, use_l10n=True)
-
-    return date_filter(
-        value, "SHORT_DATE_FORMAT" if not is_datetime else "SHORT_DATETIME_FORMAT"
-    )

app/apps/common/templatetags/formats.py

@@ -1,6 +1,6 @@
 from django import template
-from django.utils.formats import get_format
 
+from apps.common.functions.format import get_format
 
 register = template.Library()
 

app/apps/common/templatetags/markdown.py

@@ -0,0 +1,52 @@
+from typing import Optional
+
+import mistune
+from django import template
+from django.utils.safestring import mark_safe
+from mistune import HTMLRenderer, Markdown, BlockParser, InlineParser, safe_entity
+from mistune.plugins.formatting import strikethrough as plugin_strikethrough
+from mistune.plugins.url import url as plugin_url
+
+
+register = template.Library()
+
+
+class CustomRenderer(HTMLRenderer):
+    def link(self, text: str, url: str, title: Optional[str] = None) -> str:
+        s = '<a rel="nofollow" target="_blank" href="' + self.safe_url(url) + '"'
+        if title:
+            s += ' title="' + safe_entity(title) + '"'
+        return s + ">" + text + "</a>"
+
+    def paragraph(self, text: str) -> str:
+        return text + "\n"
+
+    def softbreak(self) -> str:
+        return "\n"
+
+    def blank_line(self) -> str:
+        return "\n"
+
+
+block = BlockParser()
+block.rules = ["blank_line"]
+inline = InlineParser(hard_wrap=False)
+inline.rules = [
+    "emphasis",
+    "link",
+    "auto_link",
+    "auto_email",
+    "linebreak",
+    "softbreak",
+]
+markdown = Markdown(
+    renderer=CustomRenderer(escape=False),
+    block=block,
+    inline=inline,
+    plugins=[plugin_strikethrough, plugin_url],
+)
+
+
+@register.filter(name="limited_markdown")
+def limited_markdown(value):
+    return mark_safe(markdown(value))

app/apps/common/templatetags/settings.py

@@ -0,0 +1,9 @@
+from django import template
+from django.conf import settings
+
+register = template.Library()
+
+
+@register.simple_tag(name="settings")
+def settings_value(name):
+    return getattr(settings, name, "")

app/apps/common/tests.py

@@ -0,0 +1,183 @@
+from django.test import TestCase, RequestFactory
+from django.template import Template, Context
+from django.urls import reverse, resolve, NoReverseMatch
+from django.contrib.auth.models import User
+from decimal import Decimal # Keep existing imports if they are from other tests
+from app.apps.common.functions.decimals import truncate_decimal # Keep existing imports
+
+# Helper to create a dummy request with resolver_match
+def setup_request_for_view(factory, view_name_or_url, user=None, namespace=None, view_name_for_resolver=None):
+    try:
+        url = reverse(view_name_or_url)
+    except NoReverseMatch:
+        url = view_name_or_url # Assume it's already a URL path
+
+    request = factory.get(url)
+    if user:
+        request.user = user
+
+    try:
+        # For resolver_match, we need to simulate how Django does it.
+        # It needs specific view_name and namespace if applicable.
+        # If view_name_for_resolver is provided, use that for resolving,
+        # otherwise, assume view_name_or_url is the view name for resolver_match.
+        resolver_match_source = view_name_for_resolver if view_name_for_resolver else view_name_or_url
+
+        # If it's a namespaced view name like 'app:view', resolve might handle it directly.
+        # If namespace is separately provided, it means the view_name itself is not namespaced.
+        resolved_match = resolve(url) # Resolve the URL to get func, args, kwargs, etc.
+
+        # Ensure resolver_match has the correct attributes, especially 'view_name' and 'namespace'
+        if hasattr(resolved_match, 'view_name'):
+            if ':' in resolved_match.view_name and not namespace: # e.g. 'app_name:view_name'
+                request.resolver_match = resolved_match
+            elif namespace and resolved_match.namespace == namespace and resolved_match.url_name == resolver_match_source.split(':')[-1]:
+                request.resolver_match = resolved_match
+            elif not namespace and resolved_match.url_name == resolver_match_source:
+                 request.resolver_match = resolved_match
+            else: # Fallback or if specific view_name/namespace parts are needed for resolver_match
+                # This part is tricky without knowing the exact structure of resolver_match expected by the tag
+                # Forcing the view_name and namespace if they are explicitly passed.
+                if namespace:
+                    resolved_match.namespace = namespace
+                if view_name_for_resolver: # This should be the non-namespaced view name part
+                     resolved_match.view_name = f"{namespace}:{view_name_for_resolver.split(':')[-1]}" if namespace else view_name_for_resolver.split(':')[-1]
+                     resolved_match.url_name = view_name_for_resolver.split(':')[-1]
+
+                request.resolver_match = resolved_match
+
+        else: # Fallback if resolve() doesn't directly give a full resolver_match object as expected
+            request.resolver_match = None
+
+
+    except Exception as e:
+        print(f"Warning: Could not resolve URL or set resolver_match for '{view_name_or_url}' (or '{view_name_for_resolver}') for test setup: {e}")
+        request.resolver_match = None
+    return request
+
+class CommonTestCase(TestCase): # Keep existing test class if other tests depend on it
+    def test_example(self): # Example of an old test
+        self.assertEqual(1 + 1, 2)
+
+    def test_truncate_decimal_function(self): # Example of an old test from problem description
+        test_cases = [
+            (Decimal('123.456'), 0, Decimal('123')),
+            (Decimal('123.456'), 1, Decimal('123.4')),
+            (Decimal('123.456'), 2, Decimal('123.45')),
+        ]
+        for value, places, expected in test_cases:
+            with self.subTest(value=value, places=places, expected=expected):
+                self.assertEqual(truncate_decimal(value, places), expected)
+
+
+class CommonTemplateTagsTests(TestCase):
+    def setUp(self):
+        self.factory = RequestFactory()
+        self.user = User.objects.create_user('testuser', 'password123')
+
+        # Using view names that should exist in a typical Django project with auth
+        # Ensure these URLs are part of your project's urlpatterns for tests to pass.
+        self.view_name_login = 'login' # Typically 'login' or 'account_login'
+        self.namespace_login = None # Often no namespace for basic auth views, or 'account'
+
+        self.view_name_admin = 'admin:index' # Admin index
+        self.namespace_admin = 'admin'
+
+        # Check if these can be reversed, skip tests if not.
+        try:
+            reverse(self.view_name_login)
+        except NoReverseMatch:
+            self.view_name_login = None # Mark as unusable
+            print(f"Warning: Could not reverse '{self.view_name_login}'. Some active_link tests might be skipped.")
+        try:
+            reverse(self.view_name_admin)
+        except NoReverseMatch:
+            self.view_name_admin = None # Mark as unusable
+            print(f"Warning: Could not reverse '{self.view_name_admin}'. Some active_link tests might be skipped.")
+
+    def test_active_link_view_match(self):
+        if not self.view_name_login: self.skipTest("Login URL not reversible.")
+        request = setup_request_for_view(self.factory, self.view_name_login, self.user,
+                                         namespace=self.namespace_login, view_name_for_resolver=self.view_name_login)
+        if not request.resolver_match: self.skipTest(f"Could not set resolver_match for {self.view_name_login}.")
+
+        template_str = "{% load active_link %} {% active_link views='" + self.view_name_login + "' %}"
+        template = Template(template_str)
+        rendered = template.render(Context({'request': request}))
+        self.assertEqual(rendered.strip(), "active")
+
+    def test_active_link_view_no_match(self):
+        if not self.view_name_login: self.skipTest("Login URL not reversible.")
+        request = setup_request_for_view(self.factory, self.view_name_login, self.user,
+                                         namespace=self.namespace_login, view_name_for_resolver=self.view_name_login)
+        if not request.resolver_match: self.skipTest(f"Could not set resolver_match for {self.view_name_login}.")
+
+        template_str = "{% load active_link %} {% active_link views='non_existent_view_name' %}"
+        template = Template(template_str)
+        rendered = template.render(Context({'request': request}))
+        self.assertEqual(rendered.strip(), "")
+
+    def test_active_link_view_match_custom_class(self):
+        if not self.view_name_login: self.skipTest("Login URL not reversible.")
+        request = setup_request_for_view(self.factory, self.view_name_login, self.user,
+                                         namespace=self.namespace_login, view_name_for_resolver=self.view_name_login)
+        if not request.resolver_match: self.skipTest(f"Could not set resolver_match for {self.view_name_login}.")
+
+        template_str = "{% load active_link %} {% active_link views='" + self.view_name_login + "' css_class='custom-active' %}"
+        template = Template(template_str)
+        rendered = template.render(Context({'request': request}))
+        self.assertEqual(rendered.strip(), "custom-active")
+
+    def test_active_link_view_no_match_inactive_class(self):
+        if not self.view_name_login: self.skipTest("Login URL not reversible.")
+        request = setup_request_for_view(self.factory, self.view_name_login, self.user,
+                                         namespace=self.namespace_login, view_name_for_resolver=self.view_name_login)
+        if not request.resolver_match: self.skipTest(f"Could not set resolver_match for {self.view_name_login}.")
+
+        template_str = "{% load active_link %} {% active_link views='non_existent_view_name' inactive_class='custom-inactive' %}"
+        template = Template(template_str)
+        rendered = template.render(Context({'request': request}))
+        self.assertEqual(rendered.strip(), "custom-inactive")
+
+    def test_active_link_namespace_match(self):
+        if not self.view_name_admin: self.skipTest("Admin URL not reversible.")
+        # The view_name_admin is already namespaced 'admin:index'
+        request = setup_request_for_view(self.factory, self.view_name_admin, self.user,
+                                         namespace=self.namespace_admin, view_name_for_resolver=self.view_name_admin)
+        if not request.resolver_match: self.skipTest(f"Could not set resolver_match for {self.view_name_admin}.")
+        # Ensure the resolver_match has the namespace set correctly by setup_request_for_view
+        self.assertEqual(request.resolver_match.namespace, self.namespace_admin, "Namespace not correctly set in resolver_match for test.")
+
+        template_str = "{% load active_link %} {% active_link namespaces='" + self.namespace_admin + "' %}"
+        template = Template(template_str)
+        rendered = template.render(Context({'request': request}))
+        self.assertEqual(rendered.strip(), "active")
+
+    def test_active_link_multiple_views_one_match(self):
+        if not self.view_name_login: self.skipTest("Login URL not reversible.")
+        request = setup_request_for_view(self.factory, self.view_name_login, self.user,
+                                         namespace=self.namespace_login, view_name_for_resolver=self.view_name_login)
+        if not request.resolver_match: self.skipTest(f"Could not set resolver_match for {self.view_name_login}.")
+
+        template_str = "{% load active_link %} {% active_link views='other_app:other_view||" + self.view_name_login + "' %}"
+        template = Template(template_str)
+        rendered = template.render(Context({'request': request}))
+        self.assertEqual(rendered.strip(), "active")
+
+    def test_active_link_no_request_in_context(self):
+        if not self.view_name_login: self.skipTest("Login URL not reversible for placeholder view name.")
+        template_str = "{% load active_link %} {% active_link views='" + self.view_name_login + "' %}"
+        template = Template(template_str)
+        rendered = template.render(Context({})) # Empty context, no 'request'
+        self.assertEqual(rendered.strip(), "")
+
+    def test_active_link_request_without_resolver_match(self):
+        request = self.factory.get('/some_unresolved_url/') # This URL won't resolve
+        request.user = self.user
+        request.resolver_match = None # Explicitly set to None, as resolve() would fail
+
+        if not self.view_name_login: self.skipTest("Login URL not reversible for placeholder view name.")
+        template_str = "{% load active_link %} {% active_link views='" + self.view_name_login + "' %}"
+        template = Template(template_str)
+        rendered = template.render(Context({'request': request}))
+        self.assertEqual(rendered.strip(), "")

app/apps/common/urls.py

@@ -13,4 +13,9 @@ urlpatterns = [
         views.month_year_picker,
         name="month_year_picker",
     ),
+    path(
+        "cache/invalidate/",
+        views.invalidate_cache,
+        name="invalidate_cache",
+    ),
 ]

app/apps/common/utils/django.py

@@ -35,7 +35,7 @@ def django_to_python_datetime(django_format):
 def django_to_airdatepicker_datetime(django_format):
     format_map = {
         # Time
-        "h": "h",  # Hour (12-hour)
+        "h": "hh",  # Hour (12-hour)
         "H": "H",  # Hour (24-hour)
         "i": "m",  # Minutes
         "A": "AA",  # AM/PM uppercase
@@ -76,7 +76,7 @@ def django_to_airdatepicker_datetime(django_format):
 def django_to_airdatepicker_datetime_separated(django_format):
     format_map = {
         # Time formats
-        "h": "hH",  # Hour (12-hour)
+        "h": "hh",  # Hour (12-hour)
         "H": "HH",  # Hour (24-hour)
         "i": "mm",  # Minutes
         "A": "AA",  # AM/PM uppercase

app/apps/common/views.py

@@ -1,17 +1,33 @@
 from dateutil.relativedelta import relativedelta
+
+from django.contrib import messages
+from django.contrib.auth.decorators import login_required
 from django.db.models import Count
 from django.db.models.functions import ExtractYear, ExtractMonth
+from django.http import HttpResponse
 from django.shortcuts import render
 from django.urls import reverse
 from django.utils import timezone
+from django.views.decorators.http import require_http_methods
+from django.utils.translation import gettext_lazy as _
 
+from cachalot.api import invalidate
+
+from apps.common.decorators.htmx import only_htmx
 from apps.transactions.models import Transaction
+from apps.common.decorators.user import htmx_login_required
 
 
+@only_htmx
+@htmx_login_required
+@require_http_methods(["GET"])
 def toasts(request):
     return render(request, "common/fragments/toasts.html")
 
 
+@only_htmx
+@login_required
+@require_http_methods(["GET"])
 def month_year_picker(request):
     field = request.GET.get("field", "reference_date")
     for_ = request.GET.get("for", None)
@@ -84,3 +100,19 @@ def month_year_picker(request):
             "current_year": current_year,
         },
     )
+
+
+@only_htmx
+@login_required
+@require_http_methods(["GET"])
+def invalidate_cache(request):
+    invalidate()
+
+    messages.success(request, _("Cache cleared successfully"))
+
+    return HttpResponse(
+        status=204,
+        headers={
+            "HX-Trigger": "updated",
+        },
+    )

app/apps/common/widgets/datepicker.py

@@ -2,7 +2,6 @@ import datetime
 
 from django.forms import widgets
 from django.utils import formats, translation, dates
-from django.utils.formats import get_format
 from django.utils.translation import gettext_lazy as _
 
 from apps.common.utils.django import (
@@ -10,6 +9,7 @@ from apps.common.utils.django import (
     django_to_airdatepicker_datetime,
     django_to_airdatepicker_datetime_separated,
 )
+from apps.common.functions.format import get_format
 
 
 class AirDatePickerInput(widgets.DateInput):
@@ -19,15 +19,19 @@ class AirDatePickerInput(widgets.DateInput):
         format=None,
         clear_button=True,
         auto_close=True,
-        user=None,
+        read_only=True,
+        toggle_selected=None,
         *args,
         **kwargs,
     ):
         attrs = attrs or {}
-        self.user = user
         super().__init__(attrs=attrs, format=format, *args, **kwargs)
         self.clear_button = clear_button
         self.auto_close = auto_close
+        self.read_only = read_only
+        self.toggle_selected = (
+            toggle_selected if isinstance(toggle_selected, bool) else self.clear_button
+        )
 
     @staticmethod
     def _get_current_language():
@@ -41,12 +45,6 @@ class AirDatePickerInput(widgets.DateInput):
         if self.format:
             return self.format
 
-        if self.user and hasattr(self.user, "settings"):
-            user_format = self.user.settings.date_format
-            if user_format == "SHORT_DATE_FORMAT":
-                return get_format("SHORT_DATE_FORMAT", use_l10n=True)
-            return user_format
-
         return get_format("SHORT_DATE_FORMAT", use_l10n=True)
 
     def build_attrs(self, base_attrs, extra_attrs=None):
@@ -55,9 +53,13 @@ class AirDatePickerInput(widgets.DateInput):
         attrs["data-now-button-txt"] = _("Today")
         attrs["data-auto-close"] = str(self.auto_close).lower()
         attrs["data-clear-button"] = str(self.clear_button).lower()
+        attrs["data-toggle-selected"] = str(self.toggle_selected).lower()
         attrs["data-language"] = self._get_current_language()
         attrs["data-date-format"] = django_to_airdatepicker_datetime(self._get_format())
 
+        if self.read_only:
+            attrs["readonly"] = True
+
         return attrs
 
     def format_value(self, value):
@@ -97,16 +99,20 @@ class AirDateTimePickerInput(widgets.DateTimeInput):
         timepicker=True,
         clear_button=True,
         auto_close=True,
-        user=None,
+        read_only=True,
+        toggle_selected=None,
         *args,
         **kwargs,
     ):
         attrs = attrs or {}
-        self.user = user
         super().__init__(attrs=attrs, format=format, *args, **kwargs)
         self.timepicker = timepicker
         self.clear_button = clear_button
         self.auto_close = auto_close
+        self.read_only = read_only
+        self.toggle_selected = (
+            toggle_selected if isinstance(toggle_selected, bool) else self.clear_button
+        )
 
     @staticmethod
     def _get_current_language():
@@ -120,12 +126,6 @@ class AirDateTimePickerInput(widgets.DateTimeInput):
         if self.format:
             return self.format
 
-        if self.user and hasattr(self.user, "settings"):
-            user_format = self.user.settings.datetime_format
-            if user_format == "SHORT_DATETIME_FORMAT":
-                return get_format("SHORT_DATETIME_FORMAT", use_l10n=True)
-            return user_format
-
         return get_format("SHORT_DATETIME_FORMAT", use_l10n=True)
 
     def build_attrs(self, base_attrs, extra_attrs=None):
@@ -139,18 +139,27 @@ class AirDateTimePickerInput(widgets.DateTimeInput):
         attrs["data-now-button-txt"] = _("Now")
         attrs["data-timepicker"] = str(self.timepicker).lower()
         attrs["data-auto-close"] = str(self.auto_close).lower()
+        attrs["data-toggle-selected"] = str(self.toggle_selected).lower()
         attrs["data-clear-button"] = str(self.clear_button).lower()
         attrs["data-language"] = self._get_current_language()
         attrs["data-date-format"] = date_format
         attrs["data-time-format"] = time_format
 
+        if self.read_only:
+            attrs["readonly"] = True
+
         return attrs
 
     def format_value(self, value):
         """Format the value for display in the widget."""
-        if value:
+        if value and isinstance(value, (datetime.date, datetime.datetime)):
             self.attrs["data-value"] = datetime.datetime.strftime(
-                value, "%Y-%m-%d %H:%M:00"
+                value, "%Y-%m-%dT%H:%M:00"
+            )
+        elif value and isinstance(value, str):
+            value = datetime.datetime.strptime(value, "%Y-%m-%d %H:%M:00")
+            self.attrs["data-value"] = datetime.datetime.strftime(
+                value, "%Y-%m-%dT%H:%M:00"
             )
 
         if value is None:
@@ -195,6 +204,7 @@ class AirMonthYearPickerInput(AirDatePickerInput):
 
         # Add data attributes for AirDatepicker configuration
         attrs["data-now-button-txt"] = _("Today")
+        attrs["data-date-format"] = "MMMM yyyy"
 
         return attrs
 
@@ -237,3 +247,56 @@ class AirMonthYearPickerInput(AirDatePickerInput):
             except (ValueError, KeyError):
                 return None
         return None
+
+
+class AirYearPickerInput(AirDatePickerInput):
+    def __init__(self, attrs=None, format=None, *args, **kwargs):
+        super().__init__(attrs=attrs, format=format, *args, **kwargs)
+        # Store the display format for AirDatepicker
+        self.display_format = "yyyy"
+        # Store the Python format for internal use
+        self.python_format = "%Y"
+
+    def build_attrs(self, base_attrs, extra_attrs=None):
+        attrs = super().build_attrs(base_attrs, extra_attrs)
+
+        # Add data attributes for AirDatepicker configuration
+        attrs["data-now-button-txt"] = _("Today")
+        attrs["data-date-format"] = "yyyy"
+
+        return attrs
+
+    def format_value(self, value):
+        """Format the value for display in the widget."""
+        if value:
+            self.attrs["data-value"] = (
+                value  # We use this to dynamically select the initial date on AirDatePicker
+            )
+
+        if value is None:
+            return ""
+        if isinstance(value, str):
+            try:
+                value = datetime.datetime.strptime(value, "%Y-%m-%d").date()
+            except ValueError:
+                return value
+        if isinstance(value, (datetime.datetime, datetime.date)):
+            # Use Django's date translation
+            return f"{value.year}"
+        return value
+
+    def value_from_datadict(self, data, files, name):
+        """Convert the value from the widget format back to a format Django can handle."""
+        value = super().value_from_datadict(data, files, name)
+        if value:
+            try:
+                # Split the value into month name and year
+                year_str = value
+                year = int(year_str)
+
+                if year:
+                    # Return the first day of the month in Django's expected format
+                    return datetime.date(year, 1, 1).strftime("%Y-%m-%d")
+            except (ValueError, KeyError):
+                return None
+        return None

app/apps/common/widgets/decimal.py

@@ -1,7 +1,9 @@
 from decimal import Decimal, InvalidOperation
 
 from django import forms
-from django.utils.formats import get_format, number_format
+from django.utils.formats import number_format
+
+from apps.common.functions.format import get_format
 
 
 def convert_to_decimal(value: str):

app/apps/common/widgets/tom_select.py

@@ -1,4 +1,5 @@
 from django.forms import widgets, SelectMultiple
+from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
 
 
@@ -129,3 +130,28 @@ class TomSelect(widgets.Select):
 
 class TomSelectMultiple(SelectMultiple, TomSelect):
     pass
+
+
+class TransactionSelect(TomSelect):
+    def __init__(self, income: bool = True, expense: bool = True, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.load_income = income
+        self.load_expense = expense
+        self.create = False
+
+    def build_attrs(self, base_attrs, extra_attrs=None):
+        attrs = super().build_attrs(base_attrs, extra_attrs)
+
+        if self.load_income and self.load_expense:
+            attrs["data-load"] = reverse("transactions_search")
+        elif self.load_income and not self.load_expense:
+            attrs["data-load"] = reverse(
+                "transactions_search", kwargs={"filter_type": "income"}
+            )
+        elif self.load_expense and not self.load_income:
+            attrs["data-load"] = reverse(
+                "transactions_search", kwargs={"filter_type": "expenses"}
+            )
+
+        return attrs

app/apps/currencies/admin.py

@@ -1,6 +1,6 @@
 from django.contrib import admin
 
-from apps.currencies.models import Currency, ExchangeRate
+from apps.currencies.models import Currency, ExchangeRate, ExchangeRateService
 
 
 @admin.register(Currency)
@@ -11,4 +11,19 @@ class CurrencyAdmin(admin.ModelAdmin):
         return super().formfield_for_dbfield(db_field, request, **kwargs)
 
 
+@admin.register(ExchangeRateService)
+class ExchangeRateServiceAdmin(admin.ModelAdmin):
+    list_display = [
+        "name",
+        "service_type",
+        "is_active",
+        "interval_type",
+        "fetch_interval",
+        "last_fetch",
+    ]
+    list_filter = ["is_active", "service_type"]
+    search_fields = ["name"]
+    filter_horizontal = ["target_currencies"]
+
+
 admin.site.register(ExchangeRate)

app/apps/currencies/exchange_rates/base.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from decimal import Decimal
+from typing import List, Tuple, Optional
+from django.db.models import QuerySet
+
+from apps.currencies.models import Currency
+
+
+class ExchangeRateProvider(ABC):
+    rates_inverted = False
+
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key
+
+    @abstractmethod
+    def get_rates(
+        self, target_currencies: QuerySet, exchange_currencies: set
+    ) -> List[Tuple[Currency, Currency, Decimal]]:
+        """Fetch exchange rates for multiple currency pairs"""
+        raise NotImplementedError("Subclasses must implement get_rates method")
+
+    @classmethod
+    def requires_api_key(cls) -> bool:
+        """Return True if the service requires an API key"""
+        return True
+
+    @staticmethod
+    def invert_rate(rate: Decimal) -> Decimal:
+        """Invert the given rate."""
+        return Decimal("1") / rate

app/apps/currencies/exchange_rates/fetcher.py

@@ -0,0 +1,227 @@
+import logging
+from datetime import timedelta
+
+from django.db.models import QuerySet
+from django.utils import timezone
+
+from apps.currencies.exchange_rates.providers import (
+    SynthFinanceProvider,
+    SynthFinanceStockProvider,
+    CoinGeckoFreeProvider,
+    CoinGeckoProProvider,
+    TransitiveRateProvider,
+)
+from apps.currencies.models import ExchangeRateService, ExchangeRate, Currency
+
+logger = logging.getLogger(__name__)
+
+
+# Map service types to provider classes
+PROVIDER_MAPPING = {
+    "synth_finance": SynthFinanceProvider,
+    "synth_finance_stock": SynthFinanceStockProvider,
+    "coingecko_free": CoinGeckoFreeProvider,
+    "coingecko_pro": CoinGeckoProProvider,
+    "transitive": TransitiveRateProvider,
+}
+
+
+class ExchangeRateFetcher:
+    def _should_fetch_at_hour(service: ExchangeRateService, current_hour: int) -> bool:
+        """Check if service should fetch rates at given hour based on interval type."""
+        try:
+            if service.interval_type == ExchangeRateService.IntervalType.NOT_ON:
+                blocked_hours = ExchangeRateService._parse_hour_ranges(
+                    service.fetch_interval
+                )
+                should_fetch = current_hour not in blocked_hours
+                logger.info(
+                    f"NOT_ON check for {service.name}: "
+                    f"current_hour={current_hour}, "
+                    f"blocked_hours={blocked_hours}, "
+                    f"should_fetch={should_fetch}"
+                )
+                return should_fetch
+
+            if service.interval_type == ExchangeRateService.IntervalType.ON:
+                allowed_hours = ExchangeRateService._parse_hour_ranges(
+                    service.fetch_interval
+                )
+
+                should_fetch = current_hour in allowed_hours
+
+                logger.info(
+                    f"ON check for {service.name}: "
+                    f"current_hour={current_hour}, "
+                    f"allowed_hours={allowed_hours}, "
+                    f"should_fetch={should_fetch}"
+                )
+
+                return should_fetch
+
+            if service.interval_type == ExchangeRateService.IntervalType.EVERY:
+                try:
+                    interval_hours = int(service.fetch_interval)
+
+                    if service.last_fetch is None:
+                        return True
+
+                    # Round down to nearest hour
+                    now = timezone.now().replace(minute=0, second=0, microsecond=0)
+                    last_fetch = service.last_fetch.replace(
+                        minute=0, second=0, microsecond=0
+                    )
+
+                    hours_since_last = (now - last_fetch).total_seconds() / 3600
+                    should_fetch = hours_since_last >= interval_hours
+
+                    logger.info(
+                        f"EVERY check for {service.name}: "
+                        f"hours_since_last={hours_since_last:.1f}, "
+                        f"interval={interval_hours}, "
+                        f"should_fetch={should_fetch}"
+                    )
+                    return should_fetch
+                except ValueError:
+                    logger.error(
+                        f"Invalid EVERY interval format for {service.name}: "
+                        f"expected single number, got '{service.fetch_interval}'"
+                    )
+                    return False
+
+            return False
+
+        except ValueError as e:
+            logger.error(f"Error parsing fetch_interval for {service.name}: {e}")
+            return False
+
+    @staticmethod
+    def fetch_due_rates(force: bool = False) -> None:
+        """
+        Fetch rates for all services that are due for update.
+        Args:
+            force (bool): If True, fetches all active services regardless of their schedule.
+        """
+        services = ExchangeRateService.objects.filter(is_active=True)
+        current_time = timezone.now().astimezone()
+        current_hour = current_time.hour
+
+        for service in services:
+            try:
+                if force:
+                    logger.info(f"Force fetching rates for {service.name}")
+                    ExchangeRateFetcher._fetch_service_rates(service)
+                    continue
+
+                # Check if service should fetch based on interval type
+                if ExchangeRateFetcher._should_fetch_at_hour(service, current_hour):
+                    logger.info(
+                        f"Fetching rates for {service.name}. "
+                        f"Last fetch: {service.last_fetch}, "
+                        f"Interval type: {service.interval_type}, "
+                        f"Current hour: {current_hour}"
+                    )
+                    ExchangeRateFetcher._fetch_service_rates(service)
+                else:
+                    logger.debug(
+                        f"Skipping {service.name}. "
+                        f"Current hour: {current_hour}, "
+                        f"Interval type: {service.interval_type}, "
+                        f"Fetch interval: {service.fetch_interval}"
+                    )
+
+            except Exception as e:
+                logger.error(f"Error checking fetch schedule for {service.name}: {e}")
+
+    @staticmethod
+    def _get_unique_currency_pairs(
+        service: ExchangeRateService,
+    ) -> tuple[QuerySet, set]:
+        """
+        Get unique currency pairs from both target_currencies and target_accounts
+        Returns a tuple of (target_currencies QuerySet, exchange_currencies set)
+        """
+        # Get currencies from target_currencies
+        target_currencies = set(service.target_currencies.all())
+
+        # Add currencies from target_accounts
+        for account in service.target_accounts.all():
+            if account.currency and account.exchange_currency:
+                target_currencies.add(account.currency)
+
+        # Convert back to QuerySet for compatibility with existing code
+        target_currencies_qs = Currency.objects.filter(
+            id__in=[curr.id for curr in target_currencies]
+        )
+
+        # Get unique exchange currencies
+        exchange_currencies = set()
+
+        # From target_currencies
+        for currency in target_currencies:
+            if currency.exchange_currency:
+                exchange_currencies.add(currency.exchange_currency)
+
+        # From target_accounts
+        for account in service.target_accounts.all():
+            if account.exchange_currency:
+                exchange_currencies.add(account.exchange_currency)
+
+        return target_currencies_qs, exchange_currencies
+
+    @staticmethod
+    def _fetch_service_rates(service: ExchangeRateService) -> None:
+        """Fetch rates for a specific service"""
+        try:
+            provider = service.get_provider()
+
+            # Check if API key is required but missing
+            if provider.requires_api_key() and not service.api_key:
+                logger.error(f"API key required but not provided for {service.name}")
+                return
+
+            # Get unique currency pairs from both sources
+            target_currencies, exchange_currencies = (
+                ExchangeRateFetcher._get_unique_currency_pairs(service)
+            )
+
+            # Skip if no currencies to process
+            if not target_currencies or not exchange_currencies:
+                logger.info(f"No currency pairs to process for service {service.name}")
+                return
+
+            rates = provider.get_rates(target_currencies, exchange_currencies)
+
+            # Track processed currency pairs to avoid duplicates
+            processed_pairs = set()
+
+            for from_currency, to_currency, rate in rates:
+                # Create a unique identifier for this currency pair
+                pair_key = (from_currency.id, to_currency.id)
+                if pair_key in processed_pairs:
+                    continue
+
+                if provider.rates_inverted:
+                    # If rates are inverted, we need to swap currencies
+                    ExchangeRate.objects.create(
+                        from_currency=to_currency,
+                        to_currency=from_currency,
+                        rate=rate,
+                        date=timezone.now(),
+                    )
+                    processed_pairs.add((to_currency.id, from_currency.id))
+                else:
+                    # If rates are not inverted, we can use them as is
+                    ExchangeRate.objects.create(
+                        from_currency=from_currency,
+                        to_currency=to_currency,
+                        rate=rate,
+                        date=timezone.now(),
+                    )
+                    processed_pairs.add((from_currency.id, to_currency.id))
+
+            service.last_fetch = timezone.now()
+            service.save()
+
+        except Exception as e:
+            logger.error(f"Error fetching rates for {service.name}: {e}")

app/apps/currencies/exchange_rates/providers.py

@@ -0,0 +1,308 @@
+import logging
+import time
+
+import requests
+from decimal import Decimal
+from typing import Tuple, List, Optional, Dict
+
+from django.db.models import QuerySet
+
+from apps.currencies.models import Currency, ExchangeRate
+from apps.currencies.exchange_rates.base import ExchangeRateProvider
+
+logger = logging.getLogger(__name__)
+
+
+class SynthFinanceProvider(ExchangeRateProvider):
+    """Implementation for Synth Finance API (synthfinance.com)"""
+
+    BASE_URL = "https://api.synthfinance.com/rates/live"
+    rates_inverted = False  # SynthFinance returns non-inverted rates
+
+    def __init__(self, api_key: str = None):
+        super().__init__(api_key)
+        self.session = requests.Session()
+        self.session.headers.update({"Authorization": f"Bearer {self.api_key}"})
+
+    def get_rates(
+        self, target_currencies: QuerySet, exchange_currencies: set
+    ) -> List[Tuple[Currency, Currency, Decimal]]:
+        results = []
+        currency_groups = {}
+        for currency in target_currencies:
+            if currency.exchange_currency in exchange_currencies:
+                group = currency_groups.setdefault(currency.exchange_currency.code, [])
+                group.append(currency)
+
+        for base_currency, currencies in currency_groups.items():
+            try:
+                to_currencies = ",".join(
+                    currency.code
+                    for currency in currencies
+                    if currency.code != base_currency
+                )
+                response = self.session.get(
+                    f"{self.BASE_URL}",
+                    params={"from": base_currency, "to": to_currencies},
+                )
+                response.raise_for_status()
+                data = response.json()
+                rates = data["data"]["rates"]
+
+                for currency in currencies:
+                    if currency.code == base_currency:
+                        rate = Decimal("1")
+                    else:
+                        rate = Decimal(str(rates[currency.code]))
+                    # Return the rate as is, without inversion
+                    results.append((currency.exchange_currency, currency, rate))
+
+                credits_used = data["meta"]["credits_used"]
+                credits_remaining = data["meta"]["credits_remaining"]
+                logger.info(
+                    f"Synth Finance API call: {credits_used} credits used, {credits_remaining} remaining"
+                )
+            except requests.RequestException as e:
+                logger.error(
+                    f"Error fetching rates from Synth Finance API for base {base_currency}: {e}"
+                )
+            except KeyError as e:
+                logger.error(
+                    f"Unexpected response structure from Synth Finance API for base {base_currency}: {e}"
+                )
+            except Exception as e:
+                logger.error(
+                    f"Unexpected error processing Synth Finance data for base {base_currency}: {e}"
+                )
+        return results
+
+
+class CoinGeckoFreeProvider(ExchangeRateProvider):
+    """Implementation for CoinGecko Free API"""
+
+    BASE_URL = "https://api.coingecko.com/api/v3"
+    rates_inverted = True
+
+    def __init__(self, api_key: str):
+        super().__init__(api_key)
+        self.session = requests.Session()
+        self.session.headers.update({"x-cg-demo-api-key": api_key})
+
+    @classmethod
+    def requires_api_key(cls) -> bool:
+        return True
+
+    def get_rates(
+        self, target_currencies: QuerySet, exchange_currencies: set
+    ) -> List[Tuple[Currency, Currency, Decimal]]:
+        results = []
+        all_currencies = set(currency.code.lower() for currency in target_currencies)
+        all_currencies.update(currency.code.lower() for currency in exchange_currencies)
+
+        try:
+            response = self.session.get(
+                f"{self.BASE_URL}/simple/price",
+                params={
+                    "ids": ",".join(all_currencies),
+                    "vs_currencies": ",".join(all_currencies),
+                },
+            )
+            response.raise_for_status()
+            rates_data = response.json()
+
+            for target_currency in target_currencies:
+                if target_currency.exchange_currency in exchange_currencies:
+                    try:
+                        rate = Decimal(
+                            str(
+                                rates_data[target_currency.code.lower()][
+                                    target_currency.exchange_currency.code.lower()
+                                ]
+                            )
+                        )
+                        # The rate is already inverted, so we don't need to invert it again
+                        results.append(
+                            (target_currency.exchange_currency, target_currency, rate)
+                        )
+                    except KeyError:
+                        logger.error(
+                            f"Rate not found for {target_currency.code} or {target_currency.exchange_currency.code}"
+                        )
+                    except Exception as e:
+                        logger.error(
+                            f"Error calculating rate for {target_currency.code}: {e}"
+                        )
+
+            time.sleep(1)  # CoinGecko allows 10-30 calls/minute for free tier
+        except requests.RequestException as e:
+            logger.error(f"Error fetching rates from CoinGecko API: {e}")
+
+        return results
+
+
+class CoinGeckoProProvider(CoinGeckoFreeProvider):
+    """Implementation for CoinGecko Pro API"""
+
+    BASE_URL = "https://pro-api.coingecko.com/api/v3/simple/price"
+    rates_inverted = True
+
+    def __init__(self, api_key: str):
+        super().__init__(api_key)
+        self.session = requests.Session()
+        self.session.headers.update({"x-cg-pro-api-key": api_key})
+
+
+class SynthFinanceStockProvider(ExchangeRateProvider):
+    """Implementation for Synth Finance API Real-Time Prices endpoint (synthfinance.com)"""
+
+    BASE_URL = "https://api.synthfinance.com/tickers"
+    rates_inverted = True
+
+    def __init__(self, api_key: str = None):
+        super().__init__(api_key)
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"Authorization": f"Bearer {self.api_key}", "accept": "application/json"}
+        )
+
+    def get_rates(
+        self, target_currencies: QuerySet, exchange_currencies: set
+    ) -> List[Tuple[Currency, Currency, Decimal]]:
+        results = []
+
+        for currency in target_currencies:
+            if currency.exchange_currency not in exchange_currencies:
+                continue
+
+            try:
+                # Same currency has rate of 1
+                if currency.code == currency.exchange_currency.code:
+                    rate = Decimal("1")
+                    results.append((currency.exchange_currency, currency, rate))
+                    continue
+
+                # Fetch real-time price for this ticker
+                response = self.session.get(
+                    f"{self.BASE_URL}/{currency.code}/real-time"
+                )
+                response.raise_for_status()
+                data = response.json()
+
+                # Use fair market value as the rate
+                rate = Decimal(data["data"]["fair_market_value"])
+                results.append((currency.exchange_currency, currency, rate))
+
+                # Log API usage
+                credits_used = data["meta"]["credits_used"]
+                credits_remaining = data["meta"]["credits_remaining"]
+                logger.info(
+                    f"Synth Finance API call for {currency.code}: {credits_used} credits used, {credits_remaining} remaining"
+                )
+            except requests.RequestException as e:
+                logger.error(
+                    f"Error fetching rate from Synth Finance API for ticker {currency.code}: {e}",
+                    exc_info=True,
+                )
+            except KeyError as e:
+                logger.error(
+                    f"Unexpected response structure from Synth Finance API for ticker {currency.code}: {e}",
+                    exc_info=True,
+                )
+            except Exception as e:
+                logger.error(
+                    f"Unexpected error processing Synth Finance data for ticker {currency.code}: {e}",
+                    exc_info=True,
+                )
+
+        return results
+
+
+class TransitiveRateProvider(ExchangeRateProvider):
+    """Calculates exchange rates through paths of existing rates"""
+
+    rates_inverted = True
+
+    def __init__(self, api_key: str = None):
+        super().__init__(api_key)  # API key not needed but maintaining interface
+
+    @classmethod
+    def requires_api_key(cls) -> bool:
+        return False
+
+    def get_rates(
+        self, target_currencies: QuerySet, exchange_currencies: set
+    ) -> List[Tuple[Currency, Currency, Decimal]]:
+        results = []
+
+        # Get recent rates for building the graph
+        recent_rates = ExchangeRate.objects.all()
+
+        # Build currency graph
+        currency_graph = self._build_currency_graph(recent_rates)
+
+        for target in target_currencies:
+            if (
+                not target.exchange_currency
+                or target.exchange_currency not in exchange_currencies
+            ):
+                continue
+
+            # Find path and calculate rate
+            from_id = target.exchange_currency.id
+            to_id = target.id
+
+            path, rate = self._find_conversion_path(currency_graph, from_id, to_id)
+
+            if path and rate:
+                path_codes = [Currency.objects.get(id=cid).code for cid in path]
+                logger.info(
+                    f"Found conversion path: {' -> '.join(path_codes)}, rate: {rate}"
+                )
+                results.append((target.exchange_currency, target, rate))
+            else:
+                logger.debug(
+                    f"No conversion path found for {target.exchange_currency.code}->{target.code}"
+                )
+
+        return results
+
+    @staticmethod
+    def _build_currency_graph(rates) -> Dict[int, Dict[int, Decimal]]:
+        """Build a graph representation of currency relationships"""
+        graph = {}
+
+        for rate in rates:
+            # Add both directions to make the graph bidirectional
+            if rate.from_currency_id not in graph:
+                graph[rate.from_currency_id] = {}
+            graph[rate.from_currency_id][rate.to_currency_id] = rate.rate
+
+            if rate.to_currency_id not in graph:
+                graph[rate.to_currency_id] = {}
+            graph[rate.to_currency_id][rate.from_currency_id] = Decimal("1") / rate.rate
+
+        return graph
+
+    @staticmethod
+    def _find_conversion_path(
+        graph, from_id, to_id
+    ) -> Tuple[Optional[list], Optional[Decimal]]:
+        """Find the shortest path between currencies using breadth-first search"""
+        if from_id not in graph or to_id not in graph:
+            return None, None
+
+        queue = [(from_id, [from_id], Decimal("1"))]
+        visited = {from_id}
+
+        while queue:
+            current, path, current_rate = queue.pop(0)
+
+            if current == to_id:
+                return path, current_rate
+
+            for neighbor, rate in graph.get(current, {}).items():
+                if neighbor not in visited:
+                    visited.add(neighbor)
+                    queue.append((neighbor, path + [neighbor], current_rate * rate))
+
+        return None, None

app/apps/currencies/forms.py

@@ -1,6 +1,7 @@
+from crispy_bootstrap5.bootstrap5 import Switch
 from crispy_forms.bootstrap import FormActions
 from crispy_forms.helper import FormHelper
-from crispy_forms.layout import Layout
+from crispy_forms.layout import Layout, Row, Column
 from django import forms
 from django.forms import CharField
 from django.utils.translation import gettext_lazy as _
@@ -9,7 +10,7 @@ from apps.common.widgets.crispy.submit import NoClassSubmit
 from apps.common.widgets.datepicker import AirDateTimePickerInput
 from apps.common.widgets.decimal import ArbitraryDecimalDisplayNumberInput
 from apps.common.widgets.tom_select import TomSelect
-from apps.currencies.models import Currency, ExchangeRate
+from apps.currencies.models import Currency, ExchangeRate, ExchangeRateService
 
 
 class CurrencyForm(forms.ModelForm):
@@ -72,7 +73,7 @@ class ExchangeRateForm(forms.ModelForm):
         model = ExchangeRate
         fields = ["from_currency", "to_currency", "rate", "date"]
 
-    def __init__(self, *args, user=None, **kwargs):
+    def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
         self.helper = FormHelper()
@@ -81,8 +82,57 @@ class ExchangeRateForm(forms.ModelForm):
         self.helper.layout = Layout("date", "from_currency", "to_currency", "rate")
 
         self.fields["rate"].widget = ArbitraryDecimalDisplayNumberInput()
-        self.fields["date"].widget = AirDateTimePickerInput(
-            clear_button=False, user=user
+        self.fields["date"].widget = AirDateTimePickerInput(clear_button=False)
+
+        if self.instance and self.instance.pk:
+            self.helper.layout.append(
+                FormActions(
+                    NoClassSubmit(
+                        "submit", _("Update"), css_class="btn btn-outline-primary w-100"
+                    ),
+                ),
+            )
+        else:
+            self.helper.layout.append(
+                FormActions(
+                    NoClassSubmit(
+                        "submit", _("Add"), css_class="btn btn-outline-primary w-100"
+                    ),
+                ),
+            )
+
+
+class ExchangeRateServiceForm(forms.ModelForm):
+    class Meta:
+        model = ExchangeRateService
+        fields = [
+            "name",
+            "service_type",
+            "is_active",
+            "api_key",
+            "interval_type",
+            "fetch_interval",
+            "target_currencies",
+            "target_accounts",
+        ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.helper = FormHelper()
+        self.helper.form_tag = False
+        self.helper.form_method = "post"
+        self.helper.layout = Layout(
+            "name",
+            "service_type",
+            Switch("is_active"),
+            "api_key",
+            Row(
+                Column("interval_type", css_class="form-group col-md-6"),
+                Column("fetch_interval", css_class="form-group col-md-6"),
+            ),
+            "target_currencies",
+            "target_accounts",
         )
 
         if self.instance and self.instance.pk:

app/apps/currencies/migrations/0007_exchangerateservice.py

@@ -0,0 +1,32 @@
+# Generated by Django 5.1.5 on 2025-02-02 20:35
+
+import django.core.validators
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('currencies', '0006_currency_exchange_currency'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ExchangeRateService',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=255, unique=True, verbose_name='Service Name')),
+                ('service_type', models.CharField(choices=[('synth_finance', 'Synth Finance'), ('coingecko', 'CoinGecko')], max_length=255, verbose_name='Service Type')),
+                ('is_active', models.BooleanField(default=True, verbose_name='Active')),
+                ('api_key', models.CharField(blank=True, help_text='API key for the service (if required)', max_length=255, null=True, verbose_name='API Key')),
+                ('fetch_interval_hours', models.PositiveIntegerField(default=24, validators=[django.core.validators.MinValueValidator(1)], verbose_name='Fetch Interval (hours)')),
+                ('last_fetch', models.DateTimeField(blank=True, null=True, verbose_name='Last Successful Fetch')),
+                ('target_currencies', models.ManyToManyField(help_text='Select currencies to fetch exchange rates for. Rates will be fetched for each currency against their exchange_currency.', related_name='exchange_services', to='currencies.currency', verbose_name='Target Currencies')),
+            ],
+            options={
+                'verbose_name': 'Exchange Rate Service',
+                'verbose_name_plural': 'Exchange Rate Services',
+                'ordering': ['name'],
+            },
+        ),
+    ]

app/apps/currencies/migrations/0008_exchangerateservice_target_accounts_and_more.py

@@ -0,0 +1,24 @@
+# Generated by Django 5.1.5 on 2025-02-03 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('accounts', '0008_alter_account_name'),
+        ('currencies', '0007_exchangerateservice'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='exchangerateservice',
+            name='target_accounts',
+            field=models.ManyToManyField(help_text="Select accounts to fetch exchange rates for. Rates will be fetched for each account's currency against their set exchange currency.", related_name='exchange_services', to='accounts.account', verbose_name='Target Accounts'),
+        ),
+        migrations.AlterField(
+            model_name='exchangerateservice',
+            name='target_currencies',
+            field=models.ManyToManyField(help_text='Select currencies to fetch exchange rates for. Rates will be fetched for each currency against their set exchange currency.', related_name='exchange_services', to='currencies.currency', verbose_name='Target Currencies'),
+        ),
+    ]

app/apps/currencies/migrations/0009_alter_exchangerateservice_target_accounts_and_more.py

@@ -0,0 +1,24 @@
+# Generated by Django 5.1.5 on 2025-02-03 01:55
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('accounts', '0008_alter_account_name'),
+        ('currencies', '0008_exchangerateservice_target_accounts_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='exchangerateservice',
+            name='target_accounts',
+            field=models.ManyToManyField(blank=True, help_text="Select accounts to fetch exchange rates for. Rates will be fetched for each account's currency against their set exchange currency.", related_name='exchange_services', to='accounts.account', verbose_name='Target Accounts'),
+        ),
+        migrations.AlterField(
+            model_name='exchangerateservice',
+            name='target_currencies',
+            field=models.ManyToManyField(blank=True, help_text='Select currencies to fetch exchange rates for. Rates will be fetched for each currency against their set exchange currency.', related_name='exchange_services', to='currencies.currency', verbose_name='Target Currencies'),
+        ),
+    ]

app/apps/currencies/migrations/0010_alter_currency_code.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.5 on 2025-02-03 03:17
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('currencies', '0009_alter_exchangerateservice_target_accounts_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='currency',
+            name='code',
+            field=models.CharField(max_length=255, verbose_name='Currency Code'),
+        ),
+    ]

app/apps/currencies/migrations/0011_remove_exchangerateservice_fetch_interval_hours_and_more.py

@@ -0,0 +1,32 @@
+# Generated by Django 5.1.5 on 2025-02-07 02:02
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('currencies', '0010_alter_currency_code'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='exchangerateservice',
+            name='fetch_interval_hours',
+        ),
+        migrations.AddField(
+            model_name='exchangerateservice',
+            name='fetch_interval',
+            field=models.CharField(default='24', max_length=1000, verbose_name='Interval'),
+        ),
+        migrations.AddField(
+            model_name='exchangerateservice',
+            name='interval_type',
+            field=models.CharField(choices=[('on', 'On'), ('every', 'Every X hours'), ('not_on', 'Not on')], default='every', max_length=255, verbose_name='Interval Type'),
+        ),
+        migrations.AlterField(
+            model_name='exchangerateservice',
+            name='service_type',
+            field=models.CharField(choices=[('synth_finance', 'Synth Finance'), ('coingecko_free', 'CoinGecko (Demo/Free)'), ('coingecko_pro', 'CoinGecko (Pro)')], max_length=255, verbose_name='Service Type'),
+        ),
+    ]

app/apps/currencies/migrations/0012_alter_exchangerateservice_service_type.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.6 on 2025-03-02 01:28
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('currencies', '0011_remove_exchangerateservice_fetch_interval_hours_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='exchangerateservice',
+            name='service_type',
+            field=models.CharField(choices=[('synth_finance', 'Synth Finance'), ('synth_finance_stock', 'Synth Finance Stock'), ('coingecko_free', 'CoinGecko (Demo/Free)'), ('coingecko_pro', 'CoinGecko (Pro)')], max_length=255, verbose_name='Service Type'),
+        ),
+    ]

app/apps/currencies/migrations/0013_alter_exchangerateservice_service_type.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.6 on 2025-03-02 01:58
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('currencies', '0012_alter_exchangerateservice_service_type'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='exchangerateservice',
+            name='service_type',
+            field=models.CharField(choices=[('synth_finance', 'Synth Finance'), ('synth_finance_stock', 'Synth Finance Stock'), ('coingecko_free', 'CoinGecko (Demo/Free)'), ('coingecko_pro', 'CoinGecko (Pro)'), ('transitive', 'Transitive (Calculated from Existing Rates)')], max_length=255, verbose_name='Service Type'),
+        ),
+    ]

app/apps/currencies/migrations/0014_alter_currency_options.py

@@ -0,0 +1,17 @@
+# Generated by Django 5.1.7 on 2025-03-09 21:54
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('currencies', '0013_alter_exchangerateservice_service_type'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='currency',
+            options={'ordering': ['name', 'id'], 'verbose_name': 'Currency', 'verbose_name_plural': 'Currencies'},
+        ),
+    ]

app/apps/currencies/models.py

@@ -1,11 +1,18 @@
+import logging
+from typing import Set
+
 from django.core.exceptions import ValidationError
 from django.core.validators import MaxValueValidator, MinValueValidator
 from django.db import models
 from django.utils.translation import gettext_lazy as _
 
+logger = logging.getLogger(__name__)
+
 
 class Currency(models.Model):
-    code = models.CharField(max_length=10, unique=True, verbose_name=_("Currency Code"))
+    code = models.CharField(
+        max_length=255, unique=False, verbose_name=_("Currency Code")
+    )
     name = models.CharField(max_length=50, verbose_name=_("Currency Name"), unique=True)
     decimal_places = models.PositiveIntegerField(
         default=2,
@@ -31,6 +38,7 @@ class Currency(models.Model):
     class Meta:
         verbose_name = _("Currency")
         verbose_name_plural = _("Currencies")
+        ordering = ["name", "id"]
 
     def clean(self):
         super().clean()
@@ -72,7 +80,163 @@ class ExchangeRate(models.Model):
 
     def clean(self):
         super().clean()
-        if self.from_currency == self.to_currency:
+        # Check if the attributes exist before comparing them
+        if hasattr(self, "from_currency") and hasattr(self, "to_currency"):
+            if self.from_currency == self.to_currency:
+                raise ValidationError(
+                    {"to_currency": _("From and To currencies cannot be the same.")}
+                )
+
+
+class ExchangeRateService(models.Model):
+    """Configuration for exchange rate services"""
+
+    class ServiceType(models.TextChoices):
+        SYNTH_FINANCE = "synth_finance", "Synth Finance"
+        SYNTH_FINANCE_STOCK = "synth_finance_stock", "Synth Finance Stock"
+        COINGECKO_FREE = "coingecko_free", "CoinGecko (Demo/Free)"
+        COINGECKO_PRO = "coingecko_pro", "CoinGecko (Pro)"
+        TRANSITIVE = "transitive", "Transitive (Calculated from Existing Rates)"
+
+    class IntervalType(models.TextChoices):
+        ON = "on", _("On")
+        EVERY = "every", _("Every X hours")
+        NOT_ON = "not_on", _("Not on")
+
+    name = models.CharField(max_length=255, unique=True, verbose_name=_("Service Name"))
+    service_type = models.CharField(
+        max_length=255, choices=ServiceType.choices, verbose_name=_("Service Type")
+    )
+    is_active = models.BooleanField(default=True, verbose_name=_("Active"))
+    api_key = models.CharField(
+        max_length=255,
+        blank=True,
+        null=True,
+        verbose_name=_("API Key"),
+        help_text=_("API key for the service (if required)"),
+    )
+    interval_type = models.CharField(
+        max_length=255,
+        choices=IntervalType.choices,
+        verbose_name=_("Interval Type"),
+        default=IntervalType.EVERY,
+    )
+    fetch_interval = models.CharField(
+        max_length=1000, verbose_name=_("Interval"), default="24"
+    )
+    last_fetch = models.DateTimeField(
+        null=True, blank=True, verbose_name=_("Last Successful Fetch")
+    )
+
+    target_currencies = models.ManyToManyField(
+        Currency,
+        verbose_name=_("Target Currencies"),
+        help_text=_(
+            "Select currencies to fetch exchange rates for. Rates will be fetched for each currency against their set exchange currency."
+        ),
+        related_name="exchange_services",
+        blank=True,
+    )
+
+    target_accounts = models.ManyToManyField(
+        "accounts.Account",
+        verbose_name=_("Target Accounts"),
+        help_text=_(
+            "Select accounts to fetch exchange rates for. Rates will be fetched for each account's currency against their set exchange currency."
+        ),
+        related_name="exchange_services",
+        blank=True,
+    )
+
+    class Meta:
+        verbose_name = _("Exchange Rate Service")
+        verbose_name_plural = _("Exchange Rate Services")
+        ordering = ["name"]
+
+    def __str__(self):
+        return self.name
+
+    def get_provider(self):
+        from apps.currencies.exchange_rates.fetcher import PROVIDER_MAPPING
+
+        provider_class = PROVIDER_MAPPING[self.service_type]
+        return provider_class(self.api_key)
+
+    @staticmethod
+    def _parse_hour_ranges(interval_str: str) -> Set[int]:
+        """
+        Parse hour ranges and individual hours from string.
+
+        Valid formats:
+        - Single hours: "1,5,9"
+        - Ranges: "1-5"
+        - Mixed: "1-5,8,10-12"
+
+        Returns set of hours.
+        """
+        hours = set()
+
+        for part in interval_str.strip().split(","):
+            part = part.strip()
+            if "-" in part:
+                start, end = part.split("-")
+                start, end = int(start), int(end)
+                if not (0 <= start <= 23 and 0 <= end <= 23):
+                    raise ValueError("Hours must be between 0 and 23")
+                if start > end:
+                    raise ValueError(f"Invalid range: {start}-{end}")
+                hours.update(range(start, end + 1))
+            else:
+                hour = int(part)
+                if not 0 <= hour <= 23:
+                    raise ValueError("Hours must be between 0 and 23")
+                hours.add(hour)
+
+        return hours
+
+    def clean(self):
+        super().clean()
+        try:
+            if self.interval_type == self.IntervalType.EVERY:
+                if not self.fetch_interval.isdigit():
+                    raise ValidationError(
+                        {
+                            "fetch_interval": _(
+                                "'Every X hours' interval type requires a positive integer."
+                            )
+                        }
+                    )
+                hours = int(self.fetch_interval)
+                if hours < 1 or hours > 24:
+                    raise ValidationError(
+                        {
+                            "fetch_interval": _(
+                                "'Every X hours' interval must be between 1 and 24."
+                            )
+                        }
+                    )
+            else:
+                try:
+                    # Parse and validate hour ranges
+                    hours = self._parse_hour_ranges(self.fetch_interval)
+                    # Store in normalized format (optional)
+                    self.fetch_interval = ",".join(str(h) for h in sorted(hours))
+                except ValueError as e:
+                    raise ValidationError(
+                        {
+                            "fetch_interval": _(
+                                "Invalid hour format. Use comma-separated hours (0-23) "
+                                "and/or ranges (e.g., '1-5,8,10-12')."
+                            )
+                        }
+                    )
+        except ValidationError:
+            raise
+        except Exception as e:
             raise ValidationError(
-                {"to_currency": _("From and To currencies cannot be the same.")}
+                {
+                    "fetch_interval": _(
+                        "Invalid format. Please check the requirements for your selected interval type."
+                    )
+                }
             )

app/apps/currencies/tasks.py

@@ -0,0 +1,30 @@
+import logging
+
+from procrastinate.contrib.django import app
+
+from apps.currencies.exchange_rates.fetcher import ExchangeRateFetcher
+
+logger = logging.getLogger(__name__)
+
+
+@app.periodic(cron="0 * * * *")  # Run every hour
+@app.task(name="automatic_fetch_exchange_rates")
+def automatic_fetch_exchange_rates(timestamp=None):
+    """Fetch exchange rates for all due services"""
+    fetcher = ExchangeRateFetcher()
+
+    try:
+        fetcher.fetch_due_rates()
+    except Exception as e:
+        logger.error(e, exc_info=True)
+
+
+@app.task(name="manual_fetch_exchange_rates")
+def manual_fetch_exchange_rates(timestamp=None):
+    """Fetch exchange rates for all due services"""
+    fetcher = ExchangeRateFetcher()
+
+    try:
+        fetcher.fetch_due_rates(force=True)
+    except Exception as e:
+        logger.error(e, exc_info=True)

app/apps/currencies/tests.py

@@ -4,8 +4,12 @@ from django.core.exceptions import ValidationError
 from django.db import IntegrityError
 from django.test import TestCase
 from django.utils import timezone
+from django.contrib.auth.models import User # Added for ERS owner
+from datetime import date # Added for CurrencyConversionUtilsTests
+from apps.currencies.utils.convert import get_exchange_rate, convert # Added convert
+from unittest.mock import patch # Added patch
 
-from apps.currencies.models import Currency, ExchangeRate
+from apps.currencies.models import Currency, ExchangeRate, ExchangeRateService
 
 
 class CurrencyTests(TestCase):
@@ -52,6 +56,163 @@ class CurrencyTests(TestCase):
         with self.assertRaises(IntegrityError):
             Currency.objects.create(code="USD2", name="US Dollar", decimal_places=2)
 
+    def test_currency_exchange_currency_cannot_be_self(self):
+        """Test that a currency's exchange_currency cannot be itself."""
+        currency = Currency.objects.create(
+            code="XYZ", name="Test XYZ", decimal_places=2
+        )
+        currency.exchange_currency = currency  # Set exchange_currency to self
+
+        with self.assertRaises(ValidationError) as cm:
+            currency.full_clean()
+
+        self.assertIn('exchange_currency', cm.exception.error_dict)
+        # Optionally, check for a specific error message if known:
+        # self.assertTrue(any("cannot be the same as the currency itself" in e.message
+        #                     for e in cm.exception.error_dict['exchange_currency']))
+
+
+class ExchangeRateServiceTests(TestCase):
+    def setUp(self):
+        self.owner = User.objects.create_user(username='ers_owner', password='password123')
+        self.base_currency = Currency.objects.create(code="BSC", name="Base Service Coin", decimal_places=2)
+        self.default_ers_params = {
+            'name': "Test ERS",
+            'owner': self.owner,
+            'base_currency': self.base_currency,
+            'provider_class': "dummy.provider.ClassName", # Placeholder
+        }
+
+    def _create_ers_instance(self, interval_type, fetch_interval, **kwargs):
+        params = {**self.default_ers_params, 'interval_type': interval_type, 'fetch_interval': fetch_interval, **kwargs}
+        return ExchangeRateService(**params)
+
+    # Tests for IntervalType.EVERY
+    def test_ers_interval_every_valid_integer(self):
+        ers = self._create_ers_instance(ExchangeRateService.IntervalType.EVERY, "12")
+        try:
+            ers.full_clean()
+        except ValidationError:
+            self.fail("ValidationError raised unexpectedly for valid 'EVERY' interval '12'.")
+
+    def test_ers_interval_every_invalid_not_integer(self):
+        ers = self._create_ers_instance(ExchangeRateService.IntervalType.EVERY, "abc")
+        with self.assertRaises(ValidationError) as cm:
+            ers.full_clean()
+        self.assertIn('fetch_interval', cm.exception.error_dict)
+
+    def test_ers_interval_every_invalid_too_low(self):
+        ers = self._create_ers_instance(ExchangeRateService.IntervalType.EVERY, "0")
+        with self.assertRaises(ValidationError) as cm:
+            ers.full_clean()
+        self.assertIn('fetch_interval', cm.exception.error_dict)
+
+    def test_ers_interval_every_invalid_too_high(self):
+        ers = self._create_ers_instance(ExchangeRateService.IntervalType.EVERY, "25") # Max is 24 for 'EVERY'
+        with self.assertRaises(ValidationError) as cm:
+            ers.full_clean()
+        self.assertIn('fetch_interval', cm.exception.error_dict)
+
+    # Tests for IntervalType.ON (and by extension NOT_ON, as validation logic is shared)
+    def test_ers_interval_on_not_on_valid_single_hour(self):
+        ers = self._create_ers_instance(ExchangeRateService.IntervalType.ON, "5")
+        try:
+            ers.full_clean() # Should normalize to "5" if not already
+        except ValidationError:
+            self.fail("ValidationError raised unexpectedly for valid 'ON' interval '5'.")
+        self.assertEqual(ers.fetch_interval, "5")
+
+
+    def test_ers_interval_on_not_on_valid_multiple_hours(self):
+        ers = self._create_ers_instance(ExchangeRateService.IntervalType.ON, "1,8,22")
+        try:
+            ers.full_clean()
+        except ValidationError:
+            self.fail("ValidationError raised unexpectedly for valid 'ON' interval '1,8,22'.")
+        self.assertEqual(ers.fetch_interval, "1,8,22")
+
+
+    def test_ers_interval_on_not_on_valid_range(self):
+        ers = self._create_ers_instance(ExchangeRateService.IntervalType.ON, "0-4")
+        ers.full_clean() # Should not raise ValidationError
+        self.assertEqual(ers.fetch_interval, "0,1,2,3,4")
+
+    def test_ers_interval_on_not_on_valid_mixed(self):
+        ers = self._create_ers_instance(ExchangeRateService.IntervalType.ON, "1-3,8,10-12")
+        ers.full_clean() # Should not raise ValidationError
+        self.assertEqual(ers.fetch_interval, "1,2,3,8,10,11,12")
+
+    def test_ers_interval_on_not_on_invalid_char(self):
+        ers = self._create_ers_instance(ExchangeRateService.IntervalType.ON, "1-3,a")
+        with self.assertRaises(ValidationError) as cm:
+            ers.full_clean()
+        self.assertIn('fetch_interval', cm.exception.error_dict)
+
+    def test_ers_interval_on_not_on_invalid_hour_too_high(self):
+        ers = self._create_ers_instance(ExchangeRateService.IntervalType.ON, "24") # Max is 23 for 'ON' type hours
+        with self.assertRaises(ValidationError) as cm:
+            ers.full_clean()
+        self.assertIn('fetch_interval', cm.exception.error_dict)
+
+    def test_ers_interval_on_not_on_invalid_range_format(self):
+        ers = self._create_ers_instance(ExchangeRateService.IntervalType.ON, "5-1")
+        with self.assertRaises(ValidationError) as cm:
+            ers.full_clean()
+        self.assertIn('fetch_interval', cm.exception.error_dict)
+
+    def test_ers_interval_on_not_on_invalid_range_value_too_high(self):
+        ers = self._create_ers_instance(ExchangeRateService.IntervalType.ON, "20-24") # 24 is invalid hour
+        with self.assertRaises(ValidationError) as cm:
+            ers.full_clean()
+        self.assertIn('fetch_interval', cm.exception.error_dict)
+
+    def test_ers_interval_on_not_on_empty_interval(self):
+        ers = self._create_ers_instance(ExchangeRateService.IntervalType.ON, "")
+        with self.assertRaises(ValidationError) as cm:
+            ers.full_clean()
+        self.assertIn('fetch_interval', cm.exception.error_dict)
+
+    @patch('apps.currencies.exchange_rates.fetcher.PROVIDER_MAPPING')
+    def test_get_provider_valid_service_type(self, mock_provider_mapping):
+        """Test get_provider returns a configured provider instance for a valid service_type."""
+
+        class MockSynthFinanceProvider:
+            def __init__(self, key):
+                self.key = key
+
+        # Configure the mock PROVIDER_MAPPING
+        mock_provider_mapping.get.return_value = MockSynthFinanceProvider
+
+        service_instance = self._create_ers_instance(
+            interval_type=ExchangeRateService.IntervalType.EVERY, # Needs some valid interval type
+            fetch_interval="1", # Needs some valid fetch interval
+            service_type=ExchangeRateService.ServiceType.SYNTH_FINANCE,
+            api_key="test_key"
+        )
+        # Ensure the service_type is correctly passed to the mock
+        # The actual get_provider method uses PROVIDER_MAPPING[self.service_type]
+        # So, we should make the mock_provider_mapping behave like a dict for the specific key
+        mock_provider_mapping = {ExchangeRateService.ServiceType.SYNTH_FINANCE: MockSynthFinanceProvider}
+
+        with patch('apps.currencies.exchange_rates.fetcher.PROVIDER_MAPPING', mock_provider_mapping):
+            provider = service_instance.get_provider()
+
+        self.assertIsInstance(provider, MockSynthFinanceProvider)
+        self.assertEqual(provider.key, "test_key")
+
+    @patch('apps.currencies.exchange_rates.fetcher.PROVIDER_MAPPING', {}) # Empty mapping
+    def test_get_provider_invalid_service_type(self, mock_provider_mapping_empty):
+        """Test get_provider raises KeyError for an invalid or unmapped service_type."""
+        service_instance = self._create_ers_instance(
+            interval_type=ExchangeRateService.IntervalType.EVERY,
+            fetch_interval="1",
+            service_type="UNMAPPED_SERVICE_TYPE", # A type not in the (mocked) mapping
+            api_key="any_key"
+        )
+
+        with self.assertRaises(KeyError):
+            service_instance.get_provider()
+
 
 class ExchangeRateTests(TestCase):
     def setUp(self):
@@ -83,10 +244,169 @@ class ExchangeRateTests(TestCase):
             rate=Decimal("0.85"),
             date=date,
         )
-        with self.assertRaises(Exception):  # Could be IntegrityError
+        with self.assertRaises(IntegrityError):
             ExchangeRate.objects.create(
                 from_currency=self.usd,
                 to_currency=self.eur,
                 rate=Decimal("0.86"),
                 date=date,
             )
+
+    def test_from_and_to_currency_cannot_be_same(self):
+        """Test that from_currency and to_currency cannot be the same."""
+        with self.assertRaises(ValidationError) as cm:
+            rate = ExchangeRate(
+                from_currency=self.usd,
+                to_currency=self.usd,  # Same as from_currency
+                rate=Decimal("1.00"),
+                date=timezone.now().date(),
+            )
+            rate.full_clean()
+
+        # Check if the error message is as expected or if the error is associated with a specific field.
+        # The exact key ('to_currency' or '__all__') depends on how the model's clean() method is implemented.
+        # Assuming the validation error is raised with a message like "From and to currency cannot be the same."
+        # and is a non-field error or specifically tied to 'to_currency'.
+        self.assertTrue(
+            '__all__' in cm.exception.error_dict or 'to_currency' in cm.exception.error_dict,
+            "ValidationError should be for '__all__' or 'to_currency'"
+        )
+        # Optionally, check for a specific message if it's consistent:
+        # found_message = False
+        # if '__all__' in cm.exception.error_dict:
+        #     found_message = any("cannot be the same" in e.message for e in cm.exception.error_dict['__all__'])
+        # if not found_message and 'to_currency' in cm.exception.error_dict:
+        #     found_message = any("cannot be the same" in e.message for e in cm.exception.error_dict['to_currency'])
+        # self.assertTrue(found_message, "Error message about currencies being the same not found.")
+
+
+class CurrencyConversionUtilsTests(TestCase):
+    def setUp(self):
+        self.usd = Currency.objects.create(code="USD", name="US Dollar", decimal_places=2, prefix="$", suffix="")
+        self.eur = Currency.objects.create(code="EUR", name="Euro", decimal_places=2, prefix="€", suffix="")
+        self.gbp = Currency.objects.create(code="GBP", name="British Pound", decimal_places=2, prefix="£", suffix="")
+
+        # Rates for USD <-> EUR
+        self.usd_eur_rate_10th = ExchangeRate.objects.create(from_currency=self.usd, to_currency=self.eur, rate=Decimal("0.90"), date=date(2023, 1, 10))
+        self.usd_eur_rate_15th = ExchangeRate.objects.create(from_currency=self.usd, to_currency=self.eur, rate=Decimal("0.92"), date=date(2023, 1, 15))
+        ExchangeRate.objects.create(from_currency=self.usd, to_currency=self.eur, rate=Decimal("0.88"), date=date(2023, 1, 5))
+
+        # Rate for GBP <-> USD (for inverse lookup)
+        self.gbp_usd_rate_10th = ExchangeRate.objects.create(from_currency=self.gbp, to_currency=self.usd, rate=Decimal("1.25"), date=date(2023, 1, 10))
+
+    def test_get_direct_rate_closest_date(self):
+        """Test fetching a direct rate, ensuring the closest date is chosen."""
+        result = get_exchange_rate(self.usd, self.eur, date(2023, 1, 16))
+        self.assertIsNotNone(result)
+        self.assertEqual(result.effective_rate, Decimal("0.92"))
+        self.assertEqual(result.original_from_currency, self.usd)
+        self.assertEqual(result.original_to_currency, self.eur)
+
+    def test_get_inverse_rate_closest_date(self):
+        """Test fetching an inverse rate, ensuring the closest date and correct calculation."""
+        # We are looking for USD to GBP. We have GBP to USD on 2023-01-10.
+        # Target date is 2023-01-12.
+        result = get_exchange_rate(self.usd, self.gbp, date(2023, 1, 12))
+        self.assertIsNotNone(result)
+        self.assertEqual(result.effective_rate, Decimal("1") / self.gbp_usd_rate_10th.rate)
+        self.assertEqual(result.original_from_currency, self.gbp) # original_from_currency should be GBP
+        self.assertEqual(result.original_to_currency, self.usd)   # original_to_currency should be USD
+
+    def test_get_rate_exact_date_preference(self):
+        """Test that an exact date match is preferred over a closer one."""
+        # Existing rate is on 2023-01-15 (0.92)
+        # Add an exact match for the query date
+        exact_date_rate = ExchangeRate.objects.create(from_currency=self.usd, to_currency=self.eur, rate=Decimal("0.91"), date=date(2023, 1, 16))
+
+        result = get_exchange_rate(self.usd, self.eur, date(2023, 1, 16))
+        self.assertIsNotNone(result)
+        self.assertEqual(result.effective_rate, Decimal("0.91"))
+        self.assertEqual(result.original_from_currency, self.usd)
+        self.assertEqual(result.original_to_currency, self.eur)
+
+    def test_get_rate_no_matching_pair(self):
+        """Test that None is returned if no direct or inverse rate exists between the pair."""
+        # No rates exist for EUR <-> GBP in the setUp
+        result = get_exchange_rate(self.eur, self.gbp, date(2023, 1, 10))
+        self.assertIsNone(result)
+
+    def test_get_rate_prefer_direct_over_inverse_same_diff(self):
+        """Test that a direct rate is preferred over an inverse if date differences are equal."""
+        # We have GBP-USD on 2023-01-10 (self.gbp_usd_rate_10th)
+        # This means an inverse USD-GBP rate is available for 2023-01-10.
+        # Add a direct USD-GBP rate for the same date.
+        direct_usd_gbp_rate = ExchangeRate.objects.create(from_currency=self.usd, to_currency=self.gbp, rate=Decimal("0.80"), date=date(2023, 1, 10))
+
+        result = get_exchange_rate(self.usd, self.gbp, date(2023, 1, 10))
+        self.assertIsNotNone(result)
+        self.assertEqual(result.effective_rate, Decimal("0.80"))
+        self.assertEqual(result.original_from_currency, self.usd)
+        self.assertEqual(result.original_to_currency, self.gbp)
+
+        # Now test the EUR to USD case from the problem description
+        # Add EUR to USD, rate 1.1, date 2023-01-10
+        eur_usd_direct_rate = ExchangeRate.objects.create(from_currency=self.eur, to_currency=self.usd, rate=Decimal("1.1"), date=date(2023, 1, 10))
+        # We also have USD to EUR on 2023-01-10 (rate 0.90), which would be an inverse match for EUR to USD.
+
+        result_eur_usd = get_exchange_rate(self.eur, self.usd, date(2023, 1, 10))
+        self.assertIsNotNone(result_eur_usd)
+        self.assertEqual(result_eur_usd.effective_rate, Decimal("1.1"))
+        self.assertEqual(result_eur_usd.original_from_currency, self.eur)
+        self.assertEqual(result_eur_usd.original_to_currency, self.usd)
+
+    def test_convert_successful_direct(self):
+        """Test successful conversion using a direct rate."""
+        # Uses self.usd_eur_rate_15th (0.92) as it's closest to 2023-01-16
+        converted_amount, prefix, suffix, dp = convert(Decimal('100'), self.usd, self.eur, date(2023, 1, 16))
+        self.assertEqual(converted_amount, Decimal('92.00'))
+        self.assertEqual(prefix, self.eur.prefix)
+        self.assertEqual(suffix, self.eur.suffix)
+        self.assertEqual(dp, self.eur.decimal_places)
+
+    def test_convert_successful_inverse(self):
+        """Test successful conversion using an inverse rate."""
+        # Uses self.gbp_usd_rate_10th (GBP to USD @ 1.25), so USD to GBP is 1/1.25 = 0.8
+        # Target date 2023-01-12, closest is 2023-01-10
+        converted_amount, prefix, suffix, dp = convert(Decimal('100'), self.usd, self.gbp, date(2023, 1, 12))
+        expected_amount = Decimal('100') * (Decimal('1') / self.gbp_usd_rate_10th.rate)
+        self.assertEqual(converted_amount, expected_amount.quantize(Decimal('0.01')))
+        self.assertEqual(prefix, self.gbp.prefix)
+        self.assertEqual(suffix, self.gbp.suffix)
+        self.assertEqual(dp, self.gbp.decimal_places)
+
+    def test_convert_no_rate_found(self):
+        """Test conversion when no exchange rate is found."""
+        result_tuple = convert(Decimal('100'), self.eur, self.gbp, date(2023, 1, 10))
+        self.assertEqual(result_tuple, (None, None, None, None))
+
+    def test_convert_same_currency(self):
+        """Test conversion when from_currency and to_currency are the same."""
+        result_tuple = convert(Decimal('100'), self.usd, self.usd, date(2023, 1, 10))
+        self.assertEqual(result_tuple, (None, None, None, None))
+
+    def test_convert_zero_amount(self):
+        """Test conversion when the amount is zero."""
+        result_tuple = convert(Decimal('0'), self.usd, self.eur, date(2023, 1, 10))
+        self.assertEqual(result_tuple, (None, None, None, None))
+
+    @patch('apps.currencies.utils.convert.timezone')
+    def test_convert_no_date_uses_today(self, mock_timezone):
+        """Test conversion uses today's date when no date is provided."""
+        # Mock timezone.now().date() to return a specific date
+        mock_today = date(2023, 1, 16)
+        mock_timezone.now.return_value.date.return_value = mock_today
+
+        # This should use self.usd_eur_rate_15th (0.92) as it's closest to mocked "today" (2023-01-16)
+        converted_amount, prefix, suffix, dp = convert(Decimal('100'), self.usd, self.eur)
+
+        self.assertEqual(converted_amount, Decimal('92.00'))
+        self.assertEqual(prefix, self.eur.prefix)
+        self.assertEqual(suffix, self.eur.suffix)
+        self.assertEqual(dp, self.eur.decimal_places)
+
+        # Verify that timezone.now().date() was called (indirectly, by get_exchange_rate)
+        # This specific assertion for get_exchange_rate being called with a specific date
+        # would require patching get_exchange_rate itself, which is more complex.
+        # For now, we rely on the correct outcome given the mocked date.
+        # A more direct way to test date passing is if convert took get_exchange_rate as a dependency.
+        mock_timezone.now.return_value.date.assert_called_once()

app/apps/currencies/urls.py

@@ -34,4 +34,34 @@ urlpatterns = [
         views.exchange_rate_delete,
         name="exchange_rate_delete",
     ),
+    path(
+        "automatic-exchange-rates/",
+        views.exchange_rates_services_index,
+        name="automatic_exchange_rates_index",
+    ),
+    path(
+        "automatic-exchange-rates/list/",
+        views.exchange_rates_services_list,
+        name="automatic_exchange_rates_list",
+    ),
+    path(
+        "automatic-exchange-rates/add/",
+        views.exchange_rate_service_add,
+        name="automatic_exchange_rate_add",
+    ),
+    path(
+        "automatic-exchange-rates/force-fetch/",
+        views.exchange_rate_service_force_fetch,
+        name="automatic_exchange_rate_force_fetch",
+    ),
+    path(
+        "automatic-exchange-rates/<int:pk>/edit/",
+        views.exchange_rate_service_edit,
+        name="automatic_exchange_rate_edit",
+    ),
+    path(
+        "automatic-exchange-rates/<int:pk>/delete/",
+        views.exchange_rate_service_delete,
+        name="automatic_exchange_rate_delete",
+    ),
 ]

app/apps/currencies/views/__init__.py

@@ -1,2 +1,3 @@
 from .currencies import *
 from .exchange_rates import *
+from .exchange_rates_services import *

app/apps/currencies/views/exchange_rates.py

@@ -27,17 +27,17 @@ def exchange_rates_index(request):
 @require_http_methods(["GET"])
 def exchange_rates_list(request):
     pairings = (
-        ExchangeRate.objects.values("from_currency__code", "to_currency__code")
+        ExchangeRate.objects.values("from_currency__name", "to_currency__name")
         .distinct()
         .annotate(
             pair=Concat(
-                "from_currency__code",
+                "from_currency__name",
                 Value(" x "),
-                "to_currency__code",
+                "to_currency__name",
                 output_field=CharField(),
             )
         )
-        .values_list("pair", "from_currency__code", "to_currency__code")
+        .values_list("pair", "from_currency__name", "to_currency__name")
     )
 
     return render(
@@ -56,7 +56,7 @@ def exchange_rates_list_pair(request):
 
     if from_currency and to_currency:
         exchange_rates = ExchangeRate.objects.filter(
-            from_currency__code=from_currency, to_currency__code=to_currency
+            from_currency__name=from_currency, to_currency__name=to_currency
         ).order_by("-date")
     else:
         exchange_rates = ExchangeRate.objects.all().order_by("-date")
@@ -83,7 +83,7 @@ def exchange_rates_list_pair(request):
 @require_http_methods(["GET", "POST"])
 def exchange_rate_add(request):
     if request.method == "POST":
-        form = ExchangeRateForm(request.POST, user=request.user)
+        form = ExchangeRateForm(request.POST)
         if form.is_valid():
             form.save()
             messages.success(request, _("Exchange rate added successfully"))
@@ -95,7 +95,7 @@ def exchange_rate_add(request):
                 },
             )
     else:
-        form = ExchangeRateForm(user=request.user)
+        form = ExchangeRateForm()
 
     return render(
         request,
@@ -111,7 +111,7 @@ def exchange_rate_edit(request, pk):
     exchange_rate = get_object_or_404(ExchangeRate, id=pk)
 
     if request.method == "POST":
-        form = ExchangeRateForm(request.POST, instance=exchange_rate, user=request.user)
+        form = ExchangeRateForm(request.POST, instance=exchange_rate)
         if form.is_valid():
             form.save()
             messages.success(request, _("Exchange rate updated successfully"))
@@ -123,7 +123,7 @@ def exchange_rate_edit(request, pk):
                 },
             )
     else:
-        form = ExchangeRateForm(instance=exchange_rate, user=request.user)
+        form = ExchangeRateForm(instance=exchange_rate)
 
     return render(
         request,

app/apps/currencies/views/exchange_rates_services.py

@@ -0,0 +1,129 @@
+from django.contrib import messages
+from django.contrib.auth.decorators import login_required
+from django.db.models import CharField, Value
+from django.db.models.functions import Concat
+from django.http import HttpResponse
+from django.shortcuts import render, get_object_or_404
+from django.utils.translation import gettext_lazy as _
+from django.views.decorators.http import require_http_methods
+
+from apps.common.decorators.htmx import only_htmx
+from apps.currencies.forms import ExchangeRateForm, ExchangeRateServiceForm
+from apps.currencies.models import ExchangeRate, ExchangeRateService
+from apps.currencies.tasks import manual_fetch_exchange_rates
+from apps.common.decorators.demo import disabled_on_demo
+
+
+@login_required
+@disabled_on_demo
+@require_http_methods(["GET"])
+def exchange_rates_services_index(request):
+    return render(
+        request,
+        "exchange_rates_services/pages/index.html",
+    )
+
+
+@only_htmx
+@login_required
+@disabled_on_demo
+@require_http_methods(["GET"])
+def exchange_rates_services_list(request):
+    services = ExchangeRateService.objects.all()
+
+    return render(
+        request,
+        "exchange_rates_services/fragments/list.html",
+        {"services": services},
+    )
+
+
+@only_htmx
+@login_required
+@disabled_on_demo
+@require_http_methods(["GET", "POST"])
+def exchange_rate_service_add(request):
+    if request.method == "POST":
+        form = ExchangeRateServiceForm(request.POST)
+        if form.is_valid():
+            form.save()
+            messages.success(request, _("Service added successfully"))
+
+            return HttpResponse(
+                status=204,
+                headers={
+                    "HX-Trigger": "updated, hide_offcanvas",
+                },
+            )
+    else:
+        form = ExchangeRateServiceForm()
+
+    return render(
+        request,
+        "exchange_rates_services/fragments/add.html",
+        {"form": form},
+    )
+
+
+@only_htmx
+@login_required
+@disabled_on_demo
+@require_http_methods(["GET", "POST"])
+def exchange_rate_service_edit(request, pk):
+    service = get_object_or_404(ExchangeRateService, id=pk)
+
+    if request.method == "POST":
+        form = ExchangeRateServiceForm(request.POST, instance=service)
+        if form.is_valid():
+            form.save()
+            messages.success(request, _("Service updated successfully"))
+
+            return HttpResponse(
+                status=204,
+                headers={
+                    "HX-Trigger": "updated, hide_offcanvas",
+                },
+            )
+    else:
+        form = ExchangeRateServiceForm(instance=service)
+
+    return render(
+        request,
+        "exchange_rates_services/fragments/edit.html",
+        {"form": form, "service": service},
+    )
+
+
+@only_htmx
+@login_required
+@disabled_on_demo
+@require_http_methods(["DELETE"])
+def exchange_rate_service_delete(request, pk):
+    service = get_object_or_404(ExchangeRateService, id=pk)
+
+    service.delete()
+
+    messages.success(request, _("Service deleted successfully"))
+
+    return HttpResponse(
+        status=204,
+        headers={
+            "HX-Trigger": "updated, hide_offcanvas",
+        },
+    )
+
+
+@only_htmx
+@login_required
+@disabled_on_demo
+@require_http_methods(["GET"])
+def exchange_rate_service_force_fetch(request):
+    manual_fetch_exchange_rates.defer()
+    messages.success(request, _("Services queued successfully"))
+
+    return HttpResponse(
+        status=204,
+        headers={
+            "HX-Trigger": "toasts",
+        },
+    )

app/apps/dca/admin.py

@@ -1,7 +1,13 @@
 from django.contrib import admin
 
 from apps.dca.models import DCAStrategy, DCAEntry
+from apps.common.admin import SharedObjectModelAdmin
+
 
-# Register your models here.
-admin.site.register(DCAStrategy)
 admin.site.register(DCAEntry)
+
+
+@admin.register(DCAStrategy)
+class TransactionEntityModelAdmin(SharedObjectModelAdmin):
+    def get_queryset(self, request):
+        return DCAStrategy.all_objects.all()

app/apps/dca/forms.py

@@ -1,14 +1,22 @@
-from crispy_forms.bootstrap import FormActions
+from crispy_bootstrap5.bootstrap5 import Switch, BS5Accordion
+from crispy_forms.bootstrap import FormActions, AccordionGroup
 from crispy_forms.helper import FormHelper
-from crispy_forms.layout import Layout, Row, Column
+from crispy_forms.layout import Layout, Row, Column, HTML
 from django import forms
 from django.utils.translation import gettext_lazy as _
 
+from apps.accounts.models import Account
 from apps.common.widgets.crispy.submit import NoClassSubmit
 from apps.common.widgets.datepicker import AirDatePickerInput
 from apps.common.widgets.decimal import ArbitraryDecimalDisplayNumberInput
 from apps.common.widgets.tom_select import TomSelect
 from apps.dca.models import DCAStrategy, DCAEntry
+from apps.common.widgets.tom_select import TransactionSelect
+from apps.transactions.models import Transaction, TransactionTag, TransactionCategory
+from apps.common.fields.forms.dynamic_select import (
+    DynamicModelChoiceField,
+    DynamicModelMultipleChoiceField,
+)
 
 
 class DCAStrategyForm(forms.ModelForm):
@@ -53,6 +61,75 @@ class DCAStrategyForm(forms.ModelForm):
 
 
 class DCAEntryForm(forms.ModelForm):
+    create_transaction = forms.BooleanField(
+        label=_("Create transaction"), initial=False, required=False
+    )
+
+    from_account = forms.ModelChoiceField(
+        queryset=Account.objects.filter(is_archived=False),
+        label=_("From Account"),
+        widget=TomSelect(clear_button=False, group_by="group"),
+        required=False,
+    )
+    to_account = forms.ModelChoiceField(
+        queryset=Account.objects.filter(is_archived=False),
+        label=_("To Account"),
+        widget=TomSelect(clear_button=False, group_by="group"),
+        required=False,
+    )
+
+    from_category = DynamicModelChoiceField(
+        create_field="name",
+        model=TransactionCategory,
+        required=False,
+        label=_("Category"),
+        queryset=TransactionCategory.objects.filter(active=True),
+    )
+    to_category = DynamicModelChoiceField(
+        create_field="name",
+        model=TransactionCategory,
+        required=False,
+        label=_("Category"),
+        queryset=TransactionCategory.objects.filter(active=True),
+    )
+
+    from_tags = DynamicModelMultipleChoiceField(
+        model=TransactionTag,
+        to_field_name="name",
+        create_field="name",
+        required=False,
+        label=_("Tags"),
+        queryset=TransactionTag.objects.filter(active=True),
+    )
+    to_tags = DynamicModelMultipleChoiceField(
+        model=TransactionTag,
+        to_field_name="name",
+        create_field="name",
+        required=False,
+        label=_("Tags"),
+        queryset=TransactionTag.objects.filter(active=True),
+    )
+
+    expense_transaction = DynamicModelChoiceField(
+        model=Transaction,
+        to_field_name="id",
+        label=_("Expense Transaction"),
+        required=False,
+        queryset=Transaction.objects.none(),
+        widget=TransactionSelect(clear_button=True, income=False, expense=True),
+        help_text=_("Type to search for a transaction to link to this entry"),
+    )
+
+    income_transaction = DynamicModelChoiceField(
+        model=Transaction,
+        to_field_name="id",
+        label=_("Income Transaction"),
+        required=False,
+        queryset=Transaction.objects.none(),
+        widget=TransactionSelect(clear_button=True, income=True, expense=False),
+        help_text=_("Type to search for a transaction to link to this entry"),
+    )
+
     class Meta:
         model = DCAEntry
         fields = [
@@ -60,13 +137,19 @@ class DCAEntryForm(forms.ModelForm):
             "amount_paid",
             "amount_received",
             "notes",
+            "expense_transaction",
+            "income_transaction",
         ]
         widgets = {
             "notes": forms.Textarea(attrs={"rows": 3}),
         }
 
-    def __init__(self, *args, user=None, **kwargs):
+    def __init__(self, *args, **kwargs):
+        strategy = kwargs.pop("strategy", None)
         super().__init__(*args, **kwargs)
+
+        self.strategy = strategy if strategy else self.instance.strategy
+
         self.helper = FormHelper()
         self.helper.form_tag = False
         self.helper.layout = Layout(
@@ -75,18 +158,66 @@ class DCAEntryForm(forms.ModelForm):
                 Column("amount_paid", css_class="form-group col-md-6"),
                 Column("amount_received", css_class="form-group col-md-6"),
             ),
-            Row(
-                Column("expense_transaction", css_class="form-group col-md-6"),
-                Column("income_transaction", css_class="form-group col-md-6"),
-            ),
             "notes",
+            BS5Accordion(
+                AccordionGroup(
+                    _("Create transaction"),
+                    Switch("create_transaction"),
+                    Row(
+                        Column(
+                            Row(
+                                Column(
+                                    "from_account",
+                                    css_class="form-group",
+                                ),
+                                css_class="form-row",
+                            ),
+                            Row(
+                                Column(
+                                    "from_category",
+                                    css_class="form-group col-md-6 mb-0",
+                                ),
+                                Column(
+                                    "from_tags", css_class="form-group col-md-6 mb-0"
+                                ),
+                                css_class="form-row",
+                            ),
+                        ),
+                        css_class="p-1 mx-1 my-3 border rounded-3",
+                    ),
+                    Row(
+                        Column(
+                            Row(
+                                Column(
+                                    "to_account",
+                                    css_class="form-group",
+                                ),
+                                css_class="form-row",
+                            ),
+                            Row(
+                                Column(
+                                    "to_category", css_class="form-group col-md-6 mb-0"
+                                ),
+                                Column("to_tags", css_class="form-group col-md-6 mb-0"),
+                                css_class="form-row",
+                            ),
+                        ),
+                        css_class="p-1 mx-1 my-3 border rounded-3",
+                    ),
+                    active=False,
+                ),
+                AccordionGroup(
+                    _("Link transaction"),
+                    "income_transaction",
+                    "expense_transaction",
+                ),
+                flush=False,
+                always_open=False,
+                css_class="mb-3",
+            ),
         )
 
         if self.instance and self.instance.pk:
-            # decimal_places = self.instance.account.currency.decimal_places
-            # self.fields["amount"].widget = ArbitraryDecimalDisplayNumberInput(
-            #     decimal_places=decimal_places
-            # )
             self.helper.layout.append(
                 FormActions(
                     NoClassSubmit(
@@ -95,7 +226,6 @@ class DCAEntryForm(forms.ModelForm):
                 ),
             )
         else:
-            # self.fields["amount"].widget = ArbitraryDecimalDisplayNumberInput()
             self.helper.layout.append(
                 FormActions(
                     NoClassSubmit(
@@ -106,4 +236,137 @@ class DCAEntryForm(forms.ModelForm):
 
         self.fields["amount_paid"].widget = ArbitraryDecimalDisplayNumberInput()
         self.fields["amount_received"].widget = ArbitraryDecimalDisplayNumberInput()
-        self.fields["date"].widget = AirDatePickerInput(clear_button=False, user=user)
+        self.fields["date"].widget = AirDatePickerInput(clear_button=False)
+
+        expense_transaction = None
+        income_transaction = None
+        if self.instance and self.instance.pk:
+            # Edit mode - get from instance
+            expense_transaction = self.instance.expense_transaction
+            income_transaction = self.instance.income_transaction
+        elif self.data.get("expense_transaction"):
+            # Form validation - get from submitted data
+            try:
+                expense_transaction = Transaction.objects.get(
+                    id=self.data["expense_transaction"]
+                )
+                income_transaction = Transaction.objects.get(
+                    id=self.data["income_transaction"]
+                )
+            except Transaction.DoesNotExist:
+                pass
+
+            # If we have a current transaction, ensure it's in the queryset
+        if income_transaction:
+            self.fields["income_transaction"].queryset = Transaction.objects.filter(
+                id=income_transaction.id
+            )
+        if expense_transaction:
+            self.fields["expense_transaction"].queryset = Transaction.objects.filter(
+                id=expense_transaction.id
+            )
+
+        self.fields["from_account"].queryset = Account.objects.filter(
+            is_archived=False,
+        )
+
+        self.fields["from_category"].queryset = TransactionCategory.objects.filter(
+            active=True
+        )
+        self.fields["from_tags"].queryset = TransactionTag.objects.filter(active=True)
+
+        self.fields["to_account"].queryset = Account.objects.filter(
+            is_archived=False,
+        )
+
+        self.fields["to_category"].queryset = TransactionCategory.objects.filter(
+            active=True
+        )
+        self.fields["to_tags"].queryset = TransactionTag.objects.filter(active=True)
+
+    def clean(self):
+        cleaned_data = super().clean()
+
+        if cleaned_data.get("create_transaction"):
+            from_account = cleaned_data.get("from_account")
+            to_account = cleaned_data.get("to_account")
+
+            if not from_account and not to_account:
+                raise forms.ValidationError(
+                    {
+                        "from_account": _("You must provide an account."),
+                        "to_account": _("You must provide an account."),
+                    }
+                )
+            elif not from_account and to_account:
+                raise forms.ValidationError(
+                    {"from_account": _("You must provide an account.")}
+                )
+            elif not to_account and from_account:
+                raise forms.ValidationError(
+                    {"to_account": _("You must provide an account.")}
+                )
+
+            if from_account == to_account:
+                raise forms.ValidationError(
+                    _("From and To accounts must be different.")
+                )
+
+        return cleaned_data
+
+    def save(self, **kwargs):
+        instance = super().save(commit=False)
+
+        if self.cleaned_data.get("create_transaction"):
+            from_account = self.cleaned_data["from_account"]
+            to_account = self.cleaned_data["to_account"]
+            from_amount = instance.amount_paid
+            to_amount = instance.amount_received
+            date = instance.date
+            description = _("DCA for %(strategy_name)s") % {
+                "strategy_name": self.strategy.name
+            }
+            from_category = self.cleaned_data.get("from_category")
+            to_category = self.cleaned_data.get("to_category")
+            notes = self.cleaned_data.get("notes")
+
+            # Create "From" transaction
+            from_transaction = Transaction.objects.create(
+                account=from_account,
+                type=Transaction.Type.EXPENSE,
+                is_paid=True,
+                date=date,
+                amount=from_amount,
+                description=description,
+                category=from_category,
+                notes=notes,
+            )
+            from_transaction.tags.set(self.cleaned_data.get("from_tags", []))
+
+            # Create "To" transaction
+            to_transaction = Transaction.objects.create(
+                account=to_account,
+                type=Transaction.Type.INCOME,
+                is_paid=True,
+                date=date,
+                amount=to_amount,
+                description=description,
+                category=to_category,
+                notes=notes,
+            )
+            to_transaction.tags.set(self.cleaned_data.get("to_tags", []))
+
+            instance.expense_transaction = from_transaction
+            instance.income_transaction = to_transaction
+        else:
+            if instance.expense_transaction:
+                instance.expense_transaction.amount = instance.amount_paid
+                instance.expense_transaction.save()
+            if instance.income_transaction:
+                instance.income_transaction.amount = instance.amount_received
+                instance.income_transaction.save()
+
+        instance.strategy = self.strategy
+        instance.save()
+
+        return instance

app/apps/dca/migrations/0003_dcastrategy_owner_dcastrategy_shared_with_and_more.py

@@ -0,0 +1,31 @@
+# Generated by Django 5.1.6 on 2025-03-07 18:20
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dca', '0002_alter_dcaentry_amount_paid_and_more'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='dcastrategy',
+            name='owner',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='%(class)s_owned', to=settings.AUTH_USER_MODEL),
+        ),
+        migrations.AddField(
+            model_name='dcastrategy',
+            name='shared_with',
+            field=models.ManyToManyField(blank=True, related_name='%(class)s_shared', to=settings.AUTH_USER_MODEL),
+        ),
+        migrations.AddField(
+            model_name='dcastrategy',
+            name='visibility',
+            field=models.CharField(choices=[('private', 'Private'), ('public', 'Public')], default='private', max_length=10),
+        ),
+    ]

app/apps/dca/models.py

@@ -1,16 +1,15 @@
-from datetime import timedelta
 from decimal import Decimal
-from statistics import mean, stdev
 
 from django.db import models
 from django.template.defaultfilters import date
 from django.utils import timezone
 from django.utils.translation import gettext_lazy as _
 
+from apps.common.models import SharedObject, SharedObjectManager
 from apps.currencies.utils.convert import convert, get_exchange_rate
 
 
-class DCAStrategy(models.Model):
+class DCAStrategy(SharedObject):
     name = models.CharField(max_length=255, verbose_name=_("Name"))
     target_currency = models.ForeignKey(
         "currencies.Currency",
@@ -28,6 +27,9 @@ class DCAStrategy(models.Model):
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
 
+    objects = SharedObjectManager()
+    all_objects = models.Manager()  # Unfiltered manager
+
     class Meta:
         verbose_name = _("DCA Strategy")
         verbose_name_plural = _("DCA Strategies")

app/apps/dca/tests.py

@@ -1,3 +1,344 @@
-from django.test import TestCase
+from django.test import TestCase, Client
+from django.contrib.auth.models import User
+from django.urls import reverse
+from django.forms import NON_FIELD_ERRORS
+from apps.currencies.models import Currency
+from apps.dca.models import DCAStrategy, DCAEntry
+from apps.dca.forms import DCAStrategyForm, DCAEntryForm # Added DCAEntryForm
+from apps.accounts.models import Account, AccountGroup # Added Account models
+from apps.transactions.models import TransactionCategory, Transaction # Added Transaction models
+from decimal import Decimal
+from datetime import date
+from unittest.mock import patch
 
-# Create your tests here.
+class DCATests(TestCase):
+    def setUp(self):
+        self.owner = User.objects.create_user(username='testowner', password='password123')
+        self.client = Client()
+        self.client.login(username='testowner', password='password123')
+
+        self.payment_curr = Currency.objects.create(code="USD", name="US Dollar", decimal_places=2)
+        self.target_curr = Currency.objects.create(code="BTC", name="Bitcoin", decimal_places=8)
+
+        # AccountGroup for accounts
+        self.account_group = AccountGroup.objects.create(name="DCA Test Group", owner=self.owner)
+
+        # Accounts for transactions
+        self.account1 = Account.objects.create(
+            name="Payment Account USD",
+            owner=self.owner,
+            currency=self.payment_curr,
+            group=self.account_group
+        )
+        self.account2 = Account.objects.create(
+            name="Target Account BTC",
+            owner=self.owner,
+            currency=self.target_curr,
+            group=self.account_group
+        )
+
+        # TransactionCategory for transactions
+        # Using INFO type as it's generic. TRANSFER might imply specific paired transaction logic not relevant here.
+        self.category1 = TransactionCategory.objects.create(
+            name="DCA Category",
+            owner=self.owner,
+            type=TransactionCategory.TransactionType.INFO
+        )
+
+
+        self.strategy1 = DCAStrategy.objects.create(
+            name="Test Strategy 1",
+            owner=self.owner,
+            payment_currency=self.payment_curr,
+            target_currency=self.target_curr
+        )
+
+        self.entries1 = [
+            DCAEntry.objects.create(
+                strategy=self.strategy1,
+                date=date(2023, 1, 1),
+                amount_paid=Decimal('100.00'),
+                amount_received=Decimal('0.010')
+            ),
+            DCAEntry.objects.create(
+                strategy=self.strategy1,
+                date=date(2023, 2, 1),
+                amount_paid=Decimal('150.00'),
+                amount_received=Decimal('0.012')
+            ),
+            DCAEntry.objects.create(
+                strategy=self.strategy1,
+                date=date(2023, 3, 1),
+                amount_paid=Decimal('120.00'),
+                amount_received=Decimal('0.008')
+            )
+        ]
+
+    def test_strategy_index_view_authenticated_user(self):
+        # Uses self.client and self.owner from setUp
+        response = self.client.get(reverse('dca:dca_strategy_index'))
+        self.assertEqual(response.status_code, 200)
+
+    def test_strategy_totals_and_average_price(self):
+        self.assertEqual(self.strategy1.total_entries(), 3)
+        self.assertEqual(self.strategy1.total_invested(), Decimal('370.00')) # 100 + 150 + 120
+        self.assertEqual(self.strategy1.total_received(), Decimal('0.030'))  # 0.01 + 0.012 + 0.008
+
+        expected_avg_price = Decimal('370.00') / Decimal('0.030')
+        # Match precision of the model method if it's specific, e.g. quantize
+        # For now, direct comparison. The model might return a Decimal that needs specific quantizing.
+        self.assertEqual(self.strategy1.average_entry_price(), expected_avg_price)
+
+    def test_strategy_average_price_no_received(self):
+        strategy2 = DCAStrategy.objects.create(
+            name="Test Strategy 2",
+            owner=self.owner,
+            payment_currency=self.payment_curr,
+            target_currency=self.target_curr
+        )
+        DCAEntry.objects.create(
+            strategy=strategy2,
+            date=date(2023, 4, 1),
+            amount_paid=Decimal('100.00'),
+            amount_received=Decimal('0') # Total received is zero
+        )
+        self.assertEqual(strategy2.total_received(), Decimal('0'))
+        self.assertEqual(strategy2.average_entry_price(), Decimal('0'))
+
+    @patch('apps.dca.models.convert')
+    def test_dca_entry_value_and_pl(self, mock_convert):
+        entry = self.entries1[0] # amount_paid=100, amount_received=0.010
+
+        # Simulate current price: 1 target_curr = 20,000 payment_curr
+        # So, 0.010 target_curr should be 0.010 * 20000 = 200 payment_curr
+        simulated_converted_value = entry.amount_received * Decimal('20000')
+        mock_convert.return_value = (
+            simulated_converted_value,
+            self.payment_curr.prefix,
+            self.payment_curr.suffix,
+            self.payment_curr.decimal_places
+        )
+
+        current_val = entry.current_value()
+        self.assertEqual(current_val, Decimal('200.00'))
+
+        # Profit/Loss = current_value - amount_paid = 200 - 100 = 100
+        self.assertEqual(entry.profit_loss(), Decimal('100.00'))
+
+        # P/L % = (profit_loss / amount_paid) * 100 = (100 / 100) * 100 = 100
+        self.assertEqual(entry.profit_loss_percentage(), Decimal('100.00'))
+
+        # Check that convert was called correctly by current_value()
+        # current_value calls convert(self.amount_received, self.strategy.target_currency, self.strategy.payment_currency)
+        # The date argument defaults to None if not passed, which is the case here.
+        mock_convert.assert_called_once_with(
+            entry.amount_received,
+            self.strategy1.target_currency,
+            self.strategy1.payment_currency,
+            None # Date argument is optional and defaults to None
+        )
+
+    @patch('apps.dca.models.convert')
+    def test_dca_strategy_value_and_pl(self, mock_convert):
+
+        def side_effect_func(amount_to_convert, from_currency, to_currency, date=None):
+            if from_currency == self.target_curr and to_currency == self.payment_curr:
+                # Simulate current price: 1 target_curr = 20,000 payment_curr
+                converted_value = amount_to_convert * Decimal('20000')
+                return (converted_value, self.payment_curr.prefix, self.payment_curr.suffix, self.payment_curr.decimal_places)
+            # Fallback for any other unexpected calls, though not expected in this test
+            return (Decimal('0'), '', '', 2)
+
+        mock_convert.side_effect = side_effect_func
+
+        # strategy1 entries:
+        # 1: paid 100, received 0.010. Current value = 0.010 * 20000 = 200
+        # 2: paid 150, received 0.012. Current value = 0.012 * 20000 = 240
+        # 3: paid 120, received 0.008. Current value = 0.008 * 20000 = 160
+        # Total current value = 200 + 240 + 160 = 600
+        self.assertEqual(self.strategy1.current_total_value(), Decimal('600.00'))
+
+        # Total invested = 100 + 150 + 120 = 370
+        # Total profit/loss = current_total_value - total_invested = 600 - 370 = 230
+        self.assertEqual(self.strategy1.total_profit_loss(), Decimal('230.00'))
+
+        # Total P/L % = (total_profit_loss / total_invested) * 100
+        # (230 / 370) * 100 = 62.162162...
+        expected_pl_percentage = (Decimal('230.00') / Decimal('370.00')) * Decimal('100')
+        self.assertAlmostEqual(self.strategy1.total_profit_loss_percentage(), expected_pl_percentage, places=2)
+
+    def test_dca_strategy_form_valid_data(self):
+        form_data = {
+            'name': 'Form Test Strategy',
+            'target_currency': self.target_curr.pk,
+            'payment_currency': self.payment_curr.pk
+        }
+        form = DCAStrategyForm(data=form_data)
+        self.assertTrue(form.is_valid(), form.errors.as_text())
+
+        strategy = form.save(commit=False)
+        strategy.owner = self.owner
+        strategy.save()
+
+        self.assertEqual(strategy.name, 'Form Test Strategy')
+        self.assertEqual(strategy.owner, self.owner)
+        self.assertEqual(strategy.target_currency, self.target_curr)
+        self.assertEqual(strategy.payment_currency, self.payment_curr)
+
+    def test_dca_strategy_form_missing_name(self):
+        form_data = {
+            'target_currency': self.target_curr.pk,
+            'payment_currency': self.payment_curr.pk
+        }
+        form = DCAStrategyForm(data=form_data)
+        self.assertFalse(form.is_valid())
+        self.assertIn('name', form.errors)
+
+    def test_dca_strategy_form_missing_target_currency(self):
+        form_data = {
+            'name': 'Form Test Missing Target',
+            'payment_currency': self.payment_curr.pk
+        }
+        form = DCAStrategyForm(data=form_data)
+        self.assertFalse(form.is_valid())
+        self.assertIn('target_currency', form.errors)
+
+    # Tests for DCAEntryForm clean method
+    def test_dca_entry_form_clean_create_transaction_missing_accounts(self):
+        data = {
+            'date': date(2023, 1, 1),
+            'amount_paid': Decimal('100.00'),
+            'amount_received': Decimal('0.01'),
+            'create_transaction': True,
+            # from_account and to_account are missing
+        }
+        form = DCAEntryForm(data=data, strategy=self.strategy1, owner=self.owner)
+        self.assertFalse(form.is_valid())
+        self.assertIn('from_account', form.errors)
+        self.assertIn('to_account', form.errors)
+
+    def test_dca_entry_form_clean_create_transaction_same_accounts(self):
+        data = {
+            'date': date(2023, 1, 1),
+            'amount_paid': Decimal('100.00'),
+            'amount_received': Decimal('0.01'),
+            'create_transaction': True,
+            'from_account': self.account1.pk,
+            'to_account': self.account1.pk, # Same as from_account
+            'from_category': self.category1.pk,
+            'to_category': self.category1.pk,
+        }
+        form = DCAEntryForm(data=data, strategy=self.strategy1, owner=self.owner)
+        self.assertFalse(form.is_valid())
+        # Check for non-field error or specific field error based on form implementation
+        self.assertTrue(NON_FIELD_ERRORS in form.errors or 'to_account' in form.errors)
+        if NON_FIELD_ERRORS in form.errors:
+             self.assertTrue(any("From and To accounts must be different" in error for error in form.errors[NON_FIELD_ERRORS]))
+
+
+    # Tests for DCAEntryForm save method
+    def test_dca_entry_form_save_create_transactions(self):
+        data = {
+            'date': date(2023, 5, 1),
+            'amount_paid': Decimal('200.00'),
+            'amount_received': Decimal('0.025'),
+            'create_transaction': True,
+            'from_account': self.account1.pk,
+            'to_account': self.account2.pk,
+            'from_category': self.category1.pk,
+            'to_category': self.category1.pk,
+            'description': 'Test DCA entry transaction creation'
+        }
+        form = DCAEntryForm(data=data, strategy=self.strategy1, owner=self.owner)
+
+        if not form.is_valid():
+            print(form.errors.as_json()) # Print errors if form is invalid
+        self.assertTrue(form.is_valid())
+
+        entry = form.save()
+
+        self.assertIsNotNone(entry.pk)
+        self.assertEqual(entry.strategy, self.strategy1)
+        self.assertIsNotNone(entry.expense_transaction)
+        self.assertIsNotNone(entry.income_transaction)
+
+        # Check expense transaction
+        expense_tx = entry.expense_transaction
+        self.assertEqual(expense_tx.account, self.account1)
+        self.assertEqual(expense_tx.type, Transaction.Type.EXPENSE)
+        self.assertEqual(expense_tx.amount, data['amount_paid'])
+        self.assertEqual(expense_tx.category, self.category1)
+        self.assertEqual(expense_tx.owner, self.owner)
+        self.assertEqual(expense_tx.date, data['date'])
+        self.assertIn(str(entry.id)[:8], expense_tx.description) # Check if part of entry ID is in description
+
+        # Check income transaction
+        income_tx = entry.income_transaction
+        self.assertEqual(income_tx.account, self.account2)
+        self.assertEqual(income_tx.type, Transaction.Type.INCOME)
+        self.assertEqual(income_tx.amount, data['amount_received'])
+        self.assertEqual(income_tx.category, self.category1)
+        self.assertEqual(income_tx.owner, self.owner)
+        self.assertEqual(income_tx.date, data['date'])
+        self.assertIn(str(entry.id)[:8], income_tx.description)
+
+
+    def test_dca_entry_form_save_update_linked_transactions(self):
+        # 1. Create an initial DCAEntry with linked transactions
+        initial_data = {
+            'date': date(2023, 6, 1),
+            'amount_paid': Decimal('50.00'),
+            'amount_received': Decimal('0.005'),
+            'create_transaction': True,
+            'from_account': self.account1.pk,
+            'to_account': self.account2.pk,
+            'from_category': self.category1.pk,
+            'to_category': self.category1.pk,
+        }
+        initial_form = DCAEntryForm(data=initial_data, strategy=self.strategy1, owner=self.owner)
+        self.assertTrue(initial_form.is_valid(), initial_form.errors.as_json())
+        initial_entry = initial_form.save()
+
+        self.assertIsNotNone(initial_entry.expense_transaction)
+        self.assertIsNotNone(initial_entry.income_transaction)
+
+        # 2. Data for updating the form
+        update_data = {
+            'date': initial_entry.date, # Keep date same or change, as needed
+            'amount_paid': Decimal('55.00'), # New value
+            'amount_received': Decimal('0.006'), # New value
+            # 'create_transaction': False, # Or not present, form should not create new if instance has linked tx
+            'from_account': initial_entry.expense_transaction.account.pk, # Keep same accounts
+            'to_account': initial_entry.income_transaction.account.pk,
+            'from_category': initial_entry.expense_transaction.category.pk,
+            'to_category': initial_entry.income_transaction.category.pk,
+        }
+
+        # When create_transaction is not checked (or False), it means we are not creating *new* transactions,
+        # but if the instance already has linked transactions, they *should* be updated.
+        # The form's save method should handle this.
+
+        update_form = DCAEntryForm(data=update_data, instance=initial_entry, strategy=initial_entry.strategy, owner=self.owner)
+
+        if not update_form.is_valid():
+            print(update_form.errors.as_json()) # Print errors if form is invalid
+        self.assertTrue(update_form.is_valid())
+
+        updated_entry = update_form.save()
+
+        # Refresh from DB to ensure changes are saved and reflected
+        updated_entry.refresh_from_db()
+        if updated_entry.expense_transaction: # Check if it exists before trying to refresh
+            updated_entry.expense_transaction.refresh_from_db()
+        if updated_entry.income_transaction: # Check if it exists before trying to refresh
+            updated_entry.income_transaction.refresh_from_db()
+
+
+        self.assertEqual(updated_entry.amount_paid, Decimal('55.00'))
+        self.assertEqual(updated_entry.amount_received, Decimal('0.006'))
+
+        self.assertIsNotNone(updated_entry.expense_transaction, "Expense transaction should still be linked.")
+        self.assertEqual(updated_entry.expense_transaction.amount, Decimal('55.00'))
+
+        self.assertIsNotNone(updated_entry.income_transaction, "Income transaction should still be linked.")
+        self.assertEqual(updated_entry.income_transaction.amount, Decimal('0.006'))

app/apps/dca/urls.py

@@ -12,6 +12,16 @@ urlpatterns = [
         views.strategy_delete,
         name="dca_strategy_delete",
     ),
+    path(
+        "dca/<int:strategy_id>/take-ownership/",
+        views.strategy_take_ownership,
+        name="dca_strategy_take_ownership",
+    ),
+    path(
+        "dca/<int:pk>/share/",
+        views.strategy_share,
+        name="dca_strategy_share_settings",
+    ),
     path(
         "dca/<int:strategy_id>/",
         views.strategy_detail_index,

app/apps/dca/views.py

@@ -11,6 +11,8 @@ from django.views.decorators.http import require_http_methods
 from apps.common.decorators.htmx import only_htmx
 from apps.dca.forms import DCAEntryForm, DCAStrategyForm
 from apps.dca.models import DCAStrategy, DCAEntry
+from apps.common.models import SharedObject
+from apps.common.forms import SharedObjectForm
 
 
 @login_required
@@ -57,6 +59,16 @@ def strategy_add(request):
 def strategy_edit(request, strategy_id):
     dca_strategy = get_object_or_404(DCAStrategy, id=strategy_id)
 
+    if dca_strategy.owner and dca_strategy.owner != request.user:
+        messages.error(request, _("Only the owner can edit this"))
+
+        return HttpResponse(
+            status=204,
+            headers={
+                "HX-Trigger": "updated, hide_offcanvas",
+            },
+        )
+
     if request.method == "POST":
         form = DCAStrategyForm(request.POST, instance=dca_strategy)
         if form.is_valid():
@@ -85,9 +97,15 @@ def strategy_edit(request, strategy_id):
 def strategy_delete(request, strategy_id):
     dca_strategy = get_object_or_404(DCAStrategy, id=strategy_id)
 
-    dca_strategy.delete()
-
-    messages.success(request, _("DCA strategy deleted successfully"))
+    if (
+        dca_strategy.owner != request.user
+        and request.user in dca_strategy.shared_with.all()
+    ):
+        dca_strategy.shared_with.remove(request.user)
+        messages.success(request, _("Item no longer shared with you"))
+    else:
+        dca_strategy.delete()
+        messages.success(request, _("DCA strategy deleted successfully"))
 
     return HttpResponse(
         status=204,
@@ -97,6 +115,65 @@ def strategy_delete(request, strategy_id):
     )
 
 
+@only_htmx
+@login_required
+@require_http_methods(["GET"])
+def strategy_take_ownership(request, strategy_id):
+    dca_strategy = get_object_or_404(DCAStrategy, id=strategy_id)
+
+    if not dca_strategy.owner:
+        dca_strategy.owner = request.user
+        dca_strategy.visibility = SharedObject.Visibility.private
+        dca_strategy.save()
+
+        messages.success(request, _("Ownership taken successfully"))
+
+    return HttpResponse(
+        status=204,
+        headers={
+            "HX-Trigger": "updated, hide_offcanvas",
+        },
+    )
+
+
+@only_htmx
+@login_required
+@require_http_methods(["GET", "POST"])
+def strategy_share(request, pk):
+    obj = get_object_or_404(DCAStrategy, id=pk)
+
+    if obj.owner and obj.owner != request.user:
+        messages.error(request, _("Only the owner can edit this"))
+
+        return HttpResponse(
+            status=204,
+            headers={
+                "HX-Trigger": "updated, hide_offcanvas",
+            },
+        )
+
+    if request.method == "POST":
+        form = SharedObjectForm(request.POST, instance=obj, user=request.user)
+        if form.is_valid():
+            form.save()
+            messages.success(request, _("Configuration saved successfully"))
+
+            return HttpResponse(
+                status=204,
+                headers={
+                    "HX-Trigger": "updated, hide_offcanvas",
+                },
+            )
+    else:
+        form = SharedObjectForm(instance=obj, user=request.user)
+
+    return render(
+        request,
+        "dca/fragments/strategy/share.html",
+        {"form": form, "object": obj},
+    )
+
+
 @login_required
 def strategy_detail_index(request, strategy_id):
     strategy = get_object_or_404(DCAStrategy, id=strategy_id)
@@ -155,11 +232,9 @@ def strategy_detail(request, strategy_id):
 def strategy_entry_add(request, strategy_id):
     strategy = get_object_or_404(DCAStrategy, id=strategy_id)
     if request.method == "POST":
-        form = DCAEntryForm(request.POST, user=request.user)
+        form = DCAEntryForm(request.POST, strategy=strategy)
         if form.is_valid():
-            entry = form.save(commit=False)
-            entry.strategy = strategy
-            entry.save()
+            entry = form.save()
             messages.success(request, _("Entry added successfully"))
 
             return HttpResponse(
@@ -169,7 +244,7 @@ def strategy_entry_add(request, strategy_id):
                 },
             )
     else:
-        form = DCAEntryForm(user=request.user)
+        form = DCAEntryForm(strategy=strategy)
 
     return render(
         request,
@@ -184,7 +259,7 @@ def strategy_entry_edit(request, strategy_id, entry_id):
     dca_entry = get_object_or_404(DCAEntry, id=entry_id, strategy__id=strategy_id)
 
     if request.method == "POST":
-        form = DCAEntryForm(request.POST, instance=dca_entry, user=request.user)
+        form = DCAEntryForm(request.POST, instance=dca_entry)
         if form.is_valid():
             form.save()
             messages.success(request, _("Entry updated successfully"))
@@ -196,7 +271,7 @@ def strategy_entry_edit(request, strategy_id, entry_id):
                 },
             )
     else:
-        form = DCAEntryForm(instance=dca_entry, user=request.user)
+        form = DCAEntryForm(instance=dca_entry)
 
     return render(
         request,

app/apps/export_app/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

app/apps/export_app/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class ExportConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "apps.export_app"

app/apps/export_app/forms.py

@@ -0,0 +1,198 @@
+from crispy_forms.bootstrap import FormActions
+from crispy_forms.helper import FormHelper
+from crispy_forms.layout import Layout, HTML
+from django import forms
+from django.utils.translation import gettext_lazy as _
+
+from apps.common.widgets.crispy.submit import NoClassSubmit
+
+
+class ExportForm(forms.Form):
+    users = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("Users"),
+        initial=True,
+    )
+    accounts = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("Accounts"),
+        initial=True,
+    )
+    currencies = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("Currencies"),
+        initial=True,
+    )
+    transactions = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("Transactions"),
+        initial=True,
+    )
+    categories = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("Categories"),
+        initial=True,
+    )
+    tags = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("Tags"),
+        initial=False,
+    )
+    entities = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("Entities"),
+        initial=False,
+    )
+    recurring_transactions = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("Recurring Transactions"),
+        initial=True,
+    )
+    installment_plans = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("Installment Plans"),
+        initial=True,
+    )
+    exchange_rates = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("Exchange Rates"),
+        initial=False,
+    )
+    exchange_rates_services = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("Automatic Exchange Rates"),
+        initial=False,
+    )
+    rules = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("Rules"),
+        initial=True,
+    )
+    dca = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("DCA"),
+        initial=False,
+    )
+    import_profiles = forms.BooleanField(
+        required=False,
+        widget=forms.CheckboxInput(),
+        label=_("Import Profiles"),
+        initial=True,
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.helper = FormHelper()
+        self.helper.form_tag = False
+        self.helper.form_method = "post"
+        self.helper.layout = Layout(
+            "users",
+            "accounts",
+            "currencies",
+            "transactions",
+            "categories",
+            "entities",
+            "tags",
+            "installment_plans",
+            "recurring_transactions",
+            "exchange_rates_services",
+            "exchange_rates",
+            "rules",
+            "dca",
+            "import_profiles",
+            FormActions(
+                NoClassSubmit(
+                    "submit", _("Export"), css_class="btn btn-outline-primary w-100"
+                ),
+            ),
+        )
+
+
+class RestoreForm(forms.Form):
+    zip_file = forms.FileField(
+        required=False,
+        help_text=_("Import a ZIP file exported from WYGIWYH"),
+        label=_("ZIP File"),
+    )
+    users = forms.FileField(required=False, label=_("Users"))
+    accounts = forms.FileField(required=False, label=_("Accounts"))
+    currencies = forms.FileField(required=False, label=_("Currencies"))
+    transactions_categories = forms.FileField(required=False, label=_("Categories"))
+    transactions_tags = forms.FileField(required=False, label=_("Tags"))
+    transactions_entities = forms.FileField(required=False, label=_("Entities"))
+    transactions = forms.FileField(required=False, label=_("Transactions"))
+    installment_plans = forms.FileField(required=False, label=_("Installment Plans"))
+    recurring_transactions = forms.FileField(
+        required=False, label=_("Recurring Transactions")
+    )
+    automatic_exchange_rates = forms.FileField(
+        required=False, label=_("Automatic Exchange Rates")
+    )
+    exchange_rates = forms.FileField(required=False, label=_("Exchange Rates"))
+    transaction_rules = forms.FileField(required=False, label=_("Transaction rules"))
+    transaction_rules_actions = forms.FileField(
+        required=False, label=_("Edit transaction action")
+    )
+    transaction_rules_update_or_create = forms.FileField(
+        required=False, label=_("Update or create transaction actions")
+    )
+    dca_strategies = forms.FileField(required=False, label=_("DCA Strategies"))
+    dca_entries = forms.FileField(required=False, label=_("DCA Entries"))
+    import_profiles = forms.FileField(required=False, label=_("Import Profiles"))
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.helper = FormHelper()
+        self.helper.form_tag = False
+        self.helper.form_method = "post"
+        self.helper.layout = Layout(
+            "zip_file",
+            HTML("<hr />"),
+            "users",
+            "accounts",
+            "currencies",
+            "transactions",
+            "transactions_categories",
+            "transactions_entities",
+            "transactions_tags",
+            "installment_plans",
+            "recurring_transactions",
+            "automatic_exchange_rates",
+            "exchange_rates",
+            "transaction_rules",
+            "transaction_rules_actions",
+            "transaction_rules_update_or_create",
+            "dca_strategies",
+            "dca_entries",
+            "import_profiles",
+            FormActions(
+                NoClassSubmit(
+                    "submit", _("Restore"), css_class="btn btn-outline-primary w-100"
+                ),
+            ),
+        )
+
+    def clean(self):
+        cleaned_data = super().clean()
+        if not cleaned_data.get("zip_file") and not any(
+            cleaned_data.get(field) for field in self.fields if field != "zip_file"
+        ):
+            raise forms.ValidationError(
+                _("Please upload either a ZIP file or at least one CSV file")
+            )
+        return cleaned_data

app/apps/export_app/models.py

@@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.

app/apps/export_app/resources/accounts.py

@@ -0,0 +1,29 @@
+from import_export import fields, resources, widgets
+
+from apps.accounts.models import Account, AccountGroup
+from apps.export_app.widgets.foreign_key import AutoCreateForeignKeyWidget
+from apps.currencies.models import Currency
+
+
+class AccountResource(resources.ModelResource):
+    group = fields.Field(
+        attribute="group",
+        column_name="group",
+        widget=AutoCreateForeignKeyWidget(AccountGroup, "name"),
+    )
+    currency = fields.Field(
+        attribute="currency",
+        column_name="currency",
+        widget=widgets.ForeignKeyWidget(Currency, "name"),
+    )
+    exchange_currency = fields.Field(
+        attribute="exchange_currency",
+        column_name="exchange_currency",
+        widget=widgets.ForeignKeyWidget(Currency, "name"),
+    )
+
+    class Meta:
+        model = Account
+
+    def get_queryset(self):
+        return Account.all_objects.all()

app/apps/export_app/resources/currencies.py

@@ -0,0 +1,52 @@
+from import_export import fields, resources, widgets
+
+from apps.accounts.models import Account
+from apps.currencies.models import Currency, ExchangeRate, ExchangeRateService
+from apps.export_app.widgets.foreign_key import SkipMissingForeignKeyWidget
+from apps.export_app.widgets.numbers import UniversalDecimalWidget
+
+
+class CurrencyResource(resources.ModelResource):
+    exchange_currency = fields.Field(
+        attribute="exchange_currency",
+        column_name="exchange_currency",
+        widget=SkipMissingForeignKeyWidget(Currency, "name"),
+    )
+
+    class Meta:
+        model = Currency
+
+
+class ExchangeRateResource(resources.ModelResource):
+    from_currency = fields.Field(
+        attribute="from_currency",
+        column_name="from_currency",
+        widget=widgets.ForeignKeyWidget(Currency, "name"),
+    )
+    to_currency = fields.Field(
+        attribute="to_currency",
+        column_name="to_currency",
+        widget=widgets.ForeignKeyWidget(Currency, "name"),
+    )
+    rate = fields.Field(
+        attribute="rate", column_name="rate", widget=UniversalDecimalWidget()
+    )
+
+    class Meta:
+        model = ExchangeRate
+
+
+class ExchangeRateServiceResource(resources.ModelResource):
+    target_currencies = fields.Field(
+        attribute="target_currencies",
+        column_name="target_currencies",
+        widget=widgets.ManyToManyWidget(Currency, field="name"),
+    )
+    target_accounts = fields.Field(
+        attribute="target_accounts",
+        column_name="target_accounts",
+        widget=widgets.ManyToManyWidget(Account, field="name"),
+    )
+
+    class Meta:
+        model = ExchangeRateService

app/apps/export_app/resources/dca.py

@@ -0,0 +1,38 @@
+from import_export import fields, resources
+from import_export.widgets import ForeignKeyWidget
+
+from apps.dca.models import DCAStrategy, DCAEntry
+from apps.currencies.models import Currency
+from apps.export_app.widgets.numbers import UniversalDecimalWidget
+
+
+class DCAStrategyResource(resources.ModelResource):
+    target_currency = fields.Field(
+        attribute="target_currency",
+        column_name="target_currency",
+        widget=ForeignKeyWidget(Currency, "name"),
+    )
+    payment_currency = fields.Field(
+        attribute="payment_currency",
+        column_name="payment_currency",
+        widget=ForeignKeyWidget(Currency, "name"),
+    )
+
+    class Meta:
+        model = DCAStrategy
+
+
+class DCAEntryResource(resources.ModelResource):
+    amount_paid = fields.Field(
+        attribute="amount_paid",
+        column_name="amount_paid",
+        widget=UniversalDecimalWidget(),
+    )
+    amount_received = fields.Field(
+        attribute="amount_received",
+        column_name="amount_received",
+        widget=UniversalDecimalWidget(),
+    )
+
+    class Meta:
+        model = DCAEntry

app/apps/export_app/resources/import_app.py

@@ -0,0 +1,8 @@
+from import_export import resources
+
+from apps.import_app.models import ImportProfile
+
+
+class ImportProfileResource(resources.ModelResource):
+    class Meta:
+        model = ImportProfile

app/apps/export_app/resources/rules.py

@@ -0,0 +1,25 @@
+from import_export import fields, resources
+from import_export.widgets import ForeignKeyWidget
+
+from apps.export_app.widgets.foreign_key import AutoCreateForeignKeyWidget
+from apps.export_app.widgets.many_to_many import AutoCreateManyToManyWidget
+from apps.rules.models import (
+    TransactionRule,
+    TransactionRuleAction,
+    UpdateOrCreateTransactionRuleAction,
+)
+
+
+class TransactionRuleResource(resources.ModelResource):
+    class Meta:
+        model = TransactionRule
+
+
+class TransactionRuleActionResource(resources.ModelResource):
+    class Meta:
+        model = TransactionRuleAction
+
+
+class UpdateOrCreateTransactionRuleResource(resources.ModelResource):
+    class Meta:
+        model = UpdateOrCreateTransactionRuleAction

app/apps/export_app/resources/transactions.py

@@ -0,0 +1,158 @@
+from import_export import fields, resources
+from import_export.widgets import ForeignKeyWidget
+
+from apps.accounts.models import Account
+from apps.export_app.widgets.foreign_key import AutoCreateForeignKeyWidget
+from apps.export_app.widgets.many_to_many import AutoCreateManyToManyWidget
+from apps.export_app.widgets.string import EmptyStringToNoneField
+from apps.transactions.models import (
+    Transaction,
+    TransactionCategory,
+    TransactionTag,
+    TransactionEntity,
+    RecurringTransaction,
+    InstallmentPlan,
+)
+from apps.export_app.widgets.numbers import UniversalDecimalWidget
+
+
+class TransactionResource(resources.ModelResource):
+    account = fields.Field(
+        attribute="account",
+        column_name="account",
+        widget=ForeignKeyWidget(Account, "name"),
+    )
+
+    category = fields.Field(
+        attribute="category",
+        column_name="category",
+        widget=AutoCreateForeignKeyWidget(TransactionCategory, "name"),
+    )
+
+    tags = fields.Field(
+        attribute="tags",
+        column_name="tags",
+        widget=AutoCreateManyToManyWidget(TransactionTag, field="name"),
+    )
+
+    entities = fields.Field(
+        attribute="entities",
+        column_name="entities",
+        widget=AutoCreateManyToManyWidget(TransactionEntity, field="name"),
+    )
+
+    internal_id = EmptyStringToNoneField(
+        column_name="internal_id", attribute="internal_id"
+    )
+
+    amount = fields.Field(
+        attribute="amount",
+        column_name="amount",
+        widget=UniversalDecimalWidget(),
+    )
+
+    class Meta:
+        model = Transaction
+
+    def get_queryset(self):
+        return Transaction.userless_all_objects.all()
+
+
+class TransactionTagResource(resources.ModelResource):
+    class Meta:
+        model = TransactionTag
+
+    def get_queryset(self):
+        return TransactionTag.all_objects.all()
+
+
+class TransactionEntityResource(resources.ModelResource):
+    class Meta:
+        model = TransactionEntity
+
+    def get_queryset(self):
+        return TransactionEntity.all_objects.all()
+
+
+class TransactionCategoyResource(resources.ModelResource):
+    class Meta:
+        model = TransactionCategory
+
+    def get_queryset(self):
+        return TransactionCategory.all_objects.all()
+
+
+class RecurringTransactionResource(resources.ModelResource):
+    account = fields.Field(
+        attribute="account",
+        column_name="account",
+        widget=ForeignKeyWidget(Account, "name"),
+    )
+
+    category = fields.Field(
+        attribute="category",
+        column_name="category",
+        widget=AutoCreateForeignKeyWidget(TransactionCategory, "name"),
+    )
+
+    tags = fields.Field(
+        attribute="tags",
+        column_name="tags",
+        widget=AutoCreateManyToManyWidget(TransactionTag, field="name"),
+    )
+
+    entities = fields.Field(
+        attribute="entities",
+        column_name="entities",
+        widget=AutoCreateManyToManyWidget(TransactionEntity, field="name"),
+    )
+
+    amount = fields.Field(
+        attribute="amount",
+        column_name="amount",
+        widget=UniversalDecimalWidget(),
+    )
+
+    class Meta:
+        model = RecurringTransaction
+
+    def get_queryset(self):
+        return RecurringTransaction.all_objects.all()
+
+
+class InstallmentPlanResource(resources.ModelResource):
+    account = fields.Field(
+        attribute="account",
+        column_name="account",
+        widget=ForeignKeyWidget(Account, "name"),
+    )
+
+    category = fields.Field(
+        attribute="category",
+        column_name="category",
+        widget=AutoCreateForeignKeyWidget(TransactionCategory, "name"),
+    )
+
+    tags = fields.Field(
+        attribute="tags",
+        column_name="tags",
+        widget=AutoCreateManyToManyWidget(TransactionTag, field="name"),
+    )
+
+    entities = fields.Field(
+        attribute="entities",
+        column_name="entities",
+        widget=AutoCreateManyToManyWidget(TransactionEntity, field="name"),
+    )
+
+    installment_amount = fields.Field(
+        attribute="installment_amount",
+        column_name="installment_amount",
+        widget=UniversalDecimalWidget(),
+    )
+
+    class Meta:
+        model = InstallmentPlan
+
+    def get_queryset(self):
+        return InstallmentPlan.all_objects.all()

app/apps/export_app/resources/users.py

@@ -0,0 +1,161 @@
+from import_export import resources, fields
+from django.contrib.auth import get_user_model
+from django.conf import settings
+
+
+from apps.users.models import UserSettings
+
+User = get_user_model()
+
+
+class UserResource(resources.ModelResource):
+    # User fields
+    email = fields.Field(attribute="email", column_name="Email")
+
+    # UserSettings fields - for export only
+    hide_amounts = fields.Field(
+        attribute="settings__hide_amounts", column_name="Hide Amounts", readonly=True
+    )
+    mute_sounds = fields.Field(
+        attribute="settings__mute_sounds", column_name="Mute Sounds", readonly=True
+    )
+    date_format = fields.Field(
+        attribute="settings__date_format", column_name="Date Format", readonly=True
+    )
+    datetime_format = fields.Field(
+        attribute="settings__datetime_format",
+        column_name="Datetime Format",
+        readonly=True,
+    )
+    number_format = fields.Field(
+        attribute="settings__number_format", column_name="Number Format", readonly=True
+    )
+    language = fields.Field(
+        attribute="settings__language", column_name="Language", readonly=True
+    )
+    timezone = fields.Field(
+        attribute="settings__timezone", column_name="Timezone", readonly=True
+    )
+    start_page = fields.Field(
+        attribute="settings__start_page", column_name="Start Page", readonly=True
+    )
+
+    # Human-readable fields for choice values
+    start_page_display = fields.Field(column_name="Start Page Display", readonly=True)
+    language_display = fields.Field(column_name="Language Display", readonly=True)
+    timezone_display = fields.Field(column_name="Timezone Display", readonly=True)
+
+    @staticmethod
+    def dehydrate_start_page_display(user):
+        if hasattr(user, "settings"):
+            return dict(UserSettings.StartPage.choices).get(
+                user.settings.start_page, ""
+            )
+        return ""
+
+    @staticmethod
+    def dehydrate_language_display(user):
+        if hasattr(user, "settings"):
+            languages = dict([("auto", "Auto")] + list(settings.LANGUAGES))
+            return languages.get(user.settings.language, user.settings.language)
+        return ""
+
+    @staticmethod
+    def dehydrate_timezone_display(user):
+        if hasattr(user, "settings"):
+            if user.settings.timezone == "auto":
+                return "Auto"
+            return user.settings.timezone
+        return ""
+
+    def after_init_instance(self, instance, new, row, **kwargs):
+        """
+        Store settings data on the instance to be used after save
+        """
+        # Process boolean fields properly
+        hide_amounts = row.get("Hide Amounts", "").lower() == "true"
+        mute_sounds = row.get("Mute Sounds", "").lower() == "true"
+
+        # Store settings data on the instance for later use
+        instance._settings_data = {
+            "hide_amounts": hide_amounts,
+            "mute_sounds": mute_sounds,
+            "date_format": row.get("Date Format", "SHORT_DATE_FORMAT"),
+            "datetime_format": row.get("Datetime Format", "SHORT_DATETIME_FORMAT"),
+            "number_format": row.get("Number Format", "AA"),
+            "language": row.get("Language", "auto"),
+            "timezone": row.get("Timezone", "auto"),
+            "start_page": row.get("Start Page", UserSettings.StartPage.MONTHLY),
+        }
+
+        return instance
+
+    def after_save_instance(self, instance, row, **kwargs):
+        """
+        Create or update UserSettings after User is saved
+        """
+        if not hasattr(instance, "_settings_data"):
+            return
+
+        settings_data = instance._settings_data
+
+        # Create or update UserSettings
+        try:
+            user_settings = UserSettings.objects.get(user=instance)
+            # Update existing settings
+            for key, value in settings_data.items():
+                setattr(user_settings, key, value)
+            user_settings.save()
+        except UserSettings.DoesNotExist:
+            # Create new settings
+            UserSettings.objects.create(user=instance, **settings_data)
+
+    def get_queryset(self):
+        """
+        Ensure settings are prefetched when exporting users
+        """
+        return super().get_queryset().select_related("settings")
+
+    class Meta:
+        model = User
+        import_id_fields = ["id"]
+        fields = (
+            "id",
+            "email",
+            "first_name",
+            "last_name",
+            "is_active",
+            "date_joined",
+            "password",
+            "hide_amounts",
+            "mute_sounds",
+            "date_format",
+            "datetime_format",
+            "number_format",
+            "language",
+            "language_display",
+            "timezone",
+            "timezone_display",
+            "start_page",
+            "start_page_display",
+        )
+        export_order = (
+            "id",
+            "email",
+            "first_name",
+            "last_name",
+            "is_active",
+            "date_joined",
+            "password",
+            "hide_amounts",
+            "mute_sounds",
+            "date_format",
+            "datetime_format",
+            "number_format",
+            "language",
+            "language_display",
+            "timezone",
+            "timezone_display",
+            "start_page",
+            "start_page_display",
+        )

app/apps/export_app/tests.py

@@ -0,0 +1,164 @@
+from django.test import TestCase, Client
+from django.contrib.auth.models import User
+from django.urls import reverse
+from django.utils.translation import gettext_lazy as _
+from unittest.mock import patch, MagicMock
+from io import BytesIO
+import zipfile # Added for zip file creation
+from django.core.files.uploadedfile import InMemoryUploadedFile # Added for file upload testing
+
+# Dataset from tablib is not directly imported, its behavior will be mocked.
+# Resource classes are also mocked by path string.
+
+from apps.export_app.forms import ExportForm, RestoreForm # Added RestoreForm
+
+
+class ExportAppTests(TestCase):
+    def setUp(self):
+        self.superuser = User.objects.create_superuser(
+            username='super',
+            email='super@example.com',
+            password='password'
+        )
+        self.client = Client()
+        self.client.login(username='super', password='password')
+
+    @patch('apps.export_app.views.UserResource')
+    def test_export_form_single_selection_csv_response(self, mock_UserResource):
+        # Configure the mock UserResource
+        mock_user_resource_instance = mock_UserResource.return_value
+
+        # Mock the export() method's return value (which is a Dataset object)
+        # Then, mock the 'csv' attribute of this Dataset object
+        mock_dataset = MagicMock() # Using MagicMock for the dataset
+        mock_dataset.csv = "user_id,username\n1,testuser"
+        mock_user_resource_instance.export.return_value = mock_dataset
+
+        post_data = {'users': True} # Other fields default to False or their initial values
+
+        response = self.client.post(reverse('export_app:export_form'), data=post_data)
+
+        mock_user_resource_instance.export.assert_called_once()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response['Content-Type'], 'text/csv')
+        self.assertIn("attachment; filename=", response['Content-Disposition'])
+        self.assertIn(".csv", response['Content-Disposition'])
+        # Check if the filename contains 'users'
+        self.assertIn("users_export_", response['Content-Disposition'].lower())
+        self.assertEqual(response.content.decode(), "user_id,username\n1,testuser")
+
+    @patch('apps.export_app.views.AccountResource') # Mock AccountResource first
+    @patch('apps.export_app.views.UserResource')   # Then UserResource
+    def test_export_form_multiple_selections_zip_response(self, mock_UserResource, mock_AccountResource):
+        # Configure UserResource mock
+        mock_user_instance = mock_UserResource.return_value
+        mock_user_dataset = MagicMock()
+        mock_user_dataset.csv = "user_data_here"
+        mock_user_instance.export.return_value = mock_user_dataset
+
+        # Configure AccountResource mock
+        mock_account_instance = mock_AccountResource.return_value
+        mock_account_dataset = MagicMock()
+        mock_account_dataset.csv = "account_data_here"
+        mock_account_instance.export.return_value = mock_account_dataset
+
+        post_data = {
+            'users': True,
+            'accounts': True
+            # other fields default to False or their initial values
+        }
+
+        response = self.client.post(reverse('export_app:export_form'), data=post_data)
+
+        mock_user_instance.export.assert_called_once()
+        mock_account_instance.export.assert_called_once()
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response['Content-Type'], 'application/zip')
+        self.assertIn("attachment; filename=", response['Content-Disposition'])
+        self.assertIn(".zip", response['Content-Disposition'])
+        # Add zip file content check if possible and required later
+
+    def test_export_form_no_selection(self):
+        # Get all field names from ExportForm and set them to False
+        # This ensures that if new export options are added, this test still tries to unselect them.
+        form_fields = ExportForm.base_fields.keys()
+        post_data = {field: False for field in form_fields}
+
+        response = self.client.post(reverse('export_app:export_form'), data=post_data)
+
+        self.assertEqual(response.status_code, 200)
+        # The expected message is "You have to select at least one export"
+        # This message is translatable, so using _() for comparison if the view returns translated string.
+        # The view returns HttpResponse(_("You have to select at least one export"))
+        self.assertEqual(response.content.decode('utf-8'), _("You have to select at least one export"))
+
+    # Placeholder for zip content check, if to be implemented
+    # import zipfile
+    # def test_zip_contents(self):
+    #     # ... (setup response with zip data) ...
+    #     with zipfile.ZipFile(BytesIO(response.content), 'r') as zipf:
+    #         self.assertIn('users.csv', zipf.namelist())
+    #         self.assertIn('accounts.csv', zipf.namelist())
+    #         user_csv_content = zipf.read('users.csv').decode()
+    #         self.assertEqual(user_csv_content, "user_data_here")
+    #         account_csv_content = zipf.read('accounts.csv').decode()
+    #         self.assertEqual(account_csv_content, "account_data_here")
+
+    @patch('apps.export_app.views.process_imports')
+    def test_import_form_valid_zip_calls_process_imports(self, mock_process_imports):
+        # Create a mock ZIP file content
+        zip_content_buffer = BytesIO()
+        with zipfile.ZipFile(zip_content_buffer, 'w') as zf:
+            zf.writestr('dummy.csv', 'some,data')
+        zip_content_buffer.seek(0)
+
+        # Create an InMemoryUploadedFile instance
+        mock_zip_file = InMemoryUploadedFile(
+            zip_content_buffer,
+            'zip_file',  # field_name
+            'test_export.zip',  # file_name
+            'application/zip',  # content_type
+            zip_content_buffer.getbuffer().nbytes,  # size
+            None  # charset
+        )
+
+        post_data = {'zip_file': mock_zip_file}
+        url = reverse('export_app:restore_form')
+
+        response = self.client.post(url, data=post_data, format='multipart')
+
+        mock_process_imports.assert_called_once()
+        # Check the second argument passed to process_imports (the form's cleaned_data['zip_file'])
+        # The first argument (args[0]) is the request object.
+        # The second argument (args[1]) is the form instance.
+        # We need to check the 'zip_file' attribute of the cleaned_data of the form instance.
+        # However, it's simpler to check the UploadedFile object directly if that's what process_imports receives.
+        # Based on the task: "The second argument to process_imports is form.cleaned_data['zip_file']"
+        # This means that process_imports is called as process_imports(request, form.cleaned_data['zip_file'], ...)
+        # Let's assume process_imports signature is process_imports(request, file_obj, ...)
+        # So, call_args[0][1] would be the file_obj.
+
+        # Actually, the view calls process_imports(request, form)
+        # So, we check form.cleaned_data['zip_file'] on the passed form instance
+        called_form_instance = mock_process_imports.call_args[0][1] # The form instance
+        self.assertEqual(called_form_instance.cleaned_data['zip_file'], mock_zip_file)
+
+        self.assertEqual(response.status_code, 204)
+        # The HX-Trigger header might have multiple values, ensure both are present
+        self.assertIn("hide_offcanvas", response.headers['HX-Trigger'])
+        self.assertIn("updated", response.headers['HX-Trigger'])
+
+
+    def test_import_form_no_file_selected(self):
+        post_data = {} # No file selected
+        url = reverse('export_app:restore_form')
+
+        response = self.client.post(url, data=post_data)
+
+        self.assertEqual(response.status_code, 200) # Form re-rendered with errors
+        # Check that the specific error message from RestoreForm.clean() is present
+        expected_error_message = _("Please upload either a ZIP file or at least one CSV file")
+        self.assertContains(response, expected_error_message)
+        # Also check for the HX-Trigger which is always set
+        self.assertIn("updated", response.headers['HX-Trigger'])

app/apps/export_app/urls.py

@@ -0,0 +1,8 @@
+from django.urls import path
+import apps.export_app.views as views
+
+urlpatterns = [
+    path("export/", views.export_index, name="export_index"),
+    path("export/form/", views.export_form, name="export_form"),
+    path("export/restore/", views.import_form, name="restore_form"),
+]