Initial working version with minor bugs

trades/admin.py

@@ -0,0 +1,4 @@
+from django.contrib import admin
+from .models import TradeOffer
+
+admin.site.register(TradeOffer)

trades/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class TradesConfig(AppConfig):
+    name = "trades"
+
+    def ready(self):
+        # This import registers the signal handlers defined in trades/signals.py.
+        import trades.signals

trades/forms.py

@@ -0,0 +1,70 @@
+from django import forms
+from django.core.exceptions import ValidationError
+from .models import TradeOffer
+from friend_codes.models import FriendCode
+from cards.models import Card
+
+class TradeOfferUpdateForm(forms.ModelForm):
+    class Meta:
+        model = TradeOffer
+        # We now only edit the `state` field
+        fields = ["state"]
+
+    def __init__(self, *args, **kwargs):
+        """
+        Expects additional keyword arguments:
+           - friend_codes: a list of friend code objects for the current user.
+        This initializer filters the available state choices based on:
+          - The current state's allowed transition.
+          - Which party (initiated_by or accepted_by) is acting.
+        """
+        friend_codes = kwargs.pop("friend_codes")
+        super().__init__(*args, **kwargs)
+
+        instance = self.instance
+        allowed_state = None
+
+        # Define permitted transitions based on the current state and user role:
+        if instance.state == TradeOffer.State.INITIATED:
+            # Allow the accepted_by party to accept the trade.
+            if instance.accepted_by in friend_codes:
+                allowed_state = TradeOffer.State.ACCEPTED
+        elif instance.state == TradeOffer.State.ACCEPTED:
+            # Allow the initiated_by party to mark the trade as sent.
+            if instance.initiated_by in friend_codes:
+                allowed_state = TradeOffer.State.SENT
+        elif instance.state == TradeOffer.State.SENT:
+            # Allow the accepted_by party to mark the trade as received.
+            if instance.accepted_by in friend_codes:
+                allowed_state = TradeOffer.State.RECEIVED
+
+        if allowed_state:
+            # Limit the `state` field's choices to only the permitted transition.
+            label = dict(TradeOffer.State.choices)[allowed_state]
+            self.fields["state"].choices = [(allowed_state, label)]
+        else:
+            # If no valid transition is available for this user, remove the field.
+            self.fields.pop("state")
+
+    def clean_have_cards(self):
+        have_cards = self.cleaned_data.get("have_cards")
+        if have_cards:
+            for card in have_cards.all():
+                if card.rarity not in ALLOWED_RARITIES:
+                    # Raising a ValidationError here will cause this error message to be shown beneath the 'have_cards' field.
+                    raise ValidationError(
+                        f"The card '{card}' has an invalid rarity: {card.rarity}. Allowed rarities are: {', '.join(ALLOWED_RARITIES)}."
+                    )
+        return have_cards
+
+class TradeOfferAcceptForm(forms.Form):
+    friend_code = forms.ModelChoiceField(
+        queryset=FriendCode.objects.none(),
+        label="Select a Friend Code to Accept This Trade Offer"
+    )
+
+    def __init__(self, *args, **kwargs):
+        # Expecting a keyword argument `friend_codes` with the user's friend codes.
+        friend_codes = kwargs.pop("friend_codes")
+        super().__init__(*args, **kwargs)
+        self.fields["friend_code"].queryset = friend_codes

trades/migrations/0001_initial.py

@@ -0,0 +1,31 @@
+# Generated by Django 5.1.2 on 2025-02-26 08:04
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('cards', '0001_initial'),
+        ('friend_codes', '0002_alter_friendcode_friend_code'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='TradeOffer',
+            fields=[
+                ('id', models.AutoField(primary_key=True, serialize=False)),
+                ('hash', models.CharField(editable=False, max_length=8)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('state', models.CharField(choices=[('INITIATED', 'Initiated'), ('ACCEPTED', 'Accepted'), ('SENT', 'Sent'), ('RECEIVED', 'Received')], default='INITIATED', max_length=10)),
+                ('accepted_by', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='accepted_by', to='friend_codes.friendcode')),
+                ('have_cards', models.ManyToManyField(related_name='trade_offers_have', to='cards.card')),
+                ('initiated_by', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='initiated_by', to='friend_codes.friendcode')),
+                ('want_cards', models.ManyToManyField(related_name='trade_offers_want', to='cards.card')),
+            ],
+        ),
+    ]

trades/models.py

@@ -0,0 +1,72 @@
+from django.db import models
+import hashlib  # <-- import hashlib for computing md5
+from cards.models import Card
+from friend_codes.models import FriendCode
+
+class TradeOffer(models.Model):
+  id = models.AutoField(primary_key=True)
+  hash = models.CharField(max_length=8, editable=False)
+  initiated_by = models.ForeignKey("friend_codes.FriendCode", on_delete=models.PROTECT, related_name='initiated_by')
+  accepted_by = models.ForeignKey("friend_codes.FriendCode", on_delete=models.PROTECT, null=True, blank=True, related_name='accepted_by')
+  want_cards = models.ManyToManyField("cards.Card", related_name='trade_offers_want')
+  have_cards = models.ManyToManyField("cards.Card", related_name='trade_offers_have')
+  created_at = models.DateTimeField(auto_now_add=True)
+  updated_at = models.DateTimeField(auto_now=True)
+
+  class State(models.TextChoices):
+    INITIATED = 'INITIATED', 'Initiated'
+    ACCEPTED = 'ACCEPTED', 'Accepted'
+    SENT = 'SENT', 'Sent'
+    RECEIVED = 'RECEIVED', 'Received'    
+
+  state = models.CharField(
+    max_length=10,
+    choices=State.choices,
+    default=State.INITIATED,
+  )
+
+  def __str__(self):
+    return f"Want: {', '.join([x.name for x in self.want_cards.all()])} -> Have: {', '.join([x.name for x in self.have_cards.all()])}"
+
+  def update_state(self, new_state):
+    """
+    Explicitly update the trade state to new_state if allowed.
+
+    Allowed transitions:
+      - INITIATED -> ACCEPTED
+      - ACCEPTED -> SENT
+      - SENT -> RECEIVED
+
+    Raises:
+        ValueError: If the new_state is not allowed.
+    """
+    allowed_transitions = {
+        self.State.INITIATED: self.State.ACCEPTED,
+        self.State.ACCEPTED: self.State.SENT,
+        self.State.SENT: self.State.RECEIVED
+    }
+
+    # Check that new_state is one of the defined State choices
+    if new_state not in [choice[0] for choice in self.State.choices]:
+        raise ValueError(f"'{new_state}' is not a valid state.")
+
+    # If the current state is already final, no further transition is allowed.
+    if self.state not in allowed_transitions:
+        raise ValueError(f"No transitions allowed from the final state '{self.state}'.")
+
+    # Verify that the desired new_state is the valid transition for the current state.
+    if allowed_transitions[self.state] != new_state:
+        raise ValueError(f"Transition from {self.state} to {new_state} is not allowed.")
+
+    self.state = new_state
+    # Save all changes so that any in-memory modifications (like accepted_by) are persisted.
+    self.save()  # Changed from self.save(update_fields=["state"])
+
+  def save(self, *args, **kwargs):
+    # Determine if the object is being created (i.e. it doesn't yet have a pk)
+    is_new = self.pk is None
+    super().save(*args, **kwargs)
+    # Once the object has a pk, compute and save the hash if it hasn't been set yet.
+    if is_new and not self.hash:
+        self.hash = hashlib.md5(str(self.id).encode('utf-8')).hexdigest()[:8]
+        super().save(update_fields=["hash"])

trades/signals.py

@@ -0,0 +1,25 @@
+from django.core.exceptions import ValidationError
+from django.db.models.signals import m2m_changed
+from django.dispatch import receiver
+from .models import TradeOffer
+from cards.models import Card
+
+def check_trade_offer_rarity(instance):
+    combined_cards = list(instance.have_cards.all()) + list(instance.want_cards.all())
+    # Map rarities 6 (Super Rare) and 7 (Special Art Rare) to a single value (here, 6)
+    rarities = {
+        card.rarity_id if card.rarity_id not in (6, 7) else 6
+        for card in combined_cards
+    }
+    if len(rarities) > 1:
+        raise ValidationError("All cards in a trade offer must have the same rarity.")
+
+@receiver(m2m_changed, sender=TradeOffer.have_cards.through)
+def validate_have_cards_rarity(sender, instance, action, **kwargs):
+    if action == "post_add":
+        check_trade_offer_rarity(instance)
+
+@receiver(m2m_changed, sender=TradeOffer.want_cards.through)
+def validate_want_cards_rarity(sender, instance, action, **kwargs):
+    if action == "post_add":
+        check_trade_offer_rarity(instance) 

trades/templatetags/trade_offer_tags.py

@@ -0,0 +1,12 @@
+from django import template
+
+register = template.Library()
+
+@register.inclusion_tag('includes/trade_offer.html')
+def render_trade_offer(offer):
+    """
+    Renders a trade offer in the desired format.
+    """
+    return {
+        'offer': offer
+    } 

trades/tests.py

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

trades/urls.py

