FCC/Extension/GlobalPumpFdc/Support/FControlFusionG/IFSFManager.cs

using FControlFUSIONCF;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Xml;
using System.Xml.Serialization;
using Wayne.FDCPOSLibrary;
using Wayne.FDCPOSLibrary.Configuration;
using Wayne.ForecourtControl.OptBridge;
using Wayne.Lib;
using Wayne.Lib.Log;


namespace Wayne.ForecourtControl.Fusion
{
    public class Heartbeat : DisposableBase
    {
        private readonly Timer heartbeatTimer;
        private readonly Timer disconnectionTimer;
        public event EventHandler OnHeartbeatTimeout;
        public event EventHandler OnHeartbeatInterval;
        public long heartbeatTimeout;
        public long heartbeatInterval;
        public bool tryingConnect;
        private IFSFManager ifsfManager;
        private readonly DebugLogger debugLogger;

        public Heartbeat(IFSFManager _ifsfManager, long _heartbeatInterval, long _heartbeatTimeout)
        {
            ifsfManager = _ifsfManager;
            heartbeatInterval = _heartbeatInterval;
            heartbeatTimeout = _heartbeatTimeout;
            debugLogger = ifsfManager.DebugLogger;
            disconnectionTimer = new Timer(HeartbeatTimeout, null, Timeout.Infinite, Timeout.Infinite);
            heartbeatTimer = new Timer(HeartbeatInterval, null, Timeout.Infinite, Timeout.Infinite);
        }

        private void HeartbeatTimeout(Object state)
        {
            if (IsDisposed)
            {
                return;
            }

            if (debugLogger.IsActive())
                debugLogger.Add("Heartbeat Timeout");
            if (OnHeartbeatTimeout != null)
                OnHeartbeatTimeout.Invoke(this, null);
            if (heartbeatTimeout > 0)
            {
                disconnectionTimer.Change(heartbeatTimeout, Timeout.Infinite);
            }
        }

        private void HeartbeatInterval(Object state)
        {
            if (IsDisposed)
            {
                return;
            }

            if (OnHeartbeatInterval != null)
                OnHeartbeatInterval.Invoke(this, null);
        }

        public void ResetDisconnectionTimeout()
        {
            if (IsDisposed)
            {
                return;
            }

            // read HeartbeatTimeout config parameter
            string sValue = IniFile.IniReadValue(ConfigurationParams.inifile, "FUSION-Connection", "HeartbeatTimeout");
            try
            {
                if (sValue.Length > 0)
                    heartbeatTimeout = Convert.ToInt32(sValue);
            }
            catch (Exception ex)
            {
                if (debugLogger.IsActive())
                    debugLogger.Add(string.Format("Exception reading heartbeatTimeout: {0}", ex));
            }
            if (heartbeatTimeout > 0)
            {
                disconnectionTimer.Change(heartbeatTimeout, Timeout.Infinite);
            }
        }

        public void Restart()
        {
            if (IsDisposed)
            {
                return;
            }

            // start sending heartbeat when receive logon and send            
            if (heartbeatInterval > 0)
            {
                heartbeatTimer.Change(heartbeatInterval, Timeout.Infinite);
            }
        }

        public void Stop()
        {
            if (IsDisposed)
            {
                return;
            }
            heartbeatTimer.Change(Timeout.Infinite, Timeout.Infinite);
        }

        public void NotifyDisconnection()
        {
            if (IsDisposed)
            {
                return;
            }

            heartbeatTimer.Change(Timeout.Infinite, Timeout.Infinite);
            tryingConnect = true;
            disconnectionTimer.Change(Timeout.Infinite, Timeout.Infinite);

            Restart();
        }

        public void SetReconnected()
        {
            if (IsDisposed)
            {
                return;
            }

            tryingConnect = false;
        }

        protected override void DoDispose()
        {
            heartbeatTimer.Dispose();
            disconnectionTimer.Dispose();
        }
    }

    #region Event Args
    public class DeviceStateChangedEventArgs : EventArgs
    {
        public string deviceType;
        public int deviceId;
        public LogicalDeviceState state;
        public LogicalDeviceState substate;
        public string lockingAS;
        public int nozzleUp;

        public DeviceStateChangedEventArgs(string _deviceType, int _deviceId, LogicalDeviceState _state, LogicalDeviceState _substate, string _lockingAS, int _nozzleUp)
        {
            deviceType = _deviceType;
            deviceId = _deviceId;
            state = _state;
            substate = _substate;
            lockingAS = _lockingAS;
            nozzleUp = _nozzleUp;
        }
    }

    public class VIRStateChangedEventArgs : EventArgs
    {
        public int deviceId;
        public string virId;
        public DeviceConnectionState state;

        public VIRStateChangedEventArgs(int _deviceId, string _virId, DeviceConnectionState _state)
        {
            deviceId = _deviceId;
            virId = _virId;
            state = _state;
        }
    }

    public class FuelModeChangedEventArgs : EventArgs
    {
        public string deviceType;
        public int deviceId;
        public int mode;

        public FuelModeChangedEventArgs(string _deviceType, int _deviceId, int _mode)
        {
            deviceType = _deviceType;
            deviceId = _deviceId;
            mode = _mode;
        }
    }

    public class OperationModeChangedEventArgs : EventArgs
    {
        public string deviceType;
        public int deviceId;
        public ushort mode;

        public OperationModeChangedEventArgs(string _deviceType, int _deviceId, ushort _mode)
        {
            deviceType = _deviceType;
            deviceId = _deviceId;
            mode = _mode;
        }
    }

    public class CurrentFuellingStatusEventArgs : EventArgs
    {
        public string deviceType;
        public int deviceId;
        public int nozzleId;
        public decimal volume;
        public decimal amount;
        public decimal price;
        public string authAS;

        /// <summary>
        /// The fuel period id of the current fuelling
        /// </summary>
        public int FuelPeriodSequenceNo { get; set; }

        /// <summary>
        /// The AuthorizationId
        /// </summary>
        public int ReleaseId { get; set; }

        /// <summary>
        /// The TransactionSeqNo
        /// </summary>
        public int TransactionId { get; set; }

        /// <summary>
        /// The Reserving Device Id
        /// </summary>
        public int ReservingDeviceId { get; set; }

        public CurrentFuellingStatusEventArgs(string _deviceType, int _deviceId, int _nozzleId, decimal _volume, decimal _amount, decimal _price, string _authAS)
        {
            deviceType = _deviceType;
            deviceId = _deviceId;
            nozzleId = _nozzleId;
            volume = _volume;
            amount = _amount;
            price = _price;
            authAS = _authAS;

        }
    }

    public class FuelPointTotalsEventArgs : EventArgs
    {
        public int requestId;
        public bool overallResult;
        public string deviceType;
        public int deviceId;
        public int nozzleId;
        public decimal volume;
        public decimal amount;
        public decimal price;
        public string originalTransactionData;

        public FuelPointTotalsEventArgs(int _requestId, bool _overallResult, string _deviceType, int _deviceId, int _nozzleId, decimal _volume, decimal _amount, decimal _price, string _originalTransactionData)
        {
            requestId = _requestId;
            overallResult = _overallResult;
            deviceType = _deviceType;
            deviceId = _deviceId;
            nozzleId = _nozzleId;
            volume = _volume;
            amount = _amount;
            price = _price;
            originalTransactionData = _originalTransactionData;
        }
    }

    public class FuelSaleTrxEventArgs : EventArgs
    {
        public int transactionId;
        public int fuellingSeqNo;
        public Wayne.FDCPOSLibrary.FuellingState transactionStatus;
        public int completionReason;
        public string deviceType;
        public int deviceId;
        public int nozzleId;
        public decimal volume;
        public decimal amount;
        public decimal price;
        public int fuelMode;
        public DateTime trxStartDateTime;
        public DateTime trxEndDateTime;
        public string lockingAS;
        public string authAS;
        public string DSPFields;
        public string CRCMode;
        public string MIDLinesNarrow;
        public string MIDLinesWide;
        public int releaseToken;
        public byte reservingDeviceId;
        public FuellingType fuellingType;
        public string origMessageXml;
        /// <summary>
        /// The fuel period id for the transaction
        /// </summary>
        public int FuelPeriodSequenceNo { get; set; }

        public FuelSaleTrxEventArgs(int _transactionId, int _fuellingSeqNo, Wayne.FDCPOSLibrary.FuellingState _transactionStatus,
            int _completionReason, string _deviceType, int _deviceId, int _nozzleId, decimal _volume, decimal _amount,
            decimal _price, int _fuelMode, DateTime _trxStartDateTime, DateTime _trxEndDateTime, string _lockingAS,
            string _authAS, string _DSPFields, string _CRCMode, string _MIDLinesNarrow,
            string _MIDLinesWide, int _releaseToken, byte _reservingDeviceId, FuellingType _fuellingType,
            string _originalMessageXml = null)
        {
            transactionId = _transactionId;
            fuellingSeqNo = _fuellingSeqNo;
            transactionStatus = _transactionStatus;
            completionReason = _completionReason;
            deviceType = _deviceType;
            deviceId = _deviceId;
            nozzleId = _nozzleId;
            volume = _volume;
            amount = _amount;
            price = _price;
            fuelMode = _fuelMode;
            trxStartDateTime = _trxStartDateTime;
            trxEndDateTime = _trxEndDateTime;
            lockingAS = _lockingAS;
            authAS = _authAS;
            DSPFields = _DSPFields;
            CRCMode = _CRCMode;
            MIDLinesNarrow = _MIDLinesNarrow;
            MIDLinesWide = _MIDLinesWide;
            releaseToken = _releaseToken;
            reservingDeviceId = _reservingDeviceId;
            fuellingType = _fuellingType;
            origMessageXml = _originalMessageXml;
        }
    }

    public class ChangeFuelPriceEventArgs : EventArgs
    {
        public int productId;
        public int mode;
        public decimal oldPrice;
        public decimal newPrice;

        public ChangeFuelPriceEventArgs(int _productId, int _mode, decimal _oldPrice, decimal _newPrice)
        {
            productId = _productId;
            mode = _mode;
            oldPrice = _oldPrice;
            newPrice = _newPrice;
        }
    }

    public class DeviceAlarmEventArgs : EventArgs
    {
        public string deviceType;
        public int deviceId;
        public int alarmId;
        public string alarmDescr;

        public DeviceAlarmEventArgs(string _deviceType, int _deviceId, int _alarmId, string _alarmDescr)
        {
            deviceType = _deviceType;
            deviceId = _deviceId;
            alarmId = _alarmId;
            alarmDescr = _alarmDescr;
        }
    }

    public class VersionInfoEventArgs : EventArgs
    {
        public string release;
        public string version;
        public string hotfix;

        public VersionInfoEventArgs(string _release, string _version, string _hotfix)
        {
            version = _version;
            release = _release;
            hotfix = _hotfix;
        }
    }

    public class TankDataEventArgs : EventArgs
    {
        int DeviceID;
        int TankNo;
        string Type;
        int ManualMode;
        decimal AverageTemp;
        decimal GrossStandardVolume;
        decimal ObservedDensity;
        decimal ProductLevel;
        decimal TotalObservedVolume;
        decimal WaterLevel;
        int TPStatus;

        public TankDataEventArgs(int _DeviceID, int _TankNo, string _Type, int _ManualMode,
            decimal _AverageTemp, decimal _GrossStandardVolume, decimal _ObservedDensity,
            decimal _ProductLevel, decimal _TotalObservedVolume, decimal _WaterLevel, int _TPStatus)
        {
            DeviceID = _DeviceID;
            TankNo = _TankNo;
            Type = _Type;
            ManualMode = _ManualMode;
            AverageTemp = _AverageTemp;
            GrossStandardVolume = _GrossStandardVolume;
            ObservedDensity = _ObservedDensity;
            ProductLevel = _ProductLevel;
            TotalObservedVolume = _TotalObservedVolume;
            WaterLevel = _WaterLevel;
            TPStatus = _TPStatus;
        }
    }

    public class OptReadEventArgs : EventArgs
    {
        public string deviceType;
        public int deviceId;
        public byte[] message;

        public OptReadEventArgs(string _deviceType, int _deviceId, byte[] _message)
        {
            deviceType = _deviceType;
            deviceId = _deviceId;
            message = _message;
        }
    }

    #endregion

    public class IFSFManager : DisposableBase
    {
        public ServiceRequest serviceRequestLogOn;
        private IFSFSockets _clientSocket;

        public IFSFSockets clientSocket
        {
            get { return _clientSocket; }
        }

        private Heartbeat _heartbeat;
        public Heartbeat heartbeat
        {
            get { return _heartbeat; }
        }

        private FUSIONManager manager;
        public bool authentificationErrorRetry;

        public event EventHandler<DeviceStateChangedEventArgs> OnDeviceStateChange;
        public event EventHandler<VIRStateChangedEventArgs> OnVirStateChange;
        public event EventHandler<FuelModeChangedEventArgs> OnFuelModeChange;
        public event EventHandler<OperationModeChangedEventArgs> OnOperationModeChange;
        public event EventHandler<CurrentFuellingStatusEventArgs> OnCurrentFuellingStatus;
        public event EventHandler<FuelPointTotalsEventArgs> OnFuelPointTotals;
        public event EventHandler<FuelSaleTrxEventArgs> OnFuelSaleTrx;
        public event EventHandler<DeviceAlarmEventArgs> OnDeviceAlarm;
        public event EventHandler<VersionInfoEventArgs> OnVersionInfo;
        public event EventHandler<ChangeFuelPriceEventArgs> OnChangeFuelPrice;
        public event EventHandler<FuelSaleTrxEventArgs> OnLockFuelSaleTrx;
        public event EventHandler<FuelSaleTrxEventArgs> OnUnlockFuelSaleTrx;
        public event EventHandler<FuelSaleTrxEventArgs> OnClearFuelSaleTrx;
        public event EventHandler<FuelSaleTrxEventArgs> OnGetAvailableFuelSaleTrx;
        public event EventHandler<FuelSaleTrxEventArgs> OnGetFuelSaleTrxDetails;
        public event EventHandler<OptReadEventArgs> OnOptRead;
        public event EventHandler<TankDataEventArgs> OnTankData;
        public event EventHandler<EventArgs> OnConfigurationChange;
        public event EventHandler<EventArgs> OnTwinMasterReady;

        private readonly Dictionary<int, int> unsolicitedFPStateChangeDictionary = new Dictionary<int, int>();

        private readonly DebugLogger debugLogger;
        public DebugLogger DebugLogger { get { return debugLogger; } }

        public IFSFManager(FUSIONManager manager, int id)
        {
            debugLogger = manager.DebugLogger;

            this._clientSocket = new IFSFSockets(id, this);
            this._clientSocket.OnResponseTimeout += new EventHandler(_clientSocket_OnResponseTimeout);
            this.manager = manager;

            this._heartbeat = new Heartbeat(this, this._clientSocket.heartbeatInterval, this._clientSocket.heartbeatTimeout);
            heartbeat.OnHeartbeatInterval += new EventHandler(heartbeat_OnHeartbeatInterval);
            heartbeat.OnHeartbeatTimeout += new EventHandler(heartbeat_OnHeartbeatTimeout);

            authentificationErrorRetry = true;
        }

        private void DebugLog(string s)
        {
            if (debugLogger.IsActive())
                debugLogger.Add(s);
        }

        public static void ArrayResize<T>(ref T[] array, int newSize)
        {
            int oldSize = (array == null) ? 0 : array.Length;
            T[] newArray = new T[newSize];
            int preserveLength = System.Math.Min(oldSize, newSize);
            for (int i = 0; i < preserveLength; i++)
                newArray[i] = array[i];
            array = newArray;
        }

        public LogicalDeviceState convertLogicalDeviceState(string state)
        {
            if (state == LogicalDeviceState.FDC_CALLING.ToString())
                return LogicalDeviceState.FDC_CALLING;
            else if (state == LogicalDeviceState.FDC_CONFIGURE.ToString())
                return LogicalDeviceState.FDC_CONFIGURE;
            else if (state == LogicalDeviceState.FDC_DISABLED.ToString())
                return LogicalDeviceState.FDC_DISABLED;
            else if (state == LogicalDeviceState.FDC_ERRORSTATE.ToString())
                return LogicalDeviceState.FDC_ERRORSTATE;
            else if (state == LogicalDeviceState.FDC_FUELLING.ToString())
                return LogicalDeviceState.FDC_FUELLING;
            else if (state == LogicalDeviceState.FDC_INVALIDSTATE.ToString())
                return LogicalDeviceState.FDC_INVALIDSTATE;
            else if (state == LogicalDeviceState.FDC_LOCKED.ToString())
                return LogicalDeviceState.FDC_LOCKED;
            else if (state == LogicalDeviceState.FDC_OFFLINE.ToString())
                return LogicalDeviceState.FDC_OFFLINE;
            else if (state == LogicalDeviceState.FDC_OUTOFORDER.ToString())
                return LogicalDeviceState.FDC_OUTOFORDER;
            else if (state == LogicalDeviceState.FDC_READY.ToString())
                return LogicalDeviceState.FDC_READY;
            else if (state == LogicalDeviceState.FDC_REQUESTED.ToString())
                return LogicalDeviceState.FDC_REQUESTED;
            else if (state == LogicalDeviceState.FDC_STARTED.ToString())
                return LogicalDeviceState.FDC_STARTED;
            else if (state == LogicalDeviceState.FDC_SUSPENDED.ToString())
                return LogicalDeviceState.FDC_SUSPENDED;
            else if (state == LogicalDeviceState.FDC_TEST.ToString())
                return LogicalDeviceState.FDC_TEST;
            else if (state == LogicalDeviceState.FDC_SUSPENDED_STARTED.ToString())
                return LogicalDeviceState.FDC_SUSPENDED_STARTED;
            else if (state == LogicalDeviceState.FDC_SUSPENDED_FUELLING.ToString())
                return LogicalDeviceState.FDC_SUSPENDED_FUELLING;
            else if (state == LogicalDeviceState.FDC_CLOSED.ToString())
                return LogicalDeviceState.FDC_CLOSED;
            else if (state == LogicalDeviceState.FDC_AUTHORISED.ToString())
                return LogicalDeviceState.FDC_AUTHORISED;
            else if (state == LogicalDeviceState.FDC_FUELLING_TERMINATED.ToString())
                return LogicalDeviceState.FDC_FUELLING_TERMINATED;
            return 0;



        }

        private Wayne.FDCPOSLibrary.FuellingState convertFuellingState(string state)
        {
            if (state == Wayne.FDCPOSLibrary.FuellingState.Locked.ToString())
                return Wayne.FDCPOSLibrary.FuellingState.Locked;
            else if (state == Wayne.FDCPOSLibrary.FuellingState.Payable.ToString())
                return Wayne.FDCPOSLibrary.FuellingState.Payable;
            else if (state == Wayne.FDCPOSLibrary.FuellingState.Paid.ToString() || state == Wayne.FDCPOSLibrary.FuellingState.Cleared.ToString())
                return Wayne.FDCPOSLibrary.FuellingState.Paid;
            return 0;
        }

