FCC/Applications/FdcServer/FDCPOSInterfaceServer/FDCPOSInterfaceServer.cs

using System;
using System.Collections;
using System.Collections.Generic;
//using System.Linq;
using System.Threading;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Net;
using System.Net.Sockets;
using System.Diagnostics;
using System.Reflection;

using Wayne.FDCPOSLibrary;
using Wayne.OptInterface;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System.Linq;
using Edge.Core.IndustryStandardInterface.ATG;

//using System.Windows.Forms;

namespace Wayne.FDCPOSInterface
{
    [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
    public interface IFDCPOSInterfaceServer
    {
        #region MyRegion

        [DispId(1)]
        bool Start(int iIPPortA, bool encryptedHeader, string forecourtConfiguration, int version, bool useExtensions, string certificate);

        [DispId(4)]
        void LogOn(string workstationID, string applicationSender, int requestId, int iResponsePort, int iUnsolicitedPort, int status, string overallResult);

        [DispId(5)]
        void LogOff(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(6)]
        void VersionInfo(string workstationID, string applicationSender, int requestId, string supplier, string version, string release, string hotfix, int status, string overallResult);

        [DispId(7)]
        void StartForecourt(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(8)]
        void StopForecourt(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        //[DispId(9)] spostato di indice
        //void GetCurrentFuellingStatusAdd(string workstationID, string applicationSender, int requestId, int deviceId, double volume, double amount, double price, int nozzle, int transactionId, string authoriseSender, string overallResult);

        [DispId(10)]
        void GetDeviceStateAdd(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int deviceState, int deviceSubState, string errorId, string errorDescription, int logicalStatus, string lockingAS, int nozzleListNum, int nozzleListState, int nozzleListLogicalState, int nozzleListTankState);

        [DispId(11)]
        void TerminateFuellingAdd(string workstationID, string applicationSender, int requestId, int deviceId, int deviceStatus);

        [DispId(12)]
        void AuthoriseFuelPoint(string workstationID, string applicationSender, int requestId, int transactionId, string releaseToken, int deviceId, int deviceStatus, int status, string overallResult);

        [DispId(13)]
        void ChangeFuelMode(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int mode, int status, string overallResult);

        //[DispId(14)]
        //void ChangeFuelPrice(string workstationID, string applicationSender, int requestId, int productId, double newprice, int mode, double oldprice, string overallResult);

        [DispId(15)]
        void LockFuelSaleTrx(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken, int status, int fuellingState, string overallResult);

        [DispId(16)]
        void UnlockFuelSaleTrx(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken, int status, int fuellingState, string overallResult);

        [DispId(17)]
        void ClearFuelSaleTrx(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken, int status, int fuellingState, string overallResult);

        [DispId(18)]
        bool GetAvailableFuelSaleTrxsAdd(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken, int state);

        [DispId(19)]
        bool GetAvailableFuelSaleTrxsSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(20)]
        bool GetFuelSaleTrxDetailsAdd(string workstationID, string applicationSender, int requestId, int deviceId, double volume, double amount, double price, int nozzle, int productNo, string productName, string productUM, int mode, int transactionId, string releaseToken, int state, string startTime, string endTime, string lockingAS, string authorisationAS, int reservingDeviceId, int fuellingType);

        [DispId(21)]
        bool GetFuelSaleTrxDetailsSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(22)]
        bool GetProductTableAdd(string workstationID, string applicationSender, int requestId, int productNo, string ProductName);

        [DispId(23)]
        bool GetProductTableSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(24)]
        bool GetModeTableAdd(string workstationID, string applicationSender, int requestId, int modeNo, string ModeName);

