DiagRequest: start also on wakeupSimulation (mains powered machines)

See DC_printer_interface.graphml/pdf

DCPlugin.pro

@@ -9,7 +9,7 @@ QT += serialport
 INCLUDEPATH += $${PWD}/plugins
 INCLUDEPATH += $${PWD}/include
 
-QMAKE_CXXFLAGS += -Wno-deprecated-copy -O
+QMAKE_CXXFLAGS += -Wno-deprecated-copy
 
 # default
 ARCH = PTU5
@@ -30,7 +30,14 @@ contains( CONFIG, PTU5 ) {
     QMAKE_CXXFLAGS += -std=c++11
     linux-clang {  QMAKE_CXXFLAGS += -Qunused-arguments   }
     CONFIG += link_pkgconfig
+    PTU5BASEPATH = /opt/devel/ptu5
     ARCH = PTU5
+
+    INCLUDEPATH += $$PTU5BASEPATH/qt/libs/deviceController/include/
+    LIBS += -L$$PTU5BASEPATH/qt/libs/deviceController/library
+
+    LIBS += -lCAslave
+    LIBS += -lCAmaster
 }
 
 contains( CONFIG, PTU5_YOCTO ) {
@@ -38,8 +45,8 @@ contains( CONFIG, PTU5_YOCTO ) {
     PTU5BASEPATH = /opt/devel/ptu5
     ARCH = PTU5
 
-    # add qmqtt lib
+    LIBS += -lCAslave
-    #LIBS += -lQt5Qmqtt
+    LIBS += -lCAmaster
 }
 
 TARGET   = ATBDeviceControllerPlugin
@@ -49,8 +56,6 @@ INTERFACE_DEFINITION = $${PWD}/src/ATBAPP/DeviceControllerInterface.h
 
 DEFINES += DEVICECONTROLLERPLUGIN_LIBRARY
 
-DEFINES += USE_DC_VMC_UNIFICATION
-
 # The following define makes your compiler emit warnings if you use
 # any Qt feature that has been marked deprecated (the exact warnings
 # depend on your compiler). Please consult the documentation of the
@@ -71,7 +76,6 @@ DEFINES += QT_DEPRECATED_WARNINGS
 
 # ATBAPP interface
 HEADERS += \
-    include/interfaces.h \
     src/ATBAPP/ATBAPPplugin.h \
     src/ATBAPP/DeviceControllerDiag.h \
     src/ATBAPP/DeviceControllerInterface.h \
@@ -79,10 +83,12 @@ HEADERS += \
     src/ATBAPP/ATBMachineEvent.h \
     src/ATBAPP/ATBDeviceControllerPlugin.h \
     src/ATBAPP/Utils.h \
-    src/ATBAPP/UnifiedDCVMCInterface.h \
+    src/ATBAPP/support/CashUtils.h \
     src/ATBAPP/support/DBusControllerInterface.h \
     src/ATBAPP/support/JSON.h \
-    src/ATBAPP/support/PTUSystem.h
+    src/ATBAPP/support/PTUSystem.h \
+    src/ATBAPP/support/PersistentData.h \
+    src/ATBAPP/support/Ticket.h
 
 SOURCES += \
     src/ATBAPP/ATBHealthEvent.cpp \
@@ -90,9 +96,12 @@ SOURCES += \
     src/ATBAPP/ATBDeviceControllerPlugin.cpp \
     src/ATBAPP/DeviceControllerDiag.cpp \
     src/ATBAPP/Utils.cpp \
+    src/ATBAPP/support/CashUtils.cpp \
     src/ATBAPP/support/DBusControllerInterface.cpp \
     src/ATBAPP/support/JSON.cpp \
-    src/ATBAPP/support/PTUSystem.cpp
+    src/ATBAPP/support/PTUSystem.cpp \
+    src/ATBAPP/support/PersistentData.cpp \
+    src/ATBAPP/support/Ticket.cpp
 
 DISTFILES += \
     generate-version.sh

src/ATBAPP/ATBAPPplugin.h

@@ -5,63 +5,18 @@
  * a simple class with only one method for plugin info
  */
 #include <QObject>
-#include <QStringList>
+#include <QString>
 
-struct ATBAPPplugin {
+class ATBAPPplugin
-    enum class PLUGIN_STATE : quint8 {
+{
-        NOT_INITIALIZED = 0,
-        INITIALIZED = 1
-    };
-    enum class RESULT_STATE : quint8 {
-        SUCCESS = 1,                // operation was successfull
-        ERROR_BACKEND,              // error from backend (e.g. backend replies with error)
-        ERROR_NETWORK,
-        ERROR_TIMEOUT,              // the operation timed out
-        ERROR_PROCESS,              // internal plugin error, should not occur (this is a bug in implementation)
-        ERROR_BUSY,
-        ERROR_STATE,
-        ERROR_RETRY,                // retry operation
-        INFO                        // informational (e.g. display a message, log something etc.)
-    };
-    enum class CASH_STATE   : quint8 {
-        CACHE_EMPTY,                // Cache still empty, default state
-        CACHE_INPUT,                // Coins are in Cache
-        OVERPAYED,
-        /* t.b.d. */
-    };
-    enum class TICKET_VARIANT : quint8 {
-        PARKING_TICKET,
-        RECEIPT,
-        ERROR_RECEIPT,
-        START_RECEIPT,   // e.g. Szeged Start
-        STOP_RECEIPT,    // e.g. Szeged Stop
-    };
-    enum class STEP : quint8 {
-        UP = 1,
-        DOWN = 2
-    };
-    enum class TERMINAL_STATE : quint8 {
-        NOT_AVAILABLE = 1,
-        AVAILABLE,
-        PREPARED_FOR_VENDING,
-        BUSY,
-        NEEDS_MAINTENANCE
-    };
 
+public:
     virtual const QString & getPluginInfo() = 0;
-    virtual QStringList getPluginInfoList() {
-        return QStringList(QString());
-    }
 };
 
-using PLUGIN_STATE = ATBAPPplugin::PLUGIN_STATE;
-using RESULT_STATE = ATBAPPplugin::RESULT_STATE;
-using CASH_STATE = ATBAPPplugin::CASH_STATE;
-using TICKET_VARIANT = ATBAPPplugin::TICKET_VARIANT;
-using STEP = ATBAPPplugin::STEP;
-using TERMINAL_STATE = ATBAPPplugin::TERMINAL_STATE;
-
 Q_DECLARE_INTERFACE(ATBAPPplugin,
                     "eu.atb.ptu.plugin.ATBAPPplugin/0.9")
 
+
+
 #endif // ATBAPPPLUGIN_H

src/ATBAPP/ATBDeviceControllerPlugin.h

@@ -2,27 +2,32 @@
 #define ATBDEVICECONTROLLERPLUGIN_H
 
 #include <QObject>
+#include <QLocale>
 
 #include "src/ATBAPP/DeviceControllerInterface.h"
 #include "src/ATBAPP/ATBAPPplugin.h"
 #include "src/ATBAPP/DeviceControllerDiag.h"
+#include "src/ATBAPP/support/Ticket.h"
 
 #include "version.h"
 
+#include "support/PersistentData.h"
 
+#include <DeviceController/interfaces.h>
 
-#include "interfaces.h"
+#include <unistd.h>
 
 
 class DBusControllerInterface;
 class QTextCodec;
 
-
+using namespace nsDeviceControllerInterface;
-// using namespace nsDeviceControllerInterface;
 
 class QSettings;
 
-class ATBDeviceControllerPlugin : public DeviceControllerInterface
+
+class ATBDeviceControllerPlugin :
+        public DeviceControllerInterface
 {
     Q_OBJECT
     Q_INTERFACES(ATBAPPplugin)
@@ -33,14 +38,13 @@ class ATBDeviceControllerPlugin : public DeviceControllerInterface
 
 public:
     explicit ATBDeviceControllerPlugin(QObject *parent = nullptr);
-    virtual ~ATBDeviceControllerPlugin();
+    ~ATBDeviceControllerPlugin();
 
     // ----------------------------------------------------------------------------
     // interface:
-    virtual PLUGIN_STATE initPlugin(QObject *eventReceiver, QObject *atbSystem, QObject *hmiConfig, QSettings const &settings) override;
+    PLUGIN_STATE initDCPlugin(QObject *eventReceiver, const QSettings & settings);
-    virtual PLUGIN_STATE initPlugin(QObject *eventReceiver, QSettings const &settings) override;
+
-    virtual PLUGIN_STATE initVMCPlugin(QObject *eventReceiver, QObject *atbSystem, QObject *hmiConfig, const QSettings & settings) override;
+    void sendDeviceParameter(const QJsonObject & jsonObject);
-    virtual PLUGIN_STATE initDCPlugin(QObject *eventReceiver, const QSettings & settings) override;
 
     // TASKS: Cash handling -------------------------------------------------------
     void requestStartCashInput(const QString & amount);
@@ -48,6 +52,10 @@ public:
     void cashCollect();
     void cashAbort();
 
+    // read coin/cash processing variants -----------------------------------------
+    nsDeviceControllerInterface::COIN_PROCESSOR coinProcessor();
+    nsDeviceControllerInterface::BILL_ACCEPTOR  billAcceptor();
+
     // TASKS: printing ------------------------------------------------------------
     void requestPrintTicket(const QHash<QString, QVariant> & printingData);
     void requestPrintTicket(nsDeviceControllerInterface::TICKET_VARIANT ticketVariant, const QHash<QString, QVariant> & printingData);
@@ -58,106 +66,43 @@ public:
     void requestAccount();
 
     // mandantory ATBAPP plugin methods: ------------------------------------------
-    nsDeviceControllerInterface::PLUGIN_STATE getState() override;
+    nsDeviceControllerInterface::PLUGIN_STATE getState();
-    QString const &getLastError() override;
+    QString & getLastError();
-    QString const &getLastErrorDescription() override;
+    const QString & getLastErrorDescription();
 
-    virtual QStringList getPluginInfoList() override;
+    const QString & getPluginInfo();
-    virtual const QString &getPluginInfo() override;
 
     // helpers e.g. for debug / log
-    virtual QString const &getString(RESULT_STATE resultState) override;
+    const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState);;
 
 public slots:
-    virtual void onChangedProgramModeToSELL() override;
+    void onChangedProgramModeToSELL();
-    virtual void onChangedProgramModeToSERVICE() override;
+    void onChangedProgramModeToSERVICE();
-    virtual void onChangedProgramModeToIDLE() override;
+    void onChangedProgramModeToIDLE();
-    virtual void onChangedProgramModeToOOO() override;
+    void onChangedProgramModeToOOO();
 
-    virtual void startPhysicalLayer() override;
+    void startPhysicalLayer();
-    virtual void stopPhysicalLayer() override;
+    void stopPhysicalLayer();
-    virtual void reboot() override;
+    void reboot();
-    virtual void reset() override;
+    void reset();
 
 
 
 signals:
-    void printTicketFinished(RESULT_STATE resultState,
+    // public Signals are defined in interface
-                             const QString & errorCode,
-                             const QString & errorDescription);
-    void printReceiptFinished(RESULT_STATE resultState,
-                              const QString & errorCode,
-                              const QString & errorDescription);
-
-    /**
-     * emitted on e.g. a coin input
-     */
-    void cashInputEvent(RESULT_STATE resultState,
-                                CASH_STATE cashState,
-                                const QString & newCashValue,
-                                /* additional variables? */
-                                const QString & errorCode,
-                                const QString & errorDescription);
-
-    /**
-     * emitted if cashInput has been stopped, e.g. in result to task requestStopCashInput():
-     *  -> shutter is blocked
-     *  -> no cash input is possible
-     *  -> coins are in cache
-     */
-    void cashInputFinished(RESULT_STATE resultState,
-                                     const QString & newCashValue,
-                                     /*  additional variables? */
-                                     const QString & errorCode,
-                                     const QString & errorDescription);
-
-
-    /**
-     * emitted e.g. if service door is opened
-     */
-    void requestModeSERVICE();
-
-    /**
-     * emitted e.g. if doors are closed
-     */
-    void requestModeIDLE();
-
-    /**
-     * emitted e.g. on severe errors
-     */
-    void requestModeOOO();
-
-    /**
-     * emitted e.g. if service door is opened
-     */
-    void requestAccountResponse(const QHash<QString, QVariant> & accountData);
-
-    /**
-     * emitted on error
-     * depending on errorCode:
-     * -> interrupt selling process
-     * -> machine can go to state OOO
-     * -> send error event to ISMAS
-     * -> ...
-     */
-    void Error(
-            /*  additional variables? */
-            const QString & errorCode,
-            const QString & errorDescription);
 
 
 private:
    QString errorCode;
    QString errorDescription;
    QString pluginInfo;
-   QStringList pluginInfoList;
-
-   QList<int> templateList;
 
    QString serialPortName;
 
    bool useDebug;
 
+   bool isMaster;
+
    PLUGIN_STATE pluginState;
 
    QObject* eventReceiver;
@@ -168,6 +113,10 @@ private:
 
    DeviceControllerDiag* diag;
 
+   PersistentData *persistentData;
+
+   uint32_t cashStartAmountInt;
+
 
    QTextCodec *codec;
 
@@ -183,6 +132,17 @@ private:
    // dbus
    int init_sc_dbus();
 
+   // printer privates ----------------------------------------------------------------------------
+   Ticket * currentTicket;
+   QLocale printerLocale;
+
+   void prepareDynTemplateData();
+
+   void private_setupDynTemplateData_START_RECEIPT(struct T_dynDat *dynTicketData, Ticket *ticket);
+   void private_setupDynTemplatData_STOP_RECEIPT(struct T_dynDat *dynTicketData,   Ticket *ticket);
+   void private_setupDynTemplatData_FOOD_STAMP(struct T_dynDat *dynTicketData,     Ticket *ticket);
+   // ---------------------------------------------------------------------------------------------
+
 private slots:
    // printer
 
@@ -192,6 +152,8 @@ private slots:
    void onPrinterWaitForPrintingTicket();
    void onPrinterWaitForPrintingReceipt();
 
+   void onPrinterPrepareDynTemplateData();
+
    void onPrintFinishedOK();
    void onPrintFinishedERR();
 
@@ -199,9 +161,11 @@ private slots:
    void onCashGotCoin();
    void onCashPayStopedSuccess();
    void onCashPayStopByMax();
+   void onCashPayStopByPushbutton();
    void onCashPayStopByEscrow();
    void onCashPayStopByError();
    void onCashPayStopByTimeout();
+   void onCashChangerState();
 
    // doors and hardware contacts
    void onServiceDoorOpened();

src/ATBAPP/DeviceControllerDiag.cpp

@@ -5,11 +5,16 @@
 #include <QUuid>
 #include <QDebug>
 
-DeviceControllerDiag::DeviceControllerDiag(QObject *parent)
+DeviceControllerDiag::DeviceControllerDiag(PersistentData *pData, QObject *parent)
     : QObject(parent)
+    , coinProcessorType(nsDeviceControllerInterface::COIN_PROCESSOR::ESCROW)
+    , billAcceptor(nsDeviceControllerInterface::BILL_ACCEPTOR::NO)
     , eventReceiver(nullptr)
     , isRequestRunning(false)
     , flagInterruptDiag(false)
+    , lastState(DeviceController::State::INITIAL_STATE)
+    , _isErrorState(false)
+    , pData(pData)
 {
     diagRequestTimeoutTimer = new QTimer(this);
     diagRequestTimeoutTimer->setInterval(1000*20);  // 20s
@@ -40,6 +45,16 @@ void DeviceControllerDiag::diagRequest()
     this->diagRequestTimeoutTimer->start();
 
     this->private_startDiag();
+
+    // read dc-fw-version:
+    /* note: dc_getSWVersion() returns always 32 characters (QString)...
+     * if no version string could be read it will contain 32 null-characters:
+     * "\u0000\u0000..."
+     */
+    QString dc_fw_version = hw->dc_getSWversion().remove(QChar('\0'));
+    qCritical() << "ATBDeviceControllerPlugin: DC firmware version: " << dc_fw_version;
+    this->pData->setDCFirmwareVersion(dc_fw_version);
+    this->pData->serializeToFile();
 }
 
 
@@ -49,12 +64,32 @@ void DeviceControllerDiag::onDiagRequestTimeoutTimerTimeout()
     this->flagInterruptDiag = true;
 }
 
+
+bool DeviceControllerDiag::isErrorState()
+{
+    return this->_isErrorState;
+}
+
+bool DeviceControllerDiag::isOperatingState()
+{
+    return !this->_isErrorState;
+}
+
+QSet<DeviceController::State> DeviceControllerDiag::getCurrentMachineState()
+{
+    return this->machineEventSet;
+}
+
+
+
 void DeviceControllerDiag::private_startDiag()
 {
     // check for DiagRequestTimeoutTimerTimeout:
     if (this->flagInterruptDiag) {
         qCritical() << "DeviceControllerDiag::private_startDiag() interrupted!";
         this->private_sendDiagEvent(DeviceController::State::E255);
+        this->isRequestRunning  = false;
+        this->flagInterruptDiag = false;
         return;
     }
 
@@ -87,6 +122,8 @@ void DeviceControllerDiag::sys_superviseSystem()
     if (this->flagInterruptDiag) {
         qCritical() << "DeviceControllerDiag::sys_superviseSystem() interrupted!";
         this->private_sendDiagEvent(DeviceController::State::E255);
+        this->flagInterruptDiag = false;
+        this->isRequestRunning  = false;
         return;
     }
 
@@ -95,6 +132,8 @@ void DeviceControllerDiag::sys_superviseSystem()
         // es gibt keinerlei gültige Daten vom DC
         qCritical() << "DeviceControllerDiag::sys_superviseSystem() no valid data!";
         this->private_sendDiagEvent(DeviceController::State::E254);
+        this->diagRequestTimeoutTimer->stop();
+        this->isRequestRunning  = false;
         return;
     }
 
@@ -210,6 +249,19 @@ void DeviceControllerDiag::sub_componentAssessment()
     }
     // -----------------------------------------------------------------------------------------------
 
