django-redsys 1.0.0__py3-none-any.whl

django_redsys/__init__.py

@@ -0,0 +1 @@
+

django_redsys/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class DjangoRedsysConfig(AppConfig):
+    name = 'django_redsys'
+    verbose_name = 'RedSys'
+
+    def ready(self):
+        from . import checks  # noqa: F401

django_redsys/checks.py

@@ -0,0 +1,44 @@
+from django.conf import settings
+from django.core import checks
+from django.core.exceptions import ImproperlyConfigured
+from redsys import environments
+
+from .client import get_client
+from .conf import notification_networks
+
+
+@checks.register()
+def check_settings(app_configs, **kwargs):
+    errors = []
+    try:
+        get_client()
+    except ImproperlyConfigured as error:
+        errors.append(checks.Error(str(error), id='django_redsys.E001'))
+    try:
+        notification_networks()
+    except (TypeError, ValueError) as error:
+        errors.append(
+            checks.Error(
+                f'REDSYS_NOTIFICATION_IPS is not valid: {error}',
+                hint='List IP addresses or networks, such as "192.0.2.10" or "192.0.2.0/24".',
+                id='django_redsys.E002',
+            )
+        )
+    return errors
+
+
+@checks.register(deploy=True)
+def check_deploy(app_configs, **kwargs):
+    try:
+        client = get_client()
+    except ImproperlyConfigured:
+        return []
+    if settings.DEBUG or client.environment == environments.PROD:
+        return []
+    return [
+        checks.Warning(
+            f'REDSYS_CLIENT targets the {client.environment} environment with DEBUG off.',
+            hint='Production payments need environment=PROD (or sandbox=False).',
+            id='django_redsys.W001',
+        )
+    ]

django_redsys/client.py

@@ -0,0 +1,20 @@
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+from redsys.clients import RedirectClient
+
+
+def get_client(client_class=RedirectClient):
+    """A python-redsys client built from the ``REDSYS_CLIENT`` setting.
+
+    ``REDSYS_CLIENT`` holds the client's keyword options, or ``api_key`` and the remaining
+    options for ``from_api_key()``. ``client_class`` takes ``DirectClient`` or ``AsyncDirectClient``.
+    """
+    options = dict(getattr(settings, 'REDSYS_CLIENT', None) or {})
+    if 'api_key' not in options and 'secret_key' not in options:
+        raise ImproperlyConfigured('REDSYS_CLIENT must set secret_key or api_key.')
+    try:
+        if 'api_key' in options:
+            return client_class.from_api_key(options.pop('api_key'), **options)
+        return client_class(options.pop('secret_key'), **options)
+    except (TypeError, ValueError) as error:
+        raise ImproperlyConfigured(f'REDSYS_CLIENT is not valid: {error}') from error

django_redsys/conf.py

@@ -0,0 +1,13 @@
+from ipaddress import ip_network
+
+from django.conf import settings
+
+
+def notification_networks():
+    """The networks of ``REDSYS_NOTIFICATION_IPS``, or ``None`` when the setting is absent or empty."""
+    entries = getattr(settings, 'REDSYS_NOTIFICATION_IPS', None)
+    if not entries:
+        return None
+    if not isinstance(entries, (list, tuple)) or not all(isinstance(entry, str) for entry in entries):
+        raise TypeError('it must be a list of strings.')
+    return [ip_network(entry, strict=False) for entry in entries]

django_redsys/notifications/__init__.py

@@ -0,0 +1 @@
+

django_redsys/notifications/admin.py

@@ -0,0 +1,17 @@
+from django.contrib import admin
+
+from .models import Notification
+
+
+@admin.register(Notification)
+class NotificationAdmin(admin.ModelAdmin):
+    list_display = ['order', 'response_code', 'authorized', 'amount', 'currency', 'environment', 'count', 'received_at']
+    list_filter = ['authorized', 'environment', 'transaction_type', 'processed_pay_method']
+    search_fields = ['order', 'authorization_code']
+    date_hierarchy = 'received_at'
+
+    def has_add_permission(self, request):
+        return False
+
+    def has_change_permission(self, request, obj=None):
+        return False

django_redsys/notifications/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class NotificationsConfig(AppConfig):
+    name = 'django_redsys.notifications'
+    # The default label, "notifications", is common enough to clash with another app.
+    label = 'django_redsys_notifications'
+    verbose_name = 'RedSys notifications'
+    default_auto_field = 'django.db.models.BigAutoField'

django_redsys/notifications/management/__init__.py

@@ -0,0 +1 @@
+

django_redsys/notifications/management/commands/__init__.py

@@ -0,0 +1 @@
+

django_redsys/notifications/management/commands/purge_redsys_notifications.py

