| /******************************************************************************* |
| * 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.event; |
| |
| import java.util.List; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.sql.Timestamp; |
| import java.util.Locale; |
| import java.text.DecimalFormat; |
| import java.text.ParseException; |
| |
| import net.xoetrope.xui.XProjectManager; |
| |
| import org.ofbiz.base.util.cache.UtilCache; |
| import org.ofbiz.base.util.Debug; |
| import org.ofbiz.base.util.UtilMisc; |
| import org.ofbiz.base.util.UtilDateTime; |
| import org.ofbiz.base.util.UtilFormatOut; |
| import org.ofbiz.base.util.UtilValidate; |
| import org.ofbiz.pos.device.DeviceLoader; |
| import org.ofbiz.pos.device.impl.Receipt; |
| import org.ofbiz.pos.screen.PosScreen; |
| import org.ofbiz.pos.screen.PaidInOut; |
| import org.ofbiz.pos.PosTransaction; |
| import org.ofbiz.pos.adaptor.SyncCallbackAdaptor; |
| import org.ofbiz.pos.component.Input; |
| import org.ofbiz.pos.component.Output; |
| import org.ofbiz.entity.GenericDelegator; |
| import org.ofbiz.entity.GenericEntityException; |
| import org.ofbiz.entity.GenericValue; |
| import org.ofbiz.entity.util.EntityListIterator; |
| import org.ofbiz.entity.condition.EntityExpr; |
| import org.ofbiz.entity.condition.EntityOperator; |
| import org.ofbiz.entity.condition.EntityConditionList; |
| import org.ofbiz.service.LocalDispatcher; |
| import org.ofbiz.service.GenericServiceException; |
| import org.ofbiz.service.ServiceUtil; |
| import org.ofbiz.guiapp.xui.XuiSession; |
| import org.ofbiz.base.util.UtilProperties; |
| |
| public class ManagerEvents { |
| |
| public static final String module = ManagerEvents.class.getName(); |
| public static boolean mgrLoggedIn = false; |
| static DecimalFormat priceDecimalFormat = new DecimalFormat("#,##0.00"); |
| |
| public static void modifyPrice(PosScreen pos) { |
| PosTransaction trans = PosTransaction.getCurrentTx(pos.getSession()); |
| String sku = null; |
| try { |
| sku = MenuEvents.getSelectedItem(pos); |
| } catch (ArrayIndexOutOfBoundsException e) { |
| } |
| |
| if (sku == null) { |
| pos.getOutput().print(UtilProperties.getMessage("pos","Invalid_Selection",Locale.getDefault())); |
| pos.getJournal().refresh(pos); |
| pos.getInput().clear(); |
| } |
| |
| Input input = pos.getInput(); |
| String value = input.value(); |
| if (UtilValidate.isNotEmpty(value)) { |
| double price = 0.00; |
| boolean parsed = false; |
| try { |
| price = Double.parseDouble(value); |
| parsed = true; |
| } catch (NumberFormatException e) { |
| } |
| |
| if (parsed) { |
| price = price / 100; |
| trans.modifyPrice(sku, price); |
| |
| // re-calc tax |
| trans.calcTax(); |
| } |
| } |
| |
| // refresh the other components |
| pos.refresh(); |
| } |
| |
| public static void openTerminal(PosScreen pos) { |
| if (!mgrLoggedIn) { |
| pos.showDialog("dialog/error/mgrnotloggedin"); |
| return; |
| } |
| |
| PosTransaction trans = PosTransaction.getCurrentTx(pos.getSession()); |
| Input input = pos.getInput(); |
| if (!trans.isOpen()) { |
| if (input.isFunctionSet("OPEN")) { |
| String amountStr = input.value(); |
| if (UtilValidate.isNotEmpty(amountStr)) |
| { |
| try { |
| double amt = Double.parseDouble(amountStr); |
| amt = amt / 100; |
| amountStr = UtilFormatOut.formatPrice(amt); |
| } catch (NumberFormatException e) |
| { |
| Debug.logError(e, module); |
| } |
| } |
| GenericValue state = pos.getSession().getDelegator().makeValue("PosTerminalState", null); |
| state.set("posTerminalId", pos.getSession().getId()); |
| state.set("openedDate", UtilDateTime.nowTimestamp()); |
| state.set("openedByUserLoginId", pos.getSession().getUserId()); |
| state.set("startingTxId", trans.getTransactionId()); |
| try |
| { |
| state.set("startingDrawerAmount", new Double(priceDecimalFormat.parse(amountStr).doubleValue())); |
| } |
| catch (ParseException pe) |
| { |
| Debug.logError(pe, module); |
| } |
| try { |
| state.create(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| pos.showDialog("dialog/error/exception", e.getMessage()); |
| } |
| NavagationEvents.showPosScreen(pos); |
| } else { |
| input.clear(); |
| input.setFunction("OPEN"); |
| pos.getOutput().print(UtilProperties.getMessage("pos","OPDRAM",Locale.getDefault())); |
| return; |
| } |
| } else { |
| pos.showPage("pospanel"); |
| } |
| } |
| |
| public static void closeTerminal(PosScreen pos) { |
| if (!mgrLoggedIn) { |
| pos.showDialog("dialog/error/mgrnotloggedin"); |
| return; |
| } |
| |
| PosTransaction trans = PosTransaction.getCurrentTx(pos.getSession()); |
| if (!trans.isOpen()) { |
| pos.showDialog("dialog/error/terminalclosed"); |
| return; |
| } |
| |
| Output output = pos.getOutput(); |
| Input input = pos.getInput(); |
| if (input.isFunctionSet("CLOSE")) { |
| String[] func = input.getFunction("CLOSE"); |
| String lastValue = input.value(); |
| if (UtilValidate.isNotEmpty(lastValue)) { |
| try { |
| double dbl = Double.parseDouble(lastValue); |
| dbl = dbl / 100; |
| lastValue = UtilFormatOut.formatPrice(dbl); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, module); |
| } |
| if (UtilValidate.isNotEmpty(func[1])) { |
| func[1] = func[1] + "|"; |
| } |
| func[1] = func[1] + lastValue; |
| input.setFunction("CLOSE", func[1]); |
| } |
| |
| String[] closeInfo = new String[0]; |
| if (UtilValidate.isNotEmpty(func[1])) { |
| closeInfo = func[1].split("\\|"); |
| } |
| switch (closeInfo.length) { |
| case 0: |
| output.print(UtilProperties.getMessage("pos","ENTCAS",Locale.getDefault())); |
| break; |
| case 1: |
| output.print(UtilProperties.getMessage("pos","ENTCHK",Locale.getDefault())); |
| break; |
| case 2: |
| output.print(UtilProperties.getMessage("pos","ENTCRC",Locale.getDefault())); |
| break; |
| case 3: |
| output.print(UtilProperties.getMessage("pos","ENTGFC",Locale.getDefault())); |
| break; |
| case 4: |
| output.print(UtilProperties.getMessage("pos","ENTOTH",Locale.getDefault())); |
| break; |
| case 5: |
| GenericValue state = trans.getTerminalState(); |
| state.set("closedDate", UtilDateTime.nowTimestamp()); |
| state.set("closedByUserLoginId", pos.getSession().getUserId()); |
| try |
| { |
| state.set("actualEndingCash", new Double(priceDecimalFormat.parse(closeInfo[0]).doubleValue())); |
| state.set("actualEndingCheck", new Double(priceDecimalFormat.parse(closeInfo[1]).doubleValue())); |
| state.set("actualEndingCc", new Double(priceDecimalFormat.parse(closeInfo[2]).doubleValue())); |
| state.set("actualEndingGc", new Double(priceDecimalFormat.parse(closeInfo[3]).doubleValue())); |
| state.set("actualEndingOther", new Double(priceDecimalFormat.parse(closeInfo[4]).doubleValue())); |
| } |
| catch (ParseException pe) |
| { |
| Debug.logError(pe, module); |
| } |
| state.set("endingTxId", trans.getTransactionId()); |
| Debug.log("Updated State - " + state, module); |
| try { |
| state.store(); |
| state.refresh(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| pos.showDialog("dialog/error/exception", e.getMessage()); |
| } |
| |
| // print the totals report |
| output.print(UtilProperties.getMessage("pos","WaitingFinalSales",Locale.getDefault())); |
| //pos.showDialog("dialog/error/terminalclosed"); JLR 14/11/06 : Pb with that don't know why, useless => commented out |
| printTotals(pos, state, true); |
| |
| // lock the terminal for the moment |
| pos.getInput().setLock(true); |
| pos.getButtons().setLock(true); |
| pos.refresh(false); |
| |
| // transmit final data to server |
| GenericValue terminal = null; |
| try { |
| terminal = state.getRelatedOne("PosTerminal"); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| pos.showDialog("dialog/error/exception", e.getMessage()); |
| } |
| if (terminal != null && terminal.get("pushEntitySyncId") != null) { |
| String syncId = terminal.getString("pushEntitySyncId"); |
| SyncCallbackAdaptor cb = new SyncCallbackAdaptor(pos, syncId, state.getTimestamp("lastUpdatedTxStamp")); |
| pos.getSession().getDispatcher().registerCallback("runEntitySync", cb); |
| } else { |
| // no sync setting; just logout |
| SecurityEvents.logout(pos); |
| } |
| // unlock the terminal |
| pos.getInput().setLock(false); |
| pos.getButtons().setLock(false); |
| pos.refresh(true); |
| |
| } |
| } else { |
| trans.popDrawer(); |
| input.clear(); |
| input.setFunction("CLOSE"); |
| output.print(UtilProperties.getMessage("pos","ENTCAS",Locale.getDefault())); |
| } |
| } |
| |
| public static void voidOrder(PosScreen pos) { |
| if (!mgrLoggedIn) { |
| pos.showDialog("dialog/error/mgrnotloggedin"); |
| return; |
| } |
| |
| XuiSession session = pos.getSession(); |
| PosTransaction trans = PosTransaction.getCurrentTx(session); |
| if (!trans.isOpen()) { |
| pos.showDialog("dialog/error/terminalclosed"); |
| return; |
| } |
| |
| Output output = pos.getOutput(); |
| Input input = pos.getInput(); |
| boolean lookup = false; |
| |
| if (input.isFunctionSet("VOID")) { |
| lookup = true; |
| } else if (UtilValidate.isNotEmpty(input.value())) { |
| lookup = true; |
| } |
| |
| if (lookup) { |
| GenericValue state = trans.getTerminalState(); |
| Timestamp openDate = state.getTimestamp("openedDate"); |
| |
| String orderId = input.value(); |
| GenericValue orderHeader = null; |
| try { |
| orderHeader = session.getDelegator().findByPrimaryKey("OrderHeader", UtilMisc.toMap("orderId", orderId)); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| } |
| if (orderHeader == null) { |
| input.clear(); |
| pos.showDialog("dialog/error/ordernotfound"); |
| return; |
| } else { |
| Timestamp orderDate = orderHeader.getTimestamp("orderDate"); |
| if (orderDate.after(openDate)) { |
| LocalDispatcher dispatcher = session.getDispatcher(); |
| Map returnResp = null; |
| try { |
| returnResp = dispatcher.runSync("quickReturnOrder", UtilMisc.toMap("orderId", orderId, |
| "returnHeaderTypeId", "CUSTOMER_RETURN", "userLogin", session.getUserLogin())); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| pos.showDialog("dialog/error/exception", e.getMessage()); |
| pos.refresh(); |
| return; |
| } |
| if (returnResp != null && ServiceUtil.isError(returnResp)) { |
| pos.showDialog("dialog/error/exception", ServiceUtil.getErrorMessage(returnResp)); |
| pos.refresh(); |
| return; |
| } |
| |
| // todo print void receipt |
| |
| trans.setTxAsReturn((String) returnResp.get("returnId")); |
| input.clear(); |
| pos.showDialog("dialog/error/salevoided"); |
| pos.refresh(); |
| } else { |
| input.clear(); |
| pos.showDialog("dialog/error/ordernotfound"); |
| return; |
| } |
| } |
| } else { |
| input.setFunction("VOID"); |
| output.print(UtilProperties.getMessage("pos","VOID",Locale.getDefault())); |
| } |
| } |
| |
| public static void reprintLastTx(PosScreen pos) { |
| if (!mgrLoggedIn) { |
| pos.showDialog("dialog/error/mgrnotloggedin"); |
| return; |
| } |
| DeviceLoader.receipt.reprintReceipt(true); |
| pos.refresh(); |
| } |
| |
| public static void popDrawer(PosScreen pos) { |
| if (!mgrLoggedIn) { |
| pos.showDialog("dialog/error/mgrnotloggedin"); |
| } else { |
| PosTransaction trans = PosTransaction.getCurrentTx(pos.getSession()); |
| trans.popDrawer(); |
| pos.refresh(); |
| } |
| } |
| |
| public static void clearCache(PosScreen pos) { |
| if (!mgrLoggedIn) { |
| pos.showDialog("dialog/error/mgrnotloggedin"); |
| } else { |
| UtilCache.clearAllCaches(); |
| pos.refresh(); |
| } |
| } |
| |
| public static void resetXui(PosScreen pos) { |
| if (!mgrLoggedIn) { |
| pos.showDialog("dialog/error/mgrnotloggedin"); |
| } else { |
| XProjectManager.getPageManager().reset(); |
| pos.refresh(); |
| } |
| } |
| |
| public static void shutdown(PosScreen pos) { |
| if (!mgrLoggedIn) { |
| pos.showDialog("dialog/error/mgrnotloggedin"); |
| } else { |
| pos.getOutput().print(UtilProperties.getMessage("pos","Shutting_down",Locale.getDefault())); |
| PosTransaction.getCurrentTx(pos.getSession()).closeTx(); |
| System.exit(0); |
| } |
| } |
| |
| public static void totalsReport(PosScreen pos) { |
| if (!mgrLoggedIn) { |
| pos.showDialog("dialog/error/mgrnotloggedin"); |
| return; |
| } |
| printTotals(pos, null, false); |
| } |
| |
| public static void paidOut(PosScreen pos) { |
| paidOutAndIn(pos, "OUT"); |
| } |
| |
| public static void paidIn(PosScreen pos) { |
| paidOutAndIn(pos, "IN"); |
| } |
| |
| public static void paidOutAndIn(PosScreen pos, String type) { |
| if (!mgrLoggedIn) { |
| pos.showDialog("dialog/error/mgrnotloggedin"); |
| return; |
| } |
| |
| PosTransaction trans = PosTransaction.getCurrentTx(pos.getSession()); |
| if (!trans.isOpen()) { |
| pos.showDialog("dialog/error/terminalclosed"); |
| return; |
| } |
| |
| PaidInOut PaidInOut = new PaidInOut(trans, pos, type); |
| Map mapInOut = PaidInOut.openDlg(); |
| if (null != mapInOut.get("amount")) { |
| String amount = (String) mapInOut.get("amount"); |
| try { |
| double dbl = Double.parseDouble(amount); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, module); |
| return; |
| } |
| |
| GenericValue internTx = pos.getSession().getDelegator().makeValue("PosTerminalInternTx", null); |
| internTx.set("posTerminalLogId", trans.getTerminalLogId()); |
| try |
| { |
| internTx.set("paidAmount", new Double(priceDecimalFormat.parse(amount).doubleValue() / 100)); |
| } |
| catch (ParseException pe) |
| { |
| Debug.logError(pe, module); |
| return; |
| } |
| internTx.set("reasonComment", mapInOut.get("reason")); |
| try { |
| internTx.create(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| pos.showDialog("dialog/error/exception", e.getMessage()); |
| return; |
| } |
| //save the TX Log |
| trans.paidInOut(type); |
| NavagationEvents.showPosScreen(pos); |
| } |
| } |
| |
| private static void printTotals(PosScreen pos, GenericValue state, boolean runBalance) { |
| PosTransaction trans = PosTransaction.getCurrentTx(pos.getSession()); |
| if (!trans.isOpen()) { |
| pos.showDialog("dialog/error/terminalclosed"); |
| return; |
| } |
| if (state == null) { |
| state = trans.getTerminalState(); |
| } |
| |
| double checkTotal = 0.00; |
| double cashTotal = 0.00; |
| double gcTotal = 0.00; |
| double ccTotal = 0.00; |
| double othTotal = 0.00; |
| double total = 0.00; |
| |
| GenericDelegator delegator = pos.getSession().getDelegator(); |
| List exprs = UtilMisc.toList(new EntityExpr("originFacilityId", EntityOperator.EQUALS, trans.getFacilityId()), |
| new EntityExpr("terminalId", EntityOperator.EQUALS, trans.getTerminalId())); |
| EntityListIterator eli = null; |
| |
| try { |
| eli = delegator.findListIteratorByCondition("OrderHeaderAndPaymentPref", new EntityConditionList(exprs, EntityOperator.AND), null, null); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| } |
| |
| Timestamp dayStart = state.getTimestamp("openedDate"); |
| Timestamp dayEnd = state.getTimestamp("closedDate"); |
| if (dayEnd == null) { |
| dayEnd = UtilDateTime.nowTimestamp(); |
| } |
| |
| if (eli != null) { |
| GenericValue ohpp; |
| while (((ohpp = (GenericValue) eli.next()) != null)) { |
| Timestamp orderDate = ohpp.getTimestamp("orderDate"); |
| if (orderDate.after(dayStart) && orderDate.before(dayEnd)) { |
| String pmt = ohpp.getString("paymentMethodTypeId"); |
| Double amt = ohpp.getDouble("maxAmount"); |
| |
| if ("CASH".equals(pmt)) { |
| cashTotal += amt.doubleValue(); |
| } else if ("CHECK".equals(pmt)) { |
| checkTotal += amt.doubleValue(); |
| } else if ("GIFT_CARD".equals(pmt)) { |
| gcTotal += amt.doubleValue(); |
| } else if ("CREDIT_CARD".equals(pmt)) { |
| ccTotal += amt.doubleValue(); |
| } else { |
| othTotal += amt.doubleValue(); |
| } |
| total += amt.doubleValue(); |
| } |
| } |
| |
| try { |
| eli.close(); |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, "Trouble closing ELI", module); |
| } |
| } |
| |
| Map reportMap = new HashMap(); |
| String reportTemplate = "totals.txt"; |
| |
| // miscellaneous |
| reportMap.put("term", UtilFormatOut.padString(UtilProperties.getMessage("pos","term",Locale.getDefault()), 20, false, ' ')); |
| reportMap.put("draw", UtilFormatOut.padString(UtilProperties.getMessage("pos","draw",Locale.getDefault()), 20, false, ' ')); |
| reportMap.put("clerk", UtilFormatOut.padString(UtilProperties.getMessage("pos","clerk",Locale.getDefault()), 20, false, ' ')); |
| reportMap.put("total_report", UtilFormatOut.padString(UtilProperties.getMessage("pos","total_report",Locale.getDefault()), 20, false, ' ')); |
| |
| // titles |
| reportMap.put("cashTitle", UtilFormatOut.padString(UtilProperties.getMessage("pos","CASH",Locale.getDefault()), 20, false, ' ')); |
| reportMap.put("checkTitle", UtilFormatOut.padString(UtilProperties.getMessage("pos","CHECK",Locale.getDefault()), 20, false, ' ')); |
| reportMap.put("giftCardTitle", UtilFormatOut.padString(UtilProperties.getMessage("pos","GIFT_CARD",Locale.getDefault()), 20, false, ' ')); |
| reportMap.put("creditCardTitle", UtilFormatOut.padString(UtilProperties.getMessage("pos","CREDIT_CARD",Locale.getDefault()), 20, false, ' ')); |
| reportMap.put("otherTitle", UtilFormatOut.padString(UtilProperties.getMessage("pos","OTHER",Locale.getDefault()), 20, false, ' ')); |
| reportMap.put("grossSalesTitle", UtilFormatOut.padString(UtilProperties.getMessage("pos","GROSS_SALES",Locale.getDefault()), 20, false, ' ')); |
| reportMap.put("+/-", UtilFormatOut.padString("+/-", 20, false, ' ')); |
| reportMap.put("spacer", UtilFormatOut.padString("", 20, false, ' ')); |
| |
| // logged |
| reportMap.put("cashTotal", UtilFormatOut.padString(UtilFormatOut.formatPrice(cashTotal), 8, false, ' ')); |
| reportMap.put("checkTotal", UtilFormatOut.padString(UtilFormatOut.formatPrice(checkTotal), 8, false, ' ')); |
| reportMap.put("ccTotal", UtilFormatOut.padString(UtilFormatOut.formatPrice(ccTotal), 8, false, ' ')); |
| reportMap.put("gcTotal", UtilFormatOut.padString(UtilFormatOut.formatPrice(gcTotal), 8, false, ' ')); |
| reportMap.put("otherTotal", UtilFormatOut.padString(UtilFormatOut.formatPrice(othTotal), 8, false, ' ')); |
| reportMap.put("grossTotal", UtilFormatOut.padString(UtilFormatOut.formatPrice(total), 8, false, ' ')); |
| |
| if (runBalance) { |
| // actuals |
| double cashEnd = state.getDouble("actualEndingCash").doubleValue(); |
| double checkEnd = state.getDouble("actualEndingCheck").doubleValue(); |
| double ccEnd = state.getDouble("actualEndingCc").doubleValue(); |
| double gcEnd = state.getDouble("actualEndingGc").doubleValue(); |
| double othEnd = state.getDouble("actualEndingOther").doubleValue(); |
| double grossEnd = cashEnd + checkEnd + ccEnd + gcEnd + othEnd; |
| |
| reportMap.put("cashEnd", UtilFormatOut.padString(UtilFormatOut.formatPrice(cashEnd), 8, false, ' ')); |
| reportMap.put("checkEnd", UtilFormatOut.padString(UtilFormatOut.formatPrice(checkEnd), 8, false, ' ')); |
| reportMap.put("ccEnd", UtilFormatOut.padString(UtilFormatOut.formatPrice(ccEnd), 8, false, ' ')); |
| reportMap.put("gcEnd", UtilFormatOut.padString(UtilFormatOut.formatPrice(gcEnd), 8, false, ' ')); |
| reportMap.put("otherEnd", UtilFormatOut.padString(UtilFormatOut.formatPrice(othEnd), 8, false, ' ')); |
| reportMap.put("grossEnd", UtilFormatOut.padString(UtilFormatOut.formatPrice(grossEnd), 8, false, ' ')); |
| |
| // diffs |
| double cashDiff = cashEnd - cashTotal; |
| double checkDiff = checkEnd - checkTotal; |
| double ccDiff = ccEnd - ccTotal; |
| double gcDiff = gcEnd - gcTotal; |
| double othDiff = othEnd - othTotal; |
| double grossDiff = cashDiff + checkDiff + ccDiff + gcDiff + othDiff; |
| |
| reportMap.put("cashDiff", UtilFormatOut.padString(UtilFormatOut.formatPrice(cashDiff), 8, false, ' ')); |
| reportMap.put("checkDiff", UtilFormatOut.padString(UtilFormatOut.formatPrice(checkDiff), 8, false, ' ')); |
| reportMap.put("ccDiff", UtilFormatOut.padString(UtilFormatOut.formatPrice(ccDiff), 8, false, ' ')); |
| reportMap.put("gcDiff", UtilFormatOut.padString(UtilFormatOut.formatPrice(gcDiff), 8, false, ' ')); |
| reportMap.put("otherDiff", UtilFormatOut.padString(UtilFormatOut.formatPrice(othDiff), 8, false, ' ')); |
| reportMap.put("grossDiff", UtilFormatOut.padString(UtilFormatOut.formatPrice(grossDiff), 8, false, ' ')); |
| |
| // set the report template |
| reportTemplate = "balance.txt"; |
| } |
| |
| Receipt receipt = DeviceLoader.receipt; |
| if (receipt.isEnabled()) { |
| receipt.printReport(trans, reportTemplate, reportMap); |
| } |
| } |
| } |