+    switch (devPara.kindOfCoinChecker) {
+        case 0:
+            this->coinProcessorType = nsDeviceControllerInterface::COIN_PROCESSOR::NONE;
+            break;
+        case 1:
+        case 2:
+            this->coinProcessorType = nsDeviceControllerInterface::COIN_PROCESSOR::ESCROW;
+            break;
+        case 3:
+            this->coinProcessorType = nsDeviceControllerInterface::COIN_PROCESSOR::CHANGER;
+            break;
+    }
+
     if (devPara.kindOfCoinChecker==1 || devPara.kindOfCoinChecker==2)  // 0: without  1=EMP820   2=EMP900    3=currenza c²	(MW)
     {
         if (modCond.coinEscrow>=200) {
@@ -242,6 +294,15 @@ void DeviceControllerDiag::sub_componentAssessment()
         }
     }
 
+    switch (devPara.BillAcceptor) {
+        case 0:
+            this->billAcceptor = nsDeviceControllerInterface::BILL_ACCEPTOR::NO;
+            break;
+        default:
+            this->billAcceptor = nsDeviceControllerInterface::BILL_ACCEPTOR::YES;
+            break;
+    }
+
     /*
     if ( modCond.billReader>=200 && devPara.BillAcceptor>0)
     {
@@ -324,7 +385,6 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
 {
     qCritical() << "DeviceControllerDiag::private_sendDiagEvent() result: " << result;
 
-
     if (this->eventReceiver == nullptr) {
         qCritical() << "DeviceControllerDiag: no eventReceiver";
         return;
@@ -347,61 +407,77 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
     QString parameter;
     switch (result) {
 
+    case DeviceController::State::INITIAL_STATE:
+        break;
     case DeviceController::State::A000:   // alarm / intrusion
         eventClass = EVENT_CLASS::ALARM;
         parameter  = "alarm / intrusion";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E002:    // real time clock error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "real time clock error";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E003:   // voltage error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "voltage error";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E004:   // temperature error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "temperature error";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E007:    // coin safe full
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "coin safe full";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E008:    // bill acceptor full
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "bill acceptor full";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E009:    // no cash box
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "no cash box";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E010:    // coin escrow
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "coin escrow";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E011:    // mem error int.ee.
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "mem error int.ee.";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E018:    // no paper
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "no paper";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E020:    // printer error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "printer error";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E025:    // coin blocker
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "coin blocker";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E026:    // error coin validator
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "error coin validator";
+        this->_isErrorState = true;
         break;
     case DeviceController::State::E034:    // mdb error
         eventClass = EVENT_CLASS::ERROR;
         parameter  = "mdb error";
+        this->_isErrorState = true;
         break;
 
     case DeviceController::State::E071:   // cash box change is ongoing
@@ -437,9 +513,16 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
         break;
     case DeviceController::State::O000:   // everything is fine
         this->machineEventSet.clear();
+        this->_isErrorState = false;
         eventClass = EVENT_CLASS::OPERATE;
         parameter  = "";
+        if (this->lastState == DeviceController::State::O000) {
+            qCritical() << "   ... everything fine, no state change -> skip sending";
+            return;
+        }
+        else {
             qCritical() << "   ... everything fine";
+        }
         break;
 
     case DeviceController::State::W001:   // paper low
@@ -460,6 +543,7 @@ void DeviceControllerDiag::private_sendDiagEvent(DeviceController::State result)
         break;
     }
 
+    this->lastState = result;
 
     ATBMachineEvent *machineEvent = new ATBMachineEvent(
                 eventId,

src/ATBAPP/DeviceControllerDiag.h

@@ -5,8 +5,13 @@
 #include <QSet>
 #include <QTimer>
 
+#include <DeviceController/interfaces.h>
+
+#include "DeviceControllerInterface.h"
 #include "ATBMachineEvent.h"
-#include "interfaces.h"
+
+#include "support/PersistentData.h"
+
 
 namespace DeviceController {
     Q_NAMESPACE
@@ -47,7 +52,9 @@ namespace DeviceController {
         W001,
         W002,
         W003,
-        W004
+        W004,
+
+        INITIAL_STATE
     };
     Q_ENUM_NS(State)
 }
@@ -58,10 +65,20 @@ class DeviceControllerDiag : public QObject
     Q_OBJECT
 
 public:
-    DeviceControllerDiag(QObject *parent = nullptr);
+    DeviceControllerDiag(PersistentData *pData, QObject *parent = nullptr);
 
     void init(hwinf* hw, QObject* eventReceiver);
 
+    nsDeviceControllerInterface::COIN_PROCESSOR coinProcessorType;
+    nsDeviceControllerInterface::BILL_ACCEPTOR  billAcceptor;
+
+    /**
+     * return true, if machineEventSet contains an error
+     */
+    bool isErrorState();
+    bool isOperatingState();
+    QSet<DeviceController::State> getCurrentMachineState();
+
 public slots:
     void diagRequest();
 
