/*******************************************************************************
* 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.ofbiz.pos;
import java.io.PrintWriter;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import net.xoetrope.xui.data.XModel;
import net.xoetrope.xui.helper.SwingWorker;
import org.ofbiz.accounting.payment.PaymentGatewayServices;
import org.ofbiz.base.util.Debug;
import org.ofbiz.base.util.GeneralException;
import org.ofbiz.base.util.Log4jLoggerWriter;
import org.ofbiz.base.util.UtilDateTime;
import org.ofbiz.base.util.UtilFormatOut;
import org.ofbiz.base.util.UtilMisc;
import org.ofbiz.base.util.UtilProperties;
import org.ofbiz.base.util.UtilValidate;
import org.ofbiz.base.util.collections.LifoSet;
import org.ofbiz.entity.GenericDelegator;
import org.ofbiz.entity.GenericEntityException;
import org.ofbiz.entity.GenericValue;
import org.ofbiz.entity.util.EntityUtil;
import org.ofbiz.guiapp.xui.XuiSession;
import org.ofbiz.order.shoppingcart.CartItemModifyException;
import org.ofbiz.order.shoppingcart.CheckOutHelper;
import org.ofbiz.order.shoppingcart.ItemNotFoundException;
import org.ofbiz.order.shoppingcart.ShoppingCart;
import org.ofbiz.order.shoppingcart.ShoppingCartItem;
import org.ofbiz.order.shoppinglist.ShoppingListEvents;
import org.ofbiz.pos.component.Journal;
import org.ofbiz.pos.component.Output;
import org.ofbiz.pos.device.DeviceLoader;
import org.ofbiz.pos.screen.LoadSale;
import org.ofbiz.pos.screen.PosScreen;
import org.ofbiz.pos.screen.SaveSale;
import org.ofbiz.product.store.ProductStoreWorker;
import org.ofbiz.service.GenericServiceException;
import org.ofbiz.service.LocalDispatcher;
import org.ofbiz.service.ServiceUtil;
public class PosTransaction implements Serializable {
public static final String module = PosTransaction.class.getName();
public static final int NO_PAYMENT = 0;
public static final int INTERNAL_PAYMENT = 1;
public static final int EXTERNAL_PAYMENT = 2;
private static PrintWriter defaultPrintWriter = new Log4jLoggerWriter(Debug.getLogger(module));
private static PosTransaction currentTx = null;
private static LifoSet savedTx = new LifoSet();
private Locale defaultLocale = Locale.getDefault();
protected XuiSession session = null;
protected ShoppingCart cart = null;
protected CheckOutHelper ch = null;
protected PrintWriter trace = null;
protected GenericValue txLog = null;
protected String productStoreId = null;
protected String transactionId = null;
protected String facilityId = null;
protected String terminalId = null;
protected String currency = null;
protected String orderId = null;
protected String partyId = null;
protected Locale locale = null;
protected boolean isOpen = false;
protected int drawerIdx = 0;
private GenericValue shipAddress = null;
private Map skuDiscounts = new HashMap();
private int cartDiscount = -1;
public PosTransaction(XuiSession session) {
this.session = session;
this.terminalId = session.getId();
this.partyId = "_NA_";
this.trace = defaultPrintWriter;
this.productStoreId = (String) session.getAttribute("productStoreId");
this.facilityId = (String) session.getAttribute("facilityId");
this.currency = (String) session.getAttribute("currency");
this.locale = (Locale) session.getAttribute("locale");
this.cart = new ShoppingCart(session.getDelegator(), productStoreId, locale, currency);
this.ch = new CheckOutHelper(session.getDispatcher(), session.getDelegator(), cart);
cart.setChannelType("POS_SALES_CHANNEL");
cart.setTransactionId(transactionId);
cart.setFacilityId(facilityId);
cart.setTerminalId(terminalId);
if (session.getUserLogin() != null) {
cart.addAdditionalPartyRole(session.getUserLogin().getString("partyId"), "SALES_REP");
}
// setup the TX log
this.transactionId = session.getDelegator().getNextSeqId("PosTerminalLog");
txLog = session.getDelegator().makeValue("PosTerminalLog", null);
txLog.set("posTerminalLogId", this.transactionId);
txLog.set("posTerminalId", terminalId);
txLog.set("transactionId", transactionId);
txLog.set("userLoginId", session.getUserId());
txLog.set("statusId", "POSTX_ACTIVE");
txLog.set("logStartDateTime", UtilDateTime.nowTimestamp());
try {
txLog.create();
} catch (GenericEntityException e) {
Debug.logError(e, "Unable to create TX log - not fatal", module);
}
currentTx = this;
trace("transaction created");
}
public String getUserId() {
return session.getUserId();
}
public int getDrawerNumber() {
return drawerIdx + 1;
}
public void popDrawer() {
DeviceLoader.drawer[drawerIdx].openDrawer();
}
public String getTransactionId() {
return this.transactionId;
}
public String getTerminalId() {
return this.terminalId;
}
public String getFacilityId() {
return this.facilityId;
}
public String getTerminalLogId() {
return txLog.getString("posTerminalLogId");
}
public boolean isOpen() {
if (!this.isOpen) {
GenericValue terminalState = this.getTerminalState();
if (terminalState != null) {
this.isOpen = true;
} else {
this.isOpen = false;
}
}
return this.isOpen;
}
public boolean isEmpty() {
return (cart == null || cart.size() == 0);
}
public List lookupItem(String sku) throws GeneralException {
// first check for the product
GenericValue product = session.getDelegator().findByPrimaryKey("Product", UtilMisc.toMap("productId", sku));
if (product != null) {
return UtilMisc.toList(product);
} else {
// not found; so we move on to GoodIdentification
return session.getDelegator().findByAnd("GoodIdentificationAndProduct",
UtilMisc.toMap("idValue", sku), UtilMisc.toList("productId"));
}
}
public String getOrderId() {
return this.orderId;
}
public double getTaxTotal() {
return cart.getTotalSalesTax();
}
public double getGrandTotal() {
return UtilFormatOut.formatPriceNumber(cart.getGrandTotal()).doubleValue();
}
public int getNumberOfPayments() {
return cart.selectedPayments();
}
public double getPaymentTotal() {
return UtilFormatOut.formatPriceNumber(cart.getPaymentTotal()).doubleValue();
}
public double getTotalDue() {
double grandTotal = this.getGrandTotal();
double paymentAmt = this.getPaymentTotal();
return (grandTotal - paymentAmt);
}
public int size() {
return cart.size();
}
public Map getItemInfo(int index) {
ShoppingCartItem item = cart.findCartItem(index);
Map itemInfo = new HashMap();
itemInfo.put("productId", item.getProductId());
itemInfo.put("description", item.getDescription());
itemInfo.put("quantity", UtilFormatOut.formatQuantity(item.getQuantity()));
itemInfo.put("basePrice", UtilFormatOut.formatPrice(item.getBasePrice()));
itemInfo.put("subtotal", UtilFormatOut.formatPrice(item.getItemSubTotal()));
itemInfo.put("isTaxable", item.taxApplies() ? "T" : " ");
itemInfo.put("adjustments", item.getOtherAdjustments() != 0 ?
UtilFormatOut.formatPrice(item.getOtherAdjustments()) : "");
return itemInfo;
}
public Map getPaymentInfo(int index) {
ShoppingCart.CartPaymentInfo inf = cart.getPaymentInfo(index);
GenericValue infValue = inf.getValueObject(session.getDelegator());
GenericValue paymentPref = null;
try {
Map fields = new HashMap();
fields.put("paymentMethodTypeId", inf.paymentMethodTypeId);
if (inf.paymentMethodId != null) {
fields.put("paymentMethodId", inf.paymentMethodId);
}
fields.put("maxAmount", inf.amount);
fields.put("orderId", this.getOrderId());
List paymentPrefs = session.getDelegator().findByAnd("OrderPaymentPreference", fields);
if (paymentPrefs != null && paymentPrefs.size() > 0) {
Debug.log("Found some prefs - " + paymentPrefs.size(), module);
if (paymentPrefs.size() > 1) {
Debug.logError("Multiple OrderPaymentPreferences found for the same payment method!", module);
} else {
paymentPref = EntityUtil.getFirst(paymentPrefs);
Debug.log("Got the first pref - " + paymentPref, module);
}
} else {
Debug.logError("No OrderPaymentPreference found - " + fields, module);
}
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
Debug.log("PaymentPref - " + paymentPref, module);
Map payInfo = new HashMap();
// locate the auth info
GenericValue authTrans = null;
if (paymentPref != null) {
authTrans = PaymentGatewayServices.getAuthTransaction(paymentPref);
if (authTrans != null) {
payInfo.putAll(authTrans);
String authInfoString = "Ref: " + authTrans.getString("referenceNum") + " Auth: " + authTrans.getString("gatewayCode");
payInfo.put("authInfoString", authInfoString);
} else {
Debug.logError("No Authorization transaction found for payment preference - " + paymentPref, module);
}
} else {
Debug.logError("Payment preference is empty!", module);
return payInfo;
}
Debug.log("AuthTrans - " + authTrans, module);
if ("PaymentMethodType".equals(infValue.getEntityName())) {
payInfo.put("description", infValue.getString("description"));
payInfo.put("payInfo", infValue.getString("description"));
payInfo.put("amount", UtilFormatOut.formatPrice(inf.amount));
} else {
String paymentMethodTypeId = infValue.getString("paymentMethodTypeId");
GenericValue pmt = null;
try {
pmt = infValue.getRelatedOne("PaymentMethodType");
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (pmt != null) {
payInfo.put("description", pmt.getString("description"));
payInfo.put("amount", UtilFormatOut.formatPrice(inf.amount));
}
if ("CREDIT_CARD".equals(paymentMethodTypeId)) {
GenericValue cc = null;
try {
cc = infValue.getRelatedOne("CreditCard");
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
String nameOnCard = cc.getString("firstNameOnCard") + " " + cc.getString("lastNameOnCard");
nameOnCard = nameOnCard.trim();
payInfo.put("nameOnCard", nameOnCard);
String cardNum = cc.getString("cardNumber");
String cardStr = cardNum.substring(0, 2);
cardStr = cardStr + "****";
cardStr = cardStr + cardNum.substring(cardNum.length() - 4);
String expDate = cc.getString("expireDate");
String infoString = cardStr + " " + expDate;
payInfo.put("payInfo", infoString);
payInfo.putAll(cc);
} else if ("GIFT_CARD".equals(paymentMethodTypeId)) {
GenericValue gc = null;
try {
gc = infValue.getRelatedOne("GiftCard");
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
}
}
return payInfo;
}
public double getItemQuantity(String productId) {
trace("request item quantity", productId);
ShoppingCartItem item = cart.findCartItem(productId, null, null, null, 0.00);
if (item != null) {
return item.getQuantity();
} else {
trace("item not found", productId);
return 0;
}
}
public void addItem(String productId, double quantity) throws CartItemModifyException, ItemNotFoundException {
trace("add item", productId + "/" + quantity);
try {
cart.addOrIncreaseItem(productId, null, quantity, null, null, null, null, null, null, null, null, null, null, null, null, session.getDispatcher());
} catch (ItemNotFoundException e) {
trace("item not found", e);
throw e;
} catch (CartItemModifyException e) {
trace("add item error", e);
throw e;
}
}
public void modifyQty(String productId, double quantity) throws CartItemModifyException {
trace("modify item quantity", productId + "/" + quantity);
ShoppingCartItem item = cart.findCartItem(productId, null, null, null, 0.00);
if (item != null) {
try {
item.setQuantity(quantity, session.getDispatcher(), cart, true);
} catch (CartItemModifyException e) {
Debug.logError(e, module);
trace("modify item error", e);
throw e;
}
} else {
trace("item not found", productId);
}
}
public void modifyPrice(String productId, double price) {
trace("modify item price", productId + "/" + price);
ShoppingCartItem item = cart.findCartItem(productId, null, null, null, 0.00);
if (item != null) {
item.setBasePrice(price);
} else {
trace("item not found", productId);
}
}
public void addDiscount(String productId, double discount, boolean percent) {
GenericValue adjustment = session.getDelegator().makeValue("OrderAdjustment", null);
adjustment.set("orderAdjustmentTypeId", "DISCOUNT_ADJUSTMENT");
if (percent) {
adjustment.set("sourcePercentage", new Double(discount * 100));
} else {
adjustment.set("amount", new Double(discount));
}
if (productId != null) {
trace("add item adjustment");
ShoppingCartItem item = cart.findCartItem(productId, null, null, null, 0.00);
Integer itemAdj = (Integer) skuDiscounts.get(productId);
if (itemAdj != null) {
item.removeAdjustment(itemAdj.intValue());
}
int idx = item.addAdjustment(adjustment);
skuDiscounts.put(productId, new Integer(idx));
} else {
trace("add sale adjustment");
if (cartDiscount > -1) {
cart.removeAdjustment(cartDiscount);
}
cartDiscount = cart.addAdjustment(adjustment);
}
}
public void clearDiscounts() {
if (cartDiscount > -1) {
cart.removeAdjustment(cartDiscount);
cartDiscount = -1;
}
if (skuDiscounts.size() > 0) {
Iterator i = skuDiscounts.keySet().iterator();
while (i.hasNext()) {
String productId = (String) i.next();
ShoppingCartItem item = cart.findCartItem(productId, null, null, null, 0.00);
Integer itemAdj = (Integer) skuDiscounts.remove(productId);
if (itemAdj != null) {
item.removeAdjustment(itemAdj.intValue());
}
}
}
}
public void voidItem(String productId) throws CartItemModifyException {
trace("void item", productId);
ShoppingCartItem item = cart.findCartItem(productId, null, null, null, 0.00);
if (item != null) {
try {
int itemIdx = cart.getItemIndex(item);
cart.removeCartItem(itemIdx, session.getDispatcher());
} catch (CartItemModifyException e) {
Debug.logError(e, module);
trace("void item error", productId, e);
throw e;
}
} else {
trace("item not found", productId);
}
}
public void voidSale() {
trace("void sale");
txLog.set("statusId", "POSTX_VOIDED");
txLog.set("itemCount", new Long(cart.size()));
txLog.set("logEndDateTime", UtilDateTime.nowTimestamp());
try {
txLog.store();
} catch (GenericEntityException e) {
Debug.logError(e, "Unable to store TX log - not fatal", module);
}
cart.clear();
currentTx = null;
}
public void closeTx() {
trace("transaction closed");
txLog.set("statusId", "POSTX_CLOSED");
txLog.set("itemCount", new Long(cart.size()));
txLog.set("logEndDateTime", UtilDateTime.nowTimestamp());
try {
txLog.store();
} catch (GenericEntityException e) {
Debug.logError(e, "Unable to store TX log - not fatal", module);
}
cart.clear();
currentTx = null;
}
public void paidInOut(String type) {
trace("paid " + type);
txLog.set("statusId", "POSTX_PAID_" + type);
txLog.set("logEndDateTime", UtilDateTime.nowTimestamp());
try {
txLog.store();
} catch (GenericEntityException e) {
Debug.logError(e, "Unable to store TX log - not fatal", module);
}
currentTx = null;
}
public void calcTax() {
try {
ch.calcAndAddTax(this.getStoreOrgAddress());
} catch (GeneralException e) {
Debug.logError(e, module);
}
}
public void clearTax() {
cart.removeAdjustmentByType("SALES_TAX");
}
public int checkPaymentMethodType(String paymentMethodTypeId) {
Map fields = UtilMisc.toMap("paymentMethodTypeId", paymentMethodTypeId, "productStoreId", productStoreId);
List values = null;
try {
values = session.getDelegator().findByAndCache("ProductStorePaymentSetting", fields);
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
final String externalCode = "PRDS_PAY_EXTERNAL";
if (UtilValidate.isEmpty(values)) {
return NO_PAYMENT;
} else {
boolean isExternal = true;
Iterator i = values.iterator();
while (i.hasNext() && isExternal) {
GenericValue v = (GenericValue) i.next();
Debug.log("Testing [" + paymentMethodTypeId + "] - " + v, module);
if (!externalCode.equals(v.getString("paymentServiceTypeEnumId"))) {
isExternal = false;
}
}
if (isExternal) {
return EXTERNAL_PAYMENT;
} else {
return INTERNAL_PAYMENT;
}
}
}
public double addPayment(String id, double amount) {
return this.addPayment(id, amount, null, null);
}
public double addPayment(String id, double amount, String refNum, String authCode) {
trace("added payment", id + "/" + amount);
if ("CASH".equals(id)) {
// clear cash payments first; so there is only one
cart.clearPayment(id);
}
cart.addPaymentAmount(id, new Double(amount), refNum, authCode, true, true, false);
return this.getTotalDue();
}
public void setPaymentRefNum(int paymentIndex, String refNum, String authCode) {
trace("setting payment index reference number", paymentIndex + " / " + refNum + " / " + authCode);
ShoppingCart.CartPaymentInfo inf = cart.getPaymentInfo(paymentIndex);
inf.refNum[0] = refNum;
inf.refNum[1] = authCode;
}
public void clearPayments() {
trace("all payments cleared from sale");
cart.clearPayments();
}
public void clearPayment(int index) {
trace("removing payment", "" + index);
cart.clearPayment(index);
}
public void clearPayment(String id) {
trace("removing payment", id);
cart.clearPayment(id);
}
public int selectedPayments() {
return cart.selectedPayments();
}
public void setTxAsReturn(String returnId) {
trace("returned sale");
txLog.set("statusId", "POSTX_RETURNED");
txLog.set("returnId", returnId);
txLog.set("logEndDateTime", UtilDateTime.nowTimestamp());
try {
txLog.store();
} catch (GenericEntityException e) {
Debug.logError(e, "Unable to store TX log - not fatal", module);
}
cart.clear();
currentTx = null;
}
public double processSale(Output output) throws GeneralException {
trace("process sale");
double grandTotal = this.getGrandTotal();
double paymentAmt = this.getPaymentTotal();
if (grandTotal > paymentAmt) {
throw new IllegalStateException();
}
// attach the party ID to the cart
cart.setOrderPartyId(partyId);
// validate payment methods
output.print(UtilProperties.getMessage("pos","Validating",defaultLocale));
Map valRes = ch.validatePaymentMethods();
if (valRes != null && ServiceUtil.isError(valRes)) {
throw new GeneralException(ServiceUtil.getErrorMessage(valRes));
}
// store the "order"
output.print(UtilProperties.getMessage("pos","Saving",defaultLocale));
Map orderRes = ch.createOrder(session.getUserLogin());
Debug.log("Create Order Resp : " + orderRes, module);
if (orderRes != null && ServiceUtil.isError(orderRes)) {
throw new GeneralException(ServiceUtil.getErrorMessage(orderRes));
} else if (orderRes != null) {
this.orderId = (String) orderRes.get("orderId");
}
// process the payment(s)
output.print(UtilProperties.getMessage("pos","Processing",defaultLocale));
Map payRes = null;
try {
payRes = ch.processPayment(ProductStoreWorker.getProductStore(productStoreId, session.getDelegator()), session.getUserLogin(), true);
} catch (GeneralException e) {
Debug.logError(e, module);
throw e;
}
if (payRes != null && ServiceUtil.isError(payRes)) {
throw new GeneralException(ServiceUtil.getErrorMessage(payRes));
}
// get the change due
double change = (grandTotal - paymentAmt);
// notify the change due
output.print(UtilProperties.getMessage("pos","CHANGE",defaultLocale) + " " + UtilFormatOut.formatPrice(this.getTotalDue() * -1));
// threaded drawer/receipt printing
final PosTransaction currentTrans = this;
final SwingWorker worker = new SwingWorker() {
public Object construct() {
// open the drawer
currentTrans.popDrawer();
// print the receipt
DeviceLoader.receipt.printReceipt(currentTrans, true);
return null;
}
};
worker.start();
// save the TX Log
txLog.set("statusId", "POSTX_SOLD");
txLog.set("orderId", orderId);
txLog.set("itemCount", new Long(cart.size()));
txLog.set("logEndDateTime", UtilDateTime.nowTimestamp());
try {
txLog.store();
} catch (GenericEntityException e) {
Debug.logError(e, "Unable to store TX log - not fatal", module);
}
// clear the tx
currentTx = null;
return change;
}
private synchronized GenericValue getStoreOrgAddress() {
if (this.shipAddress == null) {
// locate the store's physical address - use this for tax
GenericValue facility = (GenericValue) session.getAttribute("facility");
if (facility == null) {
return null;
}
List fcp = null;
try {
fcp = facility.getRelatedByAnd("FacilityContactMechPurpose", UtilMisc.toMap("contactMechPurposeTypeId", "SHIP_ORIG_LOCATION"));
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
fcp = EntityUtil.filterByDate(fcp);
GenericValue purp = EntityUtil.getFirst(fcp);
if (purp != null) {
try {
this.shipAddress = session.getDelegator().findByPrimaryKey("PostalAddress",
UtilMisc.toMap("contactMechId", purp.getString("contactMechId")));
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
}
}
return this.shipAddress;
}
public void saveTx() {
savedTx.push(this);
currentTx = null;
trace("transaction saved");
}
public void appendItemDataModel(XModel model) {
if (cart != null) {
Iterator i = cart.iterator();
while (i.hasNext()) {
ShoppingCartItem item = (ShoppingCartItem) i.next();
double quantity = item.getQuantity();
double unitPrice = item.getBasePrice();
double subTotal = unitPrice * quantity;
double adjustment = item.getOtherAdjustments();
XModel line = Journal.appendNode(model, "tr", "", "");
Journal.appendNode(line, "td", "sku", item.getProductId());
Journal.appendNode(line, "td", "desc", item.getName());
Journal.appendNode(line, "td", "qty", UtilFormatOut.formatQuantity(quantity));
Journal.appendNode(line, "td", "price", UtilFormatOut.formatPrice(subTotal));
Journal.appendNode(line, "td", "index", Integer.toString(cart.getItemIndex(item)));
if (adjustment != 0) {
// append the promo info
XModel promo = Journal.appendNode(model, "tr", "", "");
Journal.appendNode(promo, "td", "sku", "");
Journal.appendNode(promo, "td", "desc", UtilProperties.getMessage("pos","(adjustment)",defaultLocale));
Journal.appendNode(promo, "td", "qty", "-");
Journal.appendNode(promo, "td", "price", UtilFormatOut.formatPrice(adjustment));
}
}
}
}
public void appendTotalDataModel(XModel model) {
if (cart != null) {
double taxAmount = cart.getTotalSalesTax();
double total = cart.getGrandTotal();
XModel taxLine = Journal.appendNode(model, "tr", "", "");
Journal.appendNode(taxLine, "td", "sku", "");
Journal.appendNode(taxLine, "td", "desc", UtilProperties.getMessage("pos","Sales_Tax",defaultLocale));
Journal.appendNode(taxLine, "td", "qty", "-");
Journal.appendNode(taxLine, "td", "price", UtilFormatOut.formatPrice(taxAmount));
XModel totalLine = Journal.appendNode(model, "tr", "", "");
Journal.appendNode(totalLine, "td", "sku", "");
Journal.appendNode(totalLine, "td", "desc", UtilProperties.getMessage("pos","Grand_Total",defaultLocale));
Journal.appendNode(totalLine, "td", "qty", "-");
Journal.appendNode(totalLine, "td", "price", UtilFormatOut.formatPrice(total));
}
}
public void appendPaymentDataModel(XModel model) {
if (cart != null) {
int paymentInfoSize = cart.selectedPayments();
for (int i = 0; i < paymentInfoSize; i++) {
ShoppingCart.CartPaymentInfo inf = cart.getPaymentInfo(i);
GenericValue paymentInfoObj = inf.getValueObject(session.getDelegator());
GenericValue paymentMethodType = null;
GenericValue paymentMethod = null;
if ("PaymentMethod".equals(paymentInfoObj.getEntityName())) {
paymentMethod = paymentInfoObj;
try {
paymentMethodType = paymentMethod.getRelatedOne("PaymentMethodType");
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
} else {
paymentMethodType = paymentInfoObj;
}
Object desc = paymentMethodType != null ? paymentMethodType.get("description",defaultLocale) : "??";
String descString = desc.toString();
double amount = 0;
if (inf.amount == null) {
amount = cart.getGrandTotal() - cart.getPaymentTotal();
} else {
amount = inf.amount.doubleValue();
}
XModel paymentLine = Journal.appendNode(model, "tr", "", "");
Journal.appendNode(paymentLine, "td", "sku", "");
Journal.appendNode(paymentLine, "td", "desc", descString);
Journal.appendNode(paymentLine, "td", "qty", "-");
Journal.appendNode(paymentLine, "td", "price", UtilFormatOut.formatPrice(-1 * amount));
Journal.appendNode(paymentLine, "td", "index", Integer.toString(i));
}
}
}
public void appendChangeDataModel(XModel model) {
if (cart != null) {
double changeDue = (-1 * this.getTotalDue());
if (changeDue >= 0) {
XModel changeLine = Journal.appendNode(model, "tr", "", "");
Journal.appendNode(changeLine, "td", "sku", "");
Journal.appendNode(changeLine, "td", "desc", "Change");
Journal.appendNode(changeLine, "td", "qty", "-");
Journal.appendNode(changeLine, "td", "price", UtilFormatOut.formatPrice(changeDue));
}
}
}
public String makeCreditCardVo(String cardNumber, String expDate, String firstName, String lastName) {
LocalDispatcher dispatcher = session.getDispatcher();
String expMonth = expDate.substring(0, 2);
String expYear = expDate.substring(2);
// two digit year check -- may want to re-think this
if (expYear.length() == 2) {
expYear = "20" + expYear;
}
Map svcCtx = new HashMap();
svcCtx.put("userLogin", session.getUserLogin());
svcCtx.put("partyId", partyId);
svcCtx.put("cardNumber", cardNumber);
svcCtx.put("firstNameOnCard", firstName == null ? "" : firstName);
svcCtx.put("lastNameOnCard", lastName == null ? "" : lastName);
svcCtx.put("expMonth", expMonth);
svcCtx.put("expYear", expYear);
svcCtx.put("cardType", UtilValidate.getCardType(cardNumber));
Debug.log("Create CC : " + svcCtx, module);
Map svcRes = null;
try {
svcRes = dispatcher.runSync("createCreditCard", svcCtx);
} catch (GenericServiceException e) {
Debug.logError(e, module);
return null;
}
if (ServiceUtil.isError(svcRes)) {
Debug.logError(ServiceUtil.getErrorMessage(svcRes) + " - " + svcRes, module);
return null;
} else {
return (String) svcRes.get("paymentMethodId");
}
}
public GenericValue getTerminalState() {
GenericDelegator delegator = session.getDelegator();
List states = null;
try {
states = delegator.findByAnd("PosTerminalState", UtilMisc.toMap("posTerminalId", this.getTerminalId()));
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
states = EntityUtil.filterByDate(states, UtilDateTime.nowTimestamp(), "openedDate", "closedDate", true);
return EntityUtil.getFirst(states);
}
public void setPrintWriter(PrintWriter writer) {
this.trace = writer;
}
private void trace(String s) {
trace(s, null, null);
}
private void trace(String s, Throwable t) {
trace(s, null, t);
}
private void trace(String s1, String s2) {
trace(s1, s2, null);
}
private void trace(String s1, String s2, Throwable t) {
if (trace != null) {
String msg = s1;
if (UtilValidate.isNotEmpty(s2)) {
msg = msg + "(" + s2 + ")";
}
if (t != null) {
msg = msg + " : " + t.getMessage();
}
// print the trace line
trace.println("[POS @ " + terminalId + " TX:" + transactionId + "] - " + msg);
trace.flush();
}
}
public static synchronized PosTransaction getCurrentTx(XuiSession session) {
if (currentTx == null) {
if (session.getUserLogin() != null) {
currentTx = new PosTransaction(session);
}
}
return currentTx;
}
public void loadSale(PosScreen pos) {
List shoppingLists = createShoppingLists();
if (!shoppingLists.isEmpty()) {
Hashtable salesMap = createSalesMap(shoppingLists);
if (!salesMap.isEmpty()) {
LoadSale loadSale = new LoadSale(salesMap, this, pos);
loadSale.openDlg();
}
else {
pos.showDialog("dialog/error/nosales");
}
} else {
pos.showDialog("dialog/error/nosales");
}
}
public List createShoppingLists() {
List shoppingLists = null;
GenericDelegator delegator = this.session.getDelegator();
try {
shoppingLists = delegator.findAll("ShoppingList");
} catch (GenericEntityException e) {
Debug.logError(e, module);
ServiceUtil.returnError("Error running initLowLevelCode: " + e.getMessage());
}
if (shoppingLists == null) {
Debug.log(UtilProperties.getMessage("EcommerceUiLabels","EcommerceNoShoppingListsCreate",locale), module);
}
return shoppingLists;
}
public Hashtable createSalesMap(List shoppingLists) {
Hashtable salesMap = new Hashtable();
Iterator i = shoppingLists.iterator();
while (i.hasNext()){
GenericValue shoppingList = (GenericValue) i.next();
List items = null;
try {
items = shoppingList.getRelated("ShoppingListItem", UtilMisc.toList("shoppingListItemSeqId"));
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (UtilValidate.isNotEmpty(items)) {
String listName = shoppingList.getString("listName");
String shoppingListId = shoppingList.getString("shoppingListId");
salesMap.put(shoppingListId, listName);
}
}
return salesMap;
}
public boolean addListToCart(String shoppingListId, PosScreen pos, boolean append) {
GenericDelegator delegator = session.getDelegator();
LocalDispatcher dispatcher = session.getDispatcher();
String includeChild = null; // Perhaps will be used later ...
String prodCatalogId = null;
try {
ShoppingListEvents.addListToCart(delegator, dispatcher, cart, prodCatalogId, shoppingListId, (includeChild != null), true, append);
} catch (IllegalArgumentException e) {
Debug.logError(e, module);
pos.showDialog("dialog/error/exception", e.getMessage());
return false;
}
return true;
}
public boolean clearList(String shoppingListId, PosScreen pos) {
GenericDelegator delegator = session.getDelegator();
try {
ShoppingListEvents.clearListInfo(delegator, shoppingListId);
} catch (GenericEntityException e) {
Debug.logError(e, module);
pos.showDialog("dialog/error/exception", e.getMessage());
return false;
}
return true;
}
public void saveSale(PosScreen pos) {
SaveSale SaveSale = new SaveSale(this, pos);
SaveSale.openDlg();
}
public void saveSale(String shoppingListName, PosScreen pos) {
if (cart.size() == 0 ) {
pos.showDialog("dialog/error/exception", UtilProperties.getMessage("OrderErrorUiLabels", "OrderUnableToCreateNewShoppingList",locale));
return;
}
GenericDelegator delegator = this.session.getDelegator();
LocalDispatcher dispatcher = session.getDispatcher();
GenericValue userLogin = session.getUserLogin();
Locale locale = defaultLocale;
String shoppingListId = null;
if (!UtilValidate.isEmpty(shoppingListName)) {
// create a new shopping list with partyId = user connected (POS clerk, etc.) and not buyer (_NA_ in POS)
Map serviceCtx = UtilMisc.toMap("userLogin", session.getUserLogin(), "partyId", session.getUserPartyId(),
"productStoreId", productStoreId, "listName", shoppingListName);
serviceCtx.put("shoppingListTypeId", "SLT_SPEC_PURP");
Map newListResult = null;
try {
newListResult = dispatcher.runSync("createShoppingList", serviceCtx);
} catch (GenericServiceException e) {
Debug.logError(e, "Problem while creating new ShoppingList", module);
pos.showDialog("dialog/error/exception", UtilProperties.getMessage("OrderErrorUiLabels", "OrderUnableToCreateNewShoppingList",locale));
return;
}
// check for errors
if (ServiceUtil.isError(newListResult)) {
String error = ServiceUtil.getErrorMessage(newListResult);
Debug.logError(error, module);
pos.showDialog("dialog/error/exception", error);
return;
}
// get the new list id
if (newListResult != null) {
shoppingListId = (String) newListResult.get("shoppingListId");
} else {
Debug.logError("Problem while creating new ShoppingList", module);
pos.showDialog("dialog/error/exception", UtilProperties.getMessage("OrderErrorUiLabels", "OrderUnableToCreateNewShoppingList",locale));
return;
}
}
String selectedCartItems[] = new String[cart.size()];
for(int i = 0; i < cart.size(); i++) {
Integer integer = new Integer(i);
selectedCartItems[i] = integer.toString();
}
try {
ShoppingListEvents.addBulkFromCart(delegator, dispatcher, cart, userLogin, shoppingListId, selectedCartItems, true, true);
} catch (IllegalArgumentException e) {
Debug.logError(e, "Problem while creating new ShoppingList", module);
pos.showDialog("dialog/error/exception", UtilProperties.getMessage("OrderErrorUiLabels", "OrderUnableToCreateNewShoppingList",locale));
}
}
}