        private int convertCompletionReason(string reason)
        {
            // Fusion 4.4
            if (reason == Wayne.FDCPOSLibrary.CompletionReason.NormalCompletion.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.NormalCompletion;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.AuthorizationTimeout.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.AuthorizationTimeout;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.FuellingTimeout.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.FuellingTimeout;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.NoFlowTimeout.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.NoFlowTimeout;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.PumpDisconnected.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.PumpDisconnected;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.PumpStopped.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.PumpStopped;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.PumpGenericError.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.PumpGenericError;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.PumpPulserError.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.PumpPulserError;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.PumpLowLevelError.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.PumpLowLevelError;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.PumpDisplayError.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.PumpDisplayError;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.PumpCalculationError.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.PumpCalculationError;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.PumpAntiSpillError.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.PumpAntiSpillError;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.PumpBlenderError.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.PumpBlenderError;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.PumpVaporRecoveryError.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.PumpVaporRecoveryError;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.ZeroFilling.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.ZeroFilling;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.PresetOverrun.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.PresetOverrun;
            else if (reason == Wayne.FDCPOSLibrary.CompletionReason.ReadFromTotalizers.ToString())
                return (int)Wayne.FDCPOSLibrary.CompletionReason.ReadFromTotalizers;
            // Fusion 4.3
            return Convert.ToInt32(reason);
        }

        public static string getClientID(string workstationID, string applicationSender)
        {
            return workstationID + "-" + applicationSender;
        }

        public void Disconnect()
        {
            clientSocket.Disconnect();
            clientSocket.mainConnectionState = DeviceConnectionState.Disconnected;

            if (heartbeat != null)
                heartbeat.NotifyDisconnection();
        }

        private void _clientSocket_OnResponseTimeout(object sender, EventArgs e)
        {

        }

        private void heartbeat_OnHeartbeatTimeout(object sender, EventArgs e)
        {
            DebugLog("Heartbeat Timeout - disconnecting");
            Disconnect();
            clientSocket.mainConnectionState = DeviceConnectionState.Disconnected;
        }

        private void heartbeat_OnHeartbeatInterval(object sender, EventArgs e)
        {
            Heartbeat();
        }

        public string ReadResponse(string myString, int msglength, ref OverallResult result) //StreamReader networkStream)
        {
            string requestType = "";
            int requestId = 0;
            try
            {
                requestType = GetRequestType("RequestType", myString);
                requestId = GetRequestID("RequestID", myString);
            }
            catch (Exception ex)
            {
                DebugLog(string.Format("Unable to get request type or id - Exception! {0}", ex));
                //result = OverallResult.Failure;
            }
            if (result != OverallResult.Success)
            {
                DebugLog(string.Format("ReadResponse ERROR result='{0}'", result));
            }
            else
            {

                if (requestType == "")
                {
                    DebugLog(string.Format("ReadResponse INVALID requestType='{0}', requestId={1}", requestType, requestId));
                    result = OverallResult.FormatError;
                }
                int UTFlength = System.Text.Encoding.UTF8.GetBytes(myString).Length;
                if (result == OverallResult.Success && UTFlength != msglength)
                {
                    DebugLog(string.Format("ReadResponse header='{0}' != msgLength={1}, requestType='{2}', requestId={3}", msglength, UTFlength, requestType, requestId));
                    result = OverallResult.FormatError;
                }
                else
                {
                    try
                    {
                        DebugLog(string.Format("ReadResponse init: requestType='{0}', requestId={1}", requestType, requestId));

                        if (requestType == "LogOn")
                        {
                            ServiceResponseLogOn sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseLogOn>(myString, ref result);
                            LogOnResp(sr.RequestIDNumber, sr.OverallResult, sr.Value, sr.FDCdata[0].FDCTimeStamp);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "LogOff")
                        {
                            ServiceResponseLogOff sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseLogOff>(myString, ref result);
                            LogOffResp(sr.RequestIDNumber, sr.OverallResult);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "VersionInfo")
                        {
                            ServiceResponseVersionInfo sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseVersionInfo>(myString, ref result);
                            VersionInfoResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "StartForecourt")
                        {
                            ServiceResponseStartForecourt sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseStartForecourt>(myString, ref result);
                            string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].ErrorCode;
                            StartForecourtResp(sr.RequestIDNumber, sr.OverallResult, errorCode);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "TwinOpenMaster")
                        {
                            ServiceResponseTwinOpenMaster sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseTwinOpenMaster>(myString, ref result);
                            string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].ErrorCode;
                            TwinOpenMasterResp(sr.RequestIDNumber, sr.OverallResult, errorCode);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "StopForecourt")
                        {
                            ServiceResponseStopForecourt sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseStopForecourt>(myString, ref result);
                            string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].ErrorCode;
                            StopForecourtResp(sr.RequestIDNumber, sr.OverallResult, errorCode);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetCurrentFuellingStatus")
                        {
                            ServiceResponseGetCurrentFuellingStatus sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetCurrentFuellingStatus>(myString, ref result);
                            GetCurrentFuellingStatusResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetTotals")
                        {
                            ServiceResponseGetFuelPointTotals sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetFuelPointTotals>(myString, ref result);
                            GetFuelPointTotalsResp(sr.RequestIDNumber, sr.OverallResult, sr, myString);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetDeviceState")
                        {
                            ServiceResponseGetDeviceState sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetDeviceState>(myString, ref result);
                            GetDeviceStateResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetFPState")
                        {
                            ServiceResponseGetFPState sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetFPState>(myString, ref result);
                            GetFPStateResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetTPState")
                        {
                            ServiceResponseGetTPState sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetTPState>(myString, ref result);
                            GetTPStateResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetPPState")
                        {
                            ServiceResponseGetPPState sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetPPState>(myString, ref result);
                            GetPPStateResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetVIRState")
                        {
                            ServiceResponseGetVIRState sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetVIRState>(myString, ref result);
                            GetVIRStateResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "TerminateFuelling")
                        {
                            ServiceResponseTerminateFuelling sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseTerminateFuelling>(myString, ref result);
                            TerminateFuellingResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "AuthoriseFuelPoint")
                        {
                            ServiceResponseAuthoriseFuelPoint sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseAuthoriseFuelPoint>(myString, ref result);
                            AuthoriseFuelPointResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "ChangeFuelMode")
                        {
                            ServiceResponseChangeFuelMode sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseChangeFuelMode>(myString, ref result);
                            ChangeFuelModeResp(sr.RequestIDNumber, sr.OverallResult, sr.FDCdata);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "ChangeFPFuelMode")
                        {
                            ServiceResponseChangeFPFuelMode sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseChangeFPFuelMode>(myString, ref result);
                            ChangeFuelModeResp(sr.RequestIDNumber, sr.OverallResult, sr.FDCdata);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "ChangeFuelPrice")
                        {
                            ServiceResponseChangeFuelPrice sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseChangeFuelPrice>(myString, ref result);
                            ChangeFuelPriceResp(sr.RequestIDNumber, sr.OverallResult, sr.FDCdata);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "LockFuelSaleTrx")
                        {
                            ServiceResponseLockFuelSaleTrx sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseLockFuelSaleTrx>(myString, ref result);
                            LockFuelSaleTrxResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "UnlockFuelSaleTrx")
                        {
                            ServiceResponseUnlockFuelSaleTrx sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseUnlockFuelSaleTrx>(myString, ref result);
                            UnlockFuelSaleTrxResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "ClearFuelSaleTrx")
                        {
                            ServiceResponseClearFuelSaleTrx sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseClearFuelSaleTrx>(myString, ref result);
                            ClearFuelSaleTrxResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetAvailableFuelSaleTrxs")
                        {
                            ServiceResponseGetAvailableFuelSaleTrxs sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetAvailableFuelSaleTrxs>(myString, ref result);
                            GetAvailableFuelSaleTrxsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetFuelSaleTrxDetails")
                        {
                            string res = "";
                            if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                            {
                                ServiceResponseGetFuelSaleTrxDetailsV03 sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetFuelSaleTrxDetailsV03>(myString, ref result);
                                GetFuelSaleTrxDetailsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                res = sr.OverallResult;
                            }
                            else
                            {
                                ServiceResponseGetFuelSaleTrxDetails sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetFuelSaleTrxDetails>(myString, ref result);
                                GetFuelSaleTrxDetailsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                res = sr.OverallResult;
                            }
                            result = FDCConvert.OverallResultToInt(res);
                        }
                        else if (requestType == "GetProductTable")
                        {
                            ServiceResponseGetProductTable sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetProductTable>(myString, ref result);
                            GetProductTableResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetModeTable")
                        {
                            ServiceResponseGetModeTable sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetModeTable>(myString, ref result);
                            GetModeTableResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetFuelMode")
                        {
                            ServiceResponseGetFuelMode sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetFuelMode>(myString, ref result);
                            GetFuelModeResp(sr.RequestIDNumber, sr.OverallResult, sr.FDCdata);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetFPFuelMode")
                        {
                            ServiceResponseGetFPFuelMode sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetFPFuelMode>(myString, ref result);
                            GetFuelModeResp(sr.RequestIDNumber, sr.OverallResult, sr.FDCdata);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetConfiguration")
                        {
                            ServiceResponseGetConfiguration sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetConfiguration>(myString, ref result);
                            GetConfigurationResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetDSPConfiguration")
                        {
                            ServiceResponseGetDSPConfiguration sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetDSPConfiguration>(myString, ref result);
                            GetDSPConfigurationResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetTLGConfiguration")
                        {
                            ServiceResponseGetTLGConfiguration sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetTLGConfiguration>(myString, ref result);
                            GetTLGConfigurationResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetPPConfiguration")
                        {
                            ServiceResponseGetPPConfiguration sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetPPConfiguration>(myString, ref result);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "SetConfiguration")
                        {
                            ServiceResponseSetConfiguration sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseSetConfiguration>(myString, ref result);
                            SetConfigurationResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "LockNozzle")
                        {
                            ServiceResponseLockNozzle sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseLockNozzle>(myString, ref result);
                            LockNozzleResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "UnlockNozzle")
                        {
                            ServiceResponseUnlockNozzle sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseUnlockNozzle>(myString, ref result);
                            UnlockNozzleResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetCountrySettings")
                        {
                            ServiceResponseGetCountrySettings sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetCountrySettings>(myString, ref result);
                            GetCountrySettingsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetDSPLimits")
                        {
                            ServiceResponseGetDSPLimits sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetDSPLimits>(myString, ref result);
                            GetDSPLimitsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "ChangeDSPLimits")
                        {
                            ServiceResponseChangeDSPLimits sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseChangeDSPLimits>(myString, ref result);
                            ChangeDSPLimitsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "SuspendFuelling")
                        {
                            ServiceResponseSuspendFuelling sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseSuspendFuelling>(myString, ref result);
                            SuspendFuellingResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "ResumeFuelling")
                        {
                            ServiceResponseResumeFuelling sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseResumeFuelling>(myString, ref result);
                            ResumeFuellingResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "LockTank")
                        {
                            ServiceResponseLockTank sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseLockTank>(myString, ref result);
                            LockTankResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "UnlockTank")
                        {
                            ServiceResponseUnlockTank sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseUnlockTank>(myString, ref result);
                            UnlockTankResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetTankData")
                        {
                            ServiceResponseGetTankData sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetTankData>(myString, ref result);
                            GetTankDataResp(sr.RequestIDNumber, sr.OverallResult, sr, myString);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetTankReconciliation")
                        {
                            ServiceResponseGetTankReconciliation sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetTankReconciliation>(myString, ref result);
                            GetTankReconciliationResp(sr.RequestIDNumber, sr.OverallResult, sr, myString);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetTankDelivery")
                        {
                            ServiceResponseGetTankDelivery sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetTankDelivery>(myString, ref result);
                            GetTankDeliveryResp(sr.RequestIDNumber, sr.OverallResult, sr, myString);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "ReserveFuelPoint")
                        {
                            ServiceResponseReserveFuelPoint sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseReserveFuelPoint>(myString, ref result);
                            ReserveFuelPointResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "FreeFuelPoint")
                        {
                            ServiceResponseFreeFuelPoint sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseFreeFuelPoint>(myString, ref result);
                            FreeFuelPointResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "StartFuelPointTest")
                        {
                            ServiceResponseStartFuelPointTest sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseStartFuelPointTest>(myString, ref result);
                            StartFuelPointTestResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "EndFuelPointTest")
                        {
                            ServiceResponseEndFuelPointTest sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseEndFuelPointTest>(myString, ref result);
                            EndFuelPointTestResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "OpenFuelPoint")
                        {
                            ServiceResponseOpenFuelPoint sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseOpenFuelPoint>(myString, ref result);
                            OpenFuelPointResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "CloseFuelPoint")
                        {
                            ServiceResponseCloseFuelPoint sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseCloseFuelPoint>(myString, ref result);
                            CloseFuelPointResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "OpenDevice")
                        {
                            ServiceResponseOpenDevice sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseOpenDevice>(myString, ref result);
                            OpenDeviceResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "CloseDevice")
                        {
                            ServiceResponseCloseDevice sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseCloseDevice>(myString, ref result);
                            CloseDeviceResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "SetDeviceAlarm")
                        {
                            ServiceResponseSetDeviceAlarm sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseSetDeviceAlarm>(myString, ref result);
                            SetDeviceAlarmResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "OPTAdd")
                        {
                            ServiceResponseOPTAdd sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseOPTAdd>(myString, ref result);
                            OptAddResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "OPTRemove")
                        {
                            ServiceResponseOPTRemove sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseOPTRemove>(myString, ref result);
                            OptRemoveResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "OPTWrite")
                        {
                            ServiceResponseOPTWrite sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseOPTWrite>(myString, ref result);
                            OptWriteResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "ConfigStart")
                        {
                            ServiceResponseConfigStart sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseConfigStart>(myString, ref result);
                            if (FUSIONConfigFactory.getConfigurator() != null)
                                FUSIONConfigFactory.getConfigurator().ConfigStartResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "DefProducts")
                        {
                            ServiceResponseDefProducts sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseDefProducts>(myString, ref result);
                            if (FUSIONConfigFactory.getConfigurator() != null)
                                FUSIONConfigFactory.getConfigurator().DefProductsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "DefGrades")
                        {
                            ServiceResponseDefGrades sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseDefGrades>(myString, ref result);
                            if (FUSIONConfigFactory.getConfigurator() != null)
                                FUSIONConfigFactory.getConfigurator().DefGradesResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "DefTanks")
                        {
                            ServiceResponseDefTanks sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseDefTanks>(myString, ref result);
                            if (FUSIONConfigFactory.getConfigurator() != null)
                                FUSIONConfigFactory.getConfigurator().DefTanksResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "DefTankSuctions")
                        {
                            ServiceResponseDefTankSuctions sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseDefTankSuctions>(myString, ref result);
                            if (FUSIONConfigFactory.getConfigurator() != null)
                                FUSIONConfigFactory.getConfigurator().DefTankSuctionsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "DefFPFuelModes")
                        {
                            ServiceResponseDefFuelMode sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseDefFuelMode>(myString, ref result);
                            if (FUSIONConfigFactory.getConfigurator() != null)
                                FUSIONConfigFactory.getConfigurator().DefFuelModeResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "DefFCFuelMode")
                        {
                            ServiceResponseDefFuellingMode sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseDefFuellingMode>(myString, ref result);
                            if (FUSIONConfigFactory.getConfigurator() != null)
                                FUSIONConfigFactory.getConfigurator().DefFuellingModeResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "DefFuelPoints")
                        {
                            ServiceResponseDefFuelPoints sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseDefFuelPoints>(myString, ref result);
                            if (FUSIONConfigFactory.getConfigurator() != null)
                                FUSIONConfigFactory.getConfigurator().DefFuelPointsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "DefPricePoles")
                        {
                            ServiceResponseDefPricePole sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseDefPricePole>(myString, ref result);
                            if (FUSIONConfigFactory.getConfigurator() != null)
                                FUSIONConfigFactory.getConfigurator().DefPricePoleResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "DefTankMonitors")
                        {
                            ServiceResponseDefTankMonitor sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseDefTankMonitor>(myString, ref result);
                            if (FUSIONConfigFactory.getConfigurator() != null)
                                FUSIONConfigFactory.getConfigurator().DefTankMonitorResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "DefFPOperationModes")
                        {
                            ServiceResponseDefFPOperationModes sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseDefFPOperationModes>(myString, ref result);
                            if (FUSIONConfigFactory.getConfigurator() != null)
                                FUSIONConfigFactory.getConfigurator().DefFPOperationModesResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "ConfigEnd")
                        {
                            ServiceResponseConfigEnd sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseConfigEnd>(myString, ref result);
                            if (FUSIONConfigFactory.getConfigurator() != null)
                                FUSIONConfigFactory.getConfigurator().ConfigEndResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "GetFuelPrice")
                        {
                            ServiceResponseGetFuelPrices sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetFuelPrices>(myString, ref result);
                            GetFuelPricesResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }

                        else if (requestType == "CloseReconciliationPeriod")
                        {
                            ServiceResponseCloseReconciliationPeriod sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseCloseReconciliationPeriod>(myString, ref result);
                            CloseReconciliationPeriodResp(sr.RequestIDNumber, sr.OverallResult, sr.FDCdata);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "StopFuelPoint")
                        {
                            ServiceResponseStopFuelPoint sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseStopFuelPoint>(myString, ref result);
                            StopFuelPointResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else if (requestType == "StartFuelPoint")
                        {
                            ServiceResponseStartFuelPoint sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseStartFuelPoint>(myString, ref result);
                            StartFuelPointResp(sr.RequestIDNumber, sr.OverallResult, sr);
                            result = FDCConvert.OverallResultToInt(sr.OverallResult);
                        }
                        else
                        {

                        }
                        DebugLog(string.Format("ReadResponse end: requestType={0}, requestId={1}", requestType, requestId));
                    }
                    catch (Exception ex)
                    {
                        DebugLog(string.Format("ReadResponse RequestType='{0}', requestId={1} Exception! {2}", requestType, requestId, ex));
                        result = OverallResult.Failure;
                    }
                }

            }
            if (result != OverallResult.Success)
            {
                if (result != OverallResult.NoData)
                {
                    string deviceType = "";
                    int deviceId = 0;
                    int alarmId = 0;
                    string alarmmsg = string.Format("Error '{0}' receiving Response for requestId:'{1}', requestType:'{2}'", result.ToString(), requestId, requestType);
                    OnDeviceAlarm(this, new DeviceAlarmEventArgs(deviceType, deviceId, alarmId, alarmmsg));
                }
            }
            return requestType;
        }

        public string ReadMessage(string myString, int msglength, ref OverallResult result)
        {
            if (result != OverallResult.Success)
            {
                DebugLog(string.Format("ReadMessage ERROR result='{0}'", result));
            }
            string requestType = GetRequestType("MessageType", myString);
            int requestId = GetRequestID("MessageID", myString);
            DebugLog(string.Format("ReadMessage init: MessageType='{0}', requestId={1}", requestType, requestId));
            if (requestType == "")
            {
                DebugLog(string.Format("ReadMessage INVALID requestType='{0}', requestId={1}", requestType, requestId));
                return requestType;
            }
            int UTFlength = System.Text.Encoding.UTF8.GetBytes(myString).Length;
            if (UTFlength != msglength)
            {
                DebugLog(string.Format("ReadMessage header='{0}' != msgLength={1}", msglength, UTFlength));
                result = OverallResult.FormatError;
                return requestType;
            }
            try
            {
                switch (requestType)
                {
                    case "FDCHeartBeat":
                        {
                            HeartbeatMsg();
                        }
                        break;
                    case "FDCReady":
                    case "FDC_Ready":
                        {
                            HeartbeatMsg();
                        }
                        break;
                    case "FDCStarted":
                        {
                            FDCMessageStarted msg = clientSocket.ifsfMessages.Deserialize<FDCMessageStarted>(myString, ref result);
                            FDCStartedMsg(msg);
                        }
                        break;
                    case "TwinMasterIsOn":
                        {
                            FDCMessageTwinMasterIsOn msg = clientSocket.ifsfMessages.Deserialize<FDCMessageTwinMasterIsOn>(myString, ref result);
                            TwinMasterReadyMsg(msg);
                        }
                        break;
                    case "FDCStopped":
                        {
                            FDCMessageStopped msg = clientSocket.ifsfMessages.Deserialize<FDCMessageStopped>(myString, ref result);
                            FDCStoppedMsg(msg);
                        }
                        break;
                    case "DeviceStateChange":
                        {
                            FDCMessageDeviceStateChange msg = clientSocket.ifsfMessages.Deserialize<FDCMessageDeviceStateChange>(myString, ref result);
                            DeviceStateChangeMsg(msg);
                        }
                        break;
                    case "FPStateChange":
                        {
                            FDCMessageFPStateChange msg = clientSocket.ifsfMessages.Deserialize<FDCMessageFPStateChange>(myString, ref result);
                            FPStateChangeMsg(msg);
                        }
                        break;
                    case "TPStateChange":
                        {
                            FDCMessageTPStateChange msg = clientSocket.ifsfMessages.Deserialize<FDCMessageTPStateChange>(myString, ref result);
                            TPStateChangeMsg(msg);
                        }
                        break;
                    case "VIRStateChange":
                        {
                            FDCMessageVIRStateChange msg = clientSocket.ifsfMessages.Deserialize<FDCMessageVIRStateChange>(myString, ref result);
                            VIRStateChangeMsg(msg);
                        }
                        break;
                    case "FuelPointCurrentFuellingStatus":
                        {
                            FDCMessageCurrentFuellingStatus msg = clientSocket.ifsfMessages.Deserialize<FDCMessageCurrentFuellingStatus>(myString, ref result);
                            CurrentFuellingStatusMsg(msg);
                        }
                        break;
                    case "DeviceAlarm":
                        {
                            FDCMessageDeviceAlarm msg = clientSocket.ifsfMessages.Deserialize<FDCMessageDeviceAlarm>(myString, ref result);
                            DeviceAlarmMsg(msg);
                        }
                        break;
                    case "FuelSaleTrx":
                        {
                            FDCMessageFuelSaleTrx msg = clientSocket.ifsfMessages.Deserialize<FDCMessageFuelSaleTrx>(myString, ref result);
                            FuelSaleTrxMsg(msg, myString);
                        }
                        break;
                    case "FuelPriceChange":
                        {
                            FDCMessageFuelPriceChange msg = clientSocket.ifsfMessages.Deserialize<FDCMessageFuelPriceChange>(myString, ref result);
                            FuelPriceChangeMsg(msg);
                        }
                        break;
                    case "FuelModeChange":
                        {
                            FDCMessageFuelModeChange msg = clientSocket.ifsfMessages.Deserialize<FDCMessageFuelModeChange>(myString, ref result);
                            FuelModeChangeMsg(msg.FDCdata[0]);
                        }
                        break;
                    case "FPModeChange":
                        {
                            FDCMessageFPModeChange msg = clientSocket.ifsfMessages.Deserialize<FDCMessageFPModeChange>(myString, ref result);
                            FuelModeChangeMsg(msg.FDCdata[0]);
                        }
                        break;
                    case "FDCExceptionMsg":
                        {
                            FDCMessageFDCExceptionMsg msg = clientSocket.ifsfMessages.Deserialize<FDCMessageFDCExceptionMsg>(myString, ref result);
                            FDCExceptionMsg(msg);
                        }
                        break;
                    case "ConfigurationChange":
                        {
                            FDCMessageConfigurationChange msg = clientSocket.ifsfMessages.Deserialize<FDCMessageConfigurationChange>(myString, ref result);
                            FDCMessageConfigurationChangeMsg(msg);
                        }
                        break;
                    case "OPTRead":
                        if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                        {
                            FDCMessageOPTReadV07 msg = clientSocket.ifsfMessages.Deserialize<FDCMessageOPTReadV07>(myString, ref result);
                            OptReadMsg(msg);
                        }
                        else
                        {
                            FDCMessageOPTRead msg = clientSocket.ifsfMessages.Deserialize<FDCMessageOPTRead>(myString, ref result);
                            OptReadMsg(msg);
                        }
                        break;
                }
                DebugLog("ReadMessage end");
            }
            catch (Exception ex)
            {
                DebugLog(string.Format("ReadMessage MessageType='{0}', requestId={1} Exception! {2}", requestType, requestId, ex));
            }
            return requestType;
        }

        private string GetRequestType(string typeField, string myString)
        {
            string requestType = "";
            try
            {
                int pos;
                if ((pos = myString.IndexOf(typeField)) >= 0)
                {
                    int si = myString.IndexOf('\"', pos) + 1;
                    int ei = myString.IndexOf('\"', si);
                    requestType = myString.Substring(si, ei - si);
                }
            }
            catch (Exception ex)
            {
                DebugLog("Exception! " + ex);
            }
            return requestType;
        }

        private int GetRequestID(string typeField, string myString)
        {
            int requestID = 0;
            try
            {
                int pos;
                if ((pos = myString.IndexOf(typeField)) >= 0)
                {
                    int si = myString.IndexOf('\"', pos) + 1;
                    int ei = myString.IndexOf('\"', si);
                    requestID = Convert.ToInt32(myString.Substring(si, ei - si));
                }
            }
            catch (Exception ex)
            {
                DebugLog("Exception! " + ex);
            }
            return requestID;
        }

        public void LogOn(string posInfo, string sFDCDateTime)
        {
            // POS open channel A and send LogOn command
            // FDC open channel B and C and send LogOn response
            LogOn(null, posInfo, sFDCDateTime);
        }

        public void LogOn(byte[][] validationInfoArray, string posInfo, string sFDCDateTime)
        {
            // POS open channel A and send LogOn command
            // FDC open channel B and C and send LogOn response

            try
            {
                DebugLog(string.Format("LogOn init, version={0}", FDCGlobal.ProtocolVersion));
                ServiceRequest logOn;
                if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                {
                    // create XML ServiceRequest object
                    logOn = new ServiceRequestLogOnV07();
                    logOn.ApplicationSender = clientSocket.applicationSender;
                    logOn.WorkstationID = clientSocket.workstationID;

                    ServiceRequestPOSdataLogOnV07 posDataElem = new ServiceRequestPOSdataLogOnV07();
                    posDataElem.POSName = "";
                    if (sFDCDateTime == "")
                        posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                    else
                        posDataElem.POSTimeStamp = sFDCDateTime;
                    posDataElem.ResponsePort = clientSocket.iIPPortB.ToString();
                    posDataElem.UnsolicitedPort = clientSocket.iIPPortC.ToString();
                    posDataElem.interfaceVersion = FDCGlobal.VersionToString();
                    posDataElem.InterfaceVersion = FDCGlobal.VersionToString();
                    if (posInfo != "")
                    {
                        posDataElem.posInfo = UTF8Encoding.UTF8.GetBytes(posInfo);
                    }
                    if (validationInfoArray != null)
                        posDataElem.ValidationInfo = validationInfoArray;
                    ServiceRequestPOSdataLogOnV07[] posDataArray = { posDataElem };

                    ((ServiceRequestLogOnV07)logOn).POSdata = posDataArray;
                }
                else
                {
                    // create XML ServiceRequest object
                    logOn = new ServiceRequestLogOn();
                    logOn.ApplicationSender = clientSocket.applicationSender;
                    logOn.WorkstationID = clientSocket.workstationID;

                    ServiceRequestPOSdataLogOn posDataElem = new ServiceRequestPOSdataLogOn();
                    posDataElem.POSName = "";
                    if (sFDCDateTime == "")
                        posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                    else
                        posDataElem.POSTimeStamp = sFDCDateTime;
                    posDataElem.ResponsePort = clientSocket.iIPPortB.ToString();
                    posDataElem.UnsolicitedPort = clientSocket.iIPPortC.ToString();
                    posDataElem.InterfaceVersion = FDCGlobal.VersionToString();
                    if (posInfo != "")
                    {
                        // Get UTF16 bytes and convert UTF16 bytes to UTF8 bytes
                        DebugLog(string.Format("EnqueueMessage logOn posInfo='{0}'", posInfo));
                        posDataElem.posInfo = posInfo;
                    }
                    if (validationInfoArray != null)
                    {
                        posDataElem.ValidationInfo = validationInfoArray;
                    }

                    // calculate posValidation string
                    string posValidationSourceString = logOn.ApplicationSender + logOn.WorkstationID + posDataElem.POSTimeStamp;
                    MD5Crypter crypter = new MD5Crypter();
                    byte[] posValidationSource = new byte[posValidationSourceString.Length + crypter.getPassphrase().GetLength(0)];
                    Array.Copy(System.Text.Encoding.ASCII.GetBytes(posValidationSourceString), posValidationSource, (int)posValidationSourceString.Length);
                    Array.Copy(crypter.getPassphrase(), 0, posValidationSource, (int)posValidationSourceString.Length, (int)crypter.getPassphrase().Length);
                    byte[] posValidation = crypter.ComputeHash(posValidationSource);
                    posDataElem.posValidation = "";

                    StringBuilder sb = new StringBuilder(posValidation.Length * 2);
                    foreach (byte b in posValidation)
                        sb.Append(Convert.ToString(b, 16).PadLeft(2, '0'));
                    posDataElem.posValidation = sb.ToString().ToUpper();

                    DebugLog(string.Format("EnqueueMessage logOn posValidationSource='{0}', posValidation='{1}'", System.Text.Encoding.ASCII.GetString(posValidationSource, 0, posValidationSource.Length), posDataElem.posValidation));
                    ServiceRequestPOSdataLogOn[] posDataArray = { posDataElem };

                    ((ServiceRequestLogOn)logOn).POSdata = posDataArray;
                }

                DebugLog("EnqueueMessage logOn");
                clientSocket.ifsfMessages.EnqueueMessage(logOn, (EventHandler<AsyncCompletedEventArgs>)null, null, null, true, 30000);
                DebugLog("LogOn2 end");
            }
            catch (Exception ex)
            {
                DebugLog("LogOn Exception! " + ex);
            }
        }

        public void LogOnAddValidationInfo(byte[] validationInfo)
        {
            // POS open channel A and send LogOn command
            // FDC open channel B and C and send LogOn response

            try
            {
                if (validationInfo == null)
                {
                    DebugLog("LogOnAddValidationInfo: null validationInfo");
                    return;
                }
                DebugLog("LogOnAddValidationInfo init");
                if (this._clientSocket.logOnSendCalled && this._clientSocket.validationInfo != null)
                {
                    this._clientSocket.validationInfo = null;
                    this._clientSocket.logOnSendCalled = false;
                    DebugLog("LogOnAddValidationInfo logOnSendCalled=false");
                }

                byte[][] ValidationInfo = this._clientSocket.validationInfo;
                IFSFManager.ArrayResize<byte[]>(ref ValidationInfo, (ValidationInfo != null) ? ValidationInfo.Length + 1 : 1);
                this._clientSocket.validationInfo = ValidationInfo;
                this._clientSocket.validationInfo[this._clientSocket.validationInfo.Length - 1] = new byte[validationInfo.Length];
                this._clientSocket.validationInfo[this._clientSocket.validationInfo.Length - 1] = validationInfo;

                DebugLog("LogOnAddValidationInfo end");
            }
            catch (Exception ex)
            {
                DebugLog("LogOnAddValidationInfo Exception! " + ex);
            }
        }

        public void LogOnSend(string posInfo)
        {
            // POS open channel A and send LogOn command
            // FDC open channel B and C and send LogOn response

            try
            {
                DebugLog("LogOnSend init");

                // create XML ServiceRequest object
                if (serviceRequestLogOn == null)
                {
                    LogOn(posInfo, "");
                }
                else
                {
                    DebugLog("EnqueueMessage logOn");
                    var logOn = serviceRequestLogOn;
                    serviceRequestLogOn = null;
                    clientSocket.ifsfMessages.EnqueueMessage(logOn, null, null, null, true, 30000);
                }
                this._clientSocket.logOnSendCalled = true;
                DebugLog("LogOnSend end");
            }
            catch (Exception ex)
            {
                DebugLog("LogOnSend Exception! " + ex);
            }
        }

        private void LogOnResp(int requestId, string sOverallResult, string seal, string sFDCTimeStamp)
        {
            try
            {
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());

                if (sOverallResult == OverallResult.Success.ToString())
                {
                    // must be called after LogOn successful because the server must register the client before receiving messages
                    DebugLog(string.Format("Restarting HeartBeat next in {0}", heartbeat.heartbeatInterval));
                    heartbeat.SetReconnected();
                    heartbeat.Restart();

                    GetCountrySettings(null, null, null);

                    // check if != Connected becose FDCStart (that set state to Connected) could became before LogOnResp
                    if (clientSocket.mainConnectionState != DeviceConnectionState.Connected)
                        clientSocket.mainConnectionState = DeviceConnectionState.Connecting;

                    if (seal != "" && OnDeviceAlarm != null)
                    {
                        string deviceType = "";
                        int deviceId = 0;
                        int alarmId = 2020; // FUSION_IMSG_SEAL
                        string alarmmsg = seal;
                        OnDeviceAlarm(this, new DeviceAlarmEventArgs(deviceType, deviceId, alarmId, alarmmsg));
                    }
                }
                else if (sOverallResult == OverallResult.AuthentificationError.ToString())
                {
                    DebugLog(string.Format("authentificationErrorRetry={0}, sFDCTimeStamp={1}", authentificationErrorRetry, sFDCTimeStamp));
                    if (authentificationErrorRetry)
                    {
                        authentificationErrorRetry = false;
                        this.LogOn(clientSocket.validationInfo, clientSocket.posInfo, sFDCTimeStamp);
                    }
                    else if (OnDeviceAlarm != null)
                    {
                        authentificationErrorRetry = true;
                        string deviceType = "";
                        int deviceId = 0;
                        int alarmId = 1001; //FUSION_E_AUTHENTIFICATION_FAILED
                        string alarmmsg = "";
                        OnDeviceAlarm(this, new DeviceAlarmEventArgs(deviceType, deviceId, alarmId, alarmmsg));
                    }
                }
            }
            catch (Exception ex)
            {
                DebugLog("LogOnResp Exception! " + ex);
            }
        }

        public void LogOff()
        {
            // POS send LogOff command and close channel A 
            // FDC send LogOff response and close channel B and C 

            try
            {
                DebugLog("LogOff init");

                // create XML ServiceRequest object
                ServiceRequestLogOff logOff = new ServiceRequestLogOff();
                logOff.ApplicationSender = clientSocket.applicationSender;
                logOff.WorkstationID = clientSocket.workstationID;

                ServiceRequestPOSdataLogOff posDataElem = new ServiceRequestPOSdataLogOff();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                ServiceRequestPOSdataLogOff[] posDataArray = { posDataElem };

                logOff.POSdata = posDataArray;

                DebugLog("EnqueueMessage logOff");
                clientSocket.ifsfMessages.EnqueueMessage(logOff, null, null, null, true, 30000);
                DebugLog("LogOff end");
            }
            catch (Exception ex)
            {
                DebugLog("LogOff Exception! " + ex);
            }
        }

        private void LogOffResp(int requestId, string sOverallResult)
        {
            try
            {
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString());

                if (sOverallResult == OverallResult.Success.ToString())
                {
                    if (clientSocket.mainConnectionState != DeviceConnectionState.Connected || clientSocket.mainConnectionState != DeviceConnectionState.Connecting)
                        clientSocket.mainConnectionState = DeviceConnectionState.Disconnecting;
                }
            }
            catch (Exception ex)
            {
                DebugLog("LogOffResp Exception! " + ex);
            }
        }

        private void Heartbeat()
        {
            try
            {
                if (!heartbeat.tryingConnect)
                {
                    ServiceRequestHeartbeat heartbeatmsg = new ServiceRequestHeartbeat();
                    heartbeatmsg.ApplicationSender = this.clientSocket.applicationSender;
                    heartbeatmsg.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSReady srPosready = new ServiceRequestPOSReady();
                    srPosready.ApplicationSender = this.clientSocket.applicationSender;
                    srPosready.WorkstationID = this.clientSocket.workstationID;

                    POSMessagePOSReady msgPOSReady = new POSMessagePOSReady();
                    msgPOSReady.ApplicationSender = this.clientSocket.applicationSender;
                    msgPOSReady.WorkstationID = this.clientSocket.workstationID;
                    DebugLog(string.Format("new POSReady: type={0},id={1}, counter={2}", msgPOSReady.MessageType, msgPOSReady.MessageID, FDCMessage.requestIDConter));

                    ServiceRequestPOSdataHeartbeat posDataElem = new ServiceRequestPOSdataHeartbeat();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                    ServiceRequestPOSdataHeartbeat[] posDataArray = { posDataElem };

                    heartbeatmsg.POSdata = posDataArray;
                    srPosready.POSdata = posDataArray;
                    msgPOSReady.POSdata = posDataArray;

                    heartbeat.Restart();

                    if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                        clientSocket.ifsfMessages.EnqueueMessage(heartbeatmsg, null, null, null, false, 0);
                    else
                        clientSocket.ifsfMessages.EnqueueMessage(msgPOSReady, null, null, null, false, 0);
                }
                else
                {
                    DebugLog("HeartBeat tryingToConnect");

                    var clientSocketRespChannelBThreadObj = this.clientSocket.respChannelBThreadObj;

                    if (clientSocketRespChannelBThreadObj != null)
                    {
                        DebugLog(string.Format("HeartBeat true && {0}", !clientSocketRespChannelBThreadObj.bRunning));
                    }
                    else
                    {
                        DebugLog("HeartBeat false ");
                    }

                    if (clientSocketRespChannelBThreadObj != null && !clientSocketRespChannelBThreadObj.bRunning)
                    {
                        DebugLog("HeartBeat reconnecting");
                        if (this.clientSocket.Connect(""))
                        {
                            heartbeat.tryingConnect = false;
                            DebugLog("HeartBeat Restarting");
                            heartbeat.Restart();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                DebugLog("HeartBeat Exception! " + ex);
            }
        }

        public void VersionInfo(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestVersionInfo sr = new ServiceRequestVersionInfo();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataVersionInfo posDataElem = new ServiceRequestPOSdataVersionInfo();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                ServiceRequestPOSdataVersionInfo[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("VersionInfo Exception! " + ex);
            }
        }

        private void VersionInfoResp(int requestId, string sOverallResult, ServiceResponseVersionInfo sr)
        {
            try
            {
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString());

                if (OnVersionInfo != null)
                {
                    OnVersionInfo(this, new VersionInfoEventArgs(sr.FDCdata[0].FDCversion, sr.FDCdata[0].FDCrelease, sr.FDCdata[0].FDChotfix));
                }
            }
            catch (Exception ex)
            {
                DebugLog("VersionInfoResp Exception! " + ex);
            }
        }

        public void StartForecourt(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestStartForecourt sr = new ServiceRequestStartForecourt();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataStartForecourt posDataElem = new ServiceRequestPOSdataStartForecourt();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                ServiceRequestPOSdataStartForecourt[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("StartForecourt Exception! " + ex);
            }
        }

        public void TwinOpenMaster(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestTwinOpenMaster sr = new ServiceRequestTwinOpenMaster();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataTwinOpenMaster posDataElem = new ServiceRequestPOSdataTwinOpenMaster();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                ServiceRequestPOSdataTwinOpenMaster[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("TwinOpenMaster Exception! " + ex);
            }
        }

        private void StartForecourtResp(int requestId, string sOverallResult, string errorCode)
        {
            try
            {
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                DebugLog("StartForecourtResp Exception! " + ex);
            }
        }

        private void TwinOpenMasterResp(int requestId, string sOverallResult, string errorCode)
        {
            try
            {
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                DebugLog("TwinOpenMasterResp Exception! " + ex);
            }
        }

        public void StopForecourt(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestStopForecourt sr = new ServiceRequestStopForecourt();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataStopForecourt posDataElem = new ServiceRequestPOSdataStopForecourt();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                posDataElem.Emergencystop = "false";
                ServiceRequestPOSdataStopForecourt[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("StopForecourt Exception! " + ex);
            }
        }

        private void StopForecourtResp(int requestId, string sOverallResult, string errorCode)
        {
            try
            {
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                DebugLog("StopForecourtResp Exception! " + ex);
            }
        }


        public void GetCurrentFuellingStatus(int pumpId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetCurrentFuellingStatus sr = new ServiceRequestGetCurrentFuellingStatus();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetCurrentFuellingStatus posDataElem = new ServiceRequestPOSdataGetCurrentFuellingStatus();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetCurrentFuellingStatus[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetCurrentFuellingStatus Exception! " + ex);
            }
        }

        public void GetFuelPointTotals(int pumpId, int nozzleId, EventHandler<AsyncCompletedEventArgs<PumpAccumulatorReading>> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetFuelPointTotals sr = new ServiceRequestGetFuelPointTotals();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetFuelPointTotals posDataElem = new ServiceRequestPOSdataGetFuelPointTotals();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassGetFuelPointTotals deviceClass = new ServiceRequestDeviceClassGetFuelPointTotals();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.NozzleNo = (nozzleId == -1) ? "*" : Convert.ToString(nozzleId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetFuelPointTotals[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                EventHandler<AsyncCompletedEventArgs> proxy = (sender, e) => requestCompleted(sender, (AsyncCompletedEventArgs<PumpAccumulatorReading>)e);
                clientSocket.ifsfMessages.EnqueueMessage(sr, proxy, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetFuelPointTotals Exception! " + ex);
            }
        }

        private void GetCurrentFuellingStatusResp(int requestId, string sOverallResult, ServiceResponseGetCurrentFuellingStatus sr)
        {
            try
            {
                DebugLog("GetCurrentFuellingStatusResp init");
                if (OnCurrentFuellingStatus != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        var deviceClass = sr.FDCdata[0].DeviceClass[i];

                        if (!string.IsNullOrEmpty(deviceClass.ReleaseToken) &&
                            !string.IsNullOrEmpty(deviceClass.CurrentAmount) &&
                            !string.IsNullOrEmpty(deviceClass.CurrentVolume))
                        {
                            DebugLog(string.Format("type={0}, id={1}, volume={2}, amount={3}", deviceClass.Type,
                                                          deviceClass.DeviceID, deviceClass.CurrentVolume,
                                                          deviceClass.CurrentAmount));
                            string deviceType = deviceClass.Type;
                            int deviceId = Convert.ToInt16(deviceClass.DeviceID);
                            int nozzleId = Convert.ToInt16(deviceClass.CurrentNozzle);
                            Decimal volume = FDCConvert.ToDecimal(deviceClass.CurrentVolume);
                            Decimal amount = FDCConvert.ToDecimal(deviceClass.CurrentAmount);
                            Decimal price = FDCConvert.ToDecimal(deviceClass.CurrentUnitPrice);
                            string authAS = deviceClass.AuthorisationApplicationSender;
                            var token = AuthReleaseTokenFactory.GenerateToken(deviceClass.ReleaseToken);

                            //generate the event payload and add the ReleaseId parsed from the ReleaseToken
                            var eventArgs = new CurrentFuellingStatusEventArgs(deviceType, deviceId, nozzleId, volume,
                                                                               amount, price, authAS)
                                {
                                    ReleaseId = token.AuthorizationId,
                                    ReservingDeviceId = token.TerminalId,
                                    TransactionId = Convert.ToInt32(deviceClass.TransactionSeqNo),
                                    FuelPeriodSequenceNo = Convert.ToInt32(deviceClass.FuelPeriodSequenceNo)
                                };

                            OnCurrentFuellingStatus(this, eventArgs);
                        }
                        else
                        {
                            DebugLog("fuelling status data empty");
                        }
                    }
                }
                DebugLog("GetCurrentFuellingStatusResp end");

                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                DebugLog("GetCurrentFuellingStatusResp Exception! " + ex);
            }
        }

        private void GetFuelPointTotalsResp(int requestId, string sOverallResult, ServiceResponseGetFuelPointTotals sr, string originalXml)
        {
            try
            {
                DebugLog("GetFuelPointTotalsResp init");
                if (OnFuelPointTotals != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        DebugLog(string.Format("type={0}, id={1}, volume={2}, amount={3}", sr.FDCdata[0].DeviceClass[i].Type, sr.FDCdata[0].DeviceClass[i].DeviceID, sr.FDCdata[0].DeviceClass[i].Volume, sr.FDCdata[0].DeviceClass[i].Amount));
                        string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                        int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        int nozzleId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].NozzleNo);
                        Decimal volume = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].Volume);
                        Decimal amount = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].Amount);
                        Decimal price = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].UnitPrice);
                        OnFuelPointTotals(this, new FuelPointTotalsEventArgs(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString(),
                                                                             deviceType, deviceId, nozzleId, volume, amount, price, originalXml));
                    }
                DebugLog("GetFuelPointTotalsResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetFuelPointTotalsResp Exception! " + ex);
            }
        }

        public void GetDeviceState(string deviceType, int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                DebugLog(string.Format("GetDeviceState init: deviceId={0}, deviceType={1}", deviceId, deviceType));
                // create XML ServiceRequest object
                if (deviceType == DeviceType.DT_FuellingPoint)
                {
                    ServiceRequestGetFPState sr = new ServiceRequestGetFPState();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataGetDeviceState posDataElem = new ServiceRequestPOSdataGetDeviceState();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                    deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                    deviceClass.Type = deviceType;

                    posDataElem.DeviceClass = deviceClass;
                    ServiceRequestPOSdataGetDeviceState[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
                }
                else if (deviceType == DeviceType.DT_TankProbe || deviceType == DeviceType.DT_TankLevelGauge)
                {
                    ServiceRequestGetTPState sr = new ServiceRequestGetTPState();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataGetDeviceState posDataElem = new ServiceRequestPOSdataGetDeviceState();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                    deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                    deviceClass.Type = deviceType;

                    posDataElem.DeviceClass = deviceClass;
                    ServiceRequestPOSdataGetDeviceState[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
                }
                else if (deviceType == DeviceType.DT_Vir)
                {
                    ServiceRequestGetVIRState sr = new ServiceRequestGetVIRState();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataGetDeviceState posDataElem = new ServiceRequestPOSdataGetDeviceState();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                    deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                    deviceClass.Type = deviceType;

                    posDataElem.DeviceClass = deviceClass;
                    ServiceRequestPOSdataGetDeviceState[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
                }
                else if (deviceType == DeviceType.DT_PricePole || deviceType == DeviceType.DT_PricePolePoint)
                {
                    ServiceRequestGetPPState sr = new ServiceRequestGetPPState();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataGetDeviceState posDataElem = new ServiceRequestPOSdataGetDeviceState();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                    deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                    deviceClass.Type = deviceType;

                    posDataElem.DeviceClass = deviceClass;
                    ServiceRequestPOSdataGetDeviceState[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
                }
                else
                {
                    ServiceRequestGetDeviceState sr = new ServiceRequestGetDeviceState();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataGetDeviceState posDataElem = new ServiceRequestPOSdataGetDeviceState();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                    deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                    deviceClass.Type = deviceType;

                    posDataElem.DeviceClass = deviceClass;
                    ServiceRequestPOSdataGetDeviceState[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
                }
                DebugLog("GetDeviceState end");
            }
            catch (Exception ex)
            {
                DebugLog("GetDeviceState Exception! " + ex);
            }
        }

        private void GetDeviceStateResp(int requestId, string sOverallResult, ServiceResponseGetDeviceState sr)
        {
            try
            {
                if (OnDeviceStateChange != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        DebugLog(string.Format("GetDeviceStateResp type={0}, id={1}, state={2}, substate={3}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[i].DeviceID, sr.FDCdata[0].DeviceClass[i].LogicalState, sr.FDCdata[0].DeviceClass[i].LogicalSubState));

                        string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                        int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        LogicalDeviceState state = this.convertLogicalDeviceState(!string.IsNullOrEmpty(sr.FDCdata[0].DeviceClass[i].LogicalState) ? sr.FDCdata[0].DeviceClass[i].LogicalState : sr.FDCdata[0].DeviceClass[i].DeviceState.DeviceState);
                        LogicalDeviceState substate = convertLogicalDeviceState(!string.IsNullOrEmpty(sr.FDCdata[0].DeviceClass[i].LogicalSubState) ? sr.FDCdata[0].DeviceClass[i].LogicalSubState : sr.FDCdata[0].DeviceClass[i].DeviceSubState);
                        int nozzleUp = 0;
                        if (sr.FDCdata[0].DeviceClass[i].Nozzle != null)
                        {
                            foreach (NozzleStateClass nozzleState in sr.FDCdata[0].DeviceClass[i].Nozzle)
                            {
                                if (nozzleState.LogicalNozzle == "NozzleUp")
                                    nozzleUp = Convert.ToInt32(nozzleState.NozzleNo);
                            }
                        }
                        OnDeviceStateChange.Invoke(this, new DeviceStateChangedEventArgs(deviceType, deviceId, state, substate, "", nozzleUp));
                    }
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString());
                }
                DebugLog("GetDeviceStateResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetDeviceStateResp Exception! " + ex);
            }
        }

        private void GetFPStateResp(int requestId, string sOverallResult, ServiceResponseGetFPState sr)
        {
            try
            {
                if (OnDeviceStateChange != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    if (sOverallResult == OverallResult.Success.ToString())
                    {
                        for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                        {
                            DebugLog(string.Format("GetFPStateResp type={0}, id={1}, state={2}, substate={3}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[i].DeviceID, sr.FDCdata[0].DeviceClass[i].DeviceState, sr.FDCdata[0].DeviceClass[i].DeviceSubState));

                            string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                            int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                            LogicalDeviceState state = this.convertLogicalDeviceState(sr.FDCdata[0].DeviceClass[i].DeviceState.DeviceState);
                            LogicalDeviceState substate = convertLogicalDeviceState(sr.FDCdata[0].DeviceClass[i].DeviceSubState);
                            if (!string.IsNullOrEmpty(sr.FDCdata[0].DeviceClass[i].DeviceState.Stopped) && XmlConvert.ToBoolean(sr.FDCdata[0].DeviceClass[i].DeviceState.Stopped))
                                substate = LogicalDeviceState.FDC_STOPPED;
                            string lockingAS = sr.FDCdata[0].DeviceClass[i].LockingApplicationSender;
                            int nozzleUp = 0;
                            if (sr.FDCdata[0].DeviceClass[i].Nozzle != null)
                            {
                                foreach (NozzleStateClass nozzleState in sr.FDCdata[0].DeviceClass[i].Nozzle)
                                {
                                    if (nozzleState.LogicalNozzle == "NozzleUp")
                                        nozzleUp = Convert.ToInt32(nozzleState.NozzleNo);
                                }
                            }
                            OnDeviceStateChange.Invoke(this, new DeviceStateChangedEventArgs(deviceType, deviceId, state, substate, lockingAS, nozzleUp));
                        }
                    }
                    else
                        DebugLog(string.Format("overallResult={0}", sOverallResult));
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                }
                DebugLog("GetFPStateResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetFPStateResp Exception! " + ex);
            }
        }

        private void GetTPStateResp(int requestId, string sOverallResult, ServiceResponseGetTPState sr)
        {
            try
            {
                if (OnDeviceStateChange != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        DebugLog(string.Format("GetTPStateResp type={0}, id={1}, state={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[i].DeviceID, sr.FDCdata[0].DeviceClass[i].DeviceState));

                        string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                        int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        LogicalDeviceState state = this.convertLogicalDeviceState(sr.FDCdata[0].DeviceClass[i].DeviceState.DeviceState);
                        OnDeviceStateChange.Invoke(this, new DeviceStateChangedEventArgs(deviceType, deviceId, state, LogicalDeviceState.FDC_UNDEFINED, "", 0));
                    }
                }
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString());
                DebugLog("GetTPStateResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetTPStateResp Exception! " + ex);
            }
        }

        private void GetPPStateResp(int requestId, string sOverallResult, ServiceResponseGetPPState sr)
        {
            try
            {
                if (OnDeviceStateChange != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        DebugLog(string.Format("GetPPStateResp type={0}, id={1}, state={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[i].DeviceID, sr.FDCdata[0].DeviceClass[i].DeviceState));
                    }
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString());
                }
                DebugLog("GetPPStateResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetPPStateResp Exception! " + ex);
            }
        }

        private void GetVIRStateResp(int requestId, string sOverallResult, ServiceResponseGetVIRState sr)
        {
            try
            {
                if (OnVirStateChange != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        if (sr.FDCdata[0].DeviceClass[i].Vir != null)
                        {
                            foreach (VIRStateClass virState in sr.FDCdata[0].DeviceClass[i].Vir)
                            {
                                DebugLog(string.Format("GetVIRStateResp type={0}, id={1}, virId={2}, state={3}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[i].DeviceID, virState.VirID, virState.DeviceState));
                                LogicalDeviceState state = this.convertLogicalDeviceState(virState.DeviceState);
                                DeviceConnectionState deviceState;
                                if (state == LogicalDeviceState.FDC_READY)
                                    deviceState = DeviceConnectionState.Connected;
                                else if (state == LogicalDeviceState.FDC_OFFLINE)
                                    deviceState = DeviceConnectionState.Disconnected;
                                else
                                    deviceState = DeviceConnectionState.Unknown;
                                OnVirStateChange(this, new VIRStateChangedEventArgs(deviceId, virState.VirID, deviceState));
                            }
                        }
                    }
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString());
                }
                DebugLog("GetVIRStateResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetVIRStateResp Exception! " + ex);
            }
        }

        public void TerminateFuelling(int pumpId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestTerminateFuelling sr = new ServiceRequestTerminateFuelling();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataTerminateFuelling posDataElem = new ServiceRequestPOSdataTerminateFuelling();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;
                deviceClass.CreateZeroSale = Convert.ToString(false);

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataTerminateFuelling[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("TerminateFuelling Exception! " + ex);
            }
        }

        private void TerminateFuellingResp(int requestId, string sOverallResult, ServiceResponseTerminateFuelling sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass[0].ErrorCode;
                DebugLog(string.Format("TerminateFuellingResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[0].DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                DebugLog("TerminateFuellingResp Exception! " + ex);
            }
        }

        public void AuthoriseFuelPoint(int pumpId, int transactionId, FuellingType fuellingType, byte reservingDeviceId, IAuthorizeParameters authParams, EventHandler<AsyncCompletedEventArgs<long>> requestCompleted, object userToken, object src)
        {
            try
            {
                DebugLog(String.Format("ISFSManager.AuthoriseFuelPoint: pumpId={0}, fuellingType={1}, reservingDeviceId={2}, request={3}, Token={4} Src={5}",
                        pumpId, fuellingType, reservingDeviceId, requestCompleted, userToken, src));
                DebugLog(
                    String.Format(
                        "ISFSManager.AuthoriseFuelPoint: authParams: PresetType={0}, PresetValue={1}, LockToClient={2}, Prepay={3}, ConsentGiven={4}, PriceGroup={5}, AllowedFuelGrade={6}, FuelGradeMaxVolume={7}",
                        authParams.PresetType, authParams.PresetValue, authParams.LockToReleaseClient, authParams.Prepay,
                        authParams.ConsentGiven, authParams.PriceGroup, authParams.AllowedFuelGrade,
                        authParams.FuelGradeMaxVolume));

                // create XML ServiceRequest object
                ServiceRequestAuthoriseFuelPoint sr = new ServiceRequestAuthoriseFuelPoint();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataAuthoriseFuelPoint posDataElem = new ServiceRequestPOSdataAuthoriseFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassAuthoriseFuelPoint authFP = new ServiceRequestDeviceClassAuthoriseFuelPoint();
                authFP.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                authFP.Type = DeviceType.DT_FuellingPoint;
                if (authParams.PresetType == PresetType.Amount)
                {
                    authFP.MaxTrxVolume = FDCConvert.ToString((Decimal)0);
                    authFP.MaxTrxAmount = FDCConvert.ToString(authParams.PresetValue);
                }
                else
                {
                    authFP.MaxTrxVolume = FDCConvert.ToString(authParams.PresetValue);
                    authFP.MaxTrxAmount = FDCConvert.ToString((Decimal)0);
                }
                authFP.LockFuelSaleTrx = Convert.ToString(authParams.LockToReleaseClient);

                //Token is a composition of the terminal id and release id, this token is echoed back when the transaction is completed
                //Terminal Id is only needed for outdoor or prepaid transactions. All other have Terminal Id = 0.
                //Receipt no is only used for prepaid transactions,
                var terminalId = 0;
                if (fuellingType == FuellingType.OptCardPaid || fuellingType == FuellingType.OptCashPaid)
                    terminalId = reservingDeviceId;
                if (fuellingType == FuellingType.Prepaid)
                    terminalId = authParams.PrepayReceiptNo / 10000;
                var token = AuthReleaseTokenFactory.GenerateToken(
                    terminalId,
                    transactionId,
                    fuellingType == FuellingType.Prepaid ? (int?)(authParams.PrepayReceiptNo % 10000) : null);
                authFP.ReleaseToken = token.ToString();

                authFP.ReservingDeviceId = Convert.ToString(reservingDeviceId);
                authFP.FuellingType = Convert.ToString((int)fuellingType);

                if (authParams.Prepay)
                {
                    var prepaidTrx = new PrepaidTrxElementClass();
                    prepaidTrx.IsPrepaid = Convert.ToString(true);
                    authFP.PrepaidTrx = prepaidTrx;
                }

                if (authParams.ConsentGiven)
                    authFP.ConsentGiven = Convert.ToString(true);

                authFP.ProcessZeroSale = Convert.ToString(authParams.ProcessZeroSale);

                authFP.ApplyAuthPresetRetries = Convert.ToString(authParams.ApplyAuthPresetRetries);

                var modeNo = manager.forecourtControl.ForecourtConfiguration.GetFuelMode(fuellingType, authParams.PriceGroup);
                DebugLog(String.Format("ISFSManager.AuthoriseFuelPoint.configuration.GetFuelMode: fuellingType={0}, PriceGroup={1}, modeNo={2}",
                                                fuellingType, authParams.PriceGroup, modeNo));

                var pump = src as IPump;
                if (pump != null)
                {
                    if ((pump.State == PumpState.Idle || pump.State == PumpState.Calling) && fuellingType == FuellingType.Postpaid)
                    {
                        // Authorized in advance for self service. Change fuel mode to use the specific one
                        modeNo = manager.forecourtControl.ForecourtConfiguration.GetFuelMode(authParams.PriceGroup, true);
                        DebugLog(String.Format("ISFSManager.AuthoriseFuelPoint.configuration.GetFuelMode: fuellingType={0}, PriceGroup=Postpaid, modeNo={1}",
                                        fuellingType, modeNo));
                    }
                }

                authFP.FuelMode = new FuelModeElementClass() { ModeNo = modeNo.ToString() };

                ReleasedProductsClass products = new ReleasedProductsClass();

                AllowedFuelGrades fgs = (AllowedFuelGrades)(authParams.AllowedFuelGrade);
                FuelGradeMaxVolumes vols = (FuelGradeMaxVolumes)(authParams.FuelGradeMaxVolume);
                int count = 0;
                products.Product = new ProductElementClass[fgs.Count];
                for (int iFuelGrade = 0; iFuelGrade < fgs.Count; iFuelGrade++)
                {
                    if (fgs[iFuelGrade])
                    {
                        products.Product[count] = new ProductElementClass();
                        products.Product[count].ProductNo = Convert.ToString(iFuelGrade); //productNo = iFuelGrade(product index) + 1
                        if ((iFuelGrade < vols.Count) && vols[iFuelGrade].HasValue)
                            products.Product[count].MaxTrxVolume = FDCConvert.ToString((decimal)vols[iFuelGrade]);
                        count++;
                    }
                }
                authFP.ReleasedProducts = products;


                posDataElem.DeviceClass = authFP;
                ServiceRequestPOSdataAuthoriseFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                //Transaction ID is sent in response from the proxy delegate. 
                EventHandler<AsyncCompletedEventArgs> proxy = (sender, e) => requestCompleted(sender, new AsyncCompletedEventArgs<long>(e.Success, transactionId, e.UserToken));

                clientSocket.ifsfMessages.EnqueueMessage(sr, proxy, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("AuthoriseFuelPoint Exception! " + ex);
            }
        }

        private void AuthoriseFuelPointResp(int requestId, string sOverallResult, ServiceResponseAuthoriseFuelPoint sr)
        {
            try
            {
                DebugLog("AuthoriseFuelPointResp init");
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                if ((errorCode == ErrorCode.ERRCD_OK.ToString()) && (sOverallResult == OverallResult.Success.ToString()))
                {
                    // Ok so far, but wait for unsolicited FPStateChange before making decision about success.
                    DebugLog(string.Format("Waiting for unsolicited FPStateChange, RequestId={0}.", requestId));
                    unsolicitedFPStateChangeDictionary[Convert.ToInt16(sr.FDCdata[0].DeviceClass.DeviceID)] = requestId;
                }
                else
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, false);
                DebugLog("AuthoriseFuelPointResp end");
            }
            catch (Exception ex)
            {
                DebugLog("AuthoriseFuelPointResp Exception! " + ex);
            }
        }


        public void ChangeFuelMode(int pumpId, int mode, ushort? operationMode, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestChangeFuelMode sr = new ServiceRequestChangeFuelMode();
                if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                    sr.RequestType = "ChangeFuelMode";
                else
                    sr.RequestType = "ChangeFPFuelMode";
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataChangeFuelMode posDataElem = new ServiceRequestPOSdataChangeFuelMode();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassChangeFuelMode deviceClass = new ServiceRequestDeviceClassChangeFuelMode();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                deviceClass.FuelMode = new FuelModeElementClass();
                deviceClass.FuelMode.ModeNo = Convert.ToString(mode);
                if (operationMode.HasValue)
                {
                    deviceClass.FuelMode.OperationModeSpecified = true;
                    deviceClass.FuelMode.OperationMode = (ushort)operationMode;
                }

                ServiceRequestDeviceClassChangeFuelMode[] deviceClassArray = { deviceClass };

                posDataElem.DeviceClass = deviceClassArray;
                ServiceRequestPOSdataChangeFuelMode[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("ChangeFuelMode Exception! " + ex);
            }
        }

        public void ChangeFuelModeAdd(ServiceRequestChangeFuelMode sr, int pumpId, int mode, ushort? operationMode, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            // create XML ServiceRequest object
            sr.ApplicationSender = this.clientSocket.applicationSender;
            sr.WorkstationID = this.clientSocket.workstationID;
            DebugLog(string.Format("ChangeFuelModeAdd init: sr.ApplicationSender={0}, sr.WorkstationID={1}, pumpId={2}, mode={3}", sr.ApplicationSender, sr.WorkstationID, pumpId, mode));

            ServiceRequestPOSdataChangeFuelMode POSDataElem;
            if (sr.POSdata != null)
                POSDataElem = sr.POSdata[0];
            else
            {
                ServiceRequestPOSdataChangeFuelMode[] POSDataArray = null;
                DebugLog(string.Format("ChangeFuelModeAdd: new ServiceRequestPOSdataChangeFuelMode"));
                POSDataElem = new ServiceRequestPOSdataChangeFuelMode();
                ArrayResize(ref POSDataArray, 1);
                POSDataArray[POSDataArray.Length - 1] = POSDataElem;
                POSDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                sr.POSdata = POSDataArray;
            }

            ServiceRequestDeviceClassChangeFuelMode devicemode = null;
            if (POSDataElem.DeviceClass != null)
            {
                foreach (ServiceRequestDeviceClassChangeFuelMode devicemodeTemp in POSDataElem.DeviceClass)
                    if (devicemodeTemp.DeviceID == Convert.ToString(pumpId) && devicemodeTemp.ModeNo == Convert.ToString(mode))
                    {
                        devicemode = devicemodeTemp;
                        DebugLog(string.Format("ChangeFuelModeAdd: device/mode found"));
                    }
            }
            if (devicemode == null)
            {
                DebugLog(string.Format("ChangeFuelModeAdd: new mode"));
                devicemode = new ServiceRequestDeviceClassChangeFuelMode();
                devicemode.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                devicemode.Type = DeviceType.DT_FuellingPoint;
                devicemode.FuelMode = new FuelModeElementClass();
                devicemode.FuelMode.ModeNo = Convert.ToString(mode);
                if (operationMode.HasValue)
                {
                    devicemode.FuelMode.OperationModeSpecified = true;
                    devicemode.FuelMode.OperationMode = (ushort)operationMode;
                }

                ServiceRequestDeviceClassChangeFuelMode[] devicemodeArray = POSDataElem.DeviceClass;
                ArrayResize(ref devicemodeArray, (devicemodeArray != null) ? devicemodeArray.Length + 1 : 1);
                DebugLog(string.Format("ChangeFuelModeAdd: resize devidemodeArray to '{0}' items", devicemodeArray.Length));
                devicemodeArray[devicemodeArray.Length - 1] = devicemode;
                POSDataElem.DeviceClass = devicemodeArray;
            }
            DebugLog("ChangeFuelModeAdd end");

        }

        public void ChangeFuelModeSend(ServiceRequestChangeFuelMode sr, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            DebugLog(string.Format("ChangeFuelModeSend init: sr.ApplicationSender={0}, sr.WorkstationID={1}", sr.ApplicationSender, sr.WorkstationID));
            clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            DebugLog(string.Format("ChangeFuelModeSend end: sr.ApplicationSender={0}, sr.WorkstationID={1}", sr.ApplicationSender, sr.WorkstationID));

        }

        private void ChangeFuelModeResp(int requestId, string sOverallResult, ServiceResponseFDCdataChangeFuelMode[] fdcData)
        {
            try
            {
                DebugLog(string.Format("ChangeFuelModeResp init, sOverallResult={0}", sOverallResult));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                if (fdcData[0] != null && fdcData[0].DeviceClass != null)
                {
                    for (int i = 0; i < fdcData[0].DeviceClass.Length; i++)
                    {
                        if (fdcData[0].DeviceClass[i].ErrorCode != null && fdcData[0].DeviceClass[i].ErrorCode != ErrorCode.ERRCD_OK.ToString() && fdcData[0].DeviceClass[i].ErrorCode != ErrorCode.ERRCD_NO.ToString())
                        {
                            DebugLog(string.Format("ChangeFuelModeResp type={0}, id={1}, errorCode={2}", fdcData[0].DeviceClass[i].Type, fdcData[0].DeviceClass[i].DeviceID, fdcData[0].DeviceClass[i].ErrorCode));
                            string deviceType = fdcData[0].DeviceClass[i].Type;
                            int deviceId = Convert.ToInt16(fdcData[0].DeviceClass[i].DeviceID);
                            int alarmId = -1;
                            string alarmmsg = "Error " + fdcData[0].DeviceClass[i].ErrorCode + " changing fuel mode";
                            OnDeviceAlarm.Fire(this, new DeviceAlarmEventArgs(deviceType, deviceId, alarmId, alarmmsg));
                        }
                    }
                }
                DebugLog("ChangeFuelModeResp end");
            }
            catch (Exception ex)
            {
                DebugLog("ChangeFuelModeResp Exception! " + ex);
            }
        }


        public void ChangeFuelPrice(int productId, Decimal price, int mode, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestChangeFuelPrice sr = new ServiceRequestChangeFuelPrice();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;


                ServiceRequestPOSdataChangeFuelPrice posDataElem = new ServiceRequestPOSdataChangeFuelPrice();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestProductChangeFuelPrice[] products = new ServiceRequestProductChangeFuelPrice[1];
                ServiceRequestProductChangeFuelPrice product = new ServiceRequestProductChangeFuelPrice();
                product.ProductNo = (productId == -1) ? "*" : Convert.ToString(productId);

                ServiceRequestFuelModeChangeFuelPrice[] fuelModes = new ServiceRequestFuelModeChangeFuelPrice[1];
                ServiceRequestFuelModeChangeFuelPrice fuelMode = new ServiceRequestFuelModeChangeFuelPrice();
                fuelMode.PriceNew = FDCConvert.ToString(price);
                fuelMode.ModeNo = Convert.ToString(mode);
                fuelModes[0] = fuelMode;

                product.FuelMode = fuelModes;

                products[0] = product;

                posDataElem.Product = products;

                ServiceRequestPOSdataChangeFuelPrice[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("ChangeFuelPrice Exception! " + ex);
            }
        }

        public void ChangeFuelPriceAdd(ServiceRequestChangeFuelPrice sr, int productId, Decimal price, int mode)
        {
            // create XML ServiceRequest object
            sr.ApplicationSender = this.clientSocket.applicationSender;
            sr.WorkstationID = this.clientSocket.workstationID;
            DebugLog(string.Format("ChangeFuelPriceAdd init: sr.ApplicationSender={0}, sr.WorkstationID={1}, productId={2}, price={3}, mode={4}", sr.ApplicationSender, sr.WorkstationID, productId, price, mode));

            ServiceRequestPOSdataChangeFuelPrice POSDataElem;
            if (sr.POSdata != null)
                POSDataElem = sr.POSdata[0];
            else
            {
                ServiceRequestPOSdataChangeFuelPrice[] POSDataArray = null;
                DebugLog("ChangeFuelPriceAdd: new ServiceRequestPOSdataChangeFuelPrice");
                POSDataElem = new ServiceRequestPOSdataChangeFuelPrice();
                ArrayResize(ref POSDataArray, 1);
                POSDataArray[POSDataArray.Length - 1] = POSDataElem;
                POSDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                sr.POSdata = POSDataArray;
            }

            ServiceRequestProductChangeFuelPrice product = null;
            if (POSDataElem.Product != null)
            {
                foreach (ServiceRequestProductChangeFuelPrice productTemp in POSDataElem.Product)
                    if (productTemp.ProductNo == Convert.ToString(productId) && productTemp.ModeNo == Convert.ToString(mode))
                    {
                        product = productTemp;
                        DebugLog("ChangeFuelPriceAdd: product found");
                    }
            }
            if (product == null && productId > 0)
            {
                DebugLog("ChangeFuelPriceAdd: new product");
                product = new ServiceRequestProductChangeFuelPrice();
                product.ProductNo = (productId == -1) ? "*" : Convert.ToString(productId);

                ServiceRequestProductChangeFuelPrice[] productArray = POSDataElem.Product;
                ArrayResize(ref productArray, (productArray != null) ? productArray.Length + 1 : 1);
                DebugLog(string.Format("ChangeFuelPriceAdd: resize product to '{0}' items", productArray.Length));
                productArray[productArray.Length - 1] = product;
                POSDataElem.Product = productArray;
            }

            ServiceRequestFuelModeChangeFuelPrice fuelMode = null;
            if (product.FuelMode != null)
            {
                foreach (ServiceRequestFuelModeChangeFuelPrice fuelModeTemp in product.FuelMode)
                    if (product.ProductNo == Convert.ToString(productId) && fuelModeTemp.ModeNo == Convert.ToString(mode))
                    {
                        fuelMode = fuelModeTemp;
                        DebugLog("ChangeFuelPriceAdd: fuelMode found");
                    }
            }
            if (fuelMode == null && mode > 0)
            {
                fuelMode = new ServiceRequestFuelModeChangeFuelPrice();
                fuelMode.PriceNew = FDCConvert.ToString(price);
                fuelMode.ModeNo = Convert.ToString(mode);

                ServiceRequestFuelModeChangeFuelPrice[] fuelModeArray = product.FuelMode;
                ArrayResize(ref fuelModeArray, (fuelModeArray != null) ? fuelModeArray.Length + 1 : 1);
                DebugLog(string.Format("ChangeFuelPriceAdd: resize fuelMode to '{0}' items", fuelModeArray.Length));
                fuelModeArray[fuelModeArray.Length - 1] = fuelMode;
                product.FuelMode = fuelModeArray;
            }
            DebugLog(string.Format("ChangeFuelPriceAdd end: sr.ApplicationSender={0}, sr.WorkstationID={1}", sr.ApplicationSender, sr.WorkstationID));

        }

        public void ChangeFuelPriceSend(ServiceRequestChangeFuelPrice sr, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            DebugLog(string.Format("ChangeFuelPriceSend init: sr.ApplicationSender={0}, sr.WorkstationID={1}", sr.ApplicationSender, sr.WorkstationID));

            if (sr.POSdata == null)
            {
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;
                var posDataArray = new ServiceRequestPOSdataChangeFuelPrice[1];
                DebugLog("ChangeFuelPriceAdd: new ServiceRequestPOSdataChangeFuelPrice");
                var posDataElem = new ServiceRequestPOSdataChangeFuelPrice();
                posDataArray[0] = posDataElem;
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                sr.POSdata = posDataArray;
            }

            clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            DebugLog(string.Format("ChangeFuelPriceSend end: sr.ApplicationSender={0}, sr.WorkstationID={1}", sr.ApplicationSender, sr.WorkstationID));

        }

        public void CloseReconciliationPeriodAsyncSend(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                var sr = new ServiceRequestCloseReconciliationPeriod();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                var posDataElem = new ServiceRequestPOSdataCloseReconciliationPeriod();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestPOSdataCloseReconciliationPeriod[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("CloseReconciliationPeriodAsyncSend Exception! " + ex);
            }
        }


        private void ChangeFuelPriceResp(int requestId, string sOverallResult, ServiceResponseFDCdataChangeFuelPrice[] fdcData)
        {
            try
            {
                DebugLog("ChangeFuelPriceResp init");

                string errorCode = (fdcData[0].FDCStatus != null) ? fdcData[0].FDCStatus : fdcData[0].ErrorCode;
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());

                DebugLog("ChangeFuelPriceResp end");
            }
            catch (Exception ex)
            {
                DebugLog("ChangeFuelPriceResp Exception! " + ex);
            }
        }

        private void CloseReconciliationPeriodResp(int requestId, string sOverallResult, ServiceResponseFDCdataCloseReconciliationPeriod[] fdcData)
        {
            try
            {
                DebugLog("CloseReconciliationPeriodResp init");

                if (fdcData != null)
                {
                    string errorCode = fdcData[0].FDCStatus ?? fdcData[0].ErrorCode;
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                }
                else
                {
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, false);
                }
                DebugLog("CloseReconciliationPeriodResp end");
            }
            catch (Exception ex)
            {
                DebugLog("CloseReconciliationPeriodResp Exception! " + ex);
            }
        }


        public void LockFuelSaleTrx(int pumpId, int transactionNo, int releaseToken, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                ServiceRequestLockFuelSaleTrx sr = new ServiceRequestLockFuelSaleTrx();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataBaseFuelSaleTrx posDataElem = new ServiceRequestPOSdataBaseFuelSaleTrx();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassBaseFuelSaleTrx deviceClass = new ServiceRequestDeviceClassBaseFuelSaleTrx();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;
                deviceClass.TransactionSeqNo = Convert.ToString(transactionNo);

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataBaseFuelSaleTrx[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("LockFuelSaleTrx Exception! " + ex);
            }
        }

        private void LockFuelSaleTrxResp(int requestId, string sOverallResult, ServiceResponseLockFuelSaleTrx sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass.ErrorCode;
                DebugLog(string.Format("LockFuelSaleTrxResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));

                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("LockFuelSaleTrxResp end");
            }
            catch (Exception ex)
            {
                DebugLog("LockFuelSaleTrxResp Exception! " + ex);
            }
        }

        public void UnlockFuelSaleTrx(int pumpId, int transactionNo, int releaseToken, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                ServiceRequestUnlockFuelSaleTrx sr = new ServiceRequestUnlockFuelSaleTrx();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataBaseFuelSaleTrx posDataElem = new ServiceRequestPOSdataBaseFuelSaleTrx();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassBaseFuelSaleTrx deviceClass = new ServiceRequestDeviceClassBaseFuelSaleTrx();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                deviceClass.TransactionSeqNo = Convert.ToString(transactionNo);

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataBaseFuelSaleTrx[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("UnlockFuelSaleTrx Exception! " + ex);
            }
        }

        private void UnlockFuelSaleTrxResp(int requestId, string sOverallResult, ServiceResponseUnlockFuelSaleTrx sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                DebugLog(string.Format("UnlockFuelSaleTrxResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));

                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("UnlockFuelSaleTrxResp end");
            }
            catch (Exception ex)
            {
                DebugLog("UnlockFuelSaleTrxResp Exception! " + ex);
            }
        }

        public void ClearFuelSaleTrx(int pumpId, int transactionNo, int releaseToken, string note, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                ServiceRequestClearFuelSaleTrx sr = new ServiceRequestClearFuelSaleTrx();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataClearFuelSaleTrx posDataElem = new ServiceRequestPOSdataClearFuelSaleTrx();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassClearFuelSaleTrx deviceClass = new ServiceRequestDeviceClassClearFuelSaleTrx();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;
                deviceClass.TransactionSeqNo = Convert.ToString(transactionNo);
                // ignored by Fusion
                //deviceClass.FuelSaleNote = note;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataClearFuelSaleTrx[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("ClearFuelSaleTrx Exception! " + ex);
            }
        }

        private void ClearFuelSaleTrxResp(int requestId, string sOverallResult, ServiceResponseClearFuelSaleTrx sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                DebugLog(string.Format("ClearFuelSaleTrxResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("ClearFuelSaleTrxResp end");
            }
            catch (Exception ex)
            {
                DebugLog("ClearFuelSaleTrxResp Exception! " + ex);
            }
        }

        public void SendConfig(string commandFileName, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            clientSocket.SendConfig(commandFileName);
        }

        public void GetAvailableFuelSaleTrxs(int pumpId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetAvailableFuelSaleTrxs sr = new ServiceRequestGetAvailableFuelSaleTrxs();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetAvailableFuelSaleTrxs posDataElem = new ServiceRequestPOSdataGetAvailableFuelSaleTrxs();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetAvailableFuelSaleTrxs[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetAvailableFuelSaleTrxs Exception! " + ex);
            }
        }

        private void GetAvailableFuelSaleTrxsResp(int requestId, string sOverallResult, ServiceResponseGetAvailableFuelSaleTrxs sr)
        {
            try
            {
                DebugLog("GetAvailableFuelSaleTrxsResp init");
                if (sr.FDCdata == null || sr.FDCdata[0].DeviceClass == null)
                {
                    DebugLog("no fuel sale available - end");
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, true);
                    return;
                }
                if (OnGetAvailableFuelSaleTrx != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        if (sr.FDCdata[0].DeviceClass[i].ErrorCode != null && sr.FDCdata[0].DeviceClass[i].ErrorCode == ErrorCode.ERRCD_OK.ToString())
                        {
                            string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                            int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                            int transactionNo = Convert.ToInt32(sr.FDCdata[0].DeviceClass[i].TransactionSeqNo);
                            int releaseToken;

                            try
                            {
                                releaseToken = Int32.Parse(sr.FDCdata[0].DeviceClass[i].ReleaseToken, System.Globalization.NumberStyles.HexNumber);
                            }
                            catch (Exception ex)
                            {
                                releaseToken = 0;
                            }

                            OnGetAvailableFuelSaleTrx(this, new FuelSaleTrxEventArgs(transactionNo, 0, 0, 0, deviceType, deviceId, 0, 0, 0, 0, 0,
                                                      DateTime.Now, DateTime.Now, "", "", null, null, null, null, releaseToken, 0, FuellingType.Unknown));
                            int timeout = 0;
                            string sValue = IniFile.IniReadValue(ConfigurationParams.inifile, "FUSION-Connection", "GetFuelSaleTrxDetailTimeout");
                            if (sValue.Length > 0)
                                timeout = Convert.ToInt16(sValue);
                            DebugLog(string.Format("GetFuelSaleTrxDetailTimeout={0}", timeout));
                            Thread.Sleep(timeout);
                        }
                        else
                            DebugLog(string.Format("Id={0} - Error={1}", sr.FDCdata[0].DeviceClass[i].DeviceID, sr.FDCdata[0].DeviceClass[i].ErrorCode));
                    }
                }
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, true);
                DebugLog("GetAvailableFuelSaleTrxsResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetAvailableFuelSaleTrxsResp Exception! " + ex);
            }
        }

        public void GetFuelSaleTrxDetails(int pumpId, int transactionNo, int releaseToken, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            // create XML ServiceRequest object
            try
            {
                ServiceRequestGetFuelSaleTrxDetails sr = new ServiceRequestGetFuelSaleTrxDetails();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetFuelSaleTrxDetails posDataElem = new ServiceRequestPOSdataGetFuelSaleTrxDetails();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassGetFuelSaleTrxDetails deviceClass = new ServiceRequestDeviceClassGetFuelSaleTrxDetails();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                deviceClass.TransactionSeqNo = (transactionNo == -1) ? "*" : Convert.ToString(transactionNo);

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetFuelSaleTrxDetails[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetFuelSaleTrxDetails Exception! " + ex);
            }
        }

        private void GetFuelSaleTrxDetailsResp(int requestId, string sOverallResult, ServiceResponseGetFuelSaleTrxDetails sr)
        {
            try
            {
                DebugLog("GetFuelSaleTrxDetailsResp init");
                if (sr.FDCdata == null || sr.FDCdata[0].DeviceClass == null)
                {
                    DebugLog("no fuel sale details - end");
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, true);
                    return;
                }
                if ((OnGetFuelSaleTrxDetails != null || OnFuelSaleTrx != null) && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    var serializer = new XmlSerializer(typeof(FDCMessageFuelSaleTrx));

                    foreach (ServiceResponseDeviceClassGetFuelSaleTrxDetails deviceClass in sr.FDCdata[0].DeviceClass)
                    {
                        if (deviceClass.ErrorCode == ErrorCode.ERRCD_OK.ToString())
                        {
                            DebugLog(string.Format("type={0}, id={1}, nozzle={2}, price={3}, amount={4}, vol={5}, authAS={6}, lockAS={7}",
                                                deviceClass.Type, deviceClass.DeviceID,
                                                deviceClass.NozzleNo, deviceClass.UnitPrice, deviceClass.Amount, deviceClass.Volume,
                                                deviceClass.AuthorisationApplicationSender, deviceClass.LockingApplicationSender));

                            string deviceType = deviceClass.Type;
                            int deviceId = Convert.ToInt16(deviceClass.DeviceID);
                            int nozzleId = Convert.ToInt16(deviceClass.NozzleNo);
                            decimal volume = FDCConvert.ToDecimal(deviceClass.Volume);
                            decimal amount = FDCConvert.ToDecimal(deviceClass.Amount);
                            decimal price = FDCConvert.ToDecimal(deviceClass.UnitPrice);
                            int transactionSeqNum = Convert.ToInt32(deviceClass.TransactionSeqNo);
                            // if fuelling sequence number not available, use transaction sequence number
                            int fuellingSeqNum = string.IsNullOrEmpty(deviceClass.FuellingSequenceNo)
                                                     ? transactionSeqNum
                                                     : Convert.ToInt32(deviceClass.FuellingSequenceNo);
                            Wayne.FDCPOSLibrary.FuellingState transactionState = convertFuellingState(deviceClass.State);
                            int completionReason = 0;
                            int fuelMode = (deviceClass.FuelMode != null && deviceClass.FuelMode.ModeNo != null && deviceClass.FuelMode.ModeNo != "") ? Convert.ToInt32(deviceClass.FuelMode.ModeNo) : 0;
                            DateTime trxStartDateTime = Convert.ToDateTime(deviceClass.StartTimeStamp);
                            DateTime trxEndDateTime = Convert.ToDateTime(deviceClass.EndTimeStamp);
                            string authAS = deviceClass.AuthorisationApplicationSender;
                            string lockingAS = deviceClass.LockingApplicationSender;
                            string DSPFields = deviceClass.DSPFields;
                            string CRCMode = deviceClass.CRCMode;
                            string MIDLinesNarrow = deviceClass.MIDLinesNarrow;
                            string MIDLinesWide = deviceClass.MIDLinesWide;

                            FuellingType fuellingType = (deviceClass.FuellingType == "") ? FuellingType.Unknown : ((FuellingType)Convert.ToInt16(deviceClass.FuellingType));
                            if (fuellingType == FuellingType.Unknown)
                            {
                                DebugLog("Fuelling of unkown type received. Converting to DetectedFromAccumulators!!!");
                                fuellingType = FuellingType.DetectedFromAccumulators;
                            }

                            int releaseToken;
                            try
                            {
                                IReleaseToken token = AuthReleaseTokenFactory.GenerateToken(deviceClass.ReleaseToken);
                                releaseToken = token.AuthorizationId;
                            }
                            catch
                            {
                                releaseToken = 0;
                            }

                            byte reservingDeviceId;
                            try
                            {
                                reservingDeviceId = Convert.ToByte(deviceClass.ReservingDeviceId);
                            }
                            catch (Exception ex)
                            {
                                reservingDeviceId = 0;
                            }


                            FDCMessageFDCdataFuelSaleTrx fdcData = new FDCMessageFDCdataFuelSaleTrx()
                            {
                                FDCTimeStamp = sr.FDCdata[0].FDCTimeStamp,
                                DeviceClass = new FDCMessageDeviceClassFuelSaleTrx()
                                {
                                    Amount = deviceClass.Amount,
                                    AuthorisationApplicationSender = deviceClass.AuthorisationApplicationSender,
                                    BlendRatio = deviceClass.BlendRatio,
                                    CompletionReason = "0",
                                    CRCMode = deviceClass.CRCMode,
                                    DeviceID = deviceClass.DeviceID,
                                    DSPFields = deviceClass.DSPFields,
                                    EndTimeStamp = deviceClass.EndTimeStamp,
                                    ErrorCode = deviceClass.ErrorCode,
                                    FuelPeriodSequenceNo = deviceClass.FuelPeriodSequenceNo,
                                    FuelMode = deviceClass.FuelMode,
                                    FuellingSequenceNo = deviceClass.FuellingSequenceNo,
                                    FuellingType = deviceClass.FuellingType,
                                    LockingApplicationSender = deviceClass.LockingApplicationSender,
                                    MIDLinesNarrow = deviceClass.MIDLinesNarrow,
                                    MIDLinesWide = deviceClass.MIDLinesWide,
                                    MaxTrxAmount = deviceClass.MaxTrxAmount,
                                    NozzleNo = deviceClass.NozzleNo,
                                    PrepaidTrx = deviceClass.PrepaidTrx,
                                    ProductName = deviceClass.ProductName,
                                    ProductNo = deviceClass.ProductNo,
                                    ProductNo1 = deviceClass.ProductNo1,
                                    ProductNo2 = deviceClass.ProductNo2,
                                    ProductUM = deviceClass.ProductUM,
                                    PumpNo = deviceClass.PumpNo,
                                    ReleaseToken = deviceClass.ReleaseToken,
                                    ReservingDeviceId = deviceClass.ReservingDeviceId,
                                    StartTimeStamp = deviceClass.StartTimeStamp,
                                    State = deviceClass.State,
                                    TransactionSeqNo = deviceClass.TransactionSeqNo,
                                    Type = deviceClass.Type,
                                    UnitPrice = deviceClass.UnitPrice,
                                    Volume = deviceClass.Volume,
                                    VolumeProduct1 = deviceClass.VolumeProduct1,
                                    VolumeProduct2 = deviceClass.VolumeProduct2,
                                },
                            };


                            FDCMessageFuelSaleTrx fdcMessageFuelSaleTrx = new FDCMessageFuelSaleTrx()
                            {
                                MessageType = "FuelSaleTrx",
                                ApplicationSender = sr.ApplicationSender,
                                WorkstationID = sr.WorkstationID,
                                MessageID = sr.RequestID, //?
                                FDCdata = new FDCMessageFDCdataFuelSaleTrx[] { fdcData },
                            };

                            var builder = new StringBuilder();
                            using (var writer = new StringWriter(builder))
                            {
                                serializer.Serialize(writer, fdcMessageFuelSaleTrx);
                            }
                            string derivedXml = builder.ToString();

                            if (OnGetFuelSaleTrxDetails != null)
                            {
                                var eventPayload = new FuelSaleTrxEventArgs(
                                    transactionSeqNum,
                                    fuellingSeqNum,
                                    transactionState,
                                    completionReason,
                                    deviceType,
                                    deviceId,
                                    nozzleId,
                                    volume,
                                    amount,
                                    price,
                                    fuelMode,
                                    trxStartDateTime,
                                    trxEndDateTime,
                                    lockingAS,
                                    authAS,
                                    DSPFields,
                                    CRCMode,
                                    MIDLinesNarrow,
                                    MIDLinesWide,
                                    releaseToken,
                                    reservingDeviceId,
                                    fuellingType,
                                    derivedXml)
                                {
                                    FuelPeriodSequenceNo = Convert.ToInt32(deviceClass.FuelPeriodSequenceNo)
                                };
                                OnGetFuelSaleTrxDetails(this, eventPayload);
                            }
                            if (OnFuelSaleTrx != null)
                            {
                                var eventPayload = new FuelSaleTrxEventArgs(
                                    transactionSeqNum,
                                    fuellingSeqNum,
                                    transactionState,
                                    completionReason,
                                    deviceType,
                                    deviceId,
                                    nozzleId,
                                    volume,
                                    amount,
                                    price,
                                    fuelMode,
                                    trxStartDateTime,
                                    trxEndDateTime,
                                    lockingAS,
                                    authAS,
                                    DSPFields,
                                    CRCMode,
                                    MIDLinesNarrow,
                                    MIDLinesWide,
                                    releaseToken,
                                    reservingDeviceId,
                                    fuellingType,
                                    derivedXml)
                                {
                                    FuelPeriodSequenceNo = Convert.ToInt32(deviceClass.FuelPeriodSequenceNo)
                                };
                                OnFuelSaleTrx(this, eventPayload);
                            }
                        }
                        else
                            DebugLog("no fuel sale details anymore");
                    }


                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, true);
                }
                DebugLog("GetFuelSaleTrxDetailsResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetFuelSaleTrxDetailsResp Exception! " + ex);
            }
        }

        private void GetFuelSaleTrxDetailsResp(int requestId, string sOverallResult, ServiceResponseGetFuelSaleTrxDetailsV03 sr)
        {
            try
            {
                DebugLog("GetFuelSaleTrxDetailsRespV03 init");
                if (sr.FDCdata == null || sr.FDCdata[0].DeviceClass == null)
                {
                    DebugLog("no fuel sale details - end");
                    return;
                }
                if ((OnGetFuelSaleTrxDetails != null || OnFuelSaleTrx != null) && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        DebugLog(string.Format("type={0}, id={1}, nozzle={2}, amount={3}, vol={4}",
                                            sr.FDCdata[0].DeviceClass[i].Type, sr.FDCdata[0].DeviceClass[i].DeviceID,
                                            sr.FDCdata[0].DeviceClass[i].NozzleNo, sr.FDCdata[0].DeviceClass[i].Amount, sr.FDCdata[0].DeviceClass[i].Volume));

                        string deviceType = sr.FDCdata[0].DeviceClass[0].Type;
                        int transactionSeqNum = Convert.ToInt32(sr.FDCdata[0].DeviceClass[i].TransactionNo);
                        int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        Wayne.FDCPOSLibrary.FuellingState transactionState = convertFuellingState(sr.FDCdata[0].DeviceClass[i].State);
                        int completionReason = 0;
                        int nozzleId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].NozzleNo);
                        decimal volume = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].Volume);
                        decimal amount = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].Amount);
                        decimal price = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].UnitPrice);
                        int fuelMode = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].FuelMode);
                        DateTime trxStartDateTime = Convert.ToDateTime(sr.FDCdata[0].DeviceClass[i].StartTimeStamp);
                        DateTime trxEndDateTime = Convert.ToDateTime(sr.FDCdata[0].DeviceClass[i].EndTimeStamp);
                        string lockingAS = "";
                        string authAS = "";
                        string DSPFields = sr.FDCdata[0].DeviceClass[i].DSPFields;
                        string CRCMode = sr.FDCdata[0].DeviceClass[i].CRCMode;
                        string MIDLinesNarrow = "";
                        string MIDLinesWide = "";

                        int authId;
                        try
                        {
                            var token = AuthReleaseTokenFactory.GenerateToken(sr.FDCdata[0].DeviceClass[i].ReleaseToken);
                            authId = token.AuthorizationId;
                        }
                        catch
                        {
                            authId = 0;
                        }

                        if (OnGetFuelSaleTrxDetails != null)
                            OnGetFuelSaleTrxDetails(this, new FuelSaleTrxEventArgs(transactionSeqNum, 0, transactionState, completionReason, deviceType, deviceId, nozzleId, volume, amount, price, fuelMode, trxStartDateTime, trxEndDateTime, lockingAS, authAS, DSPFields, CRCMode, MIDLinesNarrow, MIDLinesWide, authId, 0, FuellingType.Unknown));
                        if (OnFuelSaleTrx != null)
                            OnFuelSaleTrx(this, new FuelSaleTrxEventArgs(transactionSeqNum, 0, transactionState, completionReason, deviceType, deviceId, nozzleId, volume, amount, price, fuelMode, trxStartDateTime, trxEndDateTime, lockingAS, authAS, DSPFields, CRCMode, MIDLinesNarrow, MIDLinesWide, authId, 0, FuellingType.Unknown));

                    }
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, true);
                }
                DebugLog("GetFuelSaleTrxDetailsResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetFuelSaleTrxDetailsResp Exception! " + ex);
            }
        }


        public void GetProductTable(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetProductTable sr = new ServiceRequestGetProductTable();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetProductTable posDataElem = new ServiceRequestPOSdataGetProductTable();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestPOSdataGetProductTable[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetProductTable Exception! " + ex);
            }
        }

        private void GetProductTableResp(int requestId, string sOverallResult, ServiceResponseGetProductTable sr)
        {
            try
            {
                DebugLog("GetProductTableResp init");

                if (sr == null || (sr.OverallResult != OverallResult.Success.ToString() && sr.OverallResult != "") ||
                    sr.FDCdata == null || sr.FDCdata.Length == 0 ||
                    sr.FDCdata[0].FuelProducts == null || sr.FDCdata[0].FuelProducts.Length == 0 ||
                    sr.FDCdata[0].FuelProducts[0].Product == null || sr.FDCdata[0].FuelProducts[0].Product.Length == 0)
                {
                    DebugLog("error in ServiceResponseGetProductTable");
                }

                //manage getConfigurationData
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, true, sr);
                DebugLog("GetProductTableResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetProductTableResp Exception! " + ex);
            }
        }


        public void GetModeTable(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetModeTable sr = new ServiceRequestGetModeTable();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetModeTable posDataElem = new ServiceRequestPOSdataGetModeTable();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestPOSdataGetModeTable[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetModeTable Exception! " + ex);
            }
        }

        private void GetModeTableResp(int requestId, string sOverallResult, ServiceResponseGetModeTable sr)
        {
            try
            {
                DebugLog("GetModeTableResp init");
                DebugLog("GetModeTableResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetModeTableResp Exception! " + ex);
            }
        }

        public void GetFuelMode(int pumpId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetFuelMode srV07 = new ServiceRequestGetFuelMode();
                ServiceRequestGetFPFuelMode sr = new ServiceRequestGetFPFuelMode();
                srV07.ApplicationSender = this.clientSocket.applicationSender;
                srV07.WorkstationID = this.clientSocket.workstationID;
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetFuelMode posDataElem = new ServiceRequestPOSdataGetFuelMode();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetFuelMode[] posDataArray = { posDataElem };

                srV07.POSdata = posDataArray;
                sr.POSdata = posDataArray;

                if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                    clientSocket.ifsfMessages.EnqueueMessage(srV07, requestCompleted, userToken, src, true, 30000);
                else
                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetFuelMode Exception! " + ex);
            }
        }

        private void GetFuelModeResp(int requestId, string sOverallResult, ServiceResponseFDCdataGetFuelMode[] fdcData)
        {
            try
            {
                DebugLog("GetFuelModeResp init");

                if (fdcData == null || fdcData[0].DeviceClass == null)
                {
                    DebugLog("no device available - end");
                    return;
                }
                // TO ADD
                if (OnFuelModeChange != null)
                {
                    string deviceType = fdcData[0].DeviceClass[0].Type;
                    int deviceId = Convert.ToInt16(fdcData[0].DeviceClass[0].DeviceID);
                    int mode = 0;
                    if (fdcData[0].DeviceClass[0].FuelMode.ModeNo != null)
                        mode = Convert.ToInt16(fdcData[0].DeviceClass[0].FuelMode.ModeNo);
                    else
                        mode = Convert.ToInt16(fdcData[0].DeviceClass[0].ModeNo);

                    DebugLog("Trigger FuelModeChanged");
                    OnFuelModeChange.Fire(this, new FuelModeChangedEventArgs(deviceType, deviceId, mode));
                }

                if (OnOperationModeChange != null)
                {
                    var deviceType = fdcData[0].DeviceClass[0].Type;
                    int deviceId = Convert.ToInt16(fdcData[0].DeviceClass[0].DeviceID);
                    if (fdcData[0].DeviceClass[0].FuelMode.OperationModeSpecified)
                    {
                        var mode = Convert.ToUInt16(fdcData[0].DeviceClass[0].FuelMode.OperationMode);

                        DebugLog("Trigger OperationModeChanged");
                        OnOperationModeChange.Fire(this, new OperationModeChangedEventArgs(deviceType, deviceId, mode));
                    }
                }

                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString());

                DebugLog("GetFuelModeResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetFuelModeResp Exception! " + ex);
            }
        }

        public void GetConfiguration(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetConfiguration sr = new ServiceRequestGetConfiguration();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetConfiguration posDataElem = new ServiceRequestPOSdataGetConfiguration();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestPOSdataGetConfiguration[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetConfiguration Exception! " + ex);
            }
        }
        private void GetConfigurationResp(int requestId, string sOverallResult, ServiceResponseGetConfiguration sr)
        {
            try
            {
                DebugLog("GetConfigurationResp init: INVALID FOR V7 !");
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == "Success", sr);

                DebugLog("GetConfigurationResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetConfigurationResp Exception! " + ex);
            }
        }

