Dépôt officiel du code source de l'ERP OpenConcerto

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.erp.core.sales.pos.io;

import org.openconcerto.erp.core.sales.pos.io.ConcertProtocol.ConcertStateListener.States;

import org.openconcerto.utils.StringUtils;

import java.io.ByteArrayOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.ArrayList;

import java.util.List;

import org.apache.poi.util.HexDump;

import gnu.io.CommPort;

import gnu.io.CommPortIdentifier;

import gnu.io.SerialPort;

public class ConcertProtocol {

    public interface ConcertStateListener {

        enum States {

            ERROR, CONNECTED, WAITING, OK, NOK

        }

        void stateChanged(States state);

    }

    // Message start

    private static final char STX = (char) 0x02;

    // Message end

    private static final char ETX = (char) 0x03;

    // End of transmission

    private static final char EOT = (char) 0x04;

    // Start of transmission

    private static final char ENQ = (char) 0x05;

    // Positive ACK

    private static final char ACK = (char) 0x06;

    // Negative ACK

    private static final char NACK = (char) 0x15;

    // Mode

    private static final char MODE_CARD = '1';

    // Type

    private static final char TYPE_BUY = '0';

    // Currency

    public static final String CURRENCY_EUR = "978";

    private String port;

    private List<ConcertStateListener> listeners = new ArrayList<>();

    public ConcertProtocol(String port) {

        this.port = port;

    }

    public void addStateListener(ConcertStateListener listener) {

        listeners.add(listener);

    }

    private void fireStateChanged(States connected) {

        for (ConcertStateListener l : listeners)

            l.stateChanged(connected);

    }

    public synchronized boolean sendCardPayment(int amountInCents, String currency) throws Exception {

        if (currency == null) {

            currency = CURRENCY_EUR;

        }

        return sendPrototolE(1, amountInCents, true, MODE_CARD, TYPE_BUY, currency, "OpenConcerto");

    }

    public boolean sendPrototolE(int posIndex, int amountInCents, boolean requireResponse, char mode, char type, String currency, String string) throws Exception {

        boolean result = false;

        if (posIndex > 99 || posIndex < 0) {

            fireStateChanged(ConcertStateListener.States.ERROR);

            throw new IllegalArgumentException("Pos index must be between 0 and 99");

        }

        if (amountInCents < 0) {

            fireStateChanged(ConcertStateListener.States.ERROR);

            throw new IllegalArgumentException("Amount must be positive");

        }

        if (currency.length() != 3) {

            fireStateChanged(ConcertStateListener.States.ERROR);

            throw new IllegalArgumentException("Bad currency code : " + currency);

        }

        final OutputStream out;

        InputStream in;

        final SerialPort serialPort;

        if (isSerialPort()) {

            serialPort = getSerialPort();

            out = serialPort.getOutputStream();

            in = serialPort.getInputStream();

        } else {

            serialPort = null;

            in = new FileInputStream(this.port);

            if (in.available() > 0) {

                byte[] buffer = new byte[512];

                in.read(buffer);

                in.close();

            }

            in = new FileInputStream(this.port);

            out = new FileOutputStream(this.port);

        }

        out.write(ENQ);

        byte[] buffer = new byte[512];

        int nbRead = in.read(buffer);

        if (nbRead != 1 || buffer[0] != ACK) {

            String r = StringUtils.bytesToHexString(buffer, nbRead);

            in.close();

            out.close();

            if (serialPort != null) {

                serialPort.close();

            }

            fireStateChanged(ConcertStateListener.States.ERROR);

            throw new IllegalStateException("Bad response received : " + r);

        }

        fireStateChanged(ConcertStateListener.States.CONNECTED);

        //

        final ByteArrayOutputStream bOut = new ByteArrayOutputStream();

        bOut.write(STX);

        // POS Index

        String n = rightAlign(posIndex, 2, '0');

        bOut.write(n.getBytes());

        // Amount in cents

        bOut.write(rightAlign(amountInCents, 8, '0').getBytes());

        if (requireResponse) {

            bOut.write('1');

        } else {

            bOut.write('0');

        }

        // Mode & type

        bOut.write(mode);

        bOut.write(type);

        // Currency

        bOut.write(currency.getBytes());

        // Text

        bOut.write(leftAlign(string, 10, ' ').getBytes());

        bOut.write(ETX);

        byte b = getLrc(bOut.toByteArray());

        bOut.write(b);

        out.write(bOut.toByteArray());

        // READ ACK

        nbRead = in.read(buffer);

        if (nbRead != 1 || buffer[0] != ACK) {

            String r = StringUtils.bytesToHexString(buffer, nbRead);

            in.close();

            out.close();

            if (serialPort != null) {

                serialPort.close();

            }

            fireStateChanged(ConcertStateListener.States.ERROR);

            throw new IllegalStateException("Bad response received : " + nbRead + ": " + r);

        }

        // END

        out.write(EOT);

        fireStateChanged(ConcertStateListener.States.WAITING);

        // Wait reply

        int count = 0;

        final int maxCount = 60 * 5;

        while (count < maxCount) {

            nbRead = in.read(buffer);

            if (nbRead > 0) {

                if (buffer[0] == ENQ) {

                    out.write(ACK);

                } else if (buffer[0] == STX) {

                    if (buffer[3] == '0') {

                        result = true;

                        out.write(ACK);

                        count = maxCount;

                        fireStateChanged(ConcertStateListener.States.OK);

                    } else if (buffer[3] == '7') {

                        out.write(NACK);

                        count = maxCount;

                        fireStateChanged(ConcertStateListener.States.NOK);

                    }

                } else if (buffer[0] == EOT) {

                    count = maxCount;

                }

            }

            Thread.sleep(200);

            count++;

        }

        out.close();

        in.close();

        if (serialPort != null) {

            serialPort.close();

        }

        return result;

    }

    private byte getLrc(byte[] bytes) {

        byte lrc = (byte) 0x0;

        for (int i = 1; i < bytes.length; i++) {

            lrc ^= bytes[i];

        }

        return lrc;

    }

    private boolean isSerialPort() {

        return (this.port.startsWith("/dev") || this.port.startsWith("COM"));

    }

    private SerialPort getSerialPort() throws Exception {

        if (port == null || port.length() == 0) {

            throw new IllegalStateException("Invalid serial port name: " + port);

        }

        CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(port);

        if (portIdentifier.isCurrentlyOwned()) {

            throw new IllegalAccessError("Port " + port + " is currently in use");

        }

        CommPort commPort = portIdentifier.open("CommUtil", 2000);

        if (!(commPort instanceof SerialPort)) {

            throw new IllegalStateException("Invalid serial port: " + port);

        }

        SerialPort serialPort = (SerialPort) commPort;

        serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);

        return serialPort;

    }

    private static String rightAlign(int value, int maxWidth, char fillChar) {

        String r = String.valueOf(value);

        if (r.length() > maxWidth) {

            return r.substring(0, maxWidth);

        }

        int n = maxWidth - r.length();

        for (int i = 0; i < n; i++) {

            r = fillChar + r;

        }

        return r;

    }

    private static String leftAlign(String r, int maxWidth, char fillChar) {

        if (r.length() > maxWidth) {

            return r.substring(0, maxWidth);

        }

        int n = maxWidth - r.length();

        for (int i = 0; i < n; i++) {

            r += fillChar;

        }

        return r;

    }

    public static void main(String[] args) throws Exception {

        ConcertProtocol p = new ConcertProtocol("COM9");

        p.sendCardPayment(4579, ConcertProtocol.CURRENCY_EUR);

    }

}