pyrofetes-frontend/src/app/components/deliverery-note-table/deliverery-note-table.ts

import {Component, inject, OnInit, signal, viewChild} from '@angular/core';
import {DatePipe} from "@angular/common";
import {ModalNav} from "../modal-nav/modal-nav";
import {NzDividerComponent} from "ng-zorro-antd/divider";
import {NzIconDirective} from "ng-zorro-antd/icon";
import {NzTableComponent} from "ng-zorro-antd/table";
import {DelivereryNoteForm} from "../deliverery-note-form/deliverery-note-form";
import {DeliverynotesService, GetDeliveryNoteDto, UpdateDeliveryNoteDto} from "../../services/api";
import {NzNotificationService} from "ng-zorro-antd/notification";
import {firstValueFrom} from "rxjs";
import {format} from "date-fns";
import {FileService} from "../../services/file.service";
import {AuthService} from "../../services/auth.service";

@Component({
    selector: 'app-deliverery-note-table',
    imports: [
        ModalNav,
        NzDividerComponent,
        NzIconDirective,
        NzTableComponent,
        DelivereryNoteForm,
        DatePipe,
    ],
    templateUrl: './deliverery-note-table.html',
    styleUrl: './deliverery-note-table.css',
})
export class DelivereryNoteTable implements OnInit {
    private deliveryNotesService = inject(DeliverynotesService);
    private notificationService = inject(NzNotificationService);
    private fileService = inject(FileService);
    private authService = inject(AuthService);

    deliveryNotes = signal<GetDeliveryNoteDto[]>([]);
    deliveryNotesLoading = signal<boolean>(false);
    admin = signal<boolean>(false);

    modal = viewChild.required<ModalNav>('modalNav');

    date = new Date().toISOString().split('T')[0]; // yyyy-mm-dd

    async ngOnInit() {
        await this.fetchDeliveryNotes();
        this.admin.set(this.authService.isAdmin());
    }

    async fetchDeliveryNotes() {
        this.deliveryNotesLoading.set(true)
        try {
            const deliveryNotes = await firstValueFrom(this.deliveryNotesService.getAllDeliveryNoteEndpoint());
            this.deliveryNotes.set(deliveryNotes);
        } catch {
            this.notificationService.error('Erreur', 'Erreur lors du chargement des bons de livraison');
        }
        this.deliveryNotesLoading.set(false)
    }

    async delete(deliveryNote: number) {
        this.deliveryNotesLoading.set(true)
        try {
            await firstValueFrom(this.deliveryNotesService.deleteDeliveryNoteEndpoint(deliveryNote));
            this.notificationService.success('Success', 'Suppression effectuée');
        } catch {
            this.notificationService.error('Erreur', 'Impossible de supprimer la ligne');
        }
        this.deliveryNotesLoading.set(false)
        await this.fetchDeliveryNotes();
    }

    async validate(deliveryNote: number) {
        this.deliveryNotesLoading.set(true)
        try {
            const PatchRealDate = {
                realDeliveryDate: format(new Date(), 'yyyy-MM-dd')
            };

            try {
                await firstValueFrom(this.deliveryNotesService.patchRealDeliveryDateEndpoint(deliveryNote, PatchRealDate))
                this.notificationService.success('Success', 'Date actualisée');
            } catch {
                this.notificationService.error('Erreur', 'La date à déjà été actualisée');
            }
        } catch {
            this.notificationService.error('Erreur', 'Erreur d\'actualisation de la date');
        }
        this.deliveryNotesLoading.set(false)
        await this.fetchDeliveryNotes()
    }

    async export(deliveryNoteId: number) {
        this.deliveryNotesLoading.set(true)
        try {
            const pdf = await firstValueFrom(this.deliveryNotesService.getDeliveryNotePdfEndpoint(deliveryNoteId, "response"));
            this.fileService.downloadBlob(pdf)
        } catch {
            this.notificationService.error('Erreur', 'Impossible de générer un PDF');
        }
        this.deliveryNotesLoading.set(false)
    }

    async edit(id: number, updateDelivereryNoteComponent: DelivereryNoteForm) {
        if (updateDelivereryNoteComponent.deliveryNoteForm.invalid) {
            this.notificationService.error('Erreur', 'Formulaire invalide');
            return;
        }

        try {
            const raw = updateDelivereryNoteComponent.deliveryNoteForm.getRawValue();

            const toIso = (val: any) =>
                val ? new Date(val).toISOString().substring(0, 10) : null;

            const deliveryNoteDto: UpdateDeliveryNoteDto = {
                trackingNumber: raw.trackingNumber,
                delivererId: raw.delivererId,
                expeditionDate: toIso(raw.expeditionDate),
                estimateDeliveryDate: toIso(raw.estimatedDate),
                realDeliveryDate: toIso(raw.realDeliveryDate)
            };

            await firstValueFrom(this.deliveryNotesService.updateDeliveryNoteEndpoint(id, deliveryNoteDto));
            this.notificationService.success('Success', 'Bon de livraison modifié');
        } catch {
            this.notificationService.error('Erreur', 'Erreur lors de la modification');
        }
    }

    selectedDeliveryNote: GetDeliveryNoteDto | null = null;

    openEditModal(deliveryNote: GetDeliveryNoteDto) {
        this.selectedDeliveryNote = {...deliveryNote};
        this.modal().showModal();
    }

    async onModalOk(id: number, updateDelivereryNoteComponent: DelivereryNoteForm, modal: ModalNav) {
        if (!this.selectedDeliveryNote) return;

        await this.edit(id, updateDelivereryNoteComponent);
        updateDelivereryNoteComponent.deliveryNoteForm.reset();
        this.onModalCancel(modal);
        await this.fetchDeliveryNotes();
    }

    onModalCancel(modal: ModalNav) {
        modal.isVisible = false;
    }
}