Laclic
/
Souke

/**
 Copyright distrib (2018)

 contact@opendistrib.net

 Ce logiciel est un programme informatique servant à aider les producteurs
 à distribuer leur production en circuits courts.

 Ce logiciel est régi par la licence CeCILL soumise au droit français et
 respectant les principes de diffusion des logiciels libres. Vous pouvez
 utiliser, modifier et/ou redistribuer ce programme sous les conditions
 de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA
 sur le site "http://www.cecill.info".

 En contrepartie de l'accessibilité au code source et des droits de copie,
 de modification et de redistribution accordés par cette licence, il n'est
 offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
 seule une responsabilité restreinte pèse sur l'auteur du programme,  le
 titulaire des droits patrimoniaux et les concédants successifs.

 A cet égard  l'attention de l'utilisateur est attirée sur les risques
 associés au chargement,  à l'utilisation,  à la modification et/ou au
 développement et à la reproduction du logiciel par l'utilisateur étant
 donné sa spécificité de logiciel libre, qui peut le rendre complexe à
 manipuler et qui le réserve donc à des développeurs et des professionnels
 avertis possédant  des  connaissances  informatiques approfondies.  Les
 utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
 logiciel à leurs besoins dans des conditions permettant d'assurer la
 sécurité de leurs systèmes et ou de leurs données et, plus généralement,
 à l'utiliser et l'exploiter dans les mêmes conditions de sécurité.

 Le fait que vous puissiez accéder à cet en-tête signifie que vous avez
 pris connaissance de la licence CeCILL, et que vous en avez accepté les
 termes.
 */