@@ -83,7 +100,11 @@ private:
 
     int lastVoltage;
 
+    DeviceController::State lastState;
     QSet<DeviceController::State> machineEventSet;
+    bool _isErrorState;
+
+    PersistentData* pData;
 
 private slots:
     void onDiagRequestTimeoutTimerTimeout();

src/ATBAPP/DeviceControllerInterface.h

@@ -5,25 +5,30 @@
 
 #include <QSettings>
 #include <QString>
+#include <QJsonObject>
 
 #include "ATBAPPplugin.h"
-#include "UnifiedDCVMCInterface.h"
 
 namespace nsDeviceControllerInterface {
-    using PLUGIN_STATE = ATBAPPplugin::PLUGIN_STATE;
+    enum class PLUGIN_STATE : quint8;
-    using RESULT_STATE = ATBAPPplugin::RESULT_STATE;
+    enum class RESULT_STATE : quint8;
-    using CASH_STATE = ATBAPPplugin::CASH_STATE;
+    enum class CASH_STATE   : quint8;
-    using TICKET_VARIANT = ATBAPPplugin::TICKET_VARIANT;
+    enum class TICKET_VARIANT : quint8;
+    enum class COIN_PROCESSOR : quint8;
+    enum class BILL_ACCEPTOR  : quint8;
+
+
+    enum class SERVICE_TEXT  : quint16;
 }
 
