https://mediq.de/-/media/Base-Themes/Commerce-Components-Theme/Scr…count-mediq-repeatorder-orderlines-model.js

1function MediqRepeatOrderOrderLineViewModel(product, parentView) {
2    var self = this;
3
4    const maxValue = 99;
5    const minValue = 1;
6
7    self.materialId = ko.observable(product.variantId);
8    self.title = ko.observable(product.title);
9    self.image = ko.observable(product.imageUrl);
10    self.productUrl = ko.observable(product.productUrl);
11    self.price = ko.observable(product.price);
12    self.priceValue = ko.observable(product.priceValue);
13    self.typeOfGood = ko.observable(product.typeOfGood);
14    self.isReimbursed = ko.observable(product.isReimbursed);
15    self.isOrderable = ko.observable(product.isOrderable);
16    self.deliveryUnit = ko.observable(product.deliveryUnit);
17    self.isMediqSelect = ko.observable(product.isMediqSelect);
18    self.isNewpackaging = ko.observable(product.isNewpackaging);
19    self.nonOrderableQuantityError = ko.observable(false);
20    self.disableQuantityInput = ko.observable(false);
21    if (!product.orderable) {
22        self.disableDecrease = ko.observable(true);
23        self.disableIncrease = ko.observable(true);
24        self.nonOrderableQuantityError = ko.observable(true);
25        self.isOrderable = ko.observable(false);
26        self.disableQuantityInput(true);
27    }
28    else {
29        self.disableDecrease = ko.observable(product.quantity <= minValue);
30        self.disableIncrease = ko.observable(product.quantity >= maxValue);
31    }
32    self.showLessQuantityError = ko.observable(false);
33    self.showMaxQuantityError = ko.observable(false);
34    self.hasError = ko.observable(false);
35    self.quantity = ko.observable(product.quantity);
36    //Set initial quatity and product cancelled.
37    self.markAsCancelled = ko.observable(product.markAsCancelled);
38    self.initialQuantity = ko.observable(product.initialQuantity);
39    self.initialCancelled = ko.observable(product.initialMarkAsCancelled);
40
41    if (self.initialCancelled()) {
42        // disable quantity on reactivation
43        self.disableIncrease(true);
44        self.disableDecrease(true);
45        self.disableQuantityInput(true);
46    }
47
48    self.setButton = function (currentValue) {
49        self.hasError(false);
50        self.disableQuantityInput(false);
51
52        self.showLessQuantityError(false);
53        self.showMaxQuantityError(false);
54        if (isNaN(currentValue) || currentValue < minValue) {
55            this.disableIncrease(false);
56            this.disableDecrease(true);
57            self.showLessQuantityError(true);
58            self.hasError(true);
59        } else if (currentValue > maxValue) {
60            this.disableIncrease(true);
61            this.disableDecrease(false);
62            self.showMaxQuantityError(true);
63            self.hasError(true);
64        } else if (currentValue == maxValue) {
65            this.disableIncrease(true);
66            this.disableDecrease(false);
67        } else if (currentValue == minValue) {
68            this.disableIncrease(false);
69            this.disableDecrease(true);
70        } else {
71            this.disableIncrease(false);
72            this.disableDecrease(false);
73        }
74    };
75
76    self.quantityInputChange = function () {
77        parentView.showUpdateSuccessMessage(false);
78        parentView.showUpdateFailedMessage(false);
79
80        if (!this.isOrderable())
81        {
82            return;
83        }
84
85        var currentValue = parseInt(this.quantity());
86        self.setButton(currentValue);
87        parentView.setDirty();
88    };
89
90    self.increaseQuantity = function (model, event) {
91        parentView.showUpdateSuccessMessage(false);
92        parentView.showUpdateFailedMessage(false);
93
94        if (!this.isOrderable())
95        {
96            return;
97        }
98        var currentValue = parseInt(this.quantity());
99        if (currentValue <= maxValue || currentValue === undefined || isNaN(currentValue)) {
100            if (isNaN(currentValue)) {
101                currentValue = 0;
102            }
103            currentValue = currentValue + 1;
104            self.setButton(currentValue);
105            self.quantity(currentValue);
106            parentView.setDirty();
107        }
108    };
109
110    self.decreaseQuantity = function () {
111        parentView.showUpdateSuccessMessage(false);
112        parentView.showUpdateFailedMessage(false);
113
114        if (!this.isOrderable())
115        {
116            return;
117        }
118        var currentValue = parseInt(this.quantity());
119        if (currentValue > minValue) {
120            currentValue = currentValue - 1;
121            self.setButton(currentValue);
122            self.quantity(currentValue);
123            parentView.setDirty();
124        }
125    };
126
127    self.cancelLineItem = function () {
128        parentView.showUpdateSuccessMessage(false);
129        parentView.showUpdateFailedMessage(false);
130
131        self.markAsCancelled(true);
132        self.setButton(self.initialQuantity());
133        self.quantity(self.initialQuantity());
134        parentView.setDirty();
135        parentView.checkAllProductCancelled();
136    };
137
138    self.reactivateLineItem = function () {
139        parentView.showUpdateSuccessMessage(false);
140        parentView.showUpdateFailedMessage(false);
141
142        self.markAsCancelled(false);
143        if (self.initialCancelled()) {
144            // disable quantity on reactivation
145            self.disableIncrease(true);
146            self.disableDecrease(true);
147            self.disableQuantityInput(true);
148        }
149
150        if (self.nonOrderableQuantityError()) {
151            self.disableIncrease(true);
152            self.disableDecrease(true);
153            self.disableQuantityInput(true);
154        }
155        parentView.setDirty();
156        parentView.checkAllProductCancelled();
157    };
158
159    self.onSuccess = function () {
160        if (self.markAsCancelled()) {
161            if (!self.initialCancelled()) {
162                self.initialCancelled(true);
163            }
164        } else {
165            if (self.initialCancelled()) {
166                // reset quantity selector
167                self.initialCancelled(false);
168                self.setButton(self.initialQuantity());
169            }
170        }
171    }
172}
173
174function MediqRepeatOrderOrderLinesViewModel() {
175    var self = this;
176
177    self.id = ko.observable()
178    self.orderLines = ko.observableArray();
179    self.visible = ko.observable(false);
180    self.hasErrors = ko.computed(function () {
181        var hasErrors = false;
182        ko.utils.arrayForEach(self.orderLines(), function (line) {
183            hasErrors = hasErrors || line.hasError();
184        })
185        return hasErrors;
186    });

187    self.showUpdateSuccessMessage = ko.observable(false);
188    self.showUpdateFailedMessage = ko.observable(false);
189    self.allProductCancelledMessage = ko.observable();
190    self.isAllProductCancelled = ko.observable(false);
191    self.isDirty = ko.observable(false);
192    self.updateModel = function (data) {
193        if (data) {
194            self.id(data.id);
195            self.orderLines([]);
196            $(data.orderLines).each(function (cnt) {
197                self.orderLines.push(new MediqRepeatOrderOrderLineViewModel(this, self));
198            });
199            self.visible(true);
200        }
201    };
202
203    self.setDirty = function () {
204        self.isDirty(true);
205        self.updateOrderLinesContext();
206    }
207
208    self.checkAllProductCancelled = function () {
209        if (self.isAllProductCancelled()) {
210            var checkLine = self.orderLines().every(function (line) {
211                return line.markAsCancelled() === true;
212            });
213            if (checkLine) {
214                MessageContext.PublishInfo(null, self.allProductCancelledMessage, null, null);
215            }
216            else {
217                MessageContext.PublishCommand(this, MessageContext.StandardCommands.ClearAll);
218            }
219        }
220    }
221
222    self.updateOrderLinesContext = function () {
223        var mappedLines = [];
224        ko.utils.arrayForEach(self.orderLines(), function (line) {
225            mappedLines.push({
226                lineTotal: line.markAsCancelled() ? 0 : parseInt(line.quantity()) * parseFloat(line.priceValue())
227            })
228        });
229
230        var subTotal = mappedLines.map(line => line.lineTotal).reduce(function (prev, next) {
231            return prev + next;
232        });
233        OrderLinesContext.Update(this, {
234            subTotal: subTotal,
235            hasErrors: self.hasErrors(),
236            orderId: self.id(),
237            lines: self.orderLines().map(function (line) {
238                return {
239                    materialId: line.materialId(),
240                    quantity: parseInt(line.quantity()),
241                    markAsCancelled: line.markAsCancelled(),
242                    initialCancelled: line.initialCancelled()
243                }
244            })
245        });
246    }
247
248    self.updateOrder = function (model) {
249        self.showUpdateSuccessMessage(false);
250        self.showUpdateFailedMessage(false);
251        self.isDirty(false);
252        var updateOrderData = {
253            orderId: model.id(),
254            orderLines: model.orderLines().map(function (line) {
255                return {
256                    materialId: line.materialId(),
257                    quantity: parseInt(line.quantity()),
258                    markAsCancelled: line.markAsCancelled()
259                }
260            })
261        };
262        AjaxService.Post("/api/cxa/RepeatOrders/SaveOrderLinesOfRepeatOrder", updateOrderData, function (data, success) {
263            if (data && data.Success) {
264                self.showUpdateSuccessMessage(true);
265                ko.utils.arrayForEach(self.orderLines(), function (line) {
266                    line.onSuccess();
267                });
268            } else {
269                self.showUpdateFailedMessage(true);
270            }
271        });
272    };
273}