manuels-scolaires/manuels/admin.py

from django.contrib import admin, messages
from django.db.models import Prefetch
from import_export import resources, fields
from import_export.admin import ExportMixin
from import_export.widgets import IntegerWidget, DecimalWidget

from manuels.models import Teacher, Book, Level, Editor, SuppliesRequirement, CommonSupply, ISBNError


class TeacherResource(resources.ModelResource):
    class Meta:
        model = Teacher
        fields = ('first_name', 'last_name', 'email', 'phone_number')


@admin.register(Teacher)
class TeacherAdmin(ExportMixin, admin.ModelAdmin):
    resource_class = TeacherResource
    list_display = ['full_name', 'email', 'phone_number', 'has_confirmed_list']

    def send_link(self, request, queryset):
        for teacher in queryset:
            teacher.send_link(request)
        messages.success(request, f'Le lien a bien été envoyé aux {queryset.count()} coordonateur(s) sélectionné(s).')

    send_link.short_description = 'Envoyer le lien'

    actions = [send_link]


class LevelResource(resources.ModelResource):
    non_acquired_book_count = fields.Field(attribute='non_acquired_book_count', widget=IntegerWidget())
    non_acquired_book_price = fields.Field(attribute='non_acquired_book_price', widget=DecimalWidget())
    non_acquired_consumable_count = fields.Field(attribute='non_acquired_consumable_count', widget=IntegerWidget())
    non_acquired_consumable_price = fields.Field(attribute='non_acquired_consumable_price', widget=DecimalWidget())
    non_acquired_total_price = fields.Field(attribute='non_acquired_total_price', widget=DecimalWidget())

    class Meta:
        model = Level
        fields = (
            'name',
            'non_acquired_book_count',
            'non_acquired_book_price',
            'non_acquired_consumable_count',
            'non_acquired_consumable_price',
            'non_acquired_total_price',
        )
        export_order = (
            'name',
            'non_acquired_book_count',
            'non_acquired_book_price',
            'non_acquired_consumable_count',
            'non_acquired_consumable_price',
            'non_acquired_total_price',
        )


@admin.register(Level)
class LevelAdmin(ExportMixin, admin.ModelAdmin):
    resource_class = LevelResource
    list_display = [
        'name',
        'order',
        'non_acquired_book_count',
        'non_acquired_book_price',
        'non_acquired_consumable_count',
        'non_acquired_consumable_price',
        'non_acquired_total_price',
    ]
    list_editable = ['order']
    list_display_links = ['name']

    def get_queryset(self, request):
        return super(LevelAdmin, self).get_queryset(request).prefetch_related(
            Prefetch("book_set", to_attr="prefetched_books"))

    def non_acquired_book_count(self, obj: Level):
        return obj.non_acquired_book_count

    non_acquired_book_count.short_description = 'Nombre de livres à acheter (hors consommables)'

    def non_acquired_book_price(self, obj: Level):
        return f'{obj.non_acquired_book_price:.2f}€'

    non_acquired_book_price.short_description = 'Coût des livres à acheter (hors consommables)'

    def non_acquired_consumable_count(self, obj: Level):
        return obj.non_acquired_consumable_count

    non_acquired_consumable_count.short_description = 'Nombre de consommables à acheter'

    def non_acquired_consumable_price(self, obj: Level):
        return f'{obj.non_acquired_consumable_price:.2f}€'

    non_acquired_consumable_price.short_description = 'Coût des consommables à acheter'

    def non_acquired_total_price(self, obj: Level):
        return f'{obj.non_acquired_total_price:.2f}€'

    non_acquired_total_price.short_description = 'Coût total à acheter'


class BookResource(resources.ModelResource):
    decitre_url = fields.Field(attribute='decitre_url')

    class Meta:
        model = Book
        fields = ('title', 'authors', 'editor__name', 'publication_year', 'isbn', 'comments', 'other_editor',
                  'price', 'previously_acquired', 'teacher__first_name', 'teacher__last_name', 'level__name', 'field',
                  'consumable', "decitre_url")
        export_order = ('level__name', 'field', 'title', 'authors', 'editor__name', 'publication_year', 'isbn', 'price',
                        'other_editor', 'previously_acquired', 'teacher__first_name', 'teacher__last_name', 'comments',
                        'consumable', "decitre_url")


@admin.register(Book)
class BookAdmin(ExportMixin, admin.ModelAdmin):
    resource_class = BookResource
    list_display = ['level', 'field', 'title', 'authors', 'editor', 'other_editor', 'publication_year', 'isbn',
                    'price', 'previously_acquired', 'teacher', 'done', 'consumable']
    list_editable = ['done']
    list_filter = ['done', 'previously_acquired', 'consumable', 'level', 'editor', 'teacher']
    list_display_links = ['title']
    fieldsets = [
        ('Infos livre', {
            'fields': ('title', 'consumable', 'authors', ('editor', 'other_editor'), 'publication_year',
                       'isbn', 'created_at', 'updated_at', 'comments')
        }),
        ('Élève', {
            'fields': ('price', 'previously_acquired',)
        }),
        ('Coordonnateur', {
            'fields': ('teacher', 'level', 'field')
        }),
        ('Gestion', {
            'fields': ('done',)
        }),
    ]
    readonly_fields = ['created_at', 'updated_at']

    def get_queryset(self, request):
        return super(BookAdmin, self).get_queryset(request).select_related("editor", "level", "teacher")

    def update_with_decitre(self, request, queryset):
        for book in queryset:
            try:
                book.update_from_decitre()
                messages.success(
                    request,
                    f'Mise à jour réussie du livre "{book.title}" ({book.level.name} - {book.field})'
                )
            except ISBNError as e:
                messages.warning(
                    request,
                    f'Erreur lors de la mise à jour du livre "{book.title}" ({book.level.name} - {book.field}) : {e.data.get("error")}'
                )

    update_with_decitre.short_description = 'Mettre à jour avec Decitre'

    def mark_as_done(self, request, queryset):
        queryset.update(done=True)

    mark_as_done.short_description = "Marquer comme traité"
    actions = [update_with_decitre, mark_as_done]


@admin.register(Editor)
class EditorAdmin(admin.ModelAdmin):
    pass


@admin.register(CommonSupply)
class CommonSupplyAdmin(admin.ModelAdmin):
    list_display = ['name', 'order']
    list_display_links = ['name']
    list_editable = ['order']


class SuppliesResource(resources.ModelResource):
    class Meta:
        model = SuppliesRequirement
        fields = ('supplies', 'field', 'level__name', 'teacher__first_name', 'teacher__last_name')
        export_order = ('level__name', 'field', 'supplies', 'teacher__first_name', 'teacher__last_name')


@admin.register(SuppliesRequirement)
class SuppliesRequirementAdmin(ExportMixin, admin.ModelAdmin):
    resource_class = SuppliesResource
    list_display = ['id', 'teacher', 'level', 'field', 'supplies', 'done']
    list_editable = ['done']
    readonly_fields = ['created_at', 'updated_at']
    list_filter = ['done', 'teacher', 'level']

    def get_queryset(self, request):
        return super(SuppliesRequirementAdmin, self).get_queryset(request).select_related("level", "teacher")