var app = new Vue({
    el: '#app-distribution-index',

    data() {
        return Object.assign(
            {
                UrlManager: UrlManager,
                baseUrl: $('meta[name=baseurl]').attr('content'),
                date: null,
                dateFormat: null,
                loading: true,
                distribution: {
                    active: false,
                },
                producer: null,
                oneDistributionWeekActive: false,
                products: [],
                countActiveProducts: 0,
                pointsSale: [],
                meansPayment: [],
                idActivePointSale: 0,
                pointSaleActive: null,
                idDefaultPointSale: 0,
                countActivePointsSale: 0,
                countOrdersByPointSale: [],
                orders: [],
                ordersUpdate: [],
                countOrders: 0,
                users: [],
                deliveryNotes: [],
                showModalProducts: false,
                showModalPointsSale: false,
                showModalFormOrderCreate: false,
                orderCreate: null,
                showModalFormOrderUpdate: false,
                idOrderUpdate: 0,
                showViewProduct: false,
                idOrderView: 0,
                showModalPayment: false,
                idOrderPayment: 0,
                showLoading: false,
                tillerIsSynchro: false,
                checkboxSelectAllOrders: false,
                messageGenerateDeliveryNoteDisplayed: false,
                missingSubscriptions: false,
                loadingUpdateProductOrder: false,
                units: [],
                calendar: {
                    mode: 'single',
                    attrs: [],
                    themeStyles: {
                        wrapper: {
                            background: '#F7F7F7',
                            color: '#333',
                            border: 'solid 1px #e0e0e0'
                        },
                        header: {
                            padding: '10px 10px',
                        },
                        headerHorizontalDivider: {
                            borderTop: 'solid rgba(255, 255, 255, 0.2) 1px',
                            width: '80%',
                        },
                        weekdays: {
                            color: '#e0e0e0',
                            fontWeight: '600',
                            padding: '10px 10px',
                            fontSize: '2rem'
                        },
                        weeks: {
                            padding: '0 15px 15px 15px',
                        },
                        dayContent: function (object) {
                            var style = {
                                fontSize: '2rem',
                                padding: '16px',
                            };

                            if (object.isHovered || object.isFocus) {
                                style.backgroundColor = '#F39C12';
                            }

                            return style;
                        },
                    },
                    formats: {
                        dayPopover: 'DD/MM/YYYY'
                    }
                },
            }
            , window.vueValues);
    },

    mounted: function () {
        if ($('#distribution-date').size()) {
            this.date = new Date($('#distribution-date').html());
            this.dateFormat = ('0' + this.date.getDate()).slice(-2) + '/'
                + ('0' + (this.date.getMonth() + 1)).slice(-2) + '/'
                + this.date.getFullYear();
        }
        this.init();
        this.loading = false;
    },

    methods: {
        getDate: function () {
            return this.formatDate(this.date);
        },
        formatDate: function (date) {
            if (date) {
                return date.getFullYear() + '-'
                    + ('0' + (date.getMonth() + 1)).slice(-2) + '-'
                    + ('0' + date.getDate()).slice(-2);
            }
            return false;
        },
        init: function (idActivePointSale) {
            var app = this;
            this.showLoading = true;

            axios.get("ajax-infos", {params: {date: this.getDate()}})
                .then(function (response) {
                    app.calendar.attrs = [];
                    app.units = response.data.units;
                    app.distribution = response.data.distribution;
                    app.producer = response.data.producer;
                    app.products = response.data.products;
                    app.initCountActiveProducts();
                    app.meansPayment = response.data.means_payment;
                    app.oneDistributionWeekActive = response.data.one_distribution_week_active;
                    app.missingSubscriptions = response.data.missing_subscriptions;
                    app.countOrders = 0;
                    if (response.data.orders) {
                        app.orders = JSON.parse(JSON.stringify(response.data.orders));
                        app.ordersUpdate = JSON.parse(JSON.stringify(response.data.orders));

                        for (i = 0; i < app.orders.length; i++) {
                            if (!app.orders[i].date_delete) {
                                app.countOrders++;
                            }
                        }
                    } else {
                        app.orders = [];
                    }

                    if (response.data.order_create) {
                        app.orderCreate = response.data.order_create;
                        app.idDefaultPointSale = app.orderCreate.id_point_sale;
                    }

                    if (response.data.points_sale) {
                        app.pointsSale = response.data.points_sale;
                        app.initPointsSale(idActivePointSale);
                    } else {
                        app.pointsSale = [];
                    }

                    if (response.data.users) {
                        app.users = response.data.users;
                    }

                    if (response.data.delivery_notes) {
                        app.deliveryNotes = response.data.delivery_notes;
                    }

                    app.tillerIsSynchro = response.data.tiller_is_synchro;

                    app.calendar.attrs = [];
                    var distributions = response.data.distributions;
                    var dayCurrentIsDistributionActive = false;
                    var dateFormatCompare = false;
                    if (app.date) {
                        dateFormatCompare = app.date.getFullYear() + '-'
                            + ('0' + (app.date.getMonth() + 1)).slice(-2) + '-'
                            + ('0' + app.date.getDate()).slice(-2);
                    }

                    if (distributions.length) {
                        var fillMode = 'solid';
                        var dayToday = app.formatDate(new Date());
                        for (var i = 0; i < distributions.length; i++) {
                            if(distributions[i].date < dayToday) {
                                fillMode = 'outline';
                            }
                            else {
                                fillMode = 'solid';
                            }

                            app.calendar.attrs.push({
                                key: distributions[i].date,
                                dates: distributions[i].date,
                                highlight: {
                                    color: 'green',
                                    fillMode: fillMode
                                }
                            });

                            if (distributions[i].date == dateFormatCompare) {
                                dayCurrentIsDistributionActive = true;
                            }
                        }
                    }

                    app.showLoading = false;
                    app.checkboxSelectAllOrders = false;

                    let searchParams = new URLSearchParams(window.location.search);
                    if (searchParams.has('message_generate_bl') && !app.messageGenerateDeliveryNoteDisplayed) {
                        appAlerts.alert('info', 'Pour générer un bon de livraison, sélectionnez tout d\'abord un jour et un lieu de distribution.', 6000);
                        app.messageGenerateDeliveryNoteDisplayed = true;
                    }

                    if (app.idOrderUpdate) {
                        app.updateOrderFromUrl();
                    }

                    setTimeout("opendistrib_popover(); opendistrib_dropdown_tooltip();", 500);

                    var highlightStyle = {
                        color: 'orange',
                        fillMode: 'light'
                    }
                    if (dayCurrentIsDistributionActive) {
                        highlightStyle = {
                            color: 'orange',
                            fillMode: 'solid'
                        }
                    }
                    app.calendar.attrs.push({
                        key: 'current',
                        highlight: highlightStyle,
                        dates: app.date
                    });
                });
        },
        initCountActiveProducts: function () {
            this.countActiveProducts = 0;
            for (var i = 0; i < this.products.length; i++) {
                if (this.products[i].productDistribution && this.products[i].productDistribution[0].active == 1) {
                    this.countActiveProducts++;
                }
            }
        },
        initPointsSale: function (idActivePointSale) {
            this.countActivePointsSale = 0;
            this.setIdActivePointSale(0);
            for (var i = 0; i < this.pointsSale.length; i++) {
                if (this.pointsSale[i].pointSaleDistribution[0].delivery == 1) {
                    this.countActivePointsSale++;
                    this.setIdActivePointSale(this.pointsSale[i].id);
                }
            }
            if (this.countActivePointsSale > 1) {
                this.setIdActivePointSale(0);
            }
            if (idActivePointSale) {
                this.setIdActivePointSale(idActivePointSale);
            }

            this.countOrdersByPointSale = [];
            for (var i = 0; i < this.pointsSale.length; i++) {
                this.countOrdersByPointSale[this.pointsSale[i].id] = 0;
            }
            for (var i = 0; i < this.orders.length; i++) {
                this.countOrdersByPointSale[this.orders[i].id_point_sale]++;
            }
        },
        dayClicked: function (day) {
            this.date = day.date;
            this.dateFormat = ('0' + this.date.getDate()).slice(-2) + '/'
                + ('0' + (this.date.getMonth() + 1)).slice(-2) + '/'
                + this.date.getFullYear();
            this.init();
        },
        productQuantityMaxChange: function (event) {
            var quantityMax = event.currentTarget.value;
            axios.get("ajax-process-product-quantity-max", {
                params: {
                    idDistribution: this.distribution.id,
                    idProduct: event.currentTarget.getAttribute('data-id-product'),
                    quantityMax: (!quantityMax || quantityMax.length === 0) ? -1 : quantityMax
                }
            })
                .then(function (response) {

                });
        },
        productActiveClick: function (event) {
            var idProduct = event.currentTarget.getAttribute('data-id-product');
            var activeProduct = event.currentTarget.getAttribute('data-active-product');
            axios.get("ajax-process-active-product", {
                params: {
                    idDistribution: this.distribution.id,
                    idProduct: idProduct,
                    active: activeProduct
                }
            })
                .then(function (response) {

                });

            for (i = 0; i < this.products.length; i++) {
                if (this.products[i].productDistribution && this.products[i].id == idProduct) {
                    this.products[i].productDistribution[0].active = activeProduct;
                }
            }
            this.initCountActiveProducts();
        },
        isOneProductMaximumQuantityExceeded: function () {
            for (var i = 0; i < this.products.length; i++) {
                if (this.isProductMaximumQuantityExceeded(this.products[i])) {
                    return true;
                }
            }

            return false;
        },
        isProductMaximumQuantityExceeded: function (product) {
            return
                this.getProductDistribution(product)
                && this.getProductDistribution(product).quantity_max
                && product.quantity_ordered
                && product.quantity_ordered > this.getProductDistribution(product).quantity_max;
        },
        pointSaleActiveClick: function (event) {
            var idPointSale = event.currentTarget.getAttribute('data-id-point-sale');
            var deliveryPointSale = event.currentTarget.getAttribute('data-delivery-point-sale');
            axios.get("ajax-process-active-point-sale", {
                params: {
                    idDistribution: this.distribution.id,
                    idPointSale: idPointSale,
                    delivery: deliveryPointSale
                }
            })
                .then(function (response) {

                });

            for (i = 0; i < this.pointsSale.length; i++) {
                if (this.pointsSale[i].id == idPointSale) {
                    this.pointsSale[i].pointSaleDistribution[0].delivery = deliveryPointSale;
                }
            }

            this.initPointsSale();
        },
        activeDistribution: function (event) {
            var app = this;
            var active = parseInt(event.currentTarget.getAttribute('data-active'));

            axios.get("ajax-process-active-distribution", {
                params: {
                    idDistribution: this.distribution.id,
                    active: active
                }
            })
                .then(function (response) {
                    app.init();
                    app.alertsActiveDistribution(active, 'Distribution');
                });
        },
        activeWeekDistribution: function (event) {
            var app = this;
            var active = parseInt(event.currentTarget.getAttribute('data-active'));

            axios.get("ajax-process-active-week-distribution", {
                params: {
                    date: this.date.getFullYear() + '-'
                        + ('0' + (this.date.getMonth() + 1)).slice(-2) + '-'
                        + ('0' + this.date.getDate()).slice(-2),
                    active: active
                }
            })
                .then(function (response) {
                    app.init();
                    app.alertsActiveDistribution(active, 'Semaine de distribution');
                });
        },
        alertsActiveDistribution: function (active, label) {
            if (!active) {
                appAlerts.alert(
                    'success',
                    label + ' désactivée.',
                );
                appAlerts.alert(
                    'info',
                    'Pensez à bien recréditer les clients qui auraient passé commande en utilisant leur crédit.',
                    6000
                );
            } else {
                appAlerts.alert(
                    'success',
                    label + ' activée.',
                );
            }
        },
        pointSaleClick: function (event) {
            this.setIdActivePointSale(event.currentTarget.getAttribute('data-id-point-sale'));
        },
        setIdActivePointSale: function (id) {
            this.idActivePointSale = id;

            for(key in this.pointsSale) {
                if(this.pointsSale[key].id == id) {
                    this.pointSaleActive = this.pointsSale[key];
                }
            }

            if (!id) {
                this.orderCreate.id_point_sale = this.idDefaultPointSale;
            } else {
                this.orderCreate.id_point_sale = id;
            }
            setTimeout("opendistrib_popover(); opendistrib_dropdown_tooltip();", 500);
        },
        orderCreatedUpdated: function () {
            this.showModalFormOrderCreate = false;
            this.showModalFormOrderUpdate = false;
            this.init(this.idActivePointSale);
        },
        deleteOrderClick: function (event) {
            var app = this;
            var idOrder = event.currentTarget.getAttribute('data-id-order');
            axios.get(UrlManager.getBaseUrlAbsolute() + "order/ajax-delete", {
                params: {
                    idOrder: idOrder
                }
            })
                .then(function (response) {
                    app.init(app.idActivePointSale);
                });
        },
        updateOrderFromUrl: function () {
            this.initModalFormOrder();
            this.updateProductOrderPrices(false);
        },
        updateOrderClick: function (event) {
            var idOrder = event.currentTarget.getAttribute('data-id-order');
            this.idOrderUpdate = idOrder;
            this.showModalFormOrderUpdate = true;
            this.initModalFormOrder();
            this.updateProductOrderPrices(false);
        },
        openModalFormOrderCreate: function () {
            this.showModalFormOrderCreate = true;
            this.initModalFormOrder();
            this.updateProductOrderPrices(false);
        },
        initModalFormOrder: function () {
            var app = this;
            setTimeout(function () {
                $('.modal-body').css('height', $(window).height());
                $('.modal-body').css('maxHeight', 'unset');

                $('.select2-order-form').select2({
                    width: 'resolve'
                });
                $('.select2-order-form').on('select2:select', function (e) {
                    var idUser = e.params.data.id;
                    if (app.showModalFormOrderCreate) {
                        Vue.set(app.orderCreate, 'id_user', idUser);
                    }
                    if (app.showModalFormOrderUpdate) {
                        Vue.set(app.ordersUpdate[app.getOrderUpdateKey()], 'id_user', idUser);
                    }
                });

                // Passage à la ligne du dessous quand on appuie sur "Entrée"
                $('.modal-form-order .input-quantity').keypress(function (e) {
                    if (e.which == 13) {
                        $(this).parent().parent().parent()
                            .next().find('.input-quantity').focus();
                    }
                });
            }, 500);
        },
        getOrderUpdateKey: function () {
            if (app.showModalFormOrderUpdate && app.idOrderUpdate) {
                for (keyOrderUpdate in app.ordersUpdate) {
                    if (app.ordersUpdate[keyOrderUpdate].id == app.idOrderUpdate) {
                        return keyOrderUpdate;
                    }
                }
            }
        },
        orderPaymentModalClick: function (event) {
            var idOrder = event.currentTarget.getAttribute('data-id-order');
            this.idOrderPayment = idOrder;
            this.showModalPayment = true;
        },
        getTypePayment: function(order) {
            if(order.amount_paid < order.amount) {
                return 'payment';
            }
            else {
                return 'refund';
            }
        },
        isTypePayment: function(order) {
            return this.getTypePayment(order) == 'payment';
        },
        getLabelPaymentRefund: function(order, labelPay, labelRefund, labelMeanPayment) {
            var str = '';

            if(this.isTypePayment(order)) {
                str += labelPay;
            }
            else {
                str += labelRefund;
            }

            str += ' '+labelMeanPayment;

            return str;
        },
        orderPaymentClick: function (event) {
            var app = this;
            var idOrder = event.currentTarget.getAttribute('data-id-order');
            if (!idOrder) {
                idOrder = this.idOrderPayment;
            }
            axios.get(UrlManager.getBaseUrlAbsolute() + "order/ajax-payment", {
                params: {
                    idOrder: idOrder,
                    type: event.currentTarget.getAttribute('data-type'),
                    meanPayment: event.currentTarget.getAttribute('data-mean-payment')
                    //amount: event.currentTarget.getAttribute('data-amount')
                }
            })
                .then(function (response) {
                    app.init(app.idActivePointSale);
                });
        },
        orderViewClick: function (event) {
            var currentIdOrderView = event.currentTarget.getAttribute('data-id-order');
            if (this.idOrderView == currentIdOrderView) {
                this.showViewProduct = !this.showViewProduct;
            } else {
                this.showViewProduct = true;
                this.idOrderView = currentIdOrderView;
            }

        },
        closeModalProducts: function () {
            this.showModalProducts = false;
            this.init(this.idActivePointSale);
        },
        closeModalOrderForm: function(create) {
            if(create) {
                this.showModalFormOrderCreate = false
            }
            else {
                this.showModalFormOrderUpdate = false
            }

            this.init(this.idActivePointSale);
        },
        cloneOrder: function (order) {
            var clone = Object.assign({}, order);

            clone.productOrder = {};
            for (var key in order.productOrder) {
                clone.productOrder[key] = order.productOrder[key];
            }

            return clone;
        },
        addSubscriptions: function () {
            var app = this;
            axios.get(UrlManager.getBaseUrlAbsolute() + "distribution/ajax-process-add-subscriptions", {
                params: {
                    date: this.getDate()
                }
            })
                .then(function (response) {
                    app.init(app.idActivePointSale);
                    appAlerts.alertResponse(response);
                });
        },
        synchroTiller: function () {
            var app = this;
            this.showLoading = true;
            axios.get(UrlManager.getBaseUrlAbsolute() + "distribution/ajax-process-synchro-tiller", {
                params: {
                    date: this.getDate()
                }
            })
                .then(function (response) {
                    app.init(app.idActivePointSale);
                });
        },
        totalActivePointSale: function () {
            var total = 0;
            for (var i = 0; i < this.orders.length; i++) {
                if (this.orders[i].id_point_sale == this.idActivePointSale) {
                    total += parseFloat(this.orders[i].amount);
                }
            }
            return total.toFixed(2);
        },
        weightActivePointSale: function () {
            var weight = 0;
            for (var i = 0; i < this.orders.length; i++) {
                if (this.orders[i].id_point_sale == this.idActivePointSale) {
                    weight += parseFloat(this.orders[i].weight);
                }
            }
            return weight.toFixed(2);
        },
        changeSynchroTiller: function (event) {
            var app = this;
            var idOrder = event.currentTarget.getAttribute('data-id-order');
            axios.get(UrlManager.getBaseUrlAbsolute() + "order/ajax-change-synchro-tiller", {
                params: {
                    idOrder: idOrder,
                    boolSynchroTiller: event.currentTarget.checked ? 1 : 0
                }
            })
                .then(function (response) {
                    app.init();
                });
        },
        selectAllOrdersEvent: function (event) {
            var bool = event.currentTarget.checked;
            this.selectAllOrders(bool);
        },
        selectAllOrders: function (bool) {
            for (var key in this.orders) {
                if (this.orders[key].id_point_sale == this.idActivePointSale) {
                    this.orders[key].selected = bool;
                }
            }
        },
        oneOrderSelected: function () {
            for (var key in this.orders) {
                if (this.orders[key].selected == true) {
                    return true;
                }
            }
            return false;
        },
        generateDeliveryNotePointSale: function () {
            if (!this.oneOrderSelected()) {
                this.selectAllOrders(true);
            }

            if (this.oneOrderSelected()) {
                var app = this;
                var idOrders = {};
                for (var key in this.orders) {
                    if (this.orders[key].selected == true) {
                        idOrders[key] = this.orders[key].id;
                    }
                }
                axios.get(UrlManager.getBaseUrlAbsolute() + "distribution/ajax-generate-delivery-note-point-sale", {
                    params: {
                        idOrders: JSON.stringify(idOrders)
                    }
                })
                    .then(function (response) {
                        appAlerts.alertResponse(response);
                        app.init(app.idActivePointSale);
                    });
            } else {
                appAlerts.alert('danger', 'Veuillez sélectionner au moins une commande pour générer un bon de livraison');
            }
        },
        generateDeliveryNoteEachUser: function () {
            if (!this.oneOrderSelected()) {
                this.selectAllOrders(true);
            }

            if (this.oneOrderSelected()) {
                var app = this;
                var idOrders = {};
                for (var key in this.orders) {
                    if (this.orders[key].selected == true) {
                        idOrders[key] = this.orders[key].id;
                    }
                }
                axios.get(UrlManager.getBaseUrlAbsolute() + "distribution/ajax-generate-delivery-note-each-user", {
                    params: {
                        idOrders: JSON.stringify(idOrders)
                    }
                })
                    .then(function (response) {
                        appAlerts.alertResponse(response);
                        app.init(app.idActivePointSale);
                    });
            } else {
                appAlerts.alert('danger', 'Veuillez sélectionner au moins une commande pour générer un bon de livraison');
            }
        },
        validateDeliveryNotes: function () {
            if (!this.oneOrderSelected()) {
                this.selectAllOrders(true);
            }
            if (this.oneOrderSelected()) {
                var app = this;
                var idOrders = {};
                for (var key in this.orders) {
                    if (this.orders[key].selected == true) {
                        idOrders[key] = this.orders[key].id;
                    }
                }
                axios.get(UrlManager.getBaseUrlAbsolute() + "distribution/ajax-validate-delivery-notes", {
                    params: {
                        idOrders: JSON.stringify(idOrders)
                    }
                })
                    .then(function (response) {
                        appAlerts.alertResponse(response);
                        app.init(app.idActivePointSale);
                    });
            } else {
                appAlerts.alert('danger', 'Veuillez sélectionner au moins une commande pour valider un bon de livraison');
            }
        },
        generateDeliveryNote: function (event) {
            var app = this;
            var idOrder = event.currentTarget.getAttribute('data-id-order');
            axios.get(UrlManager.getBaseUrlAbsolute() + "distribution/ajax-generate-delivery-note", {
                params: {
                    idOrder: idOrder
                }
            })
                .then(function (response) {
                    appAlerts.alertResponse(response);
                    app.init(app.idActivePointSale);
                });
        },
        deliveryNoteExist: function (idPointSale) {
            return typeof this.deliveryNotes[this.idActivePointSale] != 'undefined';
        },
        payOrders: function () {
            var app = this;
            axios.get(UrlManager.getBaseUrlAbsolute() + "cron/pay-orders", {
                params: {
                    date: app.getDate()
                }
            })
                .then(function (response) {
                    appAlerts.alertResponse(response);
                    app.init(app.idActivePointSale);
                });
        },

        updateProductOrderPrices: function (updatePricesOnUpdateOrder) {
            var app = this;
            app.loadingUpdateProductOrder = true;
            var order = null;

            if (app.showModalFormOrderCreate) {
                order = app.orderCreate;
            }

            if (app.showModalFormOrderUpdate && app.idOrderUpdate) {
                for (keyOrderUpdate in app.ordersUpdate) {
                    if (app.ordersUpdate[keyOrderUpdate].id == app.idOrderUpdate) {
                        order = app.ordersUpdate[keyOrderUpdate];
                    }
                }
            }

            if (order) {
                axios.get(UrlManager.getBaseUrlAbsolute() + "distribution/ajax-update-product-order", {
                    params: {
                        idDistribution: app.distribution.id,
                        idUser: order.id_user,
                        idPointSale: order.id_point_sale,
                        idOrder: order.id
                    }
                })
                    .then(function (response) {
                        if (response.data) {
                            for (idProduct in response.data) {

                                if (app.showModalFormOrderCreate) {
                                    Vue.set(app.orderCreate.productOrder[idProduct], 'prices', response.data[idProduct].prices);
                                    Vue.set(app.orderCreate.productOrder[idProduct], 'active', response.data[idProduct].active);
                                    Vue.set(app.orderCreate.productOrder[idProduct], 'price', app.getBestProductPrice(app.orderCreate, idProduct, app.orderCreate.productOrder[idProduct].quantity, false));
                                    Vue.set(app.orderCreate.productOrder[idProduct], 'price_with_tax', app.getBestProductPrice(app.orderCreate, idProduct, app.orderCreate.productOrder[idProduct].quantity, true));
                                }

                                if (app.showModalFormOrderUpdate && app.idOrderUpdate) {
                                    for (keyOrderUpdate in app.ordersUpdate) {
                                        if (order.id == app.idOrderUpdate) {
                                            Vue.set(app.ordersUpdate[keyOrderUpdate].productOrder[idProduct], 'prices', response.data[idProduct].prices);
                                            Vue.set(app.ordersUpdate[keyOrderUpdate].productOrder[idProduct], 'active', response.data[idProduct].active);
                                            Vue.set(app.ordersUpdate[keyOrderUpdate].productOrder[idProduct], 'invoice_price', response.data[idProduct].invoice_price);

                                            if (updatePricesOnUpdateOrder) {
                                                Vue.set(
                                                    app.ordersUpdate[keyOrderUpdate].productOrder[idProduct],
                                                    'price',
                                                    app.getBestProductPrice(app.ordersUpdate[keyOrderUpdate], idProduct, app.ordersUpdate[keyOrderUpdate].productOrder[idProduct].quantity, false));
                                                Vue.set(
                                                    app.ordersUpdate[keyOrderUpdate].productOrder[idProduct],
                                                    'price_with_tax',
                                                    app.getBestProductPrice(app.ordersUpdate[keyOrderUpdate], idProduct, app.ordersUpdate[keyOrderUpdate].productOrder[idProduct].quantity, true));
                                            }
                                        }
                                    }
                                }
                            }

                            if (updatePricesOnUpdateOrder) {
                                appAlerts.alert('info', 'Prix rechargés');
                            }
                        }

                        app.loadingUpdateProductOrder = false;
                    });
            }
        },
        updateInvoicePrices: function () {
            var order = null;

            if (app.showModalFormOrderUpdate && app.idOrderUpdate) {
                for (keyOrderUpdate in app.ordersUpdate) {
                    if (app.ordersUpdate[keyOrderUpdate].id == app.idOrderUpdate) {
                        order = app.ordersUpdate[keyOrderUpdate];
                    }
                }
            }

            if (order) {
                axios.get(UrlManager.getBaseUrlAbsolute() + "distribution/ajax-update-invoice-prices", {
                    params: {
                        idOrder: order.id
                    }
                })
                    .then(function (response) {
                        app.updateProductOrderPrices(false);
                        appAlerts.alert('info', 'Prix facturés réinitialisés.');
                    });
            }
        },
        getBestProductPrice: function (order, idProduct, theQuantity, withTax) {
            var product = this.getProduct(idProduct);
            var thePrice = 9999;
            var pricesArray = order.productOrder[idProduct].prices;

            var unitCoefficient = this.getUnitCoefficient(product.unit);
            if (theQuantity) {
                theQuantity = theQuantity / unitCoefficient;
            }

            if (pricesArray) {
                for (var i = 0; i < pricesArray.length; i++) {
                    var price = pricesArray[i].price;
                    if (withTax) {
                        price = pricesArray[i].price_with_tax
                    }

                    var fromQuantity = pricesArray[i].from_quantity;

                    if (price < thePrice && fromQuantity <= theQuantity) {
                        thePrice = price;
                    }
                }
            } else {
                if (withTax) {
                    thePrice = getPriceWithTax(product.price, product.taxRate.value);
                } else {
                    thePrice = product.price;
                }
            }

            if (thePrice == 9999) {
                return 0;
            } else {
                return thePrice;
            }
        },
        getProduct: function (idProduct) {
            for (var i = 0; i < this.products.length; i++) {
                if (this.products[i].id == idProduct) {
                    return this.products[i];
                }
            }

            return false;
        },
        countDocuments: function(order) {
            var count = 0;

            if(order.id_delivery_note) {
                count ++;
            }

            if(order.id_quotation) {
                count ++;
            }

            if(order.id_invoice) {
                count ++;
            }

            return count;
        },
        getUnitCoefficient: function(unit) {
            return this.units[unit].coefficient;
        },
        getProductDistribution: function(product) {
            if(typeof product.productDistribution !== 'undefined' && product.productDistribution[0]) {
                return product.productDistribution[0];
            }

            return null;
        },
        copyLinkOrder: function($event, urlOrder) {
            $event.preventDefault();
            navigator.clipboard.writeText(urlOrder);
            appAlerts.alert('success', 'Lien vers la page de commande de la distribution copié.');
            return false;
        }
    },
});

