django-app-logs 2.2.1__tar.gz

django_app_logs-2.2.1/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: django-app-logs
+Version: 2.2.1
+Summary: Logging django's actions
+Author-email: Cissé Anzoumana <anzcisse1@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mosco23/django-app-logs
+Project-URL: Documentation, https://github.com/mosco23/django-app-logs#readme
+Project-URL: Bug Tracker, https://github.com/mosco23/django-app-logs/issues
+Keywords: django,logging,logger,access,django access log
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Django :: 4.0
+Classifier: Framework :: Django :: 4.1
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+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: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: Django>=3.2
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-django>=4.5.0; extra == "dev"
+
+# Django Access Log
+
+
+## Add packge to INSTALLED_APPS
+
+```python
+
+INSTALLED_APPS = [
+    ...
+    'django_app_logs',
+]
+
+```
+
+## Make migrations
+
+```python
+
+python manage.py migrate
+
+```

django_app_logs-2.2.1/README.md

@@ -0,0 +1,21 @@
+# Django Access Log
+
+
+## Add packge to INSTALLED_APPS
+
+```python
+
+INSTALLED_APPS = [
+    ...
+    'django_app_logs',
+]
+
+```
+
+## Make migrations
+
+```python
+
+python manage.py migrate
+
+```

django_app_logs-2.2.1/django_app_logs/admin.py

