feat: export (WIP)

app/apps/export_app/views.py

@@ -1,31 +1,61 @@
+import logging
 import zipfile
-from io import BytesIO
+from io import BytesIO, TextIOWrapper
 
+from django.contrib import messages
+from django.contrib.auth.decorators import login_required
+from django.db import transaction
 from django.http import HttpResponse
 from django.shortcuts import render
+from django.utils import timezone
+from django.utils.translation import gettext_lazy as _
+from django.views.decorators.http import require_http_methods
+from tablib import Dataset
 
-from apps.export_app.forms import ExportForm
+from apps.export_app.forms import ExportForm, RestoreForm
 from apps.export_app.resources.accounts import AccountResource
 from apps.export_app.resources.transactions import (
     TransactionResource,
     TransactionTagResource,
     TransactionEntityResource,
     TransactionCategoyResource,
+    InstallmentPlanResource,
+    RecurringTransactionResource,
 )
 from apps.export_app.resources.currencies import (
     CurrencyResource,
     ExchangeRateResource,
     ExchangeRateServiceResource,
 )
+from apps.export_app.resources.rules import (
+    TransactionRuleResource,
+    TransactionRuleActionResource,
+    UpdateOrCreateTransactionRuleResource,
+)
+from apps.export_app.resources.dca import (
+    DCAStrategyResource,
+    DCAEntryResource,
+)
+from apps.export_app.resources.import_app import (
+    ImportProfileResource,
+)
+from apps.common.decorators.htmx import only_htmx
+
+logger = logging.getLogger()
 
 
-# Create your views here.
+@login_required
+@require_http_methods(["GET"])
 def export_index(request):
-    dataset = TransactionResource().export()
-    print(dataset.csv)
+    return render(request, "export_app/pages/index.html")
 
 
+@only_htmx
+@login_required
+@require_http_methods(["GET", "POST"])
 def export_form(request):
+    timestamp = timezone.localtime(timezone.now()).strftime("%Y-%m-%dT%H-%M-%S")
+
     if request.method == "POST":
         form = ExportForm(request.POST)
         if form.is_valid():
@@ -37,10 +67,18 @@ def export_form(request):
             export_categories = form.cleaned_data.get("categories", False)
             export_tags = form.cleaned_data.get("tags", False)
             export_entities = form.cleaned_data.get("entities", False)
+            export_installment_plans = form.cleaned_data.get("installment_plans", False)
+            export_recurring_transactions = form.cleaned_data.get(
+                "recurring_transactions", False
+            )
+
             export_exchange_rates_services = form.cleaned_data.get(
                 "exchange_rates_services", False
             )
             export_exchange_rates = form.cleaned_data.get("exchange_rates", False)
+            export_rules = form.cleaned_data.get("rules", False)
+            export_dca = form.cleaned_data.get("dca", False)
+            export_import_profiles = form.cleaned_data.get("import_profiles", False)
 
             exports = []
             if export_accounts:
@@ -49,15 +87,23 @@ def export_form(request):
                 exports.append((CurrencyResource().export(), "currencies"))
             if export_transactions:
                 exports.append((TransactionResource().export(), "transactions"))
+            if export_categories:
+                exports.append(
+                    (TransactionCategoyResource().export(), "transactions_categories")
+                )
             if export_tags:
                 exports.append((TransactionTagResource().export(), "transactions_tags"))
             if export_entities:
                 exports.append(
                     (TransactionEntityResource().export(), "transactions_entities")
                 )
-            if export_categories:
+            if export_installment_plans:
                 exports.append(
-                    (TransactionCategoyResource().export(), "transactions_categories")
+                    (InstallmentPlanResource().export(), "installment_plans")
+                )
+            if export_recurring_transactions:
+                exports.append(
+                    (RecurringTransactionResource().export(), "recurring_transactions")
                 )
             if export_exchange_rates_services:
                 exports.append(
@@ -65,6 +111,32 @@ def export_form(request):
                 )
             if export_exchange_rates:
                 exports.append((ExchangeRateResource().export(), "exchange_rates"))
+            if export_rules:
+                exports.append(
+                    (TransactionRuleResource().export(), "transaction_rules")
+                )
+                exports.append(
+                    (
+                        TransactionRuleActionResource().export(),
+                        "transaction_rules_actions",
+                    )
+                )
+                exports.append(
+                    (
+                        UpdateOrCreateTransactionRuleResource().export(),
+                        "transaction_rules_update_or_create",
+                    )
+                )
+            if export_dca:
+                exports.append((DCAStrategyResource().export(), "dca_strategies"))
+                exports.append(
+                    (
+                        DCAEntryResource().export(),
+                        "dca_entries",
+                    )
+                )
+            if export_import_profiles:
+                exports.append((ImportProfileResource().export(), "import_profiles"))
 
             if len(exports) >= 2:
                 with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
