from django.db import models
from django.contrib.auth.models import User

class MyModel(models.Model):
    created = models.DateTimeField(auto_now_add=True)
    created_by = models.ForeignKey(User, on_delete=models.CASCADE)
    name = models.CharField(max_length=256, unique=True)

from django import forms
from django.shortcuts import render
from django.views.generic.base import View
from django.views.generic.edit import FormMixin
from django_tables2 import Column, SingleTableMixin, SingleTableView, Table
from .models import MyModel


class MyModelTable(Table):
    class Meta:
        model = MyModel
        template_name = "table.html"
        fields = (
            "name",
            "created",
            "created_by",
        )
        order_by = ("-created_by", "name")
        # Add some bootstrap styling
        attrs = {"class": "table table-striped table-bordered"}
        # Specify some custom classes to include nice transitions
        row_attrs = {"class": "fade-in"}


class TableView(SingleTableView):
    template_name = "view.html"
    model = MyModel
    table_class = MyModelTable
    paginate_by = 100

    
class CreateTableRowMixin(SingleTableMixin, FormMixin):
    """
    Define a post method that supports rendering different responses
    based on whether the form submission is valid or not.
    
    When valid, the response should be a new row for the table.
    When invalid, the response should be the form with the validation
    errors.
    """
    template_name_table_row = None
    template_name_form = None

    def post(self, request, *args, **kwargs):
        form = self.get_form()
        if form.is_valid():
            return self.form_valid(form)
        else:
            return self.form_invalid(form)

    def form_valid(self, form):
        """If the form is valid, render the table row."""
        # Move the object into the table data so it renders as the only row
        self.table_data = [form.save()]
        return render(
            self.request,
            self.template_name_table_row,
            context=self.get_context_data(form=form),
        )

    def form_invalid(self, form):
        """If the form is invalid, render the invalid form."""
        # Setting the table_data to an empty list avoids extra DB hits
        self.table_data = []
        response = render(
            self.request,
            self.template_name_form,
            context=self.get_context_data(form=form),
        )
        return response

    
class RelayTriggerAfterSwapMixin:
    """
    Set the HX-Trigger-After-Swap response header if the request needs it.
    The purpose here is to avoid the server telling the client which specific
    event should be raised. Instead, this allows the client to declaratively
    specify the event that should be raised when the swap is complete.
    Example template:
         hx-on:htmx:config-request="event.detail.parameters.success_event = 'event_name'"
         @event_name.window="bootstrap.Modal.getInstance('#Modal-ID').hide()"
    """

    def form_valid(self, *args, **kwargs):
        response = super().form_valid(*args, **kwargs)
        if value := self.request.POST.get("success_event"):
            response.headers["HX-Trigger-After-Swap"] = value
        return response


class MyModelModelForm(forms.ModelForm):
    class Meta:
        model = MyModel
        fields = ['name']

        
class MyModelFormView(
    RelayTriggerAfterSwapMixin, CreateTableRowMixin, View
):
    model = MyModel
    template_name_table_row = "row.html"
    template_name_form = "form.html"
    form_class = MyModelModelForm
    table_class = MyModelTable
    prefix = "my-model"

    def get(self, request, *args, **kwargs):
        # Setting the table_data to an empty list avoids extra DB hits
        self.table_data = []
        form = self.get_form()
        return render(
            request,
            "form.html",
            context=self.get_context_data(form=form),
        )

    def get_form(self, form_class=None):
        form = super().get_form(form_class=form_class)
        form.instance.created_by = self.request.user
        return form

from django.urls import path
from . import views

urlpatterns = [
    path("view/", views.MyModelTableView.as_view(), name="view"),
    path("form/", views.MyModelFormView.as_view(), name="form"),
]