@@ -0,0 +1,188 @@
+from django.contrib import admin
+from django.contrib.contenttypes.models import ContentType
+from django.urls import path, reverse
+from django.template.loader import render_to_string
+from django.shortcuts import render
+from django.utils.html import format_html
+from django.http import Http404
+import json
+
+from .models import ActionLog
+
+
+@admin.register(ActionLog)
+class ActionLogAdmin(admin.ModelAdmin):
+    list_display = (
+        'timestamp',
+        'user_display',
+        'action_display',
+        'content_type',
+        'object_repr',
+        'object_history_link',
+        'ip_address',
+    )
+    list_filter = ('action', 'content_type', 'timestamp')
+    search_fields = ('object_repr', 'user__username', 'ip_address')
+    date_hierarchy = 'timestamp'
+    readonly_fields = (
+        'content_type',
+        'object_id',
+        'object_repr',
+        'action',
+        'user',
+        'ip_address',
+        'user_agent',
+        'changes_display',
+        'timestamp',
+    )
+
+    fieldsets = (
+        ('Objet', {
+            'fields': ('content_type', 'object_id', 'object_repr')
+        }),
+        ('Action', {
+            'fields': ('action', 'user', 'timestamp')
+        }),
+        ('Contexte', {
+            'fields': ('ip_address', 'user_agent'),
+            'classes': ('collapse',)
+        }),
+        ('Modifications', {
+            'fields': ('changes_display',)
+        }),
+    )
+
+    def has_add_permission(self, request):
+        return False
+
+    def has_change_permission(self, request, obj=None):
+        return False
+
+    def has_delete_permission(self, request, obj=None):
+        return request.user.is_superuser
+
+    def get_urls(self):
+        urls = super().get_urls()
+        custom_urls = [
+            path(
+                'object-history/<int:content_type_id>/<int:object_id>/',
+                self.admin_site.admin_view(self.object_history_view),
+                name='history_object_history'
+            ),
+        ]
+        return custom_urls + urls
+
+    def object_history_view(self, request, content_type_id, object_id):
+        """Vue pour afficher l'historique complet d'un objet."""
+        try:
+            content_type = ContentType.objects.get(pk=content_type_id)
+        except ContentType.DoesNotExist:
+            raise Http404("Type de contenu non trouvé")
+
+        logs = ActionLog.objects.filter(
+            content_type=content_type,
+            object_id=object_id
+        ).order_by('-timestamp')
+
+        # Récupérer la représentation de l'objet
+        if logs.exists():
+            object_repr = logs.first().object_repr
+        else:
+            # Essayer de récupérer l'objet directement
+            model_class = content_type.model_class()
+            try:
+                obj = model_class.objects.get(pk=object_id)
+                object_repr = str(obj)
+            except model_class.DoesNotExist:
+                object_repr = f"{content_type.model} #{object_id} (supprimé)"
+
+        # URL vers l'objet s'il existe encore
+        object_url = None
+        model_class = content_type.model_class()
+        try:
+            obj = model_class.objects.get(pk=object_id)
+            object_url = reverse(
+                f'admin:{content_type.app_label}_{content_type.model}_change',
+                args=[object_id]
+            )
+        except (model_class.DoesNotExist, Exception):
+            pass
+
+        context = {
+            **self.admin_site.each_context(request),
+            'title': f'Historique de {object_repr}',
+            'logs': logs,
+            'content_type': content_type,
+            'object_id': object_id,
+            'object_repr': object_repr,
+            'object_url': object_url,
+        }
+
+        return render(request, 'admin/history/object_history.html', context)
+
+    def user_display(self, obj):
+        if obj.user:
+            return f"{obj.user.last_name} {obj.user.first_name}".strip() or obj.user.username
+        return "Système"
+    user_display.short_description = "Utilisateur"
+
+    def action_display(self, obj):
+        colors = {
+            'CREATE': '#28a745',
+            'UPDATE': '#ffc107',
+            'DELETE': '#dc3545',
+        }
+        color = colors.get(obj.action, '#6c757d')
+        return format_html(
+            '<span style="color: {}; font-weight: bold;">{}</span>',
+            color,
+            obj.get_action_display()
+        )
+    action_display.short_description = "Action"
+
+    def object_history_link(self, obj):
+        """Lien vers l'historique complet de l'objet."""
+        url = reverse(
+            'admin:django_app_logs_object_history',
+            args=[obj.content_type_id, obj.object_id]
+        )
+        count = ActionLog.objects.filter(
+            content_type=obj.content_type,
+            object_id=obj.object_id
+        ).count()
+        return format_html(
+            '<a href="{}" title="Voir tout l\'historique de cet objet">'
+            '<i class="fas fa-history"></i> {} action(s)</a>',
+            url,
+            count
+        )
+    object_history_link.short_description = "Historique"
+
+
+    def changes_display(self, obj):
+        if not obj.changes:
+            return "-"
+
+        history = []
+        for field, values in obj.changes.items():
+            old_val = values.get('old', '-')
+            new_val = values.get('new', '-')
+
+            if isinstance(old_val, dict):
+                old_val = old_val.get('repr', json.dumps(old_val, ensure_ascii=False))
+            if isinstance(new_val, dict):
+                new_val = new_val.get('repr', json.dumps(new_val, ensure_ascii=False))
+
+            data = {
+                "field": field,
+                "old_val": old_val,
+                "new_val": new_val,
+            }
+            history.append(data)
+
+        context = {
+            'history': history
+        }
+        return render_to_string('admin/partials/action_view.html', context)
+    changes_display.short_description = "Détails des modifications"
+

django_app_logs-2.2.1/django_app_logs/apps.py

@@ -0,0 +1,15 @@
+from django.apps import AppConfig
+
+
+class DjangoAppLogsConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_app_logs'
+    verbose_name = 'Journal des actions'
+
+    def ready(self):
+        # Enregistrer les exclusions par défaut
+        from .registry import ActionLogRegistry
+        ActionLogRegistry.register_default_exclusions()
+
+        # Importer les signaux pour les connecter
+        from . import signals  # noqa

django_app_logs-2.2.1/django_app_logs/middleware.py