@@ -72,21 +144,141 @@ def export_form(request):
                         zip_file.writestr(f"{name}.csv", dataset.csv)
 
                 response = HttpResponse(
-                    zip_buffer.getvalue(), content_type="application/zip"
+                    zip_buffer.getvalue(),
+                    content_type="application/zip",
+                    headers={
+                        "HX-Trigger": "hide_offcanvas, updated",
+                        "Content-Disposition": f'attachment; filename="{timestamp}_WYGIWYH_export.zip"',
+                    },
                 )
-                response["Content-Disposition"] = f'attachment; filename="export.zip"'
                 return response
-            else:
+            elif len(exports) == 1:
                 dataset, name = exports[0]
 
                 response = HttpResponse(
                     dataset.csv,
                     content_type="text/csv",
+                    headers={
+                        "HX-Trigger": "hide_offcanvas, updated",
+                        "Content-Disposition": f'attachment; filename="{timestamp}_WYGIWYH_export_{name}.csv"',
+                    },
                 )
-                response["Content-Disposition"] = f'attachment; filename="{name}.csv"'
                 return response
+            else:
+                return HttpResponse(
+                    _("You have to select at least one export"),
+                )
 
     else:
         form = ExportForm()
 
-    return render(request, "export_app/pages/form.html", context={"form": form})
+    return render(request, "export_app/fragments/export.html", context={"form": form})
+
+
+@only_htmx
+@login_required
+@require_http_methods(["GET", "POST"])
+def import_form(request):
+    if request.method == "POST":
+        form = RestoreForm(request.POST, request.FILES)
+        if form.is_valid():
+            try:
+                process_imports(request, form.cleaned_data)
+                messages.success(request, _("Data imported successfully"))
+                return HttpResponse(
+                    status=204,
+                    headers={
+                        "HX-Trigger": "hide_offcanvas, updated",
+                    },
+                )
+            except Exception as e:
+                logger.error("Error importing", exc_info=e)
+                messages.error(
+                    request,
+                    _("There was an error importing. Check the logs for more details."),
+                )
+    else:
+        form = RestoreForm()
+
+    response = render(request, "export_app/fragments/restore.html", {"form": form})
+    response["HX-Trigger"] = "updated"
+    return response
+
+
+def process_imports(request, cleaned_data):
+    # Define import order to handle dependencies
+    import_order = [
+        ("currencies", CurrencyResource),
+        (
+            "currencies",
+            CurrencyResource,
+        ),  # We do a double pass because exchange_currency may not exist when currency is initially created
+        ("accounts", AccountResource),
+        ("transactions_categories", TransactionCategoyResource),
+        ("transactions_tags", TransactionTagResource),
+        ("transactions_entities", TransactionEntityResource),
+        ("automatic_exchange_rates", ExchangeRateServiceResource),
+        ("exchange_rates", ExchangeRateResource),
+        ("installment_plans", InstallmentPlanResource),
+        ("recurring_transactions", RecurringTransactionResource),
+        ("transactions", TransactionResource),
+        ("dca_strategies", DCAStrategyResource),
+        ("dca_entries", DCAEntryResource),
+        ("import_profiles", ImportProfileResource),
+        ("transaction_rules", TransactionRuleResource),
+        ("transaction_rules_actions", TransactionRuleActionResource),
+        ("transaction_rules_update_or_create", UpdateOrCreateTransactionRuleResource),
+    ]
+
+    def import_dataset(content, resource_class, field_name):
+        try:
+            # Create a new resource instance
+            resource = resource_class()
+
+            # Create dataset from CSV content
+            dataset = Dataset()
+            dataset.load(content, format="csv")
+
+            # Debug logging
+            logger.debug(f"Importing {field_name}")
+            logger.debug(f"Headers: {dataset.headers}")
+            logger.debug(f"First row: {dataset[0] if len(dataset) > 0 else 'No data'}")
+
+            # Perform the import
+            result = resource.import_data(
+                dataset,
+                dry_run=False,
+                raise_errors=True,
+                collect_failed_rows=True,
+                use_transactions=False,
+                skip_unchanged=True,
+            )
+
+            if result.has_errors():
+                raise ImportError(f"Failed rows: {result.failed_dataset}")
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Error importing {field_name}: {str(e)}")
+            raise ImportError(f"Error importing {field_name}: {str(e)}")
+
+    with transaction.atomic():
+        if zip_file := cleaned_data.get("zip_file"):
+            # Process ZIP file
+            with zipfile.ZipFile(zip_file) as z:
+                for filename in z.namelist():
+                    name = filename.replace(".csv", "")
+                    with z.open(filename) as f:
+                        content = f.read().decode("utf-8")
+
+                        for field_name, resource_class in import_order:
+                            if name == field_name:
+                                import_dataset(content, resource_class, field_name)
+                                break
+        else:
+            # Process individual files
+            for field_name, resource_class in import_order:
+                if csv_file := cleaned_data.get(field_name):
+                    content = csv_file.read().decode("utf-8")
+                    import_dataset(content, resource_class, field_name)