pyrofetes-frontend/src/app/pages/stock/stock.ts

import {Component, inject, OnInit, signal, viewChild} from '@angular/core';
import {StockTable} from "../../components/stock-table/stock-table";
import {ModalButton} from "../../components/modal-button/modal-button";
import {CreatePurchaseorderForm} from "../../components/create-purchaseorder-form/create-purchaseorder-form";
import {NzNotificationService} from "ng-zorro-antd/notification";
import {
    CreatePurchaseOrderDto, CreateQuotationDto,
    GetProductDto,
    GetSupplierDto,
    PurchaseordersService,
    QuotationsService,
    SuppliersService
} from "../../services/api";
import {firstValueFrom} from "rxjs";
import {CreateQuotationForm} from "../../components/create-quotation-form/create-quotation-form";
import {AddProductSupplierForm} from "../../components/add-product-supplier-form/add-product-supplier-form";

@Component({
    selector: 'app-stock',
    imports: [
        StockTable,
        ModalButton,
        CreatePurchaseorderForm,
        CreateQuotationForm,
        AddProductSupplierForm,
    ],
    templateUrl: './stock.html',
    styleUrl: './stock.css',
})

export class Stock implements OnInit {
    createPurchaseOrder = viewChild.required<CreatePurchaseorderForm>('purchaseOrderForm');
    createQuotation = viewChild.required<CreateQuotationForm>('quotationForm');
    addProduct = viewChild.required<AddProductSupplierForm>('supplierForm');
    modalButtonPurchaseOrder = viewChild.required<ModalButton>('modalButtonPurchaseOrder');
    modalButtonQuotation = viewChild.required<ModalButton>('modalButtonQuotation');
    modalButtonSupplier = viewChild.required<ModalButton>('modalButtonSupplier');

    private purchaseOrdersService = inject(PurchaseordersService);
    private quotationsService = inject(QuotationsService);
    private suppliersService = inject(SuppliersService);
    private notificationService = inject(NzNotificationService);

    products = signal<GetProductDto[]>([]);
    suppliers = signal<GetSupplierDto[]>([]);
    selectedProducts = signal([]);

    productIds = signal<number[]>([]);

    async ngOnInit() {
        try {
            const suppliers = await firstValueFrom(this.suppliersService.getAllSuppliersEndpoint());
            this.suppliers.set(suppliers);
        } catch {
            this.notificationService.error('Erreur', 'Impossible de charger les fournisseurs');
        }
    }

    onSelectionChange(ids: number[]) {
        this.productIds.set(ids);
        this.selectedProducts.set(this.products().filter(x => ids.includes(x.id)));
    }

    openPurchaseOrderForm() {
        this.createPurchaseOrder().addProductToForm();
    }

    openQuotationForm() {
        this.createQuotation().addProductToForm();
    }

    openSupplierForm() {
        this.addProduct().addProductToForm();
    }

    async addPurchaseOrder() {
        const form = this.createPurchaseOrder().createPurchaseOrderForm;

        if (form.invalid) {
            this.notificationService.error('Erreur', 'Formulaire invalide');
            return;
        }

        const orderLines = this.createPurchaseOrder().lines.value.map((line: { productId: any; quantity: any; }) => ({
            productId: line.productId,
            quantity: line.quantity
        }));

        if (!orderLines.length) {
            this.notificationService.error('Erreur', 'Aucun produit sélectionné');
            return;
        }

        const purchaseOrder: CreatePurchaseOrderDto = {
            purchaseConditions: form.value.purchaseConditions,
            products: orderLines,
            supplierId: form.value.supplierId
        };

        try {
            await firstValueFrom(this.purchaseOrdersService.createPurchaseOrder(purchaseOrder));
            this.notificationService.success('Succès', 'Bon de commande créé');
        } catch {
            this.notificationService.error('Erreur', 'Erreur lors de la création du bon de commande.');
        }
    }

    async addQuotation() {
        const form = this.createQuotation().createQuotationForm;

        if (form.invalid) {
            this.notificationService.error('Erreur', 'Formulaire invalide');
            return;
        }

        const orderLines = this.createQuotation().lines.value.map((line: { productId: any; quantity: any; }) => ({
            productId: line.productId,
            quantity: line.quantity
        }));

        if (!orderLines.length) {
            this.notificationService.error('Erreur', 'Aucun produit sélectionné');
            return;
        }

        const quotation: CreateQuotationDto = {
            message: this.createQuotation().createQuotationForm.value.message,
            conditionsSale: this.createQuotation().createQuotationForm.value.conditionsSale,
            customerId: this.createQuotation().createQuotationForm.value.customerId,
            supplierId: this.createQuotation().createQuotationForm.value.supplierId,
            products: orderLines
        };

        try {
            await firstValueFrom(this.quotationsService.createQuotationEndpoint(quotation));
            this.notificationService.success('Succès', 'Devis créé');
        } catch {
            this.notificationService.error('Erreur', 'Erreur lors de la création du devis.');
        }
    }

    async addProductFromSupplier() {
        const form = this.addProduct().addProductForm;
        let success = 0;

        if (form.invalid) {
            this.notificationService.error('Erreur', 'Formulaire invalide');
            return;
        }

        const supplierId = form.value.supplierId;
        const lines = this.addProduct().lines.value;

        if (!lines.length) {
            this.notificationService.error('Erreur', 'Aucun produit sélectionné');
            return;
        }

        for (const line of lines) {
            try {
                await firstValueFrom(
                    this.suppliersService.addProductToSupplierEndpoint(
                        supplierId,
                        line.productId,
                        {
                            sellingPrice: line.price
                        }
                    )
                );

                success++;
            } catch {
            }
        }
        this.notificationService.success('Succès', `${success} produits ajoutés`);
    }

    async onModalPurchaseOrderOk() {
        await this.addPurchaseOrder();
        this.createPurchaseOrder().createPurchaseOrderForm.reset();
        this.modalButtonPurchaseOrder().isVisible = false;
        this.onModalPurchaseOrderCancel();
    }

    onModalPurchaseOrderCancel() {
        this.modalButtonPurchaseOrder().isVisible = false;
    }

    async onModalQuotationOk() {
        await this.addQuotation();
        this.createQuotation().createQuotationForm.reset();
        this.modalButtonQuotation().isVisible = false;
        this.onModalQuotationCancel();
    }

    onModalQuotationCancel() {
        this.modalButtonQuotation().isVisible = false;
    }

    async onModalSupplierOk() {
        await this.addProductFromSupplier();
        this.addProduct().addProductForm.reset();
        this.modalButtonSupplier().isVisible = false;
        this.onModalSupplierCancel();
    }

    onModalSupplierCancel() {
        this.modalButtonSupplier().isVisible = false;
    }
}