@@ -0,0 +1,51 @@
+from threading import local
+
+_request_context = local()
+
+
+class RequestContextMiddleware:
+    """
+    Middleware qui capture et stocke les informations de contexte de la requête
+    (user, IP, User-Agent) dans un thread-local pour utilisation par les signaux.
+    """
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        # Stocker les informations dans le thread-local
+        _request_context.user = getattr(request, 'user', None)
+        _request_context.ip_address = self.get_client_ip(request)
+        _request_context.user_agent = request.META.get('HTTP_USER_AGENT', '')[:500]
+
+        response = self.get_response(request)
+
+        return response
+
+    @staticmethod
+    def get_client_ip(request):
+        """Récupère l'IP client, gérant les proxies."""
+        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
+        if x_forwarded_for:
+            ip = x_forwarded_for.split(',')[0].strip()
+        else:
+            ip = request.META.get('REMOTE_ADDR')
+        return ip
+
+    @staticmethod
+    def get_current_user():
+        """Récupère l'utilisateur courant."""
+        user = getattr(_request_context, 'user', None)
+        if user and hasattr(user, 'is_authenticated') and user.is_authenticated:
+            return user
+        return None
+
+    @staticmethod
+    def get_ip_address():
+        """Récupère l'adresse IP."""
+        return getattr(_request_context, 'ip_address', None)
+
+    @staticmethod
+    def get_user_agent():
+        """Récupère le User-Agent."""
+        return getattr(_request_context, 'user_agent', '')

django_app_logs-2.2.1/django_app_logs/migrations/0001_initial.py

@@ -0,0 +1,39 @@
+# Generated by Django 5.0.7 on 2025-12-14 09:11
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('contenttypes', '0002_remove_content_type_name'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ActionLog',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('object_id', models.PositiveIntegerField(verbose_name='ID objet')),
+                ('object_repr', models.CharField(blank=True, max_length=255, verbose_name='Représentation objet')),
+                ('action', models.CharField(choices=[('CREATE', 'Création'), ('UPDATE', 'Modification'), ('DELETE', 'Suppression')], max_length=10, verbose_name='Action')),
+                ('ip_address', models.GenericIPAddressField(blank=True, null=True, verbose_name='Adresse IP')),
+                ('user_agent', models.TextField(blank=True, verbose_name='User-Agent')),
+                ('changes', models.JSONField(default=dict, verbose_name='Modifications')),
+                ('timestamp', models.DateTimeField(auto_now_add=True, db_index=True, verbose_name='Date/Heure')),
+                ('content_type', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='contenttypes.contenttype', verbose_name='Type de contenu')),
+                ('user', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='action_logs', to=settings.AUTH_USER_MODEL, verbose_name='Utilisateur')),
+            ],
+            options={
+                'verbose_name': "Journal d'action",
+                'verbose_name_plural': 'Journal des actions',
+                'ordering': ['-timestamp'],
+                'indexes': [models.Index(fields=['content_type', 'object_id'], name='history_act_content_14194b_idx'), models.Index(fields=['user', 'timestamp'], name='history_act_user_id_ca8939_idx'), models.Index(fields=['action', 'timestamp'], name='history_act_action_a84aa4_idx')],
+            },
+        ),
+    ]

django_app_logs-2.2.1/django_app_logs/models.py