-class DeviceControllerInterface : public QObject, public UnifiedDCVMCInterface
+
+class DeviceControllerInterface : public QObject
+                                , public ATBAPPplugin
 {
     Q_OBJECT
     Q_INTERFACES(ATBAPPplugin)
-    Q_INTERFACES(UnifiedDCVMCInterface)
 
 public:
-
     virtual ~DeviceControllerInterface() {}
 
     /**
@@ -32,7 +37,14 @@ public:
      * @param settings
      * @return
      */
-    virtual PLUGIN_STATE initDCPlugin(QObject *eventReceiver, const QSettings & settings) = 0;
+    virtual nsDeviceControllerInterface::PLUGIN_STATE initDCPlugin(QObject *eventReceiver,
+                                                                   const QSettings & settings) = 0;
+
+    /**
+     * e.g. send location
+     */
+    virtual void sendDeviceParameter(const QJsonObject & jsonObject) = 0;
+
 
     // TASKS: Cash handling -------------------------------------------------------
     /**
@@ -60,10 +72,13 @@ public:
 
     // TASKS: printing ------------------------------------------------------------
     virtual void requestPrintTicket(const QHash<QString, QVariant> & printingData) = 0;
-    virtual void requestPrintTicket(TICKET_VARIANT ticketVariant, const QHash<QString, QVariant> & printingData) = 0;
+    virtual void requestPrintTicket(nsDeviceControllerInterface::TICKET_VARIANT ticketVariant, const QHash<QString, QVariant> & printingData) = 0;
     virtual void requestPrintReceipt(const QHash<QString, QVariant> & printingData) = 0;
     virtual void requestPrintReceipt(const QString & printingString) = 0;
 
+    // read coin/cash processing variants
+    virtual nsDeviceControllerInterface::COIN_PROCESSOR coinProcessor() = 0;
+    virtual nsDeviceControllerInterface::BILL_ACCEPTOR  billAcceptor() = 0;
 
     // mandantory ATBAPP plugin methods:
     virtual nsDeviceControllerInterface::PLUGIN_STATE getState() = 0;
@@ -74,7 +89,7 @@ public:
     // -> ATBAPPplugin::getPluginInfo()
 
     // helpers e.g. for debug / log
-    virtual const QString &getString(nsDeviceControllerInterface::RESULT_STATE resultState) = 0;
+    virtual const QString getString(nsDeviceControllerInterface::RESULT_STATE resultState) = 0;
 
 public slots:
     virtual void onChangedProgramModeToSELL() = 0;
@@ -87,6 +102,7 @@ public slots:
     virtual void reboot() = 0;
     virtual void reset() = 0;
 
+
 signals:
     void printTicketFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
                                      const QString & errorCode,
@@ -95,6 +111,9 @@ signals:
                                      const QString & errorCode,
                                      const QString & errorDescription);
 
+
+    void coinAttached();
+
     /**
      * emitted on e.g. a coin input
      */
@@ -113,15 +132,38 @@ signals:
      */
     void cashInputFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
                                      const QString & newCashValue,
-                                     /*  additional variables? */
+                                     const QString & coinValue,
+                                     const QString & noteValue,
+                                     const QString & changeValue,
                                      const QString & errorCode,
                                      const QString & errorDescription);
 