@@ -0,0 +1,20 @@
+from datetime import timedelta
+
+from django.core.management.base import BaseCommand, CommandError
+from django.utils import timezone
+
+from django_redsys.notifications.models import Notification
+
+
+class Command(BaseCommand):
+    help = 'Deletes the RedSys notifications first received more than DAYS days ago.'
+
+    def add_arguments(self, parser):
+        parser.add_argument('--older-than', type=int, required=True, metavar='DAYS')
+
+    def handle(self, *args, older_than, **options):
+        if older_than < 0:
+            raise CommandError('--older-than must be 0 or more days.')
+        cutoff = timezone.now() - timedelta(days=older_than)
+        deleted, _ = Notification.objects.filter(received_at__lt=cutoff).delete()
+        self.stdout.write(f'{deleted} notifications deleted.')

django_redsys/notifications/migrations/0001_initial.py

@@ -0,0 +1,49 @@
+# Generated by Django 6.1.3 on 2026-11-08 13:16
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name='Notification',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('digest', models.CharField(max_length=64, unique=True, verbose_name='payload digest')),
+                ('order', models.CharField(db_index=True, max_length=32, verbose_name='order')),
+                ('response_code', models.IntegerField(blank=True, null=True, verbose_name='response code')),
+                ('authorized', models.BooleanField(verbose_name='authorized')),
+                (
+                    'amount',
+                    models.DecimalField(blank=True, decimal_places=3, max_digits=15, null=True, verbose_name='amount'),
+                ),
+                ('currency', models.IntegerField(blank=True, null=True, verbose_name='currency')),
+                ('transaction_type', models.CharField(blank=True, max_length=8, verbose_name='transaction type')),
+                ('authorization_code', models.CharField(blank=True, max_length=16, verbose_name='authorization code')),
+                ('merchant_code', models.CharField(blank=True, max_length=16, verbose_name='merchant code')),
+                ('terminal', models.CharField(blank=True, max_length=8, verbose_name='terminal')),
+                ('environment', models.CharField(blank=True, max_length=8, verbose_name='environment')),
+                ('secure_payment', models.CharField(blank=True, max_length=4, verbose_name='secure payment')),
+                (
+                    'processed_pay_method',
+                    models.CharField(blank=True, max_length=8, verbose_name='processed payment method'),
+                ),
+                ('error_code', models.CharField(blank=True, max_length=16, verbose_name='error code')),
+                ('redsys_date', models.CharField(blank=True, max_length=16, verbose_name='RedSys date')),
+                ('redsys_hour', models.CharField(blank=True, max_length=16, verbose_name='RedSys hour')),
+                ('remote_addr', models.GenericIPAddressField(blank=True, null=True, verbose_name='sender address')),
+                ('received_at', models.DateTimeField(db_index=True, verbose_name='received at')),
+                ('last_received_at', models.DateTimeField(verbose_name='last received at')),
+                ('count', models.PositiveIntegerField(default=1, verbose_name='arrivals')),
+            ],
+            options={
+                'verbose_name': 'notification',
+                'verbose_name_plural': 'notifications',
+                'ordering': ['-received_at'],
+            },
+        ),
+    ]

django_redsys/notifications/migrations/__init__.py

@@ -0,0 +1 @@
+

django_redsys/notifications/models.py

