/*******************************************************************************
* 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.verify;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.GeneralException;
import org.apache.ofbiz.base.util.UtilMisc;
import org.apache.ofbiz.base.util.UtilProperties;
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.service.LocalDispatcher;
import org.apache.ofbiz.service.ServiceContainer;
import org.apache.ofbiz.service.ServiceUtil;
@SuppressWarnings("serial")
public class VerifyPickSession implements Serializable {
public static final String module = VerifyPickSession.class.getName();
protected GenericValue userLogin = null;
protected String dispatcherName = null;
protected String delegatorName = null;
protected String picklistBinId = null;
protected String facilityId = null;
protected List<VerifyPickSessionRow> pickRows = null;
private transient Delegator _delegator = null;
private transient LocalDispatcher _dispatcher = null;
private static BigDecimal ZERO = BigDecimal.ZERO;
public VerifyPickSession() {
}
public VerifyPickSession(LocalDispatcher dispatcher, GenericValue userLogin) {
this._dispatcher = dispatcher;
this.dispatcherName = dispatcher.getName();
this._delegator = _dispatcher.getDelegator();
this.delegatorName = _delegator.getDelegatorName();
this.userLogin = userLogin;
this.pickRows = new LinkedList<VerifyPickSessionRow>();
}
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 void createRow(String orderId, String orderItemSeqId, String shipGroupSeqId, String productId, String originGeoId, BigDecimal quantity, Locale locale) throws GeneralException {
if (orderItemSeqId == null && productId != null) {
orderItemSeqId = this.findOrderItemSeqId(productId, orderId, shipGroupSeqId, quantity, locale);
}
// get the reservations for the item
Map<String, Object> inventoryLookupMap = new HashMap<String, Object>();
inventoryLookupMap.put("orderId", orderId);
inventoryLookupMap.put("orderItemSeqId", orderItemSeqId);
inventoryLookupMap.put("shipGroupSeqId", shipGroupSeqId);
List<GenericValue> reservations = this.getDelegator().findByAnd("OrderItemShipGrpInvRes", inventoryLookupMap, UtilMisc.toList("quantity DESC"), false);
// no reservations we cannot add this item
if (UtilValidate.isEmpty(reservations)) {
throw new GeneralException(UtilProperties.getMessage("ProductErrorUiLabels", "ProductErrorNoInventoryReservationsAvailableCannotVerifyThisItem", locale));
}
if (reservations.size() == 1) {
GenericValue reservation = EntityUtil.getFirst(reservations);
int checkCode = this.checkRowForAdd(reservation, orderId, orderItemSeqId, shipGroupSeqId, productId, quantity);
this.createVerifyPickRow(checkCode, reservation, orderId, orderItemSeqId, shipGroupSeqId, productId, originGeoId, quantity, locale);
} else {
// more than one reservation found
Map<GenericValue, BigDecimal> reserveQtyMap = new HashMap<GenericValue, BigDecimal>();
BigDecimal qtyRemain = quantity;
for (GenericValue reservation : reservations) {
if (qtyRemain.compareTo(ZERO) > 0) {
if (!productId.equals(reservation.getRelatedOne("InventoryItem", false).getString("productId"))) {
continue;
}
BigDecimal reservedQty = reservation.getBigDecimal("quantity");
BigDecimal resVerifiedQty = this.getVerifiedQuantity(orderId, orderItemSeqId, shipGroupSeqId, productId, reservation.getString("inventoryItemId"));
if (resVerifiedQty.compareTo(reservedQty) >= 0) {
continue;
} else {
reservedQty = reservedQty.subtract(resVerifiedQty);
}
BigDecimal thisQty = reservedQty.compareTo(qtyRemain) > 0 ? qtyRemain : reservedQty;
int thisCheck = this.checkRowForAdd(reservation, orderId, orderItemSeqId, shipGroupSeqId, productId, thisQty);
switch (thisCheck) {
case 2:
// new verify pick row will be created
reserveQtyMap.put(reservation, thisQty);
qtyRemain = qtyRemain.subtract(thisQty);
break;
case 1:
// existing verify pick row has been updated
qtyRemain = qtyRemain.subtract(thisQty);
break;
case 0:
//doing nothing
break;
}
}
}
if (qtyRemain.compareTo(ZERO) == 0) {
for (Map.Entry<GenericValue, BigDecimal> entry : reserveQtyMap.entrySet()) {
GenericValue reservation = entry.getKey();
BigDecimal qty = entry.getValue();
this.createVerifyPickRow(2, reservation, orderId, orderItemSeqId, shipGroupSeqId, productId, originGeoId, qty, locale);
}
} else {
throw new GeneralException(UtilProperties.getMessage("ProductErrorUiLabels", "ProductErrorNotEnoughInventoryReservationAvailableCannotVerifyTheItem", locale));
}
}
}
protected String findOrderItemSeqId(String productId, String orderId, String shipGroupSeqId, BigDecimal quantity, Locale locale) throws GeneralException {
Map<String, Object> orderItemLookupMap = new HashMap<String, Object>();
orderItemLookupMap.put("orderId", orderId);
orderItemLookupMap.put("productId", productId);
orderItemLookupMap.put("statusId", "ITEM_APPROVED");
orderItemLookupMap.put("shipGroupSeqId", shipGroupSeqId);
List<GenericValue> orderItems = this.getDelegator().findByAnd("OrderItemAndShipGroupAssoc", orderItemLookupMap, null, false);
String orderItemSeqId = null;
if (orderItems != null) {
for (GenericValue orderItem : orderItems) {
// get the reservations for the item
Map<String, Object> inventoryLookupMap = new HashMap<String, Object>();
inventoryLookupMap.put("orderId", orderId);
inventoryLookupMap.put("orderItemSeqId", orderItem.getString("orderItemSeqId"));
inventoryLookupMap.put("shipGroupSeqId", shipGroupSeqId);
List<GenericValue> reservations = this.getDelegator().findByAnd("OrderItemShipGrpInvRes", inventoryLookupMap, null, false);
for (GenericValue reservation : reservations) {
BigDecimal qty = reservation.getBigDecimal("quantity");
if (quantity.compareTo(qty) <= 0) {
orderItemSeqId = orderItem.getString("orderItemSeqId");
break;
}
}
}
}
if (orderItemSeqId != null) {
return orderItemSeqId;
} else {
throw new GeneralException(UtilProperties.getMessage("ProductErrorUiLabels", "ProductErrorNoValidOrderItemFoundForProductWithEnteredQuantity", UtilMisc.toMap("productId", productId, "quantity", quantity), locale));
}
}
protected int checkRowForAdd(GenericValue reservation, String orderId, String orderItemSeqId, String shipGroupSeqId, String productId, BigDecimal quantity) {
// check to see if the reservation can hold the requested quantity amount
String inventoryItemId = reservation.getString("inventoryItemId");
BigDecimal resQty = reservation.getBigDecimal("quantity");
VerifyPickSessionRow pickRow = this.getPickRow(orderId, orderItemSeqId, shipGroupSeqId, productId, inventoryItemId);
if (pickRow == null) {
if (resQty.compareTo(quantity) < 0) {
return 0;
} else {
return 2;
}
} else {
BigDecimal newQty = pickRow.getReadyToVerifyQty().add(quantity);
if (resQty.compareTo(newQty) < 0) {
return 0;
} else {
pickRow.setReadyToVerifyQty(newQty);
return 1;
}
}
}
protected void createVerifyPickRow(int checkCode, GenericValue res, String orderId, String orderItemSeqId, String shipGroupSeqId, String productId, String originGeoId,BigDecimal quantity, Locale locale) throws GeneralException {
// process the result; add new item if necessary
switch (checkCode) {
case 0:
// not enough reserved
throw new GeneralException(UtilProperties.getMessage("ProductErrorUiLabels", "ProductErrorNotEnoughInventoryReservationAvailableCannotVerifyTheItem", locale));
case 1:
// we're all good to go; quantity already updated
break;
case 2:
// need to create a new item
String inventoryItemId = res.getString("inventoryItemId");
pickRows.add(new VerifyPickSessionRow(orderId, orderItemSeqId, shipGroupSeqId, productId, originGeoId, inventoryItemId, quantity));
break;
}
}
public GenericValue getUserLogin() {
return this.userLogin;
}
public void setFacilityId(String facilityId) {
this.facilityId = facilityId;
}
public String getFacilityId() {
return this.facilityId;
}
public void setPicklistBinId(String setPicklistBinId) {
this.picklistBinId = setPicklistBinId;
}
public String getPicklistBinId() {
return this.picklistBinId;
}
public List<VerifyPickSessionRow> getPickRows() {
return this.pickRows;
}
public List<VerifyPickSessionRow> getPickRows(String orderId) {
List<VerifyPickSessionRow> pickVerifyRows = new LinkedList<VerifyPickSessionRow>();
for (VerifyPickSessionRow line: this.getPickRows()) {
if (orderId.equals(line.getOrderId())) {
pickVerifyRows.add(line);
}
}
return pickVerifyRows;
}
public BigDecimal getReadyToVerifyQuantity(String orderId, String orderSeqId) throws GeneralException {
BigDecimal readyToVerifyQty = BigDecimal.ZERO;
for (VerifyPickSessionRow line: this.getPickRows()) {
if ((orderId.equals(line.getOrderId())) && (orderSeqId.equals(line.getOrderItemSeqId()))) {
readyToVerifyQty = readyToVerifyQty.add(line.getReadyToVerifyQty());
}
}
return readyToVerifyQty;
}
public VerifyPickSessionRow getPickRow(String orderId, String orderItemSeqId, String shipGroupSeqId, String productId, String inventoryItemId) {
for (VerifyPickSessionRow line : this.getPickRows(orderId)) {
if (orderItemSeqId.equals(line.getOrderItemSeqId()) && shipGroupSeqId.equals(line.getShipGroupSeqId())
&& productId.equals(line.getProductId()) && inventoryItemId.equals(line.getInventoryItemId())) {
return line;
}
}
return null;
}
public BigDecimal getVerifiedQuantity(String orderId, String orderItemSeqId, String shipGroupSeqId, String productId, String inventoryItemId) {
BigDecimal total = ZERO;
for (VerifyPickSessionRow pickRow : this.getPickRows(orderId)) {
if (orderItemSeqId.equals(pickRow.getOrderItemSeqId()) && shipGroupSeqId.equals(pickRow.getShipGroupSeqId()) && productId.equals(pickRow.getProductId())) {
if (inventoryItemId == null || inventoryItemId.equals(pickRow.getInventoryItemId())) {
total = total.add(pickRow.getReadyToVerifyQty());
}
}
}
return total;
}
public void clearAllRows() {
this.pickRows.clear();
}
public String complete(String orderId, Locale locale) throws GeneralException {
this.checkVerifiedQty(orderId, locale);
// check reserved quantity, it should be equal to verified quantity
this.checkReservedQty(orderId, locale);
String shipmentId = this.createShipment((this.getPickRows(orderId)).get(0));
this.issueItemsToShipment(shipmentId, locale);
this.updateProduct();
// Update the shipment status to Picked, this will trigger createInvoicesFromShipment and finally a invoice will be created
Map<String, Object> updateShipmentCtx = new HashMap<String, Object>();
updateShipmentCtx.put("shipmentId", shipmentId);
updateShipmentCtx.put("statusId", "SHIPMENT_PICKED");
updateShipmentCtx.put("userLogin", this.getUserLogin());
this.getDispatcher().runSync("updateShipment", updateShipmentCtx);
return shipmentId;
}
protected void checkReservedQty(String orderId, Locale locale) throws GeneralException {
List<String> errorList = new LinkedList<String>();
for (VerifyPickSessionRow pickRow : this.getPickRows(orderId)) {
BigDecimal reservedQty = this.getReservedQty(pickRow.getOrderId(), pickRow.getOrderItemSeqId(), pickRow.getShipGroupSeqId());
BigDecimal verifiedQty = this.getReadyToVerifyQuantity(pickRow.getOrderId(), pickRow.getOrderItemSeqId());
if (verifiedQty.compareTo(reservedQty) != 0) {
errorList.add(UtilProperties.getMessage("ProductErrorUiLabels", "ProductErrorVerifiedQtyDoesNotMatchTheReservedQtyForItem", UtilMisc.toMap("productId", pickRow.getProductId(), "verifiedQty", pickRow.getReadyToVerifyQty(), "reservedQty", reservedQty), locale));
}
}
if (errorList.size() > 0) {
throw new GeneralException(UtilProperties.getMessage("OrderErrorUiLabels", "OrderErrorAttemptToVerifyOrderFailed", UtilMisc.toMap("orderId", orderId), locale), errorList);
}
}
public BigDecimal getReservedQty(String orderId, String orderItemSeqId, String shipGroupSeqId) {
BigDecimal reservedQty = ZERO;
try {
GenericValue reservation = EntityUtil.getFirst(this.getDelegator().findByAnd("OrderItemAndShipGrpInvResAndItemSum", UtilMisc.toMap("orderId", orderId, "orderItemSeqId", orderItemSeqId, "shipGroupSeqId", shipGroupSeqId), null, false));
reservedQty = reservation.getBigDecimal("totQuantityAvailable");
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
return reservedQty;
}
protected void checkVerifiedQty(String orderId, Locale locale) throws GeneralException {
BigDecimal verifiedQty = ZERO;
BigDecimal orderedQty = ZERO;
List<GenericValue> orderItems = this.getDelegator().findByAnd("OrderItem", UtilMisc.toMap("orderId", orderId, "statusId", "ITEM_APPROVED"), null, false);
for (GenericValue orderItem : orderItems) {
orderedQty = orderedQty.add(orderItem.getBigDecimal("quantity"));
}
for (VerifyPickSessionRow pickRow : this.getPickRows(orderId)) {
verifiedQty = verifiedQty.add(pickRow.getReadyToVerifyQty());
}
if (orderedQty.compareTo(verifiedQty) != 0) {
throw new GeneralException(UtilProperties.getMessage("ProductErrorUiLabels", "ProductErrorAllOrderItemsAreNotVerified", locale));
}
}
protected void issueItemsToShipment(String shipmentId, Locale locale) throws GeneralException {
List<VerifyPickSessionRow> processedRows = new LinkedList<VerifyPickSessionRow>();
for (VerifyPickSessionRow pickRow : this.getPickRows()) {
if (this.checkLine(processedRows, pickRow)) {
BigDecimal totalVerifiedQty = this.getVerifiedQuantity(pickRow.getOrderId(), pickRow.getOrderItemSeqId(), pickRow.getShipGroupSeqId(), pickRow.getProductId(), pickRow.getInventoryItemId());
pickRow.issueItemToShipment(shipmentId, picklistBinId, userLogin, totalVerifiedQty, getDispatcher(), locale);
processedRows.add(pickRow);
}
}
}
protected boolean checkLine(List<VerifyPickSessionRow> processedRows, VerifyPickSessionRow pickrow) {
for (VerifyPickSessionRow processedRow : processedRows) {
if (pickrow.isSameItem(processedRow)) {
pickrow.setShipmentItemSeqId(processedRow.getShipmentItemSeqId());
return false;
}
}
return true;
}
protected String createShipment(VerifyPickSessionRow line) throws GeneralException {
Delegator delegator = this.getDelegator();
String orderId = line.getOrderId();
Map<String, Object> newShipment = new HashMap<String, Object>();
newShipment.put("originFacilityId", facilityId);
newShipment.put("primaryShipGroupSeqId", line.getShipGroupSeqId());
newShipment.put("primaryOrderId", orderId);
newShipment.put("shipmentTypeId", "OUTGOING_SHIPMENT");
newShipment.put("statusId", "SHIPMENT_SCHEDULED");
newShipment.put("userLogin", this.getUserLogin());
GenericValue orderRoleShipTo = EntityQuery.use(delegator).from("OrderRole").where("orderId", orderId, "roleTypeId", "SHIP_TO_CUSTOMER").queryFirst();
if (UtilValidate.isNotEmpty(orderRoleShipTo)) {
newShipment.put("partyIdTo", orderRoleShipTo.getString("partyId"));
}
String partyIdFrom = null;
GenericValue orderItemShipGroup = EntityQuery.use(delegator).from("OrderItemShipGroup").where("orderId", orderId, "shipGroupSeqId", line.getShipGroupSeqId()).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", orderId, "roleTypeId", "SHIP_FROM_VENDOR").queryFirst();
if (UtilValidate.isNotEmpty(orderRoleShipFrom)) {
partyIdFrom = orderRoleShipFrom.getString("partyId");
} else {
orderRoleShipFrom = EntityQuery.use(delegator).from("OrderRole").where("orderId", orderId, "roleTypeId", "BILL_FROM_VENDOR").queryFirst();
partyIdFrom = orderRoleShipFrom.getString("partyId");
}
}
newShipment.put("partyIdFrom", partyIdFrom);
Map<String, Object> newShipResp = this.getDispatcher().runSync("createShipment", newShipment);
if (ServiceUtil.isError(newShipResp)) {
throw new GeneralException(ServiceUtil.getErrorMessage(newShipResp));
}
String shipmentId = (String) newShipResp.get("shipmentId");
return shipmentId;
}
protected void updateProduct() throws GeneralException {
for (VerifyPickSessionRow pickRow : this.getPickRows()) {
if (UtilValidate.isNotEmpty(pickRow.getOriginGeoId())) {
Map<String, Object> updateProductCtx = new HashMap<String, Object>();
updateProductCtx.put("originGeoId", pickRow.getOriginGeoId());
updateProductCtx.put("productId", pickRow.getProductId());
updateProductCtx.put("userLogin", this.getUserLogin());
Map<String, Object> result = this.getDispatcher().runSync("updateProduct", updateProductCtx);
if (ServiceUtil.isError(result)) {
throw new GeneralException(ServiceUtil.getErrorMessage(result));
}
}
}
}
}