+    /**
+     * emitted if cashPayment has been finished, e.g. in result to task cashCollect():
+     *  -> ticket should be printed sucessfully
+     *  -> coins in excrow or changer are given back to user
+     * Provides data for logging, especially changed value
+     */
+    void cashPaymentFinished(nsDeviceControllerInterface::RESULT_STATE resultState,
+                                     const QString & newCashValue,  // total inserted amount amount
+                                     const QString & coinValue,     // inserted amount, paid with coins
+                                     const QString & noteValue,     // inserted amount, paid with notes
+                                     const QString & changeValue,   // amount changed by changer/escrow
+                                     const QString & errorCode,
+                                     const QString & errorDescription);
+
+
+
     /**
      * emitted e.g. if service door is opened
      */
     void requestModeSERVICE();
 
+    /**
+     * emitted e.g. if vault door is opened
+     */
+    void requestModeACCOUNT();
+
     /**
      * emitted e.g. if doors are closed
      */
@@ -138,6 +180,12 @@ signals:
     void requestAccountResponse(const QHash<QString, QVariant> & accountData);
 
 
+    /**
+     * show text messages in service mode
+     */
+    void showServiceText(nsDeviceControllerInterface::SERVICE_TEXT serviceText, const QString & text);
+
+
     /**
      * emitted on error
      * depending on errorCode:
@@ -153,7 +201,62 @@ signals:
 
 };
 
+
 Q_DECLARE_INTERFACE(DeviceControllerInterface,
-                    "eu.atb.ptu.plugin.DeviceControllerInterface/1.0")
+                    "eu.atb.ptu.plugin.DeviceControllerInterface/1.1.4")
+
+
+namespace nsDeviceControllerInterface {
+
+    enum class PLUGIN_STATE : quint8 {
+        NOT_INITIALIZED = 0,
+        INITIALIZED = 1
+    };
+
+    enum class RESULT_STATE : quint8 {
+        SUCCESS = 1,                // operation was successfull
+        ERROR_BACKEND,              // error from backend (e.g. backend replies with error)
+        ERROR_TIMEOUT,              // the operation timed out
+        ERROR_PROCESS,              // internal plugin error, should not occur (this is a bug in implementation)
+        ERROR_RETRY,                // retry operation
+        INFO                        // informational (e.g. display a message, log something etc.)
+    };
+
+    enum class CASH_STATE   : quint8 {
+        CACHE_EMPTY,                // Cache still empty, default state
+        CACHE_INPUT,                // Coins are in Cache
+        OVERPAYED,
+        /* t.b.d. */
+    };
+
+
+    enum class TICKET_VARIANT : quint8 {
+        PARKING_TICKET,
+        RECEIPT,
+        ERROR_RECEIPT,
+        START_RECEIPT,   // e.g. Szeged Start
+        STOP_RECEIPT,    // e.g. Szeged Stop
+        FOOD_STAMP
+    };
+
+    enum class COIN_PROCESSOR : quint8 {
+        CHANGER,
+        ESCROW,
+        NONE
+    };
+
+    enum class BILL_ACCEPTOR  : quint8 {
+        YES,
+        NO
+    };
+
+    enum class SERVICE_TEXT  : quint16 {
+        SERVICE_DOOR_OPENED,
+        VAULT_DOOR_OPENED,
+        COIN_BOX_REMOVED,
+        COIN_BOX_INSERTED
+        /* t.b.d. */
+    };
+}
 
 #endif // DEVICECONTROLLERINTERFACE_H

src/ATBAPP/UnifiedDCInterface.cpp