@@ -0,0 +1,17 @@
+from django.urls import path
+
+from .views import (
+    TradeOfferCreateView,
+    TradeOfferListView,
+    TradeOfferUpdateView,
+    TradeOfferDeleteView,
+    TradeOfferSearchView,
+)
+
+urlpatterns = [
+    path("create/", TradeOfferCreateView.as_view(), name="trade_offer_create"),
+    path("", TradeOfferListView.as_view(), name="trade_offer_list"),
+    path("search/", TradeOfferSearchView.as_view(), name="trade_offer_search"),
+    path("<int:pk>/", TradeOfferUpdateView.as_view(), name="trade_offer_update"),
+    path("delete/<int:pk>/", TradeOfferDeleteView.as_view(), name="trade_offer_delete"),
+]

trades/views.py

@@ -0,0 +1,224 @@
+from django.views.generic import TemplateView, DeleteView, CreateView, ListView, DetailView, FormView
+from django.urls import reverse_lazy
+from django.http import HttpResponseRedirect
+from django.contrib.auth.mixins import LoginRequiredMixin
+from django.shortcuts import get_object_or_404
+from django.core.exceptions import PermissionDenied, ValidationError
+from django.views.generic.edit import FormMixin
+from django.utils import timezone
+from django.db.models import Q
+
+from .models import TradeOffer
+from .forms import TradeOfferUpdateForm, TradeOfferAcceptForm
+from cards.models import Card
+
+class TradeOfferCreateView(LoginRequiredMixin, CreateView):
+    model = TradeOffer
+    template_name = "trades/trade_offer_create.html"
+    success_url = reverse_lazy("trade_offer_list")
+    fields = ["want_cards", "have_cards", "initiated_by"]
+
+    def form_valid(self, form):
+        # Save the object without committing m2m fields immediately.
+        self.object = form.save(commit=False)
+        self.object.save()
+        try:
+            # This call will trigger the m2m signals and may raise a ValidationError.
+            form.save_m2m()  
+        except ValidationError as e:
+            # Attach the error message to the "have_cards" field (or as a non-field error)
+            form.add_error("have_cards", e.messages[0])
+            return self.form_invalid(form)
+        return HttpResponseRedirect(self.get_success_url())
+
+class TradeOfferListView(LoginRequiredMixin, ListView):
+    model = TradeOffer
+    template_name = "trades/trade_offer_list.html"
+
+    def get_queryset(self):
+        qs = super().get_queryset().prefetch_related("have_cards", "want_cards").select_related("initiated_by", "accepted_by")
+        request = self.request
+
+        show_completed = request.GET.get("show_completed", "").lower() in ["true", "1"]
+        my_trades = request.GET.get("my_trades", "").lower() in ["true", "1"]
+
+        now = timezone.now()
+        seven_days_ago = now - timezone.timedelta(days=7)
+
+        if show_completed:
+            qs = qs.filter(Q(state=TradeOffer.State.RECEIVED))
+        else:
+            qs = qs.filter(updated_at__gte=seven_days_ago).exclude(state=TradeOffer.State.RECEIVED)
+
+        if my_trades:
+            friend_codes = self.request.user.friend_codes.all()
+            qs = qs.filter(Q(initiated_by__in=friend_codes) | Q(accepted_by__in=friend_codes))
+        
+        return qs.order_by("-updated_at")
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["show_completed"] = self.request.GET.get("show_completed", "").lower() in ["true", "1"]
+        context["my_trades"] = self.request.GET.get("my_trades", "").lower() in ["true", "1"]
+        return context
+
+class TradeOfferUpdateView(LoginRequiredMixin, FormMixin, DetailView):
+    """
+    Merged view that displays trade offer details and renders a form used for either:
+      - Accepting an offer (if in INITIATED state and not initiated by the current user), or
+      - Performing an allowed state transition via the update form.
+    """
+    model = TradeOffer
+    template_name = "trades/trade_offer_update.html"
+    success_url = reverse_lazy("trade_offer_list")
+
+    def get_user_friend_codes(self):
+        return self.request.user.friend_codes.all()
+
+    def get_form_class(self):
+        trade_offer = self.get_object()
+        user_friend_codes = self.get_user_friend_codes()
+        if trade_offer.state == trade_offer.State.INITIATED and trade_offer.initiated_by not in user_friend_codes:
+            return TradeOfferAcceptForm
+        return TradeOfferUpdateForm
+
+    def get_form_kwargs(self):
+        kwargs = super().get_form_kwargs()
+        kwargs["friend_codes"] = self.get_user_friend_codes()
+        if self.get_form_class() == TradeOfferUpdateForm:
+            kwargs["instance"] = self.get_object()
+        return kwargs
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        form_class = self.get_form_class()
+        if "form" not in context:
+            context["form"] = self.get_form(form_class)
+        context["action"] = "accept" if form_class == TradeOfferAcceptForm else "update"
+        
+        trade_offer = self.object
+        user_friend_codes = self.get_user_friend_codes()
+        seven_days_ago = timezone.now() - timezone.timedelta(days=7)
+        
+        can_delete = False
+        if trade_offer.initiated_by in user_friend_codes:
+            if trade_offer.state == trade_offer.State.INITIATED:
+                can_delete = True
+            elif trade_offer.state == trade_offer.State.SENT and trade_offer.updated_at < seven_days_ago:
+                can_delete = True
+        elif trade_offer.accepted_by in user_friend_codes:
+            if trade_offer.state in [trade_offer.State.ACCEPTED, trade_offer.State.RECEIVED]:
+                if trade_offer.updated_at < seven_days_ago:
+                    can_delete = True
+        
+        context["can_delete"] = can_delete
+        return context
+
+    def post(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        user_friend_codes = self.get_user_friend_codes()
+        form_class = self.get_form_class()
+        form = self.get_form(form_class)
+
+        if form_class == TradeOfferAcceptForm:
+            if not (self.object.state == self.object.State.INITIATED and
+                    self.object.initiated_by not in user_friend_codes):
+                raise PermissionDenied("You are not allowed to accept this trade offer.")
+
+        if form.is_valid():
+            return self.form_valid(form)
+        else:
+            return self.form_invalid(form)
+
+    def form_valid(self, form):
+        """
+        Save the instance and its many-to-many fields in a try/except block to catch
+        ValidationError raised by the m2m_changed signal (or a custom validation method).
+        """
+        trade_offer = self.get_object()
+        # For example, if you want to perform a pre-save validation of card rarities,
+        # you might call a model method (that you define) like:
+        try:
+            trade_offer.validate_card_rarities()
+        except ValueError as e:
+            form.add_error("have_cards", str(e))
+            return self.form_invalid(form)
+
+        # For the m2m part, manually save to catch errors from the signal:
+        self.object = form.save(commit=False)
+        # Process state change or friend code acceptance:
+        if isinstance(form, TradeOfferAcceptForm):
+            chosen_friend_code = form.cleaned_data["friend_code"]
+            trade_offer.accepted_by = chosen_friend_code
+            try:
+                trade_offer.update_state(TradeOffer.State.ACCEPTED)
+            except ValueError as e:
+                # Attach as non-field error (or on a specific field if you prefer)
+                form.add_error(None, str(e))
+                return self.form_invalid(form)
+        else:
+            new_state = form.cleaned_data["state"]
+            try:
+                trade_offer.update_state(new_state)
+            except ValueError as e:
+                form.add_error("state", str(e))
+                return self.form_invalid(form)
+
+        try:
+            # Save instance and its m2m fields; any ValidationError raised here (e.g.,
+            # from the m2m_changed signals) will be caught.
+            self.object.save()      # Save the TradeOffer instance.
+            form.save_m2m()          # This call triggers the m2m_changed signals.
+        except ValidationError as e:
+            # Here we attach the signal error (from card rarities) to the form so that
+            # the user can see it. You can attach it to a specific field or as a non-field error.
+            form.add_error("have_cards", e.messages[0])
+            return self.form_invalid(form)
+
+        return HttpResponseRedirect(self.get_success_url())
+
+class TradeOfferDeleteView(LoginRequiredMixin, DeleteView):
+    model = TradeOffer
+    success_url = reverse_lazy("trade_offer_list")
+    template_name = "trades/trade_offer_delete.html"
+
+class TradeOfferSearchView(LoginRequiredMixin, ListView):
+    model = TradeOffer
+    template_name = "trades/trade_offer_search.html"
+    context_object_name = "trade_offers"
+
+    def get_queryset(self):
+        qs = super().get_queryset().filter(state=TradeOffer.State.INITIATED).prefetch_related("have_cards", "want_cards").select_related("initiated_by", "accepted_by")
+        offered_card = self.request.GET.get("offered_card", "").strip()
+        wanted_cards = self.request.GET.getlist("wanted_cards")
+        
+        if not offered_card and not wanted_cards:
+            return qs.none()
+
+        if offered_card:
+            try:
+                offered_card_id = int(offered_card)
+            except ValueError:
+                qs = qs.none()
+            else:
+                qs = qs.filter(have_cards__id=offered_card_id)
+        
+        if wanted_cards:
+            valid_wanted_cards = []
+            for card_str in wanted_cards:
+                try:
+                    valid_wanted_cards.append(int(card_str))
+                except ValueError:
+                    qs = qs.none()
+                    break
+            if valid_wanted_cards:
+                qs = qs.filter(want_cards__id__in=valid_wanted_cards)
+        return qs
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["offered_card"] = self.request.GET.get("offered_card", "")
+        context["wanted_cards"] = self.request.GET.getlist("wanted_cards")
+        context["available_cards"] = Card.objects.order_by("name", "rarity__pk").select_related("rarity", "cardset")
+        return context
+