@@ -0,0 +1,84 @@
+from hashlib import sha256
+from ipaddress import ip_address
+
+from django.db import models
+from django.db.models import F
+from django.utils import timezone
+from django.utils.translation import gettext_lazy as _
+
+
+def _address(value):
+    try:
+        return str(ip_address(value))
+    except ValueError:
+        return None
+
+
+class NotificationManager(models.Manager):
+    def register(self, merchant_parameters, response, environment='', remote_addr=None):
+        """Records a verified notification; ``True`` for the first arrival of its payload, ``False`` for a repeat."""
+
+        def text(name):
+            # Values are signed by RedSys but their lengths are not the database's to trust.
+            return (getattr(response, name) or '')[: self.model._meta.get_field(name).max_length]
+
+        now = timezone.now()
+        notification, created = self.get_or_create(
+            digest=sha256(merchant_parameters.encode()).hexdigest(),
+            defaults={
+                'order': text('order'),
+                'response_code': response.response_code,
+                'authorized': response.is_authorized(),
+                'amount': response.amount,
+                'currency': response.currency,
+                'transaction_type': text('transaction_type'),
+                'authorization_code': text('authorization_code'),
+                'merchant_code': text('merchant_code'),
+                'terminal': text('terminal'),
+                'environment': environment or '',
+                'secure_payment': text('secure_payment'),
+                'processed_pay_method': text('processed_pay_method'),
+                'error_code': text('error_code'),
+                'redsys_date': (response.date or '')[:16],
+                'redsys_hour': (response.hour or '')[:16],
+                'remote_addr': _address(remote_addr or ''),
+                'received_at': now,
+                'last_received_at': now,
+            },
+        )
+        if not created:
+            self.filter(pk=notification.pk).update(count=F('count') + 1, last_received_at=now)
+        return created
+
+
+class Notification(models.Model):
+    digest = models.CharField(_('payload digest'), max_length=64, unique=True)
+    order = models.CharField(_('order'), max_length=32, db_index=True)
+    response_code = models.IntegerField(_('response code'), null=True, blank=True)
+    authorized = models.BooleanField(_('authorized'))
+    amount = models.DecimalField(_('amount'), max_digits=15, decimal_places=3, null=True, blank=True)
+    currency = models.IntegerField(_('currency'), null=True, blank=True)
+    transaction_type = models.CharField(_('transaction type'), max_length=8, blank=True)
+    authorization_code = models.CharField(_('authorization code'), max_length=16, blank=True)
+    merchant_code = models.CharField(_('merchant code'), max_length=16, blank=True)
+    terminal = models.CharField(_('terminal'), max_length=8, blank=True)
+    environment = models.CharField(_('environment'), max_length=8, blank=True)
+    secure_payment = models.CharField(_('secure payment'), max_length=4, blank=True)
+    processed_pay_method = models.CharField(_('processed payment method'), max_length=8, blank=True)
+    error_code = models.CharField(_('error code'), max_length=16, blank=True)
+    redsys_date = models.CharField(_('RedSys date'), max_length=16, blank=True)
+    redsys_hour = models.CharField(_('RedSys hour'), max_length=16, blank=True)
+    remote_addr = models.GenericIPAddressField(_('sender address'), null=True, blank=True)
+    received_at = models.DateTimeField(_('received at'), db_index=True)
+    last_received_at = models.DateTimeField(_('last received at'))
+    count = models.PositiveIntegerField(_('arrivals'), default=1)
+
+    objects = NotificationManager()
+
+    class Meta:
+        ordering = ['-received_at']
+        verbose_name = _('notification')
+        verbose_name_plural = _('notifications')
+
+    def __str__(self):
+        return f'{self.order} {self.response_code}'

django_redsys/signals.py

@@ -0,0 +1,8 @@
+from django.dispatch import Signal
+
+request_created = Signal()
+notification_received = Signal()
+notification_authorized = Signal()
+notification_denied = Signal()
+notification_invalid = Signal()
+notification_repeated = Signal()

django_redsys/templates/django_redsys/ko.html

@@ -0,0 +1,15 @@
+{% load i18n %}{% get_current_language as LANGUAGE_CODE %}<!DOCTYPE html>
+<html lang="{{ LANGUAGE_CODE }}">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="robots" content="noindex">
+    <title>{% block title %}{% translate "Payment not completed" %}{% endblock %}</title>
+</head>
+<body>
+    {% block content %}
+    <h1>{% translate "Payment not completed" %}</h1>
+    <p>{% blocktranslate with order=redsys_response.order %}Order {{ order }}.{% endblocktranslate %}</p>
+    {% endblock %}
+</body>
+</html>

django_redsys/templates/django_redsys/ok.html

@@ -0,0 +1,15 @@
+{% load i18n %}{% get_current_language as LANGUAGE_CODE %}<!DOCTYPE html>
+<html lang="{{ LANGUAGE_CODE }}">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="robots" content="noindex">
+    <title>{% block title %}{% translate "Payment completed" %}{% endblock %}</title>
+</head>
+<body>
+    {% block content %}
+    <h1>{% translate "Payment completed" %}</h1>
+    <p>{% blocktranslate with order=redsys_response.order %}Order {{ order }}.{% endblocktranslate %}</p>
+    {% endblock %}
+</body>
+</html>

django_redsys/templates/django_redsys/redirect.html

@@ -0,0 +1,20 @@
+{% load i18n %}{% get_current_language as LANGUAGE_CODE %}<!DOCTYPE html>
+<html lang="{{ LANGUAGE_CODE }}">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="robots" content="noindex">
+    <title>{% block title %}{% translate "Redirecting to the payment page" %}{% endblock %}</title>
+    {% block head %}{% endblock %}
+</head>
+<body>
+    {% block content %}
+    <form id="redsys" method="post" action="{{ endpoint }}">
+        {% for name, value in fields.items %}<input type="hidden" name="{{ name }}" value="{{ value }}">
+        {% endfor %}
+        <noscript><button type="submit">{% translate "Continue to the payment page" %}</button></noscript>
+    </form>
+    <script{% if csp_nonce is not None %} nonce="{{ csp_nonce }}"{% endif %}>document.getElementById('redsys').submit();</script>
+    {% endblock %}
+</body>
+</html>

django_redsys/urls.py