@@ -1,19 +0,0 @@
-#include "DeviceControllerInterface.h"
-
-
-using UNIFIED_PLUGIN_STATE = UnifiedDCVMCInterface<DeviceControllerInterface>::UNIFIED_PLUGIN_STATE;
-
-
-template<>
-UNIFIED_PLUGIN_STATE UnifiedDCVMCInterface<DeviceControllerInterface>::initPlugin(QObject *eventReceiver, QSettings const &settings) {
-
-
-    switch(static_cast<DeviceControllerInterface*>(this)->initDCPlugin(eventReceiver, settings)) {
-    case nsDeviceControllerInterface::PLUGIN_STATE::INITIALIZED:
-        return UNIFIED_PLUGIN_STATE::INITIALIZED;
-    case nsDeviceControllerInterface::PLUGIN_STATE::NOT_INITIALIZED:
-        return UNIFIED_PLUGIN_STATE::NOT_INITIALIZED;
-    }
-
-    return UNIFIED_PLUGIN_STATE::NOT_INITIALIZED;
-}

src/ATBAPP/UnifiedDCVMCInterface.h

@@ -1,62 +0,0 @@
-#ifndef UNIFIED_DCVMC_INTERFACE_H_INCLUDED
-#define UNIFIED_DCVMC_INTERFACE_H_INCLUDED
-
-#include <QObject>
-#include <QSettings>
-
-#include <QtPlugin>
-
-#include <QSettings>
-#include <QString>
-
-#include "ATBAPPplugin.h"
-
-
-class UnifiedDCVMCInterface : public ATBAPPplugin {
-    Q_INTERFACES(ATBAPPplugin)
-
-public:
-    explicit UnifiedDCVMCInterface() = default;
-    virtual ~UnifiedDCVMCInterface() = default;
-
-    virtual QStringList getPluginInfoList() = 0;
-    virtual const QString &getPluginInfo() = 0;
-
-    // mandantory ATBAPP plugin methods:
-    virtual PLUGIN_STATE getState() = 0;
-    virtual QString const &getLastError() = 0;
-    virtual QString const &getLastErrorDescription() = 0;
-
-    virtual PLUGIN_STATE initPlugin(QObject *eventReceiver,
-                                    QObject *atbSystem,
-                                    QObject *hmiConfig,
-                                    QSettings const &settings) = 0;
-
-    virtual PLUGIN_STATE initPlugin(QObject *eventReceiver, QSettings const &settings) = 0;
-
-    virtual PLUGIN_STATE initDCPlugin(QObject *eventReceiver,
-                                      const QSettings & settings) = 0;
-
-    virtual PLUGIN_STATE initVMCPlugin(QObject *eventReceiver,
-                                       QObject *atbSystem, QObject *hmiConfig,
-                                       const QSettings & settings) = 0;
-
-
-    virtual QString const &getString(RESULT_STATE resultState) = 0;
-
-public slots:
-    virtual void onChangedProgramModeToSELL() = 0;
-    virtual void onChangedProgramModeToSERVICE() = 0;
-    virtual void onChangedProgramModeToIDLE() = 0;
-    virtual void onChangedProgramModeToOOO() = 0;
-
-    virtual void startPhysicalLayer() = 0;
-    virtual void stopPhysicalLayer() = 0;
-    virtual void reboot() = 0;
-    virtual void reset() = 0;
-};
-
-Q_DECLARE_INTERFACE(UnifiedDCVMCInterface,
-                    "eu.atb.ptu.plugin.UnifiedDCVMCInterface/1.0")
-
-#endif // UNIFIED_DCVMC_INTERFACE_H_INCLUDED

src/ATBAPP/support/CashUtils.cpp

@@ -0,0 +1,74 @@
+#include "CashUtils.h"
+
+#include <QDebug>
+
+#define MAX_COINS 64
+#define MAX_NOTES 16
+
+/*****************************************************************************
+* Get current inserted coins
+*
+* getAllInsertedCoins(uint16_t *types, uint16_t *values)
+*       all inserted coins of this past transaction are stored, max 64
+*/
+uint32_t CashUtils::getAmountOfInsertedCoins(hwinf* hw)
+{
+    uint32_t result = 0;
+
+    uint16_t types[MAX_COINS];
+    uint16_t values[MAX_COINS];
+    hw->getAllInsertedCoins(types, values);
+
+    for (int i = 0; i < MAX_COINS; i++) {
+        result += values[i];
+    }
+
+    return result;
+}
+
+
+/*****************************************************************************
+ * Get current inserted notes
+ *
+ * virtual uint8_t bna_getCurrentNotes(uint16_t latestBill, uint16_t *currentNotes) const =0;
+ * returns number of collected bank notes since start-command (current transaction)
+ *    latestBill: last accepted bank note, value in cent
+ *    currentNotes an array with up to 16 (further) notes collected
+ *
+ */
+uint32_t CashUtils::getAmountOfInsertedNotes(hwinf* hw)
+{
+    uint32_t result = 0;
+    uint8_t numberOfInsertedNotes;
+
+    uint16_t beforeArray = 0;
+    uint16_t currentNotes[4];
+    uint16_t afterArray = 0;
+    numberOfInsertedNotes = hw->bna_getCurrentNotes(0, currentNotes);
+
+    if ( (beforeArray != 0) || (afterArray != 0) ) {
+        qCritical() << "CashUtils::getAmountOfInsertedNotes() ERROR: Array";
+    }
+
+    if (numberOfInsertedNotes == 99) {
+        // Error
+        qCritical() << "CashUtils::getAmountOfInsertedNotes() ERROR: ";
+        for (int i = 0; i < 4; i++) {
+        qCritical() << "   currentNotes[" << i << "] = " << currentNotes[i];
+        }
+    }
+    else {
+        // no error
+        result = currentNotes[3];
+        result = ( result << 16 ) | currentNotes[2];
+    }
+
+    // DEBUG
+    qCritical() << "--------------------------------------------------";
+    qCritical() << "CashUtils::getAmountOfInsertedNotes()";
+    qCritical() << "          numberOfInsertedNotes = " << numberOfInsertedNotes;
+    qCritical() << "                         result = " << result;
+    qCritical() << "--------------------------------------------------";
+
+    return result;
+}

src/ATBAPP/support/CashUtils.h

@@ -0,0 +1,14 @@
+#ifndef CASHUTILS_H
+#define CASHUTILS_H
+
+#include <QObject>
+#include <DeviceController/interfaces.h>
+
+namespace CashUtils {
+
+uint32_t getAmountOfInsertedCoins(hwinf* hw);
+uint32_t getAmountOfInsertedNotes(hwinf* hw);
+
+}
+
+#endif // CASHUTILS_H

