| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import org.ofbiz.entity.condition.* |
| import org.ofbiz.entity.util.* |
| import org.ofbiz.service.ServiceUtil |
| import org.ofbiz.base.util.* |
| |
| shipmentId = request.getParameter("shipmentId"); |
| orderId = request.getParameter("purchaseOrderId"); |
| shipGroupSeqId = request.getParameter("shipGroupSeqId"); |
| context.shipmentId = shipmentId; |
| context.shipGroupSeqId = shipGroupSeqId; |
| |
| // Retrieve the map resident in session which stores order item quantities to receive |
| itemQuantitiesToReceive = session.getAttribute("purchaseOrderItemQuantitiesToReceive"); |
| if (itemQuantitiesToReceive) { |
| sessionShipmentId = itemQuantitiesToReceive._shipmentId; |
| sessionOrderId = itemQuantitiesToReceive._orderId; |
| if ((sessionShipmentId && !sessionShipmentId.equals(shipmentId)) || |
| ((sessionOrderId && !sessionOrderId.equals(orderId))) || |
| "Y".equals(request.getParameter("clearAll"))) { |
| |
| // Clear the map if the shipmentId or orderId are different than the current ones, or |
| // if the clearAll parameter is present |
| itemQuantitiesToReceive.clear(); |
| } |
| } |
| |
| shipment = delegator.findOne("Shipment", [shipmentId : shipmentId], false); |
| context.shipment = shipment; |
| if (!shipment) { |
| return; |
| } |
| |
| isPurchaseShipment = "PURCHASE_SHIPMENT".equals(shipment.shipmentTypeId); |
| context.isPurchaseShipment = isPurchaseShipment; |
| if (!isPurchaseShipment) { |
| return; |
| } |
| |
| facility = shipment.getRelatedOne("DestinationFacility", false); |
| context.facility = facility; |
| context.facilityId = shipment.destinationFacilityId; |
| context.now = UtilDateTime.nowTimestamp(); |
| |
| if (!orderId) { |
| orderId = shipment.primaryOrderId; |
| } |
| if (!shipGroupSeqId) { |
| shipGroupSeqId = shipment.primaryShipGroupSeqId; |
| } |
| context.orderId = orderId; |
| |
| if (!orderId) { |
| return; |
| } |
| |
| orderHeader = delegator.findOne("OrderHeader", [orderId : orderId], false); |
| context.orderHeader = orderHeader; |
| if (!orderHeader) { |
| return; |
| } |
| |
| isPurchaseOrder = "PURCHASE_ORDER".equals(orderHeader.orderTypeId); |
| context.isPurchaseOrder = isPurchaseOrder; |
| if (!isPurchaseOrder) { |
| return; |
| } |
| |
| // Get the base currency from the facility owner, for currency conversions |
| baseCurrencyUomId = null; |
| if (facility) { |
| owner = facility.getRelatedOne("OwnerParty", false); |
| if (owner) { |
| result = dispatcher.runSync("getPartyAccountingPreferences", [organizationPartyId : owner.partyId, userLogin : request.getAttribute("userLogin")]); |
| if (!ServiceUtil.isError(result) && result.partyAccountingPreference) { |
| ownerAcctgPref = result.partyAccountingPreference; |
| } |
| } |
| if (ownerAcctgPref) { |
| baseCurrencyUomId = ownerAcctgPref.baseCurrencyUomId; |
| } |
| } |
| |
| inventoryItemTypes = delegator.findList("InventoryItemType", null, null, null, null, false); |
| context.inventoryItemTypes = inventoryItemTypes; |
| |
| // Populate the tracking map with shipment and order IDs |
| if (!itemQuantitiesToReceive) { |
| itemQuantitiesToReceive = [_shipmentId : shipmentId, _orderId : orderId]; |
| } |
| |
| oiasgaLimitMap = null; |
| if (shipGroupSeqId) { |
| oiasgaLimitMap = [shipGroupSeqId : shipGroupSeqId]; |
| } |
| |
| orderItemDatas = [:] as TreeMap; |
| totalAvailableToReceive = 0; |
| |
| // Populate the order item data for the FTL |
| orderItems = orderHeader.getRelated("OrderItemAndShipGroupAssoc", oiasgaLimitMap, ['shipGroupSeqId', 'orderItemSeqId'], false); |
| orderItems.each { orderItemAndShipGroupAssoc -> |
| product = orderItemAndShipGroupAssoc.getRelatedOne("Product", false); |
| |
| // Get the order item, since the orderItemAndShipGroupAssoc's quantity field is manipulated in some cases |
| orderItem = delegator.findOne("OrderItem", [orderId : orderId, orderItemSeqId : orderItemAndShipGroupAssoc.orderItemSeqId], false); |
| orderItemData = [:]; |
| |
| // Get the item's ordered quantity |
| totalOrdered = 0; |
| ordered = orderItem.getDouble("quantity"); |
| if (ordered) { |
| totalOrdered += ordered.doubleValue(); |
| } |
| cancelled = orderItem.getDouble("cancelQuantity"); |
| if (cancelled) { |
| totalOrdered -= cancelled.doubleValue(); |
| } |
| |
| // Get the item quantity received from all shipments via the ShipmentReceipt entity |
| totalReceived = 0.0; |
| receipts = delegator.findList("ShipmentReceipt", EntityCondition.makeCondition([orderId : orderId, orderItemSeqId : orderItem.orderItemSeqId]), null, null, null, false); |
| fulfilledReservations = [] as ArrayList; |
| if (receipts) { |
| receipts.each { rec -> |
| accepted = rec.getDouble("quantityAccepted"); |
| rejected = rec.getDouble("quantityRejected"); |
| if (accepted) { |
| totalReceived += accepted.doubleValue(); |
| } |
| if (rejected) { |
| totalReceived += rejected.doubleValue(); |
| } |
| // Get the reservations related to this receipt |
| oisgirs = delegator.findList("OrderItemShipGrpInvRes", EntityCondition.makeCondition([inventoryItemId : rec.inventoryItemId]), null, null, null, false); |
| if (oisgirs) { |
| fulfilledReservations.addAll(oisgirs); |
| } |
| } |
| } |
| orderItemData.fulfilledReservations = fulfilledReservations; |
| |
| // Update the unit cost with the converted value, if any |
| if (baseCurrencyUomId && orderHeader.currencyUom) { |
| if (product) { |
| result = dispatcher.runSync("convertUom", [uomId : orderHeader.currencyUom, uomIdTo : baseCurrencyUomId, originalValue : orderItem.unitPrice]); |
| if (!ServiceUtil.isError(result)) { |
| orderItem.unitPrice = result.convertedValue; |
| } |
| } |
| } |
| |
| // Retrieve the backordered quantity |
| // TODO: limit to a facility? The shipment destination facility is not necessarily the same facility as the inventory |
| conditions = [EntityCondition.makeCondition("productId", EntityOperator.EQUALS, product.productId), |
| EntityCondition.makeCondition("availableToPromiseTotal", EntityOperator.LESS_THAN, BigDecimal.ZERO)]; |
| negativeInventoryItems = delegator.findList("InventoryItem", EntityCondition.makeCondition(conditions, EntityOperator.AND), null, null, null, false); |
| backOrderedQuantity = 0; |
| negativeInventoryItems.each { negativeInventoryItem -> |
| backOrderedQuantity += negativeInventoryItem.getDouble("availableToPromiseTotal").doubleValue(); |
| } |
| orderItemData.backOrderedQuantity = Math.abs(backOrderedQuantity); |
| |
| // Calculate how many units it should be possible to recieve for this purchase order |
| availableToReceive = totalOrdered - totalReceived; |
| totalAvailableToReceive += availableToReceive; |
| orderItemData.availableToReceive = availableToReceive; |
| orderItemData.totalQuantityReceived = totalReceived; |
| orderItemData.shipGroupSeqId = orderItemAndShipGroupAssoc.shipGroupSeqId; |
| orderItemData.orderItem = orderItem; |
| orderItemData.product = product; |
| orderItemDatas.put(orderItem.orderItemSeqId, orderItemData); |
| } |
| context.orderItemDatas = orderItemDatas.values(); |
| |
| // Handle any item product quantities to receive by adding to the map in session |
| productIdToReceive = request.getParameter("productId"); |
| productQtyToReceive = request.getParameter("quantity"); |
| context.newQuantity = productQtyToReceive; |
| |
| if (productIdToReceive) { |
| List candidateOrderItems = EntityUtil.filterByAnd(orderItems, [productId : productIdToReceive]); |
| |
| // If the productId as given isn't found in the order, try any goodIdentifications and use the first match |
| if (!candidateOrderItems) { |
| goodIdentifications = delegator.findList("GoodIdentification", EntityCondition.makeCondition([idValue : productIdToReceive]), null, null, null, false); |
| if (goodIdentifications) { |
| giit = goodIdentifications.iterator(); |
| while (giit.hasNext()) { |
| goodIdentification = giit.next(); |
| candidateOrderItems = EntityUtil.filterByAnd(orderItems, [productId : goodIdentification.productId]); |
| if (candidateOrderItems) { |
| productIdToReceive = goodIdentification.productId; |
| break; |
| } |
| } |
| } |
| } |
| |
| if (candidateOrderItems) { |
| quantity = 0; |
| if (productQtyToReceive) { |
| try { |
| quantity = Double.parseDouble(productQtyToReceive); |
| } catch (Exception e) { |
| // Ignore the quantity update if there's a problem parsing it |
| } |
| } |
| |
| totalQuantityUsed = 0; |
| totalQuantityToReceiveBefore = 0; |
| pqit = candidateOrderItems.iterator(); |
| while (pqit.hasNext() && totalQuantityUsed < quantity) { |
| candidateOrderItem = pqit.next(); |
| orderItemSeqId = candidateOrderItem.orderItemSeqId; |
| qtyBefore = itemQuantitiesToReceive.containsKey(orderItemSeqId) ? itemQuantitiesToReceive.get(orderItemSeqId) : 0; |
| totalQuantityToReceiveBefore += qtyBefore; |
| qtyMaxAvailable = orderItemDatas.get(orderItemSeqId).availableToReceive - qtyBefore; |
| |
| if (qtyMaxAvailable <= 0) { |
| continue; |
| } |
| |
| qtyUsedForItem = quantity - totalQuantityUsed >= qtyMaxAvailable ? qtyMaxAvailable : quantity - totalQuantityUsed; |
| itemQuantitiesToReceive.put(orderItemSeqId, qtyUsedForItem + qtyBefore); |
| totalQuantityUsed += qtyUsedForItem; |
| } |
| |
| // If there's any quantity to receive left after using as much as possible for every relevant order item, add an error message to the context |
| if (quantity > totalQuantityUsed) { |
| context.ProductReceiveInventoryAgainstPurchaseOrderQuantityExceedsAvailableToReceive = true; |
| } |
| |
| // Notify if some or all of the quantity just entered for the product will go to a backorder |
| backOrderedQuantity = orderItemDatas.get(EntityUtil.getFirst(candidateOrderItems).orderItemSeqId).backOrderedQuantity - totalQuantityToReceiveBefore; |
| |
| if (backOrderedQuantity > 0) { |
| totalQtyUsedForBackorders = backOrderedQuantity >= totalQuantityUsed ? totalQuantityUsed : backOrderedQuantity; |
| if (totalQtyUsedForBackorders > 0) { |
| context.quantityToReceive = totalQuantityUsed; |
| context.quantityToBackOrder = totalQtyUsedForBackorders; |
| context.ProductReceiveInventoryAgainstPurchaseOrderQuantityGoesToBackOrder = true; |
| } |
| } |
| } else { |
| |
| // Add an error message to the context if the productId doesn't exist in this purchase order |
| context.ProductReceiveInventoryAgainstPurchaseOrderProductNotFound = true; |
| } |
| } |
| |
| // Put the tracking map back into the session, in case it has been reconstructed |
| session.setAttribute("purchaseOrderItemQuantitiesToReceive", itemQuantitiesToReceive); |
| context.itemQuantitiesToReceive = itemQuantitiesToReceive; |
| context.totalAvailableToReceive = totalAvailableToReceive; |