@@ -0,0 +1,10 @@
+from django.urls import path
+
+from . import views
+
+app_name = 'django_redsys'
+urlpatterns = [
+    path('notification/', views.NotificationView.as_view(), name='notification'),
+    path('ok/', views.ResultView.as_view(template_name='django_redsys/ok.html'), name='ok'),
+    path('ko/', views.ResultView.as_view(template_name='django_redsys/ko.html', authorized=False), name='ko'),
+]

django_redsys/views.py

@@ -0,0 +1,169 @@
+from contextlib import nullcontext
+from ipaddress import ip_address
+
+from django.apps import apps
+from django.core.exceptions import PermissionDenied, SuspiciousOperation
+from django.db import router, transaction
+from django.http import Http404, HttpResponse
+from django.shortcuts import render
+from django.urls import reverse
+from django.utils.cache import add_never_cache_headers
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from django.views.generic import FormView, TemplateView, View
+from redsys import transactions
+from redsys.clients import MERCHANT_PARAMETERS
+
+from .client import get_client
+from .conf import notification_networks
+from .signals import (
+    notification_authorized,
+    notification_denied,
+    notification_invalid,
+    notification_received,
+    notification_repeated,
+    request_created,
+)
+
+NOTIFICATIONS_APP = 'django_redsys.notifications'
+
+
+class RedsysClientMixin:
+    def get_redsys_client(self):
+        """The python-redsys client of this view; ``get_client()`` unless a subclass picks another account."""
+        return get_client()
+
+
+class RedsysPaymentMixin(RedsysClientMixin):
+    """Signs a redirect-connection operation and renders the form that posts it to RedSys."""
+
+    transaction_type = transactions.AUTHORIZATION
+    redirect_template_name = 'django_redsys/redirect.html'
+
+    def get_redsys_fields(self):
+        raise NotImplementedError('get_redsys_fields() must return the operation fields, or None for no order.')
+
+    def get_redsys_request(self):
+        operation_fields = self.get_redsys_fields()
+        if not operation_fields:
+            raise Http404('No order to pay.')
+        fields = {
+            'merchant_url': self.request.build_absolute_uri(reverse('django_redsys:notification')),
+            'url_ok': self.request.build_absolute_uri(reverse('django_redsys:ok')),
+            'url_ko': self.request.build_absolute_uri(reverse('django_redsys:ko')),
+            **operation_fields,
+        }
+        redsys_request = self.get_redsys_client().request(self.transaction_type, **fields)
+        request_created.send(sender=type(self), request=self.request, redsys_request=redsys_request, fields=fields)
+        return redsys_request
+
+    def redirect_to_redsys(self):
+        redsys_request = self.get_redsys_request()
+        context = {'endpoint': redsys_request.endpoint, 'fields': redsys_request.to_dict()}
+        response = render(self.request, self.redirect_template_name, context)
+        # A cached form would resubmit a used order number (SIS0051).
+        add_never_cache_headers(response)
+        return response
+
+
+class RedsysPaymentView(RedsysPaymentMixin, View):
+    def get(self, request, *args, **kwargs):
+        return self.redirect_to_redsys()
+
+    def post(self, request, *args, **kwargs):
+        return self.redirect_to_redsys()
+
+
+class RedsysPaymentFormView(RedsysPaymentMixin, FormView):
+    def form_valid(self, form):
+        self.form = form
+        return self.redirect_to_redsys()
+
+
+@method_decorator(csrf_exempt, name='dispatch')
+class NotificationView(RedsysClientMixin, View):
+    """Receives the server-to-server notification RedSys posts to ``merchant_url``."""
+
+    http_method_names = ['post']
+
+    def is_allowed_sender(self):
+        networks = notification_networks()
+        if networks is None:
+            return True
+        try:
+            address = ip_address(self.request.META.get('REMOTE_ADDR', ''))
+        except ValueError:
+            return False
+        return any(address in network for network in networks)
+
+    def post(self, request, *args, **kwargs):
+        if not self.is_allowed_sender():
+            error = PermissionDenied('RedSys notification from an address outside REDSYS_NOTIFICATION_IPS.')
+            notification_invalid.send(sender=type(self), request=request, error=error)
+            raise error
+        client = self.get_redsys_client()
+        try:
+            response = client.parse_response(request.POST.dict())
+        # The payload is untrusted input: any failure to parse or verify it makes the notification invalid.
+        except Exception as error:
+            notification_invalid.send(sender=type(self), request=request, error=error)
+            raise SuspiciousOperation('RedSys notification failed verification.') from error
+        # Recording and receivers commit together: a receiver that fails leaves the notification unrecorded.
+        with self.processing():
+            if not self.register_notification(response, client):
+                notification_repeated.send(sender=type(self), request=request, response=response)
+                return HttpResponse()
+            notification_received.send(sender=type(self), request=request, response=response)
+            outcome = notification_authorized if response.is_authorized() else notification_denied
+            outcome.send(sender=type(self), request=request, response=response)
+        return HttpResponse()
+
+    def recording(self):
+        return apps.is_installed(NOTIFICATIONS_APP)
+
+    def processing(self):
+        if not self.recording():
+            return nullcontext()
+        from .notifications.models import Notification
+
+        return transaction.atomic(using=router.db_for_write(Notification))
+
+    def register_notification(self, response, client):
+        """Whether the notification is new: always without ``django_redsys.notifications``, else per its record."""
+        if not self.recording():
+            return True
+        from .notifications.models import Notification
+
+        return Notification.objects.register(
+            self.request.POST.get(MERCHANT_PARAMETERS, ''),
+            response,
+            environment=client.environment,
+            remote_addr=self.request.META.get('REMOTE_ADDR'),
+        )
+
+
+class ResultView(RedsysClientMixin, TemplateView):
+    """The ``url_ok`` / ``url_ko`` page: 404 unless RedSys appended a verified result with the expected outcome."""
+
+    authorized = True
+
+    def get_redsys_response(self):
+        payload = self.request.GET.dict()
+        if not payload:
+            return None
+        client = self.get_redsys_client()
+        try:
+            return client.parse_response(payload)
+        except Exception:
+            return None
+
+    def get(self, request, *args, **kwargs):
+        self.redsys_response = self.get_redsys_response()
+        if self.redsys_response is None or self.redsys_response.is_authorized() != self.authorized:
+            raise Http404('No RedSys result to show.')
+        return super().get(request, *args, **kwargs)
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context['redsys_response'] = self.redsys_response
+        return context

django_redsys-1.0.0.dist-info/METADATA

@@ -0,0 +1,239 @@
+Metadata-Version: 2.4
+Name: django-redsys
+Version: 1.0.0
+Summary: Django views, URLs and signals for RedSys TPV Virtual payments, on top of python-redsys.
+Author-email: David Díaz <d.diazp@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/ddiazpinto/django-redsys
+Project-URL: Source, https://github.com/ddiazpinto/django-redsys
+Keywords: django,redsys,sermepa,tpv,payments
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: Django>=5.2
+Requires-Dist: python-redsys>=2.2
+Dynamic: license-file
+
+# django-redsys
+
+[![CI](https://github.com/ddiazpinto/django-redsys/actions/workflows/ci.yml/badge.svg)](https://github.com/ddiazpinto/django-redsys/actions/workflows/ci.yml) ![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg) ![Django 5.2+](https://img.shields.io/badge/django-5.2%2B-blue.svg) [![License: Apache 2.0](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+
+Django views, URLs and signals for RedSys TPV Virtual payments over the *redirect connection*. Signing, verification, parameters, constants and response codes come from [python-redsys](https://github.com/ddiazpinto/python-redsys); this app adds the Django side: the page that sends the cardholder to RedSys, the endpoint that receives RedSys's notification, the OK and KO pages, and signals.
+
+## Installation
+
+```bash
+pip install django-redsys
+```
+
+```python
+# settings.py
+INSTALLED_APPS = [..., 'django_redsys']
+
+REDSYS_CLIENT = {
+    'secret_key': '...',
+    'merchant_code': '999008881',
+    'terminal': 1,
+    'sandbox': True,
+}
+
+# urls.py
+urlpatterns = [..., path('redsys/', include('django_redsys.urls'))]
+```
+
+## Settings
+
+| Setting | Use |
+|---|---|
+| `REDSYS_CLIENT` | Required. The account: the keyword options of python-redsys's `RedirectClient`. |
+| `REDSYS_NOTIFICATION_IPS` | Optional. Addresses or networks allowed to post notifications; see [Notification senders](#notification-senders). |
+
+The keys of `REDSYS_CLIENT`:
+
+| Key | Use |
+|---|---|
+| `secret_key` | Merchant secret key. Required unless `api_key` is set. |
+| `merchant_code`, `terminal` | Merchant code (FUC) and terminal number. |
+| `sandbox` or `environment` | `sandbox=True` targets the test environment; `environment=` takes `redsys.environments.TEST`, `PROD`, `INTE` or `DESA`. Production by default. |
+| `currency` | Default currency (`redsys.currencies`); the euro unless set. |
+| `signature_version` | `HMAC_SHA512_V2` by default. |
+| `module` | `Ds_Merchant_Module` of every request. |
+| `api_key` | A RedSys API key, read with `RedirectClient.from_api_key()`; replaces `secret_key`, `merchant_code`, `terminal` and the environment. |
+
+The keys go to the constructor unchanged, so an option a later python-redsys adds works without a django-redsys release. An unknown key, an invalid value, or `api_key` together with the values it replaces raises `ImproperlyConfigured`. See the [python-redsys configuration](https://github.com/ddiazpinto/python-redsys#configuration).
+
+`manage.py check` validates both settings (`django_redsys.E001`, `django_redsys.E002`). `manage.py check --deploy` warns when `REDSYS_CLIENT` targets an environment other than production while `DEBUG` is off (`django_redsys.W001`); a staging server that uses the test environment on purpose silences it with `SILENCED_SYSTEM_CHECKS`.
+
+## Payment view
+
+A subclass of `RedsysPaymentView` returns the operation fields; the view signs them and renders a form that posts itself to RedSys. It answers GET and POST. A view that stores state, as the one below, is reached through a POST form (a "Pay" button): browsers and crawlers prefetch GET links, and each prefetch would use up an order number.
+
+```python
+from decimal import Decimal
+
+from django.shortcuts import get_object_or_404
+from django_redsys.views import RedsysPaymentView
+from redsys import generate_order
+
+
+class PayOrderView(RedsysPaymentView):
+    def get_redsys_fields(self):
+        order = get_object_or_404(Order, pk=self.kwargs['pk'], user=self.request.user)
+        order.redsys_order = generate_order()
+        order.save(update_fields=['redsys_order'])
+        return {
+            'order': order.redsys_order,
+            'amount': order.total,  # Decimal, in euros unless currency= says otherwise
+            'merchant_data': str(order.pk),
+            'product_description': 'Online order',
+        }
+```
+
+| Attribute or method | Use |
+|---|---|
+| `get_redsys_fields()` | Required. The keyword fields of the operation: `order`, `amount` and any other [redirect parameter](https://github.com/ddiazpinto/python-redsys/blob/master/docs/redirect-connection.md). `None` (or `Http404` raised) when there is no order to pay: the view answers `404`. |
+| `get_redsys_client()` | The client that signs, `get_client()` by default. A view that pays through another terminal or merchant returns its own `RedirectClient`; the notification and result views have the same method. |
+| `transaction_type` | `redsys.transactions.AUTHORIZATION` by default; `PREAUTHORIZATION`, `AUTHENTICATION` or `REFUND_WITHOUT_ORIGINAL` for the other redirect operations. |
+| `redirect_template_name` | `django_redsys/redirect.html` by default. |
+| `get_redsys_request()` | Builds and signs the python-redsys `Request`; sends `request_created`. |
+
+`merchant_url`, `url_ok` and `url_ko` default to the app's notification, OK and KO URLs; a value returned by `get_redsys_fields()` replaces them. The URLs are absolute, from `request.build_absolute_uri()`; behind a proxy that terminates TLS, `SECURE_PROXY_SSL_HEADER` makes them `https`.
+
+The page is sent with `Cache-Control: no-store`: a cached copy would post an order number RedSys already received, which it rejects (SIS0051).
+
+`RedsysPaymentFormView` is the same on top of `FormView`: after `form_valid()`, `self.form` holds the validated form for `get_redsys_fields()`. `RedsysPaymentMixin` holds the behavior for other view classes; `redirect_to_redsys()` returns the response.
+
+Invalid fields raise python-redsys's `ValueError` subclasses before anything is signed ([errors](https://github.com/ddiazpinto/python-redsys#errors)).
+
+## Notification and signals
+
+RedSys posts the result of every operation to `merchant_url`. `NotificationView` (`django_redsys:notification`) verifies the signature, parses the result into a python-redsys `Response` and sends the signals; it answers `200` with an empty body. A payload that fails parsing or verification, whatever the exception, raises `SuspiciousOperation` chained to it: Django answers `400` and logs it on the `django.security` logger.
+
+| Signal (`django_redsys.signals`) | Sent | Arguments |
+|---|---|---|
+| `request_created` | A payment view signed a request. | `request`, `redsys_request`, `fields` |
+| `notification_received` | A notification passed verification. | `request`, `response` |
+| `notification_authorized` | After `notification_received`, when `response.is_authorized()`. | `request`, `response` |
+| `notification_denied` | After `notification_received`, otherwise. | `request`, `response` |
+| `notification_invalid` | A notification failed verification or parsing, or came from an address outside `REDSYS_NOTIFICATION_IPS`. | `request`, `error` |
+| `notification_repeated` | With [the notification record](#notification-record), a verified notification whose payload already arrived; sent instead of the three above. | `request`, `response` |
+
+`sender` is the view class. The notification is the source of truth for an operation's outcome; the OK and KO pages are not, since the cardholder may never reach them.
+
+A valid notification can arrive more than once. The signed result also reaches the cardholder's browser on the redirect to `url_ok` or `url_ko` (when the portal sends it, see below), and a copy posted to the notification URL verifies like the original. Receivers are idempotent: they act on the state of the order, not on the arrival of the signal, and check that the result matches what was asked for.
+
+```python
+from django.db import transaction
+from django.dispatch import receiver
+from django_redsys.signals import notification_authorized
+
+
+@receiver(notification_authorized)
+def mark_paid(sender, request, response, **kwargs):
+    with transaction.atomic():
+        order = Order.objects.select_for_update().filter(redsys_order=response.order).first()
+        if order is None or order.is_paid or order.total != response.amount:
+            return
+        order.mark_paid(authorization_code=response.authorization_code)
+```
+
+`response` carries every result field (`order`, `amount`, `response_code`, `authorization_code`, `merchant_data`, `card_country`, ...) and `response.describe(language)` gives the meaning of the code; see the [response parameters](https://github.com/ddiazpinto/python-redsys/blob/master/docs/redirect-connection.md#response-parameters) and [response codes](https://github.com/ddiazpinto/python-redsys/blob/master/docs/response-codes.md). An exception in a receiver propagates, and the notification gets a `500`.
+
+## Notification senders
+
+`REDSYS_NOTIFICATION_IPS`, off by default, limits who may post to the notification URL. A request from any other address gets `403` before its payload is parsed, and `notification_invalid` is sent with a `PermissionDenied` error.
+
+```python
+REDSYS_NOTIFICATION_IPS = ['192.0.2.10', '198.51.100.0/24']  # RedSys's addresses, as the bank or RedSys gives them
+```
+
+The address compared is `REMOTE_ADDR`. Behind a proxy or load balancer, `REMOTE_ADDR` is the proxy's unless the server sets it from the forwarded header; a subclass of `NotificationView` can override `is_allowed_sender()` to read it another way. The signature check stays: the list only saves the work of parsing what does not come from RedSys.
+
+## Notification record
+
+`django_redsys.notifications`, an optional app, records every verified notification and turns a repeat into `notification_repeated`:
+
+```python
+INSTALLED_APPS = [..., 'django_redsys', 'django_redsys.notifications']
+```
+
+```bash
+python manage.py migrate
+```
+
+- A notification is a repeat when its `Ds_MerchantParameters` is identical to one already recorded (SHA-256 digest, unique). A new result for the same order is not a repeat. Idempotency per order stays with the receivers.
+- The record and the signals commit in one transaction on the database the model is routed to: a receiver that raises leaves nothing recorded, and the next arrival of the same notification is processed as new.
+- Each record keeps the order, the response code and `SISnnnn` error code, whether it was authorized, the amount and currency, the transaction type, the authorization code, the merchant code, terminal and environment (`TEST`, `PROD`, ...), whether the payment was 3-D Secure authenticated (`Ds_SecurePayment`), the payment method that processed it (`Ds_ProcessedPayMethod`), RedSys's date and hour as sent (`Ds_Date`, `Ds_Hour`), the sender address, the first and last arrival, and the number of arrivals. Card data, stored-card tokens (`Ds_Merchant_Identifier`, `Ds_Merchant_Cof_Txnid`) and `merchant_data` are not stored: a token charges the card again, and `merchant_data` is free text. Invalid notifications are not recorded.
+- The admin lists the records read-only (`django.contrib.admin` installed). `python manage.py purge_redsys_notifications --older-than DAYS` deletes the records first received more than `DAYS` days ago, for a retention period run from cron or a scheduler.
+- The app label is `django_redsys_notifications`.
+
+## OK and KO pages
+
+`django_redsys:ok` and `django_redsys:ko` render `django_redsys/ok.html` and `django_redsys/ko.html` through `ResultView`, with the verified result as `redsys_response`. RedSys appends the signed result to the redirect only when the option "Enviar Parámetros en las URLs" is on in its portal. Without a result that verifies, or with an outcome that does not match the page (an authorized result on the KO page, or the reverse), the page answers `404`. With the option off, `url_ok` and `url_ko` point to the project's own views. A template with the same name in the project replaces the app's.
+
+## Templates and Content Security Policy
+
+`django_redsys/redirect.html` receives `endpoint` and `fields` (the three `Ds_*` fields) and submits the form with an inline script, with a `<noscript>` button as fallback. With Django's CSP middleware (Django 6.0 and later) and the `django.template.context_processors.csp` context processor, the script carries the request's nonce; the policy then needs `CSP.NONCE` in `script-src` and the RedSys host in `form-action`:
+
+```python
+from django.utils.csp import CSP
+
+SECURE_CSP = {
+    'script-src': [CSP.SELF, CSP.NONCE],
+    'form-action': [CSP.SELF, 'https://sis.redsys.es', 'https://sis-t.redsys.es:25443'],
+}
+```
+
+Every template defines a `title` and a `content` block; `redirect.html` also defines `head`.
+
+## Direct operations
+
+`django_redsys.client.get_client()` builds the client from `REDSYS_CLIENT`; it takes another client class for the direct connection (`pip install "python-redsys[http]"`):
+
+```python
+from django_redsys.client import get_client
+from redsys.clients import DirectClient
+
+response = get_client(DirectClient).refund(order=order.redsys_order, amount=order.total).send()
+response.is_refunded()
+```
+
+## Compatibility
+
+| | |
+|---|---|
+| Version | 1.0.0 |
+| Django | 5.2 LTS, 6.0 and 6.1 |
+| Python | 3.10 to 3.15 (Django 6.0 and later need 3.12) |
+| python-redsys | 2.2 and later |
+
+Upgrading from 0.4: [`docs/migration-0.4-to-1.0.md`](docs/migration-0.4-to-1.0.md).
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run ruff check django_redsys tests && uv run ruff format --check django_redsys tests
+```
+
+## License
+
+Apache License 2.0, as python-redsys. See [`LICENSE`](LICENSE) and [`NOTICE`](NOTICE). Releases up to 0.4.2 were published under the MIT License.

django_redsys-1.0.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+django_redsys/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+django_redsys/apps.py,sha256=WTXxE_V-DAug4wqxVbI559kqTHwG57_2_2pKzfB6n8o,193
+django_redsys/checks.py,sha256=LgrAe4r70C1C8vqbxfY0UyKBhlvclzXuMTqZMoPCC9I,1338
+django_redsys/client.py,sha256=3PqfDFcIf6t9bYirrMuT08plefnmKrZaV3czwDXUfN8,987
+django_redsys/conf.py,sha256=_TTzDZRHW57lMFTtEPdxIgYYGnZBhWg6fErBP-GkfTQ,533
+django_redsys/signals.py,sha256=pCNwhYYZxHFs4PLtoW4l4ZaSD6ugZ1s-brMaBE7ykiE,227
+django_redsys/urls.py,sha256=woLggeXUBk39qaYZqEq1gQDNMMiLttBfpuwzRNpSpW4,382
+django_redsys/views.py,sha256=XqodQDfjUk6B9S38Tz6zmZWIlgULQhy-ERDa2UygDMo,6782
+django_redsys/notifications/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+django_redsys/notifications/admin.py,sha256=hyKZ8Ntrgxj1PxZKc7m62P_vp5ZfxiD9nxT0FYr3K2k,585
+django_redsys/notifications/apps.py,sha256=BB8nz8kWCVER38lF6dl2GAjWmJbfWYZAX2ygtj9I7zY,342
+django_redsys/notifications/models.py,sha256=H2fg9RNoicCsiVZJ3HyJNC9j9i-rnBP1ByzNFX4UzTE,3981
+django_redsys/notifications/management/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+django_redsys/notifications/management/commands/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+django_redsys/notifications/management/commands/purge_redsys_notifications.py,sha256=t5oMF6yGm41P1uLYvXGCSp6P7mfC1EdUvRJ_oEoIoAA,789
+django_redsys/notifications/migrations/0001_initial.py,sha256=42cfDo-a6zMdsjq-ta8xSwHdMDqFF-QK76IBDtQcNQQ,2855
+django_redsys/notifications/migrations/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+django_redsys/templates/django_redsys/ko.html,sha256=EtxglKx1QbnLxD9ZQEWwFlVc1AHU7YHd-IZgSGEPRFE,581
+django_redsys/templates/django_redsys/ok.html,sha256=jeQF3rg1vjjqggsy1_hnta7UE9QsHMZ_IQQMdzrSpEM,573
+django_redsys/templates/django_redsys/redirect.html,sha256=IU6UtTVRD899_egyfDvc-_x6vYdcGocohCeiTUYcGmI,903
+django_redsys-1.0.0.dist-info/licenses/LICENSE,sha256=qsc7MUj20dcRHbyjIJn2jSbGRMaBOuHk8F9leaomY_4,11360
+django_redsys-1.0.0.dist-info/licenses/NOTICE,sha256=QwkHYuPzHIdnNLmmwoqcsrehtIBB76LGdcIwTMiOVbY,201
+django_redsys-1.0.0.dist-info/METADATA,sha256=y6UwMancP6plh3C3hJMvb3dchcYQ5VA0lNnh2pBizos,14695
+django_redsys-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+django_redsys-1.0.0.dist-info/top_level.txt,sha256=Tw9TJXtLISTUIE8Cx_FYmO4h8kzf4DkbJQYTwbsU5to,14
+django_redsys-1.0.0.dist-info/RECORD,,

django_redsys-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

django_redsys-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

django_redsys-1.0.0.dist-info/licenses/NOTICE

@@ -0,0 +1,7 @@
+django-redsys
+Copyright 2016-2026 David Díaz
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may obtain a copy of the License at:
+
+    https://www.apache.org/licenses/LICENSE-2.0

django_redsys-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+django_redsys