@@ -0,0 +1,89 @@
+from django.db import models
+from django.conf import settings
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.contenttypes.fields import GenericForeignKey
+
+
+class ActionType(models.TextChoices):
+    CREATE = 'CREATE', 'Création'
+    UPDATE = 'UPDATE', 'Modification'
+    DELETE = 'DELETE', 'Suppression'
+
+
+class ActionLog(models.Model):
+    """
+    Modèle de traçabilité des actions CRUD sur tous les modèles du projet.
+    """
+    # Relation générique vers l'objet concerné
+    content_type = models.ForeignKey(
+        ContentType,
+        on_delete=models.CASCADE,
+        verbose_name="Type de contenu"
+    )
+    object_id = models.PositiveIntegerField(verbose_name="ID objet")
+    content_object = GenericForeignKey('content_type', 'object_id')
+
+    # Représentation textuelle de l'objet (utile après suppression)
+    object_repr = models.CharField(
+        max_length=255,
+        verbose_name="Représentation objet",
+        blank=True
+    )
+
+    # Type d'action
+    action = models.CharField(
+        max_length=10,
+        choices=ActionType.choices,
+        verbose_name="Action"
+    )
+
+    # Utilisateur ayant effectué l'action
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name='action_logs',
+        verbose_name="Utilisateur"
+    )
+
+    # Informations de contexte HTTP
+    ip_address = models.GenericIPAddressField(
+        null=True,
+        blank=True,
+        verbose_name="Adresse IP"
+    )
+    user_agent = models.TextField(
+        blank=True,
+        verbose_name="User-Agent"
+    )
+
+    # Données avant/après modification
+    # Pour CREATE: {"field1": {"new": value}, ...}
+    # Pour UPDATE: {"field1": {"old": x, "new": y}, ...} (champs modifiés uniquement)
+    # Pour DELETE: {"field1": {"old": value}, ...}
+    changes = models.JSONField(
+        default=dict,
+        verbose_name="Modifications"
+    )
+
+    # Timestamp de l'action
+    timestamp = models.DateTimeField(
+        auto_now_add=True,
+        db_index=True,
+        verbose_name="Date/Heure"
+    )
+
+    class Meta:
+        verbose_name = "Journal d'action"
+        verbose_name_plural = "Journal des actions"
+        ordering = ['-timestamp']
+        indexes = [
+            models.Index(fields=['content_type', 'object_id']),
+            models.Index(fields=['user', 'timestamp']),
+            models.Index(fields=['action', 'timestamp']),
+        ]
+
+    def __str__(self):
+        user_str = self.user.username if self.user else 'Système'
+        return f"[{self.timestamp:%Y-%m-%d %H:%M}] {user_str} - {self.action} - {self.object_repr}"

django_app_logs-2.2.1/django_app_logs/registry.py

@@ -0,0 +1,43 @@
+class ActionLogRegistry:
+    """
+    Registre des modèles à exclure du tracking automatique.
+    """
+
+    _excluded_models = set()
+
+    @classmethod
+    def exclude(cls, model_or_label):
+        """
+        Exclut un modèle du tracking.
+
+        Usage:
+            ActionLogRegistry.exclude('operation_app.Transfert')
+            ActionLogRegistry.exclude(Transfert)
+        """
+        if isinstance(model_or_label, str):
+            cls._excluded_models.add(model_or_label.lower())
+        else:
+            label = f"{model_or_label._meta.app_label}.{model_or_label._meta.model_name}"
+            cls._excluded_models.add(label.lower())
+
+    @classmethod
+    def is_excluded(cls, model):
+        """Vérifie si un modèle est exclu."""
+        label = f"{model._meta.app_label}.{model._meta.model_name}".lower()
+        return label in cls._excluded_models
+
+    @classmethod
+    def register_default_exclusions(cls):
+        """Enregistre les exclusions par défaut."""
+        # Modèles explicitement exclus (ont leur propre système d'archive)
+        #cls.exclude('operation_app.transfert')
+        #cls.exclude('operation_app.recouvrement')
+
+        # Le modèle ActionLog lui-même (éviter récursion)
+        cls.exclude('django_app_logs.actionlog')
+
+        # Modèles Django internes à exclure
+        cls.exclude('contenttypes.contenttype')
+        cls.exclude('sessions.session')
+        cls.exclude('admin.logentry')
+        cls.exclude('auth.permission')

django_app_logs-2.2.1/django_app_logs/serializers.py

