Payment review

insalan/payment/admin.py

@@ -0,0 +1,103 @@
+"""Payment Admin Panel Code"""
+# Disable lints:
+# "Too few public methods"
+# pylint: disable=R0903
+
+from django import forms
+from django.contrib import admin, messages
+
+from django.utils.translation import gettext_lazy as _
+
+from .models import Product, Transaction, Payment
+
+
+class ProductAdmin(admin.ModelAdmin):
+    """Admin handler for Products"""
+
+    list_display = ("id", "price", "name", "desc", "category", "associated_tournament")
+    search_fields = ["id", "price", "name"]
+
+
+admin.site.register(Product, ProductAdmin)
+
+
+@admin.action(description=_("Rembourser la transaction"))
+def reimburse_transactions(modeladmin, request, queryset):
+    """Reimburse all selected actions"""
+    for transaction in queryset:
+        (is_err, msg) = transaction.refund_transaction(request.user.username)
+        if is_err:
+            modeladmin.message_user(
+                request, _("Erreur: %(msg)s") % {"msg": msg}, messages.ERROR
+            )
+            break
+
+
+class PaymentAdmin(admin.ModelAdmin):
+    """
+    Admin handler for payments"
+    """
+
+    list_display = ("id", "amount", "transaction")
+
+    def has_add_permission(self, _request):
+        """Remove the ability to add a payment from the backoffice"""
+        return False
+
+    def has_change_permission(self, _request, _obj=None):
+        """Remove the ability to edit a payment from the backoffice"""
+        return False
+
+    def has_delete_permission(self, _request, _obj=None):
+        """Remove the ability to edit a payment from the backoffice"""
+        return False
+
+
+admin.site.register(Payment, PaymentAdmin)
+
+
+class TransactionAdmin(admin.ModelAdmin):
+    """
+    Admin handler for Transactions
+    In the backoffice, Transactions can only be seen, they cannot be add,
+    removed or changed this way
+    """
+
+    list_display = (
+        "id",
+        "payer",
+        "payment_status",
+        "creation_date",
+        "intent_id",
+        "order_id",
+        "last_modification_date",
+        "amount",
+    )
+    search_fields = [
+        "id",
+        "payer",
+        "products",
+        "payment_status",
+        "creation_date",
+        "intent_id",
+        "order_id",
+        "last_modification_date",
+        "amount",
+    ]
+
+    # actions = [reimburse_transactions]
+
+    def has_add_permission(self, _request):
+        """Remove the ability to add a transaction from the backoffice"""
+        return False
+
+    def has_change_permission(self, _request, _obj=None):
+        """Remove the ability to edit a transaction from the backoffice"""
+        return False
+
+    def has_delete_permission(self, _request, _obj=None):
+        """Remove the ability to edit a transaction from the backoffice"""
+        return False
+
+
+admin.site.register(Transaction, TransactionAdmin)

insalan/payment/apps.py

@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class PaymentConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name ='insalan.payment'
+    verbose_name = _('Paiement')

insalan/payment/hooks.py

@@ -0,0 +1,118 @@
+"""
+Hooks module for payment
+
+This file is not part of the Django rest framework. Rather, it is a component
+designed for other components of the application to come and register custom
+handlers for payment success or failure.
+"""
+
+import logging
+
+from django.utils.translation import gettext_lazy as _
+
+from .models import ProductCategory
+
+
+class PaymentCallbackSystem:
+    """
+    Interface to register your hooks with, and get them
+    """
+
+    # The dictionary of hooks
+    __HOOKS = {}
+    __logger = logging.getLogger("insalan.payment.hooks.PaymentCallbackSystem")
+
+    @classmethod
+    def register_handler(cls, prodcat, handler, overwrite=False):
+        """
+        Register a handler for a product category
+
+        You give it a product (any instance of
+        `payment.models.ProductCategory`), and a handler (any subclass of
+        `payment.hooks.PaymentHooks`).
+
+        Overwriting an existing hook will trigger an error, unless you set
+        `overwrite=False`.
+        """
+
+        # Verify arguments
+        # 1. product is an instance of Product
+        if not isinstance(prodcat, ProductCategory):
+            raise ValueError(_("Produit qui n'est pas une instance de Produit"))
+
+        if not issubclass(handler, PaymentHooks):
+            raise ValueError(_("Descripteur qui ne dérive pas de PaymentHooks"))
+
+        if cls.__HOOKS.get(prodcat):
+            if overwrite:
+                cls.__logger.warning(
+                    "Overwriting handler for product category %s", prodcat
+                )
+            else:
+                raise ValueError(_(f"Descripteur déjà défini pour {prodcat}"))
+
+        cls.__HOOKS[prodcat] = handler
+
+    @classmethod
+    def retrieve_handler(cls, prodcat):
+        """
+        Retrieve a handler class for a product category
+
+        If a handler is not registered, returns None
+        """
+        return cls.__HOOKS.get(prodcat)
+
+
+# Base class/interface
+class PaymentHooks:
+    """
+    Payment Hooks Class
+
+    This is a base class that must be derived by all hooks implementers, who
+    will then implement their way of handling payment success and failure.
+    """
+
+    @staticmethod
+    def prepare_transaction(_transaction, _product, _count) -> bool:
+        """
+        Prepare things that may have to be created prior to payment
+
+        Arguments are the preliminary transaction, product and count.
+        This hook is ran by the payment view exactly right before forwarding the
+        user to HelloAsso.
+        """
+
+    @staticmethod
+    def payment_success(_transaction, _product, _count):
+        """
+        Payment Success Handler
+
+        This method handles the process of validating a transaction, with the
+        transaction object, product and count given.
+        By that point, you can safely assume that the payment succeeded, and
+        that the `.payment_status` field of the transaction is set to
+        `SUCCEEDED`.
+        """
+
+    @staticmethod
+    def payment_failure(_transaction, _product, _count):
+        """
+        Payment Failure Handler
+
+        This method handles the process of cleaning up after a failed
+        transaction. By this point you can safely assume that the payment failed
+        and that `.payment_status` on the transaction object is set to `FAILED`.
+        """
+
+    @staticmethod
+    def payment_refunded(_transaction, _product, _count):
+        """
+        Payment Refund Handler
+
+        This method handles the process of cleaning up after a refund of a
+        transaction. By this point, you can safely assume that the payment has
+        been refunded on the side of helloasso.
+        """
+
+
+# vim: set tw=80: