FCC/Applications/FdcServer/FDCPOSInterfaceServer/Messages.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;

using System.Threading;

using System.Xml;
using System.Xml.Serialization;
using System.IO;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.InteropServices;

using System.Net;
using System.Net.Sockets;
using Wayne.FDCPOSLibrary;
using Wayne.FDCPOSLibrary.Configuration;
using System.Globalization;
using System.Linq;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.DependencyInjection;
using Edge.Core.IndustryStandardInterface.ATG;

namespace Wayne.FDCPOSInterface
{
    public class Heartbeat : IDisposable
    {
        private System.Threading.Timer heartbeatTimer = null;
        private System.Threading.Timer disconnectionTimer = null;
        public event EventHandler OnClientHeartbeatTimeout;
        public event EventHandler OnHeartbeatInterval;
        public readonly long ClientHeartbeatTimeout = 30000;
        public readonly long heartbeatInterval = 10000;

        public bool tryingConnect = false;

        public Heartbeat()
        {
            //heartbeatInterval = _heartbeatInterval;
            //heartbeatTimeout = _heartbeatTimeout;

            //string sHeartbeatTimeout = IniFile.IniReadValue(SINPConfigurazione.IniPath + "ForecourtServer.ini", "FUSION-Connection", "HeartbeatTimeout");
            //if (sHeartbeatTimeout.Length > 0)
            //{
            //    try
            //    {
            //        heartbeatTimeout = Convert.ToInt32(sHeartbeatTimeout);
            //    }
            //    catch (Exception ex)
            //    {
            //    }
            //}
            //string sHeartbeatInterval = IniFile.IniReadValue(SINPConfigurazione.IniPath + "ForecourtServer.ini", "FUSION-Connection", "HeartbeatInterval");
            //if (sHeartbeatInterval.Length > 0)
            //{
            //    try
            //    {
            //        heartbeatInterval = Convert.ToInt32(sHeartbeatInterval);
            //    }
            //    catch (Exception ex)
            //    {
            //    }
            //}

            ////FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(1), string.Format("A heartbeat instance was created with heartbeatTimeout: {0}, heartbeatInterval: {1}", heartbeatTimeout, heartbeatInterval));
        }

        ~Heartbeat()
        {
            if (disconnectionTimer != null)
                disconnectionTimer.Dispose();
            disconnectionTimer = null;
            if (heartbeatTimer != null)
                heartbeatTimer.Dispose();
            heartbeatTimer = null;
        }

        ////Implement dispose to free resources
        public void Dispose()
        {
            if (disconnectionTimer != null)
                disconnectionTimer.Dispose();
            disconnectionTimer = null;
            if (heartbeatTimer != null)
                heartbeatTimer.Dispose();
            heartbeatTimer = null;
        }


        private void HeartbeatTimeout(Object state)
        {
            ////FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(1), "Heartbeat Timeout, fire the event");
            OnClientHeartbeatTimeout.Invoke(this, null);
        }

        private void HeartbeatInterval(Object state)
        {
            OnHeartbeatInterval.Invoke(this, null);
        }

        public void ResetClientDisconnectionTimer()
        {
            StopClientDisconnectionTimer();
            StartClientDisconnectionTimer();
        }

        public void StopClientDisconnectionTimer()
        {
            if (ClientHeartbeatTimeout > 0)
            {
                ////FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4), string.Format("dispose Disconnection timer"));
                if (disconnectionTimer != null)
                    disconnectionTimer.Dispose();
                disconnectionTimer = null;
            }
        }

        public void StartClientDisconnectionTimer()
        {
            if (ClientHeartbeatTimeout > 0)
            {
                ////FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4), string.Format("new Disconnection timer"));
                disconnectionTimer = new System.Threading.Timer(new System.Threading.TimerCallback(HeartbeatTimeout), this, ClientHeartbeatTimeout, System.Threading.Timeout.Infinite);
            }
        }

        public void RestartHeartbeatTimer()
        {
            // start sending heartbeat when receive logon and send 
            if (heartbeatTimer != null)
                heartbeatTimer.Dispose();
            heartbeatTimer = null;
            if (heartbeatInterval > 0)
                heartbeatTimer = new System.Threading.Timer(new System.Threading.TimerCallback(HeartbeatInterval), this, heartbeatInterval, System.Threading.Timeout.Infinite);
        }

        public void NotifyDisconnection()
        {
            tryingConnect = true;
            //Restart();
        }
    }

    public class Messages
    {
        //protected static NLog.Logger fdcSocketLogger = NLog.LogManager.LoadConfiguration("nlog.config").GetLogger("FdcServerSocket");
        protected ILogger fdcSocketLogger;
        //= ServiceBuilder.Provider
        //.GetRequiredService<ILoggerFactory>().CreateLogger("FdcServerSocket");
        private MD5Crypter crypter = new MD5Crypter();
        public static bool bWholeConfiguration = true;
        protected FDCPOSManager fdcPosManager;
        protected Dictionary<string, ServiceResponse> serviceResponseClientList;

        public delegate void HeartbeatCallback(string workstationID, string applicationSender);
        bool traceXML = false;
        public Messages(FDCPOSManager _fdcposManager, ILogger logger)
        {
            this.fdcSocketLogger = logger;
            this.fdcPosManager = _fdcposManager;
            serviceResponseClientList = new Dictionary<string, ServiceResponse>();
        }

        private object sync_sendObj = new object();
        public void SendFDCMessage<T>(FDCPOSClient fdcPosClient, T msg)
        {
            string xmlBodyString = null;
            try
            {
                if (fdcPosClient == null)
                {
                    fdcSocketLogger.LogInformation("SendFDCMessage, client is NULL!");
                    ////FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(1), string.Format("client is NULL!"));
                    return;
                }

                if (!fdcPosClient.connected || !fdcPosClient.logon)
                {
                    if (!fdcPosClient.connected)
                    {
                        fdcSocketLogger.LogInformation(string.Format("client '{0}' NOT connected, will not send msg to", fdcPosClient.sID));
                        ////FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(1), string.Format("client '{0}' NOT connected", fdcposClient.sID));
                    }
                    else if (!fdcPosClient.logon)
                    {
                        fdcSocketLogger.LogInformation(string.Format("client '{0}' NOT logon, will not send msg to", fdcPosClient.sID));
                        ////FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(1), string.Format("client '{0}' NOT logon", fdcposClient.sID));
                    }

                    return;
                }

                FDCPOSManager.messageIdCounter++;

                var result = FdcServerTcpHandler.SerializeFdcMessageToNetworkBytes(msg, this.fdcPosManager.encryptedHeader);
                xmlBodyString = result.Item2;

                if (result.Item1.Length >= 19999999)
                    fdcSocketLogger.LogInformation("SendFDCMessage " + typeof(T).Name
                        + ", rawBytes Length: " + result.Item1.Length + " excceed normal value, will send anyway");


                if (fdcSocketLogger.IsEnabled(LogLevel.Debug))
                    fdcSocketLogger.LogDebug("Will Send Fdc Msg(full message include header bytes count: " + result.Item1.Length + "): "
                        + msg.GetType().Name + ", content:\r\n"
                        + result.Item2
                        + "\r\n to client(wId: " + (fdcPosClient.workstationID ?? "")
                        + ", appSender: " + (fdcPosClient.applicationSender ?? "") + ")");
                fdcPosClient.socketChannelUnsolicited.Client.Send(result.Item1);
                if (fdcSocketLogger.IsEnabled(LogLevel.Debug))
                    fdcSocketLogger.LogDebug("  done send Fdc Msg: " + msg.GetType().Name + "");
            }
            catch (Exception ex)
            {
                fdcSocketLogger.LogError("SendFDCMessage to client(wId: " + (fdcPosClient.workstationID ?? "")
                    + ", appSender: " + (fdcPosClient.applicationSender ?? "")
                    + ", " + ((IPEndPoint)fdcPosClient.socketChannelUnsolicited.Client.RemoteEndPoint).ToString()
                    + ") exceptioned, " +
                    "\r\n FdcMessage: " + typeof(T).Name + ":" +
                    "\r\n" + (xmlBodyString ?? "") +
                    "\r\n exception detail: " + ex
                    + System.Environment.NewLine + "Will disconnect this client and remove it from TcpClientList");
                fdcPosClient.Dispose();
                this.fdcPosManager.DisconnectClient(fdcPosClient);
            }
        }
    }

    public class ConfigurationMessages : Messages
    {
        public ConfigurationMessages(FDCPOSManager _fdcposManager, ILogger logger)
            : base(_fdcposManager, logger)
        {

        }

        //public void Start(int iIPPortConfig, bool encryptedHeader, string forecourtConfiguration, int version, bool useExtensions, string certificate)
        //{
        //    if (((FDCPOSConfigurationManager)this.fdcposManager).respChannelConfigThreadObj != null && ((FDCPOSConfigurationManager)this.fdcposManager).respChannelConfigThreadObj.tcpListenerRunning)
        //        return;

        //    if (((FDCPOSConfigurationManager)fdcposManager) != null)
        //    {
        //        ((FDCPOSConfigurationManager)fdcposManager).encryptedHeader = encryptedHeader;
        //        ((FDCPOSConfigurationManager)fdcposManager).forecourtConfiguration = forecourtConfiguration;
        //        FDCGlobal.ProtocolVersion = (FDCVersion)version;
        //        ((FDCPOSConfigurationManager)fdcposManager).useExtensions = useExtensions;
        //        ((FDCPOSConfigurationManager)fdcposManager).certificate = certificate.ToUpper();
        //    }
        //    // run configuration reader listener if different from FDCPOS listener
        //    ((FDCPOSConfigurationManager)fdcposManager).respChannelConfigThreadObj = new TCPListenerConfigThread(((FDCPOSConfigurationManager)fdcposManager), ((FDCPOSConfigurationManager)fdcposManager).configurationInterface, ((FDCPOSConfigurationManager)fdcposManager).socketChannelConfig, iIPPortConfig);
        //    if (iIPPortConfig > 0 && iIPPortConfig != FDCPOSInterfaceServerManager.fdcposManager.respChannelAThreadObj.IPPort)
        //    {
        //        Thread respChannelConfigThread = new Thread(new ThreadStart(((FDCPOSConfigurationManager)fdcposManager).respChannelConfigThreadObj.TCPListenerThreadProc));
        //        respChannelConfigThread.Start();
        //    }
        //    //else
        //    //    ((FDCPOSConfigurationManager)fdcposManager).respChannelConfigThreadObj = FDCPOSInterfaceServerManager.fdcposManager.respChannelAThreadObj;
        //}