@@ -0,0 +1,121 @@
+import json
+from datetime import datetime, date, time
+from decimal import Decimal
+from uuid import UUID
+from django.db.models import Model
+from django.db.models.fields.files import FieldFile
+
+
+class ActionLogEncoder(json.JSONEncoder):
+    """
+    Encodeur JSON personnalisé pour les valeurs de modèles Django.
+    """
+
+    def default(self, obj):
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        elif isinstance(obj, date):
+            return obj.isoformat()
+        elif isinstance(obj, time):
+            return obj.isoformat()
+        elif isinstance(obj, Decimal):
+            return str(obj)
+        elif isinstance(obj, UUID):
+            return str(obj)
+        elif isinstance(obj, FieldFile):
+            return obj.name if obj else None
+        elif isinstance(obj, Model):
+            return {
+                'pk': obj.pk,
+                'repr': str(obj),
+                'model': f"{obj._meta.app_label}.{obj._meta.model_name}"
+            }
+        elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes)):
+            return list(obj)
+        return super().default(obj)
+
+
+def serialize_value(value):
+    """Sérialise une valeur pour stockage JSON."""
+    return json.loads(json.dumps(value, cls=ActionLogEncoder))
+
+
+def get_model_field_value(instance, field_name):
+    """
+    Récupère la valeur d'un champ de manière sécurisée.
+    Gère les FK en récupérant le PK et la représentation.
+    """
+    try:
+        field = instance._meta.get_field(field_name)
+        value = getattr(instance, field_name, None)
+
+        # Pour les ForeignKey, on stocke le PK + représentation
+        if hasattr(field, 'related_model') and field.related_model:
+            if value is not None:
+                return {
+                    'pk': value.pk,
+                    'repr': str(value)
+                }
+            return None
+
+        return serialize_value(value)
+    except Exception:
+        return None
+
+
+def compute_changes(old_instance, new_instance, fields_to_track=None):
+    """
+    Calcule les différences entre deux instances d'un modèle.
+
+    Args:
+        old_instance: Instance avant modification (ou None pour CREATE)
+        new_instance: Instance après modification
+        fields_to_track: Liste de noms de champs à tracker (None = tous)
+
+    Returns:
+        dict: {field_name: {'old': value, 'new': value}, ...}
+    """
+    changes = {}
+
+    # Champs à ignorer
+    ignored_fields = {'id', 'pk', 'created_at', 'updated_at'}
+
+    # Déterminer les champs à tracker
+    if fields_to_track is None:
+        fields = [
+            f.name for f in new_instance._meta.get_fields()
+            if hasattr(f, 'column') and f.name not in ignored_fields
+        ]
+    else:
+        fields = [f for f in fields_to_track if f not in ignored_fields]
+
+    for field_name in fields:
+        new_value = get_model_field_value(new_instance, field_name)
+
+        if old_instance is None:
+            # CREATE: toutes les nouvelles valeurs
+            if new_value is not None:
+                changes[field_name] = {'new': new_value}
+        else:
+            # UPDATE: seulement les différences
+            old_value = get_model_field_value(old_instance, field_name)
+            if old_value != new_value:
+                changes[field_name] = {'old': old_value, 'new': new_value}
+
+    return changes
+
+
+def get_instance_snapshot(instance):
+    """
+    Capture un snapshot complet d'une instance (pour DELETE).
+    """
+    snapshot = {}
+    ignored_fields = {'id', 'pk'}
+
+    for field in instance._meta.get_fields():
+        if hasattr(field, 'column') and field.name not in ignored_fields:
+            value = get_model_field_value(instance, field.name)
+            if value is not None:
+                snapshot[field.name] = {'old': value}
+
+    return snapshot

django_app_logs-2.2.1/django_app_logs/signals.py

@@ -0,0 +1,175 @@
+import logging
+from django.db.models.signals import post_save, pre_save, pre_delete, post_delete
+from django.dispatch import receiver
+from django.contrib.contenttypes.models import ContentType
+from django.db import connection
+from django.apps import apps
+
+from .models import ActionLog, ActionType
+from .registry import ActionLogRegistry
+from .middleware import RequestContextMiddleware
+from .serializers import compute_changes, get_instance_snapshot
+
+logger = logging.getLogger('history')
+
+# Cache pour stocker l'état pré-modification
+_pre_save_states = {}
+_pre_delete_states = {}
+
+
+def get_context():
+    """Récupère le contexte de la requête courante."""
+    return {
+        'user': RequestContextMiddleware.get_current_user(),
+        'ip_address': RequestContextMiddleware.get_ip_address(),
+        'user_agent': RequestContextMiddleware.get_user_agent(),
+    }
+
+def _skip_signal():
+    # App pas complètement prête (startup, migrate, shell, etc.)
+    if not apps.ready:
+        return True
+
+    # Migration / transaction en cours
+    if connection.in_atomic_block:
+        return True
+
+    # Table pas encore créée
+    return "django_app_logs_actionlog" not in connection.introspection.table_names()
+
+
+@receiver(pre_save)
+def on_pre_save(sender, instance, raw, using, update_fields, **kwargs):
+    """
+    Signal pre_save: capture l'état avant modification pour UPDATE.
+    """
+    if raw:
+        return
+
+    if ActionLogRegistry.is_excluded(sender):
+        return
+
+    if sender._meta.proxy or sender._meta.abstract:
+        return
+
+    # Seulement pour les updates (instance avec pk existant en base)
+    if instance.pk:
+        try:
+            cache_key = (sender, instance.pk)
+            old_instance = sender.objects.get(pk=instance.pk)
+            _pre_save_states[cache_key] = old_instance
+        except sender.DoesNotExist:
+            pass
+
+
+@receiver(post_save)
+def on_post_save(sender, instance, created, raw, using, update_fields, **kwargs):
+    """
+    Signal post_save: capture CREATE et UPDATE.
+    """
+    # Ignorer les fixtures (raw=True)
+    if raw or _skip_signal():
+        return
+
+    # Vérifier si le modèle est exclu
+    if ActionLogRegistry.is_excluded(sender):
+        return
+
+    # Ignorer les modèles sans table (proxy, abstract)
+    if sender._meta.proxy or sender._meta.abstract:
+        return
+
+    try:
+        content_type = ContentType.objects.get_for_model(sender)
+        context = get_context()
+
+        if created:
+            # CREATE
+            action = ActionType.CREATE
+            changes = compute_changes(None, instance)
+        else:
+            # UPDATE
+            action = ActionType.UPDATE
+
+            # Récupérer l'ancien état depuis le cache
+            cache_key = (sender, instance.pk)
+            old_instance = _pre_save_states.pop(cache_key, None)
+
+            changes = compute_changes(old_instance, instance)
+
+            # Si aucun changement significatif, ne pas logger
+            if not changes:
+                return
+
+        ActionLog.objects.create(
+            content_type=content_type,
+            object_id=instance.pk,
+            object_repr=str(instance)[:255],
+            action=action,
+            user=context['user'],
+            ip_address=context['ip_address'],
+            user_agent=context['user_agent'] or '',
+            changes=changes,
+        )
+
+    except Exception as e:
+        # En production, logger l'erreur sans faire échouer la transaction
+        logger.exception(f"Erreur lors du tracking de {sender}: {e}")
+
+
+@receiver(pre_delete)
+def on_pre_delete(sender, instance, using, **kwargs):
+    """
+    Signal pre_delete: capture l'état avant suppression.
+    """
+    if ActionLogRegistry.is_excluded(sender):
+        return
+
+    if sender._meta.proxy or sender._meta.abstract:
+        return
+
+    cache_key = (sender, instance.pk)
+    _pre_delete_states[cache_key] = {
+        'snapshot': get_instance_snapshot(instance),
+        'repr': str(instance)[:255],
+    }
+
+
+@receiver(post_delete)
+def on_post_delete(sender, instance, using, **kwargs):
+    """
+    Signal post_delete: enregistre la suppression.
+    """
+    if ActionLogRegistry.is_excluded(sender):
+        return
+
+    if sender._meta.proxy or sender._meta.abstract:
+        return
+
+    try:
+        content_type = ContentType.objects.get_for_model(sender)
+        context = get_context()
+
+        cache_key = (sender, instance.pk)
+        pre_state = _pre_delete_states.pop(cache_key, None)
+
+        if pre_state:
+            changes = pre_state['snapshot']
+            object_repr = pre_state['repr']
+        else:
+            changes = get_instance_snapshot(instance)
+            object_repr = str(instance)[:255]
+
+        ActionLog.objects.create(
+            content_type=content_type,
+            object_id=instance.pk,
+            object_repr=object_repr,
+            action=ActionType.DELETE,
+            user=context['user'],
+            ip_address=context['ip_address'],
+            user_agent=context['user_agent'] or '',
+            changes=changes,
+        )
+
+    except Exception as e:
+        logger.exception(f"Erreur lors du tracking suppression de {sender}: {e}")

django_app_logs-2.2.1/django_app_logs/utils.py

@@ -0,0 +1,140 @@
+from django.contrib.contenttypes.models import ContentType
+
+from .models import ActionLog, ActionType
+from .middleware import RequestContextMiddleware
+from .serializers import compute_changes, get_instance_snapshot
+
+
+def bulk_create_with_history(model_class, objects, **kwargs):
+    """
+    Wrapper pour bulk_create avec tracking.
+
+    Usage:
+        from history.utils import bulk_create_with_history
+        created = bulk_create_with_history(MyModel, [obj1, obj2, obj3])
+    """
+    created = model_class.objects.bulk_create(objects, **kwargs)
+
+    content_type = ContentType.objects.get_for_model(model_class)
+    context = {
+        'user': RequestContextMiddleware.get_current_user(),
+        'ip_address': RequestContextMiddleware.get_ip_address(),
+        'user_agent': RequestContextMiddleware.get_user_agent() or '',
+    }
+
+    logs = []
+    for obj in created:
+        changes = compute_changes(None, obj)
+        logs.append(ActionLog(
+            content_type=content_type,
+            object_id=obj.pk,
+            object_repr=str(obj)[:255],
+            action=ActionType.CREATE,
+            changes=changes,
+            **context
+        ))
+
+    ActionLog.objects.bulk_create(logs)
+    return created
+
+
+def queryset_delete_with_history(queryset):
+    """
+    Wrapper pour QuerySet.delete() avec tracking.
+
+    Usage:
+        from history.utils import queryset_delete_with_history
+        deleted_count = queryset_delete_with_history(MyModel.objects.filter(active=False))
+    """
+    model_class = queryset.model
+    content_type = ContentType.objects.get_for_model(model_class)
+    context = {
+        'user': RequestContextMiddleware.get_current_user(),
+        'ip_address': RequestContextMiddleware.get_ip_address(),
+        'user_agent': RequestContextMiddleware.get_user_agent() or '',
+    }
+
+    logs = []
+    for obj in queryset:
+        snapshot = get_instance_snapshot(obj)
+        logs.append(ActionLog(
+            content_type=content_type,
+            object_id=obj.pk,
+            object_repr=str(obj)[:255],
+            action=ActionType.DELETE,
+            changes=snapshot,
+            **context
+        ))
+
+    ActionLog.objects.bulk_create(logs)
+    return queryset.delete()
+
+
+def get_object_history(obj):
+    """
+    Récupère l'historique complet d'un objet.
+
+    Usage:
+        from history.utils import get_object_history
+        history = get_object_history(my_intermed)
+    """
+    content_type = ContentType.objects.get_for_model(obj)
+    return ActionLog.objects.filter(
+        content_type=content_type,
+        object_id=obj.pk
+    ).order_by('-timestamp')
+
+
+def get_user_actions(user, limit=50):
+    """
+    Récupère les dernières actions d'un utilisateur.
+
+    Usage:
+        from history.utils import get_user_actions
+        actions = get_user_actions(request.user)
+    """
+    return ActionLog.objects.filter(user=user).order_by('-timestamp')[:limit]
+
+
+def get_object_history_url(obj):
+    """
+    Retourne l'URL de la page d'historique d'un objet.
+
+    Usage:
+        from history.utils import get_object_history_url
+        url = get_object_history_url(my_intermed)
+        # -> /admin/history/actionlog/object-history/15/42/
+    """
+    from django.urls import reverse
+    content_type = ContentType.objects.get_for_model(obj)
+    return reverse(
+        'admin:django_app_logs_object_history',
+        args=[content_type.pk, obj.pk]
+    )
+
+
+def get_history_link_html(obj):
+    """
+    Retourne un lien HTML vers l'historique d'un objet.
+    Utile pour l'intégration dans d'autres ModelAdmin.
+
+    Usage dans un ModelAdmin:
+        from history.utils import get_history_link_html
+
+        def history_link(self, obj):
+            return get_history_link_html(obj)
+        history_link.short_description = "Historique"
+    """
+    from django.utils.html import format_html
+    url = get_object_history_url(obj)
+    count = ActionLog.objects.filter(
+        content_type=ContentType.objects.get_for_model(obj),
+        object_id=obj.pk
+    ).count()
+    if count > 0:
+        return format_html(
+            '<a href="{}" title="Voir l\'historique">'
+            '<i class="fas fa-history"></i> {} action(s)</a>',
+            url, count
+        )
+    return format_html('<span class="text-muted">Aucun historique</span>')