        [DispId(25)]
        bool GetModeTableSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(26)]
        bool GetFuelModeAdd(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int modeNo);

        [DispId(27)]
        bool GetFuelModeSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(28)]
        bool GetConfigurationAddDSP(string workstationID, string applicationSender, int requestId, int deviceId, int productNo, string ProductName, int FuelPriceModeNo, double FuelPrice);

        [DispId(29)]
        bool GetConfigurationAddFP(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int nozzleNo, int productNo1, int productNo2, double blendRatio, int blendProductNo);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="workstationID"></param>
        /// <param name="applicationSender"></param>
        /// <param name="requestId"></param>
        /// <param name="tankDevice_pumpId_nozzleId_Map">list of tankDeviceId:PumpId:NozzleLogicalId</param>
        /// <returns></returns>
        [DispId(30)]
        bool GetConfigurationAddTLG(string workstationID, string applicationSender, int requestId, IEnumerable<IGrouping<Tank, IGrouping<int, byte>>> tankDevice_pumpId_nozzleId_Map);

        [DispId(31)]
        bool GetConfigurationAddTP(string workstationID, string applicationSender, int requestId, int tlgId, int deviceId, int tankNo, int productNo, string ProductName, int manualMode, double shellCapacity, double maxSafeFillCap, double lowCapacity, double minOperatingCapacity, int tankManifoldPartnersTankNo, double hiHiLevel, double hiLevel, double loLevel, double loLoLevel, double hiWater);

        [DispId(32)]
        bool GetConfigurationAddPP(string workstationID, string applicationSender, int requestId, int DeviceId, int logicalDeviceNo, int manualMode, int segmentNo, int productNo, string ProductName, double ProductPrice, int modeNo);

        [DispId(33)]
        bool GetConfigurationSend(string workstationID, string applicationSender, int requestId, string deviceType, string overallResult);

        [DispId(34)]
        void SetConfiguration(string workstationID, string applicationSender, int requestId, string overallResult);

        [DispId(35)]
        void LockNozzle(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int nozzleNo, int status, string overallResult);

        [DispId(36)]
        void UnlockNozzle(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int nozzleNo, int status, string overallResult);

        [DispId(37)]
        void GetCountrySettings(string workstationID, string applicationSender, int requestId, string volumeUnit, string currencyCode, string levelUnit, string temperatureUnit, string thousandDelimiter, string decimalSign, string countryCode, string languageCode, int status, string overallResult);

        [DispId(38)]
        bool GetDSPLimitsAdd(string workstationID, string applicationSender, int requestId, int deviceId, int productNo, int modeNo, double maxTrxAmount, double maxTrxVolume);

        [DispId(39)]
        bool GetDSPLimitsSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(40)]
        void ChangeDSPLimits(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(41)]
        void SuspendFuellingAdd(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int deviceStatus);

        [DispId(42)]
        void ResumeFuellingAdd(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int deviceStatus);

        [DispId(43)]
        void LockTank(string workstationID, string applicationSender, int requestId, int deviceId, int tankNo, int status, string overallResult);

        [DispId(44)]
        void UnlockTank(string workstationID, string applicationSender, int requestId, int deviceId, int tankNo, int status, string overallResult);

        //[DispId(45)]
        //void GetTankData(string workstationID, string applicationSender, int requestId, int deviceId, int tankNo, int manualMode, int TPStatus, double productLevel, double totalObservedVolume, double grossStandardVolume, double averageTemp, double waterLevel, double observedDensity, string overallResult);

        [DispId(46)]
        void ReserveFuelPoint(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int status, string overallResult);

        [DispId(47)]
        void FreeFuelPoint(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int status, string overallResult);

        [DispId(48)]
        bool GetCurrentFuellingStatusAdd(string workstationID, string applicationSender, int requestId, int deviceId, double volume, double amount, double price, int nozzle, int transactionId, string releaseToken, string authorisationAS);

        [DispId(49)]
        bool GetCurrentFuellingStatusSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(50)]
        void StartFuelPointTest(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int status, string overallResult);

        [DispId(51)]
        void EndFuelPointTest(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int status, string overallResult);

        [DispId(52)]
        void GetFuelPointTotalsAdd(string workstationID, string applicationSender, int requestId, int deviceId, int nozzleId, int productNo, double volume, double amount, double price);
        [DispId(53)]
        void GetFuelPointTotalsSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(54)]
        void SetDeviceAlarm(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int status, string overallResult);

        [DispId(55)]
        void OpenFuelPointAdd(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int deviceStatus);

        [DispId(56)]
        void CloseFuelPointAdd(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int deviceStatus);



        [DispId(57)]
        void OpenFuelPointSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(58)]
        void CloseFuelPointSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(59)]
        void SuspendFuellingSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(60)]
        void ResumeFuellingSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(61)]
        void TerminateFuellingSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(62)]
        void GetDeviceStateSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);

        [DispId(63)]
        void GetTankDataAdd(string workstationID, string applicationSender, int requestId, int deviceId, int tankNo, int manualMode, int TPStatus, double productLevel, double totalObservedVolume, double grossStandardVolume, double averageTemp, double waterLevel, double observedDensity, int logicalStatus, int deviceStatus);
        [DispId(64)]
        void GetTankDataSend(string workstationID, string applicationSender, int requestId, int status, string overallResult);


        [DispId(80)]
        void DeviceStateChange(string deviceType, int deviceId, int deviceState, int deviceSubState, string errorId, string errorDescription, string lockingAS, int nozzleListNum, int nozzleListState, int nozzleListLogicalState, int nozzleListTankState);

        [DispId(81)]
        void FDCStop();

        [DispId(82)]
        void FDCStart();

        [DispId(83)]
        void CurrentFuellingStatus(int deviceId, double volume, double amount, double price, int nozzle, int transactionId, string releaseToken, int mode, int productNo);

        [DispId(84)]
        void DeviceAlarm(string deviceType, int deviceId, int alarmId, string alarmDescr);

        [DispId(85)]
        void FuelSaleTrx(int deviceId, double volume, double amount, double price, int nozzle, int productNo, string productName, string productUM, int mode, int transactionId, int transactionStatus, int completionReason, string releaseToken, string startTime, string endTime, string lockingAS, string authorisationAS, int reservingDeviceId, int fuellingType);

        [DispId(86)]
        void FuelPriceChange(int productNo, int modeNo, double newPrice, double oldPrice, string effectiveDateTime);

        [DispId(87)]
        void FuelModeChange(string deviceType, int deviceId, int modeNo);

        [DispId(88)]
        void FDCExceptionMsg(int exceptionNo, string description);

        [DispId(89)]
        void ConfigurationChange(int fDCDeviceStatus);



        [DispId(101)]
        void Add(string workstationID, string applicationSender, int requestId, string deviceType, int iOptId, string overallResult);

        [DispId(102)]
        void Remove(string workstationID, string applicationSender, int requestId, string deviceType, int iOptId, string overallResult);

        [DispId(103)]
        void Write(string workstationID, string applicationSender, int requestId, string deviceType, int iOptId, string overallResult);


        [DispId(130)]
        void DeviceStateChange(string deviceType, int iOptId, int state, int substate);

        [DispId(131)]
        //void Read(string deviceType, int iOptId, byte[] message);
        void Read(string deviceType, int iOptId, string message);
        #endregion
    }

    [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
    [Guid("ABFFCF76-2598-4698-9A3E-D7D915A12413")]
    public interface IFDCPOSInterfaceServerEvents
    {
        #region MyRegion
        [DispId(1)]
        void OnLogOnReq(string workstationID, string applicationSender, int requestID, int responsePort, int unsolicitedPort, int version);

        [DispId(2)]
        void OnLogOffReq(string workstationID, string applicationSender, int requestID);

        [DispId(3)]
        void OnVersionInfoReq(string workstationID, string applicationSender, int requestID);

        [DispId(4)]
        void OnStartForecourtReq(string workstationID, string applicationSender, int requestID);

        [DispId(5)]
        void OnStopForecourtReq(string workstationID, string applicationSender, int requestID, bool emergencyStop);

        [DispId(6)]
        void OnGetCurrentFuellingStatusReq(string workstationID, string applicationSender, int requestID, int deviceId);

        [DispId(7)]
        void OnGetDeviceStateReq(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId);

        [DispId(8)]
        void OnTerminateFuellingReq(string workstationID, string applicationSender, int requestID, int deviceId);

        [DispId(9)]
        void OnAuthoriseFuelPointReq(string workstationID, string applicationSender, int requestID, string releaseToken, int fuellingType, int deviceId, int reservingDeviceId, double maxTrxAmount, double maxTrxVolume, string products, int mode, bool lockFuelSaleTrx, string payType);

        [DispId(10)]
        void OnChangeFuelModeReq(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId, int mode);

        //[DispId(11)]
        //double OnChangeFuelPriceReq(string workstationID, string applicationSender, int requestID, int product, double price, int mode);

        [DispId(12)]
        void OnLockFuelSaleTrxReq(string workstationID, string applicationSender, int requestID, int deviceId, int transactionNo, string releaseToken);

        [DispId(13)]
        void OnUnlockFuelSaleTrxReq(string workstationID, string applicationSender, int requestID, int deviceId, int transactionNo, string releaseToken);

        [DispId(14)]
        void OnClearFuelSaleTrxReq(string workstationID, string applicationSender, int requestID, int deviceId, int transactionNo, string releaseToken);

        [DispId(15)]
        void OnGetAvailableFuelSaleTrxsReq(string workstationID, string applicationSender, int requestID, int deviceId);

        [DispId(16)]
        void OnGetFuelSaleTrxDetailsReq(string workstationID, string applicationSender, int requestID, int deviceId, int transactionNo, string releaseToken);

        [DispId(17)]
        void OnGetProductTableReq(string workstationID, string applicationSender, int requestID);

        [DispId(18)]
        void OnGetModeTableReq(string workstationID, string applicationSender, int requestID);

        [DispId(19)]
        void OnGetFuelModeReq(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId);

        [DispId(20)]
        void OnGetConfigurationReq(string workstationID, string applicationSender, int requestID, string deviceType);

        [DispId(21)]
        void OnSetConfigurationAddDSPReq(string workstationID, string applicationSender, int requestID, int deviceId, int productNo, string ProductName, int fuelPriceModeNo, double fuelPrice);
        [DispId(22)]
        void OnSetConfigurationEndDSPReq(string workstationID, string applicationSender, int requestID, int deviceId);
        [DispId(23)]
        void OnSetConfigurationAddFPReq(string workstationID, string applicationSender, int requestID, int deviceId, int pumpNo, int nozzleNo, int productNo1, int productNo2, double blendRatio, int blendProductNo);
        [DispId(24)]
        void OnSetConfigurationEndFPReq(string workstationID, string applicationSender, int requestID, int deviceId);
        [DispId(25)]
        void OnSetConfigurationAddTLGReq(string workstationID, string applicationSender, int requestID, int deviceId);
        [DispId(26)]
        void OnSetConfigurationEndTLGReq(string workstationID, string applicationSender, int requestID, int deviceId);
        [DispId(27)]
        void OnSetConfigurationAddTPReq(string workstationID, string applicationSender, int requestID, int deviceId, int tankNo, int productNo, string ProductName, int manualMode, double shellCapacity, double maxSafeFillCap, double lowCapacity, double minOperatingCapacity, int tankManifoldPartnersTankNo, double hiHiLevel, double hiLevel, double loLevel, double loLoLevel, double hiWater);
        [DispId(28)]
        void OnSetConfigurationEndTPReq(string workstationID, string applicationSender, int requestID, int deviceId, int tankNo);
        [DispId(29)]
        void OnSetConfigurationAddPPReq(string workstationID, string applicationSender, int requestID, int deviceId, int logicalDeviceNo, int manualMode, int segmentNo, int productNo, string ProductName, double productPrice);
        [DispId(30)]
        void OnSetConfigurationEndPPReq(string workstationID, string applicationSender, int requestID, int deviceId);

        [DispId(31)]
        void OnLockNozzleReq(string workstationID, string applicationSender, int requestID, int deviceId, int nozzleNo);
        [DispId(32)]
        void OnUnlockNozzleReq(string workstationID, string applicationSender, int requestID, int deviceId, int nozzleNo);

        [DispId(33)]
        void OnGetCountrySettingsReq(string workstationID, string applicationSender, int requestID);

        [DispId(34)]
        void OnGetDSPLimitsReq(string workstationID, string applicationSender, int requestID, int deviceId);

        [DispId(35)]
        void OnChangeDSPLimitsReq(string workstationID, string applicationSender, int requestID, int deviceId, int productNo, int modeNo, double maxTrxAmount, double maxTrxVolume);

        [DispId(36)]
        void OnSuspendFuellingReq(string workstationID, string applicationSender, int requestID, int deviceId);

        [DispId(37)]
        void OnResumeFuellingReq(string workstationID, string applicationSender, int requestID, int deviceId);

        [DispId(38)]
        void OnLockTankReq(string workstationID, string applicationSender, int requestID, int deviceId, int tankNo);

        [DispId(39)]
        void OnUnlockTankReq(string workstationID, string applicationSender, int requestID, int deviceId, int tankNo);

        [DispId(40)]
        void OnGetTankDataReq(string workstationID, string applicationSender, int requestID, int deviceId, int tankNo);

        [DispId(41)]
        void OnReserveFuelPointReq(string workstationID, string applicationSender, int requestID, int deviceId);
        [DispId(42)]
        void OnFreeFuelPointReq(string workstationID, string applicationSender, int requestID, int deviceId);

        [DispId(43)]
        void OnStartFuelPointTestReq(string workstationID, string applicationSender, int requestID, int deviceId);
        [DispId(44)]
        void OnEndFuelPointTestReq(string workstationID, string applicationSender, int requestID, int deviceId);

        [DispId(45)]
        void OnGetFuelPointTotalsReq(string workstationID, string applicationSender, int requestId, int deviceId, int nozzleId);

        [DispId(46)]
        void OnSetDeviceAlarmReq(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int alarmCode, string alarmMsg);

        [DispId(47)]
        void OnOpenFuelPointReq(string workstationID, string applicationSender, int requestId, int deviceId);
        [DispId(48)]
        void OnCloseFuelPointReq(string workstationID, string applicationSender, int requestId, int deviceId);

        [DispId(49)]
        void OnClientDisconnected(string workstationID, string applicationSender);

        [DispId(50)]
        double OnChangeFuelPriceAddReq(string workstationID, string applicationSender, int requestID, int product, double price, int mode, string effectiveDateTime);
        [DispId(51)]
        string OnChangeFuelPriceEndReq(string workstationID, string applicationSender, int requestID);

        [DispId(52)]
        int OnChangeFuelModeAddReq(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId, int mode);
        [DispId(53)]
        string OnChangeFuelModeEndReq(string workstationID, string applicationSender, int requestID);

        [DispId(54)]
        void OnValidateSealAddReq(string filename, string version, string hash, string addInfo);
        [DispId(55)]
        bool OnValidateSealEndReq(bool go);

        [DispId(60)]
        string OnChangeFuelPriceInStringReq(string workstationID, string applicationSender, int requestID, string formattedValues);

        [DispId(101)]
        void OnAddSerialPortReq(string workstationID, string applicationSender, int requestId, string deviceType, int iOptId, int port, int baudRate, int dataBit, int stopBit, int parity);

        [DispId(102)]
        void OnAddTCPReq(string workstationID, string applicationSender, int requestId, string deviceType, int iOptId, string address, int port);

        [DispId(103)]
        void OnRemoveReq(string workstationID, string applicationSender, int requestId, string deviceType, int iOptId);

        [DispId(104)]
        //void OnWriteReq(string workstationID, string applicationSender, int requestId, string deviceType, int iOptId, byte[] message);
        void OnWriteReq(string workstationID, string applicationSender, int requestId, string deviceType, int iOptId, string message);
        #endregion
    }

    [Guid("6B1019E4-0E55-4301-ADBE-2187520CD5FF")]
    [ClassInterface(ClassInterfaceType.None)]
    [ComVisible(true)]
    [ProgId("FDCPOSInterface.FDCPOSInterfaceServer")]
    [ComSourceInterfaces(typeof(IFDCPOSInterfaceServerEvents))]
    public class FDCPOSInterfaceServer : IFDCPOSInterfaceServer
    {
        public bool IsStarted { get; private set; }
        private static IServiceProvider services;

        [ComVisible(false)]
        public FdcPosMessages messages;
        [ComVisible(false)]
        FDCPOSInterfaceServerManager fdcposManager;

        public static IFDCPOSInterfaceServer CreateFDCPOSInterface()
        {
            return new FDCPOSInterfaceServer(services);
        }

        // Remember! the constructor cannot have parameters when called from COM CreateInstance
        public FDCPOSInterfaceServer(IServiceProvider services)
        {
            try
            {
                FDCPOSInterfaceServer.services = services;
                if (FDCPOSInterfaceServerManager.fdcPosManager == null)
                    FDCPOSInterfaceServerManager.fdcPosManager = new FDCPOSInterfaceServerManager(services);
                //FDCPOSInterfaceServerManager.fdcposManager.fdcPosInterface = this;
                this.fdcposManager = (FDCPOSInterfaceServerManager)FDCPOSInterfaceServerManager.fdcPosManager;
                fdcposManager.fdcPosInterface = this;

                var loggerFactory = services.GetRequiredService<ILoggerFactory>();
                var fdcServerSocketLogger = loggerFactory.CreateLogger("DynamicPrivate_FdcServerSocket");
                messages = new FdcPosMessages(fdcposManager, fdcServerSocketLogger);
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine(ex.Message + ":" + ex.StackTrace);
            }
        }

        public void Disconnect(string workstationID, string applicationSender)
        {
            OnClientDisconnected?.Invoke(workstationID, applicationSender);

        }

        [ComVisible(false)]
        public System.Threading.Timer timerCurrentFuellingStatus = null;

        #region public delegate void OnLogOnReqTarget, public event OnLogOnReqTarget OnLogOnReq;

        public delegate void OnLogOnReqTarget(string workstationID, string applicationSender, int requestId, int responsePort, int unsolicitedPort, int version);
        public delegate void OnValidateSealAddReqTarget(string filename, string version, string hash, string addInfo);
        public delegate bool OnValidateSealEndReqTarget(bool go);
        public delegate void OnLogOffReqTarget(string workstationID, string applicationSender, int requestId);
        public delegate void OnVersionInfoReqTarget(string workstationID, string applicationSender, int requestId);
        public delegate void OnStartForecourtReqTarget(string workstationID, string applicationSender, int requestId);
        public delegate void OnStopForecourtReqTarget(string workstationID, string applicationSender, int requestId, bool emergencyStop);
        public delegate void OnGenericTypelessMessageReqTarget(string workstationID, string applicationSender, int requestId, string message);

        public delegate void OnGetCurrentFuellingStatusReqTarget(string workstationID, string applicationSender, int requestId, int deviceId);
        public delegate void OnGetFuelPointTotalsReqTarget(string workstationID, string applicationSender, int requestId, int deviceId, int nozzleId);
        public delegate void OnGetDeviceStateReqTarget(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId);
        public delegate void OnTerminateFuellingReqTarget(string workstationID, string applicationSender, int requestId, int deviceId);
        public delegate void OnAuthoriseFuelPointReqTarget(string workstationID, string applicationSender, int requestId, string releaseToken, int fuellingType, int deviceId, int reservingDeviceId, double maxTrxAmount, double maxTrxVolume, string products, int mode, bool lockFuelSaleTrx, string payType);
        public delegate void OnChangeFuelModeReqTarget(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int mode);
        public delegate int OnChangeFuelModeAddReqTarget(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int mode);
        public delegate string OnChangeFuelModeEndReqTarget(string workstationID, string applicationSender, int requestId);
        //public delegate double OnChangeFuelPriceReqTarget(string workstationID, string applicationSender, int requestId, int product, double price, int mode);
        public delegate double OnChangeFuelPriceAddReqTarget(string workstationID, string applicationSender, int requestId, int product, double price, int mode, string effectiveDateTime);
        public delegate string OnChangeFuelPriceEndReqTarget(string workstationID, string applicationSender, int requestId);
        public delegate string OnChangeFuelPriceInStringReqTarget(string workstationID, string applicationSender, int requestId, string formattedValues);
        public delegate void OnLockFuelSaleTrxReqTarget(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken);
        public delegate void OnUnlockFuelSaleTrxReqTarget(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken);
        public delegate void OnClearFuelSaleTrxReqTarget(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken);
        public delegate void OnGetAvailableFuelSaleTrxsReqTarget(string workstationID, string applicationSender, int requestId, int deviceId);
        public delegate void OnGetFuelSaleTrxDetailsReqTarget(string workstationID, string applicationSender, int requestID, int deviceId, int transactionNo, string releaseToken);
        public delegate void OnGetProductTableReqTarget(string workstationID, string applicationSender, int requestID);
        public delegate void OnGetModeTableReqTarget(string workstationID, string applicationSender, int requestID);
        public delegate void OnGetFuelModeReqTarget(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId);
        public delegate void OnGetConfigurationReqTarget(string workstationID, string applicationSender, int requestID, string deviceType);
        public delegate void OnSetConfigurationAddDSPReqTarget(string workstationID, string applicationSender, int requestID, int deviceId, int productNo, string ProductName, int FuelPriceModeNo, double FuelPrice);
        public delegate void OnSetConfigurationEndDSPReqTarget(string workstationID, string applicationSender, int requestID, int deviceId);
        public delegate void OnSetConfigurationAddFPReqTarget(string workstationID, string applicationSender, int requestID, int deviceId, int pumpNo, int nozzleNo, int productNo1, int productNo2, double blendRatio, int blendProductNo);
        public delegate void OnSetConfigurationEndFPReqTarget(string workstationID, string applicationSender, int requestID, int deviceId);
        public delegate void OnSetConfigurationAddTLGReqTarget(string workstationID, string applicationSender, int requestID, int deviceId);
        public delegate void OnSetConfigurationAddTPReqTarget(string workstationID, string applicationSender, int requestID, int deviceId, int tankNo, int productNo, string ProductName, int manualMode, double shellCapacity, double maxSafeFillCap, double lowCapacity, double minOperatingCapacity, int tankManifoldPartnersTankNo, double hiHiLevel, double hiLevel, double loLevel, double loLoLevel, double hiWater);
        public delegate void OnSetConfigurationEndTPReqTarget(string workstationID, string applicationSender, int requestID, int deviceId, int tankNo);
        public delegate void OnSetConfigurationAddPPReqTarget(string workstationID, string applicationSender, int requestID, int deviceId, int logicalDeviceNo, int manualMode, int segmentNo, int productNo, string ProductName, double productPrice);
        public delegate void OnSetConfigurationEndPPReqTarget(string workstationID, string applicationSender, int requestID, int deviceId);
        public delegate void OnLockNozzleReqTarget(string workstationID, string applicationSender, int requestID, int deviceId, int NozzleNo);
        public delegate void OnUnlockNozzleReqTarget(string workstationID, string applicationSender, int requestID, int deviceId, int NozzleNo);
        public delegate void OnGetCountrySettingsReqTarget(string workstationID, string applicationSender, int requestID);
        public delegate void OnGetDSPLimitsReqTarget(string workstationID, string applicationSender, int requestID, int deviceId);
        public delegate void OnChangeDSPLimitsReqTarget(string workstationID, string applicationSender, int requestID, int deviceId, int productNo, int modeNo, double maxTrxAmount, double maxTrxVolume);
        public delegate void OnSuspendFuellingReqTarget(string workstationID, string applicationSender, int requestID, int deviceId);
        public delegate void OnResumeFuellingReqTarget(string workstationID, string applicationSender, int requestID, int deviceId);
        public delegate void OnLockTankReqTarget(string workstationID, string applicationSender, int requestID, int deviceId, int tankNo);
        public delegate void OnUnlockTankReqTarget(string workstationID, string applicationSender, int requestID, int deviceId, int tankNo);
        public delegate void OnGetTankDataReqTarget(string workstationID, string applicationSender, int requestID, int deviceId, int tankNo);
        public delegate void OnReserveFuelPointReqTarget(string workstationID, string applicationSender, int requestID, int deviceId);
        public delegate void OnFreeFuelPointReqTarget(string workstationID, string applicationSender, int requestID, int deviceId);
        public delegate void OnStartFuelPointTestReqTarget(string workstationID, string applicationSender, int requestID, int deviceId);
        public delegate void OnEndFuelPointTestReqTarget(string workstationID, string applicationSender, int requestID, int deviceId);
        public delegate void OnSetDeviceAlarmReqTarget(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId, int alarmCode, string alarmMsg);
        public delegate void OnOpenFuelPointReqTarget(string workstationID, string applicationSender, int requestID, int deviceId);
        public delegate void OnCloseFuelPointReqTarget(string workstationID, string applicationSender, int requestID, int deviceId);
        public delegate void OnClientDisconnectedTarget(string workstationID, string applicationSender);


        public event OnLogOnReqTarget OnLogOnReq;
        public event OnValidateSealAddReqTarget OnValidateSealAddReq;
        public event OnValidateSealEndReqTarget OnValidateSealEndReq;
        public event OnLogOffReqTarget OnLogOffReq;
        public event OnVersionInfoReqTarget OnVersionInfoReq;
        public event OnStartForecourtReqTarget OnStartForecourtReq;
        public event OnStopForecourtReqTarget OnStopForecourtReq;
        public event OnGenericTypelessMessageReqTarget OnGetGenericTypelessMessageReq;

        public event OnGetCurrentFuellingStatusReqTarget OnGetCurrentFuellingStatusReq;
        public event OnGetFuelPointTotalsReqTarget OnGetFuelPointTotalsReq;
        public event OnGetDeviceStateReqTarget OnGetDeviceStateReq;
        public event OnTerminateFuellingReqTarget OnTerminateFuellingReq;
        public event OnAuthoriseFuelPointReqTarget OnAuthoriseFuelPointReq;
        public event OnChangeFuelModeReqTarget OnChangeFuelModeReq;
        public event OnChangeFuelModeAddReqTarget OnChangeFuelModeAddReq;
        public event OnChangeFuelModeEndReqTarget OnChangeFuelModeEndReq;
        //public event OnChangeFuelPriceReqTarget OnChangeFuelPriceReq;
        public event OnChangeFuelPriceAddReqTarget OnChangeFuelPriceAddReq;
        public event OnChangeFuelPriceEndReqTarget OnChangeFuelPriceEndReq;
        public event OnChangeFuelPriceInStringReqTarget OnChangeFuelPriceInStringReq;
        public event OnLockFuelSaleTrxReqTarget OnLockFuelSaleTrxReq;
        public event OnUnlockFuelSaleTrxReqTarget OnUnlockFuelSaleTrxReq;
        public event OnClearFuelSaleTrxReqTarget OnClearFuelSaleTrxReq;
        public event OnGetAvailableFuelSaleTrxsReqTarget OnGetAvailableFuelSaleTrxsReq;
        public event OnGetFuelSaleTrxDetailsReqTarget OnGetFuelSaleTrxDetailsReq;
        public event OnGetProductTableReqTarget OnGetProductTableReq;
        public event OnGetModeTableReqTarget OnGetModeTableReq;
        public event OnGetFuelModeReqTarget OnGetFuelModeReq;
        public event OnGetConfigurationReqTarget OnGetConfigurationReq;
        public event OnSetConfigurationAddDSPReqTarget OnSetConfigurationAddDSPReq;
        public event OnSetConfigurationEndDSPReqTarget OnSetConfigurationEndDSPReq;
        public event OnSetConfigurationAddFPReqTarget OnSetConfigurationAddFPReq;
        public event OnSetConfigurationEndFPReqTarget OnSetConfigurationEndFPReq;
        public event OnSetConfigurationAddTLGReqTarget OnSetConfigurationAddTLGReq;
        public event OnSetConfigurationAddTPReqTarget OnSetConfigurationAddTPReq;
        public event OnSetConfigurationEndTPReqTarget OnSetConfigurationEndTPReq;
        public event OnSetConfigurationAddPPReqTarget OnSetConfigurationAddPPReq;
        public event OnSetConfigurationEndPPReqTarget OnSetConfigurationEndPPReq;
        public event OnLockNozzleReqTarget OnLockNozzleReq;
        public event OnUnlockNozzleReqTarget OnUnlockNozzleReq;
        public event OnGetCountrySettingsReqTarget OnGetCountrySettingsReq;
        public event OnGetDSPLimitsReqTarget OnGetDSPLimitsReq;
        public event OnChangeDSPLimitsReqTarget OnChangeDSPLimitsReq;
        public event OnSuspendFuellingReqTarget OnSuspendFuellingReq;
        public event OnResumeFuellingReqTarget OnResumeFuellingReq;
        public event OnLockTankReqTarget OnLockTankReq;
        public event OnUnlockTankReqTarget OnUnlockTankReq;
        public event OnGetTankDataReqTarget OnGetTankDataReq;
        public event OnReserveFuelPointReqTarget OnReserveFuelPointReq;
        public event OnFreeFuelPointReqTarget OnFreeFuelPointReq;
        public event OnStartFuelPointTestReqTarget OnStartFuelPointTestReq;
        public event OnEndFuelPointTestReqTarget OnEndFuelPointTestReq;
        public event OnSetDeviceAlarmReqTarget OnSetDeviceAlarmReq;
        public event OnOpenFuelPointReqTarget OnOpenFuelPointReq;
        public event OnCloseFuelPointReqTarget OnCloseFuelPointReq;
        public event OnClientDisconnectedTarget OnClientDisconnected;

        #endregion

        public bool Start(int iIPPortA, bool encryptedHeader, string forecourtConfiguration, int version, bool useExtensions, string certificate)
        {
            //FDCPOSManager.tracer.WriteLine(string.Format("init: port={0}, encryptedHeader={1}, version={2}, useExtensions={3}, certificate={4}", iIPPortA, encryptedHeader, version, useExtensions, certificate));
            var result = messages.Start(iIPPortA, encryptedHeader, forecourtConfiguration, version, useExtensions, certificate);
            this.IsStarted = true;
            GetCountrySettingsReq("", FDCPOSInterfaceServerManager.FDCPOSServerApplication, -1);
            return result;
        }

        public bool Stop()
        {
            messages.Stop();
            this.IsStarted = false;
            return true;
        }

        public void TestEvent()
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnLogOnReq != null)
            {
                //OnLogOnReq(1, 100, 101);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        #region handle incoming ServiceRequests from Fdc client

        public void ValidateSealAddReq(string filename, string version, string hash, string addInfo)
        {
            bool res = false;
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnValidateSealAddReq != null)
            {
                //OnLogOnReq(workstationID, applicationSender, requestID, iResponsePort, iUnsolicitedPort);
                OnValidateSealAddReq(filename, version, hash, addInfo);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }
        public bool ValidateSealEndReq(bool go)
        {
            bool res = false;
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnValidateSealEndReq != null)
            {
                //OnLogOnReq(workstationID, applicationSender, requestID, iResponsePort, iUnsolicitedPort);
                res = OnValidateSealEndReq(go);
            }
            //FDCPOSManager.tracer.WriteLine("end");
            return res;
        }

        public void LogOnReq(string workstationID, string applicationSender, int requestID, int iResponsePort, int iUnsolicitedPort, int version)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnLogOnReq != null)
            {
                //OnLogOnReq(workstationID, applicationSender, requestID, iResponsePort, iUnsolicitedPort);
                OnLogOnReq(workstationID, applicationSender, requestID, iResponsePort, iUnsolicitedPort, version);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void LogOffReq(string workstationID, string applicationSender, int requestID)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnLogOffReq != null)
            {
                OnLogOffReq(workstationID, applicationSender, requestID);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void VersionInfoReq(string workstationID, string applicationSender, int requestID)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnVersionInfoReq != null)
            {
                OnVersionInfoReq(workstationID, applicationSender, requestID);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void StartForecourtReq(string workstationID, string applicationSender, int requestID)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnStartForecourtReq != null)
            {
                OnStartForecourtReq(workstationID, applicationSender, requestID);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void StopForecourtReq(string workstationID, string applicationSender, int requestID, bool emergencyStop)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnStopForecourtReq != null)
            {
                OnStopForecourtReq(workstationID, applicationSender, requestID, emergencyStop);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void GenericTypelessMessageReq(string workstationID, string applicationSender, int requestID, string message)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnGetGenericTypelessMessageReq != null)
            {
                OnGetGenericTypelessMessageReq(workstationID, applicationSender, requestID, message);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void GetCurrentFuellingStatusReq(string workstationID, string applicationSender, int requestID, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnGetCurrentFuellingStatusReq != null)
            {
                OnGetCurrentFuellingStatusReq(workstationID, applicationSender, requestID, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void GetFuelPointTotalsReq(string workstationID, string applicationSender, int requestID, int deviceId, int nozzleId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnGetFuelPointTotalsReq != null)
            {
                OnGetFuelPointTotalsReq(workstationID, applicationSender, requestID, deviceId, nozzleId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void GetDeviceStateReq(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnGetDeviceStateReq != null)
            {
                OnGetDeviceStateReq(workstationID, applicationSender, requestID, deviceType, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void TerminateFuellingReq(string workstationID, string applicationSender, int requestID, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnTerminateFuellingReq != null)
            {
                OnTerminateFuellingReq(workstationID, applicationSender, requestID, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void AuthoriseFuelPointReq(string workstationID, string applicationSender, int requestID, string releaseToken, int fuellingType, int deviceId, int reservingDeviceId, decimal maxTrxAmount, decimal maxTrxVolume, string products, int mode, bool lockFuelSaleTrx, string payType)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnAuthoriseFuelPointReq != null)
            {
                //FDCPOSManager.tracer.WriteLine("OnAuthoriseFuelPointReq != null");
                OnAuthoriseFuelPointReq(workstationID, applicationSender, requestID, releaseToken, fuellingType, deviceId, reservingDeviceId, Convert.ToDouble(maxTrxAmount), Convert.ToDouble(maxTrxVolume), products, mode, lockFuelSaleTrx, payType);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void ChangeFuelModeReq(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId, int mode)
        {
            string result = OverallResult.Success.ToString();
            //FDCPOSManager.tracer.WriteLine(string.Format("init: device={0}, mode={1}", deviceId, mode));
            if (OnChangeFuelModeAddReq != null)
            {
                OnChangeFuelModeReq(workstationID, applicationSender, requestID, deviceType, deviceId, mode);

                //int nRetries = maxRetries;
                //while (nRetries > 0)
                //{
                //    nRetries--;
                //    result = OnChangeFuelModeReq(workstationID, applicationSender, requestID, deviceType, deviceId, mode);
                //    if (result == OverallResult.Success.ToString())
                //        break;
                //}
                //if (nRetries == 0)
                //    this.messages.ChangeFuelMode(workstationID, applicationSender, requestId, deviceType, deviceId, mode, ErrorCode., overallResult);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }
        public int ChangeFuelModeAddReq(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId, int mode)
        {
            int result = (int)ErrorCode.ERRCD_OK;
            //FDCPOSManager.tracer.WriteLine(string.Format("init: device={0}, mode={1}", deviceId, mode));
            if (OnChangeFuelModeAddReq != null)
            {
                result = OnChangeFuelModeAddReq(workstationID, applicationSender, requestID, deviceType, deviceId, mode);
            }
            //FDCPOSManager.tracer.WriteLine("end");
            return result;
        }
        public string ChangeFuelModeEndReq(string workstationID, string applicationSender, int requestID)
        {
            string result = OverallResult.Success.ToString();
            //FDCPOSManager.tracer.WriteLine(string.Format("init: "));
            if (OnChangeFuelModeEndReq != null)
            {
                result = OnChangeFuelModeEndReq(workstationID, applicationSender, requestID);
            }
            //FDCPOSManager.tracer.WriteLine("end");
            return result;
        }
        //public string ChangeFuelPriceReq(string workstationID, string applicationSender, int requestID, int product, decimal price, int mode, out double oldPrice)
        //{
        //    string result = OverallResult.Success.ToString();
        //    //FDCPOSManager.tracer.WriteLine("init");
        //    Double tempOldPrice;
        //    oldPrice = -1;
        //    if (OnChangeFuelPriceReq != null)
        //    {
        //        tempOldPrice = OnChangeFuelPriceReq(workstationID, applicationSender, requestID, product, Convert.ToDouble(price), mode);
        //        if (tempOldPrice == -1)
        //        {
        //            result = OverallResult.Failure.ToString();
        //        }
        //        else
        //            oldPrice = tempOldPrice;
        //    }
        //    //FDCPOSManager.tracer.WriteLine(string.Format("end:  result={0}, oldPrice={1}", result, oldPrice));
        //    return result;
        //}

        public string ChangeFuelPriceAddReq(string workstationID, string applicationSender, int requestID, int product, decimal price, int mode, string effectiveDateTime, out double oldPrice)
        {
            string result = OverallResult.Success.ToString();
            //FDCPOSManager.tracer.WriteLine("init");
            Double tempOldPrice;
            oldPrice = -1;
            if (OnChangeFuelPriceAddReq != null)
            {
                tempOldPrice = OnChangeFuelPriceAddReq(workstationID, applicationSender, requestID, product, Convert.ToDouble(price), mode, effectiveDateTime);
                if (tempOldPrice == -1)
                {
                    result = OverallResult.Failure.ToString();
                }
                else
                    oldPrice = tempOldPrice;
            }
            //FDCPOSManager.tracer.WriteLine(string.Format("end:  result={0}, oldPrice={1}", result, oldPrice));
            return result;
        }

        public string ChangeFuelPriceEndReq(string workstationID, string applicationSender, int requestID)
        {
            string result = OverallResult.Success.ToString();
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnChangeFuelPriceEndReq != null)
            {
                result = OnChangeFuelPriceEndReq(workstationID, applicationSender, requestID);
            }
            //FDCPOSManager.tracer.WriteLine(string.Format("end:  result={0}", result));
            return result;
        }

        public string ChangeFuelPriceInStringReq(string workstationID, string applicationSender, int requestID, string formattedValues)
        {
            string result = OverallResult.Success.ToString();
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnChangeFuelPriceInStringReq != null)
            {
                result = OnChangeFuelPriceInStringReq(workstationID, applicationSender, requestID, formattedValues);
            }
            //FDCPOSManager.tracer.WriteLine(string.Format("end:  result={0}", result));
            return result;
        }

        public void LockFuelSaleTrxReq(string workstationID, string applicationSender, int requestID, int deviceId, int transactionNo, string releaseToken)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnLockFuelSaleTrxReq != null)
            {
                OnLockFuelSaleTrxReq(workstationID, applicationSender, requestID, deviceId, transactionNo, releaseToken);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void UnlockFuelSaleTrxReq(string workstationID, string applicationSender, int requestID, int deviceId, int transactionNo, string releaseToken)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnUnlockFuelSaleTrxReq != null)
            {
                OnUnlockFuelSaleTrxReq(workstationID, applicationSender, requestID, deviceId, transactionNo, releaseToken);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void ClearFuelSaleTrxReq(string workstationID, string applicationSender, int requestID, int deviceId, int transactionNo, string releaseToken)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnClearFuelSaleTrxReq != null)
            {
                OnClearFuelSaleTrxReq(workstationID, applicationSender, requestID, deviceId, transactionNo, releaseToken);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }
        public void GetAvailableFuelSaleTrxsReq(string workstationID, string applicationSender, int requestID, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnGetAvailableFuelSaleTrxsReq != null)
            {
                OnGetAvailableFuelSaleTrxsReq(workstationID, applicationSender, requestID, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }
        public void GetFuelSaleTrxDetailsReq(string workstationID, string applicationSender, int requestID, int deviceId, int transactionNo, string releaseToken)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnGetFuelSaleTrxDetailsReq != null)
            {
                OnGetFuelSaleTrxDetailsReq(workstationID, applicationSender, requestID, deviceId, transactionNo, releaseToken);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }
        public void GetProductTableReq(string workstationID, string applicationSender, int requestID)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnGetProductTableReq != null)
            {
                OnGetProductTableReq(workstationID, applicationSender, requestID);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void GetModeTableReq(string workstationID, string applicationSender, int requestID)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnGetModeTableReq != null)
            {
                OnGetModeTableReq(workstationID, applicationSender, requestID);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }
        public void GetFuelModeReq(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnGetFuelModeReq != null)
            {
                OnGetFuelModeReq(workstationID, applicationSender, requestID, deviceType, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }
        public void GetConfigurationReq(string workstationID, string applicationSender, int requestID, string deviceType)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnGetConfigurationReq != null)
            {
                OnGetConfigurationReq(workstationID, applicationSender, requestID, deviceType);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void SetConfigurationReq(ServiceRequestSetConfiguration sr)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (sr == null || sr.POSdata == null)
                return;
            ServiceRequestPOSdataSetConfiguration PosDataElem = null;
            if (sr.POSdata.Length > 0)
            {
                PosDataElem = sr.POSdata[0];
            }
            if (PosDataElem == null || PosDataElem.DeviceClass == null || PosDataElem.DeviceClass.Length == 0)
                return;
            bool bDeviceFound = false;
            foreach (ServiceDeviceClassConfiguration deviceClass in PosDataElem.DeviceClass)
            {
                bDeviceFound = false;
                switch (deviceClass.Type)
                {
                    case Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser:
                        if (deviceClass.DSPProduct == null || deviceClass.DSPProduct.Length == 0)
                            break;
                        foreach (ServiceProductDSPDeviceClassConfiguration product in deviceClass.DSPProduct)
                        {
                            if (product.DSPFuelPrice == null || product.DSPFuelPrice.Length == 0)
                                break;
                            foreach (ServiceFuelPriceDSPDeviceClassConfiguration fuelPrice in product.DSPFuelPrice)
                            {
                                if (OnSetConfigurationAddDSPReq != null)
                                {
                                    OnSetConfigurationAddDSPReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(deviceClass.DeviceID), Convert.ToInt32(product.DSPProductNo), product.DSPProductName, Convert.ToInt32(fuelPrice.FPDSPModeNo), FDCConvert.ToDouble(fuelPrice.FPDSPPrice));
                                    bDeviceFound = true;
                                }
                            }
                        }
                        if (bDeviceFound && OnSetConfigurationEndDSPReq != null)
                        {
                            OnSetConfigurationEndDSPReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(deviceClass.DeviceID));
                        }
                        break;
                    case Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint:
                        if (deviceClass.FPNozzle == null || deviceClass.FPNozzle.Length == 0)
                            break;
                        foreach (ServiceNozzleFPDeviceClassConfiguration nozzle in deviceClass.FPNozzle)
                        {
                            if (nozzle.FPProductId == null || nozzle.FPProductId.Length == 0)
                                break;
                            foreach (ServiceProductIdFPDeviceClassConfiguration product in nozzle.FPProductId)
                            {
                                if (OnSetConfigurationAddFPReq != null)
                                {
                                    OnSetConfigurationAddFPReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(deviceClass.DeviceID), Convert.ToInt32(deviceClass.FPPumpNo), Convert.ToInt32(nozzle.FPNozzleNo), Convert.ToInt32(product.PIFPProductNo1), Convert.ToInt32(product.PIFPProductNo2), FDCConvert.ToDouble(product.PIFPBlendRatio), Convert.ToInt32(product.PIFPBlendProductNo));
                                    bDeviceFound = true;
                                }
                            }
                        }
                        if (bDeviceFound && OnSetConfigurationEndFPReq != null)
                        {
                            OnSetConfigurationEndFPReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(deviceClass.DeviceID));
                        }
                        break;
                    case Wayne.FDCPOSLibrary.DeviceType.DT_TankLevelGauge:
                        if (OnSetConfigurationAddTLGReq != null)
                        {
                            OnSetConfigurationAddTLGReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(deviceClass.DeviceID));
                        }
                        break;
                    case Wayne.FDCPOSLibrary.DeviceType.DT_TankProbe:
                        if (deviceClass.TPTankManifoldPartners == null || deviceClass.TPTankManifoldPartners.Length == 0 ||
                            deviceClass.TPSetPoints == null || deviceClass.TPSetPoints.Length == 0)
                            break;
                        foreach (ServiceTankManifoldPartnersTPDeviceClassConfiguration TankManifoldPartners in deviceClass.TPTankManifoldPartners)
                        {
                            if (TankManifoldPartners.TPTankNo == null || TankManifoldPartners.TPTankNo.Length == 0)
                                break;
                            foreach (ServiceTankNoTPDeviceClassConfiguration tankNo in TankManifoldPartners.TPTankNo)
                            {
                                if (OnSetConfigurationAddTPReq != null)
                                {
                                    int iManualMode;
                                    if (deviceClass.TP_PPManualMode == "False")
                                        iManualMode = 0;
                                    else
                                        iManualMode = 1;
                                    OnSetConfigurationAddTPReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(deviceClass.DeviceID),
                                        Convert.ToInt32(deviceClass.TPTankNo), Convert.ToInt32(deviceClass.TPProductNo),
                                        deviceClass.TPProductName, iManualMode,
                                        (deviceClass.TPShellCapacity == "") ? -1 : FDCConvert.ToDouble(deviceClass.TPShellCapacity),
                                        (deviceClass.TPMaxSafeFillCap == "") ? -1 : FDCConvert.ToDouble(deviceClass.TPMaxSafeFillCap),
                                        (deviceClass.TPLowCapacity == "") ? -1 : FDCConvert.ToDouble(deviceClass.TPLowCapacity),
                                        (deviceClass.TPMinOperatingCapacity == "") ? -1 : FDCConvert.ToDouble(deviceClass.TPMinOperatingCapacity),
                                        (tankNo.TPTankNo == "") ? -1 : Convert.ToInt32(tankNo.TPTankNo),
                                        (deviceClass.TPSetPoints[0].TPHiHiLevel == "") ? -1 : FDCConvert.ToDouble(deviceClass.TPSetPoints[0].TPHiHiLevel),
                                        (deviceClass.TPSetPoints[0].TPHiLevel == "") ? -1 : FDCConvert.ToDouble(deviceClass.TPSetPoints[0].TPHiLevel),
                                        (deviceClass.TPSetPoints[0].TPLoLevel == "") ? -1 : FDCConvert.ToDouble(deviceClass.TPSetPoints[0].TPLoLevel),
                                        (deviceClass.TPSetPoints[0].TPLoLoLevel == "") ? -1 : FDCConvert.ToDouble(deviceClass.TPSetPoints[0].TPLoLoLevel),
                                        (deviceClass.TPSetPoints[0].TPHiWater == "") ? -1 : FDCConvert.ToDouble(deviceClass.TPSetPoints[0].TPHiWater));
                                    bDeviceFound = true;
                                }
                            }
                        }
                        if (bDeviceFound && OnSetConfigurationEndFPReq != null)
                        {
                            OnSetConfigurationEndTPReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(deviceClass.DeviceID), Convert.ToInt32(deviceClass.TPTankNo));
                        }
                        break;
                    case Wayne.FDCPOSLibrary.DeviceType.DT_PricePole:
                        if (deviceClass.PPSegments == null || deviceClass.PPSegments.Length == 0)
                            break;
                        foreach (ServiceSegmentsPPDeviceClassConfiguration segment in deviceClass.PPSegments)
                        {
                            if (segment.SPPLine == null || segment.SPPLine.Length == 0)
                                break;
                            foreach (ServiceLinePPDeviceClassConfiguration line in segment.SPPLine)
                            {
                                int iManualMode;
                                if (deviceClass.TP_PPManualMode == "False")
                                    iManualMode = 0;
                                else
                                    iManualMode = 1;
                                if (OnSetConfigurationAddPPReq != null)
                                {
                                    OnSetConfigurationAddPPReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(deviceClass.DeviceID), Convert.ToInt32(deviceClass.PPLogicalDeviceNo), iManualMode, Convert.ToInt32(line.LSPPSegmentNo), Convert.ToInt32(line.LSPPProductNo), line.LSPPProductName, FDCConvert.ToDouble(line.LSPPProductPrice));
                                    bDeviceFound = true;
                                }
                            }
                        }
                        if (bDeviceFound && OnSetConfigurationEndPPReq != null)
                        {
                            OnSetConfigurationEndPPReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(deviceClass.DeviceID));
                        }
                        break;
                }
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void LockNozzleReq(string workstationID, string applicationSender, int requestID, int deviceId, int nozzloNo)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnLockNozzleReq != null)
            {
                OnLockNozzleReq(workstationID, applicationSender, requestID, deviceId, nozzloNo);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void UnlockNozzleReq(string workstationID, string applicationSender, int requestID, int deviceId, int nozzleNo)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnUnlockNozzleReq != null)
            {
                OnUnlockNozzleReq(workstationID, applicationSender, requestID, deviceId, nozzleNo);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void GetCountrySettingsReq(string workstationID, string applicationSender, int requestID)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnGetCountrySettingsReq != null)
            {
                OnGetCountrySettingsReq(workstationID, applicationSender, requestID);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }
        public void GetDSPLimitsReq(string workstationID, string applicationSender, int requestID, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnGetDSPLimitsReq != null)
            {
                OnGetDSPLimitsReq(workstationID, applicationSender, requestID, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void ChangeDSPLimitsReq(string workstationID, string applicationSender, int requestID, int deviceId, int productNo, int modeNo, decimal maxTrxAmount, decimal maxTrxVolume)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnChangeDSPLimitsReq != null)
            {
                OnChangeDSPLimitsReq(workstationID, applicationSender, requestID, deviceId, productNo, modeNo, Convert.ToDouble(maxTrxAmount), Convert.ToDouble(maxTrxVolume));
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }
        public void SuspendFuellingReq(string workstationID, string applicationSender, int requestID, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnSuspendFuellingReq != null)
            {
                OnSuspendFuellingReq(workstationID, applicationSender, requestID, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }
        public void ResumeFuellingReq(string workstationID, string applicationSender, int requestID, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnResumeFuellingReq != null)
            {
                OnResumeFuellingReq(workstationID, applicationSender, requestID, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }
        public void LockTankReq(string workstationID, string applicationSender, int requestID, int deviceId, int tankNo)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnLockTankReq != null)
            {
                OnLockTankReq(workstationID, applicationSender, requestID, deviceId, tankNo);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }
        public void UnlockTankReq(string workstationID, string applicationSender, int requestID, int deviceId, int tankNo)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnUnlockTankReq != null)
            {
                OnUnlockTankReq(workstationID, applicationSender, requestID, deviceId, tankNo);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void GetTankDataReq(string workstationID, string applicationSender, int requestID, int deviceId, int tankNo)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnGetTankDataReq != null)
            {
                OnGetTankDataReq(workstationID, applicationSender, requestID, deviceId, tankNo);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void ReserveFuelPointReq(string workstationID, string applicationSender, int requestID, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnReserveFuelPointReq != null)
            {
                OnReserveFuelPointReq(workstationID, applicationSender, requestID, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void FreeFuelPointReq(string workstationID, string applicationSender, int requestID, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnFreeFuelPointReq != null)
            {
                OnFreeFuelPointReq(workstationID, applicationSender, requestID, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void StartFuelPointTestReq(string workstationID, string applicationSender, int requestID, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnStartFuelPointTestReq != null)
            {
                OnStartFuelPointTestReq(workstationID, applicationSender, requestID, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void EndFuelPointTestReq(string workstationID, string applicationSender, int requestID, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnEndFuelPointTestReq != null)
            {
                OnEndFuelPointTestReq(workstationID, applicationSender, requestID, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void SetDeviceAlarmReq(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId, int alarmCode, string alarmMsg)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnSetDeviceAlarmReq != null)
            {
                OnSetDeviceAlarmReq(workstationID, applicationSender, requestID, deviceType, deviceId, alarmCode, alarmMsg);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void OpenFuelPointReq(string workstationID, string applicationSender, int requestID, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnOpenFuelPointReq != null)
            {
                OnOpenFuelPointReq(workstationID, applicationSender, requestID, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void CloseFuelPointReq(string workstationID, string applicationSender, int requestID, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnCloseFuelPointReq != null)
            {
                OnCloseFuelPointReq(workstationID, applicationSender, requestID, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        #endregion

        #region send ServiceResponses to Fdc client

        public void LogOn(string workstationID, string applicationSender, int requestId, int iResponsePort, int iUnsolicitedPort, int status, string overallResult)
        {
            messages.LogOn(workstationID, applicationSender, requestId, iResponsePort, iUnsolicitedPort, status, overallResult, null);
        }

        public void LogOff(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            messages.LogOff(workstationID, applicationSender, requestId, status, overallResult);
            //FDCPOSManager.tracer.WriteLine(string.Format("disconnect client '{0}'", FDCPOSClient.getClientID(workstationID, applicationSender)));
            //do not disconnect client
            //this.fdcposManager.DisconnectClient(fdcposManager.tcpClientList[FDCPOSClient.getClientID(workstationID, applicationSender)]);
        }

        public void VersionInfo(string workstationID, string applicationSender, int requestId, string supplier, string version, string release, string hotfix, int status, string overallResult)
        {
            if (supplier == "")
                supplier = "Dresser Wayne";
            System.Reflection.Assembly assembly = System.Reflection.Assembly.GetAssembly(System.Type.GetType("Wayne.FDCPOSInterface.FDCPOSInterfaceServer"));
            string[] sElems;
            sElems = assembly.FullName.Split(new char[] { ',' });
            string sFullVersion = sElems[1];
            sFullVersion = sFullVersion.Substring(sFullVersion.IndexOf('=') + 1);
            sElems = sFullVersion.Split(new char[] { '.' });
            version = sElems[0];
            release = sElems[1];
            hotfix = sElems[2] + "." + sElems[3];
            messages.VersionInfo(workstationID, applicationSender, requestId, supplier, version, release, hotfix, status, overallResult);
        }

        public void StartForecourt(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            messages.StartForecourt(workstationID, applicationSender, requestId, status, overallResult);
        }

        public void StopForecourt(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            messages.StopForecourt(workstationID, applicationSender, requestId, status, overallResult);
        }

        public bool GetCurrentFuellingStatusAdd(string workstationID, string applicationSender, int requestId, int deviceId, double volume, double amount, double price, int nozzle, int transactionId, string releaseToken, string authorisationAS)
        {
            return messages.GetCurrentFuellingStatusAdd(workstationID, applicationSender, requestId, deviceId, Convert.ToDecimal(volume), Convert.ToDecimal(amount), Convert.ToDecimal(price), nozzle, transactionId, releaseToken, authorisationAS);
        }

        public bool GetCurrentFuellingStatusSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            return messages.GetCurrentFuellingStatusSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public void GetFuelPointTotalsAdd(string workstationID, string applicationSender, int requestId, int deviceId, int nozzleId, int productNo, double volume, double amount, double price)
        {
            messages.GetFuelPointTotalsAdd(workstationID, applicationSender, requestId, deviceId, nozzleId, productNo, Convert.ToDecimal(volume), Convert.ToDecimal(amount), Convert.ToDecimal(price));
        }

        public void GetFuelPointTotalsSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            messages.GetFuelPointTotalsSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public void GetDeviceStateAdd(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int deviceState, int deviceSubState, string errorId, string errorDescription, int logicalStatus, string lockingAS, int nozzleListNum, int nozzleListState, int nozzleListLogicalState, int nozzleListTankState)
        {
            LogicalDeviceState logicalDeviceState, logicalDeviceSubState;
            if (deviceType == Wayne.FDCPOSLibrary.DeviceType.DT_OutdoorPaymentTerminal)
                logicalDeviceState = (deviceState == 1) ? LogicalDeviceState.FDC_READY : LogicalDeviceState.FDC_OFFLINE;
            else
                logicalDeviceState = (LogicalDeviceState)deviceState;
            logicalDeviceSubState = (LogicalDeviceState)deviceSubState;
            messages.GetDeviceStateAdd(workstationID, applicationSender, requestId, deviceType, deviceId, logicalDeviceState, logicalDeviceSubState, errorId, errorDescription, (LogicalState)logicalStatus, lockingAS, nozzleListNum, nozzleListState, nozzleListLogicalState, nozzleListTankState);
        }
        public void GetDeviceStateSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            messages.GetDeviceStateSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public void TerminateFuellingAdd(string workstationID, string applicationSender, int requestId, int deviceId, int deviceStatus)
        {
            messages.TerminateFuellingAdd(workstationID, applicationSender, requestId, deviceId, (LogicalDeviceState)deviceStatus);
        }
        public void TerminateFuellingSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            messages.TerminateFuellingSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public void AuthoriseFuelPoint(string workstationID, string applicationSender, int requestId, int transactionId, string releaseToken, int deviceId, int deviceStatus, int status, string overallResult)
        {
            messages.AuthoriseFuelPoint(workstationID, applicationSender, requestId, transactionId, releaseToken, deviceId, (LogicalDeviceState)deviceStatus, status, overallResult);
        }

        public void ChangeFuelMode(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int mode, int status, string overallResult)
        {
            messages.ChangeFuelMode(workstationID, applicationSender, requestId, deviceType, deviceId, mode, status, overallResult);
        }

        //public void ChangeFuelPrice(string workstationID, string applicationSender, int requestId, int productId, double newprice, int mode, double oldprice, string overallResult)
        //{
        //    messages.ChangeFuelPrice(workstationID, applicationSender, requestId, productId, Convert.ToDecimal(newprice), mode, Convert.ToDecimal(oldprice), overallResult);
        //}

        public void LockFuelSaleTrx(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken, int status, int fuellingState, string overallResult)
        {
            messages.LockFuelSaleTrx(workstationID, applicationSender, requestId, deviceId, transactionNo, releaseToken, status, fuellingState, overallResult);
        }

        public void UnlockFuelSaleTrx(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken, int status, int fuellingState, string overallResult)
        {
            messages.UnlockFuelSaleTrx(workstationID, applicationSender, requestId, deviceId, transactionNo, releaseToken, status, fuellingState, overallResult);
        }

        public void ClearFuelSaleTrx(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken, int status, int fuellingState, string overallResult)
        {
            messages.ClearFuelSaleTrx(workstationID, applicationSender, requestId, deviceId, transactionNo, releaseToken, status, fuellingState, overallResult);
        }

        public bool GetAvailableFuelSaleTrxsAdd(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken, int state)
        {
            return messages.GetAvailableFuelSaleTrxsAdd(workstationID, applicationSender, requestId, deviceId, transactionNo, releaseToken, state);
        }

        public bool GetAvailableFuelSaleTrxsSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            return messages.GetAvailableFuelSaleTrxsSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public bool GetFuelSaleTrxDetailsAdd(string workstationID, string applicationSender, int requestId, int deviceId, double volume, double amount, double price, int nozzle, int productNo, string productName, string productUM, int mode, int transactionId, string releaseToken, int state, string startTime, string endTime, string lockingAS, string authorisationAS, int reservingDeviceId, int fuellingType)
        {
            return messages.GetFuelSaleTrxDetailsAdd(workstationID, applicationSender, requestId, deviceId, Convert.ToDecimal(volume), Convert.ToDecimal(amount), Convert.ToDecimal(price), nozzle, productNo, productName, productUM, mode, transactionId, releaseToken, state, startTime, endTime, lockingAS, authorisationAS, reservingDeviceId, fuellingType);
        }

        public bool GetFuelSaleTrxDetailsSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            return messages.GetFuelSaleTrxDetailsSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public bool GetProductTableAdd(string workstationID, string applicationSender, int requestId, int productNo, string ProductName)
        {
            return messages.GetProductTableAdd(workstationID, applicationSender, requestId, productNo, ProductName);
        }

        public bool GetProductTableSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            return messages.GetProductTableSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public bool GetModeTableAdd(string workstationID, string applicationSender, int requestId, int modeNo, string ModeName)
        {
            return messages.GetModeTableAdd(workstationID, applicationSender, requestId, modeNo, ModeName);
        }

        public bool GetModeTableSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            return messages.GetModeTableSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public bool GetFuelModeAdd(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int modeNo)
        {
            return messages.GetFuelModeAdd(workstationID, applicationSender, requestId, deviceType, deviceId, modeNo);
        }

        public bool GetFuelModeSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            return messages.GetFuelModeSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public bool GetConfigurationAddDSP(string workstationID, string applicationSender, int requestId, int deviceId, int productNo, string ProductName, int fuelPriceModeNo, double fuelPrice)
        {
            return messages.GetConfigurationAddDSP(workstationID, applicationSender, requestId, deviceId, productNo, ProductName, fuelPriceModeNo, Convert.ToDecimal(fuelPrice));
        }

        public bool GetConfigurationAddFP(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int nozzleNo, int productNo1, int productNo2, double blendRatio, int blendProductNo)
        {
            return messages.GetConfigurationAddFP(workstationID, applicationSender, requestId, deviceId, pumpNo, nozzleNo, productNo1, productNo2, Convert.ToDecimal(blendRatio), blendProductNo);
        }

        /// <summary>
        /// Get the config of TLG
        /// TLG - Tank Level Gauge
        /// </summary>
        /// <param name="workstationID"></param>
        /// <param name="applicationSender"></param>
        /// <param name="requestId"></param>
        /// <param name="tankDevice_pumpId_nozzleId_Map">list of tankDevice:PumpId:NozzleLogicalId</param>
        /// <returns></returns>
        public bool GetConfigurationAddTLG(string workstationID, string applicationSender, int requestId, IEnumerable<IGrouping<Tank, IGrouping<int, byte>>> tankDevice_pumpId_nozzleId_Map)
        {
            return messages.GetConfigurationAddTLG(workstationID, applicationSender, requestId, tankDevice_pumpId_nozzleId_Map);
        }

        public bool GetConfigurationAddTP(string workstationID, string applicationSender, int requestId, int tlgId, int deviceId, int tankNo, int productNo, string ProductName, int manualMode, double shellCapacity, double maxSafeFillCap, double lowCapacity, double minOperatingCapacity, int tankManifoldPartnersTankNo, double hiHiLevel, double hiLevel, double loLevel, double loLoLevel, double hiWater)
        {
            return messages.GetConfigurationAddTP(workstationID, applicationSender, requestId, tlgId, deviceId, tankNo, productNo, ProductName, manualMode, Convert.ToDecimal(shellCapacity), Convert.ToDecimal(maxSafeFillCap), Convert.ToDecimal(lowCapacity), Convert.ToDecimal(minOperatingCapacity), tankManifoldPartnersTankNo, Convert.ToDecimal(hiHiLevel), Convert.ToDecimal(hiLevel), Convert.ToDecimal(loLevel), Convert.ToDecimal(loLoLevel), Convert.ToDecimal(hiWater));
        }

        public bool GetConfigurationAddPP(string workstationID, string applicationSender, int requestId, int deviceId, int logicalDeviceNo, int manualMode, int segmentNo, int productNo, string ProductName, double productPrice, int modeNo)
        {
            return messages.GetConfigurationAddPP(workstationID, applicationSender, requestId, deviceId, logicalDeviceNo, manualMode, segmentNo, productNo, ProductName, Convert.ToDecimal(productPrice), modeNo);
        }

        public bool GetConfigurationSend(string workstationID, string applicationSender, int requestId, string deviceType, string overallResult)
        {
            return messages.GetConfigurationSend(workstationID, applicationSender, requestId, deviceType, overallResult);
        }

        public void SetConfiguration(string workstationID, string applicationSender, int requestId, string overallResult)
        {
            messages.SetConfiguration(workstationID, applicationSender, requestId, overallResult);
        }
        public void LockNozzle(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int nozzleNo, int status, string overallResult)
        {
            messages.LockNozzle(workstationID, applicationSender, requestId, deviceId, pumpNo, nozzleNo, status, overallResult);
        }
        public void UnlockNozzle(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int nozzleNo, int status, string overallResult)
        {
            messages.UnlockNozzle(workstationID, applicationSender, requestId, deviceId, pumpNo, nozzleNo, status, overallResult);
        }

        public void GetCountrySettings(string workstationID, string applicationSender, int requestId, string volumeUnit, string currencyCode, string levelUnit, string temperatureUnit, string thousandDelimiter, string decimalSign, string countryCode, string languageCode, int status, string overallResult)
        {
            messages.GetCountrySettings(workstationID, applicationSender, requestId, volumeUnit, currencyCode, levelUnit, temperatureUnit, thousandDelimiter, decimalSign, countryCode, languageCode, status, overallResult);
        }

        public bool GetDSPLimitsAdd(string workstationID, string applicationSender, int requestId, int deviceId, int productNo, int fuelModeNo, double maxTrxAmount, double maxTrxVolume)
        {
            return messages.GetDSPLimitsAdd(workstationID, applicationSender, requestId, deviceId, productNo, fuelModeNo, maxTrxAmount, maxTrxVolume);
        }

        public bool GetDSPLimitsSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            return messages.GetDSPLimitsSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public void ChangeDSPLimits(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            messages.ChangeDSPLimits(workstationID, applicationSender, requestId, status, overallResult);
        }

        public void SuspendFuellingAdd(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int deviceStatus)
        {
            messages.SuspendFuellingAdd(workstationID, applicationSender, requestId, deviceId, pumpNo, (LogicalDeviceState)deviceStatus);
        }
        public void SuspendFuellingSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            messages.SuspendFuellingSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public void ResumeFuellingAdd(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int deviceStatus)
        {
            messages.ResumeFuellingAdd(workstationID, applicationSender, requestId, deviceId, pumpNo, (LogicalDeviceState)deviceStatus);
        }
        public void ResumeFuellingSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            messages.ResumeFuellingSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public void LockTank(string workstationID, string applicationSender, int requestId, int deviceId, int tankNo, int status, string overallResult)
        {
            messages.LockTank(workstationID, applicationSender, requestId, deviceId, tankNo, status, overallResult);
        }

        public void UnlockTank(string workstationID, string applicationSender, int requestId, int deviceId, int tankNo, int status, string overallResult)
        {
            messages.UnlockTank(workstationID, applicationSender, requestId, deviceId, tankNo, status, overallResult);
        }

        //public void GetTankData(string workstationID, string applicationSender, int requestId, int deviceId, int tankNo, int manualMode, int TPStatus, double productLevel, double totalObservedVolume, double grossStandardVolume, double averageTemp, double waterLevel, double observedDensity, string overallResult)
        //{
        //    messages.GetTankData(workstationID, applicationSender, requestId, deviceId, tankNo, manualMode, TPStatus, productLevel, totalObservedVolume, grossStandardVolume, averageTemp, waterLevel, observedDensity, overallResult);
        //}

        /// <summary>
        /// 
        /// </summary>
        /// <param name="workstationID"></param>
        /// <param name="applicationSender"></param>
        /// <param name="requestId"></param>
        /// <param name="deviceId"></param>
        /// <param name="tankNo"></param>
        /// <param name="manualMode"></param>
        /// <param name="TPStatus">tank probe status</param>
        /// <param name="productLevel"></param>
        /// <param name="totalObservedVolume"></param>
        /// <param name="grossStandardVolume"></param>
        /// <param name="averageTemp"></param>
        /// <param name="waterLevel"></param>
        /// <param name="observedDensity"></param>
        /// <param name="logicalStatus"></param>
        /// <param name="deviceStatus"></param>
        public void GetTankDataAdd(string workstationID, string applicationSender, int requestId, int deviceId,
            int tankNo, int manualMode, int TPStatus, double productLevel, double totalObservedVolume, double grossStandardVolume, double averageTemp, double waterLevel, double observedDensity, int logicalStatus, int deviceStatus)
        {
            messages.GetTankDataAdd(workstationID, applicationSender, requestId, deviceId, tankNo, manualMode, TPStatus, productLevel, totalObservedVolume, grossStandardVolume, averageTemp, waterLevel, observedDensity, logicalStatus, deviceStatus);
        }

        public void GetTankDataSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            messages.GetTankDataSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public void ReserveFuelPoint(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int status, string overallResult)
        {
            messages.ReserveFuelPoint(workstationID, applicationSender, requestId, deviceId, pumpNo, status, overallResult);
        }

        public void FreeFuelPoint(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int status, string overallResult)
        {
            messages.FreeFuelPoint(workstationID, applicationSender, requestId, deviceId, pumpNo, status, overallResult);
        }

        public void StartFuelPointTest(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int status, string overallResult)
        {
            messages.StartFuelPointTest(workstationID, applicationSender, requestId, deviceId, pumpNo, status, overallResult);
        }

        public void EndFuelPointTest(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int status, string overallResult)
        {
            messages.EndFuelPointTest(workstationID, applicationSender, requestId, deviceId, pumpNo, status, overallResult);
        }

        public void SetDeviceAlarm(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int status, string overallResult)
        {
            messages.SetDeviceAlarm(workstationID, applicationSender, requestId, deviceType, deviceId, status, overallResult);
        }

        public void OpenFuelPointAdd(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int deviceStatus)
        {
            messages.OpenFuelPointAdd(workstationID, applicationSender, requestId, deviceId, pumpNo, (LogicalDeviceState)deviceStatus);
        }
        public void OpenFuelPointSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            messages.OpenFuelPointSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public void CloseFuelPointAdd(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int deviceStatus)
        {
            messages.CloseFuelPointAdd(workstationID, applicationSender, requestId, deviceId, pumpNo, (LogicalDeviceState)deviceStatus);
        }
        public void CloseFuelPointSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            messages.CloseFuelPointSend(workstationID, applicationSender, requestId, status, overallResult);
        }

        public void GenericTypelessMessageSend(string workstationID, string applicationSender, int requestId, string responseMessage, string overallResult)
        {
            messages.GenericTypelessMessageSend(workstationID, applicationSender, requestId, responseMessage, overallResult);
        }

        #endregion

        #region send FDCMessages to Fdc client

        /// <summary>
        /// 
        /// </summary>
        /// <param name="deviceType"></param>
        /// <param name="deviceId"></param>
        /// <param name="deviceState"></param>
        /// <param name="deviceSubState"></param>
        /// <param name="errorId"></param>
        /// <param name="errorDescription"></param>
        /// <param name="lockingAS"></param>
        /// <param name="nozzleListNum">how many nozzles in this pump</param>
        /// <param name="nozzleListState">binary map, 0000 0101 indicates 1st and 3rd nozzle are NozzleUp, others are NozzleDown</param>
        /// <param name="nozzleListLogicalState">binary map, 0000 1001 indicates 1st and 4th nozzle are Locked, others are Unlocked</param>
        /// <param name="nozzleListTankState"></param>
        public void DeviceStateChange(string deviceType, int deviceId, int deviceState, int deviceSubState, string errorId, string errorDescription, string lockingAS, int nozzleListNum, int nozzleListState, int nozzleListLogicalState, int nozzleListTankState)
        {
            if (deviceType == FDCPOSLibrary.DeviceType.DT_FuellingPoint || deviceType == FDCPOSLibrary.DeviceType.DT_FuelDispenser ||
                deviceType == FDCPOSLibrary.DeviceType.DT_TankProbe || deviceType == FDCPOSLibrary.DeviceType.DT_TankLevelGauge ||
                deviceType == FDCPOSLibrary.DeviceType.DT_PricePole)
            {
                //FDCPOSManager.tracer.WriteLine(string.Format("init: deviceType={0}, deviceId={1}, deviceState={2}, deviceSubState={3}", deviceType, deviceId, deviceState.ToString(), deviceSubState.ToString()));
                messages.DeviceStateChange(deviceType, deviceId, (LogicalDeviceState)deviceState, (LogicalDeviceState)deviceSubState, errorId, errorDescription, lockingAS, nozzleListNum, nozzleListState, nozzleListLogicalState, nozzleListTankState);
            }
            else
            {
                //FDCPOSManager.tracer.WriteLine(string.Format("Invalid type '{0}', only 'FP' or 'DSP' allowed", deviceType));
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void FDCStop()
        {
            //FDCPOSManager.tracer.WriteLine("init");
            messages.FDCStop();
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void FDCStart()
        {
            //FDCPOSManager.tracer.WriteLine("init");

            SchemasSG tmp_sgmInst = SchemasSG.Instance; //load the schemas in FDCPOSInterfaceServer constructor
            tmp_sgmInst = null;

            messages.FDCStart();
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void CurrentFuellingStatus(int deviceId, double volume, double amount, double price, int nozzle, int transactionId, string releaseToken, int mode, int productNo)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            //string val = IniFile.IniReadValue(SINPConfigurazione.IniPath + "ForecourtServer.ini", "Test", "CurrentFuellingStatusEnabled");
            //if (val != "0")
            messages.CurrentFuellingStatus(deviceId, Convert.ToDecimal(volume), Convert.ToDecimal(amount), Convert.ToDecimal(price), nozzle, transactionId, releaseToken, mode, productNo);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void DeviceAlarm(string deviceType, int deviceId, int alarmId, string alarmDescr)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            messages.DeviceAlarm(deviceType, deviceId, alarmId, alarmDescr);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void FuelSaleTrx(int deviceId, double volume, double amount, double price, int nozzle, int productNo, string productName, string productUM, int mode, int transactionId, int transactionStatus, int completionReason, string releaseToken, string startTime, string endTime, string lockingAS, string authorisationAS, int reservingDeviceId, int fuellingType)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            messages.FuelSaleTrx(deviceId, Convert.ToDecimal(volume), Convert.ToDecimal(amount), Convert.ToDecimal(price), nozzle, productNo, productName, productUM, mode, transactionId, transactionStatus, completionReason, releaseToken, startTime, endTime, lockingAS, authorisationAS, reservingDeviceId, fuellingType);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void FuelPriceChange(int productNo, int modeNo, double newPrice, double oldPrice, string effectiveDateTime)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            messages.FuelPriceChange(productNo, modeNo, newPrice, oldPrice, effectiveDateTime);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void FuelModeChange(string deviceType, int deviceId, int modeNo)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            messages.FuelModeChange(deviceType, deviceId, modeNo);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void FDCExceptionMsg(int exceptionNo, string description)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            messages.FDCExceptionMsg(exceptionNo, description);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void ConfigurationChange(int fDCDeviceStatus)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            messages.ConfigurationChange(fDCDeviceStatus);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        /// <summary>
        /// send a string msg to specific or all Fdc client(s) via TCP network
        /// </summary>
        /// <param name="workstationId">the target Fdc client with this workstation id. leave to null if want to broadcast to all Fdc clients</param>
        /// <param name="applicationSender"></param>
        /// <param name="msg"></param>
        public void SendGenericTypelessMessageToFdcClient(string workstationId, string applicationSender, string msg)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            messages.SendGenericMessageToFdcClient(workstationId, applicationSender, msg);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        #endregion


        public delegate void OnAddSerialPortReqTarget(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int port, int baudRate, int dataBit, int stopBit, int parity);
        public delegate void OnAddTCPReqTarget(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, string address, int port);
        public delegate void OnRemoveReqTarget(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId);
        public delegate void OnWriteReqTarget(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, string message);
        //public delegate void OnWriteReqTarget(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, byte[] message);

        public event OnAddSerialPortReqTarget OnAddSerialPortReq;
        public event OnAddTCPReqTarget OnAddTCPReq;
        public event OnRemoveReqTarget OnRemoveReq;
        public event OnWriteReqTarget OnWriteReq;


        #region Opt ServiceRequests

        public void AddSerialPortReq(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId, int port, int baudRate, int dataBit, int stopBit, int parity)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnAddSerialPortReq != null)
            {
                OnAddSerialPortReq(workstationID, applicationSender, requestID, deviceType, deviceId, port, baudRate, dataBit, stopBit, parity);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void AddTCPReq(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId, string address, int port)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnAddTCPReq != null)
            {
                OnAddTCPReq(workstationID, applicationSender, requestID, deviceType, deviceId, address, port);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void RemoveReq(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            if (OnRemoveReq != null)
            {
                OnRemoveReq(workstationID, applicationSender, requestID, deviceType, deviceId);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void WriteReq(string workstationID, string applicationSender, int requestID, string deviceType, int deviceId, byte[] message)
        {
            //FDCPOSManager.tracer.WriteLine(string.Format("init: deviceId={0}", deviceId));
            if (OnWriteReq != null)
            {
                //System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
                System.Text.UnicodeEncoding encoding = new System.Text.UnicodeEncoding();

                string dataWrite = encoding.GetString(message);
                //FDCPOSManager.tracer.WriteLine(string.Format("data={0}", dataWrite));
                OnWriteReq(workstationID, applicationSender, requestID, deviceType, deviceId, dataWrite);
                ////FDCPOSManager.tracer.WriteLine(string.Format("message={0}", message));
                //OnWriteReq(workstationID, applicationSender, requestID, deviceType, deviceId, message);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        #endregion

        #region Opt ServiceResponses
        public void Add(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, string overallResult)
        {
            messages.OptAdd(workstationID, applicationSender, requestId, deviceType, deviceId, overallResult);
        }

        public void Remove(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, string overallResult)
        {
            messages.OptRemove(workstationID, applicationSender, requestId, deviceType, deviceId, overallResult);
        }

        public void Write(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, string overallResult)
        {
            messages.OptWrite(workstationID, applicationSender, requestId, deviceType, deviceId, overallResult);
        }
        #endregion

        #region Opt FDCMessages
        public void DeviceStateChange(string deviceType, int deviceId, int logicalState, int logicalSubState)
        {
            if (deviceType == FDCPOSLibrary.DeviceType.DT_OutdoorPaymentTerminal)
            {
                LogicalDeviceState logicalDeviceState = (logicalState == 1) ? LogicalDeviceState.FDC_READY : LogicalDeviceState.FDC_OFFLINE;
                messages.DeviceStateChange(deviceType, deviceId, logicalDeviceState, logicalDeviceState, "", "", "", 0, 0, 0, 0);
            }
            else
            {
                //FDCPOSManager.tracer.WriteLine(string.Format("Invalid type '{0}', only 'OPT' allowed", deviceType));
            }
        }

        //public void Read(string deviceType, int deviceId, byte[] message)
        public void Read(string deviceType, int deviceId, string message)
        {
            byte[] bytedata;
            System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
            bytedata = encoding.GetBytes(message);
            messages.OptRead(deviceType, deviceId, bytedata);
            //messages.OptRead(deviceType, deviceId, message);
        }
        #endregion

    }

}