        public void GetDSPConfiguration(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetDSPConfiguration sr = new ServiceRequestGetDSPConfiguration();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetConfiguration posDataElem = new ServiceRequestPOSdataGetConfiguration();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestPOSdataGetConfiguration[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetDSPConfiguration Exception! " + ex);
            }
        }


        private void GetDSPConfigurationResp(int requestId, string sOverallResult, ServiceResponseGetDSPConfiguration sr)
        {
            try
            {
                DebugLog("GetDSPConfigurationResp init");


                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId,
                    sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString(), sr);

                DebugLog("GetDSPConfigurationResp end");

            }
            catch (Exception ex)
            {
                DebugLog("GetDSPConfigurationResp Exception! " + ex);
            }
        }



        public void GetTLGConfiguration(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetTLGConfiguration sr = new ServiceRequestGetTLGConfiguration();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetConfiguration posDataElem = new ServiceRequestPOSdataGetConfiguration();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestPOSdataGetConfiguration[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetTLGConfiguration Exception! " + ex);
            }
        }

        private void GetTLGConfigurationResp(int requestId, string sOverallResult, ServiceResponseGetTLGConfiguration sr)
        {
            try
            {
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString(), sr);
                DebugLog("GetTLGConfigurationResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetTLGConfigurationResp Exception! " + ex);
            }
        }

        private void SetConfigurationResp(int requestId, string sOverallResult, ServiceResponseSetConfiguration sr)
        {
            try
            {
                DebugLog("SetConfigurationResp init");

                DebugLog("SetConfigurationResp end");
            }
            catch (Exception ex)
            {
                DebugLog("SetConfigurationResp Exception! " + ex);
            }
        }

        public void LockNozzle(int deviceId, int nozzleNo, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestLockNozzle sr = new ServiceRequestLockNozzle();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataLockNozzle posDataElem = new ServiceRequestPOSdataLockNozzle();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassLockNozzle deviceClass = new ServiceRequestDeviceClassLockNozzle();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;
                deviceClass.NozzleNo = (nozzleNo == -1) ? "*" : Convert.ToString(nozzleNo);

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataLockNozzle[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("LockNozzle Exception! " + ex);
            }
        }

        private void LockNozzleResp(int requestId, string sOverallResult, ServiceResponseLockNozzle sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass.ErrorCode;
                DebugLog(string.Format("LockNozzleResp type={0}, id={1}, nozzleNo={2}, errorCode={3}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, sr.FDCdata[0].DeviceClass.NozzleNo, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                DebugLog(string.Format("LockNozzleResp end"));
            }
            catch (Exception ex)
            {
                DebugLog("LockNozzleResp Exception! " + ex);
            }
        }

        public void UnlockNozzle(int deviceId, int nozzleNo, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestUnlockNozzle sr = new ServiceRequestUnlockNozzle();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataUnlockNozzle posDataElem = new ServiceRequestPOSdataUnlockNozzle();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassUnlockNozzle deviceClass = new ServiceRequestDeviceClassUnlockNozzle();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                deviceClass.NozzleNo = (nozzleNo == -1) ? "*" : Convert.ToString(nozzleNo);

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataUnlockNozzle[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("UnlockNozzle Exception! " + ex);
            }
        }

        private void UnlockNozzleResp(int requestId, string sOverallResult, ServiceResponseUnlockNozzle sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                DebugLog(string.Format("UnlockNozzleResp type={0}, id={1}, nozzleNo={2}, errorCode{3}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, sr.FDCdata[0].DeviceClass.NozzleNo, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("UnlockNozzleResp end");
            }
            catch (Exception ex)
            {
                DebugLog("UnlockNozzleResp Exception! " + ex);
            }
        }

        public void GetCountrySettings(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetCountrySettings sr = new ServiceRequestGetCountrySettings();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetCountrySettings posDataElem = new ServiceRequestPOSdataGetCountrySettings();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                ServiceRequestPOSdataGetCountrySettings[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetCountrySettings Exception! " + ex);
            }
        }

        private void GetCountrySettingsResp(int requestId, string sOverallResult, ServiceResponseGetCountrySettings sr)
        {
            try
            {
                DebugLog("GetCountrySettingsResp init");
                if (sr.FDCdata[0].DecimalSign != null)
                    FDCConvert.DecimalSeparator = sr.FDCdata[0].DecimalSign;
                if (sr.FDCdata[0].ThousandDelimiter != null)
                    FDCConvert.ThousandSeparator = sr.FDCdata[0].ThousandDelimiter;

                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, true, sr);

                this.clientSocket.mainConnectionState = DeviceConnectionState.Connected;
                DebugLog(string.Format("GetCountrySettingsResp end: DecimalSeparator={0}, ThousandSeparator={1}, connectionState={2}", FDCConvert.DecimalSeparator, FDCConvert.ThousandSeparator, this.clientSocket.mainConnectionState));
            }
            catch (Exception ex)
            {
                DebugLog("GetCountrySettingsResp Exception! " + ex);
            }
        }

        public void GetDSPLimits(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetDSPLimits sr = new ServiceRequestGetDSPLimits();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetDSPLimits posDataElem = new ServiceRequestPOSdataGetDSPLimits();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetDSPLimits[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetDSPLimits Exception! " + ex);
            }
        }

        private void GetDSPLimitsResp(int requestId, string sOverallResult, ServiceResponseGetDSPLimits sr)
        {
            try
            {
                if (sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        DebugLog(string.Format("GetDSPLimitsResp type={0}, id={1}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[i].DeviceID));

                    }
                DebugLog("GetDSPLimitsResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetDSPLimitsResp Exception! " + ex);
            }
        }

        public void ChangeDSPLimits(int deviceId, int productNo, int modeNo, double maxTrxAmount, double maxTrxVolume, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestChangeDSPLimits sr = new ServiceRequestChangeDSPLimits();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataChangeDSPLimits posDataElem = new ServiceRequestPOSdataChangeDSPLimits();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassChangeDSPLimits deviceClass = new ServiceRequestDeviceClassChangeDSPLimits();
                deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
                deviceClass.ProductNo = Convert.ToString(productNo);
                deviceClass.ModeNo = Convert.ToString(modeNo);
                System.Globalization.NumberFormatInfo provider = new System.Globalization.NumberFormatInfo();
                provider.NumberDecimalSeparator = System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;
                provider.NumberGroupSeparator = System.Globalization.NumberFormatInfo.CurrentInfo.NumberGroupSeparator;
                provider.NumberGroupSizes = System.Globalization.NumberFormatInfo.CurrentInfo.NumberGroupSizes;
                deviceClass.MaxTrxAmount = string.Format(provider, "{0:F2}", maxTrxAmount);
                provider.NumberDecimalDigits = 3;
                deviceClass.MaxTrxVolume = string.Format(provider, "{0:F3}", maxTrxVolume);

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataChangeDSPLimits[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("ChangeDSPLimits Exception! " + ex);
            }
        }

        private void ChangeDSPLimitsResp(int requestId, string sOverallResult, ServiceResponseChangeDSPLimits sr)
        {
            try
            {
                DebugLog("ChangeDSPLimitsResp init");
                DebugLog("ChangeDSPLimitsResp end");
            }
            catch (Exception ex)
            {
                DebugLog("ChangeDSPLimitsResp Exception! " + ex);
            }
        }

        public void SuspendFuelling(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestSuspendFuelling sr = new ServiceRequestSuspendFuelling();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataSuspendFuelling posDataElem = new ServiceRequestPOSdataSuspendFuelling();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataSuspendFuelling[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("SuspendFuelling Exception! " + ex);
            }
        }

        private void SuspendFuellingResp(int requestId, string sOverallResult, ServiceResponseSuspendFuelling sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass[0].ErrorCode;
                DebugLog(string.Format("SuspendFuellingResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[0].DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("SuspendFuellingResp end");
            }
            catch (Exception ex)
            {
                DebugLog("SuspendFuellingResp Exception! " + ex);
            }
        }

        public void ResumeFuelling(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestResumeFuelling sr = new ServiceRequestResumeFuelling();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataResumeFuelling posDataElem = new ServiceRequestPOSdataResumeFuelling();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataResumeFuelling[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("ResumeFuelling Exception! " + ex);
            }
        }

        private void ResumeFuellingResp(int requestId, string sOverallResult, ServiceResponseResumeFuelling sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass[0].ErrorCode;
                DebugLog(string.Format("ResumeFuellingResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[0].DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("ResumeFuellingResp end");
            }
            catch (Exception ex)
            {
                DebugLog("ResumeFuellingResp Exception! " + ex);
            }
        }

        public void StopFuelPoint(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestStopFuelPoint sr = new ServiceRequestStopFuelPoint();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataStopFuelPoint posDataElem = new ServiceRequestPOSdataStopFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;
                deviceClass.CreateZeroSale = Convert.ToString(false);
                
                if (src is FUSIONPump)
                {
                    FUSIONPump p = (FUSIONPump)src;
                    if (p.State == PumpState.Fuelling)
                        deviceClass.CreateZeroSale = Convert.ToString(true);
                }

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataStopFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("StopFuelPoint Exception! " + ex);
            }
        }

        private void StopFuelPointResp(int requestId, string sOverallResult, ServiceResponseStopFuelPoint sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass[0].ErrorCode;
                DebugLog(string.Format("StopFuelPointResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[0].DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("StopFuelPointResp end");
            }
            catch (Exception ex)
            {
                DebugLog("StopFuelPointResp Exception! " + ex);
            }
        }

        public void StartFuelPoint(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestStartFuelPoint sr = new ServiceRequestStartFuelPoint();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataStartFuelPoint posDataElem = new ServiceRequestPOSdataStartFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataStartFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("StartFuelPoint Exception! " + ex);
            }
        }

        private void StartFuelPointResp(int requestId, string sOverallResult, ServiceResponseStartFuelPoint sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass[0].ErrorCode;
                DebugLog(string.Format("StartFuelPointResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[0].DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("StartFuelPointResp end");
            }
            catch (Exception ex)
            {
                DebugLog("StartFuelPointResp Exception! " + ex);
            }
        }

        public void LockTank(int deviceId, int tankNo, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestLockTank sr = new ServiceRequestLockTank();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataLockTank posDataElem = new ServiceRequestPOSdataLockTank();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassLockTank deviceClass = new ServiceRequestDeviceClassLockTank();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.TankNo = Convert.ToString(tankNo);
                deviceClass.Type = DeviceType.DT_TankProbe;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataLockTank[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("LockTank Exception! " + ex);
            }
        }

        private void LockTankResp(int requestId, string sOverallResult, ServiceResponseLockTank sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass[0].ErrorCode;
                DebugLog(string.Format("LockTankResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[0].DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("LockTankResp end");
            }
            catch (Exception ex)
            {
                DebugLog("LockTankResp Exception! " + ex);
            }
        }

        public void UnlockTank(int deviceId, int tankNo, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestUnlockTank sr = new ServiceRequestUnlockTank();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataUnlockTank posDataElem = new ServiceRequestPOSdataUnlockTank();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassUnlockTank deviceClass = new ServiceRequestDeviceClassUnlockTank();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.TankNo = Convert.ToString(tankNo);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_TankProbe;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataUnlockTank[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("UnlockTank Exception! " + ex);
            }
        }

        private void UnlockTankResp(int requestId, string sOverallResult, ServiceResponseUnlockTank sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass[0].ErrorCode;
                DebugLog(string.Format("UnlockTankResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[0].DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("UnlockTankResp end");
            }
            catch (Exception ex)
            {
                DebugLog("UnlockTankResp Exception! " + ex);
            }
        }

        public void GetTankData(int deviceId, int tankNo, EventHandler<AsyncCompletedEventArgs<ITankReadingEx>> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetTankData sr = new ServiceRequestGetTankData();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetTankData posDataElem = new ServiceRequestPOSdataGetTankData();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassGetTankData deviceClass = new ServiceRequestDeviceClassGetTankData();
                deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                // Not standard
                deviceClass.Type = DeviceType.DT_TankProbe;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetTankData[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                EventHandler<AsyncCompletedEventArgs> proxy = (sender, e) => requestCompleted(sender, (AsyncCompletedEventArgs<ITankReadingEx>)e);
                clientSocket.ifsfMessages.EnqueueMessage(sr, proxy, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetTankData Exception! " + ex);
            }
        }

        private void GetTankDataResp(int requestId, string sOverallResult, ServiceResponseGetTankData sr, string originalXml)
        {
            try
            {
                ServiceResponseDeviceClassGetTankData tankdata = sr.FDCdata[0].DeviceClass[0];
                DebugLog(string.Format("GetTankDataResp init: tank={0}, date={1}", tankdata.TankNo, sr.FDCdata[0].FDCTimeStamp));
                DateTime date;
                try
                {
                    date = Convert.ToDateTime(sr.FDCdata[0].FDCTimeStamp);
                }
                catch (Exception ex)
                {
                    DebugLog("GetTankDataResp: Exception! " + ex);
                    DebugLog("GetTankDataResp: set datetime to now");
                    date = DateTime.Now;
                }
                string errorCode = sr.FDCdata[0].FDCStatus ?? tankdata.ErrorCode;
                ProbeState probeState = (errorCode != ErrorCode.ERRCD_OK.ToString()) ||
                                        tankdata.DeviceState != null && convertLogicalDeviceState(tankdata.DeviceState) != LogicalDeviceState.FDC_READY ? ProbeState.Failed : ProbeState.Ok;
                FUSIONTankReading tankreading;
                if (probeState == ProbeState.Ok)
                {
                    tankreading = new FUSIONTankReading(Convert.ToInt32(tankdata.TankNo),
                                                        probeState,
                                                        date,
                                                        FDCConvert.ToDecimal(
                                                            tankdata.MeasurementData.ProductLevel) / 1000,
                                                        FDCConvert.ToDecimal(
                                                            tankdata.MeasurementData
                                                                    .TotalObservedVolume),
                                                        0,
                                                        FDCConvert.ToDecimal(
                                                            tankdata.MeasurementData.WaterLevel) / 1000,
                                                        FDCConvert.ToDecimal(
                                                            tankdata.MeasurementData.WaterVolume),
                                                        FDCConvert.ToDecimal(
                                                            tankdata.MeasurementData.AverageTemp),
                                                        UnitOfMeasure.Liters,
                                                        UnitOfMeasure.Liters,
                                                        false,
                                                        originalXml);
                    DebugLog(string.Format("GetTankDataResp data received: tank={0}, state={1}, fuelLevel={2}, fuelVolume={3}, waterLevel={4}, waterVolume={5}, temperature={6}",
                                          tankdata.TankNo, tankdata.MeasurementData.TPStatus,
                                          tankdata.MeasurementData.ProductLevel,
                                          tankdata.MeasurementData.TotalObservedVolume,
                                          tankdata.MeasurementData.WaterLevel,
                                          tankdata.MeasurementData.WaterVolume,
                                          tankdata.MeasurementData.AverageTemp));
                }
                else
                {
                    tankreading = new FUSIONTankReading(Convert.ToInt32(tankdata.TankNo),
                                                        probeState,
                                                        date,
                                                        0,
                                                        0,
                                                        0,
                                                        0,
                                                        0,
                                                        0,
                                                        UnitOfMeasure.Liters,
                                                        UnitOfMeasure.Liters,
                                                        false,
                                                        originalXml);
                    DebugLog(string.Format("GetTankDataResp data received: tank={0}, probestate={1}",
                                          tankdata.TankNo, probeState));
                }
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString(), (ITankReadingEx)tankreading);

                DebugLog("GetTankDataResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetTankDataResp Exception! " + ex);
            }
        }

        public void GetTankReconciliation(int deviceId, EventHandler<AsyncCompletedEventArgs<ITankReconciliation>> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetTankReconciliation sr = new ServiceRequestGetTankReconciliation();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetTankReconciliation posDataElem = new ServiceRequestPOSdataGetTankReconciliation();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassGetTankReconciliation deviceClass = new ServiceRequestDeviceClassGetTankReconciliation();
                deviceClass.DeviceID = deviceId.ToString();
                deviceClass.Type = DeviceType.DT_TankProbe;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetTankReconciliation[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                EventHandler<AsyncCompletedEventArgs> proxy = (sender, e) => requestCompleted(sender, (AsyncCompletedEventArgs<ITankReconciliation>)e);
                clientSocket.ifsfMessages.EnqueueMessage(sr, proxy, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetTankReconciliation Exception! " + ex);
            }
        }

        private void GetTankReconciliationResp(int requestId, string sOverallResult, ServiceResponseGetTankReconciliation sr, string originalXml)
        {
            try
            {
                DebugLog("GetTankReconciliation init");
                var tankReconciliation = new TankReconciliation(originalXml);

                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString(), (ITankReconciliation)tankReconciliation);

                DebugLog("GetTank ReconciliationResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetTankReconciliation Exception! " + ex);
            }
        }




        public void GetTankDelivery(int deviceId, EventHandler<AsyncCompletedEventArgs<ITankDelivery>> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetTankDelivery sr = new ServiceRequestGetTankDelivery();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetTankDelivery posDataElem = new ServiceRequestPOSdataGetTankDelivery();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassGetTankDelivery deviceClass = new ServiceRequestDeviceClassGetTankDelivery();
                deviceClass.DeviceID = deviceId.ToString();
                deviceClass.Type = DeviceType.DT_TankProbe;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetTankDelivery[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;
                EventHandler<AsyncCompletedEventArgs> proxy = (sender, e) => requestCompleted(sender, (AsyncCompletedEventArgs<ITankDelivery>)e);
                clientSocket.ifsfMessages.EnqueueMessage(sr, proxy, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetTankDelivery Exception! " + ex);
            }
        }




        private void GetTankDeliveryResp(int requestId, string sOverallResult, ServiceResponseGetTankDelivery sr, string originalXml)
        {
            try
            {
                DebugLog("GetTankDelivery init");
                var tankDelivery = new TankDelivery(originalXml);

                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString(), (ITankDelivery)tankDelivery);

                DebugLog("GetTankDeliveryResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetTankDelivery Exception! " + ex);
            }
        }

        public void GetPumpTotals(ServiceRequestDeviceClassGetFuelPointTotals deviceClass, EventHandler<AsyncCompletedEventArgs<PumpAccumulatorReading>> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                DebugLog("Request all pump totals from Fusion");
                var sr = new ServiceRequestGetFuelPointTotals();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                var posDataElem = new ServiceRequestPOSdataGetFuelPointTotals();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                posDataElem.DeviceClass = deviceClass;

                ServiceRequestPOSdataGetFuelPointTotals[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                EventHandler<AsyncCompletedEventArgs> completed = (sender, e) => requestCompleted(sender, (AsyncCompletedEventArgs<PumpAccumulatorReading>)e);

                clientSocket.ifsfMessages.EnqueueMessage(sr, completed, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetFuelPrices Exception! " + ex);
            }
        }

        public void GetFuelPrices(EventHandler<AsyncCompletedEventArgs<IList<IFuelPriceReading>>> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                DebugLog("Request all prices from Fusion");
                var sr = new ServiceRequestGetFuelPrices();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                var posDataElem = new ServiceRequestPOSdataGetFuelPrices();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                var product = new ServiceRequestProductGetFuelPrices();
                product.ProductNo = "*";

                var products = new ServiceRequestProductGetFuelPrices[] { product };

                posDataElem.Product = products;

                ServiceRequestPOSdataGetFuelPrices[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                EventHandler<AsyncCompletedEventArgs> completed = (sender, e) => requestCompleted(sender, (AsyncCompletedEventArgs<IList<IFuelPriceReading>>)e);

                clientSocket.ifsfMessages.EnqueueMessage(sr, completed, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("GetFuelPrices Exception! " + ex);
            }
        }

        private void GetFuelPricesResp(int requestId, string sOverallResult, ServiceResponseGetFuelPrices sr)
        {
            try
            {
                DebugLog("GetFuelPriceResp: init");

                var fuelPriceReadings = new List<IFuelPriceReading>();

                if (sr.FDCdata != null && sr.FDCdata[0].Prices != null && sr.FDCdata[0].Prices.Length > 0)
                {
                    DebugLog("GetFuelPriceResp: Prices received from Fusion");


                    foreach (var product in sr.FDCdata[0].Prices)
                    {

                        if (product.FuelPrice != null && product.FuelPrice.Length > 0)
                        {
                            foreach (var mode in product.FuelPrice)
                            {
                                int productNo = Convert.ToInt32(product.ProductNo);
                                decimal price = FDCConvert.ToDecimal(mode.Price);
                                string fuelName = product.ProductName;

                                var priceGroup = manager.forecourtControl.ForecourtConfiguration.GetPriceGroup(Convert.ToInt32(mode.ModeNo), FuellingType.OptCardPaid);


                                if (string.IsNullOrEmpty(fuelName))
                                    fuelName = string.Empty;

                                DebugLog(string.Format("GetFuelPricesResp: Grade={0}, PriceGroup={1} , Price={2} , FuelName={3}",
                                    productNo, priceGroup, price, fuelName));

                                fuelPriceReadings.Add(new FuelPriceReading(productNo, priceGroup, price, fuelName));
                            }
                        }
                    }

                }
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString(), (IList<IFuelPriceReading>)fuelPriceReadings);

                DebugLog("GetFuelPricesResp end");
            }
            catch (Exception ex)
            {
                DebugLog("GetFuelPricesResp Exception! " + ex);
            }
        }



        public void ReserveFuelPoint(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestReserveFuelPoint sr = new ServiceRequestReserveFuelPoint();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataReserveFuelPoint posDataElem = new ServiceRequestPOSdataReserveFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataReserveFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("ReserveFuelPoint Exception! " + ex);
            }
        }

        private void ReserveFuelPointResp(int requestId, string sOverallResult, ServiceResponseReserveFuelPoint sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass.ErrorCode;
                DebugLog(string.Format("ReserveFuelPointResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));
                if ((errorCode == ErrorCode.ERRCD_OK.ToString()) && (sOverallResult == OverallResult.Success.ToString()))
                {
                    // Ok so far, but wait for unsolicited FPStateChange before making decision about success.
                    DebugLog(string.Format("Waiting for unsolicited FPStateChange, RequestId={0}.", requestId));
                    unsolicitedFPStateChangeDictionary[Convert.ToInt16(sr.FDCdata[0].DeviceClass.DeviceID)] = requestId;
                }
                else
                {
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, false);
                    DebugLog("ReserveFuelPointResp end");
                }
            }
            catch (Exception ex)
            {
                DebugLog("ReserveFuelPointResp Exception! " + ex);
            }
        }

        public void FreeFuelPoint(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestFreeFuelPoint sr = new ServiceRequestFreeFuelPoint();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataFreeFuelPoint posDataElem = new ServiceRequestPOSdataFreeFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataFreeFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("FreeFuelPoint Exception! " + ex);
            }
        }

        public void StartFuelPointTest(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestStartFuelPointTest sr = new ServiceRequestStartFuelPointTest();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataStartFuelPointTest posDataElem = new ServiceRequestPOSdataStartFuelPointTest();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataStartFuelPointTest[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("StartFuelPointTest Exception! " + ex);
            }
        }

        public void EndFuelPointTest(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestEndFuelPointTest sr = new ServiceRequestEndFuelPointTest();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataEndFuelPointTest posDataElem = new ServiceRequestPOSdataEndFuelPointTest();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataEndFuelPointTest[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("EndFuelPointTest Exception! " + ex);
            }
        }

        public void OpenFuelPoint(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestOpenFuelPoint sr = new ServiceRequestOpenFuelPoint();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataOpenFuelPoint posDataElem = new ServiceRequestPOSdataOpenFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataOpenFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("OpenFuelPoint Exception! " + ex);
            }
        }

        public void OpenDevice(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestOpenDevice sr = new ServiceRequestOpenDevice();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataOpenFuelPoint posDataElem = new ServiceRequestPOSdataOpenFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataOpenFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("Exception! " + ex);
            }
        }

        public void CloseFuelPoint(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestCloseFuelPoint sr = new ServiceRequestCloseFuelPoint();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataCloseFuelPoint posDataElem = new ServiceRequestPOSdataCloseFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataCloseFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("CloseFuelPoint Exception! " + ex);
            }
        }

        public void CloseDevice(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestCloseDevice sr = new ServiceRequestCloseDevice();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataCloseFuelPoint posDataElem = new ServiceRequestPOSdataCloseFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataCloseFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("CloseDevice Exception! " + ex);
            }
        }

        public void SetDeviceAlarm(string deviceType, int deviceId, IEnumerable<int> alarmCodes, IEnumerable<string> alarmMsgs, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                var alarms = new List<ServiceRequestDeviceAlarmMsg>();
                if (alarmCodes != null && alarmMsgs != null)
                {
                    if (alarmCodes.Count() == alarmMsgs.Count())
                    {
                        for (int i = 0; i < alarmCodes.Count(); i++)
                        {
                            var alarmElem = new ServiceRequestDeviceAlarmMsg
                            {
                                Number = Convert.ToString(alarmCodes.ElementAt(i)),
                                Text = alarmMsgs.ElementAt(i)
                            };
                            alarms.Add(alarmElem);
                        }
                    }
                    else
                    {
                        foreach (var alarmCode in alarmCodes)
                        {
                            var alarmElem = new ServiceRequestDeviceAlarmMsg
                            {
                                Number = Convert.ToString(alarmCode),
                                Text = alarmMsgs.First()
                            };
                            alarms.Add(alarmElem);
                        }
                    }
                }
                var deviceClass = new ServiceRequestDeviceClassSetDeviceAlarm
                {
                    DeviceID = Convert.ToString(deviceId),
                    Type = deviceType,
                    AlarmMsg = alarms.ToArray()
                };

                var posDataElem = new ServiceRequestPOSdataSetDeviceAlarm
                {
                    POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat),
                    DeviceClass = deviceClass
                };
                // create XML ServiceRequest object
                var sr = new ServiceRequestSetDeviceAlarm
                {
                    ApplicationSender = this.clientSocket.applicationSender,
                    WorkstationID = this.clientSocket.workstationID,
                    POSdata = new[] { posDataElem }
                };


                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("SetDeviceAlarm Exception! " + ex);
            }
        }

        public void SetDeviceAlarm(string deviceType, int deviceId, int alarmCode, string alarmMsg, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            SetDeviceAlarm(deviceType, deviceId, new[] { alarmCode }, new[] { alarmMsg }, requestCompleted, userToken, src);
        }

        private void FreeFuelPointResp(int requestId, string sOverallResult, ServiceResponseFreeFuelPoint sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass.ErrorCode;
                DebugLog(string.Format("FreeFuelPointResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                DebugLog("FreeFuelPointResp Exception! " + ex);
            }
        }

        private void StartFuelPointTestResp(int requestId, string sOverallResult, ServiceResponseStartFuelPointTest sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass.ErrorCode;
                DebugLog(string.Format("StartFuelPointTestResp type={0}, id={1}, errorCode{2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("StartFuelPointTestResp end");
            }
            catch (Exception ex)
            {
                DebugLog("StartFuelPointTestResp Exception! " + ex);
            }
        }

        private void EndFuelPointTestResp(int requestId, string sOverallResult, ServiceResponseEndFuelPointTest sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass.ErrorCode;
                DebugLog(string.Format("EndFuelPointTestResp type={0}, id={1}, errorCode{2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("EndFuelPointTestResp end");
            }
            catch (Exception ex)
            {
                DebugLog("EndFuelPointTestResp Exception! " + ex);
            }
        }

        private void OpenFuelPointResp(int requestId, string sOverallResult, ServiceResponseOpenFuelPoint sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus;
                DebugLog(string.Format("OpenFuelPointResp requestId={0}, errorCode={1}", requestId, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("OpenFuelPointResp end");
            }
            catch (Exception ex)
            {
                DebugLog("OpenFuelPointResp Exception! " + ex);
            }
        }

        private void CloseFuelPointResp(int requestId, string sOverallResult, ServiceResponseCloseFuelPoint sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus;
                DebugLog(string.Format("CloseFuelPointResp requestId={0}, errorCode={1}", requestId, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("CloseFuelPointResp end");
            }
            catch (Exception ex)
            {
                DebugLog("CloseFuelPointResp Exception! " + ex);
            }
        }

        private void OpenDeviceResp(int requestId, string sOverallResult, ServiceResponseOpenDevice sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass[0].ErrorCode;
                DebugLog(string.Format("OpenDeviceResp requestId={0}, errorCode={1}", requestId, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("OpenDeviceResp end");
            }
            catch (Exception ex)
            {
                DebugLog("OpenDeviceResp Exception! " + ex);
            }
        }

        private void CloseDeviceResp(int requestId, string sOverallResult, ServiceResponseCloseDevice sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus ?? sr.FDCdata[0].DeviceClass[0].ErrorCode;
                DebugLog(string.Format("CloseDeviceResp requestId={0}, errorCode={1}", requestId, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("CloseDeviceResp end");
            }
            catch (Exception ex)
            {
                DebugLog("CloseDeviceResp Exception! " + ex);
            }
        }

        private void SetDeviceAlarmResp(int requestId, string sOverallResult, ServiceResponseSetDeviceAlarm sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus;
                DebugLog(string.Format("SetDeviceAlarmResp requestId={0}, errorCode={1}", requestId, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == OverallResult.Success.ToString());
                DebugLog("SetDeviceAlarmResp end");
            }
            catch (Exception ex)
            {
                DebugLog("SetDeviceAlarmResp Exception! " + ex);
            }
        }

        public void OptAddSerialPort(int optId, string port, int baudRate, int dataBit, int stopBit, int parity, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                DebugLog(string.Format("OptAddSerialPort init: tp={0}, port={1}", optId, port));
                // create XML ServiceRequest object
                ServiceRequestOPTAdd sr = new ServiceRequestOPTAdd();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataOPTAdd posDataElem = new ServiceRequestPOSdataOPTAdd();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassOPTAdd optadd = new ServiceRequestDeviceClassOPTAdd();
                optadd.DeviceID = (optId == -1) ? "*" : Convert.ToString(optId);
                optadd.Type = DeviceType.DT_OutdoorPaymentTerminal;

                ServiceRequestDeviceClassSerialPortOPTAdd serialPort = new ServiceRequestDeviceClassSerialPortOPTAdd();
                serialPort.Port = port;
                serialPort.BaudRate = Convert.ToString(baudRate);
                serialPort.DataBit = Convert.ToString(dataBit);
                serialPort.StopBit = Convert.ToString(stopBit);
                serialPort.Parity = Convert.ToString(parity);
                optadd.serialPort = serialPort;

                posDataElem.DeviceClass = optadd;
                ServiceRequestPOSdataOPTAdd[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
                DebugLog(string.Format("OptAddSerialPort end: tp={0}, port={1}", optId, port));
            }
            catch (Exception ex)
            {
                DebugLog("OptAddSerialPort Exception! " + ex);
            }
        }

        public void OptAddTCP(int optId, string address, int port, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestOPTAdd sr = new ServiceRequestOPTAdd();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataOPTAdd posDataElem = new ServiceRequestPOSdataOPTAdd();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassOPTAdd optadd = new ServiceRequestDeviceClassOPTAdd();
                optadd.DeviceID = (optId == -1) ? "*" : Convert.ToString(optId);
                optadd.Type = Wayne.FDCPOSLibrary.DeviceType.DT_OutdoorPaymentTerminal;

                ServiceRequestDeviceClassTCPOPTAdd tcp = new ServiceRequestDeviceClassTCPOPTAdd();
                tcp.Address = address;
                tcp.Port = Convert.ToString(port);
                optadd.tcp = tcp;

                posDataElem.DeviceClass = optadd;
                ServiceRequestPOSdataOPTAdd[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("OptAddTCP Exception! " + ex);
            }
        }

        private void OptAddResp(int requestId, string sOverallResult, ServiceResponseOPTAdd sr)
        {
            try
            {
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                DebugLog("OptAddResp Exception! " + ex);
            }
        }

        public void OptRemove(int optId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestOPTRemove sr = new ServiceRequestOPTRemove();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataOPTRemove posDataElem = new ServiceRequestPOSdataOPTRemove();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassOPTRemove optRemove = new ServiceRequestDeviceClassOPTRemove();
                optRemove.DeviceID = (optId == -1) ? "*" : Convert.ToString(optId);
                optRemove.Type = DeviceType.DT_OutdoorPaymentTerminal;

                posDataElem.DeviceClass = optRemove;
                ServiceRequestPOSdataOPTRemove[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, 30000);
            }
            catch (Exception ex)
            {
                DebugLog("OptRemove Exception! " + ex);
            }
        }

        private void OptRemoveResp(int requestId, string sOverallResult, ServiceResponseOPTRemove sr)
        {
            try
            {
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                DebugLog("OptRemoveResp Exception! " + ex);
            }
        }

        public void OptWrite(int optId, byte[] message, EventHandler<OptWriteCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                {
                    ServiceRequestOPTWriteV07 sr = new ServiceRequestOPTWriteV07();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataOPTWriteV07 posDataElem = new ServiceRequestPOSdataOPTWriteV07();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClassOPTWriteV07 optwrite = new ServiceRequestDeviceClassOPTWriteV07();
                    optwrite.DeviceID = (optId == -1) ? "*" : Convert.ToString(optId);
                    optwrite.Type = DeviceType.DT_OutdoorPaymentTerminal;
                    optwrite.Message = message;

                    posDataElem.DeviceClass = optwrite;
                    ServiceRequestPOSdataOPTWriteV07[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    EventHandler<AsyncCompletedEventArgs> proxy = (sender, e) => requestCompleted(sender, (OptWriteCompletedEventArgs)e);
                    clientSocket.ifsfMessages.EnqueueMessage(sr, proxy, userToken, src, true, 30000);
                }
                else
                {
                    ServiceRequestOPTWrite sr = new ServiceRequestOPTWrite();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataOPTWrite posDataElem = new ServiceRequestPOSdataOPTWrite();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClassOPTWrite optwrite = new ServiceRequestDeviceClassOPTWrite();
                    optwrite.DeviceID = (optId == -1) ? "*" : Convert.ToString(optId);
                    optwrite.Type = DeviceType.DT_OutdoorPaymentTerminal;
                    optwrite.Message = Encoding.UTF8.GetString(message, 0, message.GetLength(0)); ;

                    posDataElem.DeviceClass = optwrite;
                    ServiceRequestPOSdataOPTWrite[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    EventHandler<AsyncCompletedEventArgs> proxy = (sender, e) => requestCompleted(sender, (OptWriteCompletedEventArgs)e);
                    clientSocket.ifsfMessages.EnqueueMessage(sr, proxy, userToken, src, true, 30000);
                }

            }
            catch (Exception ex)
            {
                DebugLog("OptWrite Exception! " + ex);
            }
        }

        private void OptWriteResp(int requestId, string sOverallResult, ServiceResponseOPTWrite sr)
        {
            try
            {
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                DebugLog("OptWriteResp Exception! " + ex);
            }
        }

        private void HeartbeatMsg()
        {
            try
            {
                // when the heartbeat is received the disconnection timer is reset (the timer that is activated when the heartbeat is no more received)
                DebugLog("Heartbeat message received");
                heartbeat.ResetDisconnectionTimeout();
            }
            catch (Exception ex)
            {
                DebugLog("HeartbeatMsg Exception! " + ex);
            }
        }

        private void DeviceStateChangeMsg(FDCMessageDeviceStateChange msg)
        {
            try
            {
                DebugLog(string.Format("DeviceStateChangeMsg init: type={0}, id={1}, state={2}, substate={3}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID, msg.FDCdata[0].DeviceClass[0].LogicalState, msg.FDCdata[0].DeviceClass[0].LogicalSubState));
                if (OnDeviceStateChange != null)
                {
                    string deviceType = msg.FDCdata[0].DeviceClass[0].Type;
                    int deviceId = Convert.ToInt16(msg.FDCdata[0].DeviceClass[0].DeviceID);
                    LogicalDeviceState state = convertLogicalDeviceState(msg.FDCdata[0].DeviceClass[0].LogicalState);
                    LogicalDeviceState substate = convertLogicalDeviceState(msg.FDCdata[0].DeviceClass[0].LogicalSubState);
                    int nozzleUp = 0;
                    if (msg.FDCdata[0].DeviceClass[0].Nozzle != null)
                    {
                        foreach (NozzleStateClass nozzleState in msg.FDCdata[0].DeviceClass[0].Nozzle)
                        {
                            if (nozzleState.LogicalNozzle == "NozzleUp")
                                nozzleUp = Convert.ToInt32(nozzleState.NozzleNo);
                        }
                    }
                    OnDeviceStateChange.Invoke(this, new DeviceStateChangedEventArgs(deviceType, deviceId, state, substate, "", nozzleUp));
                }
                DebugLog("DeviceStateChangeMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("DeviceStateChangeMsg Exception! " + ex);
            }
        }

        private void FPStateChangeMsg(FDCMessageFPStateChange msg)
        {
            try
            {
                DebugLog(string.Format("FPStateChangeMsg: type={0}, id={1}, state={2}, substate={3}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID, msg.FDCdata[0].DeviceClass[0].DeviceState, msg.FDCdata[0].DeviceClass[0].DeviceSubState));

                int deviceId = Convert.ToInt16(msg.FDCdata[0].DeviceClass[0].DeviceID);
                int requestId;
                if (unsolicitedFPStateChangeDictionary.TryGetValue(deviceId, out requestId)) // Waiting for unsolicited FPStateChange?
                {
                    string errorCode = msg.FDCdata[0].DeviceClass[0].ErrorCode;
                    DebugLog(string.Format("Got unsolicited FPStateChange mapped to RequestId={0}, ErrorCode={1}", requestId, errorCode));
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString());
                    unsolicitedFPStateChangeDictionary.Remove(deviceId);
                }

                if (OnDeviceStateChange != null)
                {
                    string deviceType = msg.FDCdata[0].DeviceClass[0].Type;
                    LogicalDeviceState state = convertLogicalDeviceState(msg.FDCdata[0].DeviceClass[0].DeviceState.DeviceState);
                    LogicalDeviceState substate = convertLogicalDeviceState(msg.FDCdata[0].DeviceClass[0].DeviceSubState);
                    if (!string.IsNullOrEmpty(msg.FDCdata[0].DeviceClass[0].DeviceState.Stopped) && XmlConvert.ToBoolean(msg.FDCdata[0].DeviceClass[0].DeviceState.Stopped))
                        substate = LogicalDeviceState.FDC_STOPPED;
                    string lockingAS = msg.FDCdata[0].DeviceClass[0].LockingApplicationSender;
                    int nozzleUp = 0;
                    if (msg.FDCdata[0].DeviceClass[0].Nozzle != null)
                    {
                        foreach (NozzleStateClass nozzleState in msg.FDCdata[0].DeviceClass[0].Nozzle)
                        {
                            if (nozzleState.LogicalNozzle == "NozzleUp")
                                nozzleUp = Convert.ToInt32(nozzleState.NozzleNo);
                        }
                    }
                    OnDeviceStateChange.Invoke(this, new DeviceStateChangedEventArgs(deviceType, deviceId, state, substate, lockingAS, nozzleUp));
                }
                DebugLog("FPStateChangeMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("FPStateChangeMsg Exception! " + ex);
            }
        }

        private void TPStateChangeMsg(FDCMessageTPStateChange msg)
        {
            try
            {
                DebugLog(string.Format("TPStateChangeMsg init: type={0}, id={1}, state={2}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID, msg.FDCdata[0].DeviceClass[0].DeviceState));
                if (OnDeviceStateChange != null)
                {
                    string deviceType = msg.FDCdata[0].DeviceClass[0].Type;
                    int deviceId = Convert.ToInt16(msg.FDCdata[0].DeviceClass[0].DeviceID);
                    LogicalDeviceState state = convertLogicalDeviceState(msg.FDCdata[0].DeviceClass[0].DeviceState.DeviceState);
                    OnDeviceStateChange.Invoke(this, new DeviceStateChangedEventArgs(deviceType, deviceId, state, LogicalDeviceState.FDC_UNDEFINED, "", 0));
                }
                DebugLog("TPStateChangeMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("TPStateChangeMsg Exception! " + ex);
            }
        }

        private void VIRStateChangeMsg(FDCMessageVIRStateChange msg)
        {
            try
            {
                DebugLog(string.Format("VIRStateChangeMsg init: type={0}, id={1}, state={2}, substate={3}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID, msg.FDCdata[0].DeviceClass[0].DeviceState, msg.FDCdata[0].DeviceClass[0].DeviceSubState));
                if (OnVirStateChange != null)
                {
                    int deviceId = Convert.ToInt16(msg.FDCdata[0].DeviceClass[0].DeviceID);
                    if (msg.FDCdata[0].DeviceClass[0].Vir != null)
                    {
                        foreach (VIRStateClass virState in msg.FDCdata[0].DeviceClass[0].Vir)
                        {
                            var state = convertLogicalDeviceState(virState.DeviceState);
                            DeviceConnectionState deviceState;
                            if (state == LogicalDeviceState.FDC_READY)
                                deviceState = DeviceConnectionState.Connected;
                            else if (state == LogicalDeviceState.FDC_OFFLINE)
                                deviceState = DeviceConnectionState.Disconnected;
                            else
                                deviceState = DeviceConnectionState.Unknown;
                            DebugLog(string.Format("VIRStateChangeMsg: type={0}, id={1}, virID={2}, virstate={3}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID, virState.VirID, virState.DeviceState));
                            OnVirStateChange(this, new VIRStateChangedEventArgs(deviceId, virState.VirID, deviceState));
                        }
                    }
                }
                else
                    DebugLog("OnVirStateChange == null");
                DebugLog("VIRStateChangeMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("VIRStateChangeMsg Exception! " + ex);
            }
        }

        private void FDCStoppedMsg(FDCMessageStopped msg)
        {
            try
            {
                DebugLog("FDCStoppedMsg init");
                this.clientSocket.mainConnectionState = DeviceConnectionState.Connecting;
                DebugLog("FDCStoppedMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("FDCStoppedMsg Exception! " + ex);
            }
        }

        private void FDCStartedMsg(FDCMessageStarted msg)
        {
            try
            {
                DebugLog("FDCStartedMsg init");
                DebugLog("FDCStartedMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("FDCStartedMsg Exception! " + ex);
            }
        }

        private void TwinMasterReadyMsg(FDCMessageTwinMasterIsOn msg)
        {
            try
            {
                DebugLog("TwinMasterReadyMsg init");
                if (OnTwinMasterReady != null)
                    OnTwinMasterReady(this, null);
                DebugLog("TwinMasterReadyMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("TwinMasterReadyMsg Exception! " + ex);
            }
        }

        private void CurrentFuellingStatusMsg(FDCMessageCurrentFuellingStatus msg)
        {
            try
            {
                DebugLog(string.Format("CurrentFuellingStatusMsg init: type={0}, id={1}, volume={2}, amount={3}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID, msg.FDCdata[0].DeviceClass[0].CurrentVolume, msg.FDCdata[0].DeviceClass[0].CurrentAmount));
                if (OnCurrentFuellingStatus != null)
                {
                    var deviceClass = msg.FDCdata[0].DeviceClass[0];
                    string deviceType = deviceClass.Type;
                    int deviceId = Convert.ToInt16(deviceClass.DeviceID);

                    int nozzleId;
                    nozzleId = Convert.ToInt16(deviceClass.CurrentNozzleNo);
                    if (nozzleId == 0)
                        nozzleId = Convert.ToInt16(deviceClass.NozzleNo);

                    Decimal volume;
                    volume = FDCConvert.ToDecimal(deviceClass.CurrentVolume);
                    if (volume == 0)
                        volume = FDCConvert.ToDecimal(deviceClass.Volume);

                    Decimal amount;
                    amount = FDCConvert.ToDecimal(deviceClass.CurrentAmount);
                    if (amount == 0)
                        amount = FDCConvert.ToDecimal(deviceClass.Amount);

                    Decimal price;
                    price = FDCConvert.ToDecimal(deviceClass.CurrentUnitPrice);
                    if (price == 0)
                        price = FDCConvert.ToDecimal(deviceClass.UnitPrice);

                    int releaseId;
                    int reservingDeviceId;
                    try
                    {
                        var token = AuthReleaseTokenFactory.GenerateToken(deviceClass.ReleaseToken);
                        releaseId = token.AuthorizationId;
                        reservingDeviceId = token.TerminalId;
                    }
                    catch
                    {
                        releaseId = 0;
                        reservingDeviceId = 0;
                    }

                    var eventArgs = new CurrentFuellingStatusEventArgs(deviceType, deviceId, nozzleId, volume, amount,
                                                                       price, "")
                        {
                            ReleaseId = releaseId,
                            ReservingDeviceId = reservingDeviceId,
                            TransactionId = Convert.ToInt32(deviceClass.TransactionSeqNo),
                            FuelPeriodSequenceNo = Convert.ToInt32(deviceClass.FuelPeriodSequenceNo)
                        };

                    OnCurrentFuellingStatus(this, eventArgs);
                }
                DebugLog("CurrentFuellingStatusMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("CurrentFuellingStatusMsg Exception! " + ex);
            }
        }

        private void DeviceAlarmMsg(FDCMessageDeviceAlarm msg)
        {
            try
            {
                DebugLog(string.Format("DeviceAlarmMsg init: type={0}, id={1}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID));
                foreach (FDCMessageDeviceAlarmDeviceClass device in msg.FDCdata[0].DeviceClass)
                {
                    var deviceType = device.Type;
                    int deviceId = Convert.ToInt16(device.DeviceID);
                    if (device.AlarmMsg != null && device.AlarmMsg.Length > 0)
                    {
                        foreach (FDCMessageDeviceAlarmMsg alarmmsg in device.AlarmMsg)
                        {
                            if (OnDeviceAlarm != null)
                            {
                                int alarmId = Convert.ToInt32(alarmmsg.Number);
                                OnDeviceAlarm(this, new DeviceAlarmEventArgs(deviceType, deviceId, alarmId, alarmmsg.Text));
                            }
                        }
                    }
                    else if (deviceType == "TP") // send empty message for Tank Probe
                    {
                        if (OnDeviceAlarm != null)
                        {
                            OnDeviceAlarm(this, new DeviceAlarmEventArgs(deviceType, deviceId, 0, ""));
                        }
                    }
                }
                DebugLog("DeviceAlarmMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("DeviceAlarmMsg Exception! " + ex);
            }
        }

        private void FuelSaleTrxMsg(FDCMessageFuelSaleTrx msg, string originalMessageXml)
        {
            try
            {
                DebugLog("FuelSaleTrxMsg init");

                if (msg != null && msg.FDCdata != null && msg.FDCdata[0] != null && msg.FDCdata[0].DeviceClass != null)
                {
                    FDCMessageDeviceClassFuelSaleTrx deviceClass = msg.FDCdata[0].DeviceClass;
                    if (OnFuelSaleTrx != null)
                    {
                        DebugLog(string.Format("FuelSaleTrxMsg type={0}, id={1}, nozzle={2}, price={3}, amount={4}, vol={5}, authAS={6}, lockAS={7}",
                                            deviceClass.Type, deviceClass.DeviceID,
                                            deviceClass.NozzleNo, deviceClass.UnitPrice, deviceClass.Amount, deviceClass.Volume,
                                            deviceClass.AuthorisationApplicationSender, deviceClass.LockingApplicationSender));

                        string deviceType = deviceClass.Type;
                        int deviceId = Convert.ToInt16(deviceClass.DeviceID);
                        int nozzleId = Convert.ToInt16(deviceClass.NozzleNo);
                        Decimal volume = FDCConvert.ToDecimal(deviceClass.Volume);
                        Decimal amount = FDCConvert.ToDecimal(deviceClass.Amount);
                        Decimal price = FDCConvert.ToDecimal(deviceClass.UnitPrice);
                        int transactionSeqNum = Convert.ToInt32(deviceClass.TransactionSeqNo);
                        // if fuelling sequence number not available, use transaction sequence number
                        int fuellingSeqNum = string.IsNullOrEmpty(deviceClass.FuellingSequenceNo)
                                                 ? transactionSeqNum
                                                 : Convert.ToInt32(deviceClass.FuellingSequenceNo);
                        Wayne.FDCPOSLibrary.FuellingState transactionState = convertFuellingState(deviceClass.State);
                        int completionReason = string.IsNullOrEmpty(deviceClass.CompletionReason) ? 0 : convertCompletionReason(deviceClass.CompletionReason);
                        int fuelMode = (deviceClass.FuelMode != null && deviceClass.FuelMode.ModeNo != null && deviceClass.FuelMode.ModeNo != "") ? Convert.ToInt32(deviceClass.FuelMode.ModeNo) : 0;
                        DateTime trxStartDateTime = Convert.ToDateTime(deviceClass.StartTimeStamp);
                        DateTime trxEndDateTime = Convert.ToDateTime(deviceClass.EndTimeStamp);
                        string authAS = deviceClass.AuthorisationApplicationSender;
                        string lockingAS = deviceClass.LockingApplicationSender;
                        string DSPFields = deviceClass.DSPFields;
                        string CRCMode = deviceClass.CRCMode;
                        string MIDLinesNarrow = deviceClass.MIDLinesNarrow;
                        string MIDLinesWide = deviceClass.MIDLinesWide;

                        FuellingType fuellingType = (deviceClass.FuellingType == "") ? FuellingType.Unknown : ((FuellingType)Convert.ToInt16(deviceClass.FuellingType));
                        if (fuellingType == FuellingType.Unknown)
                        {
                            DebugLog("Fuelling of unkown type received. Converting to DetectedFromAccumulators!!!");
                            fuellingType = FuellingType.DetectedFromAccumulators;
                        }

                        int releaseToken;
                        try
                        {
                            IReleaseToken token = AuthReleaseTokenFactory.GenerateToken(deviceClass.ReleaseToken);
                            releaseToken = token.AuthorizationId;
                        }
                        catch
                        {
                            releaseToken = 0;
                        }

                        byte reservingDeviceId;
                        try
                        {
                            reservingDeviceId = Convert.ToByte(deviceClass.ReservingDeviceId);
                        }
                        catch (Exception ex)
                        {
                            reservingDeviceId = 0;
                            DebugLog("FuelSaleTrxMsg Exception! cannot convert ReservingDeviceId to Int32");
                        }

                        var eventPayload = new FuelSaleTrxEventArgs(
                            transactionSeqNum,
                            fuellingSeqNum,
                            transactionState,
                            completionReason,
                            deviceType,
                            deviceId,
                            nozzleId,
                            volume,
                            amount,
                            price,
                            fuelMode,
                            trxStartDateTime,
                            trxEndDateTime,
                            lockingAS,
                            authAS,
                            DSPFields,
                            CRCMode,
                            MIDLinesNarrow,
                            MIDLinesWide,
                            releaseToken,
                            reservingDeviceId,
                            fuellingType,
                            originalMessageXml)
                            {
                                FuelPeriodSequenceNo = Convert.ToInt32(deviceClass.FuelPeriodSequenceNo)
                            };
                        OnFuelSaleTrx(this, eventPayload);
                    }
                    else
                        DebugLog("FuelSaleTrxMsg OnFuelSaleTrx == null");
                }
                else
                {
                    if (msg == null)
                        DebugLog("FuelSaleTrxMsg msg == null");
                    else if (msg.FDCdata == null)
                        DebugLog("FuelSaleTrxMsg msg.FDCdata == null");
                    else if (msg.FDCdata[0] == null)
                        DebugLog("FuelSaleTrxMsg msg.FDCdata[0] == null");
                    else if (msg.FDCdata[0].DeviceClass == null)
                        DebugLog("FuelSaleTrxMsg msg.FDCdata[0].DeviceClass == null");
                }


                DebugLog("FuelSaleTrxMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("FuelSaleTrxMsg Exception! " + ex);
            }
        }

        private void FuelPriceChangeMsg(FDCMessageFuelPriceChange msg)
        {
            try
            {
                DebugLog(string.Format("FuelPriceChangeMsg init: product={0}, modeno={1}, newprice={2}, oldprice={3}",
                    msg.FDCdata[0].Product[0].ProductNo,
                    msg.FDCdata[0].Product[0].FuelMode.ModeNo,
                    msg.FDCdata[0].Product[0].FuelMode.NewPrice,
                    msg.FDCdata[0].Product[0].FuelMode.OldPrice));
                if (OnChangeFuelPrice != null)
                {
                    OnChangeFuelPrice(this, new ChangeFuelPriceEventArgs(Convert.ToInt32(msg.FDCdata[0].Product[0].ProductNo), Convert.ToInt32(msg.FDCdata[0].Product[0].FuelMode.ModeNo),
                        FDCConvert.ToDecimal(msg.FDCdata[0].Product[0].FuelMode.OldPrice), FDCConvert.ToDecimal(msg.FDCdata[0].Product[0].FuelMode.NewPrice)));
                }
                DebugLog("FuelPriceChangeMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("FuelPriceChangeMsg Exception! " + ex);
            }
        }

        private void FuelModeChangeMsg(FDCMessageFDCdataFuelModeChange fdcData)
        {
            try
            {
                DebugLog("FuelModeChangeMsg init");
                foreach (FDCMessageDeviceClassFuelModeChange device in fdcData.DeviceClass)
                {
                    if (OnFuelModeChange != null)
                    {
                        string deviceType = fdcData.DeviceClass[0].Type;
                        int deviceId = Convert.ToInt16(fdcData.DeviceClass[0].DeviceID);
                        int mode;
                        if (fdcData.DeviceClass[0].FuelMode.ModeNo != null)
                            mode = Convert.ToInt16(fdcData.DeviceClass[0].FuelMode.ModeNo);
                        else
                            mode = Convert.ToInt16(fdcData.DeviceClass[0].ModeNo);
                        OnFuelModeChange(this, new FuelModeChangedEventArgs(deviceType, deviceId, mode));
                    }

                    if (OnOperationModeChange != null)
                    {
                        //TODO Why is only first item in array used?
                        if (fdcData.DeviceClass[0].FuelMode != null && fdcData.DeviceClass[0].FuelMode.OperationModeSpecified)//TODO Is enough?
                        {
                            OnOperationModeChange.Fire(this,
                                new OperationModeChangedEventArgs(fdcData.DeviceClass[0].Type,
                                    Convert.ToInt16(fdcData.DeviceClass[0].DeviceID), fdcData.DeviceClass[0].FuelMode.OperationMode));
                        }
                    }
                }
                DebugLog("FuelModeChangeMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("FuelModeChangeMsg Exception! " + ex);
            }
        }

        private void FDCExceptionMsg(FDCMessageFDCExceptionMsg msg)
        {
            try
            {
                DebugLog("FDCExceptionMsg init");
                DebugLog("FDCExceptionMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("FDCExceptionMsg Exception! " + ex);
            }
        }

        private void FDCMessageConfigurationChangeMsg(FDCMessageConfigurationChange msg)
        {
            try
            {
                DebugLog("FDCMessageConfigurationChangeMsg init");
                OnConfigurationChange.Invoke(this, null);
                DebugLog("FDCMessageConfigurationChangeMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("FDCMessageConfigurationChangeMsg Exception! " + ex);
            }
        }

        private void OptReadMsg(FDCMessageOPTRead msg)
        {
            try
            {
                DebugLog("OptReadMsg init");
                foreach (FDCMessageDeviceClassOPTRead optdata in msg.FDCdata[0].DeviceClass)
                {
                    if (OnOptRead != null)
                    {
                        string deviceType = optdata.Type;
                        byte[] databytes = ASCIIEncoding.ASCII.GetBytes(optdata.Message); ;
                        DebugLog(string.Format("type={0}, id={1}, msg={2}", optdata.Type, optdata.DeviceID, optdata.Message));
                        int deviceId = Convert.ToInt16(optdata.DeviceID);
                        OnOptRead(this, new OptReadEventArgs(deviceType, deviceId, databytes));
                    }
                }
                DebugLog("OptReadMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("OptReadMsg Exception! " + ex);
            }
        }

        private void OptReadMsg(FDCMessageOPTReadV07 msg)
        {
            try
            {
                DebugLog("OptReadMsg init");
                foreach (FDCMessageDeviceClassOPTReadV07 optdata in msg.FDCdata[0].DeviceClass)
                {
                    if (OnOptRead != null)
                    {
                        string deviceType = optdata.Type;
                        ASCIIEncoding encoding = new ASCIIEncoding();
                        DebugLog(string.Format("type={0}, id={1}, msg={2}", optdata.Type, optdata.DeviceID, encoding.GetString(optdata.Message, 0, optdata.Message.Length)));
                        int deviceId = Convert.ToInt16(optdata.DeviceID);
                        byte[] message = optdata.Message;
                        OnOptRead(this, new OptReadEventArgs(deviceType, deviceId, message));
                    }
                }
                DebugLog("OptReadMsg end");
            }
            catch (Exception ex)
            {
                DebugLog("OptReadMsg Exception! " + ex);
            }
        }

        protected override void DoDispose()
        {
            _heartbeat.Dispose();
        }
    }
}