diff --git a/app/apps/export_app/forms.py b/app/apps/export_app/forms.py index caa436c8..7d50ffb1 100644 --- a/app/apps/export_app/forms.py +++ b/app/apps/export_app/forms.py @@ -61,6 +61,12 @@ class ExportForm(forms.Form): label=_("Installment Plans"), initial=True, ) + quick_transactions = forms.BooleanField( + required=False, + widget=forms.CheckboxInput(), + label=_("Quick Transactions"), + initial=True, + ) exchange_rates = forms.BooleanField( required=False, widget=forms.CheckboxInput(), @@ -116,6 +122,7 @@ class ExportForm(forms.Form): "tags", "installment_plans", "recurring_transactions", + "quick_transactions", "exchange_rates_services", "exchange_rates", "bank_sync", @@ -142,10 +149,12 @@ class RestoreForm(forms.Form): transactions_tags = forms.FileField(required=False, label=_("Tags")) transactions_entities = forms.FileField(required=False, label=_("Entities")) transactions = forms.FileField(required=False, label=_("Transactions")) + sub_transactions = forms.FileField(required=False, label=_("Sub-transactions")) installment_plans = forms.FileField(required=False, label=_("Installment Plans")) recurring_transactions = forms.FileField( required=False, label=_("Recurring Transactions") ) + quick_transactions = forms.FileField(required=False, label=_("Quick Transactions")) automatic_exchange_rates = forms.FileField( required=False, label=_("Automatic Exchange Rates") ) @@ -180,11 +189,13 @@ class RestoreForm(forms.Form): "accounts", "currencies", "transactions", + "sub_transactions", "transactions_categories", "transactions_entities", "transactions_tags", "installment_plans", "recurring_transactions", + "quick_transactions", "automatic_exchange_rates", "exchange_rates", "bank_sync_services", diff --git a/app/apps/export_app/resources/transactions.py b/app/apps/export_app/resources/transactions.py index dbcb0f14..1abde7ca 100644 --- a/app/apps/export_app/resources/transactions.py +++ b/app/apps/export_app/resources/transactions.py @@ -1,4 +1,9 @@ +from functools import reduce +from operator import or_ + +from django.db.models import Q 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 ( @@ -14,6 +19,8 @@ from apps.transactions.models import ( TransactionEntity, RecurringTransaction, InstallmentPlan, + QuickTransaction, + SubTransaction, ) from apps.export_app.widgets.numbers import UniversalDecimalWidget @@ -166,3 +173,106 @@ class InstallmentPlanResource(resources.ModelResource): def dehydrate_account_owner(self, obj): """Export the account's owner ID for proper import matching.""" return obj.account.owner_id if obj.account else None + + +class AnyOwnerForeignKeyWidget(ForeignKeyWidget): + """Finds the parent among every user's rows, soft-deleted ones included.""" + + def get_queryset(self, value, row, *args, **kwargs): + return self.model._base_manager.all() + + +class QuickTransactionResource(resources.ModelResource): + account = fields.Field( + attribute="account", + column_name="account", + widget=AllObjectsForeignKeyWidget(Account, "name"), + ) + to_account = fields.Field( + attribute="to_account", + column_name="to_account", + widget=AllObjectsForeignKeyWidget(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(), + ) + to_amount = fields.Field( + attribute="to_amount", + column_name="to_amount", + widget=UniversalDecimalWidget(), + ) + + class Meta: + model = QuickTransaction + + def get_queryset(self): + return QuickTransaction.all_objects.all() + + +SUB_TRANSACTION_BACKUP_PARENTS = ( + "transaction", + "installment_plan", + "recurring_transaction", + "quick_transaction", +) + + +class SubTransactionResource(resources.ModelResource): + transaction = fields.Field( + attribute="transaction", + column_name="transaction", + widget=AnyOwnerForeignKeyWidget(Transaction), + ) + installment_plan = fields.Field( + attribute="installment_plan", + column_name="installment_plan", + widget=AnyOwnerForeignKeyWidget(InstallmentPlan), + ) + recurring_transaction = fields.Field( + attribute="recurring_transaction", + column_name="recurring_transaction", + widget=AnyOwnerForeignKeyWidget(RecurringTransaction), + ) + quick_transaction = fields.Field( + attribute="quick_transaction", + column_name="quick_transaction", + widget=AnyOwnerForeignKeyWidget(QuickTransaction), + ) + amount = fields.Field( + attribute="amount", + column_name="amount", + widget=UniversalDecimalWidget(), + ) + + def __init__(self, parents=SUB_TRANSACTION_BACKUP_PARENTS, **kwargs): + """`parents`: the kinds of parent being exported, whose parts go along.""" + super().__init__(**kwargs) + self.parents = parents + + class Meta: + model = SubTransaction + + def get_queryset(self): + return SubTransaction.objects.filter( + reduce(or_, (Q(**{f"{p}__isnull": False}) for p in self.parents), Q(pk__in=[])) + ) diff --git a/app/apps/export_app/tests.py b/app/apps/export_app/tests.py index e70c0357..e929864c 100644 --- a/app/apps/export_app/tests.py +++ b/app/apps/export_app/tests.py @@ -1,4 +1,5 @@ import io +from datetime import date import zipfile from decimal import Decimal @@ -9,9 +10,21 @@ from apps.accounts.models import Account, InvestmentClass from apps.common.middleware.thread_local import delete_current_user, write_current_user from apps.currencies.models import Currency from apps.export_app.resources.accounts import AccountResource, InvestmentClassResource -from apps.export_app.resources.transactions import TransactionEntityResource +from apps.export_app.resources.transactions import ( + InstallmentPlanResource, + QuickTransactionResource, + SubTransactionResource, + TransactionEntityResource, + TransactionResource, +) from apps.export_app.views import process_imports -from apps.transactions.models import TransactionEntity +from apps.transactions.models import ( + InstallmentPlan, + QuickTransaction, + SubTransaction, + Transaction, + TransactionEntity, +) class InvestmentRestoreTests(TestCase): @@ -51,3 +64,58 @@ class InvestmentRestoreTests(TestCase): self.assertEqual(account.investment_class.name, "Stocks") self.assertEqual(account.investment_class.target, Decimal("60")) self.assertEqual([e.name for e in account.income_entities.all()], ["Broker"]) + + +class SubTransactionBackupTests(TestCase): + def setUp(self): + self.user = get_user_model().objects.create_user(email="s@test.com", password="pw") + write_current_user(self.user) + self.addCleanup(delete_current_user) + account = Account.objects.create( + name="A", currency=Currency.objects.create(code="USD", name="USD", decimal_places=2) + ) + self.transaction = Transaction.objects.create( + account=account, type="EX", date=date(2030, 1, 10), amount=5 + ) + self.plan = InstallmentPlan.objects.create( + account=account, type="EX", description="Laptop", number_of_installments=2, + start_date=date(2030, 1, 10), installment_amount=100, + ) + SubTransaction.objects.create(transaction=self.transaction, name="Fee", amount="1.25") + SubTransaction.objects.create(transaction=self.transaction, name="Item", amount="3.75") + SubTransaction.objects.create(installment_plan=self.plan, name="Principal", amount=100) + lunch = QuickTransaction.objects.create( + name="Lunch", account=account, type="EX", amount=Decimal("13.90") + ) + SubTransaction.objects.create(quick_transaction=lunch, name="Meal", amount="11.90") + SubTransaction.objects.create(quick_transaction=lunch, name="Tip", amount=2) + + def _parts(self): + return sorted( + SubTransaction.objects.values_list( + "name", "transaction", "installment_plan", "quick_transaction__name", "amount" + ) + ) + + def test_round_trip_puts_parts_back_on_their_parents(self): + before = self._parts() + backup = io.BytesIO() + with zipfile.ZipFile(backup, "w") as z: + for resource, name in ( + (TransactionResource(), "transactions"), + (InstallmentPlanResource(), "installment_plans"), + (QuickTransactionResource(), "quick_transactions"), + (SubTransactionResource(), "sub_transactions"), + ): + z.writestr(f"{name}.csv", resource.export().csv) + + SubTransaction.objects.all().delete() + QuickTransaction.all_objects.all().delete() + backup.seek(0) + process_imports(None, {"zip_file": backup}) + + self.assertEqual(self._parts(), before) + + def test_exports_only_the_parts_of_exported_parents(self): + dataset = SubTransactionResource(parents=["installment_plan"]).export() + self.assertEqual([row["name"] for row in dataset.dict], ["Principal"]) diff --git a/app/apps/export_app/views.py b/app/apps/export_app/views.py index c413d3e4..3a521ddc 100644 --- a/app/apps/export_app/views.py +++ b/app/apps/export_app/views.py @@ -46,6 +46,8 @@ from apps.export_app.resources.transactions import ( TransactionCategoyResource, InstallmentPlanResource, RecurringTransactionResource, + QuickTransactionResource, + SubTransactionResource, ) from apps.export_app.resources.users import UserResource from apps.common.decorators.demo import disabled_on_demo @@ -84,6 +86,9 @@ def export_form(request): export_recurring_transactions = form.cleaned_data.get( "recurring_transactions", False ) + export_quick_transactions = form.cleaned_data.get( + "quick_transactions", False + ) export_exchange_rates_services = form.cleaned_data.get( "exchange_rates_services", False @@ -123,6 +128,27 @@ def export_form(request): exports.append( (RecurringTransactionResource().export(), "recurring_transactions") ) + if export_quick_transactions: + exports.append( + (QuickTransactionResource().export(), "quick_transactions") + ) + sub_transaction_parents = [ + parent + for parent, exported in ( + ("transaction", export_transactions), + ("installment_plan", export_installment_plans), + ("recurring_transaction", export_recurring_transactions), + ("quick_transaction", export_quick_transactions), + ) + if exported + ] + if sub_transaction_parents: + exports.append( + ( + SubTransactionResource(parents=sub_transaction_parents).export(), + "sub_transactions", + ) + ) if export_exchange_rates_services: exports.append( (ExchangeRateServiceResource().export(), "automatic_exchange_rates") @@ -250,7 +276,9 @@ def process_imports(request, cleaned_data): ("exchange_rates", ExchangeRateResource), ("installment_plans", InstallmentPlanResource), ("recurring_transactions", RecurringTransactionResource), + ("quick_transactions", QuickTransactionResource), ("transactions", TransactionResource), + ("sub_transactions", SubTransactionResource), ("bank_sync_services", BankSyncServiceResource), ("bank_sync_accounts", BankSyncAccountResource), ("dca_strategies", DCAStrategyResource),