src/ATBAPP/support/PersistentData.cpp

@@ -0,0 +1,145 @@
+#include "PersistentData.h"
+
+#include <QFile>
+#include <QFileInfo>
+#include <QDir>
+#include <QDateTime>
+#include <QDataStream>
+#include <QDebug>
+
+PersistentData::PersistentData(const QString &datafileName, QObject *parent)
+    : QObject(parent)
+    , isChangedFlag(false)
+{
+    // load persistant data, if available
+    this->filename = datafileName;
+
+    QFileInfo dataFileInfo(this->filename);
+    QString dataFilePath = dataFileInfo.path();
+
+    QDir dir;
+    if ( ! dir.exists(dataFilePath)) {
+        qCritical() << "Persistent data file does not exist!";
+        qCritical() << "          --> create new: " << this->filename;
+        dir.mkpath(dataFilePath);
+    }
+
+    this->read();
+}
+
+
+void PersistentData::serializeToFile()
+{
+    if (this->isChangedFlag) {
+        qCritical() << "PersistentData::isChanged -> save";
+        this->save();
+    }
+}
+
+void PersistentData::save()
+{
+    QFile fileOut(this->filename);
+    if (fileOut.open(QIODevice::WriteOnly))
+    {
+        QDataStream out(&fileOut);
+        out.setVersion(QDataStream::Qt_4_6);
+
+        out << this->hash;
+        fileOut.flush();
+        fileOut.close();
+
+        this->isChangedFlag = false;
+    }
+}
+
+void PersistentData::read()
+{
+    QFile fileIn(this->filename);
+    if (fileIn.open(QIODevice::ReadOnly))
+    {
+        QDataStream in(&fileIn);
+        in.setVersion(QDataStream::Qt_4_6);
+
+        in >> hash;
+
+        fileIn.close();
+    }
+}
+
+
+
+QVariant PersistentData::getParameter(const QString & key) const {
+#if defined (ARCH_DesktopLinux)
+    // note: QVariant.toString() returns empty string for custom types
+    qDebug() << "VendingData::getParameter() key = " << key << " value = " << hash.value(key).toString();
+#endif
+    return hash.value(key);
+}
+
+QVariant PersistentData::getParameter(const QString & key)
+{
+    #if defined (ARCH_DesktopLinux)
+    // note: QVariant.toString() returns empty string for custom types
+    qDebug() << "VendingData::getParameter() key = " << key << " value = " << hash.value(key).toString();
+    #endif
+
+    return hash.value(key);
+}
+
+void PersistentData::setParameter(const QString & key, QVariant value)
+{
+    this->isChangedFlag = true;
+
+    #if defined (ARCH_DesktopLinux)
+    // note: QVariant.toString() returns empty string for custom types
+    qDebug() << "VendingData::setParameter() key = " << key << " value = " << value.toString();
+    #endif
+
+    this->hash.insert(key, value);
+}
+
+void PersistentData::clearParameter(const QString & key)
+{
+    this->isChangedFlag = true;
+    this->hash.remove(key);
+}
+
+bool PersistentData::hasParameter(const QString & key) const
+{
+    return hash.contains(key);
+}
+
+
+uint PersistentData::getUintParameter(const QString & key) const
+{
+    qDebug() << "PersistentData::getUintParameter() key = " << key << " value = " << hash.value(key).toString();
+
+    uint returnValue = 0;
+    bool ok;
+
+    returnValue = hash.value(key).toString().toUInt(&ok);
+    if (!ok) returnValue = 0;
+
+    return returnValue;
+}
+
+QList<QString> PersistentData::uniqueKeys() const {
+    return hash.uniqueKeys();
+}
+
+
+void PersistentData::setDCFirmwareVersion(const QString & fw_version)
+{
+    // there must be a version string!
+    if (fw_version.size() < 1) return;
+
+    if (this->hash["dc_fw_version"].toString() != fw_version) {
+        this->isChangedFlag = true;
+        this->hash.insert("dc_fw_version", fw_version);
+    }
+}
+
+QString PersistentData::getDCFirmwareVersion()
+{
+    return this->hash["dc_fw_version"].toString();
+}

src/ATBAPP/support/PersistentData.h

@@ -0,0 +1,49 @@
+#ifndef PERSISTENTDATA_H
+#define PERSISTENTDATA_H
+
+#include <QObject>
+#include <QHash>
+#include <QVariant>
+#include <QList>
+#include <QString>
+
+class PersistentData : public QObject
+{
+    Q_OBJECT
+public:
+    explicit PersistentData(const QString &datafileName, QObject *parent = nullptr);
+
+    void setDCFirmwareVersion(const QString & fw_version);
+    QString getDCFirmwareVersion();
+
+
+    QVariant getParameter(const QString & key);
+    QVariant getParameter(const QString & key) const;
+    void setParameter(const QString & key, QVariant value);
+    void clearParameter(const QString & key);
+    bool hasParameter(const QString & key) const;
+
+    uint getUintParameter(const QString & key) const;
+    QList<QString> uniqueKeys() const;
+
+
+public slots:
+    void serializeToFile();
+
+signals:
+
+
+private:
+    QHash<QString, QVariant> hash;
+
+    QString dc_fw_version;
+
+    QString filename;
+
+    void save();
+    void read();
+
+    bool isChangedFlag;
+};
+
+#endif // PERSISTENTDATA_H

src/ATBAPP/support/Ticket.cpp

