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 {ModalButton} from "../modal-button/modal-button";
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} 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";

@Component({
  selector: 'app-deliverery-note-table',
    imports: [
        ModalButton,
        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);
    deliveryNotes = signal<GetDeliveryNoteDto[]>([]);
    deliveryNotesLoading = signal<boolean>(false);
    modal = viewChild.required<ModalNav>('modalNav');

    async ngOnInit() {
        await this.fetchDeliveryNotes();
    }

    async fetchDeliveryNotes() {
        this.deliveryNotesLoading.set(true)
        try {
            const deliveryNotes = await firstValueFrom(this.deliveryNotesService.getAllDeliveryNoteEndpoint())
            this.deliveryNotes.set(deliveryNotes);
        } catch (e) {
            this.notificationService.error(
                'Erreur',
                'Erreur de communication avec l\'API'
            )
        }
        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 (e) {
            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 (e) {
                this.notificationService.error(
                    'Erreur',
                    'La date à déjà été actualisée'
                )
            }
        } catch (e) {
            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 (e) {
            this.notificationService.error(
                'Erreur',
                'Impossible de générer un PDF'
            );
        }
        this.deliveryNotesLoading.set(false)
    }

    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();
        modal.isVisible = false;
        await this.fetchDeliveryNotes();
    }

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

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

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

            // convertit proprement les dates (string OU Date)
            const toIso = (val: any) => {
                if (!val) return null;

                // si c’est déjà un string ISO "yyyy-MM-dd", on renvoie tel quel
                if (typeof val === 'string' && /^\d{4}-\d{2}-\d{2}/.test(val)) {
                    return val.substring(0, 10);
                }

                // sinon on reconstruit une Date
                const d = new Date(val);
                if (isNaN(d.getTime())) return null;

                return d.toISOString().substring(0, 10); // yyyy-MM-dd
            };

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

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

}