django_app_logs-2.2.1/django_app_logs.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: django-app-logs
+Version: 2.2.1
+Summary: Logging django's actions
+Author-email: Cissé Anzoumana <anzcisse1@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mosco23/django-app-logs
+Project-URL: Documentation, https://github.com/mosco23/django-app-logs#readme
+Project-URL: Bug Tracker, https://github.com/mosco23/django-app-logs/issues
+Keywords: django,logging,logger,access,django access log
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Django :: 4.0
+Classifier: Framework :: Django :: 4.1
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+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: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: Django>=3.2
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-django>=4.5.0; extra == "dev"
+
+# Django Access Log
+
+
+## Add packge to INSTALLED_APPS
+
+```python
+
+INSTALLED_APPS = [
+    ...
+    'django_app_logs',
+]
+
+```
+
+## Make migrations
+
+```python
+
+python manage.py migrate
+
+```

django_app_logs-2.2.1/django_app_logs.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+django_app_logs/__init__.py
+django_app_logs/admin.py
+django_app_logs/apps.py
+django_app_logs/middleware.py
+django_app_logs/models.py
+django_app_logs/registry.py
+django_app_logs/serializers.py
+django_app_logs/signals.py
+django_app_logs/utils.py
+django_app_logs.egg-info/PKG-INFO
+django_app_logs.egg-info/SOURCES.txt
+django_app_logs.egg-info/dependency_links.txt
+django_app_logs.egg-info/requires.txt
+django_app_logs.egg-info/top_level.txt
+django_app_logs/migrations/0001_initial.py
+django_app_logs/migrations/__init__.py

django_app_logs-2.2.1/django_app_logs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_app_logs-2.2.1/django_app_logs.egg-info/requires.txt

@@ -0,0 +1,7 @@
+Django>=3.2
+
+[dev]
+black>=23.0.0
+flake8>=6.0.0
+pytest>=7.0.0
+pytest-django>=4.5.0

django_app_logs-2.2.1/django_app_logs.egg-info/top_level.txt

@@ -0,0 +1 @@
+django_app_logs

django_app_logs-2.2.1/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-app-logs"
+version = "2.2.1"
+description = "Logging django's actions"
+authors = [{name = "Cissé Anzoumana", email = "anzcisse1@gmail.com"}]
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+keywords = ["django", "logging", "logger", "access", "django access log"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: Django",
+    "Framework :: Django :: 3.2",
+    "Framework :: Django :: 4.0",
+    "Framework :: Django :: 4.1",
+    "Framework :: Django :: 4.2",
+    "Framework :: Django :: 5.0",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+dependencies = [
+    "Django>=3.2"
+]
+
+[project.optional-dependencies]
+dev = [
+    "black>=23.0.0",
+    "flake8>=6.0.0",
+    "pytest>=7.0.0",
+    "pytest-django>=4.5.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/mosco23/django-app-logs"
+Documentation = "https://github.com/mosco23/django-app-logs#readme"
+"Bug Tracker" = "https://github.com/mosco23/django-app-logs/issues"
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["django_app_logs", "django_app_logs.*"]

django_app_logs-2.2.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+