Vue.component('order-state-payment', {
    props: ['order', 'producer'],
    template: '#order-state-payment'
});

Vue.component('modal', {
    template: '#modal-template'
});

Vue.component('order-form', {
    props: ['date', 'dateFormat', 'pointsSale', 'idActivePointSale', 'meansPayment', 'users', 'products', 'order', 'orders', 'producer', 'loadingUpdateProductOrder', 'create', 'units'],
    emits: ['updateProductPrice', 'updateInvoicePrices'],
    data: function () {
        return {
            errors: [],
            idPointSale: 0,
            idUser: 0,
            username: '',
            comment: '',
            baseUrl: $('meta[name=baseurl]').attr('content'),
            vatMode: 'all' // 'with_tax'
        };
    },
    template: '#order-form-template',
    watch: {
        'order.id_user': function () {
            this.userChange();
        }
    },
    methods: {
        checkForm: function () {
            this.errors = [];

            var countProducts = 0;
            for (var key in this.order.productOrder) {
                if (this.order.productOrder[key].quantity > 0) {
                    countProducts++;
                }
            }

            if (this.order.id_point_sale
                && (this.order.id_user > 0 || (this.order.username && this.order.username.length))
                && countProducts > 0) {
                return true;
            }

            if (!this.order.id_point_sale) {
                this.errors.push('Veuillez sélectionner un point de vente');
            }

            if ((!this.order.id_user || this.order.id_user == 0) && !this.order.username.length) {
                this.errors.push('Veuillez sélectionner ou saisir un utilisateur');
            }

            if (!countProducts) {
                this.errors.push('Veuillez sélectionner au moins un produit');
            }
        },
        getProductOrderArrayRequest: function () {
            var productOrderArrayRequest = {};
            for (var key in this.order.productOrder) {
                productOrderArrayRequest[key] = {
                    quantity: this.order.productOrder[key].quantity,
                    unit: this.order.productOrder[key].unit,
                    price: this.order.productOrder[key].price,
                    invoice_price: this.order.productOrder[key].invoice_price
                };
            }
            return JSON.stringify(productOrderArrayRequest);
        },
        getPointSale: function(idPointSale) {
            for(key in this.pointsSale) {
                if (this.pointsSale[key].id == idPointSale) {
                    return this.pointsSale[key];
                }
            }

            return false;
        },
        isPointSaleCreditFunctioningOptional: function(idPointSale) {
            var pointSale = this.getPointSale(idPointSale);
            if(pointSale && pointSale.credit_functioning == 'optional') {
                return true;
            }

            return false;
        },
        submitFormCreate: function (event) {
            var app = this;
            if (this.checkForm()) {
                axios.get(UrlManager.getBaseUrlAbsolute() + "order/ajax-create", {
                    params: {
                        date: this.date.getFullYear() + '-'
                            + ('0' + (this.date.getMonth() + 1)).slice(-2) + '-'
                            + ('0' + this.date.getDate()).slice(-2),
                        idPointSale: this.order.id_point_sale,
                        idUser: this.order.id_user,
                        username: this.order.username,
                        meanPayment: this.order.mean_payment,
                        products: app.getProductOrderArrayRequest(),
                        comment: this.order.comment,
                        debitCredit: this.order.debitCredit
                    }
                })
                    .then(function (response) {
                        app.order.id_point_sale = 0;
                        app.order.id_user = 0;
                        app.order.username = '';
                        app.order.comment = '';
                        for (i = 0; i < app.order.productOrder.length; i++) {
                            app.order.productOrder[i] = 0;
                        }

                        app.$emit('ordercreatedupdated');
                    });
            }
        },
        submitFormUpdate: function (event) {
            var app = this;
            if (this.checkForm()) {
                var data = new FormData();
                data.append('date', this.date.getFullYear() + '-'
                    + ('0' + (this.date.getMonth() + 1)).slice(-2) + '-'
                    + ('0' + this.date.getDate()).slice(-2));
                data.append('idOrder', this.order.id);
                data.append('idPointSale', this.order.id_point_sale);
                data.append('meanPayment', this.order.mean_payment);
                data.append('idUser', this.order.id_user);
                data.append('username', '' + this.order.username);
                data.append('products', app.getProductOrderArrayRequest());
                data.append('comment', this.order.comment && this.order.comment.length ? this.order.comment : '');
                data.append('debitCredit', this.order.debitCredit ? this.order.debitCredit : 0);

                axios.post(UrlManager.getBaseUrlAbsolute() + "order/ajax-update", data)
                    .then(function (response) {
                        app.$emit('ordercreatedupdated');
                    });
            }
        },
        productQuantityClick: function (id_product, quantity) {
            if (!this.order.productOrder[id_product].quantity) {
                this.order.productOrder[id_product].quantity = 0;
            }
            if (parseFloat(this.order.productOrder[id_product].quantity) + quantity >= 0) {
                var theQuantity = (parseFloat(this.order.productOrder[id_product].quantity) + parseFloat(quantity)).toFixed(2);
                var theQuantityDecimal = theQuantity % 1;
                if (theQuantityDecimal == 0) {
                    theQuantity = parseInt(theQuantity);
                }

                Vue.set(this.order.productOrder[id_product], 'quantity', theQuantity);
                Vue.set(this.order.productOrder[id_product], 'price', app.getBestProductPrice(this.order, id_product, theQuantity, false));
                Vue.set(this.order.productOrder[id_product], 'price_with_tax', app.getBestProductPrice(this.order, id_product, theQuantity, true));
            }
        },
        getProduct: function (idProduct) {
            for (var i = 0; i < this.products.length; i++) {
                if (this.products[i].id == idProduct) {
                    return this.products[i];
                }
            }

            return false;
        },
        productPriceChange: function (event) {
            var idProduct = event.currentTarget.getAttribute('data-id-product');
            var product = this.getProduct(idProduct);

            if (product) {
                var taxRateValue = parseFloat(product.taxRate.value);
                var withTax = event.currentTarget.getAttribute('data-with-tax');
                var price = 0;
                var priceWithTax = 0;
                var priceValue = parseFloat(event.currentTarget.value.replace(',', '.'));

                if (withTax) {
                    priceWithTax = priceValue.toFixed(2);
                    price = getPrice(priceWithTax, taxRateValue);
                } else {
                    price = priceValue.toFixed(5);
                    priceWithTax = getPriceWithTax(price, taxRateValue);
                }

                if (isNaN(price)) {
                    price = 0;
                }

                if (isNaN(priceWithTax)) {
                    priceWithTax = 0;
                }

                Vue.set(this.order.productOrder, idProduct, {
                    active: this.order.productOrder[idProduct].active,
                    quantity: this.order.productOrder[idProduct].quantity,
                    unit: this.order.productOrder[idProduct].unit,
                    price: price,
                    price_with_tax: priceWithTax
                });
            }
        },
        userChange: function (event) {
            var app = this;
            axios.get(UrlManager.getBaseUrlAbsolute() + "distribution/ajax-point-sale-favorite", {
                params: {
                    idUser: app.order.id_user,
                }
            })
                .then(function (response) {
                    if (app.idActivePointSale == 0) {
                        app.order.id_point_sale = response.data.id_favorite_point_sale;
                    }
                    app.updateProductOrderPrices(true);
                });
        },
        pointSaleChange: function (event) {
            this.updateProductOrderPrices(true);
        },
        updateProductOrderPrices: function (updateProductOrderPrices) {
            this.$emit('updateproductorderprices', updateProductOrderPrices);
        },
        updateInvoicePrices: function () {
            this.$emit('updateinvoiceprices');
        },
        toggleVatMode: function () {
            if (this.vatMode == 'all') {
                this.vatMode = 'with_tax';
            } else {
                this.vatMode = 'all';
            }
        },
        getProductQuantityRemaining: function(product) {
            var quantityRemaining = 0;
            var productQuantityOrder = 0;
            var unit = product.unit;

            for(key in this.orders) {
                productQuantityOrder += this.getProductQuantityProductOrder(this.orders[key], product);
            }
            if(this.create == 1) {
                productQuantityOrder += this.getProductQuantityProductOrder(this.order, product);
            }

            quantityRemaining = this.getProductDistribution(product).quantity_max - productQuantityOrder;
            if(unit != 'piece') {
                quantityRemaining = quantityRemaining.toFixed(2);
            }

            return quantityRemaining;
        },
        getProductQuantityProductOrder: function(order, product) {
            var productOrder = order.productOrder[product.id];
            var unit = productOrder.unit;
            var unitCoefficient = this.getUnitCoefficient(unit);
            return parseFloat(productOrder.quantity / unitCoefficient);
        },
        getUnitCoefficient: function(unit) {
            return this.units[unit].coefficient;
        },
        getProductDistribution: function(product) {
            if(typeof product.productDistribution !== 'undefined' && product.productDistribution[0]) {
                return product.productDistribution[0];
            }
        }
    }
});