        #region ServiceResponses
        public void ConfigResponse(string requestType, string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine(string.Format("init: workstationID={0}, applicationSender={1}, requestId={2}", workstationID, applicationSender, requestId));
            ServiceResponseConfig SvRes = new ServiceResponseConfig();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestType = requestType;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseConfigFDCdata FDCDataElem = new ServiceResponseConfigFDCdata();
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
            ServiceResponseConfigFDCdata[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            FDCPOSClient fdcposClient = null;
            if (fdcPosManager.fdcClientList.ContainsKey(FDCPOSClient.getClientID(workstationID, applicationSender)))
                fdcposClient = FDCPOSConfigurationManager.fdcposManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)];
            else
                fdcposClient = FDCPOSInterfaceServerManager.fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)];
            if (fdcposClient != null)
                ((FDCPOSConfigurationManager)fdcPosManager).respChannelConfigThreadObj.SendResponse<ServiceResponseConfig>(fdcposClient, SvRes);
            //else
            //    FDCPOSManager.tracer.WriteLine("Client Undefined ! impossible to send Response!");
            //FDCPOSManager.tracer.WriteLine("end");
        }
        #endregion
    }

    public class FdcPosMessages : Messages
    {
        private ILogger logger;
        private FdcServerTcpHandler fdcServerTcpHandler;
        public FdcPosMessages(FDCPOSManager _fdcposManager, ILogger logger)
            : base(_fdcposManager, logger)
        {
            this.logger = logger;
        }

        public bool Start(int iIPPortA, bool encryptedHeader, string forecourtConfiguration, int version, bool useExtensions, string certificate)
        {
            //if (((FDCPOSInterfaceServerManager)this.fdcposManager).respChannelAThreadObj != null && ((FDCPOSInterfaceServerManager)this.fdcposManager).respChannelAThreadObj.tcpListenerRunning)
            //    return;

            if (((FDCPOSInterfaceServerManager)fdcPosManager) != null)
            {
                ((FDCPOSInterfaceServerManager)fdcPosManager).encryptedHeader = encryptedHeader;
                ((FDCPOSInterfaceServerManager)fdcPosManager).forecourtConfiguration = forecourtConfiguration;
                FDCGlobal.ProtocolVersion = (FDCVersion)version;
                ((FDCPOSInterfaceServerManager)fdcPosManager).useExtensions = useExtensions;
                ((FDCPOSInterfaceServerManager)fdcPosManager).certificate = certificate.ToUpper();
            }

            // run request listener
            this.fdcServerTcpHandler =
                new FdcServerTcpHandler(fdcPosManager, iIPPortA, this.logger);
            fdcServerTcpHandler.FdcPosInterface = ((FDCPOSInterfaceServerManager)fdcPosManager).fdcPosInterface;
            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler = fdcServerTcpHandler;
            return fdcServerTcpHandler.StartListening();
        }

        public bool Stop()
        {
            this.fdcServerTcpHandler?.Dispose();
            return true;
        }

        public void RemovePendingMessages(string clientID)
        {
            IDictionaryEnumerator srIndex = null;
            bool found = false;
            do
            {
                found = false;
                srIndex = serviceResponseClientList.GetEnumerator();
                while (srIndex.MoveNext())
                {
                    string key = (string)(srIndex.Key);
                    if (key.Contains(clientID))
                    {
                        serviceResponseClientList.Remove(key);
                        //FDCPOSManager.tracer.WriteLine(string.Format("removed elem '{0}'", key));
                        found = true;
                        break;
                    }
                }
            } while (found);
        }

        #region FDCMessages
        public void Heartbeat(string workstationID, string applicationSender)
        {
            //FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(1), "init heartbeat for " + FDCPOSClient.getClientID(workstationID, applicationSender));
            int h = 0;
            if (h != 0)
                return;

            //Monitor.Enter(fdcposManager.tcpClientList);
            try
            {
                FDCMessageFDCHeartbeat heartbeatmsg = new FDCMessageFDCHeartbeat();
                heartbeatmsg.WorkstationID = workstationID;
                heartbeatmsg.ApplicationSender = applicationSender;
                heartbeatmsg.MessageID = FDCPOSManager.messageIdCounter.ToString();

                var clientId = FDCPOSClient.getClientID(workstationID, applicationSender);
                FDCPOSClient client = null;
                if (fdcPosManager.fdcClientList.TryGetValue(clientId, out client))
                {
                    lock (client)
                        SendFDCMessage<FDCMessageFDCHeartbeat>(client, heartbeatmsg);
                    client?.heartbeat?.RestartHeartbeatTimer();
                }
            }
            catch (Exception ex)
            {
                this.logger.LogError("Notify to clients with Heartbeat exceptioned: " + ex);
                //FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(1), "Exception for client id: " + FDCPOSClient.getClientID(workstationID, applicationSender) + ", " + ex.ToString());
            }
            finally
            {
                //Monitor.Exit(fdcposManager.tcpClientList);
            }
            //FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(1), "end heartbeat for " + FDCPOSClient.getClientID(workstationID, applicationSender));
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="deviceType"></param>
        /// <param name="deviceId"></param>
        /// <param name="deviceState"></param>
        /// <param name="deviceSubState"></param>
        /// <param name="errorId"></param>
        /// <param name="errorDescription"></param>
        /// <param name="lockingAS"></param>
        /// <param name="nozzleListNum">how many nozzles in this pump</param>
        /// <param name="nozzleListState">binary map, 0000 0101 indicates 1st and 3rd nozzle are NozzleUp, others are NozzleDown</param>
        /// <param name="nozzleListLogicalState">binary map, 0000 1001 indicates 1st and 4th nozzle are Locked, others are Unlocked</param>
        /// <param name="nozzleListTankState"></param>
        public void DeviceStateChange(string deviceType, int deviceId, LogicalDeviceState deviceState,
            LogicalDeviceState deviceSubState, string errorId, string errorDescription, string lockingAS,
            int nozzleListNum, int nozzleListState, int nozzleListLogicalState, int nozzleListTankState)
        {
            string workstationID = "", applicationSender = "";

            //FDCPOSManager.tracer.WriteLine(string.Format("init: deviceType={0}, deviceId={1}, logicalState={2}, logicalSubState={3}", deviceType, deviceId, deviceState.ToString(), deviceSubState.ToString()));
            var safeCopy = new List<string>(fdcPosManager.fdcClientList.Keys.Select(k => k.ToString()).ToList());
            foreach (string sID in safeCopy)
            {
                try
                {
                    //foreach (string sID in fdcposManager.tcpClientList.Keys)
                    //{
                    if (!fdcPosManager.fdcClientList[sID].connected || !fdcPosManager.fdcClientList[sID].logon)
                        continue;

                    workstationID = fdcPosManager.fdcClientList[sID].workstationID;
                    applicationSender = fdcPosManager.fdcClientList[sID].applicationSender;

                    FDCMessageDeviceStateChange devicesc = null;
                    FDCMessageFPStateChange fpsc = null;
                    FDCMessageTPStateChange tpsc = null;
                    FDCMessagePPStateChange ppsc = null;
                    if (FDCGlobal.ProtocolVersion < FDCVersion.V0007)
                    {
                        devicesc = new FDCMessageDeviceStateChange();
                        devicesc.WorkstationID = workstationID;
                        devicesc.ApplicationSender = applicationSender;
                        devicesc.MessageID = FDCPOSManager.messageIdCounter.ToString();
                    }
                    else
                    {
                        if (deviceType == FDCPOSLibrary.DeviceType.DT_FuellingPoint || deviceType == FDCPOSLibrary.DeviceType.DT_FuelDispenser || deviceType == FDCPOSLibrary.DeviceType.DT_OutdoorPaymentTerminal)
                        {
                            fpsc = new FDCMessageFPStateChange();
                            fpsc.WorkstationID = workstationID;
                            fpsc.ApplicationSender = applicationSender;
                            fpsc.MessageID = FDCPOSManager.messageIdCounter.ToString();
                        }
                        else if (deviceType == FDCPOSLibrary.DeviceType.DT_TankLevelGauge || deviceType == FDCPOSLibrary.DeviceType.DT_TankProbe)
                        {
                            tpsc = new FDCMessageTPStateChange();
                            tpsc.WorkstationID = workstationID;
                            tpsc.ApplicationSender = applicationSender;
                            tpsc.MessageID = FDCPOSManager.messageIdCounter.ToString();
                        }
                        else if (deviceType == FDCPOSLibrary.DeviceType.DT_PricePole || deviceType == FDCPOSLibrary.DeviceType.DT_PricePolePoint)
                        {
                            ppsc = new FDCMessagePPStateChange();
                            ppsc.WorkstationID = workstationID;
                            ppsc.ApplicationSender = applicationSender;
                            ppsc.MessageID = FDCPOSManager.messageIdCounter.ToString();
                        }
                    }
                    FDCMessageFDCdataDeviceStateChange FDCDataElem = new FDCMessageFDCdataDeviceStateChange();
                    FDCMessageDeviceClass fdcDeviceClassElem = new FDCMessageDeviceClass();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.Type = deviceType; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
                    fdcDeviceClassElem.ErrorDescription = errorDescription;
                    fdcDeviceClassElem.ErrorID = errorId;
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                    {
                        fdcDeviceClassElem.LogicalState = deviceState.ToString();
                        fdcDeviceClassElem.LogicalSubState = (deviceSubState == LogicalDeviceState.FDC_UNDEFINED) ? "" : deviceSubState.ToString();
                    }
                    else
                    {
                        fdcDeviceClassElem.DeviceState = deviceState.ToString();
                        if (this.fdcPosManager.useExtensions)
                            fdcDeviceClassElem.DeviceSubState = (deviceSubState == LogicalDeviceState.FDC_UNDEFINED) ? "" : deviceSubState.ToString();

                        if (FDCGlobal.ProtocolVersion >= FDCVersion.V0007)
                        {
                            if (deviceType == FDCPOSLibrary.DeviceType.DT_FuellingPoint || deviceType == FDCPOSLibrary.DeviceType.DT_FuelDispenser || deviceType == FDCPOSLibrary.DeviceType.DT_OutdoorPaymentTerminal)
                            {
                                fdcDeviceClassElem.LockingApplicationSender = lockingAS;

                                NozzleStateClass[] nsArray = null;
                                NozzleState nozzleState;
                                LogicalState nozzleLogicalState, nozzleTankState;
                                int i;
                                for (i = 0; i < nozzleListNum; i++)
                                {
                                    Array.Resize<NozzleStateClass>(ref nsArray, (nsArray != null) ? nsArray.Length + 1 : 1);
                                    NozzleStateClass ns = new NozzleStateClass();
                                    nsArray[nsArray.Length - 1] = ns;
                                    ns.NozzleNo = Convert.ToString(i + 1);
                                    nozzleState = ((nozzleListState & ((int)(1 << i))) != 0) ? NozzleState.NozzleUp : NozzleState.NozzleDown;
                                    ns.LogicalNozzle = nozzleState.ToString();
                                    nozzleLogicalState = ((nozzleListLogicalState & ((int)(1 << i))) != 0) ? LogicalState.Locked : LogicalState.Unlocked;
                                    ns.LogicalState = nozzleLogicalState.ToString();
                                    nozzleTankState = ((nozzleListTankState & ((int)(1 << i))) != 0) ? LogicalState.Locked : LogicalState.Unlocked;
                                    ns.TankLogicalState = nozzleTankState.ToString();
                                }
                                fdcDeviceClassElem.Nozzle = nsArray;
                            }
                            else if (deviceType == FDCPOSLibrary.DeviceType.DT_TankLevelGauge || deviceType == FDCPOSLibrary.DeviceType.DT_TankProbe)
                            {
                                LogicalState tankLogicalState;
                                LogicalTPStateClass logicalTPState = new LogicalTPStateClass();
                                tankLogicalState = (nozzleListTankState != 0) ? LogicalState.Locked : LogicalState.Unlocked; //TODO...
                                logicalTPState.TankLogicalState = tankLogicalState.ToString();
                                fdcDeviceClassElem.LogicalTPState = logicalTPState;
                            }
                        }
                        else if (FDCGlobal.ProtocolVersion == FDCVersion.V0005)
                        {
                            if (deviceType == FDCPOSLibrary.DeviceType.DT_FuellingPoint || deviceType == FDCPOSLibrary.DeviceType.DT_FuelDispenser)
                            {
                                FDCMessageNozzleStateDeviceStateChange[] nsArray = null;
                                NozzleState nozzleState;
                                LogicalState nozzleLogicalState, nozzleTankState;
                                int i;
                                ////FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4),
                                //string.Format("nozzleListNum={0}, nozzleListState={1}, nozzleListLogicalState={2}", nozzleListNum, nozzleListState, nozzleListLogicalState));
                                for (i = 0; i < nozzleListNum; i++)
                                {
                                    Array.Resize<FDCMessageNozzleStateDeviceStateChange>(ref nsArray, (nsArray != null) ? nsArray.Length + 1 : 1);
                                    FDCMessageNozzleStateDeviceStateChange ns = new FDCMessageNozzleStateDeviceStateChange();
                                    nsArray[nsArray.Length - 1] = ns;
                                    nozzleState = ((nozzleListState & ((int)(1 << i))) != 0) ? NozzleState.NozzleUp : NozzleState.NozzleDown;
                                    switch (i)
                                    {
                                        case 0: ns.LogicalNozzle1 = nozzleState.ToString(); break;
                                        case 1: ns.LogicalNozzle2 = nozzleState.ToString(); break;
                                        case 2: ns.LogicalNozzle3 = nozzleState.ToString(); break;
                                        case 3: ns.LogicalNozzle4 = nozzleState.ToString(); break;
                                        case 4: ns.LogicalNozzle5 = nozzleState.ToString(); break;
                                        case 5: ns.LogicalNozzle6 = nozzleState.ToString(); break;
                                        case 6: ns.LogicalNozzle7 = nozzleState.ToString(); break;
                                        case 7: ns.LogicalNozzle8 = nozzleState.ToString(); break;
                                        default:
                                            break;
                                    }
                                    nozzleLogicalState = ((nozzleListLogicalState & ((int)(1 << i))) != 0) ? LogicalState.Locked : LogicalState.Unlocked;
                                    ns.LogicalState = nozzleLogicalState.ToString();

                                    ////FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4),
                                    //                            string.Format("i={0}, nozzleState={1}, nozzleLogicalState={2}, (int)(1 << i)={3}", i, nozzleState, nozzleLogicalState, (int)(1 << i)));
                                }
                                fdcDeviceClassElem.LogicalNozzleState = nsArray;
                            }
                            else if (deviceType == FDCPOSLibrary.DeviceType.DT_TankLevelGauge || deviceType == FDCPOSLibrary.DeviceType.DT_TankProbe)
                            {
                                FDCMessageLogicalTankStateDeviceStateChange logicalTankState = new FDCMessageLogicalTankStateDeviceStateChange();
                                LogicalState tankLogicalState = (nozzleListTankState != 0) ? LogicalState.Locked : LogicalState.Unlocked;
                                logicalTankState.LogicalState = tankLogicalState.ToString();
                                fdcDeviceClassElem.LogicalTankState = logicalTankState;
                            }
                        }

                    }
                    FDCMessageDeviceClass[] fdcDeviceClassArray = { fdcDeviceClassElem };

                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

                    FDCMessageFDCdataDeviceStateChange[] FDCDataArray = { FDCDataElem };

                    if (FDCGlobal.ProtocolVersion < FDCVersion.V0007)
                    {
                        devicesc.FDCdata = FDCDataArray;
                        ////FDCPOSManager.tracer.WriteLine(string.Format("sending workstationID={0}, applicationSender={1}", workstationID, applicationSender));
                        lock (fdcPosManager.fdcClientList[sID])
                            SendFDCMessage<FDCMessageDeviceStateChange>(fdcPosManager.fdcClientList[sID], devicesc);
                    }
                    else
                    {
                        if (deviceType == FDCPOSLibrary.DeviceType.DT_FuellingPoint || deviceType == FDCPOSLibrary.DeviceType.DT_FuelDispenser || deviceType == FDCPOSLibrary.DeviceType.DT_OutdoorPaymentTerminal)
                        {
                            fpsc.FDCdata = FDCDataArray;
                            ////FDCPOSManager.tracer.WriteLine(string.Format("sending FPState workstationID={0}, applicationSender={1}", workstationID, applicationSender));
                            lock (fdcPosManager.fdcClientList[sID])
                                SendFDCMessage<FDCMessageFPStateChange>(fdcPosManager.fdcClientList[sID], fpsc);
                        }
                        else if (deviceType == FDCPOSLibrary.DeviceType.DT_TankLevelGauge || deviceType == FDCPOSLibrary.DeviceType.DT_TankProbe)
                        {
                            tpsc.FDCdata = FDCDataArray;
                            ////FDCPOSManager.tracer.WriteLine(string.Format("sending TPState workstationID={0}, applicationSender={1}", workstationID, applicationSender));
                            lock (fdcPosManager.fdcClientList[sID])
                                SendFDCMessage<FDCMessageTPStateChange>(fdcPosManager.fdcClientList[sID], tpsc);
                        }
                        else if (deviceType == FDCPOSLibrary.DeviceType.DT_PricePole || deviceType == FDCPOSLibrary.DeviceType.DT_PricePolePoint)
                        {
                            ppsc.FDCdata = FDCDataArray;
                            ////FDCPOSManager.tracer.WriteLine(string.Format("sending PPState workstationID={0}, applicationSender={1}", workstationID, applicationSender));
                            lock (fdcPosManager.fdcClientList[sID])
                                SendFDCMessage<FDCMessagePPStateChange>(fdcPosManager.fdcClientList[sID], ppsc);
                        }
                        // }
                    }
                }
                catch (Exception ex)
                {
                    //Messages.fdcSocketLogger.LogError("Notify to clients with  exceptioned: " + ex);
                    this.logger.LogError("Notify to client(" + sID + ") " +
                            "with DeviceStateChange exceptioned: " + ex
                            + System.Environment.NewLine + "Will skip it and continue");
                }
                finally
                {
                    //Monitor.Exit(fdcposManager.tcpClientList);
                }
            }
        }

        public void FDCStop()
        {
            string workstationID = "", applicationSender = "";

            Monitor.Enter(fdcPosManager.fdcClientList);
            try
            {
                foreach (string sID in fdcPosManager.fdcClientList.Keys)
                {
                    if (!fdcPosManager.fdcClientList[sID].connected || !fdcPosManager.fdcClientList[sID].logon)
                        continue;

                    workstationID = fdcPosManager.fdcClientList[sID].workstationID;
                    applicationSender = fdcPosManager.fdcClientList[sID].applicationSender;

                    FDCMessageStopped dsc = new FDCMessageStopped();
                    dsc.WorkstationID = workstationID;
                    dsc.ApplicationSender = applicationSender;
                    dsc.MessageID = FDCPOSManager.messageIdCounter.ToString();

                    SendFDCMessage<FDCMessageStopped>(fdcPosManager.fdcClientList[sID], dsc);
                }
            }
            catch (Exception ex)
            {
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            finally
            {
                Monitor.Exit(fdcPosManager.fdcClientList);
            }
        }

        public void FDCStart()
        {
            string workstationID = "", applicationSender = "";

            Monitor.Enter(fdcPosManager.fdcClientList);
            try
            {
                foreach (string sID in fdcPosManager.fdcClientList.Keys)
                {
                    if (!fdcPosManager.fdcClientList[sID].connected || !fdcPosManager.fdcClientList[sID].logon)
                        continue;

                    workstationID = fdcPosManager.fdcClientList[sID].workstationID;
                    applicationSender = fdcPosManager.fdcClientList[sID].applicationSender;

                    FDCMessageStarted dsc = new FDCMessageStarted();
                    dsc.WorkstationID = workstationID;
                    dsc.ApplicationSender = applicationSender;
                    dsc.MessageID = FDCPOSManager.messageIdCounter.ToString();

                    SendFDCMessage<FDCMessageStarted>(fdcPosManager.fdcClientList[sID], dsc);
                }
            }
            catch (Exception ex)
            {
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            finally
            {
                Monitor.Exit(fdcPosManager.fdcClientList);
            }
        }

        //private int currentFuellingStatusOnCalling = 0;

        public void CurrentFuellingStatus(int deviceId, decimal volume, decimal amount, decimal price, int nozzle, int transactionId, string releaseToken, int mode, int productNo)
        {
            string workstationID = "", applicationSender = "";
            //if (0 == Interlocked.CompareExchange(ref this.currentFuellingStatusOnCalling, 1, 0))
            //{
            //Monitor.Enter(fdcposManager.tcpClientList);
            try
            {
                var safeCopy = new List<string>(fdcPosManager.fdcClientList.Keys.Select(k => k.ToString()).ToList());
                foreach (string sID in safeCopy)
                {
                    try
                    {
                        if (!fdcPosManager.fdcClientList[sID].connected || !fdcPosManager.fdcClientList[sID].logon)
                            continue;

                        workstationID = fdcPosManager.fdcClientList[sID].workstationID;
                        applicationSender = fdcPosManager.fdcClientList[sID].applicationSender;

                        #region MyRegion

                        FDCMessageCurrentFuellingStatus dsc = new FDCMessageCurrentFuellingStatus();
                        dsc.WorkstationID = workstationID;
                        dsc.ApplicationSender = applicationSender;
                        dsc.MessageID = FDCPOSManager.messageIdCounter.ToString();
                        FDCMessageFDCdataCurrentFuellingStatus FDCDataElem = new FDCMessageFDCdataCurrentFuellingStatus();

                        FDCMessageDeviceClassCurrentFuellingStatus fdcDeviceClassElem = new FDCMessageDeviceClassCurrentFuellingStatus();
                        fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                        fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
                        fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
                        if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                        {
                            fdcDeviceClassElem.CurrentNozzleNo = Convert.ToString(nozzle);
                            fdcDeviceClassElem.CurrentVolume = FDCConvert.ToString(volume);
                            fdcDeviceClassElem.CurrentUnitPrice = FDCConvert.ToString(price);
                            fdcDeviceClassElem.CurrentAmount = FDCConvert.ToString(amount);
                        }
                        else
                        {
                            FuelModeElementClass fuelMode = new FuelModeElementClass();
                            fuelMode.ModeNo = (mode == -1) ? "" : Convert.ToString(mode);
                            fdcDeviceClassElem.FuelMode = fuelMode;
                            fdcDeviceClassElem.NozzleNo = Convert.ToString(nozzle);
                            fdcDeviceClassElem.Volume = FDCConvert.ToString(volume);
                            fdcDeviceClassElem.UnitPrice = FDCConvert.ToString(price);
                            fdcDeviceClassElem.Amount = FDCConvert.ToString(amount);
                            fdcDeviceClassElem.VolumeProduct1 = FDCConvert.ToString(volume);
                            fdcDeviceClassElem.VolumeProduct2 = FDCConvert.ToString((Decimal)0);
                            fdcDeviceClassElem.Product1No = Convert.ToString(productNo);
                            fdcDeviceClassElem.Product2No = "";
                            fdcDeviceClassElem.BlendRatio = Convert.ToString(100);
                        }
                        fdcDeviceClassElem.ReleaseToken = releaseToken;
                        if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                            fdcDeviceClassElem.TransactionNo = Convert.ToString(transactionId);
                        else
                            fdcDeviceClassElem.TransactionSeqNo = Convert.ToString(transactionId);
                        FDCMessageDeviceClassCurrentFuellingStatus[] fdcDeviceClassArray = { fdcDeviceClassElem };

                        FDCDataElem.DeviceClass = fdcDeviceClassArray;
                        FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

                        FDCMessageFDCdataCurrentFuellingStatus[] FDCDataArray = { FDCDataElem };

                        dsc.FDCdata = FDCDataArray;

                        #endregion

                        lock (fdcPosManager.fdcClientList[sID])
                            SendFDCMessage<FDCMessageCurrentFuellingStatus>(fdcPosManager.fdcClientList[sID], dsc);
                    }
                    catch (Exception ex)
                    {
                        this.logger.LogError("Notify to client(" + sID + ") " +
                            "with CurrentFuellingStatus exceptioned: " + ex
                            + System.Environment.NewLine + "Will skip it and continue");
                        ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
                    }
                }
            }
            catch (Exception ex)
            {
                this.logger.LogError("Notify to clients with CurrentFuellingStatus exceptioned: " + ex);
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            finally
            {
                //this.currentFuellingStatusOnCalling = 0;
                //Monitor.Exit(fdcposManager.tcpClientList);
            }
            //}
            //else
            //    Messages.fdcSocketLogger.LogInformation("CurrentFuellingStatus will be skipped for avoid blocking");
        }

        public void DeviceAlarm(string deviceType, int deviceId, int alarmId, string alarmDescr)
        {
            string workstationID = "", applicationSender = "";

            ////FDCPOSManager.tracer.WriteLine("init");
            Monitor.Enter(fdcPosManager.fdcClientList);
            try
            {
                foreach (string sID in fdcPosManager.fdcClientList.Keys)
                {
                    if (!fdcPosManager.fdcClientList[sID].connected || !fdcPosManager.fdcClientList[sID].logon)
                        continue;

                    workstationID = fdcPosManager.fdcClientList[sID].workstationID;
                    applicationSender = fdcPosManager.fdcClientList[sID].applicationSender;

                    FDCMessageDeviceAlarm dsc = new FDCMessageDeviceAlarm();
                    dsc.WorkstationID = workstationID;
                    dsc.ApplicationSender = applicationSender;
                    dsc.MessageID = FDCPOSManager.messageIdCounter.ToString();
                    FDCMessageFDCdataDeviceAlarm FDCDataElem = new FDCMessageFDCdataDeviceAlarm();

                    FDCMessageDeviceAlarmMsg alarmMsgElem = new FDCMessageDeviceAlarmMsg();
                    alarmMsgElem.Number = Convert.ToString(alarmId);
                    alarmMsgElem.Text = alarmDescr;
                    FDCMessageDeviceAlarmMsg[] alarmMsgArray = { alarmMsgElem };

                    FDCMessageDeviceAlarmDeviceClass fdcDeviceClassElem = new FDCMessageDeviceAlarmDeviceClass();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.Type = deviceType;
                    fdcDeviceClassElem.AlarmMsg = alarmMsgArray;
                    FDCMessageDeviceAlarmDeviceClass[] fdcDeviceClassArray = { fdcDeviceClassElem };

                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    FDCMessageFDCdataDeviceAlarm[] FDCDataArray = { FDCDataElem };

                    dsc.FDCdata = FDCDataArray;

                    SendFDCMessage<FDCMessageDeviceAlarm>(fdcPosManager.fdcClientList[sID], dsc);
                }
            }
            catch (Exception ex)
            {
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            finally
            {
                Monitor.Exit(fdcPosManager.fdcClientList);
            }
            ////FDCPOSManager.tracer.WriteLine("end");
        }

        public void FuelSaleTrx(int deviceId, decimal volume, decimal amount, decimal price, int nozzle, int productNo,
            string productName, string productUM, int mode, int transactionId, int transactionStatus,
            int completionReason, string releaseToken, string startTime, string endTime, string lockingAS,
            string authorisationAS, int reservingDeviceId, int fuellingType)
        {
            string workstationID = "", applicationSender = "";

            //Monitor.Enter(fdcposManager.tcpClientList);
            try
            {
                var safeCopy = new List<string>(fdcPosManager.fdcClientList.Keys.Select(k => k.ToString()).ToList());
                foreach (string sID in safeCopy)
                {
                    try
                    {
                        if (!fdcPosManager.fdcClientList[sID].connected || !fdcPosManager.fdcClientList[sID].logon)
                            continue;

                        workstationID = fdcPosManager.fdcClientList[sID].workstationID;
                        applicationSender = fdcPosManager.fdcClientList[sID].applicationSender;

                        FDCMessageFuelSaleTrx dsc = new FDCMessageFuelSaleTrx();
                        dsc.WorkstationID = workstationID;
                        dsc.ApplicationSender = applicationSender;
                        dsc.MessageID = FDCPOSManager.messageIdCounter.ToString();
                        FDCMessageFDCdataFuelSaleTrx FDCDataElem = new FDCMessageFDCdataFuelSaleTrx();


                        if (FDCGlobal.ProtocolVersion > FDCVersion.V0003)
                        {
                            FDCMessageDeviceClassFuelSaleTrx fdcDeviceClassElem = new FDCMessageDeviceClassFuelSaleTrx();
                            fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                            fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
                            fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
                            fdcDeviceClassElem.NozzleNo = Convert.ToString(nozzle);

                            fdcDeviceClassElem.TransactionSeqNo = Convert.ToString(transactionId);
                            fdcDeviceClassElem.State = ((FuellingState)transactionStatus == FuellingState.Paid) ? FuellingState.Cleared.ToString() : ((FuellingState)transactionStatus).ToString();

                            if (this.fdcPosManager.useExtensions) fdcDeviceClassElem.CompletionReason = Convert.ToString(completionReason);
                            fdcDeviceClassElem.ReleaseToken = releaseToken;

                            FuelModeElementClass fuelMode = new FuelModeElementClass();
                            fuelMode.ModeNo = (mode == -1) ? "" : Convert.ToString(mode);
                            fdcDeviceClassElem.FuelMode = fuelMode;

                            fdcDeviceClassElem.VolumeProduct1 = FDCConvert.ToString(volume);
                            fdcDeviceClassElem.VolumeProduct2 = FDCConvert.ToString((Decimal)0);
                            fdcDeviceClassElem.ProductNo1 = Convert.ToString(productNo);
                            fdcDeviceClassElem.ProductNo2 = "";
                            if (this.fdcPosManager.useExtensions)
                            {
                                fdcDeviceClassElem.ProductName = productName;
                                fdcDeviceClassElem.ProductUM = productUM;
                            }
                            fdcDeviceClassElem.BlendRatio = Convert.ToString(100);
                            fdcDeviceClassElem.Amount = FDCConvert.ToString(amount);
                            fdcDeviceClassElem.Volume = FDCConvert.ToString(volume);
                            fdcDeviceClassElem.UnitPrice = FDCConvert.ToString(price);
                            if (this.fdcPosManager.useExtensions) fdcDeviceClassElem.StartTimeStamp = startTime;
                            if (this.fdcPosManager.useExtensions) fdcDeviceClassElem.EndTimeStamp = endTime;
                            fdcDeviceClassElem.AuthorisationApplicationSender = authorisationAS;
                            fdcDeviceClassElem.LockingApplicationSender = lockingAS;
                            if (this.fdcPosManager.useExtensions)
                            {
                                fdcDeviceClassElem.ReservingDeviceId = Convert.ToString(reservingDeviceId);
                                fdcDeviceClassElem.FuellingType = Convert.ToString(fuellingType);
                            }
                            FuellingInfo fuellingInfo = new FuellingInfo(deviceId, nozzle, productNo, productName, productUM, amount, volume, price, DateTime.Parse(endTime), transactionId);
                            fdcDeviceClassElem.DSPFields = fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)].getDSPFields(fuellingInfo);
                            fdcDeviceClassElem.CRCMode = fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)].getCRC(fuellingInfo);

                            FDCDataElem.DeviceClass = fdcDeviceClassElem;
                        }
                        else
                        {
                            FDCMessageTRXdataFuelSaleTrx trxdata = new FDCMessageTRXdataFuelSaleTrx();

                            FDCMessageDeviceClassTrxDataFuelSaleTrx fdcDeviceClassElem = new FDCMessageDeviceClassTrxDataFuelSaleTrx();
                            fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                            fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
                            fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
                            fdcDeviceClassElem.NozzleNo = Convert.ToString(nozzle);

                            trxdata.DeviceClass = fdcDeviceClassElem;

                            trxdata.TransactionNo = Convert.ToString(transactionId);
                            trxdata.State = Convert.ToString((FuellingState)transactionStatus);
                            trxdata.CompletionReason = Convert.ToString(completionReason);
                            trxdata.ReleaseToken = releaseToken;
                            trxdata.Type = "";
                            trxdata.FuelMode = Convert.ToString(mode);
                            trxdata.VolumeProduct1 = FDCConvert.ToString(volume);
                            trxdata.VolumeProduct2 = FDCConvert.ToString((Decimal)0);
                            trxdata.Product1No = Convert.ToString(productNo);
                            trxdata.Product2No = "";
                            if (this.fdcPosManager.useExtensions)
                            {
                                trxdata.ProductName = productName;
                                trxdata.ProductUM = productUM;
                            }
                            trxdata.BlendRatio = Convert.ToString(100);
                            trxdata.Amount = FDCConvert.ToString(amount);
                            trxdata.Volume = FDCConvert.ToString(volume);
                            trxdata.UnitPrice = FDCConvert.ToString(price);
                            trxdata.StartTimeStamp = startTime;
                            trxdata.EndTimeStamp = endTime;
                            //FDCMessageTRXdataFuelSaleTrx[] trxdataArray = { trxdata };
                            //FDCDataElem.TRXdata = trxdataArray;
                            FDCDataElem.TRXdata = trxdata;
                            FuellingInfo fuellingInfo = new FuellingInfo(deviceId, nozzle, productNo, productName, productUM, amount, volume, price, DateTime.Parse(endTime), transactionId);
                            trxdata.DSPFields = fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)].getDSPFields(fuellingInfo);
                            trxdata.CRCMode = fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)].getCRC(fuellingInfo);

                        }
                        FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

                        FDCMessageFDCdataFuelSaleTrx[] FDCDataArray = { FDCDataElem };
                        dsc.FDCdata = FDCDataArray;

                        lock (fdcPosManager.fdcClientList[sID])
                            SendFDCMessage<FDCMessageFuelSaleTrx>(fdcPosManager.fdcClientList[sID], dsc);
                    }
                    catch (Exception ex)
                    {
                        this.logger.LogError("Notify to client(" + sID + ") " +
                            "with FuelSaleTrx exceptioned: " + ex
                            + System.Environment.NewLine + "Will skip it and continue");
                        ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
                    }
                }
            }
            catch (Exception ex)
            {
                this.logger.LogError("Notify to clients with FuelSaleTrx exceptioned: " + ex);
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            finally
            {
                //Monitor.Exit(fdcposManager.tcpClientList);
            }
        }

        public void FuelPriceChange(int productNo, int modeNo, double newPrice, double oldPrice, string effectiveDateTime)
        {
            string workstationID = "", applicationSender = "";

            //Monitor.Enter(fdcposManager.tcpClientList);

            try
            {
                var safeCopy = new List<string>(fdcPosManager.fdcClientList.Keys.Select(k => k.ToString()).ToList());
                foreach (string sID in safeCopy)
                {
                    if (!fdcPosManager.fdcClientList[sID].connected || !fdcPosManager.fdcClientList[sID].logon)
                        continue;

                    workstationID = fdcPosManager.fdcClientList[sID].workstationID;
                    applicationSender = fdcPosManager.fdcClientList[sID].applicationSender;

                    FDCMessageFuelPriceChange dsc = new FDCMessageFuelPriceChange();
                    dsc.WorkstationID = workstationID;
                    dsc.ApplicationSender = applicationSender;
                    dsc.MessageID = FDCPOSManager.messageIdCounter.ToString();
                    FDCMessageFDCdataFuelPriceChange FDCDataElem = new FDCMessageFDCdataFuelPriceChange();

                    FDCMessageProductFuelPriceChange fdcProductElem = new FDCMessageProductFuelPriceChange();
                    fdcProductElem.ProductNo = Convert.ToString(productNo);
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                    {
                        fdcProductElem.ModeNo = modeNo.ToString();
                        fdcProductElem.NewPrice = FDCConvert.ToString(newPrice);
                        fdcProductElem.OldPrice = FDCConvert.ToString(oldPrice);
                        fdcProductElem.EffectiveDateTime = effectiveDateTime;
                    }
                    else
                    {
                        FDCMessageFuelModeFuelPriceChange fdcFuelModeElem = new FDCMessageFuelModeFuelPriceChange();
                        fdcFuelModeElem.ModeNo = modeNo.ToString();
                        fdcFuelModeElem.NewPrice = FDCConvert.ToString(newPrice);
                        fdcFuelModeElem.OldPrice = FDCConvert.ToString(oldPrice);
                        fdcFuelModeElem.EffectiveDateTime = effectiveDateTime;
                        fdcProductElem.FuelMode = fdcFuelModeElem;
                    }
                    FDCMessageProductFuelPriceChange[] fdcProductArray = { fdcProductElem };

                    FDCDataElem.Product = fdcProductArray;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    FDCMessageFDCdataFuelPriceChange[] FDCDataArray = { FDCDataElem };

                    dsc.FDCdata = FDCDataArray;
                    lock (fdcPosManager.fdcClientList[sID])
                        SendFDCMessage<FDCMessageFuelPriceChange>(fdcPosManager.fdcClientList[sID], dsc);
                }
            }
            catch (Exception ex)
            {
                this.logger.LogError("Notify to clients with FuelPriceChange exceptioned: " + ex);
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            finally
            {
                //Monitor.Exit(fdcposManager.tcpClientList);
            }
        }
        public void FuelModeChange(string deviceType, int deviceId, int modeNo)
        {
            string workstationID = "", applicationSender = "";

            Monitor.Enter(fdcPosManager.fdcClientList);
            try
            {
                foreach (string sID in fdcPosManager.fdcClientList.Keys)
                {
                    if (!fdcPosManager.fdcClientList[sID].connected || !fdcPosManager.fdcClientList[sID].logon)
                        continue;

                    workstationID = fdcPosManager.fdcClientList[sID].workstationID;
                    applicationSender = fdcPosManager.fdcClientList[sID].applicationSender;

                    FDCMessageFuelModeChange dsc = new FDCMessageFuelModeChange();
                    dsc.WorkstationID = workstationID;
                    dsc.ApplicationSender = applicationSender;
                    dsc.MessageID = FDCPOSManager.messageIdCounter.ToString();
                    FDCMessageFDCdataFuelModeChange FDCDataElem = new FDCMessageFDCdataFuelModeChange();

                    FDCMessageDeviceClassFuelModeChange fdcDeviceClassElem = new FDCMessageDeviceClassFuelModeChange();
                    fdcDeviceClassElem.Type = deviceType; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser; 
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                        fdcDeviceClassElem.ModeNo = (modeNo == -1) ? "" : Convert.ToString(modeNo);
                    else
                    {
                        FuelModeElementClass fuelMode = new FuelModeElementClass();
                        fuelMode.ModeNo = (modeNo == -1) ? "" : Convert.ToString(modeNo);
                        fdcDeviceClassElem.FuelMode = fuelMode;
                    }
                    FDCMessageDeviceClassFuelModeChange[] fdcDeviceClassArray = { fdcDeviceClassElem };

                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    FDCMessageFDCdataFuelModeChange[] FDCDataArray = { FDCDataElem };

                    dsc.FDCdata = FDCDataArray;

                    SendFDCMessage<FDCMessageFuelModeChange>(fdcPosManager.fdcClientList[sID], dsc);
                }
            }
            catch (Exception ex)
            {
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            finally
            {
                Monitor.Exit(fdcPosManager.fdcClientList);
            }
        }
        public void FDCExceptionMsg(int exceptionNo, string description)
        {
            string workstationID = "", applicationSender = "";

            Monitor.Enter(fdcPosManager.fdcClientList);
            try
            {
                foreach (string sID in fdcPosManager.fdcClientList.Keys)
                {
                    if (!fdcPosManager.fdcClientList[sID].connected || !fdcPosManager.fdcClientList[sID].logon)
                        continue;

                    workstationID = fdcPosManager.fdcClientList[sID].workstationID;
                    applicationSender = fdcPosManager.fdcClientList[sID].applicationSender;

                    FDCMessageFDCExceptionMsg dsc = new FDCMessageFDCExceptionMsg();
                    dsc.WorkstationID = workstationID;
                    dsc.ApplicationSender = applicationSender;
                    dsc.MessageID = FDCPOSManager.messageIdCounter.ToString();
                    FDCMessageFDCdataFDCExceptionMsg FDCDataElem = new FDCMessageFDCdataFDCExceptionMsg();


                    FDCDataElem.ExceptionNo = Convert.ToString(exceptionNo);
                    FDCDataElem.Description = description;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    FDCMessageFDCdataFDCExceptionMsg[] FDCDataArray = { FDCDataElem };

                    dsc.FDCdata = FDCDataArray;

                    SendFDCMessage<FDCMessageFDCExceptionMsg>(fdcPosManager.fdcClientList[sID], dsc);
                }
            }
            catch (Exception ex)
            {
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            finally
            {
                Monitor.Exit(fdcPosManager.fdcClientList);
            }
        }
        public void ConfigurationChange(int fDCDeviceStatus)
        {
            string workstationID = "", applicationSender = "";

            Monitor.Enter(fdcPosManager.fdcClientList);
            try
            {
                foreach (string sID in fdcPosManager.fdcClientList.Keys)
                {
                    if (!fdcPosManager.fdcClientList[sID].connected || !fdcPosManager.fdcClientList[sID].logon)
                        continue;

                    workstationID = fdcPosManager.fdcClientList[sID].workstationID;
                    applicationSender = fdcPosManager.fdcClientList[sID].applicationSender;

                    FDCMessageConfigurationChange dsc = new FDCMessageConfigurationChange();
                    dsc.WorkstationID = workstationID;
                    dsc.ApplicationSender = applicationSender;
                    dsc.MessageID = FDCPOSManager.messageIdCounter.ToString();
                    FDCMessageFDCdataConfigurationChange FDCDataElem = new FDCMessageFDCdataConfigurationChange();


                    FDCDataElem.FDCDeviceStatus = ((ErrorCode)fDCDeviceStatus).ToString();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    FDCMessageFDCdataConfigurationChange[] FDCDataArray = { FDCDataElem };

                    dsc.FDCdata = FDCDataArray;

                    SendFDCMessage<FDCMessageConfigurationChange>(fdcPosManager.fdcClientList[sID], dsc);
                }
            }
            catch (Exception ex)
            {
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            finally
            {
                Monitor.Exit(fdcPosManager.fdcClientList);
            }
        }

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

            //Monitor.Enter(fdcposManager.tcpClientList);
            try
            {
                List<string> safeCopy;
                if (string.IsNullOrEmpty(workstationId) || string.IsNullOrEmpty(applicationSender))
                    safeCopy = new List<string>(fdcPosManager.fdcClientList.Keys.Select(k => k.ToString()));
                else
                    safeCopy = new List<string>(fdcPosManager.fdcClientList
                        .Where(p => p.Key == FDCPOSClient.getClientID(workstationId, applicationSender)).Select(k => k.Key));
                foreach (string sID in safeCopy)
                {
                    if (!fdcPosManager.fdcClientList[sID].connected || !fdcPosManager.fdcClientList[sID].logon)
                        continue;

                    var wId = fdcPosManager.fdcClientList[sID].workstationID;
                    applicationSender = fdcPosManager.fdcClientList[sID].applicationSender;

                    FDCMessageGenericTypelessMessage dsc = new FDCMessageGenericTypelessMessage();
                    dsc.WorkstationID = wId;
                    dsc.ApplicationSender = applicationSender;
                    dsc.MessageID = FDCPOSManager.messageIdCounter.ToString();
                    FDCMessageFDCdataGenericTypelessMessage FDCDataElem = new FDCMessageFDCdataGenericTypelessMessage();


                    FDCDataElem.Message = msg;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    FDCMessageFDCdataGenericTypelessMessage[] FDCDataArray = { FDCDataElem };

                    dsc.FDCdata = FDCDataArray;
                    lock (fdcPosManager.fdcClientList[sID])
                        SendFDCMessage<FDCMessageGenericTypelessMessage>(fdcPosManager.fdcClientList[sID], dsc);
                }
            }
            catch (Exception ex)
            {
                fdcSocketLogger.LogError("SendGenericMessageToFdcClient to clients(wid:" + (workstationId ?? "")
                    + ", appId: " + (applicationSender ?? "") + ", msg: " + (msg ?? "") + ") with exception: \r\n" + ex);
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            finally
            {
                //Monitor.Exit(fdcposManager.tcpClientList);
            }
        }

        #endregion

        #region ServiceResponses

        public void SendErrorResponse(string requestType, string workstationID, string applicationSender, int requestId, ErrorCode status, string overallResult)
        {
            if (this.fdcSocketLogger.IsEnabled(LogLevel.Debug))
                this.fdcSocketLogger.LogDebug("Will SendErrorResponse(requestType: " + (requestType ?? "") + ") to Fdc client(wId: "
                    + (workstationID ?? "") + ",appSender: " + (applicationSender ?? "") + "), requestId: " + requestId + ", status: " + status + ", overallResult: " + (overallResult ?? ""));
            if (requestType == "LogOn") LogOn(workstationID, applicationSender, requestId, 0, 0, (int)status, overallResult, null);
            else if (requestType == "LogOff") LogOff(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "VersionInfo") VersionInfo(workstationID, applicationSender, requestId, "", "", "", "", (int)status, overallResult);
            else if (requestType == "StartForecourt") StartForecourt(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "StopForecourt") StopForecourt(workstationID, applicationSender, requestId, 0, overallResult);
            else if (requestType == "GetCurrentFuellingStatus") GetCurrentFuellingStatusSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "GetFuelPointTotals" || requestType == "GetTotals") GetFuelPointTotalsSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "GetDeviceState" || requestType == "GetFPState" || requestType == "GetTPState" || requestType == "GetPPState") GetDeviceStateSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "TerminateFuelling") TerminateFuellingSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "AuthoriseFuelPoint") AuthoriseFuelPoint(workstationID, applicationSender, requestId, 0, "", 0, 0, (int)status, overallResult);
            else if (requestType == "ChangeFuelMode") ChangeFuelMode(workstationID, applicationSender, requestId, "", 0, 0, (int)status, overallResult);
            else if (requestType == "ChangeFuelPrice") ChangeFuelPriceSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "LockFuelSaleTrx") LockFuelSaleTrx(workstationID, applicationSender, requestId, 0, 0, "", (int)status, (int)FuellingState.Undefined, overallResult);
            else if (requestType == "UnlockFuelSaleTrx") UnlockFuelSaleTrx(workstationID, applicationSender, requestId, 0, 0, "", (int)status, (int)FuellingState.Undefined, overallResult);
            else if (requestType == "ClearFuelSaleTrx") ClearFuelSaleTrx(workstationID, applicationSender, requestId, 0, 0, "", (int)status, (int)FuellingState.Undefined, overallResult);
            else if (requestType == "GetAvailableFuelSaleTrxs") GetAvailableFuelSaleTrxsSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "GetFuelSaleTrxDetails") GetFuelSaleTrxDetailsSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "GetProductTable") GetProductTableSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "GetModeTable") GetModeTableSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "GetFuelMode") GetFuelModeSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "GetConfiguration") GetConfigurationSend(workstationID, applicationSender, requestId, "", overallResult);
            else if (requestType == "GetDSPConfiguration") GetConfigurationSend(workstationID, applicationSender, requestId, DeviceType.DT_FuelDispenser, overallResult);
            else if (requestType == "GetTLGConfiguration") GetConfigurationSend(workstationID, applicationSender, requestId, DeviceType.DT_TankLevelGauge, overallResult);
            else if (requestType == "GetPPConfiguration") GetConfigurationSend(workstationID, applicationSender, requestId, DeviceType.DT_PricePole, overallResult);
            else if (requestType == "SetConfiguration") SetConfiguration(workstationID, applicationSender, requestId, overallResult);
            else if (requestType == "LockNozzle") LockNozzle(workstationID, applicationSender, requestId, 0, 0, 0, (int)status, overallResult);
            else if (requestType == "UnlockNozzle") UnlockNozzle(workstationID, applicationSender, requestId, 0, 0, 0, (int)status, overallResult);
            else if (requestType == "GetCountrySettings") GetCountrySettings(workstationID, applicationSender, requestId, "", "", "", "", "", "", "", "", (int)status, overallResult);
            else if (requestType == "GetDSPLimitsSend") GetDSPLimitsSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "ChangeDSPLimits") ChangeDSPLimits(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "SuspendFuelling") SuspendFuellingSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "ResumeFuelling") ResumeFuellingSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "LockTank") LockTank(workstationID, applicationSender, requestId, 0, 0, (int)status, overallResult);
            else if (requestType == "UnlockTank") UnlockTank(workstationID, applicationSender, requestId, 0, 0, (int)status, overallResult);
            else if (requestType == "GetTankData") GetTankDataSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "ReserveFuelPoint") ReserveFuelPoint(workstationID, applicationSender, requestId, 0, 0, 0, overallResult);
            else if (requestType == "FreeFuelPoint") FreeFuelPoint(workstationID, applicationSender, requestId, 0, 0, (int)status, overallResult);
            else if (requestType == "StartFuelPointTest") StartFuelPointTest(workstationID, applicationSender, requestId, 0, 0, (int)status, overallResult);
            else if (requestType == "EndFuelPointTest") EndFuelPointTest(workstationID, applicationSender, requestId, 0, 0, (int)status, overallResult);
            else if (requestType == "SetDeviceAlarm") SetDeviceAlarm(workstationID, applicationSender, requestId, "", 0, (int)status, overallResult);
            else if (requestType == "OpenFuelPoint" || requestType == "OpenDevice") OpenFuelPointSend(workstationID, applicationSender, requestId, (int)status, overallResult);
            else if (requestType == "CloseFuelPoint" || requestType == "CloseDevice") CloseFuelPointSend(workstationID, applicationSender, requestId, (int)status, overallResult);
        }

        public void LogOn(string workstationID, string applicationSender, int requestId, int iResponsePort, int iUnsolicitedPort, int status, string overallResult, FDCPOSClient fdcposClient)
        {
            try
            {
                bool bError = false;

                ////FDCPOSManager.tracer.WriteLine("init");
                if (fdcposClient != null) // means LogOnReq fails
                    bError = true;
                else if (fdcPosManager.fdcClientList.ContainsKey(FDCPOSClient.getClientID(workstationID, applicationSender)))
                    fdcposClient = fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)];
                else
                {
                    ////FDCPOSManager.tracer.WriteLine(string.Format("end: Error! client ID='{0}' in an unknown client", FDCPOSClient.getClientID(workstationID, applicationSender)));
                    return;
                }
                ////FDCPOSManager.tracer.WriteLine(overallResult);

                int socketTimeout = 6000;
                bool noDelay = true;
                try
                {
                    //string sValue = IniFile.IniReadValue(SINPConfigurazione.IniPath + "ForecourtServer.ini", "FUSION-Connection", "SocketTimeout");
                    //if (sValue.Length > 0)
                    //    socketTimeout = Convert.ToInt32(sValue);
                    ////FDCPOSManager.tracer.WriteLine(string.Format("socketTimeout={0}", socketTimeout));
                    //sValue = IniFile.IniReadValue(SINPConfigurazione.IniPath + "ForecourtServer.ini", "FUSION-Connection", "NoDelay");
                    //if (sValue.Length > 0 && sValue == "0")
                    //    noDelay = false;
                    ////FDCPOSManager.tracer.WriteLine(string.Format("socketTimeout={0}", socketTimeout));
                }
                catch (Exception ex)
                {
                    ////FDCPOSManager.tracer.WriteLine("EXCEPTION! " + ex.Message);
                }

                fdcposClient.sID = FDCPOSClient.getClientID(workstationID, applicationSender);
                fdcposClient.workstationID = workstationID;
                fdcposClient.applicationSender = applicationSender;

                bool bConnected = false;
                while (!bConnected)
                {
                    //FDCPOSManager.tracer.WriteLine("trying Connect socketChannelResponse ...");
                    try
                    {
                        if (iResponsePort == ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.IPPort)
                            fdcposClient.socketChannelResponse = fdcposClient.FdcClientTcpHandler.TcpClient;
                        else
                        {
                            fdcSocketLogger.LogError($"A Client(wId: {workstationID ?? ""}, appId: {applicationSender ?? ""}) is " +
                                $"trying use an unexpected ResponsePort: {iResponsePort} in LogOn ServiceRequest for setup socketChannelResponse, the expecting port is: {((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.IPPort}");
                            fdcposClient.socketChannelResponse = new TcpClient(fdcposClient.sIPAddress, iResponsePort);
                        }

                        bConnected = true;
                        ////FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4), string.Format("ReceiveTimeout={0}, SendTimeout={1}, NoDelay={2}", fdcposClient.socketChannelResponse.ReceiveTimeout, fdcposClient.socketChannelResponse.SendTimeout, fdcposClient.socketChannelResponse.NoDelay));
                        fdcposClient.socketChannelResponse.SendTimeout = socketTimeout;
                        fdcposClient.socketChannelResponse.NoDelay = noDelay;
                        ////FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4), string.Format("ReceiveTimeout={0}, SendTimeout={1}, NoDelay={2}", fdcposClient.socketChannelResponse.ReceiveTimeout, fdcposClient.socketChannelResponse.SendTimeout, fdcposClient.socketChannelResponse.NoDelay));
                    }
                    catch (Exception ex)
                    {
                        Thread.Sleep(1000);
                    }
                }
                ////FDCPOSManager.tracer.WriteLine("socketChannelResponse Connected");

                if (!bError)
                {
                    bConnected = false;
                    while (!bConnected)
                    {
                        ////FDCPOSManager.tracer.WriteLine("trying Connect socketChannelUnsolicited ...");
                        try
                        {
                            if (iUnsolicitedPort == ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.IPPort)
                                fdcposClient.socketChannelUnsolicited = fdcposClient.FdcClientTcpHandler.TcpClient;
                            else
                            {
                                fdcSocketLogger.LogError($"A Client(wId: {workstationID ?? ""}, appId: {applicationSender ?? ""}) is " +
                                    $"trying use an unexpected UnsolicitedPort: {iUnsolicitedPort} in LogOn ServiceRequest for setup socketChannelUnsolicited, the expecting port is: {((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.IPPort}");
                                fdcposClient.socketChannelUnsolicited = new TcpClient(fdcposClient.sIPAddress, iUnsolicitedPort);
                            }

                            bConnected = true;
                        }
                        catch (Exception ex)
                        {
                            Thread.Sleep(1000);
                        }
                    }
                    ////FDCPOSManager.tracer.WriteLine("socketChannelUnsolicited Connected");
                }

                ServiceResponseLogOn logOnRes = new ServiceResponseLogOn();
                logOnRes.WorkstationID = workstationID;
                logOnRes.ApplicationSender = applicationSender;
                logOnRes.RequestID = requestId.ToString();
                logOnRes.OverallResult = overallResult;

                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    logOnRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();

                fdcposClient.connected = true;
                fdcposClient.logon = true;
                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseLogOn>(fdcposClient, logOnRes);

                if (!bError)
                {
                    // start heartbeat
                    fdcposClient.heartbeat.RestartHeartbeatTimer();
                }
            }
            catch (Exception ex)
            {
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            ////FDCPOSManager.tracer.WriteLine("end");
        }

        public void LogOff(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                bool bError = false;

                ////FDCPOSManager.tracer.WriteLine("init");
                FDCPOSClient fdcposClient;
                if (fdcPosManager.fdcClientList.ContainsKey(FDCPOSClient.getClientID(workstationID, applicationSender)))
                    fdcposClient = fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)];
                else
                {
                    ////FDCPOSManager.tracer.WriteLine(string.Format("end: Error! client ID='{0}' in an unknown client", FDCPOSClient.getClientID(workstationID, applicationSender)));
                    return;
                }

                fdcposClient.sID = FDCPOSClient.getClientID(workstationID, applicationSender);
                fdcposClient.workstationID = workstationID;
                fdcposClient.applicationSender = applicationSender;

                ServiceResponseLogOff logOffRes = new ServiceResponseLogOff();
                logOffRes.WorkstationID = workstationID;
                logOffRes.ApplicationSender = applicationSender;
                logOffRes.RequestID = requestId.ToString();
                logOffRes.OverallResult = overallResult;

                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    logOffRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();

                fdcposClient.logon = false;
                RemovePendingMessages(FDCPOSClient.getClientID(workstationID, applicationSender));

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseLogOff>(fdcposClient, logOffRes);
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void VersionInfo(string workstationID, string applicationSender, int requestId, string supplier, string version, string release, string hotfix, int status, string overallResult)
        {
            ////FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseVersionInfo SvRes = new ServiceResponseVersionInfo();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString(); ;
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataVersionInfo FDCDataElem = new ServiceResponseFDCdataVersionInfo();
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            switch (FDCGlobal.ProtocolVersion)
            {
                case FDCVersion.V0003: FDCDataElem.InterfaceVersion = "00.03"; break;
                case FDCVersion.V0005: FDCDataElem.InterfaceVersion = "00.05"; break;
                case FDCVersion.V0007: FDCDataElem.InterfaceVersion = "00.07"; break;
                default: FDCDataElem.InterfaceVersion = ""; break;
            }

            FDCDataElem.FDCsupplier = supplier;
            FDCDataElem.FDCversion = version;
            FDCDataElem.FDCrelease = release;
            FDCDataElem.FDChotfix = hotfix;
            if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
            ServiceResponseFDCdataVersionInfo[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseVersionInfo>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void StartForecourt(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            ////FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseStartForecourt SvRes = new ServiceResponseStartForecourt();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataStartForecourt FDCDataElem = new ServiceResponseFDCdataStartForecourt();
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
            ServiceResponseFDCdataStartForecourt[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseStartForecourt>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void StopForecourt(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            ////FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseStopForecourt SvRes = new ServiceResponseStopForecourt();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataStopForecourt FDCDataElem = new ServiceResponseFDCdataStopForecourt();
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
            ServiceResponseFDCdataStopForecourt[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseStopForecourt>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            ////FDCPOSManager.tracer.WriteLine("end");
        }

        public bool GetCurrentFuellingStatusAdd(string workstationID, string applicationSender, int requestId, int deviceId, Decimal volume, Decimal amount, Decimal price, int nozzle, int transactionId, string releaseToken, string authorisationAS)
        {
            try
            {
                ////FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseGetCurrentFuellingStatus SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetCurrentFuellingStatus";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetCurrentFuellingStatus)(serviceResponseClientList[key]);
                if (SvRes == null)
                {
                    SvRes = new ServiceResponseGetCurrentFuellingStatus();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);
                }
                else
                {
                    if (SvRes.RequestType != "GetCurrentFuellingStatus" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        ////FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }

                ServiceResponseFDCdataGetCurrentFuellingStatus FDCDataElem = null;
                if (SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetCurrentFuellingStatus[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetCurrentFuellingStatus();
                    Array.Resize<ServiceResponseFDCdataGetCurrentFuellingStatus>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    SvRes.FDCdata = FDCDataArray;
                }

                ServiceResponseDeviceClassGetCurrentFuellingStatus deviceClass = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceResponseDeviceClassGetCurrentFuellingStatus fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId))
                            deviceClass = fdcDeviceClassElemTemp;
                }
                if (deviceClass == null && deviceId > 0)
                {
                    deviceClass = new ServiceResponseDeviceClassGetCurrentFuellingStatus();
                    deviceClass.DeviceID = Convert.ToString(deviceId);
                    deviceClass.PumpNo = Convert.ToString(deviceId);
                    deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;

                    deviceClass.CurrentNozzle = Convert.ToString(nozzle);
                    deviceClass.CurrentVolume = FDCConvert.ToString(volume);
                    deviceClass.CurrentUnitPrice = Convert.ToString(price);
                    deviceClass.CurrentAmount = FDCConvert.ToString(amount);
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                        deviceClass.TransactionNo = Convert.ToString(transactionId);
                    else
                        deviceClass.TransactionSeqNo = Convert.ToString(transactionId);
                    deviceClass.ReleaseToken = releaseToken;
                    if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                        deviceClass.AuthorisationApplicationSender = authorisationAS;

                    ServiceResponseDeviceClassGetCurrentFuellingStatus[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceResponseDeviceClassGetCurrentFuellingStatus>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                    fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = deviceClass;
                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                }
            }
            catch (Exception ex)
            {
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            ////FDCPOSManager.tracer.WriteLine("end");
            return true;
        }

        public bool GetCurrentFuellingStatusSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                ////FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseGetCurrentFuellingStatus SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetCurrentFuellingStatus";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetCurrentFuellingStatus)(serviceResponseClientList[key]);
                if (SvRes == null)
                {
                    SvRes = new ServiceResponseGetCurrentFuellingStatus();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataGetCurrentFuellingStatus FDCDataElem = new ServiceResponseFDCdataGetCurrentFuellingStatus();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    ServiceResponseFDCdataGetCurrentFuellingStatus[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                else
                {
                    if (SvRes.RequestType != "GetCurrentFuellingStatus" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        ////FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                SvRes.OverallResult = overallResult;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetCurrentFuellingStatus>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
                ////FDCPOSManager.tracer.WriteLine("end");
                return true;
            }
            catch (Exception ex)
            {
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return false;
        }

        public bool GetFuelPointTotalsAdd(string workstationID, string applicationSender, int requestId, int deviceId, int nozzleId, int productNo, decimal volume, decimal amount, decimal price)
        {
            try
            {
                ////FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseGetFuelPointTotals SvResFPTot = null;
                ServiceResponseGetTotals SvResTot = null;

                string commandName = (FDCGlobal.ProtocolVersion == FDCVersion.V0003) ? "GetFuelPointTotals" : "GetTotals";
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + commandName;
                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResFPTot = (ServiceResponseGetFuelPointTotals)(serviceResponseClientList[key]);
                    if (SvResFPTot == null)
                    {
                        SvResFPTot = new ServiceResponseGetFuelPointTotals();
                        SvResFPTot.WorkstationID = workstationID;
                        SvResFPTot.ApplicationSender = applicationSender;
                        SvResFPTot.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResFPTot);
                    }
                    else
                    {
                        if (SvResFPTot.RequestType != commandName || Convert.ToInt32(SvResFPTot.RequestID) != requestId)
                        {
                            ////FDCPOSManager.tracer.WriteLine(string.Format("SvResFPTot.RequestID={0}, requestId={1} - end false", SvResFPTot.RequestID, requestId));
                            return false;
                        }
                    }
                }
                else
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResTot = (ServiceResponseGetTotals)(serviceResponseClientList[key]);
                    if (SvResTot == null)
                    {
                        SvResTot = new ServiceResponseGetTotals();
                        SvResTot.WorkstationID = workstationID;
                        SvResTot.ApplicationSender = applicationSender;
                        SvResTot.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResTot);
                    }
                    else
                    {
                        if (SvResTot.RequestType != commandName || Convert.ToInt32(SvResTot.RequestID) != requestId)
                        {
                            ////FDCPOSManager.tracer.WriteLine(string.Format("SvResTot.RequestID={0}, requestId={1} - end false", SvResTot.RequestID, requestId));
                            return false;
                        }
                    }
                }

                ServiceResponseFDCdataGetFuelPointTotals FDCDataElem = null;
                if (SvResFPTot != null && SvResFPTot.FDCdata != null)
                    FDCDataElem = SvResFPTot.FDCdata[0];
                else if (SvResTot != null && SvResTot.FDCdata != null)
                    FDCDataElem = SvResTot.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetFuelPointTotals[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetFuelPointTotals();
                    Array.Resize<ServiceResponseFDCdataGetFuelPointTotals>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                        SvResFPTot.FDCdata = FDCDataArray;
                    else
                        SvResTot.FDCdata = FDCDataArray;
                }


                ServiceResponseDeviceClassGetFuelPointTotals fdcDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceResponseDeviceClassGetFuelPointTotals fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) && fdcDeviceClassElemTemp.NozzleNo == Convert.ToString(nozzleId))
                            fdcDeviceClassElem = fdcDeviceClassElemTemp;
                }
                if (fdcDeviceClassElem == null && deviceId > 0)
                {
                    fdcDeviceClassElem = new ServiceResponseDeviceClassGetFuelPointTotals();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
                    fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
                    fdcDeviceClassElem.NozzleNo = Convert.ToString(nozzleId);
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                    {
                        fdcDeviceClassElem.Product1No = Convert.ToString(productNo);
                        fdcDeviceClassElem.Product2No = "";
                    }
                    else
                    {
                        fdcDeviceClassElem.ProductNo1 = Convert.ToString(productNo);
                        fdcDeviceClassElem.ProductNo2 = "";
                    }
                    fdcDeviceClassElem.Amount = FDCConvert.ToString(amount);
                    fdcDeviceClassElem.Volume = FDCConvert.ToString(volume);
                    if (FDCGlobal.ProtocolVersion < FDCVersion.V0007)
                        fdcDeviceClassElem.UnitPrice = FDCConvert.ToString(price);
                    fdcDeviceClassElem.VolumeProduct1 = FDCConvert.ToString(volume);
                    fdcDeviceClassElem.VolumeProduct2 = FDCConvert.ToString((Decimal)0);
                    if (FDCGlobal.ProtocolVersion < FDCVersion.V0007)
                        fdcDeviceClassElem.BlendRatio = Convert.ToString(100);

                    ServiceResponseDeviceClassGetFuelPointTotals[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceResponseDeviceClassGetFuelPointTotals>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                    fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                }
            }
            catch (Exception ex)
            {
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            ////FDCPOSManager.tracer.WriteLine("end");
            return true;
        }
        public bool GetFuelPointTotalsSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                ////FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseGetFuelPointTotals SvResFPTot = null;
                ServiceResponseGetTotals SvResTot = null;

                string commandName = (FDCGlobal.ProtocolVersion == FDCVersion.V0003) ? "GetFuelPointTotals" : "GetTotals";
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + commandName;
                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResFPTot = (ServiceResponseGetFuelPointTotals)(serviceResponseClientList[key]);
                    if (SvResFPTot != null)
                    {
                        if (SvResFPTot.RequestType != commandName || Convert.ToInt32(SvResFPTot.RequestID) != requestId)
                        {
                            ////FDCPOSManager.tracer.WriteLine(string.Format("SvResFPTot.RequestID={0}, requestId={1} - end false", SvResFPTot.RequestID, requestId));
                            return false;
                        }
                    }
                    else
                    {
                        // send an empty response - no available data added
                        SvResFPTot = new ServiceResponseGetFuelPointTotals();
                        SvResFPTot.WorkstationID = workstationID;
                        SvResFPTot.ApplicationSender = applicationSender;
                        SvResFPTot.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResFPTot);

                        ServiceResponseFDCdataGetFuelPointTotals FDCDataElem = new ServiceResponseFDCdataGetFuelPointTotals();
                        FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                        ServiceResponseFDCdataGetFuelPointTotals[] FDCDataArray = { FDCDataElem };
                        SvResFPTot.FDCdata = FDCDataArray;
                    }
                    if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                        SvResFPTot.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                    SvResFPTot.OverallResult = overallResult;

                    ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetFuelPointTotals>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvResFPTot);
                }
                else
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResTot = (ServiceResponseGetTotals)(serviceResponseClientList[key]);
                    if (SvResTot != null)
                    {
                        if (SvResTot.RequestType != commandName || Convert.ToInt32(SvResTot.RequestID) != requestId)
                        {
                            ////FDCPOSManager.tracer.WriteLine(string.Format("SvResTot.RequestID={0}, requestId={1} - end false", SvResTot.RequestID, requestId));
                            return false;
                        }
                    }
                    else
                    {
                        // send an empty response - no available data added
                        SvResTot = new ServiceResponseGetTotals();
                        SvResTot.WorkstationID = workstationID;
                        SvResTot.ApplicationSender = applicationSender;
                        SvResTot.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResTot);

                        ServiceResponseFDCdataGetFuelPointTotals FDCDataElem = new ServiceResponseFDCdataGetFuelPointTotals();
                        FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                        ServiceResponseFDCdataGetFuelPointTotals[] FDCDataArray = { FDCDataElem };
                        SvResTot.FDCdata = FDCDataArray;
                    }
                    if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                        SvResTot.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                    SvResTot.OverallResult = overallResult;

                    ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetTotals>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvResTot);

                }
                serviceResponseClientList.Remove(key);
                ////FDCPOSManager.tracer.WriteLine("end");
                return true;
            }
            catch (Exception ex)
            {
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return false;
        }

        public bool GetDeviceStateAdd(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, LogicalDeviceState deviceState, LogicalDeviceState deviceSubState, string errorId, string errorDescription, LogicalState logicalState, string lockingAS, int nozzleListNum, int nozzleListState, int nozzleListLogicalState, int nozzleListTankState)
        {
            try
            {
                ////FDCPOSManager.tracer.WriteLine("init");
                string commandName = (FDCGlobal.ProtocolVersion <= FDCVersion.V0005) ? "GetDeviceState" : "GetFPState";
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + commandName;

                ServiceResponseGetDeviceState SvResDevice = null;
                ServiceResponseGetFPState SvResFP = null;

                if (FDCGlobal.ProtocolVersion <= FDCVersion.V0005)
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResDevice = (ServiceResponseGetDeviceState)(serviceResponseClientList[key]);
                    if (SvResDevice == null)
                    {
                        SvResDevice = new ServiceResponseGetDeviceState();
                        SvResDevice.WorkstationID = workstationID;
                        SvResDevice.ApplicationSender = applicationSender;
                        SvResDevice.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResDevice);
                    }
                    else
                    {
                        if (SvResDevice.RequestType != commandName || Convert.ToInt32(SvResDevice.RequestID) != requestId)
                        {
                            ////FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvResDevice.RequestID, requestId));
                            return false;
                        }
                    }
                }
                else
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResFP = (ServiceResponseGetFPState)(serviceResponseClientList[key]);
                    if (SvResFP == null)
                    {
                        SvResFP = new ServiceResponseGetFPState();
                        SvResFP.WorkstationID = workstationID;
                        SvResFP.ApplicationSender = applicationSender;
                        SvResFP.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResFP);
                    }
                    else
                    {
                        if (SvResFP.RequestType != commandName || Convert.ToInt32(SvResFP.RequestID) != requestId)
                        {
                            ////FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvResFP.RequestID, requestId));
                            return false;
                        }
                    }

                }


                ServiceResponseFDCdataGetDeviceState FDCDataElem = null;
                if (SvResDevice != null && SvResDevice.FDCdata != null)
                    FDCDataElem = SvResDevice.FDCdata[0];
                else if (SvResFP != null && SvResFP.FDCdata != null)
                    FDCDataElem = SvResFP.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetDeviceState[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetDeviceState();
                    Array.Resize<ServiceResponseFDCdataGetDeviceState>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    if (FDCGlobal.ProtocolVersion <= FDCVersion.V0005)
                        SvResDevice.FDCdata = FDCDataArray;
                    else if (FDCGlobal.ProtocolVersion > FDCVersion.V0005)
                        SvResFP.FDCdata = FDCDataArray;
                }

                ServiceResponseDeviceClassGetDeviceState fdcDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceResponseDeviceClassGetDeviceState fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId))
                            fdcDeviceClassElem = fdcDeviceClassElemTemp;
                }
                if (fdcDeviceClassElem == null && deviceId > 0)
                {
                    fdcDeviceClassElem = new ServiceResponseDeviceClassGetDeviceState();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.Type = deviceType;
                    fdcDeviceClassElem.ErrorDescription = errorDescription;
                    fdcDeviceClassElem.ErrorID = errorId;
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                    {
                        fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
                        fdcDeviceClassElem.LogicalState = deviceState.ToString();
                        fdcDeviceClassElem.LogicalSubState = (deviceSubState == LogicalDeviceState.FDC_UNDEFINED) ? "" : deviceSubState.ToString();
                    }
                    else
                    {
                        fdcDeviceClassElem.DeviceState = deviceState.ToString();
                        if (this.fdcPosManager.useExtensions)
                            fdcDeviceClassElem.DeviceSubState = (deviceSubState == LogicalDeviceState.FDC_UNDEFINED) ? "" : deviceSubState.ToString();

                        fdcDeviceClassElem.LockingApplicationSender = lockingAS;
                        if (FDCGlobal.ProtocolVersion >= FDCVersion.V0007)
                        {
                            NozzleStateClass[] nsArray = null;
                            NozzleState nozzleState;
                            LogicalState nozzleLogicalState, nozzleTankState;
                            int i;
                            for (i = 0; i < nozzleListNum; i++)
                            {
                                Array.Resize<NozzleStateClass>(ref nsArray, (nsArray != null) ? nsArray.Length + 1 : 1);
                                NozzleStateClass ns = new NozzleStateClass();
                                nsArray[nsArray.Length - 1] = ns;
                                ns.NozzleNo = Convert.ToString(i + 1);
                                nozzleState = ((nozzleListState & ((int)(1 << i))) != 0) ? NozzleState.NozzleUp : NozzleState.NozzleDown;
                                ns.LogicalNozzle = nozzleState.ToString();
                                nozzleLogicalState = ((nozzleListLogicalState & ((int)(1 << i))) != 0) ? LogicalState.Locked : LogicalState.Unlocked;
                                ns.LogicalState = nozzleLogicalState.ToString();
                                nozzleTankState = ((nozzleListTankState & ((int)(1 << i))) != 0) ? LogicalState.Locked : LogicalState.Unlocked;
                                ns.TankLogicalState = nozzleTankState.ToString();
                            }
                            fdcDeviceClassElem.Nozzle = nsArray;
                        }
                        else if (FDCGlobal.ProtocolVersion == FDCVersion.V0005)
                        {
                            fdcDeviceClassElem.LogicalState = logicalState.ToString();
                        }
                    }
                    ServiceResponseDeviceClassGetDeviceState[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceResponseDeviceClassGetDeviceState>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                    fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                }
                return true;
            }
            catch (Exception ex)
            {
                ////FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            ////FDCPOSManager.tracer.WriteLine("end");
            return false;

        }
        public bool GetDeviceStateSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                ////FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseGetDeviceState SvResDevice = null;
                ServiceResponseGetFPState SvResFP = null;
                string commandName = (FDCGlobal.ProtocolVersion <= FDCVersion.V0005) ? "GetDeviceState" : "GetFPState";
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + commandName;
                if (FDCGlobal.ProtocolVersion <= FDCVersion.V0005)
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResDevice = (ServiceResponseGetDeviceState)(serviceResponseClientList[key]);
                    if (SvResDevice != null)
                    {
                        if (SvResDevice.RequestType != commandName || Convert.ToInt32(SvResDevice.RequestID) != requestId)
                        {
                            ////FDCPOSManager.tracer.WriteLine(string.Format("SvResDevice.RequestID={0}, requestId={1} - end false", SvResDevice.RequestID, requestId));
                            return false;
                        }
                    }
                    else
                    {
                        // send an empty response - no available data added
                        SvResDevice = new ServiceResponseGetDeviceState();
                        SvResDevice.WorkstationID = workstationID;
                        SvResDevice.ApplicationSender = applicationSender;
                        SvResDevice.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResDevice);

                        ServiceResponseFDCdataGetDeviceState FDCDataElem = new ServiceResponseFDCdataGetDeviceState();
                        FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                        ServiceResponseFDCdataGetDeviceState[] FDCDataArray = { FDCDataElem };
                        SvResDevice.FDCdata = FDCDataArray;
                    }
                    if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                        SvResDevice.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                    SvResDevice.OverallResult = overallResult;
                    ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetDeviceState>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvResDevice);
                }
                else
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResFP = (ServiceResponseGetFPState)(serviceResponseClientList[key]);
                    if (SvResFP != null)
                    {
                        if (SvResFP.RequestType != commandName || Convert.ToInt32(SvResFP.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvResFP.RequestID={0}, requestId={1} - end false", SvResFP.RequestID, requestId));
                            return false;
                        }
                    }
                    else
                    {
                        // send an empty response - no available data added
                        SvResFP = new ServiceResponseGetFPState();
                        SvResFP.WorkstationID = workstationID;
                        SvResFP.ApplicationSender = applicationSender;
                        SvResFP.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResFP);

                        ServiceResponseFDCdataGetDeviceState FDCDataElem = new ServiceResponseFDCdataGetDeviceState();
                        FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                        ServiceResponseFDCdataGetDeviceState[] FDCDataArray = { FDCDataElem };
                        SvResFP.FDCdata = FDCDataArray;
                    }
                    if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                        SvResFP.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                    SvResFP.OverallResult = overallResult;
                    ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetFPState>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvResFP);

                }

                serviceResponseClientList.Remove(key);
                //FDCPOSManager.tracer.WriteLine("end");
                return true;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return false;

        }

        public bool TerminateFuellingAdd(string workstationID, string applicationSender, int requestId, int deviceId, LogicalDeviceState deviceStatus)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseTerminateFuelling SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "TerminateFuelling";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseTerminateFuelling)(serviceResponseClientList[key]);
                if (SvRes == null)
                {
                    SvRes = new ServiceResponseTerminateFuelling();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);
                }
                else
                {
                    if (SvRes.RequestType != "TerminateFuelling" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }

                ServiceResponseFDCdataTerminateFuelling FDCDataElem = null;
                if (SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataTerminateFuelling[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataTerminateFuelling();
                    Array.Resize<ServiceResponseFDCdataTerminateFuelling>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    //FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
                    SvRes.FDCdata = FDCDataArray;
                }

                ServiceResponseDeviceClassTerminateFuelling fdcDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceResponseDeviceClassTerminateFuelling fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId))
                            fdcDeviceClassElem = fdcDeviceClassElemTemp;
                }
                if (fdcDeviceClassElem == null && deviceId > 0)
                {
                    fdcDeviceClassElem = new ServiceResponseDeviceClassTerminateFuelling();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
                    fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0005)
                        fdcDeviceClassElem.DeviceState = deviceStatus.ToString();

                    ServiceResponseDeviceClassTerminateFuelling[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceResponseDeviceClassTerminateFuelling>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                    fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                }
                //FDCPOSManager.tracer.WriteLine("end");
                return true;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");
            return false;
        }
        public bool TerminateFuellingSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseTerminateFuelling SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "TerminateFuelling";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseTerminateFuelling)(serviceResponseClientList[key]);
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "TerminateFuelling" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }
                else
                {
                    // send an empty response - no available data added
                    SvRes = new ServiceResponseTerminateFuelling();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataTerminateFuelling FDCDataElem = new ServiceResponseFDCdataTerminateFuelling();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

                    ServiceResponseFDCdataTerminateFuelling[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                SvRes.OverallResult = overallResult;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseTerminateFuelling>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
                //FDCPOSManager.tracer.WriteLine("end");
                return true;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return false;
        }

        public void AuthoriseFuelPoint(string workstationID, string applicationSender, int requestId, int transactionId, string releaseToken, int deviceId, LogicalDeviceState deviceStatus, int status, string overallResult)
        {
            //form.TransactionIdSetText(Convert.ToString(transactionId));

            //FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseAuthoriseFuelPoint SvRes = new ServiceResponseAuthoriseFuelPoint();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataAuthoriseFuelPoint FDCDataElem = new ServiceResponseFDCdataAuthoriseFuelPoint();
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseDeviceClassAuthoriseFuelPoint deviceClass = new ServiceResponseDeviceClassAuthoriseFuelPoint();
            deviceClass.DeviceID = Convert.ToString(deviceId);
            deviceClass.PumpNo = Convert.ToString(deviceId);
            deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
            if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                deviceClass.DeviceState = deviceStatus.ToString();
            if (this.fdcPosManager.useExtensions)
                deviceClass.ReleaseToken = releaseToken;

            FDCDataElem.DeviceClass = deviceClass;
            ServiceResponseFDCdataAuthoriseFuelPoint[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseAuthoriseFuelPoint>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void ChangeFuelMode(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int mode, int status, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine(string.Format("init: deviceId={0}", deviceId));
            ServiceResponseChangeFuelMode SvRes = new ServiceResponseChangeFuelMode();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString(); ;
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataChangeFuelMode FDCDataElem = new ServiceResponseFDCdataChangeFuelMode();
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseDeviceClassChangeFuelMode deviceClass = new ServiceResponseDeviceClassChangeFuelMode();
            deviceClass.DeviceID = Convert.ToString(deviceId);
            deviceClass.PumpNo = Convert.ToString(deviceId);
            ////FDCPOSManager.tracer.WriteLine(string.Format("deviceId={0}, deviceClass.DeviceID={1}", deviceId, deviceClass.DeviceID));
            deviceClass.Type = deviceType; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;

            FDCDataElem.DeviceClass = deviceClass;
            ServiceResponseFDCdataChangeFuelMode[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseChangeFuelMode>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }
        //public bool ChangeFuelModeAdd(string workstationID, string applicationSender, int requestId, int deviceId, int mode, int status)
        //{
        //    try
        //    {
        //        //FDCPOSManager.tracer.WriteLine("init");
        //        ServiceResponseChangeFuelMode SvRes = null;
        //        string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "ChangeFuelMode";
        //        if (serviceResponseClientList.ContainsKey(key))
        //            SvRes = (ServiceResponseChangeFuelMode)(serviceResponseClientList[key]);
        //        if (SvRes == null)
        //        {
        //            SvRes = new ServiceResponseChangeFuelMode();
        //            SvRes.WorkstationID = workstationID;
        //            SvRes.ApplicationSender = applicationSender;
        //            SvRes.RequestID = requestId.ToString();
        //            serviceResponseClientList.Add(key, SvRes);
        //        }
        //        else
        //        {
        //            if (SvRes.RequestType != "ChangeFuelMode" || Convert.ToInt32(SvRes.RequestID) != requestId)
        //                return false;
        //        }

        //        ServiceResponseFDCdataChangeFuelMode FDCDataElem = null;
        //        if (SvRes.FDCdata != null)
        //            FDCDataElem = SvRes.FDCdata[0];
        //        else
        //        {
        //            ServiceResponseFDCdataChangeFuelMode[] FDCDataArray = null;
        //            FDCDataElem = new ServiceResponseFDCdataChangeFuelMode();
        //            Array.Resize<ServiceResponseFDCdataChangeFuelMode>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
        //            FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
        //            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
        //            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
        //            SvRes.FDCdata = FDCDataArray;
        //        }

        //        ServiceResponseDeviceClassChangeFuelMode fdcDeviceClassElem = null;
        //        if (FDCDataElem.DeviceClass != null)
        //        {
        //            foreach (ServiceResponseDeviceClassChangeFuelMode fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
        //                if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId))
        //                    fdcDeviceClassElem = fdcDeviceClassElemTemp;
        //        }
        //        if (fdcDeviceClassElem == null && deviceId > 0)
        //        {
        //            fdcDeviceClassElem = new ServiceResponseDeviceClassChangeFuelMode();
        //            fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
        //            fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
        //            fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;

        //            ServiceResponseDeviceClassChangeFuelMode[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
        //            Array.Resize<ServiceResponseDeviceClassChangeFuelMode>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
        //            fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
        //            FDCDataElem.DeviceClass = fdcDeviceClassArray;
        //        }
        //        //FDCPOSManager.tracer.WriteLine("end");
        //        return true;
        //    }
        //    catch (Exception ex)
        //    {
        //        //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
        //    }
        //    //FDCPOSManager.tracer.WriteLine("end");
        //    return false;
        //}
        //public bool ChangeFuelModeSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        //{
        //    try
        //    {
        //        //FDCPOSManager.tracer.WriteLine("init");
        //        ServiceResponseChangeFuelMode SvRes = null;
        //        string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "ChangeFuelMode";
        //        if (serviceResponseClientList.ContainsKey(key))
        //            SvRes = (ServiceResponseChangeFuelMode)(serviceResponseClientList[key]);
        //        if (SvRes != null)
        //        {
        //            if (SvRes.RequestType != "ChangeFuelMode" || Convert.ToInt32(SvRes.RequestID) != requestId)
        //                return false;
        //        }
        //        else
        //        {
        //            // send an empty response - no available data added
        //            SvRes = new ServiceResponseChangeFuelMode();
        //            SvRes.WorkstationID = workstationID;
        //            SvRes.ApplicationSender = applicationSender;
        //            SvRes.RequestID = requestId.ToString();
        //            serviceResponseClientList.Add(key, SvRes);

        //            ServiceResponseFDCdataChangeFuelMode FDCDataElem = new ServiceResponseFDCdataChangeFuelMode();
        //            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
        //            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
        //            ServiceResponseFDCdataChangeFuelMode[] FDCDataArray = { FDCDataElem };
        //            SvRes.FDCdata = FDCDataArray;
        //        }
        //        SvRes.OverallResult = overallResult;

        //        ((FDCPOSInterfaceServerManager)fdcposManager).respChannelAThreadObj.SendResponse<ServiceResponseChangeFuelMode>(fdcposManager.tcpClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
        //        serviceResponseClientList.Remove(key);
        //        //FDCPOSManager.tracer.WriteLine("end");
        //        return true;
        //    }
        //    catch (Exception ex)
        //    {
        //        //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
        //    }
        //    return false;
        //}


        //public void ChangeFuelPrice(string workstationID, string applicationSender, int requestId, int productId, decimal newprice, int mode, Decimal oldprice, string overallResult)
        //{
        //    //form.PriceSetText(Convert.ToString(newprice));

        //    //FDCPOSManager.tracer.WriteLine("init");
        //    ServiceResponseChangeFuelPrice SvRes = new ServiceResponseChangeFuelPrice();
        //    SvRes.WorkstationID = workstationID;
        //    SvRes.ApplicationSender = applicationSender;
        //    SvRes.RequestID = requestId.ToString();
        //    SvRes.OverallResult = overallResult;

        //    ServiceResponseFDCdataChangeFuelPrice FDCDataElem = new ServiceResponseFDCdataChangeFuelPrice();
        //    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

        //    ServiceResponseProductChangeFuelPrice product = new ServiceResponseProductChangeFuelPrice();
        //    product.EffectiveDateTime = DateTime.Now.ToString(Define.DateFormat);
        //    product.ModeNo = Convert.ToString(mode);
        //    product.ProductNo = Convert.ToString(productId);
        //    product.NewPrice = FDCConvert.ToString(newprice);
        //    product.OldPrice = FDCConvert.ToString(oldprice);

        //    FDCDataElem.Product = product;
        //    ServiceResponseFDCdataChangeFuelPrice[] FDCDataArray = { FDCDataElem };

        //    SvRes.FDCdata = FDCDataArray;

        //    ((FDCPOSInterfaceServerManager)fdcposManager).respChannelAThreadObj.SendResponse<ServiceResponseChangeFuelPrice>(fdcposManager.tcpClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
        //    //FDCPOSManager.tracer.WriteLine("end");
        //}
        public bool ChangeFuelPriceAdd(string workstationID, string applicationSender, int requestId, int productId, decimal newprice, int mode, string effectiveDateTime, Decimal oldprice)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseChangeFuelPrice SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "ChangeFuelPrice";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseChangeFuelPrice)(serviceResponseClientList[key]);
                if (SvRes == null)
                {
                    SvRes = new ServiceResponseChangeFuelPrice();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);
                }
                else
                {
                    if (SvRes.RequestType != "ChangeFuelPrice" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }

                ServiceResponseFDCdataChangeFuelPrice FDCDataElem = null;
                if (SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataChangeFuelPrice[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataChangeFuelPrice();
                    Array.Resize<ServiceResponseFDCdataChangeFuelPrice>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    SvRes.FDCdata = FDCDataArray;
                }

                ServiceResponseProductChangeFuelPrice fdcProductElem = null;
                if (FDCDataElem.Product != null)
                {
                    foreach (ServiceResponseProductChangeFuelPrice fdcProductElemTemp in FDCDataElem.Product)
                        if ((fdcProductElemTemp.ProductNo == Convert.ToString(productId) && fdcProductElemTemp.ModeNo == null) ||
                            (fdcProductElemTemp.ProductNo == Convert.ToString(productId) && fdcProductElemTemp.ModeNo == Convert.ToString(mode)))
                            fdcProductElem = fdcProductElemTemp;
                }
                if (fdcProductElem == null && productId > 0)
                {
                    fdcProductElem = new ServiceResponseProductChangeFuelPrice();
                    fdcProductElem.ProductNo = Convert.ToString(productId);

                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                    {
                        fdcProductElem.ModeNo = mode.ToString();
                        fdcProductElem.NewPrice = FDCConvert.ToString(newprice);
                        fdcProductElem.OldPrice = FDCConvert.ToString(oldprice);
                        fdcProductElem.EffectiveDateTime = effectiveDateTime;
                    }

                    ServiceResponseProductChangeFuelPrice[] fdcProductArray = FDCDataElem.Product;
                    Array.Resize<ServiceResponseProductChangeFuelPrice>(ref fdcProductArray, (fdcProductArray != null) ? fdcProductArray.Length + 1 : 1);
                    fdcProductArray[fdcProductArray.Length - 1] = fdcProductElem;
                    FDCDataElem.Product = fdcProductArray;
                }
                if (FDCGlobal.ProtocolVersion > FDCVersion.V0003)
                {
                    ServiceResponseFuelModeChangeFuelPrice fdcFuelModeElem = null;
                    if (fdcProductElem.FuelMode != null)
                    {
                        foreach (ServiceResponseFuelModeChangeFuelPrice fdcFuelModeElemTemp in fdcProductElem.FuelMode)
                            if ((fdcFuelModeElemTemp.ModeNo == Convert.ToString(mode)))
                                fdcFuelModeElem = fdcFuelModeElemTemp;
                    }
                    if (fdcFuelModeElem == null && mode > 0)
                    {
                        fdcFuelModeElem = new ServiceResponseFuelModeChangeFuelPrice();
                        fdcFuelModeElem.ModeNo = mode.ToString();
                        fdcFuelModeElem.NewPrice = FDCConvert.ToString(newprice);
                        if (FDCGlobal.ProtocolVersion == FDCVersion.V0005)
                            fdcFuelModeElem.OldPrice = FDCConvert.ToString(oldprice);
                        fdcProductElem.EffectiveDateTime = effectiveDateTime;

                        ServiceResponseFuelModeChangeFuelPrice[] fdcFuelModeArray = fdcProductElem.FuelMode;
                        Array.Resize<ServiceResponseFuelModeChangeFuelPrice>(ref fdcFuelModeArray, (fdcFuelModeArray != null) ? fdcFuelModeArray.Length + 1 : 1);
                        fdcFuelModeArray[fdcFuelModeArray.Length - 1] = fdcFuelModeElem;
                        fdcProductElem.FuelMode = fdcFuelModeArray;
                    }
                }

                //FDCPOSManager.tracer.WriteLine("end");
                return true;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");
            return false;
        }
        public bool ChangeFuelPriceSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseChangeFuelPrice SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "ChangeFuelPrice";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseChangeFuelPrice)(serviceResponseClientList[key]);
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "ChangeFuelPrice" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }
                else
                {
                    // send an empty response - no available data added
                    SvRes = new ServiceResponseChangeFuelPrice();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataChangeFuelPrice FDCDataElem = new ServiceResponseFDCdataChangeFuelPrice();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    FDCDataElem.Product = null;
                    ServiceResponseFDCdataChangeFuelPrice[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                SvRes.OverallResult = overallResult;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseChangeFuelPrice>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
                //FDCPOSManager.tracer.WriteLine("end");
                return true;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return false;
        }

        public void LockFuelSaleTrx(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken, int status, int fuellingState, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseLockFuelSaleTrx SvRes = new ServiceResponseLockFuelSaleTrx();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString(); ;
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataLockFuelSaleTrx FDCDataElem = new ServiceResponseFDCdataLockFuelSaleTrx();

            ServiceResponseDeviceClassLockFuelSaleTrx fdcDeviceClassElem = new ServiceResponseDeviceClassLockFuelSaleTrx();
            fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
            fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
            if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                fdcDeviceClassElem.TransactionNo = Convert.ToString(transactionNo);
            else
                fdcDeviceClassElem.TransactionSeqNo = Convert.ToString(transactionNo);
            if (this.fdcPosManager.useExtensions)
                fdcDeviceClassElem.ReleaseToken = releaseToken;
            fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
            if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                fdcDeviceClassElem.State = ((FuellingState)fuellingState).ToString();
            else
                fdcDeviceClassElem.State = ((FuellingState)fuellingState == FuellingState.Paid) ? FuellingState.Cleared.ToString() : ((FuellingState)fuellingState).ToString();

            FDCDataElem.DeviceClass = fdcDeviceClassElem;
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();


            ServiceResponseFDCdataLockFuelSaleTrx[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;
            if (fdcPosManager.fdcClientList.TryGetValue(FDCPOSClient.getClientID(workstationID, applicationSender), out FDCPOSClient cachedFdcPosClient))
                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseLockFuelSaleTrx>(cachedFdcPosClient, SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void UnlockFuelSaleTrx(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken, int status, int fuellingState, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseUnlockFuelSaleTrx SvRes = new ServiceResponseUnlockFuelSaleTrx();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString(); ;
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataBaseFuelSaleTrx FDCDataElem = new ServiceResponseFDCdataBaseFuelSaleTrx();

            ServiceResponseDeviceClassBaseFuelSaleTrx fdcDeviceClassElem = new ServiceResponseDeviceClassBaseFuelSaleTrx();
            fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
            fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
            if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                fdcDeviceClassElem.TransactionNo = Convert.ToString(transactionNo);
            else
                fdcDeviceClassElem.TransactionSeqNo = Convert.ToString(transactionNo);
            if (this.fdcPosManager.useExtensions)
                fdcDeviceClassElem.ReleaseToken = releaseToken;
            fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
            if (FDCGlobal.ProtocolVersion == FDCVersion.V0005)
                fdcDeviceClassElem.State = ((FuellingState)fuellingState == FuellingState.Paid) ? FuellingState.Cleared.ToString() : ((FuellingState)fuellingState).ToString();

            FDCDataElem.DeviceClass = fdcDeviceClassElem;
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseFDCdataBaseFuelSaleTrx[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;
            if (fdcPosManager.fdcClientList.TryGetValue(FDCPOSClient.getClientID(workstationID, applicationSender), out FDCPOSClient cachedFdcPosClient))
                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseUnlockFuelSaleTrx>(cachedFdcPosClient, SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void ClearFuelSaleTrx(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken, int status, int fuellingState, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseClearFuelSaleTrx SvRes = new ServiceResponseClearFuelSaleTrx();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString(); ;
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataBaseFuelSaleTrx FDCDataElem = new ServiceResponseFDCdataBaseFuelSaleTrx();

            ServiceResponseDeviceClassBaseFuelSaleTrx fdcDeviceClassElem = new ServiceResponseDeviceClassBaseFuelSaleTrx();
            fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
            fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
            if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                fdcDeviceClassElem.TransactionNo = Convert.ToString(transactionNo);
            else
                fdcDeviceClassElem.TransactionSeqNo = Convert.ToString(transactionNo);
            if (this.fdcPosManager.useExtensions)
                fdcDeviceClassElem.ReleaseToken = releaseToken;
            fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
            if (FDCGlobal.ProtocolVersion == FDCVersion.V0005)
                fdcDeviceClassElem.State = ((FuellingState)fuellingState == FuellingState.Paid) ? FuellingState.Cleared.ToString() : ((FuellingState)fuellingState).ToString();

            FDCDataElem.DeviceClass = fdcDeviceClassElem;
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseFDCdataBaseFuelSaleTrx[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;
            if (fdcPosManager.fdcClientList.TryGetValue(FDCPOSClient.getClientID(workstationID, applicationSender), out FDCPOSClient cachedFdcPosClient))
                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseClearFuelSaleTrx>(cachedFdcPosClient, SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public bool GetAvailableFuelSaleTrxsAdd(string workstationID, string applicationSender, int requestId, int deviceId, int transactionNo, string releaseToken, int state)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseGetAvailableFuelSaleTrxs SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetAvailableFuelSaleTrxs";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetAvailableFuelSaleTrxs)(serviceResponseClientList[key]);
                if (SvRes == null)
                {
                    SvRes = new ServiceResponseGetAvailableFuelSaleTrxs();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);
                }
                else
                {
                    if (SvRes.RequestType != "GetAvailableFuelSaleTrxs" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }

                ServiceResponseFDCdataGetAvailableFuelSaleTrxs FDCDataElem = null;
                if (SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetAvailableFuelSaleTrxs[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetAvailableFuelSaleTrxs();
                    Array.Resize<ServiceResponseFDCdataGetAvailableFuelSaleTrxs>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    SvRes.FDCdata = FDCDataArray;
                }

                ServiceResponseDeviceClassGetAvailableFuelSaleTrxs fdcDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceResponseDeviceClassGetAvailableFuelSaleTrxs fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if ((FDCGlobal.ProtocolVersion == FDCVersion.V0003 && fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId)) ||
                            (FDCGlobal.ProtocolVersion > FDCVersion.V0003 && fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId)) && fdcDeviceClassElemTemp.TransactionSeqNo == Convert.ToString(transactionNo) && fdcDeviceClassElemTemp.ReleaseToken == Convert.ToString(releaseToken))
                            fdcDeviceClassElem = fdcDeviceClassElemTemp;
                }
                if (fdcDeviceClassElem == null && deviceId > 0)
                {
                    fdcDeviceClassElem = new ServiceResponseDeviceClassGetAvailableFuelSaleTrxs();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
                    fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;

                    ServiceResponseDeviceClassGetAvailableFuelSaleTrxs[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceResponseDeviceClassGetAvailableFuelSaleTrxs>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                    fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                }

                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                {
                    ServiceResponseTransactionGetAvailableFuelSaleTrxs fdcTransactionElem = new ServiceResponseTransactionGetAvailableFuelSaleTrxs();
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                        fdcTransactionElem.TransactionNo = Convert.ToString(transactionNo);
                    else
                        fdcTransactionElem.TransactionSeqNo = Convert.ToString(transactionNo);
                    fdcTransactionElem.State = ((FuellingState)state).ToString();

                    ServiceResponseTransactionGetAvailableFuelSaleTrxs[] fdcTransactionArray = fdcDeviceClassElem.Transaction;
                    Array.Resize<ServiceResponseTransactionGetAvailableFuelSaleTrxs>(ref fdcTransactionArray, (fdcTransactionArray != null) ? fdcTransactionArray.Length + 1 : 1);
                    fdcTransactionArray[fdcTransactionArray.Length - 1] = fdcTransactionElem;
                    fdcDeviceClassElem.Transaction = fdcTransactionArray;
                }
                else
                {
                    fdcDeviceClassElem.TransactionSeqNo = Convert.ToString(transactionNo);
                    fdcDeviceClassElem.State = ((FuellingState)state == FuellingState.Paid) ? FuellingState.Cleared.ToString() : ((FuellingState)state).ToString();

                }
                if (this.fdcPosManager.useExtensions)
                    fdcDeviceClassElem.ReleaseToken = releaseToken;


                //FDCPOSManager.tracer.WriteLine("end");
                return true;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");
            return false;
        }

        public bool GetAvailableFuelSaleTrxsSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseGetAvailableFuelSaleTrxs SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetAvailableFuelSaleTrxs";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetAvailableFuelSaleTrxs)(serviceResponseClientList[key]);
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "GetAvailableFuelSaleTrxs" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }
                else
                {
                    // send an empty response - no available transaction added
                    SvRes = new ServiceResponseGetAvailableFuelSaleTrxs();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataGetAvailableFuelSaleTrxs FDCDataElem = new ServiceResponseFDCdataGetAvailableFuelSaleTrxs();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    ServiceResponseFDCdataGetAvailableFuelSaleTrxs[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                SvRes.OverallResult = overallResult;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetAvailableFuelSaleTrxs>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
                //FDCPOSManager.tracer.WriteLine("end");
                return true;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return false;
        }

        public bool GetFuelSaleTrxDetailsAdd(string workstationID, string applicationSender, int requestId, int deviceId, decimal volume, decimal amount, decimal price, int nozzle, int productNo, string productName, string productUM, int mode, int transactionId, string releaseToken, int state, string startTime, string endTime, string lockingAS, string authorisationAS, int reservingDeviceId, int fuellingType)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine(string.Format("init: pumpid={0}, trid={1}, releaseToken={2}", deviceId, transactionId, releaseToken));

                if (FDCGlobal.ProtocolVersion > FDCVersion.V0003)
                {
                    ServiceResponseGetFuelSaleTrxDetails SvRes = null;
                    string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetFuelSaleTrxDetails";
                    if (serviceResponseClientList.ContainsKey(key))
                        SvRes = (ServiceResponseGetFuelSaleTrxDetails)(serviceResponseClientList[key]);
                    if (SvRes == null)
                    {
                        SvRes = new ServiceResponseGetFuelSaleTrxDetails();
                        SvRes.WorkstationID = workstationID;
                        SvRes.ApplicationSender = applicationSender;
                        SvRes.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvRes);
                    }
                    else
                    {
                        if (SvRes.RequestType != "GetFuelSaleTrxDetails" || Convert.ToInt32(SvRes.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                            return false;
                        }
                    }

                    ServiceResponseFDCdataGetFuelSaleTrxDetails FDCDataElem = null;
                    if (SvRes.FDCdata != null)
                        FDCDataElem = SvRes.FDCdata[0];
                    else
                    {
                        ServiceResponseFDCdataGetFuelSaleTrxDetails[] FDCDataArray = null;
                        FDCDataElem = new ServiceResponseFDCdataGetFuelSaleTrxDetails();
                        Array.Resize<ServiceResponseFDCdataGetFuelSaleTrxDetails>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                        FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                        FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                        SvRes.FDCdata = FDCDataArray;
                    }

                    ServiceResponseDeviceClassGetFuelSaleTrxDetails fdcDeviceClassElem = null;
                    if (FDCDataElem.DeviceClass != null)
                    {
                        //FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4), string.Format("FDCDataElem.DeviceClass != null - count={0} - looping", FDCDataElem.DeviceClass.GetLength(0)));
                        foreach (ServiceResponseDeviceClassGetFuelSaleTrxDetails fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        {
                            //string transactionNo = (fdcDeviceClassElemTemp.TransactionNo != null) ? fdcDeviceClassElemTemp.TransactionNo : ((fdcDeviceClassElemTemp.TransactionSeqNo != null) ? fdcDeviceClassElemTemp.TransactionSeqNo : "");
                            string transactionNo = (fdcDeviceClassElemTemp.TransactionSeqNo != null) ? fdcDeviceClassElemTemp.TransactionSeqNo : "";
                            //FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4), string.Format("read temp_pumpid={0}, temp_trid={1}", fdcDeviceClassElemTemp.DeviceID, transactionNo));
                            if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) && transactionNo == Convert.ToString(transactionId) && fdcDeviceClassElemTemp.TransactionSeqNo == releaseToken)
                            {
                                //FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4), string.Format("FOUND! temp_pumpid={0}, temp_trid={1}, temp_releaseToken={2}", fdcDeviceClassElemTemp.DeviceID, transactionNo, fdcDeviceClassElemTemp.TransactionSeqNo));
                                fdcDeviceClassElem = fdcDeviceClassElemTemp;
                            }
                        }
                    }
                    else
                    //FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4), string.Format("FDCDataElem.DeviceClass == null"));
                    if (fdcDeviceClassElem == null && deviceId > 0)
                    {
                        fdcDeviceClassElem = new ServiceResponseDeviceClassGetFuelSaleTrxDetails();
                        fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                        fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
                        fdcDeviceClassElem.NozzleNo = Convert.ToString(nozzle);
                        fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
                        //if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                        //    fdcDeviceClassElem.TransactionNo = Convert.ToString(transactionId);
                        //else
                        fdcDeviceClassElem.TransactionSeqNo = Convert.ToString(transactionId);
                        fdcDeviceClassElem.State = ((FuellingState)state == FuellingState.Paid) ? FuellingState.Cleared.ToString() : ((FuellingState)state).ToString();
                        fdcDeviceClassElem.ReleaseToken = releaseToken;
                        fdcDeviceClassElem.TypePOS = "";
                        //if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                        //{
                        FuelModeElementClass fuelMode = new FuelModeElementClass();
                        fuelMode.ModeNo = (mode == -1) ? "" : Convert.ToString(mode);
                        fdcDeviceClassElem.FuelMode = fuelMode;
                        //}
                        fdcDeviceClassElem.VolumeProduct1 = FDCConvert.ToString(volume);
                        fdcDeviceClassElem.VolumeProduct2 = FDCConvert.ToString((Decimal)0);
                        fdcDeviceClassElem.ProductNo1 = Convert.ToString(productNo);
                        fdcDeviceClassElem.ProductNo2 = "";
                        if (this.fdcPosManager.useExtensions)
                        {
                            fdcDeviceClassElem.ProductName = productName;
                            fdcDeviceClassElem.ProductUM = productUM;
                        }
                        fdcDeviceClassElem.BlendRatio = FDCConvert.ToString((Decimal)100);
                        fdcDeviceClassElem.Amount = FDCConvert.ToString(amount);
                        fdcDeviceClassElem.Volume = FDCConvert.ToString(volume);
                        fdcDeviceClassElem.UnitPrice = FDCConvert.ToString(price);
                        fdcDeviceClassElem.StartTimeStamp = startTime;
                        fdcDeviceClassElem.EndTimeStamp = endTime;
                        //if (FDCGlobal.ProtocolVersion > FDCVersion.V0003)
                        //{
                        fdcDeviceClassElem.AuthorisationApplicationSender = authorisationAS;
                        fdcDeviceClassElem.LockingApplicationSender = lockingAS;
                        //}
                        if (this.fdcPosManager.useExtensions)
                        {
                            fdcDeviceClassElem.ReservingDeviceId = Convert.ToString(reservingDeviceId);
                            fdcDeviceClassElem.FuellingType = Convert.ToString(fuellingType);
                        }
                        FuellingInfo fuellingInfo = new FuellingInfo(deviceId, nozzle, productNo, productName, productUM, amount, volume, price, DateTime.Parse(endTime), transactionId);
                        fdcDeviceClassElem.DSPFields = fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)].getDSPFields(fuellingInfo);
                        fdcDeviceClassElem.CRCMode = fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)].getCRC(fuellingInfo);

                        ServiceResponseDeviceClassGetFuelSaleTrxDetails[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                        Array.Resize<ServiceResponseDeviceClassGetFuelSaleTrxDetails>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                        fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
                        FDCDataElem.DeviceClass = fdcDeviceClassArray;
                    }
                }
                else
                {
                    ServiceResponseGetFuelSaleTrxDetailsV03 SvRes = null;
                    string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetFuelSaleTrxDetails";
                    if (serviceResponseClientList.ContainsKey(key))
                        SvRes = (ServiceResponseGetFuelSaleTrxDetailsV03)(serviceResponseClientList[key]);
                    if (SvRes == null)
                    {
                        SvRes = new ServiceResponseGetFuelSaleTrxDetailsV03();
                        SvRes.WorkstationID = workstationID;
                        SvRes.ApplicationSender = applicationSender;
                        SvRes.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvRes);
                    }
                    else
                    {
                        if (SvRes.RequestType != "GetFuelSaleTrxDetails" || Convert.ToInt32(SvRes.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                            return false;
                        }
                    }

                    ServiceResponseFDCdataGetFuelSaleTrxDetailsV03 FDCDataElem = null;
                    if (SvRes.FDCdata != null)
                        FDCDataElem = SvRes.FDCdata[0];
                    else
                    {
                        ServiceResponseFDCdataGetFuelSaleTrxDetailsV03[] FDCDataArray = null;
                        FDCDataElem = new ServiceResponseFDCdataGetFuelSaleTrxDetailsV03();
                        Array.Resize<ServiceResponseFDCdataGetFuelSaleTrxDetailsV03>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                        FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                        FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                        SvRes.FDCdata = FDCDataArray;
                    }

                    ServiceResponseDeviceClassGetFuelSaleTrxDetailsV03 fdcDeviceClassElem = null;
                    if (FDCDataElem.DeviceClass != null)
                    {
                        //FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4), string.Format("FDCDataElem.DeviceClass != null - count={0} - looping", FDCDataElem.DeviceClass.GetLength(0)));
                        foreach (ServiceResponseDeviceClassGetFuelSaleTrxDetailsV03 fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        {
                            string transactionNo = (fdcDeviceClassElemTemp.TransactionNo != null) ? fdcDeviceClassElemTemp.TransactionNo : "";
                            //FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4), string.Format("read temp_pumpid={0}, temp_trid={1}", fdcDeviceClassElemTemp.DeviceID, transactionNo));
                            if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) && transactionNo == Convert.ToString(transactionId))
                            {
                                //FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4), string.Format("FOUND! temp_pumpid={0}, temp_trid={1}", fdcDeviceClassElemTemp.DeviceID, transactionNo));
                                fdcDeviceClassElem = fdcDeviceClassElemTemp;
                            }
                        }
                    }
                    else
                    //FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(4), string.Format("FDCDataElem.DeviceClass == null"));
                    if (fdcDeviceClassElem == null && deviceId > 0)
                    {
                        fdcDeviceClassElem = new ServiceResponseDeviceClassGetFuelSaleTrxDetailsV03();
                        fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                        fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
                        fdcDeviceClassElem.NozzleNo = Convert.ToString(nozzle);
                        fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint; // Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
                        fdcDeviceClassElem.TransactionNo = Convert.ToString(transactionId);
                        fdcDeviceClassElem.State = ((FuellingState)state).ToString();
                        fdcDeviceClassElem.ReleaseToken = releaseToken;
                        fdcDeviceClassElem.TypePOS = "";
                        fdcDeviceClassElem.FuelMode = Convert.ToString(mode);
                        fdcDeviceClassElem.VolumeProduct1 = FDCConvert.ToString(volume);
                        fdcDeviceClassElem.VolumeProduct2 = FDCConvert.ToString((Decimal)0);
                        fdcDeviceClassElem.Product1No = Convert.ToString(productNo);
                        fdcDeviceClassElem.Product2No = "";
                        if (this.fdcPosManager.useExtensions)
                        {
                            fdcDeviceClassElem.ProductName = productName;
                            fdcDeviceClassElem.ProductUM = productUM;
                        }
                        fdcDeviceClassElem.BlendRatio = FDCConvert.ToString((Decimal)100);
                        fdcDeviceClassElem.Amount = FDCConvert.ToString(amount);
                        fdcDeviceClassElem.Volume = FDCConvert.ToString(volume);
                        fdcDeviceClassElem.UnitPrice = FDCConvert.ToString(price);
                        fdcDeviceClassElem.StartTimeStamp = startTime;
                        fdcDeviceClassElem.EndTimeStamp = endTime;
                        FuellingInfo fuellingInfo = new FuellingInfo(deviceId, nozzle, productNo, productName, productUM, amount, volume, price, DateTime.Parse(endTime), transactionId);
                        fdcDeviceClassElem.DSPFields = fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)].getDSPFields(fuellingInfo);
                        fdcDeviceClassElem.CRCMode = fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)].getCRC(fuellingInfo);

                        ServiceResponseDeviceClassGetFuelSaleTrxDetailsV03[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                        Array.Resize<ServiceResponseDeviceClassGetFuelSaleTrxDetailsV03>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                        fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
                        FDCDataElem.DeviceClass = fdcDeviceClassArray;
                    }

                }
                //FDCPOSManager.tracer.WriteLine("end");
                return true;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");
            return false;
        }

        public bool GetFuelSaleTrxDetailsSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseGetFuelSaleTrxDetails SvRes = null;
                ServiceResponseGetFuelSaleTrxDetailsV03 SvResV03 = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetFuelSaleTrxDetails";
                if (serviceResponseClientList.ContainsKey(key))
                {
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                    {
                        SvResV03 = (ServiceResponseGetFuelSaleTrxDetailsV03)(serviceResponseClientList[key]);
                        if (SvResV03 != null)
                        {
                            if (SvResV03.RequestType != "GetFuelSaleTrxDetails" || Convert.ToInt32(SvResV03.RequestID) != requestId)
                            {
                                //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvResV03.RequestID, requestId));
                                return false;
                            }
                        }
                    }
                    else
                    {
                        SvRes = (ServiceResponseGetFuelSaleTrxDetails)(serviceResponseClientList[key]);
                        if (SvRes != null)
                        {
                            if (SvRes.RequestType != "GetFuelSaleTrxDetails" || Convert.ToInt32(SvRes.RequestID) != requestId)
                            {
                                //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                                return false;
                            }
                        }
                    }
                }

                // in that case can build the same object because FuelMode is not created
                if (FDCGlobal.ProtocolVersion > FDCVersion.V0003 && SvRes == null)
                {
                    SvRes = new ServiceResponseGetFuelSaleTrxDetails();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataGetFuelSaleTrxDetails FDCDataElem = new ServiceResponseFDCdataGetFuelSaleTrxDetails();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    ServiceResponseFDCdataGetFuelSaleTrxDetails[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                else if (FDCGlobal.ProtocolVersion == FDCVersion.V0003 && SvResV03 == null)
                {
                    SvResV03 = new ServiceResponseGetFuelSaleTrxDetailsV03();
                    SvResV03.WorkstationID = workstationID;
                    SvResV03.ApplicationSender = applicationSender;
                    SvResV03.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvResV03);

                    ServiceResponseFDCdataGetFuelSaleTrxDetailsV03 FDCDataElem = new ServiceResponseFDCdataGetFuelSaleTrxDetailsV03();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    ServiceResponseFDCdataGetFuelSaleTrxDetailsV03[] FDCDataArray = { FDCDataElem };
                    SvResV03.FDCdata = FDCDataArray;
                }
                if (FDCGlobal.ProtocolVersion > FDCVersion.V0003)
                {
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                    SvRes.OverallResult = overallResult;
                    ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetFuelSaleTrxDetails>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                }
                else
                {
                    SvResV03.OverallResult = overallResult;
                    ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetFuelSaleTrxDetailsV03>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvResV03);
                }

                serviceResponseClientList.Remove(key);
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");
            return true;
        }

        public bool GetProductTableAdd(string workstationID, string applicationSender, int requestId, int productNo, string ProductName)
        {
            try
            {
                ServiceResponseGetProductTable SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetProductTable";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetProductTable)(serviceResponseClientList[key]);
                if (SvRes == null)
                {
                    SvRes = new ServiceResponseGetProductTable();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);
                }
                else
                {
                    if (SvRes.RequestType != "GetProductTable" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }

                ServiceResponseFDCdataGetProductTable FDCDataElem = null;
                if (SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetProductTable[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetProductTable();
                    Array.Resize<ServiceResponseFDCdataGetProductTable>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    SvRes.FDCdata = FDCDataArray;
                }

                ServiceResponseFuelProductsGetProductTable fdcFuelProductsElem = null;
                if (FDCDataElem.FuelProducts != null)
                {
                    fdcFuelProductsElem = FDCDataElem.FuelProducts[0];
                }
                if (fdcFuelProductsElem == null)
                {
                    fdcFuelProductsElem = new ServiceResponseFuelProductsGetProductTable();

                    ServiceResponseFuelProductsGetProductTable[] fdcFuelProductArray = FDCDataElem.FuelProducts;
                    Array.Resize<ServiceResponseFuelProductsGetProductTable>(ref fdcFuelProductArray, (fdcFuelProductArray != null) ? fdcFuelProductArray.Length + 1 : 1);
                    fdcFuelProductArray[fdcFuelProductArray.Length - 1] = fdcFuelProductsElem;
                    FDCDataElem.FuelProducts = fdcFuelProductArray;
                }

                ServiceResponseProductGetProductTable fdcProductElem = new ServiceResponseProductGetProductTable();
                fdcProductElem.ProductNo = Convert.ToString(productNo);
                fdcProductElem.ProductName = ProductName;

                ServiceResponseProductGetProductTable[] fdcProductArray = fdcFuelProductsElem.Product;
                Array.Resize<ServiceResponseProductGetProductTable>(ref fdcProductArray, (fdcProductArray != null) ? fdcProductArray.Length + 1 : 1);
                fdcProductArray[fdcProductArray.Length - 1] = fdcProductElem;
                fdcFuelProductsElem.Product = fdcProductArray;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return true;
        }

        public bool GetProductTableSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                ServiceResponseGetProductTable SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetProductTable";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetProductTable)(serviceResponseClientList[key]);
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "GetProductTable" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }
                else
                {
                    // send an empty response - no available transaction added
                    SvRes = new ServiceResponseGetProductTable();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataGetProductTable FDCDataElem = new ServiceResponseFDCdataGetProductTable();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

                    ServiceResponseFDCdataGetProductTable[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                SvRes.OverallResult = overallResult;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetProductTable>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return true;
        }

        public bool GetModeTableAdd(string workstationID, string applicationSender, int requestId, int modeNo, string ModeName)
        {
            try
            {
                ServiceResponseGetModeTable SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetModeTable";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetModeTable)(serviceResponseClientList[key]);
                if (SvRes == null)
                {
                    SvRes = new ServiceResponseGetModeTable();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);
                }
                else
                {
                    if (SvRes.RequestType != "GetModeTable" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }

                ServiceResponseFDCdataGetModeTable FDCDataElem = null;
                if (SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetModeTable[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetModeTable();
                    Array.Resize<ServiceResponseFDCdataGetModeTable>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    SvRes.FDCdata = FDCDataArray;
                }

                ServiceResponseFuelModeGetModeTable FuelModeElem = new ServiceResponseFuelModeGetModeTable();
                ServiceResponseFuelModeGetModeTable[] FuelModeArray = null;
                if (FDCDataElem.FuelMode != null)
                {
                    FuelModeArray = FDCDataElem.FuelMode;
                }
                Array.Resize<ServiceResponseFuelModeGetModeTable>(ref FuelModeArray, (FuelModeArray != null) ? FuelModeArray.Length + 1 : 1);
                FuelModeArray[FuelModeArray.Length - 1] = FuelModeElem;
                FDCDataElem.FuelMode = FuelModeArray;

                FuelModeElem.ModeNo = Convert.ToString(modeNo);
                FuelModeElem.ModeName = ModeName;

            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return true;
        }

        public bool GetModeTableSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                ServiceResponseGetModeTable SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetModeTable";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetModeTable)(serviceResponseClientList[key]);
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "GetModeTable" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }
                else
                {
                    // send an empty response - no available transaction added
                    SvRes = new ServiceResponseGetModeTable();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataGetModeTable FDCDataElem = new ServiceResponseFDCdataGetModeTable();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

                    ServiceResponseFDCdataGetModeTable[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                SvRes.OverallResult = overallResult;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetModeTable>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return true;
        }

        public bool GetFuelModeAdd(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int modeNo)
        {
            try
            {
                ServiceResponseGetFuelMode SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetFuelMode";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetFuelMode)(serviceResponseClientList[key]);
                if (SvRes == null)
                {
                    SvRes = new ServiceResponseGetFuelMode();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);
                }
                else
                {
                    if (SvRes.RequestType != "GetFuelMode" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }

                ServiceResponseFDCdataGetFuelMode FDCDataElem = null;
                if (SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetFuelMode[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetFuelMode();
                    Array.Resize<ServiceResponseFDCdataGetFuelMode>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    SvRes.FDCdata = FDCDataArray;
                }

                ServiceResponseDeviceClassGetFuelMode fdcDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceResponseDeviceClassGetFuelMode fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId))
                            fdcDeviceClassElem = fdcDeviceClassElemTemp;
                }
                if (fdcDeviceClassElem == null && deviceId > 0)
                {
                    fdcDeviceClassElem = new ServiceResponseDeviceClassGetFuelMode();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.PumpNo = Convert.ToString(deviceId);
                    fdcDeviceClassElem.Type = deviceType; //Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                        fdcDeviceClassElem.ModeNo = (modeNo == -1) ? "" : Convert.ToString(modeNo);
                    else
                    {
                        FuelModeElementClass fuelMode = new FuelModeElementClass();
                        fuelMode.ModeNo = (modeNo == -1) ? "" : Convert.ToString(modeNo);
                        fdcDeviceClassElem.FuelMode = fuelMode;
                    }
                    ServiceResponseDeviceClassGetFuelMode[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceResponseDeviceClassGetFuelMode>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                    fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                }

                //ServiceResponseModeNoGetFuelMode fdcModeNoElem = new ServiceResponseModeNoGetFuelMode();
                //fdcModeNoElem.ModeNo = ModeNo;

                //ServiceResponseModeNoGetFuelMode[] fdcModeNoArray = fdcDeviceClassElem.ModeNo;
                //Array.Resize<ServiceResponseModeNoGetFuelMode>(ref fdcModeNoArray, (fdcModeNoArray != null) ? fdcModeNoArray.Length + 1 : 1);
                //fdcModeNoArray[fdcModeNoArray.Length - 1] = fdcModeNoElem;
                //fdcDeviceClassElem.ModeNo = fdcModeNoArray;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return true;
        }

        public bool GetFuelModeSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                ServiceResponseGetFuelMode SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetFuelMode";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetFuelMode)(serviceResponseClientList[key]);
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "GetFuelMode" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }
                else
                {
                    // send an empty response - no available transaction added
                    SvRes = new ServiceResponseGetFuelMode();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataGetFuelMode FDCDataElem = new ServiceResponseFDCdataGetFuelMode();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    ServiceResponseFDCdataGetFuelMode[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                SvRes.OverallResult = overallResult;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetFuelMode>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return true;
        }

        public bool GetConfigurationAddDSP(string workstationID, string applicationSender, int requestId, int deviceId, int productNo, string ProductName, int fuelPriceModeNo, decimal fuelPrice)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseGetConfiguration SvRes = null;
                ServiceResponseGetDSPConfiguration SvResDSP = null;
                string commandName = (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration) ? "GetConfiguration" : "GetDSPConfiguration";
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + commandName;
                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration)
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvRes = (ServiceResponseGetConfiguration)(serviceResponseClientList[key]);
                    if (SvRes == null)
                    {
                        SvRes = new ServiceResponseGetConfiguration();
                        SvRes.WorkstationID = workstationID;
                        SvRes.ApplicationSender = applicationSender;
                        SvRes.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvRes);
                    }
                    else
                    {
                        if (SvRes.RequestType != "GetConfiguration" || Convert.ToInt32(SvRes.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                            return false;
                        }
                    }
                }
                else
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResDSP = (ServiceResponseGetDSPConfiguration)(serviceResponseClientList[key]);
                    if (SvResDSP == null)
                    {
                        SvResDSP = new ServiceResponseGetDSPConfiguration();
                        SvResDSP.WorkstationID = workstationID;
                        SvResDSP.ApplicationSender = applicationSender;
                        SvResDSP.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResDSP);
                    }
                    else
                    {
                        if (SvResDSP.RequestType != "GetDSPConfiguration" || Convert.ToInt32(SvResDSP.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvResDSP.RequestID={0}, requestId={1} - end false", SvResDSP.RequestID, requestId));
                            return false;
                        }
                    }
                }

                ServiceResponseFDCdataGetConfiguration FDCDataElem = null;
                if (SvRes != null && SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else if (SvResDSP != null && SvResDSP.FDCdata != null)
                    FDCDataElem = SvResDSP.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetConfiguration[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetConfiguration();
                    Array.Resize<ServiceResponseFDCdataGetConfiguration>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    if (SvRes != null)
                        SvRes.FDCdata = FDCDataArray;
                    else if (SvResDSP != null)
                        SvResDSP.FDCdata = FDCDataArray;
                }

                ServiceDeviceClassConfiguration fdcDSPDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceDeviceClassConfiguration fdcDSPDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcDSPDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) && fdcDSPDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser)
                            fdcDSPDeviceClassElem = fdcDSPDeviceClassElemTemp;
                }
                if (fdcDSPDeviceClassElem == null)
                {
                    fdcDSPDeviceClassElem = new ServiceDeviceClassConfiguration();
                    fdcDSPDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDSPDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;

                    ServiceDeviceClassConfiguration[] fdcDSPDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceDeviceClassConfiguration>(ref fdcDSPDeviceClassArray, (fdcDSPDeviceClassArray != null) ? fdcDSPDeviceClassArray.Length + 1 : 1);
                    fdcDSPDeviceClassArray[fdcDSPDeviceClassArray.Length - 1] = fdcDSPDeviceClassElem;
                    FDCDataElem.DeviceClass = fdcDSPDeviceClassArray;
                }

                ServiceProductDSPDeviceClassConfiguration DSPProductElem = null;
                if (fdcDSPDeviceClassElem.DSPProduct != null)
                {
                    foreach (ServiceProductDSPDeviceClassConfiguration DSPProductDeviceClassElemTemp in fdcDSPDeviceClassElem.DSPProduct)
                        if (DSPProductDeviceClassElemTemp.DSPProductNo == Convert.ToString(productNo))
                            DSPProductElem = DSPProductDeviceClassElemTemp;
                }
                if (DSPProductElem == null)
                {
                    DSPProductElem = new ServiceProductDSPDeviceClassConfiguration();
                    DSPProductElem.DSPProductNo = Convert.ToString(productNo);
                    DSPProductElem.DSPProductName = ProductName;

                    ServiceProductDSPDeviceClassConfiguration[] DSPProductDeviceClassArray = fdcDSPDeviceClassElem.DSPProduct;
                    Array.Resize<ServiceProductDSPDeviceClassConfiguration>(ref DSPProductDeviceClassArray, (DSPProductDeviceClassArray != null) ? DSPProductDeviceClassArray.Length + 1 : 1);
                    DSPProductDeviceClassArray[DSPProductDeviceClassArray.Length - 1] = DSPProductElem;
                    fdcDSPDeviceClassElem.DSPProduct = DSPProductDeviceClassArray;
                }

                ServiceFuelPriceDSPDeviceClassConfiguration DSPFuelPriceElem = new ServiceFuelPriceDSPDeviceClassConfiguration();
                DSPFuelPriceElem.FPDSPModeNo = Convert.ToString(fuelPriceModeNo);
                DSPFuelPriceElem.FPDSPPrice = FDCConvert.ToString(fuelPrice);

                ServiceFuelPriceDSPDeviceClassConfiguration[] DSPFuelPriceArray = DSPProductElem.DSPFuelPrice;
                Array.Resize<ServiceFuelPriceDSPDeviceClassConfiguration>(ref DSPFuelPriceArray, (DSPFuelPriceArray != null) ? DSPFuelPriceArray.Length + 1 : 1);
                DSPFuelPriceArray[DSPFuelPriceArray.Length - 1] = DSPFuelPriceElem;
                DSPProductElem.DSPFuelPrice = DSPFuelPriceArray;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");

            return true;
        }

        public bool GetConfigurationAddFP(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int nozzleNo, int productNo1, int productNo2, decimal blendRatio, int blendProductNo)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");

                ServiceResponseGetConfiguration SvRes = null;
                ServiceResponseGetDSPConfiguration SvResDSP = null;
                string commandName = (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration) ? "GetConfiguration" : "GetDSPConfiguration";
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + commandName;
                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration)
                {

                    if (serviceResponseClientList.ContainsKey(key))
                        SvRes = (ServiceResponseGetConfiguration)(serviceResponseClientList[key]);
                    if (SvRes == null)
                    {
                        SvRes = new ServiceResponseGetConfiguration();
                        SvRes.WorkstationID = workstationID;
                        SvRes.ApplicationSender = applicationSender;
                        SvRes.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvRes);
                    }
                    else
                    {
                        if (SvRes.RequestType != "GetConfiguration" || Convert.ToInt32(SvRes.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                            return false;
                        }
                    }
                }
                else
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResDSP = (ServiceResponseGetDSPConfiguration)(serviceResponseClientList[key]);
                    if (SvResDSP == null)
                    {
                        SvResDSP = new ServiceResponseGetDSPConfiguration();
                        SvResDSP.WorkstationID = workstationID;
                        SvResDSP.ApplicationSender = applicationSender;
                        SvResDSP.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResDSP);
                    }
                    else
                    {
                        if (SvResDSP.RequestType != "GetDSPConfiguration" || Convert.ToInt32(SvResDSP.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvResDSP.RequestID={0}, requestId={1} - end false", SvResDSP.RequestID, requestId));
                            return false;
                        }
                    }
                }


                ServiceResponseFDCdataGetConfiguration FDCDataElem = null;
                if (SvRes != null && SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else if (SvResDSP != null && SvResDSP.FDCdata != null)
                    FDCDataElem = SvResDSP.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetConfiguration[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetConfiguration();
                    Array.Resize<ServiceResponseFDCdataGetConfiguration>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    if (SvRes != null)
                        SvRes.FDCdata = FDCDataArray;
                    else if (SvResDSP != null)
                        SvResDSP.FDCdata = FDCDataArray;
                }

                ServiceDeviceClassConfiguration fdcFPDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null && (FDCGlobal.ProtocolVersion < FDCVersion.V0007 || Messages.bWholeConfiguration))
                {
                    foreach (ServiceDeviceClassConfiguration fdcFPDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcFPDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) &&
                            fdcFPDeviceClassElemTemp.FPPumpNo == Convert.ToString(pumpNo) &&
                            fdcFPDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("DT_FuellingPoint deviceId={0} found", deviceId));
                            fdcFPDeviceClassElem = fdcFPDeviceClassElemTemp;
                        }
                }
                else if (FDCDataElem.DeviceClass != null && FDCGlobal.ProtocolVersion >= FDCVersion.V0007)
                {
                    ServiceDeviceClassConfiguration fdcFDCDeviceClassElem = null;
                    foreach (ServiceDeviceClassConfiguration fdcFDCDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcFDCDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) &&
                            fdcFDCDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format(">=V0007 - DT_FuelDispenser deviceId={0} found", deviceId));
                            fdcFDCDeviceClassElem = fdcFDCDeviceClassElemTemp;
                            if (fdcFDCDeviceClassElem.DeviceClass != null)
                            {
                                foreach (ServiceDeviceClassConfiguration fdcFPDeviceClassElemTemp in fdcFDCDeviceClassElem.DeviceClass)
                                    if (fdcFPDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) &&
                                        fdcFPDeviceClassElemTemp.FPPumpNo == Convert.ToString(pumpNo) &&
                                        fdcFPDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint)
                                    {
                                        //FDCPOSManager.tracer.WriteLine(string.Format("DT_FuellingPoint deviceId={0} found", deviceId));
                                        fdcFPDeviceClassElem = fdcFPDeviceClassElemTemp;
                                    }
                            }
                        }
                }
                if (fdcFPDeviceClassElem == null)
                {
                    //FDCPOSManager.tracer.WriteLine(string.Format("DT_FuellingPoint deviceId={0} create", deviceId));
                    fdcFPDeviceClassElem = new ServiceDeviceClassConfiguration();
                    fdcFPDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcFPDeviceClassElem.FPPumpNo = Convert.ToString(pumpNo);
                    fdcFPDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                    if (FDCGlobal.ProtocolVersion < FDCVersion.V0007 || Messages.bWholeConfiguration)
                    {
                        ServiceDeviceClassConfiguration[] fdcFPDeviceClassArray = FDCDataElem.DeviceClass;
                        Array.Resize<ServiceDeviceClassConfiguration>(ref fdcFPDeviceClassArray, (fdcFPDeviceClassArray != null) ? fdcFPDeviceClassArray.Length + 1 : 1);
                        fdcFPDeviceClassArray[fdcFPDeviceClassArray.Length - 1] = fdcFPDeviceClassElem;
                        FDCDataElem.DeviceClass = fdcFPDeviceClassArray;

                        //FDCPOSManager.tracer.WriteLine("<V0007 - array resized");
                    }
                    else
                    {
                        //ServiceDeviceClassConfiguration fdcDSPDeviceClassElem = null;
                        foreach (ServiceDeviceClassConfiguration fdcDSPDeviceClassElemTemp in FDCDataElem.DeviceClass)
                            if (fdcDSPDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) && fdcDSPDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser)
                            {
                                ServiceDeviceClassConfiguration[] fdcFPDeviceClassArray = fdcDSPDeviceClassElemTemp.DeviceClass;
                                Array.Resize<ServiceDeviceClassConfiguration>(ref fdcFPDeviceClassArray, (fdcFPDeviceClassArray != null) ? fdcFPDeviceClassArray.Length + 1 : 1);
                                fdcFPDeviceClassArray[fdcFPDeviceClassArray.Length - 1] = fdcFPDeviceClassElem;
                                fdcDSPDeviceClassElemTemp.DeviceClass = fdcFPDeviceClassArray;

                                //FDCPOSManager.tracer.WriteLine(">=V0007 - array resized");
                            }
                    }
                }

                ServiceNozzleFPDeviceClassConfiguration FPNozzleElem = null;
                if (fdcFPDeviceClassElem.FPNozzle != null)
                {
                    foreach (ServiceNozzleFPDeviceClassConfiguration FPNozzleDeviceClassElemTemp in fdcFPDeviceClassElem.FPNozzle)
                        if (FPNozzleDeviceClassElemTemp.FPNozzleNo == Convert.ToString(nozzleNo))
                            FPNozzleElem = FPNozzleDeviceClassElemTemp;
                }
                if (FPNozzleElem == null)
                {
                    FPNozzleElem = new ServiceNozzleFPDeviceClassConfiguration();
                    FPNozzleElem.FPNozzleNo = Convert.ToString(nozzleNo);

                    ServiceNozzleFPDeviceClassConfiguration[] FPNozzleDeviceClassArray = fdcFPDeviceClassElem.FPNozzle;
                    Array.Resize<ServiceNozzleFPDeviceClassConfiguration>(ref FPNozzleDeviceClassArray, (FPNozzleDeviceClassArray != null) ? FPNozzleDeviceClassArray.Length + 1 : 1);
                    FPNozzleDeviceClassArray[FPNozzleDeviceClassArray.Length - 1] = FPNozzleElem;
                    fdcFPDeviceClassElem.FPNozzle = FPNozzleDeviceClassArray;
                }

                ServiceProductIdFPDeviceClassConfiguration FPProductIdElem = new ServiceProductIdFPDeviceClassConfiguration();
                FPProductIdElem.PIFPProductNo1 = Convert.ToString(productNo1);
                FPProductIdElem.PIFPProductNo2 = Convert.ToString(productNo2);
                FPProductIdElem.PIFPBlendRatio = (blendRatio < 0) ? "" : FDCConvert.ToString(blendRatio);
                FPProductIdElem.PIFPBlendProductNo = (blendProductNo < 0) ? "" : Convert.ToString(blendProductNo);

                ServiceProductIdFPDeviceClassConfiguration[] FPProductIdArray = FPNozzleElem.FPProductId;
                Array.Resize<ServiceProductIdFPDeviceClassConfiguration>(ref FPProductIdArray, (FPProductIdArray != null) ? FPProductIdArray.Length + 1 : 1);
                FPProductIdArray[FPProductIdArray.Length - 1] = FPProductIdElem;
                FPNozzleElem.FPProductId = FPProductIdArray;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");

            return true;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="workstationID"></param>
        /// <param name="applicationSender"></param>
        /// <param name="requestId"></param>
        /// <param name="tankDevice_pumpId_nozzleId_Map">list of tankDevice:PumpId:NozzleLogicalId</param>
        /// <returns></returns>
        public bool GetConfigurationAddTLG(string workstationID, string applicationSender, int requestId,
            IEnumerable<IGrouping<Tank, IGrouping<int, byte>>> tankDevice_pumpId_nozzleId_Map)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");

                ServiceResponseGetConfiguration SvRes = null;
                ServiceResponseGetTLGConfiguration SvResTLG = null;
                string commandName = (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration) ? "GetConfiguration" : "GetTLGConfiguration";
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + commandName;
                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration)
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvRes = (ServiceResponseGetConfiguration)(serviceResponseClientList[key]);
                    if (SvRes == null)
                    {
                        SvRes = new ServiceResponseGetConfiguration();
                        SvRes.WorkstationID = workstationID;
                        SvRes.ApplicationSender = applicationSender;
                        SvRes.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvRes);
                    }
                    else
                    {
                        if (SvRes.RequestType != "GetConfiguration" || Convert.ToInt32(SvRes.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                            return false;
                        }
                    }
                }
                else
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResTLG = (ServiceResponseGetTLGConfiguration)(serviceResponseClientList[key]);
                    if (SvResTLG == null)
                    {
                        SvResTLG = new ServiceResponseGetTLGConfiguration();
                        SvResTLG.WorkstationID = workstationID;
                        SvResTLG.ApplicationSender = applicationSender;
                        SvResTLG.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResTLG);
                    }
                    else
                    {
                        if (SvResTLG.RequestType != "GetTLGConfiguration" || Convert.ToInt32(SvResTLG.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvResTLG.RequestID={0}, requestId={1} - end false", SvResTLG.RequestID, requestId));
                            return false;
                        }
                    }
                }

                ServiceResponseFDCdataGetConfiguration FDCDataElem = null;
                if (SvRes != null && SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else if (SvResTLG != null && SvResTLG.FDCdata != null)
                    FDCDataElem = SvResTLG.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetConfiguration[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetConfiguration();
                    Array.Resize<ServiceResponseFDCdataGetConfiguration>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    if (SvRes != null)
                        SvRes.FDCdata = FDCDataArray;
                    else if (SvResTLG != null)
                        SvResTLG.FDCdata = FDCDataArray;
                }

                ServiceDeviceClassConfiguration fdcTLGDeviceClassElem = null;
                //if (FDCDataElem.DeviceClass != null)
                //{
                //    foreach (ServiceDeviceClassConfiguration fdcTLGDeviceClassElemTemp in FDCDataElem.DeviceClass)
                //    {
                //        if (fdcTLGDeviceClassElemTemp.DeviceID == Convert.ToString(tankDeviceId) && fdcTLGDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_TankLevelGauge)
                //        {
                //            //VERIFICARE
                //            //fdcTLGDeviceClassElem = fdcTLGDeviceClassElemTemp;
                //            return true;
                //        }
                //    }
                //}

                //<ServiceResponse\<FDCdata>\<DeviceClass>
                var deviceClassesOfTLG = new List<ServiceDeviceClassConfiguration>();

                //group by TankNumber
                foreach (var tankGroup in tankDevice_pumpId_nozzleId_Map)
                {
                    fdcTLGDeviceClassElem = new ServiceDeviceClassConfiguration();
                    fdcTLGDeviceClassElem.TPProductNo = tankGroup.Key.Product?.ProductCode;
                    fdcTLGDeviceClassElem.TPProductName = tankGroup.Key.Product?.ProductLabel;
                    fdcTLGDeviceClassElem.TPShellCapacity = (tankGroup.Key.Limit?.FullVolume ?? 0).ToString();
                    fdcTLGDeviceClassElem.TPMaxSafeFillCap = (tankGroup.Key.Limit?.MaxVolume ?? 0).ToString();
                    fdcTLGDeviceClassElem.TPLowCapacity = (tankGroup.Key.Limit?.LowProduct ?? 0).ToString();
                    fdcTLGDeviceClassElem.TPMinOperatingCapacity = (tankGroup.Key.Limit?.LowProduct ?? 0).ToString();

                    //tank device id
                    fdcTLGDeviceClassElem.DeviceID = Convert.ToString(tankGroup.Key.TankNumber);
                    fdcTLGDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_TankLevelGauge;

                    #region

                    //<ServiceResponse\<FDCdata>\<DeviceClass>\<DeviceClass>
                    var deviceClassesOfPump = new List<ServiceDeviceClassConfiguration>();
                    foreach (var pumpGroup in tankGroup)
                    {
                        deviceClassesOfPump.Add(new ServiceDeviceClassConfiguration()
                        {
                            Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint,
                            FPPumpNo = pumpGroup.Key.ToString(),
                            FPNozzle = pumpGroup.Select(nzId => new ServiceNozzleFPDeviceClassConfiguration()
                            {
                                FPNozzleNo = nzId.ToString(),
                            }).ToArray()
                        });
                    }

                    #endregion

                    fdcTLGDeviceClassElem.DeviceClass = deviceClassesOfPump.ToArray();
                    deviceClassesOfTLG.Add(fdcTLGDeviceClassElem);
                    //ServiceDeviceClassConfiguration[] fdcTLGDeviceClassArray = FDCDataElem.DeviceClass;
                    //Array.Resize<ServiceDeviceClassConfiguration>(ref fdcTLGDeviceClassArray, (fdcTLGDeviceClassArray != null) ? fdcTLGDeviceClassArray.Length + 1 : 1);
                    //fdcTLGDeviceClassArray[fdcTLGDeviceClassArray.Length - 1] = fdcTLGDeviceClassElem;
                }

                FDCDataElem.DeviceClass = deviceClassesOfTLG.ToArray();
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");

            return true;
        }

        public bool GetConfigurationAddTP(string workstationID, string applicationSender, int requestId, int tlgId, int deviceId, int tankNo, int productNo, string ProductName, int manualMode, decimal shellCapacity, decimal maxSafeFillCap, decimal lowCapacity, decimal minOperatingCapacity, int tankManifoldPartnersTankNo, decimal hiHiLevel, decimal hiLevel, decimal loLevel, decimal loLoLevel, decimal hiWater)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");

                ServiceResponseGetConfiguration SvRes = null;
                ServiceResponseGetTLGConfiguration SvResTLG = null;
                string commandName = (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration) ? "GetConfiguration" : "GetTLGConfiguration";
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + commandName;
                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration)
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvRes = (ServiceResponseGetConfiguration)(serviceResponseClientList[key]);
                    if (SvRes == null)
                    {
                        SvRes = new ServiceResponseGetConfiguration();
                        SvRes.WorkstationID = workstationID;
                        SvRes.ApplicationSender = applicationSender;
                        SvRes.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvRes);
                    }
                    else
                    {
                        if (SvRes.RequestType != "GetConfiguration" || Convert.ToInt32(SvRes.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                            return false;
                        }
                    }
                }
                else
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResTLG = (ServiceResponseGetTLGConfiguration)(serviceResponseClientList[key]);
                    if (SvResTLG == null)
                    {
                        SvResTLG = new ServiceResponseGetTLGConfiguration();
                        SvResTLG.WorkstationID = workstationID;
                        SvResTLG.ApplicationSender = applicationSender;
                        SvResTLG.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResTLG);
                    }
                    else
                    {
                        if (SvResTLG.RequestType != "GetTLGConfiguration" || Convert.ToInt32(SvResTLG.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvResTLG.RequestID={0}, requestId={1} - end false", SvResTLG.RequestID, requestId));
                            return false;
                        }
                    }
                }

                ServiceResponseFDCdataGetConfiguration FDCDataElem = null;
                if (SvRes != null && SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else if (SvResTLG != null && SvResTLG.FDCdata != null)
                    FDCDataElem = SvResTLG.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetConfiguration[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetConfiguration();
                    Array.Resize<ServiceResponseFDCdataGetConfiguration>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    if (SvRes != null)
                        SvRes.FDCdata = FDCDataArray;
                    else if (SvResTLG != null)
                        SvResTLG.FDCdata = FDCDataArray;
                }

                ServiceDeviceClassConfiguration fdcTPDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null && (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration))
                {
                    foreach (ServiceDeviceClassConfiguration fdcTPDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcTPDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) &&
                            fdcTPDeviceClassElemTemp.TPTankNo == Convert.ToString(tankNo) &&
                            fdcTPDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_TankProbe)
                            fdcTPDeviceClassElem = fdcTPDeviceClassElemTemp;
                }
                else if (FDCDataElem.DeviceClass != null && FDCGlobal.ProtocolVersion > FDCVersion.V0003)
                {
                    ServiceDeviceClassConfiguration fdcTLGDeviceClassElem = null;
                    foreach (ServiceDeviceClassConfiguration fdcTLGDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcTLGDeviceClassElemTemp.DeviceID == Convert.ToString(tlgId) &&
                            fdcTLGDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_TankLevelGauge)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format(">V0003 - DT_TankLevelGauge deviceId={0} found", tlgId));
                            fdcTLGDeviceClassElem = fdcTLGDeviceClassElemTemp;
                            if (fdcTLGDeviceClassElem.DeviceClass != null)
                            {
                                foreach (ServiceDeviceClassConfiguration fdcTPDeviceClassElemTemp in fdcTLGDeviceClassElem.DeviceClass)
                                    if (fdcTPDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) &&
                                        fdcTPDeviceClassElemTemp.TPTankNo == Convert.ToString(tankNo) &&
                                        fdcTPDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_TankProbe)
                                    {
                                        //FDCPOSManager.tracer.WriteLine(string.Format("DT_TankProbe deviceId={0} tankNo={1} found", deviceId, tankNo));
                                        fdcTPDeviceClassElem = fdcTPDeviceClassElemTemp;
                                    }
                            }
                        }
                }
                if (fdcTPDeviceClassElem == null)
                {
                    //FDCPOSManager.tracer.WriteLine(string.Format("DT_TankProbe deviceId={0} create", deviceId));
                    fdcTPDeviceClassElem = new ServiceDeviceClassConfiguration();
                    fdcTPDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_TankProbe;
                    fdcTPDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcTPDeviceClassElem.TPTankNo = Convert.ToString(tankNo);
                    fdcTPDeviceClassElem.TPProductNo = Convert.ToString(productNo);
                    fdcTPDeviceClassElem.TPProductName = ProductName;
                    fdcTPDeviceClassElem.TP_PPManualMode = (manualMode != 0) ? "True" : "False";

                    fdcTPDeviceClassElem.TPShellCapacity = (shellCapacity < 0) ? "" : FDCConvert.ToString(shellCapacity);
                    fdcTPDeviceClassElem.TPMaxSafeFillCap = (maxSafeFillCap < 0) ? "" : FDCConvert.ToString(maxSafeFillCap);
                    fdcTPDeviceClassElem.TPLowCapacity = (lowCapacity < 0) ? "" : FDCConvert.ToString(lowCapacity);
                    fdcTPDeviceClassElem.TPMinOperatingCapacity = (minOperatingCapacity < 0) ? "" : FDCConvert.ToString(minOperatingCapacity);

                    ServiceTankManifoldPartnersTPDeviceClassConfiguration TPTankManifoldPartnersElem = new ServiceTankManifoldPartnersTPDeviceClassConfiguration();
                    ServiceTankManifoldPartnersTPDeviceClassConfiguration[] TPTankManifolPartnersArray = null;
                    Array.Resize<ServiceTankManifoldPartnersTPDeviceClassConfiguration>(ref TPTankManifolPartnersArray, (TPTankManifolPartnersArray != null) ? TPTankManifolPartnersArray.Length + 1 : 1);
                    TPTankManifolPartnersArray[TPTankManifolPartnersArray.Length - 1] = TPTankManifoldPartnersElem;
                    fdcTPDeviceClassElem.TPTankManifoldPartners = TPTankManifolPartnersArray;

                    ServiceSetPointsTPDeviceClassConfiguration SetPoints = new ServiceSetPointsTPDeviceClassConfiguration();
                    SetPoints.TPHiHiLevel = (hiHiLevel < 0) ? "" : FDCConvert.ToString(hiHiLevel);
                    SetPoints.TPHiLevel = (hiLevel < 0) ? "" : FDCConvert.ToString(hiLevel);
                    SetPoints.TPHiWater = (hiWater < 0) ? "" : FDCConvert.ToString(hiWater);
                    SetPoints.TPLoLevel = (loLevel < 0) ? "" : FDCConvert.ToString(loLevel);
                    SetPoints.TPLoLoLevel = (loLoLevel < 0) ? "" : FDCConvert.ToString(loLoLevel);
                    ServiceSetPointsTPDeviceClassConfiguration[] SetPointsArray = null;
                    Array.Resize<ServiceSetPointsTPDeviceClassConfiguration>(ref SetPointsArray, 1);
                    SetPointsArray[0] = SetPoints;
                    fdcTPDeviceClassElem.TPSetPoints = SetPointsArray;


                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration)
                    {
                        ServiceDeviceClassConfiguration[] fdcTPDeviceClassArray = FDCDataElem.DeviceClass;
                        Array.Resize<ServiceDeviceClassConfiguration>(ref fdcTPDeviceClassArray, (fdcTPDeviceClassArray != null) ? fdcTPDeviceClassArray.Length + 1 : 1);
                        fdcTPDeviceClassArray[fdcTPDeviceClassArray.Length - 1] = fdcTPDeviceClassElem;
                        FDCDataElem.DeviceClass = fdcTPDeviceClassArray;

                        //FDCPOSManager.tracer.WriteLine("<V0007 - array resized");
                    }
                    else
                    {
                        //ServiceDeviceClassConfiguration fdcDSPDeviceClassElem = null;
                        foreach (ServiceDeviceClassConfiguration fdcTLGDeviceClassElemTemp in FDCDataElem.DeviceClass)
                            if (fdcTLGDeviceClassElemTemp.DeviceID == Convert.ToString(tlgId) && fdcTLGDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_TankLevelGauge)
                            {
                                ServiceDeviceClassConfiguration[] fdcTPDeviceClassArray = fdcTLGDeviceClassElemTemp.DeviceClass;
                                Array.Resize<ServiceDeviceClassConfiguration>(ref fdcTPDeviceClassArray, (fdcTPDeviceClassArray != null) ? fdcTPDeviceClassArray.Length + 1 : 1);
                                fdcTPDeviceClassArray[fdcTPDeviceClassArray.Length - 1] = fdcTPDeviceClassElem;
                                fdcTLGDeviceClassElemTemp.DeviceClass = fdcTPDeviceClassArray;

                                //FDCPOSManager.tracer.WriteLine(">V0003 - array resized");
                            }
                    }
                }

                ServiceTankNoTPDeviceClassConfiguration TPTankNoElem = new ServiceTankNoTPDeviceClassConfiguration();
                TPTankNoElem.TPTankNo = (tankManifoldPartnersTankNo <= 0) ? "" : Convert.ToString(tankManifoldPartnersTankNo);
                if (fdcTPDeviceClassElem.TPTankManifoldPartners[0].TPTankNo == null ||
                    (fdcTPDeviceClassElem.TPTankManifoldPartners[0].TPTankNo != null && tankManifoldPartnersTankNo >= 0))
                {
                    ServiceTankNoTPDeviceClassConfiguration[] TPTankNoArray = fdcTPDeviceClassElem.TPTankManifoldPartners[0].TPTankNo;
                    Array.Resize<ServiceTankNoTPDeviceClassConfiguration>(ref TPTankNoArray, (TPTankNoArray != null) ? TPTankNoArray.Length + 1 : 1);
                    TPTankNoArray[TPTankNoArray.Length - 1] = TPTankNoElem;
                    fdcTPDeviceClassElem.TPTankManifoldPartners[0].TPTankNo = TPTankNoArray;
                }
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");

            return true;
        }

        public bool GetConfigurationAddPP(string workstationID, string applicationSender, int requestId, int deviceId, int logicalDeviceNo, int manualMode, int segmentNo, int productNo, string ProductName, decimal productPrice, int modeNo)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");

                ServiceResponseGetConfiguration SvRes = null;
                ServiceResponseGetPPConfiguration SvResPP = null;
                string commandName = (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration) ? "GetConfiguration" : "GetPPConfiguration";
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + commandName;
                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration)
                {

                    if (serviceResponseClientList.ContainsKey(key))
                        SvRes = (ServiceResponseGetConfiguration)(serviceResponseClientList[key]);
                    if (SvRes == null)
                    {
                        SvRes = new ServiceResponseGetConfiguration();
                        SvRes.WorkstationID = workstationID;
                        SvRes.ApplicationSender = applicationSender;
                        SvRes.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvRes);
                    }
                    else
                    {
                        if (SvRes.RequestType != "GetConfiguration" || Convert.ToInt32(SvRes.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                            return false;
                        }
                    }
                }
                else
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResPP = (ServiceResponseGetPPConfiguration)(serviceResponseClientList[key]);
                    if (SvResPP == null)
                    {
                        SvResPP = new ServiceResponseGetPPConfiguration();
                        SvResPP.WorkstationID = workstationID;
                        SvResPP.ApplicationSender = applicationSender;
                        SvResPP.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResPP);
                    }
                    else
                    {
                        if (SvResPP.RequestType != "GetPPConfiguration" || Convert.ToInt32(SvResPP.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvResPP.RequestID={0}, requestId={1} - end false", SvResPP.RequestID, requestId));
                            return false;
                        }
                    }
                }

                ServiceResponseFDCdataGetConfiguration FDCDataElem = null;
                if (SvRes != null && SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else if (SvResPP != null && SvResPP.FDCdata != null)
                    FDCDataElem = SvResPP.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetConfiguration[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetConfiguration();
                    Array.Resize<ServiceResponseFDCdataGetConfiguration>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    if (SvRes != null)
                        SvRes.FDCdata = FDCDataArray;
                    else if (SvResPP != null)
                        SvResPP.FDCdata = FDCDataArray;
                }

                ServiceDeviceClassConfiguration fdcPPDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceDeviceClassConfiguration fdcPPDeviceClassElemTemp in FDCDataElem.DeviceClass)
                    {
                        if (fdcPPDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) && fdcPPDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_PricePole)
                        {
                            fdcPPDeviceClassElem = fdcPPDeviceClassElemTemp;
                        }
                    }
                }
                if (fdcPPDeviceClassElem == null)
                {
                    fdcPPDeviceClassElem = new ServiceDeviceClassConfiguration();
                    fdcPPDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcPPDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_PricePole;

                    ServiceDeviceClassConfiguration[] fdcPPDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceDeviceClassConfiguration>(ref fdcPPDeviceClassArray, (fdcPPDeviceClassArray != null) ? fdcPPDeviceClassArray.Length + 1 : 1);
                    fdcPPDeviceClassArray[fdcPPDeviceClassArray.Length - 1] = fdcPPDeviceClassElem;
                    FDCDataElem.DeviceClass = fdcPPDeviceClassArray;
                }

                ServiceDeviceClassConfiguration fdcPPPDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null && (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration))
                {
                    // for V03 there is only one device level (PP)
                    foreach (ServiceDeviceClassConfiguration fdcPPDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcPPDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) && fdcPPDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_PricePole)
                            fdcPPPDeviceClassElem = fdcPPDeviceClassElemTemp;
                }
                else if (FDCDataElem.DeviceClass != null && FDCGlobal.ProtocolVersion > FDCVersion.V0003)
                {
                    fdcPPDeviceClassElem = null;
                    foreach (ServiceDeviceClassConfiguration fdcPPDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcPPDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) &&
                            fdcPPDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_PricePole)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format(">V0003 - DT_PricePole deviceId={0} found", deviceId));
                            fdcPPDeviceClassElem = fdcPPDeviceClassElemTemp;
                            if (fdcPPDeviceClassElem.DeviceClass != null)
                            {
                                foreach (ServiceDeviceClassConfiguration fdcPPPDeviceClassElemTemp in fdcPPDeviceClassElem.DeviceClass)
                                    if (fdcPPPDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) &&
                                        fdcPPPDeviceClassElemTemp.SignNo == Convert.ToString(logicalDeviceNo) &&
                                        fdcPPPDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_PricePolePoint)
                                    {
                                        //FDCPOSManager.tracer.WriteLine(string.Format("DT_PricePolePoint deviceId={0} signNo={1} found", deviceId, logicalDeviceNo));
                                        fdcPPPDeviceClassElem = fdcPPPDeviceClassElemTemp;
                                    }
                            }
                        }
                    if (fdcPPDeviceClassElem == null)
                    {
                        fdcPPDeviceClassElem = new ServiceDeviceClassConfiguration();
                        fdcPPDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                        fdcPPDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_PricePole;
                    }
                }
                if (fdcPPPDeviceClassElem == null)
                {
                    //FDCPOSManager.tracer.WriteLine(string.Format("DT_PricePolePoint deviceId={0} signId={1} create", deviceId, logicalDeviceNo));
                    fdcPPPDeviceClassElem = new ServiceDeviceClassConfiguration();
                    fdcPPPDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                    {
                        fdcPPPDeviceClassElem.PPLogicalDeviceNo = Convert.ToString(logicalDeviceNo);
                        fdcPPPDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_PricePole;
                    }
                    else
                    {
                        fdcPPPDeviceClassElem.SignNo = Convert.ToString(logicalDeviceNo);
                        fdcPPPDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_PricePolePoint;
                    }
                    fdcPPPDeviceClassElem.TP_PPManualMode = (manualMode != 0) ? "True" : "False"; ;

                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003 || Messages.bWholeConfiguration)
                    {
                        ServiceDeviceClassConfiguration[] fdcPPDeviceClassArray = FDCDataElem.DeviceClass;
                        Array.Resize<ServiceDeviceClassConfiguration>(ref fdcPPDeviceClassArray, (fdcPPDeviceClassArray != null) ? fdcPPDeviceClassArray.Length + 1 : 1);
                        fdcPPDeviceClassArray[fdcPPDeviceClassArray.Length - 1] = fdcPPPDeviceClassElem;
                        FDCDataElem.DeviceClass = fdcPPDeviceClassArray;
                        //FDCPOSManager.tracer.WriteLine("=V0003 - array resized");
                    }
                    else
                    {
                        //ServiceDeviceClassConfiguration fdcDSPDeviceClassElem = null;
                        foreach (ServiceDeviceClassConfiguration fdcPPDeviceClassElemTemp in FDCDataElem.DeviceClass)
                            if (fdcPPDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) && fdcPPDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_PricePole)
                            {
                                ServiceDeviceClassConfiguration[] fdcPPPDeviceClassArray = fdcPPDeviceClassElemTemp.DeviceClass;
                                Array.Resize<ServiceDeviceClassConfiguration>(ref fdcPPPDeviceClassArray, (fdcPPPDeviceClassArray != null) ? fdcPPPDeviceClassArray.Length + 1 : 1);
                                fdcPPPDeviceClassArray[fdcPPPDeviceClassArray.Length - 1] = fdcPPPDeviceClassElem;
                                fdcPPDeviceClassElemTemp.DeviceClass = fdcPPPDeviceClassArray;

                                //FDCPOSManager.tracer.WriteLine(">V0003 - array resized");
                            }
                    }
                }

                ServiceSegmentsPPDeviceClassConfiguration PPSegmentsElem = null;
                if (fdcPPPDeviceClassElem.PPSegments != null)
                {
                    PPSegmentsElem = fdcPPPDeviceClassElem.PPSegments[0];
                }
                else
                {
                    PPSegmentsElem = new ServiceSegmentsPPDeviceClassConfiguration();
                    ServiceSegmentsPPDeviceClassConfiguration[] SegmentsPPDeviceClassArray = fdcPPPDeviceClassElem.PPSegments;
                    Array.Resize<ServiceSegmentsPPDeviceClassConfiguration>(ref SegmentsPPDeviceClassArray, (SegmentsPPDeviceClassArray != null) ? SegmentsPPDeviceClassArray.Length + 1 : 1);
                    SegmentsPPDeviceClassArray[SegmentsPPDeviceClassArray.Length - 1] = PPSegmentsElem;
                    fdcPPPDeviceClassElem.PPSegments = SegmentsPPDeviceClassArray;
                }
                ServiceLinePPDeviceClassConfiguration PPLineElem = null;
                PPLineElem = new ServiceLinePPDeviceClassConfiguration();
                PPLineElem.LSPPSegmentNo = Convert.ToString(segmentNo);
                PPLineElem.LSPPProductNo = Convert.ToString(productNo);
                PPLineElem.LSPPProductName = ProductName;
                PPLineElem.LSPPProductPrice = FDCConvert.ToString(productPrice);
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0007)
                    PPLineElem.LSPPModeNo = Convert.ToString(modeNo);

                ServiceLinePPDeviceClassConfiguration[] LinePPDeviceClassArray = PPSegmentsElem.SPPLine;
                Array.Resize<ServiceLinePPDeviceClassConfiguration>(ref LinePPDeviceClassArray, (LinePPDeviceClassArray != null) ? LinePPDeviceClassArray.Length + 1 : 1);
                LinePPDeviceClassArray[LinePPDeviceClassArray.Length - 1] = PPLineElem;
                PPSegmentsElem.SPPLine = LinePPDeviceClassArray;

            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");

            return true;
        }

        public bool GetConfigurationSend(string workstationID, string applicationSender, int requestId, string deviceType, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine(string.Format("GetConfigurationSend init: deviceType={0}", deviceType));
            string key = "", requestType = "";
            ErrorCode status = ErrorCode.ERRCD_OK;
            if (deviceType == "")
            {
                ServiceResponseGetConfiguration SvRes = null;
                key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetConfiguration";
                if (serviceResponseClientList.ContainsKey(key))
                {
                    SvRes = (ServiceResponseGetConfiguration)(serviceResponseClientList[key]);
                    //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestType={0}", SvRes.RequestType));
                }
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "GetConfiguration" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("end FALSE: Convert.ToInt32(SvRes.requestId)={0}, requestId={1}", Convert.ToInt32(SvRes.RequestID), requestId));
                        return false;
                    }
                }
                else
                {
                    // send an empty response - no available transaction added
                    SvRes = new ServiceResponseGetConfiguration();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataGetConfiguration FDCDataElem = new ServiceResponseFDCdataGetConfiguration();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    ServiceResponseFDCdataGetConfiguration[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                SvRes.OverallResult = overallResult;
                requestType = SvRes.RequestType;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetConfiguration>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
            }
            else if (deviceType == DeviceType.DT_FuelDispenser)
            {
                ServiceResponseGetDSPConfiguration SvRes = null;
                key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetDSPConfiguration";
                if (serviceResponseClientList.ContainsKey(key))
                {
                    SvRes = (ServiceResponseGetDSPConfiguration)(serviceResponseClientList[key]);
                    //FDCPOSManager.tracer.WriteLine(string.Format("key found - SvRes.RequestType={0}", SvRes.RequestType));
                }
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "GetDSPConfiguration" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("end FALSE: Convert.ToInt32(SvRes.requestId)={0}, requestId={1}", Convert.ToInt32(SvRes.RequestID), requestId));
                        return false;
                    }
                }
                else
                {
                    //FDCPOSManager.tracer.WriteLine(string.Format("key NOT found - create object"));

                    // send an empty response - no available transaction added
                    SvRes = new ServiceResponseGetDSPConfiguration();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataGetConfiguration FDCDataElem = new ServiceResponseFDCdataGetConfiguration();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    ServiceResponseFDCdataGetConfiguration[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                SvRes.OverallResult = overallResult;
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                requestType = SvRes.RequestType;

                if (!fdcPosManager.fdcClientList.ContainsKey(FDCPOSClient.getClientID(workstationID, applicationSender)))
                {
                    fdcSocketLogger.LogDebug("####can't find client(" + FDCPOSClient.getClientID(workstationID, applicationSender)
                        + ") in TcpClientList(" + (fdcPosManager.fdcClientList.Keys.Any() ?
                                                fdcPosManager.fdcClientList.Keys.Select(k => k.ToString()).Aggregate((n, acc) => n + ", " + acc)
                                                    : "Empty yet") + "), impossible to send `ServiceResponseGetDSPConfiguration`");
                }
                else
                {
                    ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetDSPConfiguration>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                    serviceResponseClientList.Remove(key);
                }
            }
            else if (deviceType == DeviceType.DT_TankLevelGauge)
            {
                ServiceResponseGetTLGConfiguration SvRes = null;
                key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetTLGConfiguration";
                if (serviceResponseClientList.ContainsKey(key))
                {
                    SvRes = (ServiceResponseGetTLGConfiguration)(serviceResponseClientList[key]);
                    //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestType={0}", SvRes.RequestType));
                }
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "GetTLGConfiguration" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("end FALSE: Convert.ToInt32(SvRes.requestId)={0}, requestId={1}", Convert.ToInt32(SvRes.RequestID), requestId));
                        return false;
                    }
                }
                else
                {
                    // send an empty response - no available transaction added
                    SvRes = new ServiceResponseGetTLGConfiguration();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataGetConfiguration FDCDataElem = new ServiceResponseFDCdataGetConfiguration();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    ServiceResponseFDCdataGetConfiguration[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                SvRes.OverallResult = overallResult;
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                requestType = SvRes.RequestType;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetTLGConfiguration>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
            }
            else if (deviceType == DeviceType.DT_PricePole)
            {
                ServiceResponseGetPPConfiguration SvRes = null;
                key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetPPConfiguration";
                if (serviceResponseClientList.ContainsKey(key))
                {
                    SvRes = (ServiceResponseGetPPConfiguration)(serviceResponseClientList[key]);
                    //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestType={0}", SvRes.RequestType));
                }
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "GetPPConfiguration" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("end FALSE: Convert.ToInt32(SvRes.requestId)={0}, requestId={1}", Convert.ToInt32(SvRes.RequestID), requestId));
                        return false;
                    }
                }
                else
                {
                    // send an empty response - no available transaction added
                    SvRes = new ServiceResponseGetPPConfiguration();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataGetConfiguration FDCDataElem = new ServiceResponseFDCdataGetConfiguration();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    ServiceResponseFDCdataGetConfiguration[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                SvRes.OverallResult = overallResult;
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                requestType = SvRes.RequestType;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetPPConfiguration>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
            }

            //FDCPOSManager.tracer.WriteLine(string.Format("end OK: RequestType={0}", requestType));

            return true;
        }

        public void SetConfiguration(string workstationID, string applicationSender, int requestId, string overallResult)
        {
            ServiceResponseSetConfiguration SvRes = new ServiceResponseSetConfiguration();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataBasic FDCDataElem = new ServiceResponseFDCdataBasic();
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

            ServiceResponseFDCdataBasic[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseSetConfiguration>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
        }

        public void LockNozzle(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int nozzleNo, int status, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseLockNozzle SvRes = new ServiceResponseLockNozzle();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString(); ;
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataLockNozzle FDCDataElem = new ServiceResponseFDCdataLockNozzle();

            ServiceResponseDeviceClassLockNozzle fdcDeviceClassElem = new ServiceResponseDeviceClassLockNozzle();
            fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
            fdcDeviceClassElem.PumpNo = Convert.ToString(pumpNo);
            fdcDeviceClassElem.NozzleNo = Convert.ToString(nozzleNo);
            fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

            FDCDataElem.DeviceClass = fdcDeviceClassElem;
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseFDCdataLockNozzle[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseLockNozzle>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }
        public void UnlockNozzle(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int nozzleNo, int status, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseUnlockNozzle SvRes = new ServiceResponseUnlockNozzle();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString(); ;
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataUnlockNozzle FDCDataElem = new ServiceResponseFDCdataUnlockNozzle();

            ServiceResponseDeviceClassUnlockNozzle fdcDeviceClassElem = new ServiceResponseDeviceClassUnlockNozzle();
            fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
            fdcDeviceClassElem.PumpNo = Convert.ToString(pumpNo);
            fdcDeviceClassElem.NozzleNo = (nozzleNo == -1) ? "*" : Convert.ToString(nozzleNo);
            fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

            FDCDataElem.DeviceClass = fdcDeviceClassElem;
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseFDCdataUnlockNozzle[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseUnlockNozzle>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("init");
        }

        public void GetCountrySettings(string workstationID, string applicationSender, int requestId, string volumeUnit, string currencyCode, string levelUnit, string temperatureUnit, string thousandDelimiter, string decimalSign, string countryCode, string languageCode, int status, string overallResult)
        {
            FDCConvert.DecimalSeparator = decimalSign;
            FDCConvert.ThousandSeparator = thousandDelimiter;
            if (applicationSender == FDCPOSInterfaceServerManager.FDCPOSServerApplication)
                return;

            ServiceResponseGetCountrySettings SvRes = new ServiceResponseGetCountrySettings();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataGetCountrySettings FDCDataElem = new ServiceResponseFDCdataGetCountrySettings();

            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.VolumeUnit = volumeUnit;
            FDCDataElem.CurrencyCode = currencyCode;
            FDCDataElem.LevelUnit = levelUnit;
            FDCDataElem.TemperatureUnit = temperatureUnit;
            FDCDataElem.CountryCode = countryCode;
            if (FDCGlobal.ProtocolVersion < FDCVersion.V0007 || (FDCGlobal.ProtocolVersion >= FDCVersion.V0007 && this.fdcPosManager.useExtensions))
            {
                FDCDataElem.ThousandDelimiter = thousandDelimiter;
                FDCDataElem.DecimalSign = decimalSign;
                FDCDataElem.LanguageCode = languageCode;
            }
            if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseFDCdataGetCountrySettings[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetCountrySettings>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
        }

        public bool GetDSPLimitsAdd(string workstationID, string applicationSender, int requestId, int deviceId, int produtNo, int fuelModeNo, double maxTrxAmount, double maxTrxVolume)
        {
            try
            {
                ServiceResponseGetDSPLimits SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetDSPLimits";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetDSPLimits)(serviceResponseClientList[key]);
                if (SvRes == null)
                {
                    SvRes = new ServiceResponseGetDSPLimits();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);
                }
                else
                {
                    if (SvRes.RequestType != "GetDSPLimits" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }

                ServiceResponseFDCdataGetDSPLimits FDCDataElem = null;
                if (SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetDSPLimits[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetDSPLimits();
                    Array.Resize<ServiceResponseFDCdataGetDSPLimits>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    SvRes.FDCdata = FDCDataArray;
                }

                ServiceResponseDeviceClassGetDSPLimits fdcDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceResponseDeviceClassGetDSPLimits fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) && fdcDeviceClassElemTemp.Type == Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser)
                            fdcDeviceClassElem = fdcDeviceClassElemTemp;
                }
                if (fdcDeviceClassElem == null && deviceId > 0)
                {
                    fdcDeviceClassElem = new ServiceResponseDeviceClassGetDSPLimits();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;

                    ServiceResponseDeviceClassGetDSPLimits[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceResponseDeviceClassGetDSPLimits>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                    fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                }

                ServiceResponseProductDeviceClassGetDSPLimits ProdutElem = null;
                if (fdcDeviceClassElem.Product != null)
                {
                    foreach (ServiceResponseProductDeviceClassGetDSPLimits ProdutElemTemp in fdcDeviceClassElem.Product)
                    {
                        if (ProdutElemTemp.ProductNo == Convert.ToString(produtNo))
                        {
                            ProdutElem = ProdutElemTemp;
                            break;
                        }
                    }
                }
                if (ProdutElem == null)
                {
                    ProdutElem = new ServiceResponseProductDeviceClassGetDSPLimits();
                    ProdutElem.ProductNo = Convert.ToString(produtNo);
                    ServiceResponseProductDeviceClassGetDSPLimits[] ProductDeviceClassArray = fdcDeviceClassElem.Product;
                    Array.Resize<ServiceResponseProductDeviceClassGetDSPLimits>(ref ProductDeviceClassArray, (ProductDeviceClassArray != null) ? ProductDeviceClassArray.Length + 1 : 1);
                    ProductDeviceClassArray[ProductDeviceClassArray.Length - 1] = ProdutElem;
                    fdcDeviceClassElem.Product = ProductDeviceClassArray;
                }
                ServiceResponseFuelModeDeviceClassGetDSPLimits FuelModeElem = null;
                FuelModeElem = new ServiceResponseFuelModeDeviceClassGetDSPLimits();
                FuelModeElem.ModeNo = Convert.ToString(fuelModeNo);

                NumberFormatInfo nfi = new NumberFormatInfo();
                nfi.NumberDecimalSeparator = FDCConvert.DecimalSeparator;
                nfi.NumberGroupSeparator = FDCConvert.ThousandSeparator;
                nfi.NumberDecimalDigits = 2;
                FuelModeElem.MaxTrxAmount = string.Format(nfi, "{0:F2}", maxTrxAmount);
                //FuelModeElem.MaxTrxAmount = Convert.ToString(maxTrxAmount, nfi);

                nfi.NumberDecimalDigits = 3;
                FuelModeElem.MaxTrxVolume = string.Format(nfi, "{0:F3}", maxTrxVolume);
                //FuelModeElem.MaxTrxVolume = Convert.ToString(maxTrxVolume, nfi);

                ServiceResponseFuelModeDeviceClassGetDSPLimits[] FuelModeArray = ProdutElem.FuelMode;
                Array.Resize<ServiceResponseFuelModeDeviceClassGetDSPLimits>(ref FuelModeArray, (FuelModeArray != null) ? FuelModeArray.Length + 1 : 1);
                FuelModeArray[FuelModeArray.Length - 1] = FuelModeElem;
                ProdutElem.FuelMode = FuelModeArray;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return true;
        }
        public bool GetDSPLimitsSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                ServiceResponseGetDSPLimits SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetDSPLimits";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetDSPLimits)(serviceResponseClientList[key]);
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "GetDSPLimits" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }
                else
                {
                    // send an empty response - no available transaction added
                    SvRes = new ServiceResponseGetDSPLimits();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataGetDSPLimits FDCDataElem = new ServiceResponseFDCdataGetDSPLimits();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                        FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
                    ServiceResponseFDCdataGetDSPLimits[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                SvRes.OverallResult = overallResult;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetDSPLimits>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return true;
        }
        public void ChangeDSPLimits(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            ServiceResponseChangeDSPLimits SvRes = new ServiceResponseChangeDSPLimits();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString(); ;
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataChangeDSPLimits FDCDataElem = new ServiceResponseFDCdataChangeDSPLimits();

            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
            ServiceResponseFDCdataChangeDSPLimits[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseChangeDSPLimits>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
        }

        public bool SuspendFuellingAdd(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, LogicalDeviceState deviceStatus)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseSuspendFuelling SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "SuspendFuelling";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseSuspendFuelling)(serviceResponseClientList[key]);
                if (SvRes == null)
                {
                    SvRes = new ServiceResponseSuspendFuelling();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);
                }
                else
                {
                    if (SvRes.RequestType != "SuspendFuelling" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }

                ServiceResponseFDCdataSuspendFuelling FDCDataElem = null;
                if (SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataSuspendFuelling[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataSuspendFuelling();
                    Array.Resize<ServiceResponseFDCdataSuspendFuelling>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    //FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
                    SvRes.FDCdata = FDCDataArray;
                }


                ServiceResponseDeviceClassSuspendFuelling fdcDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceResponseDeviceClassSuspendFuelling fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId))
                            fdcDeviceClassElem = fdcDeviceClassElemTemp;
                }
                if (fdcDeviceClassElem == null && deviceId > 0)
                {
                    fdcDeviceClassElem = new ServiceResponseDeviceClassSuspendFuelling();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.PumpNo = Convert.ToString(pumpNo);
                    fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0005)
                        fdcDeviceClassElem.DeviceState = deviceStatus.ToString();

                    ServiceResponseDeviceClassSuspendFuelling[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceResponseDeviceClassSuspendFuelling>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                    fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                }
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");
            return true;
        }
        public bool SuspendFuellingSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                ServiceResponseSuspendFuelling SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "SuspendFuelling";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseSuspendFuelling)(serviceResponseClientList[key]);
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "SuspendFuelling" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }
                else
                {
                    // send an empty response - no available transaction added
                    SvRes = new ServiceResponseSuspendFuelling();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataSuspendFuelling FDCDataElem = new ServiceResponseFDCdataSuspendFuelling();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

                    ServiceResponseFDCdataSuspendFuelling[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                SvRes.OverallResult = overallResult;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseSuspendFuelling>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
                return true;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return false;
        }

        public bool ResumeFuellingAdd(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, LogicalDeviceState deviceStatus)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseResumeFuelling SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "ResumeFuelling";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseResumeFuelling)(serviceResponseClientList[key]);
                if (SvRes == null)
                {
                    SvRes = new ServiceResponseResumeFuelling();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);
                }
                else
                {
                    if (SvRes.RequestType != "ResumeFuelling" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }

                ServiceResponseFDCdataResumeFuelling FDCDataElem = null;
                if (SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataResumeFuelling[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataResumeFuelling();
                    Array.Resize<ServiceResponseFDCdataResumeFuelling>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    //FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
                    SvRes.FDCdata = FDCDataArray;
                }


                ServiceResponseDeviceClassResumeFuelling fdcDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceResponseDeviceClassResumeFuelling fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId))
                            fdcDeviceClassElem = fdcDeviceClassElemTemp;
                }
                if (fdcDeviceClassElem == null && deviceId > 0)
                {
                    fdcDeviceClassElem = new ServiceResponseDeviceClassResumeFuelling();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.PumpNo = Convert.ToString(pumpNo);
                    fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0005)
                        fdcDeviceClassElem.DeviceState = deviceStatus.ToString();

                    ServiceResponseDeviceClassResumeFuelling[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceResponseDeviceClassResumeFuelling>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                    fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                }
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");
            return true;
        }
        public bool ResumeFuellingSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                ServiceResponseResumeFuelling SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "ResumeFuelling";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseResumeFuelling)(serviceResponseClientList[key]);
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "ResumeFuelling" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }
                else
                {
                    // send an empty response - no available transaction added
                    SvRes = new ServiceResponseResumeFuelling();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataResumeFuelling FDCDataElem = new ServiceResponseFDCdataResumeFuelling();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

                    ServiceResponseFDCdataResumeFuelling[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                SvRes.OverallResult = overallResult;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseResumeFuelling>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
                return true;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return false;
        }

        public void LockTank(string workstationID, string applicationSender, int requestId, int deviceId, int tankNo, int status, string overallResult)
        {
            ServiceResponseLockTank SvRes = new ServiceResponseLockTank();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataLockTank FDCDataElem = new ServiceResponseFDCdataLockTank();

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

            ServiceResponseDeviceClassLockTank[] fdcDeviceClassArray = { fdcDeviceClassElem };

            FDCDataElem.DeviceClass = fdcDeviceClassArray;
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseFDCdataLockTank[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseLockTank>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
        }

        public void UnlockTank(string workstationID, string applicationSender, int requestId, int deviceId, int tankNo, int status, string overallResult)
        {
            ServiceResponseUnlockTank SvRes = new ServiceResponseUnlockTank();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataUnlockTank FDCDataElem = new ServiceResponseFDCdataUnlockTank();

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

            ServiceResponseDeviceClassUnlockTank[] fdcDeviceClassArray = { fdcDeviceClassElem };

            FDCDataElem.DeviceClass = fdcDeviceClassArray;
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseFDCdataUnlockTank[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseUnlockTank>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
        }

        //public void GetTankData(string workstationID, string applicationSender, int requestId, int deviceId, int tankNo, int manualMode, int TPStatus, double productLevel, double totalObservedVolume, double grossStandardVolume, double averageTemp, double waterLevel, double observedDensity, string overallResult)
        //{
        //    ServiceResponseGetTankData SvRes = new ServiceResponseGetTankData();
        //    SvRes.WorkstationID = workstationID;
        //    SvRes.ApplicationSender = applicationSender;
        //    SvRes.RequestID = requestId.ToString();
        //    SvRes.OverallResult = overallResult;

        //    ServiceResponseFDCdataGetTankData FDCDataElem = new ServiceResponseFDCdataGetTankData();

        //    ServiceResponseDeviceClassGetTankData fdcDeviceClassElem = new ServiceResponseDeviceClassGetTankData();
        //    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
        //    fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_TankProbe;
        //    fdcDeviceClassElem.TankNo = Convert.ToString(tankNo);
        //    if (manualMode != 0)
        //        fdcDeviceClassElem.ManualMode = "True";
        //    else
        //        fdcDeviceClassElem.ManualMode = "False";

        //    ServiceResponseMeasurementDataGetTankData fdcMesaurementDataElem = new ServiceResponseMeasurementDataGetTankData();
        //    fdcMesaurementDataElem.ProductLevel = (productLevel < 0) ? "" : Convert.ToString(productLevel);
        //    fdcMesaurementDataElem.TPStatus = Convert.ToString(TPStatus);
        //    fdcMesaurementDataElem.TotalObservedVolume = (totalObservedVolume < 0) ? "" : FDCConvert.ToString(totalObservedVolume);
        //    fdcMesaurementDataElem.GrossStandardVolume = (grossStandardVolume < 0) ? "" : FDCConvert.ToString(grossStandardVolume);
        //    fdcMesaurementDataElem.AverageTemp = (averageTemp < 0) ? "" : FDCConvert.ToString(averageTemp);
        //    fdcMesaurementDataElem.WaterLevel = (waterLevel < 0) ? "" : FDCConvert.ToString(waterLevel);
        //    fdcMesaurementDataElem.ObservedDensity = (observedDensity < 0) ? "" : FDCConvert.ToString(observedDensity);

        //    fdcDeviceClassElem.MeasurementData = fdcMesaurementDataElem;

        //    ServiceResponseDeviceClassGetTankData[] fdcDeviceClassArray = { fdcDeviceClassElem };

        //    FDCDataElem.DeviceClass = fdcDeviceClassArray;
        //    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

        //    ServiceResponseFDCdataGetTankData[] FDCDataArray = { FDCDataElem };

        //    SvRes.FDCdata = FDCDataArray;

        //    ((FDCPOSInterfaceServerManager)fdcposManager).respChannelAThreadObj.SendResponse<ServiceResponseGetTankData>(fdcposManager.tcpClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
        //}
        public bool GetTankDataAdd(string workstationID, string applicationSender, int requestId, int deviceId, int tankNo, int manualMode, int TPStatus, double productLevel, double totalObservedVolume, double grossStandardVolume, double averageTemp, double waterLevel, double observedDensity, int logicalStatus, int deviceStatus)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseGetTankData SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetTankData";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetTankData)(serviceResponseClientList[key]);
                if (SvRes == null)
                {
                    SvRes = new ServiceResponseGetTankData();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);
                }
                else
                {
                    if (SvRes.RequestType != "GetTankData" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }

                ServiceResponseFDCdataGetTankData FDCDataElem = null;
                if (SvRes.FDCdata != null)
                    FDCDataElem = SvRes.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataGetTankData[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataGetTankData();
                    Array.Resize<ServiceResponseFDCdataGetTankData>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now); //DateTime.Now.ToString(Define.DateFormat);
                    SvRes.FDCdata = FDCDataArray;
                }


                ServiceResponseDeviceClassGetTankData fdcDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceResponseDeviceClassGetTankData fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId) && fdcDeviceClassElemTemp.TankNo == Convert.ToString(tankNo))
                            fdcDeviceClassElem = fdcDeviceClassElemTemp;
                }
                if (fdcDeviceClassElem == null && deviceId > 0)
                {
                    fdcDeviceClassElem = new ServiceResponseDeviceClassGetTankData();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.TankNo = Convert.ToString(tankNo);
                    fdcDeviceClassElem.ManualMode = (manualMode != 0) ? "True" : "False";
                    fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_TankProbe;
                    fdcDeviceClassElem.MeasurementData = new ServiceResponseMeasurementDataGetTankData();
                    fdcDeviceClassElem.MeasurementData.AverageTemp = FDCConvert.ToString(averageTemp);
                    fdcDeviceClassElem.MeasurementData.GrossStandardVolume = FDCConvert.ToString(grossStandardVolume);
                    fdcDeviceClassElem.MeasurementData.ObservedDensity = FDCConvert.ToString(observedDensity);
                    fdcDeviceClassElem.MeasurementData.ProductLevel = FDCConvert.ToString(productLevel);
                    fdcDeviceClassElem.MeasurementData.TotalObservedVolume = FDCConvert.ToString(totalObservedVolume);
                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                        fdcDeviceClassElem.MeasurementData.TPStatus = ((ErrorCode)TPStatus).ToString();
                    else if (FDCGlobal.ProtocolVersion == FDCVersion.V0005)
                        fdcDeviceClassElem.MeasurementData.LogicalState = ((LogicalState)logicalStatus).ToString();
                    else
                        fdcDeviceClassElem.MeasurementData.TankLogicalState = ((LogicalState)logicalStatus).ToString();
                    fdcDeviceClassElem.MeasurementData.WaterLevel = FDCConvert.ToString(waterLevel);

                    ServiceResponseDeviceClassGetTankData[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceResponseDeviceClassGetTankData>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                    fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                }
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");
            return true;
        }
        public bool GetTankDataSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                ServiceResponseGetTankData SvRes = null;
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + "GetTankData";
                if (serviceResponseClientList.ContainsKey(key))
                    SvRes = (ServiceResponseGetTankData)(serviceResponseClientList[key]);
                if (SvRes != null)
                {
                    if (SvRes.RequestType != "GetTankData" || Convert.ToInt32(SvRes.RequestID) != requestId)
                    {
                        //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvRes.RequestID, requestId));
                        return false;
                    }
                }
                else
                {
                    // send an empty response - no available transaction added
                    SvRes = new ServiceResponseGetTankData();
                    SvRes.WorkstationID = workstationID;
                    SvRes.ApplicationSender = applicationSender;
                    SvRes.RequestID = requestId.ToString();
                    serviceResponseClientList.Add(key, SvRes);

                    ServiceResponseFDCdataGetTankData FDCDataElem = new ServiceResponseFDCdataGetTankData();
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now); //DateTime.Now.ToString(Define.DateFormat);
                    ////FDCPOSManager.tracer.WriteLine(string.Format("GetTankDataSend: Define.DateFormat={0}, FDCDataElem.FDCTimeStamp={1}", Define.DateFormat, FDCDataElem.FDCTimeStamp));
                    ServiceResponseFDCdataGetTankData[] FDCDataArray = { FDCDataElem };
                    SvRes.FDCdata = FDCDataArray;
                }
                if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                    SvRes.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                SvRes.OverallResult = overallResult;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGetTankData>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
                serviceResponseClientList.Remove(key);
                return true;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return false;
        }


        public void ReserveFuelPoint(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int status, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseReserveFuelPoint SvRes = new ServiceResponseReserveFuelPoint();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataReserveFuelPoint FDCDataElem = new ServiceResponseFDCdataReserveFuelPoint();

            ServiceResponseDeviceClassReserveFuelPoint fdcDeviceClassElem = new ServiceResponseDeviceClassReserveFuelPoint();
            fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
            fdcDeviceClassElem.PumpNo = Convert.ToString(pumpNo);
            fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

            //ServiceResponseDeviceClassReserveFuelPoint[] fdcDeviceClassArray = { fdcDeviceClassElem };

            FDCDataElem.DeviceClass = fdcDeviceClassElem;
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseFDCdataReserveFuelPoint[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseReserveFuelPoint>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void FreeFuelPoint(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int status, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseFreeFuelPoint SvRes = new ServiceResponseFreeFuelPoint();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataFreeFuelPoint FDCDataElem = new ServiceResponseFDCdataFreeFuelPoint();

            ServiceResponseDeviceClassFreeFuelPoint fdcDeviceClassElem = new ServiceResponseDeviceClassFreeFuelPoint();
            fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
            fdcDeviceClassElem.PumpNo = Convert.ToString(pumpNo);
            fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

            //ServiceResponseDeviceClassFreeFuelPoint[] fdcDeviceClassArray = { fdcDeviceClassElem };

            FDCDataElem.DeviceClass = fdcDeviceClassElem;
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseFDCdataFreeFuelPoint[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseFreeFuelPoint>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void StartFuelPointTest(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int status, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseStartFuelPointTest SvRes = new ServiceResponseStartFuelPointTest();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataStartFuelPointTest FDCDataElem = new ServiceResponseFDCdataStartFuelPointTest();

            ServiceResponseDeviceClassStartFuelPointTest fdcDeviceClassElem = new ServiceResponseDeviceClassStartFuelPointTest();
            fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
            fdcDeviceClassElem.PumpNo = Convert.ToString(pumpNo);
            fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

            //ServiceResponseDeviceClassReserveFuelPoint[] fdcDeviceClassArray = { fdcDeviceClassElem };

            FDCDataElem.DeviceClass = fdcDeviceClassElem;
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseFDCdataStartFuelPointTest[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseStartFuelPointTest>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void EndFuelPointTest(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, int status, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseEndFuelPointTest SvRes = new ServiceResponseEndFuelPointTest();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataEndFuelPointTest FDCDataElem = new ServiceResponseFDCdataEndFuelPointTest();

            ServiceResponseDeviceClassEndFuelPointTest fdcDeviceClassElem = new ServiceResponseDeviceClassEndFuelPointTest();
            fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
            fdcDeviceClassElem.PumpNo = Convert.ToString(pumpNo);
            fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

            //ServiceResponseDeviceClassReserveFuelPoint[] fdcDeviceClassArray = { fdcDeviceClassElem };

            FDCDataElem.DeviceClass = fdcDeviceClassElem;
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseFDCdataEndFuelPointTest[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseEndFuelPointTest>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void SetDeviceAlarm(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, int status, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine("init");
            ServiceResponseSetDeviceAlarm SvRes = new ServiceResponseSetDeviceAlarm();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataSetDeviceAlarm FDCDataElem = new ServiceResponseFDCdataSetDeviceAlarm();

            ServiceResponseDeviceClassSetDeviceAlarm fdcDeviceClassElem = new ServiceResponseDeviceClassSetDeviceAlarm();
            fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
            fdcDeviceClassElem.Type = deviceType;

            //ServiceResponseDeviceClassReserveFuelPoint[] fdcDeviceClassArray = { fdcDeviceClassElem };

            FDCDataElem.DeviceClass = fdcDeviceClassElem;
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
            FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

            ServiceResponseFDCdataSetDeviceAlarm[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseSetDeviceAlarm>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public bool OpenFuelPointAdd(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, LogicalDeviceState deviceStatus)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseOpenFuelPoint SvResFuelPoint = null;
                ServiceResponseOpenDevice SvResDevice = null;

                string commandName = (FDCGlobal.ProtocolVersion == FDCVersion.V0003) ? "OpenFuelPoint" : "OpenDevice";
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + commandName;
                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResFuelPoint = (ServiceResponseOpenFuelPoint)(serviceResponseClientList[key]);
                    if (SvResFuelPoint == null)
                    {
                        SvResFuelPoint = new ServiceResponseOpenFuelPoint();
                        SvResFuelPoint.WorkstationID = workstationID;
                        SvResFuelPoint.ApplicationSender = applicationSender;
                        SvResFuelPoint.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResFuelPoint);
                    }
                    else
                    {
                        if (SvResFuelPoint.RequestType != commandName || Convert.ToInt32(SvResFuelPoint.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvResFuelPoint.RequestID={0}, requestId={1} - end false", SvResFuelPoint.RequestID, requestId));
                            return false;
                        }
                    }
                }
                else
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResDevice = (ServiceResponseOpenDevice)(serviceResponseClientList[key]);
                    if (SvResDevice == null)
                    {
                        SvResDevice = new ServiceResponseOpenDevice();
                        SvResDevice.WorkstationID = workstationID;
                        SvResDevice.ApplicationSender = applicationSender;
                        SvResDevice.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResDevice);
                    }
                    else
                    {
                        if (SvResDevice.RequestType != commandName || Convert.ToInt32(SvResDevice.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvResDevice.RequestID={0}, requestId={1} - end false", SvResDevice.RequestID, requestId));
                            return false;
                        }
                    }
                }

                ServiceResponseFDCdataOpenFuelPoint FDCDataElem = null;
                if (SvResFuelPoint != null && SvResFuelPoint.FDCdata != null)
                    FDCDataElem = SvResFuelPoint.FDCdata[0];
                else if (SvResDevice != null && SvResDevice.FDCdata != null)
                    FDCDataElem = SvResDevice.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataOpenFuelPoint[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataOpenFuelPoint();
                    Array.Resize<ServiceResponseFDCdataOpenFuelPoint>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    //FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                        SvResFuelPoint.FDCdata = FDCDataArray;
                    else
                        SvResDevice.FDCdata = FDCDataArray;
                }


                ServiceResponseDeviceClassOpenFuelPoint fdcDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceResponseDeviceClassOpenFuelPoint fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId))
                            fdcDeviceClassElem = fdcDeviceClassElemTemp;
                }
                if (fdcDeviceClassElem == null && deviceId > 0)
                {
                    fdcDeviceClassElem = new ServiceResponseDeviceClassOpenFuelPoint();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.PumpNo = Convert.ToString(pumpNo);
                    fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                    if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                        fdcDeviceClassElem.DeviceState = deviceStatus.ToString();

                    ServiceResponseDeviceClassOpenFuelPoint[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceResponseDeviceClassOpenFuelPoint>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                    fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                }
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");
            return true;
        }
        public bool OpenFuelPointSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                ServiceResponseOpenFuelPoint SvResFuelPoint = null;
                ServiceResponseOpenDevice SvResDevice = null;
                string commandName = (FDCGlobal.ProtocolVersion == FDCVersion.V0003) ? "OpenFuelPoint" : "OpenDevice";
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + commandName;

                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResFuelPoint = (ServiceResponseOpenFuelPoint)(serviceResponseClientList[key]);
                    if (SvResFuelPoint != null)
                    {
                        if (SvResFuelPoint.RequestType != commandName || Convert.ToInt32(SvResFuelPoint.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvResFuelPoint.RequestID={0}, requestId={1} - end false", SvResFuelPoint.RequestID, requestId));
                            return false;
                        }
                    }
                    else
                    {
                        // send an empty response - no available transaction added
                        SvResFuelPoint = new ServiceResponseOpenFuelPoint();
                        SvResFuelPoint.WorkstationID = workstationID;
                        SvResFuelPoint.ApplicationSender = applicationSender;
                        SvResFuelPoint.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResFuelPoint);

                        ServiceResponseFDCdataOpenFuelPoint FDCDataElem = new ServiceResponseFDCdataOpenFuelPoint();
                        FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                        //FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
                        ServiceResponseFDCdataOpenFuelPoint[] FDCDataArray = { FDCDataElem };
                        SvResFuelPoint.FDCdata = FDCDataArray;
                    }
                    SvResFuelPoint.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                    SvResFuelPoint.OverallResult = overallResult;

                    ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseOpenFuelPoint>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvResFuelPoint);
                }
                else
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResDevice = (ServiceResponseOpenDevice)(serviceResponseClientList[key]);
                    if (SvResDevice != null)
                    {
                        if (SvResDevice.RequestType != commandName || Convert.ToInt32(SvResDevice.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvResDevice.RequestID={0}, requestId={1} - end false", SvResDevice.RequestID, requestId));
                            return false;
                        }
                    }
                    else
                    {
                        // send an empty response - no available transaction added
                        SvResDevice = new ServiceResponseOpenDevice();
                        SvResDevice.WorkstationID = workstationID;
                        SvResDevice.ApplicationSender = applicationSender;
                        SvResDevice.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResDevice);

                        ServiceResponseFDCdataOpenFuelPoint FDCDataElem = new ServiceResponseFDCdataOpenFuelPoint();
                        FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                        //FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
                        ServiceResponseFDCdataOpenFuelPoint[] FDCDataArray = { FDCDataElem };
                        SvResDevice.FDCdata = FDCDataArray;
                    }
                    SvResDevice.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                    SvResDevice.OverallResult = overallResult;

                    ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseOpenDevice>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvResDevice);
                }


                serviceResponseClientList.Remove(key);
                return true;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return false;
        }

        public bool CloseFuelPointAdd(string workstationID, string applicationSender, int requestId, int deviceId, int pumpNo, LogicalDeviceState deviceStatus)
        {
            try
            {
                //FDCPOSManager.tracer.WriteLine("init");
                ServiceResponseCloseFuelPoint SvResFuelPoint = null;
                ServiceResponseCloseDevice SvResDevice = null;
                string commandName = (FDCGlobal.ProtocolVersion == FDCVersion.V0003) ? "CloseFuelPoint" : "CloseDevice";
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + commandName;

                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResFuelPoint = (ServiceResponseCloseFuelPoint)(serviceResponseClientList[key]);
                    if (SvResFuelPoint == null)
                    {
                        SvResFuelPoint = new ServiceResponseCloseFuelPoint();
                        SvResFuelPoint.WorkstationID = workstationID;
                        SvResFuelPoint.ApplicationSender = applicationSender;
                        SvResFuelPoint.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResFuelPoint);
                    }
                    else
                    {
                        if (SvResFuelPoint.RequestType != commandName || Convert.ToInt32(SvResFuelPoint.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvResFuelPoint.RequestID, requestId));
                            return false;
                        }
                    }
                }
                else
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResDevice = (ServiceResponseCloseDevice)(serviceResponseClientList[key]);
                    if (SvResDevice == null)
                    {
                        SvResDevice = new ServiceResponseCloseDevice();
                        SvResDevice.WorkstationID = workstationID;
                        SvResDevice.ApplicationSender = applicationSender;
                        SvResDevice.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResDevice);
                    }
                    else
                    {
                        if (SvResDevice.RequestType != commandName || Convert.ToInt32(SvResDevice.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvRes.RequestID={0}, requestId={1} - end false", SvResDevice.RequestID, requestId));
                            return false;
                        }
                    }
                }

                ServiceResponseFDCdataCloseFuelPoint FDCDataElem = null;
                if (SvResFuelPoint != null && SvResFuelPoint.FDCdata != null)
                    FDCDataElem = SvResFuelPoint.FDCdata[0];
                else if (SvResDevice != null && SvResDevice.FDCdata != null)
                    FDCDataElem = SvResDevice.FDCdata[0];
                else
                {
                    ServiceResponseFDCdataCloseFuelPoint[] FDCDataArray = null;
                    FDCDataElem = new ServiceResponseFDCdataCloseFuelPoint();
                    Array.Resize<ServiceResponseFDCdataCloseFuelPoint>(ref FDCDataArray, (FDCDataArray != null) ? FDCDataArray.Length + 1 : 1);
                    FDCDataArray[FDCDataArray.Length - 1] = FDCDataElem;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    //FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();

                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                        SvResFuelPoint.FDCdata = FDCDataArray;
                    else
                        SvResDevice.FDCdata = FDCDataArray;
                }


                ServiceResponseDeviceClassCloseFuelPoint fdcDeviceClassElem = null;
                if (FDCDataElem.DeviceClass != null)
                {
                    foreach (ServiceResponseDeviceClassCloseFuelPoint fdcDeviceClassElemTemp in FDCDataElem.DeviceClass)
                        if (fdcDeviceClassElemTemp.DeviceID == Convert.ToString(deviceId))
                            fdcDeviceClassElem = fdcDeviceClassElemTemp;
                }
                if (fdcDeviceClassElem == null && deviceId > 0)
                {
                    fdcDeviceClassElem = new ServiceResponseDeviceClassCloseFuelPoint();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.PumpNo = Convert.ToString(pumpNo);
                    fdcDeviceClassElem.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                    if (FDCGlobal.ProtocolVersion >= FDCVersion.V0005)
                        fdcDeviceClassElem.DeviceState = deviceStatus.ToString();

                    ServiceResponseDeviceClassCloseFuelPoint[] fdcDeviceClassArray = FDCDataElem.DeviceClass;
                    Array.Resize<ServiceResponseDeviceClassCloseFuelPoint>(ref fdcDeviceClassArray, (fdcDeviceClassArray != null) ? fdcDeviceClassArray.Length + 1 : 1);
                    fdcDeviceClassArray[fdcDeviceClassArray.Length - 1] = fdcDeviceClassElem;
                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                }
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            //FDCPOSManager.tracer.WriteLine("end");
            return true;
        }
        public bool CloseFuelPointSend(string workstationID, string applicationSender, int requestId, int status, string overallResult)
        {
            try
            {
                ServiceResponseCloseFuelPoint SvResFuelPoint = null;
                ServiceResponseCloseDevice SvResDevice = null;

                string commandName = (FDCGlobal.ProtocolVersion == FDCVersion.V0003) ? "CloseFuelPoint" : "CloseDevice";
                string key = FDCPOSClient.getClientID(workstationID, applicationSender) + commandName;

                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResFuelPoint = (ServiceResponseCloseFuelPoint)(serviceResponseClientList[key]);
                    if (SvResFuelPoint != null)
                    {
                        if (SvResFuelPoint.RequestType != commandName || Convert.ToInt32(SvResFuelPoint.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvResFuelPoint.RequestID={0}, requestId={1} - end false", SvResFuelPoint.RequestID, requestId));
                            return false;
                        }
                    }
                    else
                    {
                        // send an empty response - no available transaction added
                        SvResFuelPoint = new ServiceResponseCloseFuelPoint();
                        SvResFuelPoint.WorkstationID = workstationID;
                        SvResFuelPoint.ApplicationSender = applicationSender;
                        SvResFuelPoint.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResFuelPoint);

                        ServiceResponseFDCdataCloseFuelPoint FDCDataElem = new ServiceResponseFDCdataCloseFuelPoint();
                        FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                        //FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
                        ServiceResponseFDCdataCloseFuelPoint[] FDCDataArray = { FDCDataElem };
                        SvResFuelPoint.FDCdata = FDCDataArray;
                    }
                    SvResFuelPoint.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                    SvResFuelPoint.OverallResult = overallResult;

                    ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseCloseFuelPoint>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvResFuelPoint);
                }
                else
                {
                    if (serviceResponseClientList.ContainsKey(key))
                        SvResDevice = (ServiceResponseCloseDevice)(serviceResponseClientList[key]);
                    if (SvResDevice != null)
                    {
                        if (SvResDevice.RequestType != commandName || Convert.ToInt32(SvResDevice.RequestID) != requestId)
                        {
                            //FDCPOSManager.tracer.WriteLine(string.Format("SvResDevice.RequestID={0}, requestId={1} - end false", SvResDevice.RequestID, requestId));
                            return false;
                        }
                    }
                    else
                    {
                        // send an empty response - no available transaction added
                        SvResDevice = new ServiceResponseCloseDevice();
                        SvResDevice.WorkstationID = workstationID;
                        SvResDevice.ApplicationSender = applicationSender;
                        SvResDevice.RequestID = requestId.ToString();
                        serviceResponseClientList.Add(key, SvResDevice);

                        ServiceResponseFDCdataCloseFuelPoint FDCDataElem = new ServiceResponseFDCdataCloseFuelPoint();
                        FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                        //FDCDataElem.FDCStatus = ((ErrorCode)status).ToString();
                        ServiceResponseFDCdataCloseFuelPoint[] FDCDataArray = { FDCDataElem };
                        SvResDevice.FDCdata = FDCDataArray;
                    }
                    SvResDevice.FDCdata[0].FDCStatus = ((ErrorCode)status).ToString();
                    SvResDevice.OverallResult = overallResult;

                    ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseCloseDevice>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvResDevice);
                }
                serviceResponseClientList.Remove(key);
                return true;
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return false;
        }

        public bool GenericTypelessMessageSend(string workstationID, string applicationSender, int requestId, string responseMessage, string overallResult)
        {
            try
            {
                ServiceResponseGenericTypelessMessage response = new ServiceResponseGenericTypelessMessage();

                //FDCPOSManager.tracer.WriteLine("init");
                response.OverallResult = overallResult;
                response.WorkstationID = workstationID;
                response.ApplicationSender = applicationSender;
                response.RequestID = requestId.ToString();
                response.OverallResult = overallResult;

                FDCMessageFDCdataGenericTypelessMessage FDCDataElem = new FDCMessageFDCdataGenericTypelessMessage();
                FDCDataElem.Message = responseMessage;
                //ServiceResponseDeviceClassReserveFuelPoint[] fdcDeviceClassArray = { fdcDeviceClassElem };
                FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

                FDCMessageFDCdataGenericTypelessMessage[] FDCDataArray = { FDCDataElem };

                response.FDCdata = FDCDataArray;

                ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseGenericTypelessMessage>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], response);
                //FDCPOSManager.tracer.WriteLine("end");
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
            }
            return false;
        }


        #endregion

        #region OPT Messages
        public void OptRead(string deviceType, int deviceId, byte[] message)
        {
            string workstationID = "", applicationSender = "";

            //FDCPOSManager.tracer.WriteLine(string.Format("init: Id={0}", deviceId));
            Monitor.Enter(fdcPosManager.fdcClientList);
            try
            {
                foreach (string sID in fdcPosManager.fdcClientList.Keys)
                {
                    if (!fdcPosManager.fdcClientList[sID].connected || !fdcPosManager.fdcClientList[sID].logon)
                        continue;

                    workstationID = fdcPosManager.fdcClientList[sID].workstationID;
                    applicationSender = fdcPosManager.fdcClientList[sID].applicationSender;

                    FDCMessageOPTRead dsc = new FDCMessageOPTRead();
                    dsc.WorkstationID = workstationID;
                    dsc.ApplicationSender = applicationSender;
                    dsc.MessageID = FDCPOSManager.messageIdCounter.ToString();
                    FDCMessageFDCdataOPTRead FDCDataElem = new FDCMessageFDCdataOPTRead();

                    FDCMessageDeviceClassOPTRead fdcDeviceClassElem = new FDCMessageDeviceClassOPTRead();
                    fdcDeviceClassElem.DeviceID = Convert.ToString(deviceId);
                    fdcDeviceClassElem.Type = deviceType;
                    fdcDeviceClassElem.Message = message;
                    FDCMessageDeviceClassOPTRead[] fdcDeviceClassArray = { fdcDeviceClassElem };

                    FDCDataElem.DeviceClass = fdcDeviceClassArray;
                    FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);
                    FDCMessageFDCdataOPTRead[] FDCDataArray = { FDCDataElem };

                    dsc.FDCdata = FDCDataArray;

                    SendFDCMessage<FDCMessageOPTRead>(fdcPosManager.fdcClientList[sID], dsc);
                }
            }
            catch (Exception ex)
            {
                //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            finally
            {
                Monitor.Exit(fdcPosManager.fdcClientList);
            }
            //FDCPOSManager.tracer.WriteLine("end");
        }

        #endregion

        #region OPT ServiceResponces
        public void OptAdd(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine(string.Format("init: Id={0}", deviceId));
            ServiceResponseOPTAdd SvRes = new ServiceResponseOPTAdd();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataOPTAdd FDCDataElem = new ServiceResponseFDCdataOPTAdd();
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

            ServiceResponseDeviceClassOPTAdd deviceClass = new ServiceResponseDeviceClassOPTAdd();
            deviceClass.DeviceID = Convert.ToString(deviceId);
            deviceClass.Type = deviceType;

            FDCDataElem.DeviceClass = deviceClass;
            ServiceResponseFDCdataOPTAdd[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseOPTAdd>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void OptRemove(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine(string.Format("init: Id={0}", deviceId));
            ServiceResponseOPTRemove SvRes = new ServiceResponseOPTRemove();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataOPTRemove FDCDataElem = new ServiceResponseFDCdataOPTRemove();
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

            ServiceResponseDeviceClassOPTRemove deviceClass = new ServiceResponseDeviceClassOPTRemove();
            deviceClass.DeviceID = Convert.ToString(deviceId);
            deviceClass.Type = deviceType;

            FDCDataElem.DeviceClass = deviceClass;
            ServiceResponseFDCdataOPTRemove[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseOPTRemove>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        public void OptWrite(string workstationID, string applicationSender, int requestId, string deviceType, int deviceId, string overallResult)
        {
            //FDCPOSManager.tracer.WriteLine(string.Format("init: Id={0}", deviceId));
            ServiceResponseOPTWrite SvRes = new ServiceResponseOPTWrite();
            SvRes.WorkstationID = workstationID;
            SvRes.ApplicationSender = applicationSender;
            SvRes.RequestID = requestId.ToString();
            SvRes.OverallResult = overallResult;

            ServiceResponseFDCdataOPTWrite FDCDataElem = new ServiceResponseFDCdataOPTWrite();
            FDCDataElem.FDCTimeStamp = FDCConvert.ToString(DateTime.Now);

            ServiceResponseDeviceClassOPTWrite deviceClass = new ServiceResponseDeviceClassOPTWrite();
            deviceClass.DeviceID = Convert.ToString(deviceId);
            deviceClass.Type = deviceType;

            FDCDataElem.DeviceClass = deviceClass;
            ServiceResponseFDCdataOPTWrite[] FDCDataArray = { FDCDataElem };

            SvRes.FDCdata = FDCDataArray;

            ((FDCPOSInterfaceServerManager)fdcPosManager).FdcServerTcpHandler.SendResponse<ServiceResponseOPTWrite>(fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationID, applicationSender)], SvRes);
            //FDCPOSManager.tracer.WriteLine("end");
        }

        #endregion
    }
}