/*******************************************************************************
* 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.
*******************************************************************************/
package org.apache.ofbiz.shipment.packing;
import java.math.BigDecimal;
import java.util.AbstractMap;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.GeneralException;
import org.apache.ofbiz.base.util.UtilFormatOut;
import org.apache.ofbiz.base.util.UtilMisc;
import org.apache.ofbiz.base.util.UtilValidate;
import org.apache.ofbiz.entity.Delegator;
import org.apache.ofbiz.entity.DelegatorFactory;
import org.apache.ofbiz.entity.GenericEntityException;
import org.apache.ofbiz.entity.GenericValue;
import org.apache.ofbiz.entity.util.EntityQuery;
import org.apache.ofbiz.entity.util.EntityUtil;
import org.apache.ofbiz.product.product.ProductWorker;
import org.apache.ofbiz.service.GenericServiceException;
import org.apache.ofbiz.service.LocalDispatcher;
import org.apache.ofbiz.service.ServiceContainer;
import org.apache.ofbiz.service.ServiceUtil;
@SuppressWarnings("serial")
public class PackingSession implements java.io.Serializable {
public static final String module = PackingSession.class.getName();
protected GenericValue userLogin = null;
protected String pickerPartyId = null;
protected String primaryOrderId = null;
protected String primaryShipGrp = null;
protected String dispatcherName = null;
protected String delegatorName = null;
protected String picklistBinId = null;
protected String facilityId = null;
protected String shipmentId = null;
protected String instructions = null;
protected String weightUomId = null;
protected String shipmentBoxTypeId = null;
protected BigDecimal additionalShippingCharge = null;
protected Map<Integer, BigDecimal> packageWeights = null;
protected List<PackingEvent> packEvents = null;
protected List<PackingSessionLine> packLines = null;
protected List<ItemDisplay> itemInfos = null;
protected int packageSeq = -1;
protected int status = 1;
protected Map<Integer, String> shipmentBoxTypes = null;
private transient Delegator _delegator = null;
private transient LocalDispatcher _dispatcher = null;
public PackingSession(LocalDispatcher dispatcher, GenericValue userLogin, String facilityId, String binId, String orderId, String shipGrp) {
this._dispatcher = dispatcher;
this.dispatcherName = dispatcher.getName();
this._delegator = _dispatcher.getDelegator();
this.delegatorName = _delegator.getDelegatorName();
this.primaryOrderId = orderId;
this.primaryShipGrp = shipGrp;
this.picklistBinId = binId;
this.userLogin = userLogin;
this.facilityId = facilityId;
this.packLines = new LinkedList<PackingSessionLine>();
this.packEvents = new LinkedList<PackingEvent>();
this.itemInfos = new LinkedList<PackingSession.ItemDisplay>();
this.packageSeq = 1;
this.packageWeights = new HashMap<Integer, BigDecimal>();
this.shipmentBoxTypes = new HashMap<Integer, String>();
}
public PackingSession(LocalDispatcher dispatcher, GenericValue userLogin, String facilityId) {
this(dispatcher, userLogin, facilityId, null, null, null);
}
public PackingSession(LocalDispatcher dispatcher, GenericValue userLogin) {
this(dispatcher, userLogin, null, null, null, null);
}
public void addOrIncreaseLine(String orderId, String orderItemSeqId, String shipGroupSeqId, String productId, BigDecimal quantity, int packageSeqId, BigDecimal weight, boolean update) throws GeneralException {
// reset the session if we just completed
if (status == 0) {
throw new GeneralException("Packing session has been completed; be sure to CLEAR before packing a new order! [000]");
}
// do nothing if we are trying to add a quantity of 0
if (!update && quantity.compareTo(BigDecimal.ZERO) == 0) {
return;
}
// find the actual product ID
productId = ProductWorker.findProductId(this.getDelegator(), productId);
// set the default null values - primary is the assumed first item
if (orderId == null) {
orderId = primaryOrderId;
}
if (shipGroupSeqId == null) {
shipGroupSeqId = primaryShipGrp;
}
if (orderItemSeqId == null && productId != null) {
orderItemSeqId = this.findOrderItemSeqId(productId, orderId, shipGroupSeqId, quantity);
}
// get the reservations for the item
Map<String, Object> invLookup = new HashMap<String, Object>();
invLookup.put("orderId", orderId);
invLookup.put("orderItemSeqId", orderItemSeqId);
invLookup.put("shipGroupSeqId", shipGroupSeqId);
List<GenericValue> reservations = this.getDelegator().findByAnd("OrderItemShipGrpInvRes", invLookup, UtilMisc.toList("quantity DESC"), false);
// no reservations we cannot add this item
if (UtilValidate.isEmpty(reservations)) {
throw new GeneralException("No inventory reservations available; cannot pack this item! [101]");
}
// find the inventoryItemId to use
if (reservations.size() == 1) {
GenericValue res = EntityUtil.getFirst(reservations);
int checkCode = this.checkLineForAdd(res, orderId, orderItemSeqId, shipGroupSeqId, productId, quantity, packageSeqId, update);
this.createPackLineItem(checkCode, res, orderId, orderItemSeqId, shipGroupSeqId, productId, quantity, weight, packageSeqId);
} else {
// more than one reservation found
Map<GenericValue, BigDecimal> toCreateMap = new HashMap<GenericValue, BigDecimal>();
Iterator<GenericValue> i = reservations.iterator();
BigDecimal qtyRemain = quantity;
while (i.hasNext() && qtyRemain.compareTo(BigDecimal.ZERO) > 0) {
GenericValue res = i.next();
// Check that the inventory item product match with the current product to pack
if (!productId.equals(res.getRelatedOne("InventoryItem", false).getString("productId"))) {
continue;
}
BigDecimal resQty = res.getBigDecimal("quantity");
BigDecimal resPackedQty = this.getPackedQuantity(orderId, orderItemSeqId, shipGroupSeqId, productId, res.getString("inventoryItemId"), -1);
if (resPackedQty.compareTo(resQty) >= 0) {
continue;
} else if (!update) {
resQty = resQty.subtract(resPackedQty);
}
BigDecimal thisQty = resQty.compareTo(qtyRemain) > 0 ? qtyRemain : resQty;
int thisCheck = this.checkLineForAdd(res, orderId, orderItemSeqId, shipGroupSeqId, productId, thisQty, packageSeqId, update);
switch (thisCheck) {
case 2:
Debug.logInfo("Packing check returned '2' - new pack line will be created!", module);
toCreateMap.put(res, thisQty);
qtyRemain = qtyRemain.subtract(thisQty);
break;
case 1:
Debug.logInfo("Packing check returned '1' - existing pack line has been updated!", module);
qtyRemain = qtyRemain.subtract(thisQty);
break;
case 0:
Debug.logInfo("Packing check returned '0' - doing nothing.", module);
break;
}
}
if (qtyRemain.compareTo(BigDecimal.ZERO) == 0) {
for (Map.Entry<GenericValue, BigDecimal> entry: toCreateMap.entrySet()) {
GenericValue res = entry.getKey();
BigDecimal qty = entry.getValue();
this.createPackLineItem(2, res, orderId, orderItemSeqId, shipGroupSeqId, productId, qty, weight, packageSeqId);
}
} else {
throw new GeneralException("Not enough inventory reservation available; cannot pack the item! [103]");
}
}
// run the add events
this.runEvents(PackingEvent.EVENT_CODE_ADD);
}
public void addOrIncreaseLine(String orderId, String orderItemSeqId, String shipGroupSeqId, BigDecimal quantity, int packageSeqId) throws GeneralException {
this.addOrIncreaseLine(orderId, orderItemSeqId, shipGroupSeqId, null, quantity, packageSeqId, BigDecimal.ZERO, false);
}
public void addOrIncreaseLine(String productId, BigDecimal quantity, int packageSeqId) throws GeneralException {
this.addOrIncreaseLine(null, null, null, productId, quantity, packageSeqId, BigDecimal.ZERO, false);
}
public PackingSessionLine findLine(String orderId, String orderItemSeqId, String shipGroupSeqId, String productId, String inventoryItemId, int packageSeq) {
for (PackingSessionLine line: this.getLines()) {
if (orderId.equals(line.getOrderId()) &&
orderItemSeqId.equals(line.getOrderItemSeqId()) &&
shipGroupSeqId.equals(line.getShipGroupSeqId()) &&
productId.equals(line.getProductId()) &&
inventoryItemId.equals(line.getInventoryItemId()) &&
packageSeq == line.getPackageSeq()) {
return line;
}
}
return null;
}
protected void createPackLineItem(int checkCode, GenericValue res, String orderId, String orderItemSeqId, String shipGroupSeqId, String productId, BigDecimal quantity, BigDecimal weight, int packageSeqId) throws GeneralException {
// process the result; add new item if necessary
switch (checkCode) {
case 0:
// not enough reserved
throw new GeneralException("Not enough inventory reservation available; cannot pack the item! [201]");
case 1:
// we're all good to go; quantity already updated
break;
case 2:
// need to create a new item
String invItemId = res.getString("inventoryItemId");
packLines.add(new PackingSessionLine(orderId, orderItemSeqId, shipGroupSeqId, productId, invItemId, quantity, weight, packageSeqId));
break;
}
// Add the line weight to the package weight
if (weight.compareTo(BigDecimal.ZERO) > 0) this.addToPackageWeight(packageSeqId, weight);
// update the package sequence
if (packageSeqId > packageSeq) {
this.packageSeq = packageSeqId;
}
}
protected String findOrderItemSeqId(String productId, String orderId, String shipGroupSeqId, BigDecimal quantity) throws GeneralException {
Map<String, Object> lookupMap = new HashMap<String, Object>();
lookupMap.put("orderId", orderId);
lookupMap.put("productId", productId);
lookupMap.put("statusId", "ITEM_APPROVED");
lookupMap.put("shipGroupSeqId", shipGroupSeqId);
List<String> sort = UtilMisc.toList("-quantity");
List<GenericValue> orderItems = this.getDelegator().findByAnd("OrderItemAndShipGroupAssoc", lookupMap, sort, false);
String orderItemSeqId = null;
if (orderItems != null) {
for (GenericValue item: orderItems) {
// get the reservations for the item
Map<String, Object> invLookup = new HashMap<String, Object>();
invLookup.put("orderId", orderId);
invLookup.put("orderItemSeqId", item.getString("orderItemSeqId"));
invLookup.put("shipGroupSeqId", shipGroupSeqId);
List<GenericValue> reservations = this.getDelegator().findByAnd("OrderItemShipGrpInvRes", invLookup, null, false);
for (GenericValue res: reservations) {
BigDecimal qty = res.getBigDecimal("quantity");
if (quantity.compareTo(qty) <= 0) {
orderItemSeqId = item.getString("orderItemSeqId");
break;
}
}
}
}
if (orderItemSeqId != null) {
return orderItemSeqId;
} else {
throw new GeneralException("No valid order item found for product [" + productId + "] with quantity: " + quantity);
}
}
protected int checkLineForAdd(GenericValue res, String orderId, String orderItemSeqId, String shipGroupSeqId, String productId, BigDecimal quantity, int packageSeqId, boolean update) {
// check to see if the reservation can hold the requested quantity amount
String invItemId = res.getString("inventoryItemId");
BigDecimal resQty = res.getBigDecimal("quantity");
PackingSessionLine line = this.findLine(orderId, orderItemSeqId, shipGroupSeqId, productId, invItemId, packageSeqId);
BigDecimal packedQty = this.getPackedQuantity(orderId, orderItemSeqId, shipGroupSeqId, productId);
Debug.logInfo("Packed quantity [" + packedQty + "] + [" + quantity + "]", module);
if (line == null) {
Debug.logInfo("No current line found testing [" + invItemId + "] R: " + resQty + " / Q: " + quantity, module);
if (resQty.compareTo(quantity) < 0) {
return 0;
} else {
return 2;
}
} else {
BigDecimal newQty = update ? quantity : (line.getQuantity().add(quantity));
Debug.logInfo("Existing line found testing [" + invItemId + "] R: " + resQty + " / Q: " + newQty, module);
if (resQty.compareTo(newQty) < 0) {
return 0;
} else {
line.setQuantity(newQty);
return 1;
}
}
}
public void addItemInfo(List<GenericValue> infos) {
for (GenericValue v: infos) {
ItemDisplay newItem = new ItemDisplay(v);
int currentIdx = itemInfos.indexOf(newItem);
if (currentIdx != -1) {
ItemDisplay existingItem = itemInfos.get(currentIdx);
existingItem.quantity = existingItem.quantity.add(newItem.quantity);
} else {
itemInfos.add(newItem);
}
}
}
public List<ItemDisplay> getItemInfos() {
return itemInfos;
}
/**
* <p>Delivers all the packing lines grouped by package.</p>
* Output map:
* <ul>
* <li>packageMap - a Map of type {@code Map<Integer, List<PackingSessionLine>>}
* that maps package sequence ids to the lines that belong in
* that package</li>
* <li>sortedKeys - a List of type List<Integer> with the sorted package
* sequence numbers to index the packageMap</li>
* </ul>
* @return result Map with packageMap and sortedKeys
*/
public Map<Object, Object> getPackingSessionLinesByPackage() {
Map<Integer, List<PackingSessionLine>> packageMap = new HashMap<Integer, List<PackingSessionLine>>();
for (PackingSessionLine line : packLines) {
int pSeq = line.getPackageSeq();
List<PackingSessionLine> packageLineList = packageMap.get(pSeq);
if (packageLineList == null) {
packageLineList = new LinkedList<PackingSessionLine>();
packageMap.put(pSeq, packageLineList);
}
packageLineList.add(line);
}
Object[] keys = packageMap.keySet().toArray();
java.util.Arrays.sort(keys);
List<Object> sortedKeys = new LinkedList<Object>();
for (Object key : keys) {
sortedKeys.add(key);
}
Map<Object, Object> result = new HashMap<Object, Object>();
result.put("packageMap", packageMap);
result.put("sortedKeys", sortedKeys);
return result;
}
public void clearItemInfos() {
itemInfos.clear();
}
public String getShipmentId() {
return this.shipmentId;
}
public List<PackingSessionLine> getLines() {
return this.packLines;
}
public int nextPackageSeq() {
return ++packageSeq;
}
public int getCurrentPackageSeq() {
return packageSeq;
}
public BigDecimal getPackedQuantity(String orderId, String orderItemSeqId, String shipGroupSeqId, String productId) {
return getPackedQuantity(orderId, orderItemSeqId, shipGroupSeqId, productId, null, -1);
}
public BigDecimal getPackedQuantity(String orderId, String orderItemSeqId, String shipGroupSeqId, String productId, int packageSeq) {
return getPackedQuantity(orderId, orderItemSeqId, shipGroupSeqId, productId, null, packageSeq);
}
public BigDecimal getPackedQuantity(String orderId, String orderItemSeqId, String shipGroupSeqId, String productId, String inventoryItemId, int packageSeq) {
BigDecimal total = BigDecimal.ZERO;
for (PackingSessionLine line: this.getLines()) {
if (orderId.equals(line.getOrderId()) && orderItemSeqId.equals(line.getOrderItemSeqId()) &&
shipGroupSeqId.equals(line.getShipGroupSeqId()) && productId.equals(line.getProductId())) {
if (inventoryItemId == null || inventoryItemId.equals(line.getInventoryItemId())) {
if (packageSeq == -1 || packageSeq == line.getPackageSeq()) {
total = total.add(line.getQuantity());
}
}
}
}
return total;
}
public BigDecimal getPackedQuantity(String productId, int packageSeq) {
if (productId != null) {
try {
productId = ProductWorker.findProductId(this.getDelegator(), productId);
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
}
BigDecimal total = BigDecimal.ZERO;
if (productId != null) {
for (PackingSessionLine line: this.getLines()) {
if (productId.equals(line.getProductId())) {
if (packageSeq == -1 || packageSeq == line.getPackageSeq()) {
total = total.add(line.getQuantity());
}
}
}
}
return total;
}
public BigDecimal getPackedQuantity(int packageSeq) {
BigDecimal total = BigDecimal.ZERO;
for (PackingSessionLine line: this.getLines()) {
if (packageSeq == -1 || packageSeq == line.getPackageSeq()) {
total = total.add(line.getQuantity());
}
}
return total;
}
public BigDecimal getPackedQuantity(String productId) {
return getPackedQuantity(productId, -1);
}
public BigDecimal getCurrentReservedQuantity(String orderId, String orderItemSeqId, String shipGroupSeqId, String productId) {
BigDecimal reserved = BigDecimal.ONE.negate();
try {
GenericValue res = EntityUtil.getFirst(this.getDelegator().findByAnd("OrderItemAndShipGrpInvResAndItemSum", UtilMisc.toMap("orderId", orderId,
"orderItemSeqId", orderItemSeqId, "shipGroupSeqId", shipGroupSeqId, "inventoryProductId", productId), null, false));
reserved = res.getBigDecimal("totQuantityAvailable");
if (reserved == null) {
reserved = BigDecimal.ONE.negate();
}
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
return reserved;
}
public BigDecimal getCurrentShippedQuantity(String orderId, String orderItemSeqId, String shipGroupSeqId) {
BigDecimal shipped = BigDecimal.ZERO;
List<GenericValue> issues = this.getItemIssuances(orderId, orderItemSeqId, shipGroupSeqId);
if (issues != null) {
for (GenericValue v: issues) {
BigDecimal qty = v.getBigDecimal("quantity");
if (qty == null) qty = BigDecimal.ZERO;
shipped = shipped.add(qty);
}
}
return shipped;
}
public List<String> getCurrentShipmentIds(String orderId, String orderItemSeqId, String shipGroupSeqId) {
Set<String> shipmentIds = new HashSet<String>();
List<GenericValue> issues = this.getItemIssuances(orderId, orderItemSeqId, shipGroupSeqId);
if (issues != null) {
for (GenericValue v: issues) {
shipmentIds.add(v.getString("shipmentId"));
}
}
List<String> retList = new LinkedList<String>();
retList.addAll(shipmentIds);
return retList;
}
public List<String> getCurrentShipmentIds(String orderId, String shipGroupSeqId) {
return this.getCurrentShipmentIds(orderId, null, shipGroupSeqId);
}
public void registerEvent(PackingEvent event) {
this.packEvents.add(event);
this.runEvents(PackingEvent.EVENT_CODE_EREG);
}
public LocalDispatcher getDispatcher() {
if (_dispatcher == null) {
_dispatcher = ServiceContainer.getLocalDispatcher(dispatcherName, this.getDelegator());
}
return _dispatcher;
}
public Delegator getDelegator() {
if (_delegator == null) {
_delegator = DelegatorFactory.getDelegator(delegatorName);
}
return _delegator;
}
public GenericValue getUserLogin() {
return this.userLogin;
}
public int getStatus() {
return this.status;
}
public String getFacilityId() {
return this.facilityId;
}
public void setFacilityId(String facilityId) {
this.facilityId = facilityId;
}
public String getPrimaryOrderId() {
return this.primaryOrderId;
}
public void setPrimaryOrderId(String orderId) {
this.primaryOrderId = orderId;
}
public String getPrimaryShipGroupSeqId() {
return this.primaryShipGrp;
}
public void setPrimaryShipGroupSeqId(String shipGroupSeqId) {
this.primaryShipGrp = shipGroupSeqId;
}
public void setPicklistBinId(String binId) {
this.picklistBinId = binId;
}
public String getPicklistBinId() {
return this.picklistBinId;
}
public String getHandlingInstructions() {
return this.instructions;
}
public void setHandlingInstructions(String instructions) {
this.instructions = instructions;
}
public void setPickerPartyId(String partyId) {
this.pickerPartyId = partyId;
}
public String getPickerPartyId() {
return this.pickerPartyId;
}
public int clearLastPackage() {
if (packageSeq == 1) {
this.clear();
return packageSeq;
}
List<PackingSessionLine> currentLines = UtilMisc.makeListWritable(this.packLines);
for (PackingSessionLine line: currentLines) {
if (line.getPackageSeq() == packageSeq) {
this.clearLine(line);
}
}
//return --packageSeq;
return packageSeq;
}
public void clearLine(PackingSessionLine line) {
this.packLines.remove(line);
BigDecimal packageWeight = this.packageWeights.get(line.packageSeq);
if (packageWeight != null) {
packageWeight = packageWeight.subtract(line.weight);
if (packageWeight.compareTo(BigDecimal.ZERO) < 0) {
packageWeight = BigDecimal.ZERO;
}
this.packageWeights.put(line.packageSeq, packageWeight);
}
if (line.packageSeq == packageSeq && packageSeq > 1) {
packageSeq--;
}
}
public void clearAllLines() {
this.packLines.clear();
this.packageWeights.clear();
this.shipmentBoxTypes.clear();
this.packageSeq = 1;
}
public void clear() {
this.packLines.clear();
this.instructions = null;
this.pickerPartyId = null;
this.picklistBinId = null;
this.primaryOrderId = null;
this.primaryShipGrp = null;
this.additionalShippingCharge = null;
if (this.packageWeights != null) this.packageWeights.clear();
if (this.shipmentBoxTypes != null) this.shipmentBoxTypes.clear();
this.weightUomId = null;
this.packageSeq = 1;
this.status = 1;
this.runEvents(PackingEvent.EVENT_CODE_CLEAR);
}
public String complete(boolean force) throws GeneralException {
// check to see if there is anything to process
if (this.getLines().size() == 0) {
return "EMPTY";
}
// check for errors
this.checkReservations(force);
// set the status to 0
this.status = 0;
// create the shipment
this.createShipment();
// create the packages
this.createPackages();
// issue the items
this.issueItemsToShipment();
// assign items to packages
this.applyItemsToPackages();
// update ShipmentRouteSegments with total weight and weightUomId
this.updateShipmentRouteSegments();
// set the shipment to packed
this.setShipmentToPacked();
// set role on picklist
this.setPickerOnPicklist();
// run the complete events
this.runEvents(PackingEvent.EVENT_CODE_COMPLETE);
return this.shipmentId;
}
protected void checkReservations(boolean ignore) throws GeneralException {
List<String> errors = new LinkedList<String>();
for (PackingSessionLine line: this.getLines()) {
BigDecimal reservedQty = this.getCurrentReservedQuantity(line.getOrderId(), line.getOrderItemSeqId(), line.getShipGroupSeqId(), line.getProductId());
BigDecimal packedQty = this.getPackedQuantity(line.getOrderId(), line.getOrderItemSeqId(), line.getShipGroupSeqId(), line.getProductId());
if (packedQty.compareTo(reservedQty) != 0) {
errors.add("Packed amount does not match reserved amount for item (" + line.getProductId() + ") [" + packedQty + " / " + reservedQty + "]");
}
}
if (errors.size() > 0) {
if (!ignore) {
throw new GeneralException("Attempt to pack order failed.", errors);
} else {
Debug.logWarning("Packing warnings: " + errors, module);
}
}
}
protected void checkEmptyLines() throws GeneralException {
List<PackingSessionLine> lines = new LinkedList<PackingSessionLine>();
lines.addAll(this.getLines());
for (PackingSessionLine l: lines) {
if (l.getQuantity().compareTo(BigDecimal.ZERO) == 0) {
this.packLines.remove(l);
}
}
}
protected void runEvents(int eventCode) {
if (this.packEvents.size() > 0) {
for (PackingEvent event: this.packEvents) {
event.runEvent(this, eventCode);
}
}
}
protected List<GenericValue> getItemIssuances(String orderId, String orderItemSeqId, String shipGroupSeqId) {
List<GenericValue> issues = null;
if (orderId == null) {
throw new IllegalArgumentException("Value for orderId is null");
}
Map<String, Object> lookupMap = new HashMap<String, Object>();
lookupMap.put("orderId", orderId);
if (UtilValidate.isNotEmpty(orderItemSeqId)) {
lookupMap.put("orderItemSeqId", orderItemSeqId);
}
if (UtilValidate.isNotEmpty(shipGroupSeqId)) {
lookupMap.put("shipGroupSeqId", shipGroupSeqId);
}
try {
issues = this.getDelegator().findByAnd("ItemIssuance", lookupMap, null, false);
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
return issues;
}
protected void createShipment() throws GeneralException {
// first create the shipment
Delegator delegator = this.getDelegator();
Map<String, Object> newShipment = new HashMap<String, Object>();
newShipment.put("originFacilityId", this.facilityId);
newShipment.put("primaryShipGroupSeqId", primaryShipGrp);
newShipment.put("primaryOrderId", primaryOrderId);
newShipment.put("shipmentTypeId", "OUTGOING_SHIPMENT");
newShipment.put("statusId", "SHIPMENT_INPUT");
newShipment.put("handlingInstructions", instructions);
newShipment.put("picklistBinId", picklistBinId);
newShipment.put("additionalShippingCharge", additionalShippingCharge);
newShipment.put("userLogin", userLogin);
GenericValue orderRoleShipTo = EntityQuery.use(delegator).from("OrderRole").where("orderId", primaryOrderId, "roleTypeId", "SHIP_TO_CUSTOMER").queryFirst();
if (UtilValidate.isNotEmpty(orderRoleShipTo)) {
newShipment.put("partyIdTo", orderRoleShipTo.getString("partyId"));
}
String partyIdFrom = null;
if (primaryOrderId != null) {
GenericValue orderItemShipGroup = EntityQuery.use(delegator).from("OrderItemShipGroup").where("orderId", primaryOrderId, "shipGroupSeqId", primaryShipGrp).queryFirst();
if (UtilValidate.isNotEmpty(orderItemShipGroup.getString("vendorPartyId"))) {
partyIdFrom = orderItemShipGroup.getString("vendorPartyId");
} else if (UtilValidate.isNotEmpty(orderItemShipGroup.getString("facilityId"))) {
GenericValue facility = EntityQuery.use(delegator).from("Facility").where("facilityId", orderItemShipGroup.getString("facilityId")).queryOne();
if (UtilValidate.isNotEmpty(facility.getString("ownerPartyId"))) {
partyIdFrom = facility.getString("ownerPartyId");
}
}
if (UtilValidate.isEmpty(partyIdFrom)) {
GenericValue orderRoleShipFrom = EntityQuery.use(delegator).from("OrderRole").where("orderId", primaryOrderId, "roleTypeId", "SHIP_FROM_VENDOR").queryFirst();
if (UtilValidate.isNotEmpty(orderRoleShipFrom)) {
partyIdFrom = orderRoleShipFrom.getString("partyId");
} else {
orderRoleShipFrom = EntityQuery.use(delegator).from("OrderRole").where("orderId", primaryOrderId, "roleTypeId", "BILL_FROM_VENDOR").queryFirst();
partyIdFrom = orderRoleShipFrom.getString("partyId");
}
}
} else if (this.facilityId != null) {
GenericValue facility = EntityQuery.use(delegator).from("Facility").where("facilityId", this.facilityId).queryOne();
if (UtilValidate.isNotEmpty(facility.getString("ownerPartyId"))) {
partyIdFrom = facility.getString("ownerPartyId");
}
}
newShipment.put("partyIdFrom", partyIdFrom);
Debug.logInfo("Creating new shipment with context: " + newShipment, module);
Map<String, Object> newShipResp = this.getDispatcher().runSync("createShipment", newShipment);
if (ServiceUtil.isError(newShipResp)) {
throw new GeneralException(ServiceUtil.getErrorMessage(newShipResp));
}
this.shipmentId = (String) newShipResp.get("shipmentId");
}
protected void issueItemsToShipment() throws GeneralException {
List<PackingSessionLine> processedLines = new LinkedList<PackingSessionLine>();
for (PackingSessionLine line: this.getLines()) {
if (this.checkLine(processedLines, line)) {
BigDecimal totalPacked = this.getPackedQuantity(line.getOrderId(), line.getOrderItemSeqId(),
line.getShipGroupSeqId(), line.getProductId(), line.getInventoryItemId(), -1);
line.issueItemToShipment(shipmentId, picklistBinId, userLogin, totalPacked, getDispatcher());
processedLines.add(line);
}
}
}
protected boolean checkLine(List<PackingSessionLine> processedLines, PackingSessionLine line) {
for (PackingSessionLine l: processedLines) {
if (line.isSameItem(l)) {
line.setShipmentItemSeqId(l.getShipmentItemSeqId());
return false;
}
}
return true;
}
protected void createPackages() throws GeneralException {
for (int i = 0; i < packageSeq; i++) {
String shipmentPackageSeqId = UtilFormatOut.formatPaddedNumber(i+1, 5);
Map<String, Object> pkgCtx = new HashMap<String, Object>();
pkgCtx.put("shipmentId", shipmentId);
pkgCtx.put("shipmentPackageSeqId", shipmentPackageSeqId);
pkgCtx.put("shipmentBoxTypeId", getShipmentBoxType(i+1));
pkgCtx.put("weight", getPackageWeight(i+1));
pkgCtx.put("weightUomId", getWeightUomId());
pkgCtx.put("userLogin", userLogin);
Map<String, Object> newPkgResp = this.getDispatcher().runSync("createShipmentPackage", pkgCtx);
if (ServiceUtil.isError(newPkgResp)) {
throw new GeneralException(ServiceUtil.getErrorMessage(newPkgResp));
}
}
}
protected void applyItemsToPackages() throws GeneralException {
for (PackingSessionLine line: this.getLines()) {
line.applyLineToPackage(shipmentId, userLogin, getDispatcher());
}
}
protected void updateShipmentRouteSegments() throws GeneralException {
BigDecimal shipmentWeight = getTotalWeight();
if (shipmentWeight.compareTo(BigDecimal.ZERO) <= 0) return;
List<GenericValue> shipmentRouteSegments = getDelegator().findByAnd("ShipmentRouteSegment", UtilMisc.toMap("shipmentId", this.getShipmentId()), null, false);
if (! UtilValidate.isEmpty(shipmentRouteSegments)) {
for (GenericValue shipmentRouteSegment: shipmentRouteSegments) {
shipmentRouteSegment.set("billingWeight", shipmentWeight);
shipmentRouteSegment.set("billingWeightUomId", getWeightUomId());
}
getDelegator().storeAll(shipmentRouteSegments);
}
}
protected void setShipmentToPacked() throws GeneralException {
Map<String, Object> packedCtx = UtilMisc.toMap("shipmentId", shipmentId, "statusId", "SHIPMENT_PACKED", "userLogin", userLogin);
Map<String, Object> packedResp = this.getDispatcher().runSync("updateShipment", packedCtx);
if (packedResp != null && ServiceUtil.isError(packedResp)) {
throw new GeneralException(ServiceUtil.getErrorMessage(packedResp));
}
}
protected void setPickerOnPicklist() throws GeneralException {
if (picklistBinId != null) {
// first find the picklist id
GenericValue bin = this.getDelegator().findOne("PicklistBin", UtilMisc.toMap("picklistBinId", picklistBinId), false);
if (bin != null) {
Map<String, Object> ctx = new HashMap<String, Object>();
ctx.put("picklistId", bin.getString("picklistId"));
ctx.put("partyId", pickerPartyId);
ctx.put("roleTypeId", "PICKER");
// check if the role already exists and is valid
List<GenericValue> currentRoles = this.getDelegator().findByAnd("PicklistRole", ctx, null, false);
currentRoles = EntityUtil.filterByDate(currentRoles);
// if not; create the role
if (UtilValidate.isNotEmpty(currentRoles)) {
ctx.put("userLogin", userLogin);
Map<String, Object> addRole = this.getDispatcher().runSync("createPicklistRole", ctx);
if (ServiceUtil.isError(addRole)) {
throw new GeneralException(ServiceUtil.getErrorMessage(addRole));
}
}
}
}
}
public BigDecimal getAdditionalShippingCharge() {
return additionalShippingCharge;
}
public void setAdditionalShippingCharge(BigDecimal additionalShippingCharge) {
this.additionalShippingCharge = additionalShippingCharge;
}
public BigDecimal getTotalWeight() {
BigDecimal total = BigDecimal.ZERO;
for (int i = 0; i < packageSeq; i++) {
BigDecimal packageWeight = getPackageWeight(i);
if (! UtilValidate.isEmpty(packageWeight)) {
total = total.add(packageWeight);
}
}
return total;
}
public BigDecimal getShipmentCostEstimate(GenericValue orderItemShipGroup, String productStoreId, List<GenericValue> shippableItemInfo, BigDecimal shippableTotal, BigDecimal shippableWeight, BigDecimal shippableQuantity) {
return getShipmentCostEstimate(orderItemShipGroup.getString("contactMechId"), orderItemShipGroup.getString("shipmentMethodTypeId"),
orderItemShipGroup.getString("carrierPartyId"), orderItemShipGroup.getString("carrierRoleTypeId"),
productStoreId, shippableItemInfo, shippableTotal, shippableWeight, shippableQuantity);
}
public BigDecimal getShipmentCostEstimate(GenericValue orderItemShipGroup, String productStoreId) {
return getShipmentCostEstimate(orderItemShipGroup.getString("contactMechId"), orderItemShipGroup.getString("shipmentMethodTypeId"),
orderItemShipGroup.getString("carrierPartyId"), orderItemShipGroup.getString("carrierRoleTypeId"),
productStoreId, null, null, null, null);
}
public BigDecimal getShipmentCostEstimate(String shippingContactMechId, String shipmentMethodTypeId, String carrierPartyId, String carrierRoleTypeId, String productStoreId, List<GenericValue> shippableItemInfo, BigDecimal shippableTotal, BigDecimal shippableWeight, BigDecimal shippableQuantity) {
BigDecimal shipmentCostEstimate = null;
Map<String, Object> serviceResult = null;
try {
Map<String, Object> serviceContext = new HashMap<String, Object>();
serviceContext.put("shippingContactMechId", shippingContactMechId);
serviceContext.put("shipmentMethodTypeId", shipmentMethodTypeId);
serviceContext.put("carrierPartyId", carrierPartyId);
serviceContext.put("carrierRoleTypeId", carrierRoleTypeId);
serviceContext.put("productStoreId", productStoreId);
if (UtilValidate.isEmpty(shippableItemInfo)) {
shippableItemInfo = new LinkedList<GenericValue>();
for (PackingSessionLine line: getLines()) {
List<GenericValue> oiasgas = getDelegator().findByAnd("OrderItemAndShipGroupAssoc", UtilMisc.toMap("orderId", line.getOrderId(), "orderItemSeqId", line.getOrderItemSeqId(), "shipGroupSeqId", line.getShipGroupSeqId()), null, false);
shippableItemInfo.addAll(oiasgas);
}
}
serviceContext.put("shippableItemInfo", shippableItemInfo);
if (UtilValidate.isEmpty(shippableWeight)) {
shippableWeight = getTotalWeight();
}
serviceContext.put("shippableWeight", shippableWeight);
if (UtilValidate.isEmpty(shippableQuantity)) {
shippableQuantity = getPackedQuantity(-1);
}
serviceContext.put("shippableQuantity", shippableQuantity);
if (UtilValidate.isEmpty(shippableTotal)) {
shippableTotal = BigDecimal.ZERO;
}
serviceContext.put("shippableTotal", shippableTotal);
serviceResult = getDispatcher().runSync("calcShipmentCostEstimate", serviceContext);
} catch (GenericEntityException e) {
Debug.logError(e, module);
} catch (GenericServiceException e) {
Debug.logError(e, module);
}
if (UtilValidate.isNotEmpty(serviceResult)) {
shipmentCostEstimate = (BigDecimal) serviceResult.get("shippingEstimateAmount");
}
return shipmentCostEstimate;
}
public String getWeightUomId() {
return weightUomId;
}
public void setWeightUomId(String weightUomId) {
this.weightUomId = weightUomId;
}
public void setShipmentBoxTypeId(String shipmentBoxTypeId) {
this.shipmentBoxTypeId = shipmentBoxTypeId;
}
public List<Integer> getPackageSeqIds() {
Set<Integer> packageSeqIds = new TreeSet<Integer>();
if (! UtilValidate.isEmpty(this.getLines())) {
for (PackingSessionLine line: this.getLines()) {
packageSeqIds.add(Integer.valueOf(line.getPackageSeq()));
}
}
return UtilMisc.makeListWritable(packageSeqIds);
}
public void setPackageWeight(int packageSeqId, BigDecimal packageWeight) {
if (UtilValidate.isEmpty(packageWeight)) {
packageWeights.remove(Integer.valueOf(packageSeqId));
} else {
packageWeights.put(Integer.valueOf(packageSeqId), packageWeight);
}
}
public BigDecimal getPackageWeight(int packageSeqId) {
if (this.packageWeights == null) return null;
BigDecimal packageWeight = null;
Object p = packageWeights.get(packageSeqId);
if (p != null) {
packageWeight = (BigDecimal) p;
}
return packageWeight;
}
public void addToPackageWeight(int packageSeqId, BigDecimal weight) {
if (UtilValidate.isEmpty(weight)) return;
BigDecimal packageWeight = getPackageWeight(packageSeqId);
BigDecimal newPackageWeight = UtilValidate.isEmpty(packageWeight) ? weight : weight.add(packageWeight);
setPackageWeight(packageSeqId, newPackageWeight);
}
// These methods (setShipmentBoxType and getShipmentBoxType) are added so that each package will have different box type.
public void setShipmentBoxType(int packageSeqId, String shipmentBoxType) {
if (UtilValidate.isEmpty(shipmentBoxType)) {
shipmentBoxTypes.remove(Integer.valueOf(packageSeqId));
} else {
shipmentBoxTypes.put(Integer.valueOf(packageSeqId), shipmentBoxType);
}
}
public String getShipmentBoxType(int packageSeqId) {
if (this.shipmentBoxTypes == null) return null;
String shipmentBoxType = null;
Object p = shipmentBoxTypes.get(packageSeqId);
if (p != null) {
shipmentBoxType = (String) p;
}
return shipmentBoxType;
}
class ItemDisplay extends AbstractMap<Object, Object> {
public GenericValue orderItem;
public BigDecimal quantity;
public String productId;
public ItemDisplay(GenericValue v) {
if ("PicklistItem".equals(v.getEntityName())) {
quantity = v.getBigDecimal("quantity").setScale(2, BigDecimal.ROUND_HALF_UP);
try {
orderItem = v.getRelatedOne("OrderItem", false);
productId = v.getRelatedOne("InventoryItem", false).getString("productId");
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
} else {
// this is an OrderItemAndShipGrpInvResAndItemSum
orderItem = v;
productId = v.getString("inventoryProductId");
quantity = v.getBigDecimal("totQuantityReserved").setScale(2, BigDecimal.ROUND_HALF_UP);
}
Debug.logInfo("created item display object quantity: " + quantity + " (" + productId + ")", module);
}
public GenericValue getOrderItem() {
return orderItem;
}
public BigDecimal getQuantity() {
return quantity;
}
@Override
public Set<Entry<Object, Object>> entrySet() {
return null;
}
@Override
public Object get(Object name) {
if ("orderItem".equals(name.toString())) {
return orderItem;
} else if ("quantity".equals(name.toString())) {
return quantity;
} else if ("productId".equals(name.toString())) {
return productId;
}
return null;
}
@Override
public boolean equals(Object o) {
if (o instanceof ItemDisplay) {
ItemDisplay d = (ItemDisplay) o;
boolean sameOrderItemProduct = true;
if (d.getOrderItem().getString("productId") != null && orderItem.getString("productId") != null) {
sameOrderItemProduct = d.getOrderItem().getString("productId").equals(orderItem.getString("productId"));
} else if (d.getOrderItem().getString("productId") != null || orderItem.getString("productId") != null) {
sameOrderItemProduct = false;
}
return (d.productId.equals(productId) &&
d.getOrderItem().getString("orderItemSeqId").equals(orderItem.getString("orderItemSeqId")) &&
sameOrderItemProduct);
} else {
return false;
}
}
}
}