@@ -0,0 +1,169 @@
+#include "Ticket.h"
+
+#include <QDebug>
+
+Ticket::Ticket(TICKET_VARIANT ticketVariant, QObject *parent )
+    : QObject(parent)
+    , ticketVariant(ticketVariant)
+    , _hasTemplateDynData(false)
+{
+
+}
+
+TICKET_VARIANT Ticket::variant()
+{
+    return this->ticketVariant;
+}
+
+QList<quint8> * Ticket::templateList()
+{
+    return &(this->_templateList);
+}
+
+bool Ticket::hasTemplateDynData()
+{
+    return this->_hasTemplateDynData;
+}
+
+quint8 Ticket::getCurrentProcessedTemplateNumber()
+{
+    return this->currentProcessedTemplateNumber;
+}
+
+void Ticket::setCurrentTemplateProcessed()
+{
+    this->currentProcessedTemplateNumber++;
+}
+
+
+bool Ticket::initNew(TICKET_VARIANT ticketVariant, const QList<quint8> & templateList, const QHash<QString, QVariant> & printingData)
+{
+    this->clear();
+
+    this->ticketVariant = ticketVariant;
+    this->printingData = printingData;
+    this->_templateList = templateList;
+    this->currentProcessedTemplateNumber = 0;
+
+    // DEBUG
+    qCritical() << "Ticket::initNew():";
+    qCritical() << "      -> " << ticketVariant;
+
+    int multiplicatorInt = 1;  // default
+
+    switch (this->ticketVariant) {
+    case TICKET_VARIANT::PARKING_TICKET:
+        break;
+    case TICKET_VARIANT::RECEIPT:
+        break;
+    case TICKET_VARIANT::ERROR_RECEIPT:
+        break;
+    case TICKET_VARIANT::START_RECEIPT:
+        this->_templateList << 21 << 22 << 23;
+        break;
+    case TICKET_VARIANT::STOP_RECEIPT:
+        this->_templateList << 24 << 25 << 26;
+        break;
+    case TICKET_VARIANT::FOOD_STAMP:
+         if (printingData.contains("dyn1_list")) {
+            this->_hasTemplateDynData = true;
+
+            this->dyn1List = printingData["dyn1_list"].toStringList();
+            this->dyn2List = printingData["dyn2_list"].toStringList();
+         }
+
+         if (printingData.contains("multiplicator")) {
+             multiplicatorInt = printingData["multiplicator"].toInt();
+             for (int i = 1; i < multiplicatorInt; i++) {
+                 this->_templateList << 1;
+             }
+             // last template:
+             this->_templateList << 2;
+         }
+
+         // DEBUG FOOD_STAMP:
+         qCritical() << "     --> printingData[\"multiplicator\"]" << multiplicatorInt;
+
+        break;
+    }
+
+
+    // DEBUG
+    QString templateListString;
+    for (int i =0; i < this->_templateList.size(); ++i) {
+        templateListString.append(QString(" %1").arg(this->_templateList.at(i)));
+    }
+    qCritical() << "     -> templates: " << templateListString;
+
+
+    return true;
+}
+
+void Ticket::clear()
+{
+    this->ticketVariant = TICKET_VARIANT::PARKING_TICKET;
+    this->printingData.clear();
+    this->_templateList.clear();
+    this->errorCode.clear();
+    this->errorDescription.clear();
+
+    this->_hasTemplateDynData = false;
+    this->dyn1List.clear();
+    this->dyn1List.clear();
+}
+
+QString Ticket::getErrorCode()         {  return this->errorCode;        }
+QString Ticket::getErrorDescription()  {  return this->errorDescription; }
+
+
+
+
+/**
+ */
+QStringList Ticket::getDyn1List()
+{
+    return this->dyn1List;
+}
+
+QStringList Ticket::getDyn2List()
+{
+    return this->dyn2List;
+}
+
+QHash<QString, QVariant> & Ticket::getPrintingData()
+{
+    return this->printingData;
+}
+
+
+
+
+/************************************************************************************************
+ * operator
+ *
+ */
+QDebug operator<<(QDebug debug, TICKET_VARIANT ticketVariant)
+{
+    switch (ticketVariant) {
+        case TICKET_VARIANT::PARKING_TICKET:
+            debug << "TICKET_VARIANT::PARKING_TICKET";
+            break;
+        case TICKET_VARIANT::RECEIPT:
+            debug << "TICKET_VARIANT::RECEIPT";
+            break;
+        case TICKET_VARIANT::ERROR_RECEIPT:
+            debug << "TICKET_VARIANT::ERROR_RECEIPT";
+            break;
+        case TICKET_VARIANT::START_RECEIPT:
+            debug << "TICKET_VARIANT::START_RECEIPT";
+            break;
+        case TICKET_VARIANT::STOP_RECEIPT:
+            debug << "TICKET_VARIANT::STOP_RECEIPT";
+            break;
+        case TICKET_VARIANT::FOOD_STAMP:
+            debug << "TICKET_VARIANT::FOOD_STAMP";
+            break;
+    }
+
+    return debug;
+}

src/ATBAPP/support/Ticket.h

@@ -0,0 +1,88 @@
+#ifndef TICKET_H
+#define TICKET_H
+
+#include <QObject>
+#include <QHash>
+
+#include "../DeviceControllerInterface.h"
+
+using namespace nsDeviceControllerInterface;
+
+QDebug operator<<(QDebug debug, TICKET_VARIANT ticketVariant);
+
+
+
+class Ticket : public QObject
+{
+    Q_OBJECT
+
+public:
+    Ticket(TICKET_VARIANT ticketVariant, QObject *parent = nullptr);
+
+    bool initNew(TICKET_VARIANT ticketVariant, const QList<quint8> & templateList, const QHash<QString, QVariant> & printingData);
+    void clear();
+
+    TICKET_VARIANT variant();
+
+    QList<quint8> * templateList();
+
+    /**
+     * @brief getPrintingData - generic getter for printingData
+     * Used mainly for simple tickets (single tickets e.g. ParkingTicket)
+     * @return
+     */
+    QHash<QString, QVariant> & getPrintingData();
+
+    /**
+     * @brief hasTemplateDynData
+     * @return true, if ticket has dynamic data for each template.
+     *
+     * This depends on TICKET_VARIANT and printingData
+     */
+    bool hasTemplateDynData();
+
+    /**
+     * @brief getDyn1List
+     * contains dynamic template data
+     * The size of the lists must be exactly the same as the number of templates.
+     */
+    QStringList getDyn1List();
+    QStringList getDyn2List();
+
+    quint8 getCurrentProcessedTemplateNumber();
+
+    /**
+     * Mark current template as processed
+     */
+    void setCurrentTemplateProcessed();
+
+
+    // error handling
+    QString getErrorCode();
+    QString getErrorDescription();
+
+
+
+
+private:
+    TICKET_VARIANT ticketVariant;
+
+    // printingData from application
+    QHash<QString, QVariant> printingData;
+
+    // templateList, from .ini or created by ticketVariant...
+    QList<quint8> _templateList;
+
+    bool _hasTemplateDynData;
+
+    quint8 currentProcessedTemplateNumber;
+
+    QStringList dyn1List;
+    QStringList dyn2List;
+
+    // error handling
+    QString errorCode;
+    QString errorDescription;
+};
+
+#endif // TICKET_H