FCC/Applications/FdcServer/FDCPOSInterfaceServer/socketmgr.cs

using System;
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 Wayne.OptInterface;
using Wayne.FDCPOSInterface.Configuration;


namespace Wayne.FDCPOSInterface
{
    using Microsoft.Extensions.DependencyInjection;
    using Microsoft.Extensions.Logging;
    using System.Linq;
    using System.Xml.Schema;


    public sealed class SchemasSG
    {
        private static readonly object instLock = new object();
        private static Dictionary<string, XmlSchemaSet> schemasSG;

        private static SchemasSG _instance;
        public static SchemasSG Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (instLock) // make it multithread safe
                    {
                        if (_instance == null)
                        {
                            _instance = new SchemasSG();

                        }
                    }
                }
                return _instance;

            }
        }
        public Dictionary<string, XmlSchemaSet> GetSchemas
        {
            get { return schemasSG; }

        }
        private SchemasSG()
        {
            schemasSG = new Dictionary<string, XmlSchemaSet>();

            // read schemas from resource files
            Assembly a = Assembly.GetExecutingAssembly();
            string name = a.GetName().Name;
            string sBasicTypeName = "SchemasSG.FDC_Basic_Types.xsd";
            Stream sBasicTypes = a.GetManifestResourceStream(name + "." + sBasicTypeName);
            XmlSchema sBasicTypesSchema = XmlSchema.Read(sBasicTypes, ValidationCallback);
            //FDCPOSManager.tracer.WriteLine("BasicTypes Name: " + name + "." + sBasicTypeName);

            foreach (string resource in a.GetManifestResourceNames())
            {

                if (resource.EndsWith(".xsd"))
                {
                    try
                    {
                        //FDCPOSManager.tracer.WriteLine("Schema Name: " + resource);
                        string shortName = resource.Substring(name.Length + 1);  // get rid of Assembly name
                        if (!sBasicTypeName.Equals(shortName))
                        {
                            shortName = shortName.Substring(shortName.IndexOf(".") + 1); // get rid of the folder name SchemasSG
                            shortName = shortName.Substring(0, shortName.Length - 4); // get rid of ".xsd"
                            //FDCPOSManager.tracer.WriteLine("schema name: " + shortName);

                            Stream s = Assembly.GetExecutingAssembly().GetManifestResourceStream(resource);
                            {
                                schemasSG[shortName] = new XmlSchemaSet();
                                schemasSG[shortName].Add(XmlSchema.Read(s, ValidationCallback));
                                schemasSG[shortName].Add(sBasicTypesSchema); // add this basic type to every node
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        //FDCPOSManager.tracer.WriteLine("Exception in Schemas! " + ex.Message);
                    }

                }
            }

        }

        static void ValidationCallback(object sender, ValidationEventArgs args)
        {
            //if (args.Severity == XmlSeverityType.Warning)
            //    FDCPOSManager.tracer.Write("WARNING: ");
            //else if (args.Severity == XmlSeverityType.Error)
            //    FDCPOSManager.tracer.Write("ERROR: ");

            //FDCPOSManager.tracer.WriteLine(args.Message);
        }

    }

    public class FdcClientTcpHandler : IDisposable
    {
        private bool disposed = false;
        //static NLog.Logger fdcSocketLogger = NLog.LogManager.LoadConfiguration("nlog.config").GetLogger("FdcServerSocket");
        private ILogger fdcSocketLogger;
        //= ServiceBuilder.Provider
        //.GetRequiredService<ILoggerFactory>().CreateLogger("FdcServerSocket");
        private MD5Crypter crypter = new MD5Crypter();

        /// <summary>
        /// ip:port, used for logging
        /// </summary>
        public string TcpClientEndPointString { get; private set; }

        private TcpClient tcpClient;
        public TcpClient TcpClient { get { return this.tcpClient; } }

        private FDCPOSManager fdcposManager;
        private FdcServerTcpHandler fdcServerTcpHandler;

        public string workstationID = "";
        public string applicationSender = "";

        /// <summary>
        /// fired on get tcp level error, mostly likely the tcp is broken
        /// </summary>
        public event EventHandler OnCommunicatingError;

        public FdcClientTcpHandler(FDCPOSManager _fdcposManager, FdcServerTcpHandler _fdcServerTcpHandler,
            TcpClient tcpClient, ILogger logger)
        {
            this.fdcposManager = _fdcposManager;
            this.fdcServerTcpHandler = _fdcServerTcpHandler;
            this.tcpClient = tcpClient;
            this.fdcSocketLogger = logger;
        }


        private void OnTcpClientDataRead(IAsyncResult ar)
        {
            NetworkStream networkStream;
            byte[] buffer = null;
            int readCount = 0;
            int previousReadCount = 0;
            Action<byte[], NetworkStream> callback = null;
            int expectingMsgLength = 0;
            try
            {
                //tuple is: ns, readBuffer, offset, readFullMsgCallback, expectingLengthToRead
                var parameter = (ar.AsyncState as Tuple<NetworkStream, byte[], int, Action<byte[], NetworkStream>, int>);
                networkStream = parameter.Item1;
                buffer = parameter.Item2;
                previousReadCount = parameter.Item3;
                callback = parameter.Item4;
                expectingMsgLength = parameter.Item5;

                readCount = networkStream.EndRead(ar);
                if (readCount == 0)
                    throw new Exception("tcp client received 0 count data which indicates the connection is broken, trigger disconnection");
            }
            catch (Exception eee)
            {
                fdcSocketLogger.LogError("EndRead Fdc client tcpClient NetworkStream exceptioned: " + eee
                    + "\r\n will treat as OnCommunicatingError, this client with its Ip and port: " + this.TcpClientEndPointString);
                this.OnCommunicatingError?.Invoke(this, null);
                return;
            }

            if ((readCount + previousReadCount) < expectingMsgLength)
            {
                try
                {
                    var _ = networkStream.BeginRead(buffer, (readCount + previousReadCount),
                        (expectingMsgLength - (readCount + previousReadCount)),
                        this.OnTcpClientDataRead,
                        new Tuple<NetworkStream, byte[], int, Action<byte[], NetworkStream>, int>(
                            networkStream, buffer, readCount + previousReadCount, callback, expectingMsgLength));
                }
                catch (Exception eee)
                {
                    fdcSocketLogger.LogError("Continue BeginRead Fdc client tcpClient NetworkStream exceptioned: " + eee
                        + "\r\n will treat as OnCommunicatingError, this client with its Ip and port: " + this.TcpClientEndPointString);
                    this.OnCommunicatingError?.Invoke(this, null);
                    return;
                }
            }
            else
            {
                try
                {
                    callback(buffer, networkStream);
                }
                catch (Exception xxx)
                {
                    fdcSocketLogger.LogError("Callback in OnTcpClientDataRead exceptioned: " + xxx
                        + "\r\n will ignore the error");
                }
            }
        }

        private void ProcessMessageHeader(byte[] headerBuffer, NetworkStream networkStream)
        {
            try
            {
                int msgBodyLength = FdcClientTcpHandler.getMsgLength(headerBuffer);
                if (this.fdcSocketLogger.IsEnabled(LogLevel.Debug))
                    this.fdcSocketLogger.LogDebug($"Received a msg with BodyLength: {msgBodyLength}, will further parsing...");
                if (msgBodyLength >= 19999) throw new ArgumentOutOfRangeException("MsgBodyLength: " + msgBodyLength + " is too big and unlikely a valid message");
                byte[] bodyBuffer = new byte[msgBodyLength];
                var r = networkStream.BeginRead(bodyBuffer, 0, msgBodyLength,
                        this.OnTcpClientDataRead,
                        //ns, readBuffer, offset, readFullMsgCallback, expectingLengthToRead
                        new Tuple<NetworkStream, byte[], int, Action<byte[], NetworkStream>, int>(
                            networkStream, bodyBuffer, 0,
                            (bodyBuffer, __) =>
                            {
                                this.ParseServiceRequestOrFdcMessageFromRaw(bodyBuffer, __, msgBodyLength, headerBuffer);
                                this.StartReadingDataFromClient();
                            },
                            msgBodyLength));
            }
            catch (Exception exxx)
            {
                fdcSocketLogger.LogError("BeginRead Fdc client tcpClient NetworkStream(ProcessMessageHeader) exceptioned: " + exxx
                    + "\r\n will treat as OnCommunicatingError, this client with its Ip and port: " + this.TcpClientEndPointString);
                this.OnCommunicatingError?.Invoke(this, null);
                return;
            }

        }

        private void ParseServiceRequestOrFdcMessageFromRaw(byte[] bodyBuffer, NetworkStream networkStream, int msgLength, byte[] headerBytes)
        {
            var message = Encoding.UTF8.GetString(bodyBuffer);
            if (fdcSocketLogger.IsEnabled(LogLevel.Trace))
            {
                // set a trace since the heartbeat msg is so frenquency and causing too much logging
                fdcSocketLogger.LogTrace($"Parsing ServiceRequest Or FdcMessage from raw incoming message: {message ?? ""}");
            }

            var result = OverallResult.Success;
            string sEndmsg = "";

            //no trailing spaces xml message
            string exactXmlMsgStr = "";
            int indexEndMsgSR = -1, indexEndFDCMsg = -1, indexEnd = -1;
            indexEndMsgSR = message.IndexOf("</ServiceRequest>");
            indexEndFDCMsg = message.IndexOf("</FDCMessage>");

            #region parse

            if (indexEndMsgSR >= 0 && indexEndFDCMsg >= 0)
            {
                indexEnd = System.Math.Min(indexEndMsgSR, indexEndFDCMsg);
                if (indexEndMsgSR < indexEndFDCMsg)
                {
                    sEndmsg = "</ServiceRequest>";
                    indexEndFDCMsg = -1;
                }
                else
                {
                    sEndmsg = "</FDCMessage>";
                    indexEndMsgSR = -1;
                }
            }
            else if (indexEndMsgSR >= 0 && indexEndFDCMsg < 0)
            {
                indexEnd = indexEndMsgSR;
                sEndmsg = "</ServiceRequest>";
            }
            else if (indexEndMsgSR < 0 && indexEndFDCMsg >= 0)
            {
                indexEnd = indexEndFDCMsg;
                sEndmsg = "</FDCMessage>";
            }
            else
                this.fdcSocketLogger.LogError("how a full MessageBody neither contains </ServiceRequest> nor </FDCMessage>, not a valid Fdc msg, will ignore it");

            #endregion

            if (indexEnd >= 0)
            {
                exactXmlMsgStr = message.Substring(0, indexEnd + sEndmsg.Length);
                message = message.Substring(indexEnd + sEndmsg.Length);
                if (fdcposManager.encryptedHeader)
                {
                    var hashingTarget = exactXmlMsgStr + MD5Crypter.passphrase;
                    if (!crypter.verifyMD5Hash(hashingTarget,
                        headerBytes.Skip(Define.HeaderLength).Take(Define.EncriptionLength).Select(h => h.ToString("x2")).Aggregate((acc, n) => acc + n)))
                    {
                        if (fdcSocketLogger.IsEnabled(LogLevel.Information))
                            fdcSocketLogger.LogInformation("verifyMD5Hash failed for msg from " + this.TcpClientEndPointString +
                                ", the computed&expecting hash string: " + crypter.getMD5Hash(hashingTarget) +
                                ", the hashing target(incomingMsg+passcode): \r\n" +
                                hashingTarget);
                        result = OverallResult.ValidationError;
                    }
                }

                if (exactXmlMsgStr.Length > 0)
                {
                    this.fdcServerTcpHandler.ReadRequest(this, exactXmlMsgStr, msgLength, (indexEndMsgSR > 0) ? true : false, ref result);
                }
            }
        }

        public void StartReadingDataFromClient()
        {
            if (this.tcpClient == null || !this.tcpClient.Connected) return;
            try
            {
                this.TcpClientEndPointString = ((IPEndPoint)(tcpClient.Client.RemoteEndPoint)).ToString();
            }
            catch { }

            try
            {
                NetworkStream networkStream = this.tcpClient.GetStream();
                var headerBuffer = new byte[Define.HeaderLength + Define.EncriptionLength];
                var _ = networkStream.BeginRead(headerBuffer, 0, (Define.HeaderLength + Define.EncriptionLength),
                        this.OnTcpClientDataRead,
                        //ns, readBuffer, offset, readFullMsgCallback, expectingLengthToRead
                        new Tuple<NetworkStream, byte[], int, Action<byte[], NetworkStream>, int>(
                            networkStream, headerBuffer, 0, this.ProcessMessageHeader, (Define.HeaderLength + Define.EncriptionLength)));
            }
            catch (Exception exxx)
            {
                fdcSocketLogger.LogError("Get or BeginRead Fdc client tcpClient NetworkStream exceptioned: " + exxx
                    + "\r\n will ignore this client");
                this.OnCommunicatingError?.Invoke(this, null);
                return;
            }
        }

        static public int getMsgLength(byte[] header)
        {
            int length = 0;
            for (int pos = 1; pos <= Define.HeaderLength; pos++)
            {
                length |= ((int)(header[pos - 1] << (Define.HeaderLength - pos) * 8));
            }
            return length;
        }

        public void Dispose()
        {
            try
            {
                this.disposed = true;
                this.tcpClient.Close();
            }
            catch { }
            finally { }
        }
    }

    public class FdcServerTcpHandler : IDisposable
    {
        private List<FdcClientTcpHandler> fdcClientTcpHandlers = new List<FdcClientTcpHandler>();
        //protected static NLog.Logger fdcSocketLogger = NLog.LogManager.LoadConfiguration("nlog.config").GetLogger("FdcServerSocket");
        protected ILogger fdcSocketLogger;// = ServiceBuilder.Provider.GetRequiredService<ILoggerFactory>().CreateLogger("FdcServerSocket");
        private bool disposed = false;
        protected FDCPOSManager fdcPosManager;
        protected TcpListener tcpListener;
        protected int iIPPort;
        private bool traceXML = false;

        public FDCPOSInterfaceServer FdcPosInterface { get; set; }

        public int IPPort
        {
            get { return iIPPort; }
            set { iIPPort = value; }
        }

        public FdcServerTcpHandler(FDCPOSManager _fdcPosManager, int _iIPPort, ILogger logger)
        {
            this.fdcSocketLogger = logger;
            fdcPosManager = _fdcPosManager;
            iIPPort = _iIPPort;
        }

        public bool StartListening()
        {
            try
            {
                this.tcpListener = new TcpListener(IPAddress.Any, iIPPort);
                this.tcpListener.Start();
                var _ = this.tcpListener.BeginAcceptTcpClient(this.OnTcpClientAccepted, null);
                this.fdcSocketLogger.LogInformation("FdcServerTcpHandler is listening on port: " + iIPPort);
                return true;
            }
            catch (Exception exxx)
            {
                fdcSocketLogger.LogError("Listening port: " + iIPPort + " exceptioned: " + exxx
                    + "\r\n will QUIT listening");
                throw;
            }
        }

        private void OnTcpClientAccepted(IAsyncResult ar)
        {
            TcpClient tcpClient = null;
            try
            {
                tcpClient = this.tcpListener.EndAcceptTcpClient(ar);
                this.fdcSocketLogger.LogDebug("A Tcp client: " + ((IPEndPoint)(tcpClient.Client.RemoteEndPoint)).ToString() + " has connected in...");
            }
            catch (Exception exxx)
            {
                fdcSocketLogger.LogError($"TcpListener EndAcceptTcpClient exceptioned: {exxx.ToString() + Environment.NewLine}will continue listening(depends on is app shuting down)");
                return;
            }
            finally
            {
                if (!this.disposed)
                    tcpListener.BeginAcceptTcpClient(this.OnTcpClientAccepted, null);
            }

            var fdcClientTcpHandler = new FdcClientTcpHandler(fdcPosManager, this, tcpClient, this.fdcSocketLogger);
            fdcClientTcpHandler.OnCommunicatingError += (s, e) =>
            {

                #region clean up

                fdcClientTcpHandler.Dispose();
                string fdcClientId = FDCPOSClient.getClientID(fdcClientTcpHandler.workstationID, fdcClientTcpHandler.applicationSender);
                try
                {
                    if (this.fdcPosManager.fdcClientList.ContainsKey(fdcClientId))
                    {
                        fdcSocketLogger.LogInformation(string.Format("Cleaning up existed FdcClient '{0}' which from remote: {1}",
                            fdcClientId,
                            fdcClientTcpHandler.TcpClientEndPointString));
                        this.fdcPosManager.DisconnectClient(this.fdcPosManager.fdcClientList[fdcClientId]);
                    }
                }
                catch (Exception eeee)
                {
                    fdcSocketLogger.LogInformation(string.Format("Cleaning up existed FdcClient '{0}', from remote: {1} exceptioned: \r\n {2}",
                        fdcClientId,
                        fdcClientTcpHandler.TcpClientEndPointString,
                        eeee));
                }

                #endregion

            };
            fdcClientTcpHandler.StartReadingDataFromClient();
            this.fdcClientTcpHandlers.Add(fdcClientTcpHandler);
        }

        public string ReadRequest(FdcClientTcpHandler fdcClientTcpHandler, string message, int msglength,
            bool isServiceRequest, ref OverallResult result)
        {
            OverallResult extresult = result;
            ErrorCode iFDCStatus = (int)ErrorCode.ERRCD_OK;
            int requestId = -1;
            string requestType = (isServiceRequest) ? GetRequestType(message) : GetMessageType(message);
            string applicationSender = GetApplicationSender(message);
            string workstationId = GetWorkstationID(message);

            if (string.IsNullOrEmpty(requestType))
            {
                fdcSocketLogger.LogInformation(string.Format("Client with applicationSender={0}, workstationId={1} is " +
                               "sending in a message that Fcc resolved an empty or null requestType from it, unlikely an valid format message:{2}{3}",
                               applicationSender, workstationId, Environment.NewLine, (message ?? "")));
                result = OverallResult.NoData;
                iFDCStatus = ErrorCode.ERRCD_BADVAL;
                ((FDCPOSInterfaceServerManager)this.fdcPosManager).fdcPosInterface.messages.SendErrorResponse(requestType, workstationId, applicationSender, requestId, iFDCStatus, result.ToString());
                return requestType;
            }
            try
            {
                //FDCPOSManager.tracer.WriteLine(string.Format("init requestType='{0}'", requestType));
                if (fdcSocketLogger.IsEnabled(LogLevel.Trace))
                    fdcSocketLogger.LogTrace($"Parsed the incoming Request, requestType: {requestType ?? ""}, applicationSender: {applicationSender ?? ""}, workstationId: {workstationId ?? ""}, message: {Environment.NewLine} {message ?? ""}");
                if (fdcSocketLogger.IsEnabled(LogLevel.Debug))
                    if (requestType != "POSHeartBeat")
                        fdcSocketLogger.LogTrace($"Parsed the incoming Request, requestType: {requestType ?? ""}, applicationSender: {applicationSender ?? ""}, workstationId: {workstationId ?? ""}, message: {Environment.NewLine} {message ?? ""}");

                if (requestType != "LogOn")
                {
                    if (!this.fdcPosManager.fdcClientList.ContainsKey(FDCPOSClient.getClientID(workstationId, applicationSender)))
                    {
                        FDCPOSClient fdcposClient = new FDCPOSClient(fdcPosManager, null, this.fdcSocketLogger);
                        fdcposClient.workstationID = workstationId;
                        fdcposClient.applicationSender = applicationSender;
                        IPEndPoint endpoint = (IPEndPoint)(fdcClientTcpHandler.TcpClient.Client.RemoteEndPoint);
                        string sIPAddress = endpoint.Address.ToString();
                        fdcposClient.sIPAddress = sIPAddress;
                        fdcposClient.FdcClientTcpHandler = fdcClientTcpHandler;
                        fdcposClient.connected = true;
                        fdcposClient.socketChannelResponse = fdcClientTcpHandler.TcpClient;
                        fdcClientTcpHandler.workstationID = workstationId;
                        fdcClientTcpHandler.applicationSender = applicationSender;
                        fdcPosManager.fdcClientList.Add(FDCPOSClient.getClientID(workstationId, applicationSender), fdcposClient);

                        if (this.fdcSocketLogger.IsEnabled(LogLevel.Debug))
                            this.fdcSocketLogger.LogDebug(string.Format("Unknown Client with appSender={0}, wId={1} is " +
                                "sending Request(type={2}) in without log on, Will response: AuthentificationError",
                                applicationSender, workstationId, requestType));
                        result = OverallResult.AuthentificationError;
                        iFDCStatus = ErrorCode.ERRCD_COMMERR;
                        ((FDCPOSInterfaceServerManager)this.fdcPosManager).fdcPosInterface.messages.SendErrorResponse(requestType, workstationId, applicationSender, requestId, iFDCStatus, result.ToString());
                        fdcPosManager.fdcClientList.Remove(FDCPOSClient.getClientID(workstationId, applicationSender));
                        return requestType;
                    }

                    if (result == OverallResult.Success && extresult == OverallResult.Success)
                    {
                        fdcPosManager.fdcClientList[FDCPOSClient.getClientID(workstationId, applicationSender)].heartbeat.StopClientDisconnectionTimer();
                    }
                }

                if (requestType == "POSHeartBeat")
                {
                    if (fdcSocketLogger.IsEnabled(LogLevel.Debug))
                        this.fdcSocketLogger.LogDebug(string.Format("Received a POSHeartBeat from applicationSender: {0}, workstationId: {1}", (applicationSender ?? ""), (workstationId ?? "")));
                    //    if (isServiceRequest)
                    //    {
                    //        ServiceRequestHeartbeat sr = Deserialize<ServiceRequestHeartbeat>(myString, ref result);
                    //        if (!this.fdcposManager.tcpClientList.ContainsKey(FDCPOSClient.getClientID(sr.WorkstationID, sr.ApplicationSender)))
                    //            result = OverallResult.AuthentificationError;
                    //        if (sr != null && result == OverallResult.Success && extresult == OverallResult.Success)
                    //        {
                    //            fdcposManager.tcpClientList[FDCPOSClient.getClientID(sr.WorkstationID, sr.ApplicationSender)].heartbeat.ResetDisconnectionTimeout();
                    //        }
                    //    }
                    //    else
                    //    {
                    //        FDCMessageFDCHeartbeat sr = Deserialize<FDCMessageFDCHeartbeat>(myString, ref result);
                    //        if (!this.fdcposManager.tcpClientList.ContainsKey(FDCPOSClient.getClientID(sr.WorkstationID, sr.ApplicationSender)))
                    //            result = OverallResult.AuthentificationError;
                    //        if (sr != null && result == OverallResult.Success && extresult == OverallResult.Success)
                    //        {
                    //            fdcposManager.tcpClientList[FDCPOSClient.getClientID(sr.WorkstationID, sr.ApplicationSender)].heartbeat.ResetDisconnectionTimeout();
                    //        }
                    //    }
                }
                else if (requestType == "LogOn")
                {
                    ServiceRequestLogOn sr = Deserialize<ServiceRequestLogOn>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;

                        if (sr.POSdata.GetLength(0) == 0)
                            result = OverallResult.MissingMandatoryData;
                        else
                        {
                            int iResponsePort = Convert.ToInt32(sr.POSdata[0].ResponsePort);
                            if (iResponsePort == 0)
                                iResponsePort = this.IPPort;
                            int iUnsolicitedPort = Convert.ToInt32(sr.POSdata[0].UnsolicitedPort);
                            if (iUnsolicitedPort == 0)
                                iUnsolicitedPort = this.IPPort;
                            fdcSocketLogger.LogInformation(string.Format("Client with WorkstationId: {0}, ApplicationSender: {1}, InterfaceVersion: {2} from {3} is logging on",
                                sr.WorkstationID,
                                sr.ApplicationSender,
                                (sr.POSdata?.FirstOrDefault()?.interfaceVersion ?? ""),
                                ((IPEndPoint)(fdcClientTcpHandler.TcpClient.Client.RemoteEndPoint)).ToString()
                                ));
                            if (sr.POSdata[0].interfaceVersion != null)
                            {
                                //FDCPOSManager.tracer.WriteLine(string.Format("sr.POSdata[0].interfaceVersion='{0}'", sr.POSdata[0].interfaceVersion));
                                if (sr.POSdata[0].interfaceVersion == "00.07")
                                    FDCGlobal.ProtocolVersion = FDCVersion.V0007;
                                else if (sr.POSdata[0].interfaceVersion == "00.05")
                                    FDCGlobal.ProtocolVersion = FDCVersion.V0005;
                                else if (sr.POSdata[0].interfaceVersion == "00.03")
                                    FDCGlobal.ProtocolVersion = FDCVersion.V0003;
                                //FDCPOSManager.tracer.WriteLine(string.Format("interfaceVersion set"));

                            }
                            //FDCPOSManager.tracer.WriteLine(string.Format("this.fdcposManager.forecourtConfiguration={0}", this.fdcposManager.forecourtConfiguration));
                            //FDCPOSManager.tracer.WriteLine(string.Format("test={0}", sr.POSdata[0].ValidationInfo != null && (this.fdcposManager.forecourtConfiguration != "Q8-DENMARK" && this.fdcposManager.forecourtConfiguration != "WINCOR")));
                            if (sr.POSdata[0].ValidationInfo != null && (this.fdcPosManager.forecourtConfiguration != "Q8-DENMARK" && this.fdcPosManager.forecourtConfiguration != "WINCOR"))
                            {
                                string filename = "", version = "", ssigncheck = "", CRC = "", binaryCRC = "", versionCRC = "", addInfo = "";
                                string softsealfilename = "", softsealversion = "", binarysoftsealCRC = "", versionsoftsealCRC = "";
                                bool signaturecheck = false, softsealadded = false;
                                DESCrypter crypter = new DESCrypter();

                                try
                                {
                                    Monitor.Enter(fdcPosManager);
                                    foreach (byte[] validationInfoElem in sr.POSdata[0].ValidationInfo)
                                    {
                                        byte[] data = crypter.Decrypt(validationInfoElem);
                                        if (data != null && data.Length > 0)
                                        {
                                            signaturecheck = false;

                                            string s = System.Text.Encoding.UTF8.GetString(data, 0, data.GetLength(0));
                                            //FDCPOSManager.tracer.WriteLine(string.Format("validation string='{0}'", s));
                                            filename = s.Substring(0, s.IndexOf("###"));
                                            //FDCPOSManager.tracer.WriteLine(string.Format("filename='{0}'", filename));
                                            s = s.Substring(s.IndexOf("###") + 3);
                                            version = s.Substring(0, s.IndexOf("###"));
                                            //FDCPOSManager.tracer.WriteLine(string.Format("version='{0}'", version));
                                            s = s.Substring(s.IndexOf("###") + 3);
                                            ssigncheck = s.Substring(0, s.IndexOf("###"));
                                            //FDCPOSManager.tracer.WriteLine(string.Format("ssigncheck='{0}'", ssigncheck));
                                            signaturecheck = (ssigncheck == "1") ? true : false;
                                            s = s.Substring(s.IndexOf("###") + 3);
                                            CRC = s.Substring(0, s.IndexOf("###"));
                                            if (CRC.IndexOf("-") >= 0)
                                            {
                                                binaryCRC = CRC.Substring(0, CRC.IndexOf("-"));
                                                versionCRC = CRC.Substring(CRC.IndexOf("-") + 1);
                                            }
                                            else
                                                versionCRC = CRC;
                                            //FDCPOSManager.tracer.WriteLine(string.Format("binaryCRC='{0}', versionCRC'{1}'", binaryCRC, versionCRC));
                                            s = s.Substring(s.IndexOf("###") + 3);
                                            softsealfilename = s.Substring(0, s.IndexOf("###"));
                                            //FDCPOSManager.tracer.WriteLine(string.Format("softsealfilename='{0}'", softsealfilename));
                                            s = s.Substring(s.IndexOf("###") + 3);
                                            softsealversion = s.Substring(0, s.IndexOf("###"));
                                            //FDCPOSManager.tracer.WriteLine(string.Format("softsealversion='{0}'", softsealversion));
                                            s = s.Substring(s.IndexOf("###") + 3);
                                            if (s.IndexOf("###") == -1)
                                                CRC = s;
                                            else
                                            {
                                                CRC = s.Substring(0, s.IndexOf("###"));
                                                s = s.Substring(s.IndexOf("###") + 3);
                                                addInfo = s;
                                            }
                                            if (CRC.IndexOf("-") >= 0)
                                            {
                                                binarysoftsealCRC = CRC.Substring(0, CRC.IndexOf("-"));
                                                versionsoftsealCRC = CRC.Substring(CRC.IndexOf("-") + 1);
                                            }
                                            else
                                                versionsoftsealCRC = CRC;
                                            //FDCPOSManager.tracer.WriteLine(string.Format("binarysoftsealCRC='{0}', versionsoftsealCRC'{1}'", binarysoftsealCRC, versionsoftsealCRC));

                                            if (softsealfilename != "" && !softsealadded)
                                            {
                                                //FDCPOSManager.tracer.WriteLine(string.Format("validate add file='{0}', version={1}", softsealfilename, softsealversion));
                                                this.FdcPosInterface.ValidateSealAddReq(softsealfilename.Substring(softsealfilename.LastIndexOf('\\') + 1), softsealversion, (((FDCPOSInterfaceServerManager)this.fdcPosManager).certificate == certificateType.MID) ? binarysoftsealCRC : versionsoftsealCRC, "");
                                                softsealadded = true;
                                            }
                                            if (signaturecheck)
                                            {
                                                //FDCPOSManager.tracer.WriteLine(string.Format("validate add file='{0}', version={1}", filename, version));
                                                this.FdcPosInterface.ValidateSealAddReq(filename.Substring(filename.LastIndexOf('\\') + 1), version, (((FDCPOSInterfaceServerManager)this.fdcPosManager).certificate == certificateType.MID) ? binaryCRC : versionCRC, addInfo);
                                            }
                                            else
                                            {
                                                //FDCPOSManager.tracer.WriteLine(string.Format("signature failed file='{0}', version={1}", filename, version));
                                                result = OverallResult.AuthentificationError;
                                                break;
                                            }
                                        }
                                        else
                                        {
                                            //FDCPOSManager.tracer.WriteLine(string.Format("error decrypting"));
                                            result = OverallResult.AuthentificationError;
                                            break;
                                        }
                                    }
                                    if (result == OverallResult.Success)
                                    {
                                        if (!this.FdcPosInterface.ValidateSealEndReq(true))
                                        {
                                            //FDCPOSManager.tracer.WriteLine(string.Format("error on seal validation"));
                                            result = OverallResult.AuthentificationError;
                                        }
                                    }
                                    else
                                    {
                                        //FDCPOSManager.tracer.WriteLine(string.Format("reset seal validation info"));
                                        this.FdcPosInterface.ValidateSealEndReq(false);
                                    }
                                }
                                catch (Exception ex)
                                {
                                    //FDCPOSManager.tracer.WriteLine(string.Format("LogOn Validation Info Exception! " + ex.Message));
                                    result = OverallResult.AuthentificationError;
                                }
                                finally
                                {
                                    Monitor.Exit(fdcPosManager);
                                }
                            }
                            else
                            {
                                if (this.fdcPosManager.forecourtConfiguration != "Q8-DENMARK" && this.fdcPosManager.forecourtConfiguration != "WINCOR")
                                {
                                    fdcSocketLogger.LogInformation("configuration is not Q8 and is not WINCOR - AuthorizationInfo must not be null - AuthentificationError !");
                                    //FDCPOSManager.tracer.WriteLine(string.Format("configuration is not Q8 and is not WINCOR - AuthorizationInfo must not be null - AuthentificationError !"));
                                    result = OverallResult.AuthentificationError;
                                }
                            }

                            IPEndPoint endpoint = (IPEndPoint)(fdcClientTcpHandler.TcpClient.Client.RemoteEndPoint);
                            string sIPAddress = endpoint.Address.ToString();

                            if (result == OverallResult.Success && extresult == OverallResult.Success)
                            {
                                //FDCPOSManager.tracer.WriteLine(string.Format("PortA='{0}', PortB='{1}', PortC='{2}'",
                                //this.IPPort, iResponsePort, iUnsolicitedPort));
                                //fdcSocketLogger.LogInformation(string.Format("PortA='{0}', PortB='{1}', PortC='{2}', in Logon", this.IPPort, iResponsePort, iUnsolicitedPort));
                                Messages.HeartbeatCallback heartbeatCallback = new Messages.HeartbeatCallback(this.FdcPosInterface.messages.Heartbeat);
                                bool enteredmonitor = false;
                                try
                                {
                                    Monitor.Enter(fdcPosManager.fdcClientList);
                                    enteredmonitor = true;
                                    if (!fdcPosManager.fdcClientList.ContainsKey(FDCPOSClient.getClientID(sr.WorkstationID, sr.ApplicationSender)))
                                    {
                                        //FDCPOSManager.tracer.WriteLine(string.Format("Client not found - adding"));
                                        fdcSocketLogger.LogInformation("Client: " + FDCPOSClient.getClientID(sr.WorkstationID, sr.ApplicationSender)
                                            + " not found in TcpClientList("
                                            + (fdcPosManager.fdcClientList.Keys.Any() ?
                                                fdcPosManager.fdcClientList.Keys.Select(k => k ?? "null").Aggregate((n, acc) => n + ", " + acc)
                                                    : "Empty yet")
                                            + ") - will adding in, in LogOn");
                                        FDCPOSClient fdcposClient = null;
                                        string posInfo;
                                        if (sr.POSdata[0].posInfo != null) // && sr.POSdata[0].posInfo != "")
                                        {
                                            posInfo = UTF8Encoding.UTF8.GetString(sr.POSdata[0].posInfo, 0, sr.POSdata[0].posInfo.GetLength(0));
                                            POSType posType = FDCPOSClient.GetType(posInfo);
                                            if (posType == POSType.IXTerminal)
                                            {
                                                fdcposClient = new FDCPOSClientIX(fdcPosManager, heartbeatCallback, posInfo);
                                            }
                                            else if (posType == POSType.Generic)
                                            {
                                                fdcposClient = new FDCPOSClient(fdcPosManager, heartbeatCallback, this.fdcSocketLogger);
                                            }
                                        }
                                        else
                                            fdcposClient = new FDCPOSClient(fdcPosManager, heartbeatCallback, this.fdcSocketLogger);
                                        fdcposClient.workstationID = sr.WorkstationID;
                                        fdcposClient.applicationSender = sr.ApplicationSender;
                                        fdcposClient.sIPAddress = sIPAddress;
                                        fdcposClient.FdcClientTcpHandler = fdcClientTcpHandler;
                                        fdcClientTcpHandler.workstationID = sr.WorkstationID;
                                        fdcClientTcpHandler.applicationSender = sr.ApplicationSender;
                                        fdcPosManager.fdcClientList.Add(FDCPOSClient.getClientID(sr.WorkstationID, sr.ApplicationSender), fdcposClient);
                                        fdcSocketLogger.LogInformation("      Client: " + FDCPOSClient.getClientID(sr.WorkstationID, sr.ApplicationSender) + " is added in TcpClientList");
                                        Monitor.Exit(fdcPosManager.fdcClientList);
                                        enteredmonitor = false;
                                        this.FdcPosInterface.LogOnReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, iResponsePort, iUnsolicitedPort, (int)(FDCGlobal.ProtocolVersion));
                                    }
                                    else if (!fdcPosManager.fdcClientList[FDCPOSClient.getClientID(sr.WorkstationID, sr.ApplicationSender)].logon &&
                                        fdcPosManager.fdcClientList[FDCPOSClient.getClientID(sr.WorkstationID, sr.ApplicationSender)].sIPAddress == sIPAddress)
                                    {
                                        //FDCPOSManager.tracer.WriteLine(string.Format("Client found but not logged - logging"));
                                        fdcSocketLogger.LogInformation("Client: " + FDCPOSClient.getClientID(sr.WorkstationID, sr.ApplicationSender) + " is found in TcpClientList but not logged on - will set to LoggedOn, in LogOn");
                                        FDCPOSClient fdcposClient = fdcPosManager.fdcClientList[FDCPOSClient.getClientID(sr.WorkstationID, sr.ApplicationSender)];
                                        fdcposClient.logon = true;
                                        fdcposClient.FdcClientTcpHandler = fdcClientTcpHandler;
                                        Monitor.Exit(fdcPosManager.fdcClientList);
                                        enteredmonitor = false;
                                        this.FdcPosInterface.LogOnReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, iResponsePort, iUnsolicitedPort, (int)(FDCGlobal.ProtocolVersion));
                                    }
                                    else
                                    {
                                        //FDCPOSManager.tracer.WriteLine(string.Format("Client already logged (!?)"));
                                        fdcSocketLogger.LogInformation("Client: " + FDCPOSClient.getClientID(sr.WorkstationID, sr.ApplicationSender) + " already logged on, why log on again (!?), give it an Error, in LogOn");
                                        Monitor.Exit(fdcPosManager.fdcClientList);
                                        enteredmonitor = false;
                                        FDCPOSClient tempTCPClient = new FDCPOSClient(fdcPosManager, heartbeatCallback, this.fdcSocketLogger);
                                        tempTCPClient.sIPAddress = sIPAddress;
                                        tempTCPClient.FdcClientTcpHandler = fdcClientTcpHandler;
                                        this.FdcPosInterface.messages.LogOn(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, iResponsePort, iUnsolicitedPort, (int)(FDCPOSLibrary.ErrorCode.ERRCD_NOPERM), Convert.ToString(FDCPOSLibrary.OverallResult.AuthentificationError), tempTCPClient);
                                    }
                                }
                                catch (Exception ex)
                                {
                                    fdcSocketLogger.LogError("LogOn Exceptioned: " + ex);
                                    if (enteredmonitor)
                                    {
                                        Monitor.Exit(fdcPosManager.fdcClientList);
                                    }
                                    //FDCPOSManager.tracer.WriteLine(string.Format("LogOn Exception! " + ex.Message));
                                    FDCPOSClient tempTCPClient = new FDCPOSClient(fdcPosManager, heartbeatCallback, this.fdcSocketLogger);
                                    tempTCPClient.sIPAddress = sIPAddress;
                                    tempTCPClient.FdcClientTcpHandler = fdcClientTcpHandler;
                                    this.FdcPosInterface.messages.LogOn(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, iResponsePort, iUnsolicitedPort, (int)FDCPOSLibrary.ErrorCode.ERRCD_NOPERM, Convert.ToString(FDCPOSLibrary.OverallResult.AuthentificationError), tempTCPClient);
                                    return requestType;
                                }
                            }
                            else
                            {
                                //FDCPOSManager.tracer.WriteLine(string.Format("LogOn extresult={0}, result={1} ", extresult, result));
                                FDCPOSClient tempTCPClient = new FDCPOSClient(fdcPosManager, null, this.fdcSocketLogger);
                                tempTCPClient.sIPAddress = sIPAddress;
                                tempTCPClient.FdcClientTcpHandler = fdcClientTcpHandler;
                                this.FdcPosInterface.messages.LogOn(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, iResponsePort, iUnsolicitedPort, (int)FDCPOSLibrary.ErrorCode.ERRCD_COMMERR, (result != OverallResult.Success) ? Convert.ToString(result) : Convert.ToString(extresult), tempTCPClient);
                                return requestType;
                            }
                        }
                    }
                }
                else if (requestType == "LogOff")
                {
                    ServiceRequestLogOff sr = Deserialize<ServiceRequestLogOff>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            FdcPosInterface.LogOffReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber);
                        }
                    }
                }
                else if (requestType == "VersionInfo")
                {
                    ServiceRequestVersionInfo sr = Deserialize<ServiceRequestVersionInfo>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.VersionInfoReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber);
                        }
                    }
                }
                else if (requestType == "StartForecourt")
                {
                    ServiceRequestStartForecourt sr = Deserialize<ServiceRequestStartForecourt>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.StartForecourtReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber);
                        }
                    }
                }
                else if (requestType == "StopForecourt")
                {
                    ServiceRequestStopForecourt sr = Deserialize<ServiceRequestStopForecourt>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            bool emergencyStop = (sr.POSdata[0].EmergencyStop != null && sr.POSdata[0].EmergencyStop.ToUpper() == "NO") ? emergencyStop = false : emergencyStop = true;
                            this.FdcPosInterface.StopForecourtReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, emergencyStop);
                        }
                    }
                }
                else if (requestType == "GetCurrentFuellingStatus")
                {
                    ServiceRequestGetCurrentFuellingStatus sr = Deserialize<ServiceRequestGetCurrentFuellingStatus>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetCurrentFuellingStatusReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "GetFuelPointTotals")
                {
                    ServiceRequestGetFuelPointTotals sr = Deserialize<ServiceRequestGetFuelPointTotals>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "" || sr.POSdata[0].DeviceClass.NozzleNo == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetFuelPointTotalsReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                (sr.POSdata[0].DeviceClass.NozzleNo == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.NozzleNo));
                        }
                    }
                }
                else if (requestType == "GetTotals")
                {
                    ServiceRequestGetTotals sr = Deserialize<ServiceRequestGetTotals>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "" || sr.POSdata[0].DeviceClass.NozzleNo == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetFuelPointTotalsReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                (sr.POSdata[0].DeviceClass.NozzleNo == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.NozzleNo));
                        }
                    }
                }
                else if (requestType == "GetDeviceState")
                {
                    ServiceRequestGetDeviceState sr = Deserialize<ServiceRequestGetDeviceState>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetDeviceStateReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                sr.POSdata[0].DeviceClass.Type,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "GetFPState")
                {
                    ServiceRequestGetFPState sr = Deserialize<ServiceRequestGetFPState>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetDeviceStateReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                sr.POSdata[0].DeviceClass.Type,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "TerminateFuelling")
                {
                    ServiceRequestTerminateFuelling sr = Deserialize<ServiceRequestTerminateFuelling>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.TerminateFuellingReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "AuthoriseFuelPoint")
                {
                    ServiceRequestAuthoriseFuelPoint sr = Deserialize<ServiceRequestAuthoriseFuelPoint>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0)
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            string products = "";
                            int mode = -1;
                            if (sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            {
                                //FDCPOSManager.tracer.WriteLine("'device' missing");
                                result = OverallResult.MissingMandatoryData;
                            }
                            else
                            {
                                //Decimal MaxTrxVolume = 0, MaxTrxAmount = 0;
                                ////FDCPOSManager.tracer.WriteLine(string.Format("products.GetLength={0}", sr.POSdata[0].DeviceClass.products.GetLength(0)));
                                //FDCPOSManager.tracer.WriteLine(string.Format("fuelmode={0}, mode={1}", sr.POSdata[0].DeviceClass.FuelMode, (sr.POSdata[0].DeviceClass.FuelMode != null) ? sr.POSdata[0].DeviceClass.FuelMode.ModeNo : null));
                                if (sr.POSdata[0].DeviceClass.FuelMode != null && sr.POSdata[0].DeviceClass.FuelMode.ModeNo != null && sr.POSdata[0].DeviceClass.FuelMode.ModeNo != "")
                                    mode = Convert.ToInt32(sr.POSdata[0].DeviceClass.FuelMode.ModeNo);
                                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                                {
                                    if (sr.POSdata[0].DeviceClass.Products != null && sr.POSdata[0].DeviceClass.Products.ProductNo != null &&
                                        sr.POSdata[0].DeviceClass.Products.ProductNo.GetLength(0) > 0)
                                    {
                                        foreach (string product in sr.POSdata[0].DeviceClass.Products.ProductNo)
                                        {
                                            //FDCPOSManager.tracer.WriteLine(string.Format("ProductNo='{0}', products='{0}'", product, products));
                                            ////FDCPOSManager.tracer.WriteLine(string.Format("ProductNo='{0}', products='{0}'", product.ProductNo, products));
                                            products += product + ";";
                                        }
                                    }
                                }
                                else if (FDCGlobal.ProtocolVersion == FDCVersion.V0005)
                                {
                                    if (sr.POSdata[0].DeviceClass.ReleasedProducts != null && sr.POSdata[0].DeviceClass.ReleasedProducts.ProductNo != null &&
                                        sr.POSdata[0].DeviceClass.ReleasedProducts.ProductNo.GetLength(0) > 0)
                                    {
                                        foreach (string product in sr.POSdata[0].DeviceClass.ReleasedProducts.ProductNo)
                                        {
                                            //FDCPOSManager.tracer.WriteLine(string.Format("ProductNo='{0}'", product));
                                            products += product + ";";
                                        }
                                    }
                                }
                                else
                                {
                                    if (sr.POSdata[0].DeviceClass.ReleasedProducts != null && sr.POSdata[0].DeviceClass.ReleasedProducts.Product != null &&
                                        sr.POSdata[0].DeviceClass.ReleasedProducts.Product.GetLength(0) > 0)
                                    {
                                        foreach (ProductElementClass product in sr.POSdata[0].DeviceClass.ReleasedProducts.Product)
                                        {
                                            //FDCPOSManager.tracer.WriteLine(string.Format("ProductNo='{0}'", product.ProductNo, products));
                                            products += product.ProductNo + ";";
                                        }
                                    }
                                }

                                this.FdcPosInterface.AuthoriseFuelPointReq(sr.WorkstationID,
                                    sr.ApplicationSender,
                                    sr.RequestIDNumber,
                                    (sr.POSdata[0].DeviceClass.ReleaseToken != null) ? sr.POSdata[0].DeviceClass.ReleaseToken : "",
                                    (sr.POSdata[0].DeviceClass.FuellingType == "") ? 0 : Convert.ToInt32(sr.POSdata[0].DeviceClass.FuellingType),
                                    (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                    (sr.POSdata[0].DeviceClass.ReservingDeviceId == "") ? 0 : Convert.ToInt32(sr.POSdata[0].DeviceClass.ReservingDeviceId),
                                    FDCConvert.ToDecimal(sr.POSdata[0].DeviceClass.MaxTrxAmount), FDCConvert.ToDecimal(sr.POSdata[0].DeviceClass.MaxTrxVolume),
                                    products, mode,
                                    (sr.POSdata[0].DeviceClass.LockFuelSaleTrx != null && sr.POSdata[0].DeviceClass.LockFuelSaleTrx.ToUpper() == "TRUE") ? true : false, sr.POSdata[0].DeviceClass.PayType);
                            }
                        }
                    }
                }
                else if (requestType == "ChangeFuelMode")
                {
                    ServiceRequestChangeFuelMode sr = Deserialize<ServiceRequestChangeFuelMode>(message, ref result);
                    string mode = "";
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null)
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            if (sr.POSdata[0].DeviceClass.Length > 1)
                            {
                                foreach (ServiceRequestDeviceClassChangeFuelMode deviceClass in sr.POSdata[0].DeviceClass)
                                {
                                    mode = "";
                                    if (deviceClass != null)
                                    {
                                        if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                                        {
                                            if (deviceClass.ModeNo != null) mode = deviceClass.ModeNo;
                                        }
                                        else
                                        {
                                            if (deviceClass.FuelMode != null && deviceClass.FuelMode.ModeNo != null) mode = deviceClass.FuelMode.ModeNo;
                                        }
                                        //FDCPOSManager.tracer.WriteLine(string.Format("DeviceID={0}, ModeNo={1}", deviceClass.DeviceID, mode));
                                        if (mode != "")
                                            this.FdcPosInterface.ChangeFuelModeAddReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, deviceClass.Type,
                                                                    (deviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(deviceClass.DeviceID), Convert.ToInt32(mode));
                                    }
                                }
                                this.FdcPosInterface.ChangeFuelModeEndReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber);
                            }
                            else
                            {
                                if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                                {
                                    if (sr.POSdata[0].DeviceClass[0].ModeNo != null) mode = sr.POSdata[0].DeviceClass[0].ModeNo;
                                }
                                else
                                {
                                    if (sr.POSdata[0].DeviceClass[0].FuelMode != null && sr.POSdata[0].DeviceClass[0].FuelMode.ModeNo != null) mode = sr.POSdata[0].DeviceClass[0].FuelMode.ModeNo;
                                }
                                if (mode == "")
                                    result = OverallResult.MissingMandatoryData;
                                this.FdcPosInterface.ChangeFuelModeReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, sr.POSdata[0].DeviceClass[0].Type,
                                                                    (sr.POSdata[0].DeviceClass[0].DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass[0].DeviceID),
                                                                    Convert.ToInt32(mode));
                            }
                        }
                    }
                }
                else if (requestType == "ChangeFuelPrice")
                {
                    ServiceRequestChangeFuelPrice sr = Deserialize<ServiceRequestChangeFuelPrice>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].Product == null)
                            result = OverallResult.MissingMandatoryData;
                        //FDCPOSManager.tracer.WriteLineIf(FDCPOSManager.tracer.CheckTraceLevel(3), string.Format("result=" + result));
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            string overallRes = OverallResult.Success.ToString();
                            if (sr.POSdata[0].Product != null)
                            {
                                string formattedString = "";
                                //double oldPrice;
                                string sModeNo = "", sPriceNew = "", effectiveDateTime = "";
                                foreach (ServiceRequestProductChangeFuelPrice product in sr.POSdata[0].Product)
                                {
                                    if (product == null) continue;
                                    sModeNo = "";
                                    sPriceNew = "";
                                    effectiveDateTime = "";
                                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                                    {
                                        sModeNo = (product.ModeNo != null) ? product.ModeNo : "";
                                        sPriceNew = (product.PriceNew != null) ? product.PriceNew : "";
                                        effectiveDateTime = (product.EffectiveDateTime != null) ? product.EffectiveDateTime : "";

                                        string localresult = OverallResult.Success.ToString();
                                        if (product.ProductNo != null && product.ProductNo != "" && sPriceNew != "" && sModeNo != "")
                                        {
                                            //localresult = this.FdcPosInterface.ChangeFuelPriceAddReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(product.ProductNo), FDCConvert.ToDecimal(product.PriceNew), Convert.ToInt32(product.ModeNo), out oldPrice);
                                            formattedString = formattedString + product.ProductNo + ";" + sPriceNew + ";" + sModeNo + ";" + effectiveDateTime + "!";
                                        }
                                        else
                                        {
                                            localresult = OverallResult.Failure.ToString();
                                        }
                                        if (localresult != OverallResult.Success.ToString() && overallRes == OverallResult.Success.ToString())
                                            overallRes = OverallResult.Failure.ToString();
                                        else if (localresult == OverallResult.Success.ToString() && overallRes == OverallResult.Failure.ToString())
                                            overallRes = OverallResult.PartialFailure.ToString();
                                        //FDCPOSManager.tracer.WriteLine(string.Format("localresult={0}, overallRes={1}", localresult, overallRes));
                                        //this.FdcPosInterface.messages.ChangeFuelPriceAdd(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(product.ProductNo), FDCConvert.ToDecimal(product.PriceNew), Convert.ToInt32(product.ModeNo), Convert.ToDecimal(oldPrice));
                                    }
                                    else
                                    {
                                        if (product.FuelMode != null)
                                        {
                                            /* the Schema said the FuleMode only can contain a single fule price change item!!!!!!!!!*/
                                            foreach (ServiceRequestFuelModeChangeFuelPrice fuelMode in product.FuelMode)
                                            {
                                                if (fuelMode == null) continue;
                                                sModeNo = (fuelMode.ModeNo != null) ? fuelMode.ModeNo : "";
                                                sPriceNew = (fuelMode.PriceNew != null) ? fuelMode.PriceNew : "";
                                                effectiveDateTime = (fuelMode.EffectiveDateTime != null) ? fuelMode.EffectiveDateTime : "";

                                                string localresult = OverallResult.Success.ToString();
                                                if (product.ProductNo != null && product.ProductNo != "" && sPriceNew != "" && sModeNo != "")
                                                {
                                                    //localresult = this.FdcPosInterface.ChangeFuelPriceAddReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(product.ProductNo), FDCConvert.ToDecimal(product.PriceNew), Convert.ToInt32(product.ModeNo), out oldPrice);
                                                    formattedString = formattedString + product.ProductNo + ";" + sPriceNew + ";" + sModeNo + ";" + effectiveDateTime + "!";
                                                }
                                                else
                                                {
                                                    localresult = OverallResult.Failure.ToString();
                                                }
                                                if (localresult != OverallResult.Success.ToString() && overallRes == OverallResult.Success.ToString())
                                                    overallRes = OverallResult.Failure.ToString();
                                                else if (localresult == OverallResult.Success.ToString() && overallRes == OverallResult.Failure.ToString())
                                                    overallRes = OverallResult.PartialFailure.ToString();
                                                //FDCPOSManager.tracer.WriteLine(string.Format("localresult={0}, overallRes={1}, product.ProductNo={2}, fuelMode.PriceNew={3}, fuelMode.ModeNo={4}", localresult, overallRes, product.ProductNo, fuelMode.PriceNew, fuelMode.ModeNo));
                                                //this.FdcPosInterface.messages.ChangeFuelPriceAdd(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(product.ProductNo), FDCConvert.ToDecimal(product.PriceNew), Convert.ToInt32(product.ModeNo), Convert.ToDecimal(oldPrice));
                                            }
                                        }
                                    }
                                }
                                //this.FdcPosInterface.ChangeFuelPriceEndReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber);
                                string outresult = this.FdcPosInterface.ChangeFuelPriceInStringReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, formattedString);
                                if (string.IsNullOrEmpty(outresult)) overallRes = OverallResult.Failure.ToString();
                                string item, sProd, sPriceOld;
                                while (outresult != "")
                                {
                                    if (outresult.IndexOf('!') >= 0)
                                    {
                                        item = outresult.Substring(0, outresult.IndexOf('!'));

                                        sProd = item.Substring(0, item.IndexOf(';'));
                                        item = item.Substring(item.IndexOf(';') + 1);
                                        sPriceNew = item.Substring(0, item.IndexOf(';'));
                                        item = item.Substring(item.IndexOf(';') + 1);
                                        sModeNo = item.Substring(0, item.IndexOf(';'));
                                        item = item.Substring(item.IndexOf(';') + 1);
                                        sPriceOld = item.Substring(0, item.IndexOf(';'));
                                        effectiveDateTime = item.Substring(item.IndexOf(';') + 1);

                                        outresult = outresult.Substring(outresult.IndexOf('!') + 1);

                                        // pricenew and priceold always is formatted with '.' as decimal separator
                                        sPriceNew = sPriceNew.Replace(".", FDCConvert.DecimalSeparator);
                                        sPriceOld = sPriceOld.Replace(".", FDCConvert.DecimalSeparator);
                                        Decimal pricenew = FDCConvert.ToDecimal(sPriceNew), priceold = FDCConvert.ToDecimal(sPriceOld);
                                        //FDCPOSManager.tracer.WriteLine(string.Format("prod={0}, mode={1}, newprice={2}, effectiveDateTime={3}, oldprice={4}", sProd, sModeNo, sPriceNew, effectiveDateTime, sPriceOld));

                                        this.FdcPosInterface.messages.ChangeFuelPriceAdd(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, Convert.ToInt32(sProd), pricenew, Convert.ToInt32(sModeNo), effectiveDateTime, priceold);
                                    }
                                }
                            }
                            else
                                overallRes = OverallResult.MissingMandatoryData.ToString();
                            this.FdcPosInterface.messages.ChangeFuelPriceSend(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, (int)ErrorCode.ERRCD_OK, overallRes);
                        }
                    }
                }
                else if (requestType == "LockFuelSaleTrx")
                {
                    ServiceRequestLockFuelSaleTrx sr = Deserialize<ServiceRequestLockFuelSaleTrx>(message, ref result);
                    if (sr != null)
                    {
                        string transactionNo = (sr.POSdata[0].DeviceClass.TransactionNo != null) ? sr.POSdata[0].DeviceClass.TransactionNo : ((sr.POSdata[0].DeviceClass.TransactionSeqNo != null) ? sr.POSdata[0].DeviceClass.TransactionSeqNo : "");
                        string releaseToken = (sr.POSdata[0].DeviceClass.ReleaseToken != null) ? sr.POSdata[0].DeviceClass.ReleaseToken : "";
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "" || transactionNo == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.LockFuelSaleTrxReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                Convert.ToInt32(transactionNo), releaseToken);
                        }
                    }
                }
                else if (requestType == "UnlockFuelSaleTrx")
                {
                    ServiceRequestUnlockFuelSaleTrx sr = Deserialize<ServiceRequestUnlockFuelSaleTrx>(message, ref result);
                    if (sr != null)
                    {
                        string transactionNo = (sr.POSdata[0].DeviceClass.TransactionNo != null) ? sr.POSdata[0].DeviceClass.TransactionNo : ((sr.POSdata[0].DeviceClass.TransactionSeqNo != null) ? sr.POSdata[0].DeviceClass.TransactionSeqNo : "");
                        string releaseToken = (sr.POSdata[0].DeviceClass.ReleaseToken != null) ? sr.POSdata[0].DeviceClass.ReleaseToken : "";
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "" || transactionNo == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.UnlockFuelSaleTrxReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                Convert.ToInt32(transactionNo), releaseToken);
                        }
                    }
                }
                else if (requestType == "ClearFuelSaleTrx")
                {
                    ServiceRequestClearFuelSaleTrx sr = Deserialize<ServiceRequestClearFuelSaleTrx>(message, ref result);
                    if (sr != null)
                    {
                        string transactionNo = (sr.POSdata[0].DeviceClass.TransactionNo != null) ? sr.POSdata[0].DeviceClass.TransactionNo : ((sr.POSdata[0].DeviceClass.TransactionSeqNo != null) ? sr.POSdata[0].DeviceClass.TransactionSeqNo : "");
                        string releaseToken = (sr.POSdata[0].DeviceClass.ReleaseToken != null) ? sr.POSdata[0].DeviceClass.ReleaseToken : "";
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "" || transactionNo == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.ClearFuelSaleTrxReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                Convert.ToInt32(transactionNo), releaseToken);
                        }
                    }
                }
                else if (requestType == "GetAvailableFuelSaleTrxs")
                {
                    ServiceRequestGetAvailableFuelSaleTrxs sr = Deserialize<ServiceRequestGetAvailableFuelSaleTrxs>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetAvailableFuelSaleTrxsReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "GetFuelSaleTrxDetails")
                {
                    ServiceRequestGetFuelSaleTrxDetails sr = Deserialize<ServiceRequestGetFuelSaleTrxDetails>(message, ref result);
                    if (sr != null)
                    {
                        string transactionNo = (sr.POSdata[0].DeviceClass.TransactionNo != null) ? sr.POSdata[0].DeviceClass.TransactionNo : ((sr.POSdata[0].DeviceClass.TransactionSeqNo != null) ? sr.POSdata[0].DeviceClass.TransactionSeqNo : "");
                        string releaseToken = (sr.POSdata[0].DeviceClass.ReleaseToken != null) ? sr.POSdata[0].DeviceClass.ReleaseToken : "";
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "" || (transactionNo == "" && releaseToken == ""))
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetFuelSaleTrxDetailsReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                (transactionNo == "*") ? -1 : Convert.ToInt32(transactionNo),
                                                                releaseToken);
                        }
                    }
                }
                else if (requestType == "GetProductTable")
                {
                    ServiceRequestGetProductTable sr = Deserialize<ServiceRequestGetProductTable>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetProductTableReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber);
                        }
                    }
                }
                else if (requestType == "GetModeTable")
                {
                    ServiceRequestGetModeTable sr = Deserialize<ServiceRequestGetModeTable>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetModeTableReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber);
                        }
                    }
                }
                else if (requestType == "GetFuelMode")
                {
                    ServiceRequestGetFuelMode sr = Deserialize<ServiceRequestGetFuelMode>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetFuelModeReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, sr.POSdata[0].DeviceClass.Type,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "GetConfiguration")
                {
                    Messages.bWholeConfiguration = true;
                    ServiceRequestGetConfiguration sr = Deserialize<ServiceRequestGetConfiguration>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetConfigurationReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, "");
                        }
                    }
                }
                else if (requestType == "GetDSPConfiguration")
                {
                    Messages.bWholeConfiguration = false;
                    ServiceRequestGetDSPConfiguration sr = Deserialize<ServiceRequestGetDSPConfiguration>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetConfigurationReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, DeviceType.DT_FuelDispenser);
                        }
                    }
                }
                else if (requestType == "GetTLGConfiguration")
                {
                    Messages.bWholeConfiguration = false;
                    ServiceRequestGetTLGConfiguration sr = Deserialize<ServiceRequestGetTLGConfiguration>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetConfigurationReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, DeviceType.DT_TankLevelGauge);
                        }
                    }
                }
                else if (requestType == "GetPPConfiguration")
                {
                    Messages.bWholeConfiguration = false;
                    ServiceRequestGetPPConfiguration sr = Deserialize<ServiceRequestGetPPConfiguration>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetConfigurationReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, DeviceType.DT_PricePole);
                        }
                    }
                }
                else if (requestType == "SetConfiguration")
                {
                    ServiceRequestSetConfiguration sr = Deserialize<ServiceRequestSetConfiguration>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.SetConfigurationReq(sr);
                        }
                    }
                }
                else if (requestType == "LockNozzle")
                {
                    ServiceRequestLockNozzle sr = Deserialize<ServiceRequestLockNozzle>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "" ||
                            sr.POSdata[0].DeviceClass.NozzleNo == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.LockNozzleReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                (sr.POSdata[0].DeviceClass.NozzleNo == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.NozzleNo));
                        }
                    }
                }
                else if (requestType == "UnlockNozzle")
                {
                    ServiceRequestUnlockNozzle sr = Deserialize<ServiceRequestUnlockNozzle>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "" ||
                            sr.POSdata[0].DeviceClass.NozzleNo == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.UnlockNozzleReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                (sr.POSdata[0].DeviceClass.NozzleNo == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.NozzleNo));
                        }
                    }
                }
                else if (requestType == "GetCountrySettings")
                {
                    ServiceRequestGetCountrySettings sr = Deserialize<ServiceRequestGetCountrySettings>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetCountrySettingsReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber);
                        }
                    }
                }
                else if (requestType == "GetDSPLimits")
                {
                    ServiceRequestGetDSPLimits sr = Deserialize<ServiceRequestGetDSPLimits>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetDSPLimitsReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "ChangeDSPLimits")
                {
                    ServiceRequestChangeDSPLimits sr = Deserialize<ServiceRequestChangeDSPLimits>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "" ||
                            (FDCGlobal.ProtocolVersion > FDCVersion.V0003 && (sr.POSdata[0].DeviceClass.Product == null || sr.POSdata[0].DeviceClass.Product.FuelMode == null)))
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            int mode = 0, productNo = 0;
                            Decimal maxTrxAmount = -1, maxTrxVolume = -1;
                            if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                            {
                                productNo = Convert.ToInt32(sr.POSdata[0].DeviceClass.ProductNo);
                                mode = Convert.ToInt32(sr.POSdata[0].DeviceClass.ModeNo);
                                maxTrxAmount = FDCConvert.ToDecimal(sr.POSdata[0].DeviceClass.MaxTrxAmount);
                                maxTrxVolume = FDCConvert.ToDecimal(sr.POSdata[0].DeviceClass.MaxTrxVolume);
                            }
                            else
                            {
                                productNo = Convert.ToInt32(sr.POSdata[0].DeviceClass.Product.ProductNo);
                                mode = Convert.ToInt32(sr.POSdata[0].DeviceClass.Product.FuelMode.ModeNo);
                                maxTrxAmount = FDCConvert.ToDecimal(sr.POSdata[0].DeviceClass.Product.FuelMode.MaxTrxAmount);
                                maxTrxVolume = FDCConvert.ToDecimal(sr.POSdata[0].DeviceClass.Product.FuelMode.MaxTrxVolume);
                            }
                            this.FdcPosInterface.ChangeDSPLimitsReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                        (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                        productNo,
                                        mode, maxTrxAmount, maxTrxVolume);
                        }
                    }
                }
                else if (requestType == "SuspendFuelling")
                {
                    ServiceRequestSuspendFuelling sr = Deserialize<ServiceRequestSuspendFuelling>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.SuspendFuellingReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "ResumeFuelling")
                {
                    ServiceRequestResumeFuelling sr = Deserialize<ServiceRequestResumeFuelling>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.ResumeFuellingReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "LockTank")
                {
                    ServiceRequestLockTank sr = Deserialize<ServiceRequestLockTank>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "" ||
                            sr.POSdata[0].DeviceClass.TankNo == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.LockTankReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                Convert.ToInt32(sr.POSdata[0].DeviceClass.TankNo));
                        }
                    }
                }
                else if (requestType == "UnlockTank")
                {
                    ServiceRequestUnlockTank sr = Deserialize<ServiceRequestUnlockTank>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "" ||
                            sr.POSdata[0].DeviceClass.TankNo == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.UnlockTankReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                Convert.ToInt32(sr.POSdata[0].DeviceClass.TankNo));
                        }
                    }
                }
                else if (requestType == "GetTankData")
                {
                    ServiceRequestGetTankData sr = Deserialize<ServiceRequestGetTankData>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "" ||
                            sr.POSdata[0].DeviceClass.TankNo == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GetTankDataReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                (sr.POSdata[0].DeviceClass.TankNo == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.TankNo));
                        }
                    }
                }
                else if (requestType == "ReserveFuelPoint")
                {
                    ServiceRequestReserveFuelPoint sr = Deserialize<ServiceRequestReserveFuelPoint>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.ReserveFuelPointReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "FreeFuelPoint")
                {
                    ServiceRequestFreeFuelPoint sr = Deserialize<ServiceRequestFreeFuelPoint>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.FreeFuelPointReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "StartFuelPointTest")
                {
                    ServiceRequestStartFuelPointTest sr = Deserialize<ServiceRequestStartFuelPointTest>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.StartFuelPointTestReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "EndFuelPointTest")
                {
                    ServiceRequestEndFuelPointTest sr = Deserialize<ServiceRequestEndFuelPointTest>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.EndFuelPointTestReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "SetDeviceAlarm")
                {
                    ServiceRequestSetDeviceAlarm sr = Deserialize<ServiceRequestSetDeviceAlarm>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.SetDeviceAlarmReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                sr.POSdata[0].DeviceClass.Type,
                                                                Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                Convert.ToInt32(sr.POSdata[0].DeviceClass.AlarmMsg[0].Number),
                                                                sr.POSdata[0].DeviceClass.AlarmMsg[0].Text);
                        }
                    }
                }
                else if (requestType == "OpenFuelPoint")
                {
                    ServiceRequestOpenFuelPoint sr = Deserialize<ServiceRequestOpenFuelPoint>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.OpenFuelPointReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "OpenDevice")
                {
                    ServiceRequestOpenDevice sr = Deserialize<ServiceRequestOpenDevice>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.OpenFuelPointReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "CloseFuelPoint")
                {
                    ServiceRequestCloseFuelPoint sr = Deserialize<ServiceRequestCloseFuelPoint>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.CloseFuelPointReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "CloseDevice")
                {
                    ServiceRequestCloseDevice sr = Deserialize<ServiceRequestCloseDevice>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.CloseFuelPointReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                (sr.POSdata[0].DeviceClass.DeviceID == "*") ? -1 : Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "OPTAdd")
                {
                    ServiceRequestOPTAdd sr = Deserialize<ServiceRequestOPTAdd>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            if (sr.POSdata[0].DeviceClass.serialPort != null && sr.POSdata[0].DeviceClass.serialPort.Port.Length > 0)
                                //OptInterfaceServer.optInterfaceServer.
                                this.FdcPosInterface.AddSerialPortReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                    sr.POSdata[0].DeviceClass.Type, Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID), Convert.ToInt32(sr.POSdata[0].DeviceClass.serialPort.Port),
                                                                    Convert.ToInt32(sr.POSdata[0].DeviceClass.serialPort.BaudRate), Convert.ToInt32(sr.POSdata[0].DeviceClass.serialPort.DataBit), Convert.ToInt32(sr.POSdata[0].DeviceClass.serialPort.StopBit), Convert.ToInt32(sr.POSdata[0].DeviceClass.serialPort.Parity));
                            else if (sr.POSdata[0].DeviceClass.tcp != null && sr.POSdata[0].DeviceClass.tcp.Port.Length > 0)
                                //OptInterfaceServer.optInterfaceServer.
                                this.FdcPosInterface.AddTCPReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                    sr.POSdata[0].DeviceClass.Type, Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                    sr.POSdata[0].DeviceClass.tcp.Address, Convert.ToInt32(sr.POSdata[0].DeviceClass.tcp.Port));
                        }
                    }
                }
                else if (requestType == "OPTRemove")
                {
                    ServiceRequestOPTRemove sr = Deserialize<ServiceRequestOPTRemove>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.RemoveReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                sr.POSdata[0].DeviceClass.Type, Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID));
                        }
                    }
                }
                else if (requestType == "OPTWrite")
                {
                    ServiceRequestOPTWrite sr = Deserialize<ServiceRequestOPTWrite>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (sr.POSdata.GetLength(0) == 0 || sr.POSdata[0].DeviceClass == null || sr.POSdata[0].DeviceClass.DeviceID == "")
                            result = OverallResult.MissingMandatoryData;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.WriteReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber,
                                                                sr.POSdata[0].DeviceClass.Type, Convert.ToInt32(sr.POSdata[0].DeviceClass.DeviceID),
                                                                sr.POSdata[0].DeviceClass.Message);
                        }
                    }
                }
                else if (requestType == "GenericTypelessMessage")
                {
                    ServiceRequestGenericTypelessMessage sr = Deserialize<ServiceRequestGenericTypelessMessage>(message, ref result);
                    if (sr != null)
                    {
                        requestId = sr.RequestIDNumber;
                        if (result == OverallResult.Success && extresult == OverallResult.Success)
                        {
                            this.FdcPosInterface.GenericTypelessMessageReq(sr.WorkstationID, sr.ApplicationSender, sr.RequestIDNumber, sr.POSdata[0].Message);
                        }
                    }
                }
                else
                {
                    fdcSocketLogger.LogInformation(string.Format("Client with applicationSender={0}, workstationId={1} is " +
                            "sending in an unknown requestType: {2} message, Will response: ParsingError",
                            applicationSender, workstationId, requestType));
                    result = OverallResult.ParsingError;
                }
            }
            catch (Exception ex)
            {
                result = OverallResult.Failure;
                fdcSocketLogger.LogError("ReadRequest(requestType: " + (requestType ?? "") + ") from Fdc client(wId: "
                    + (workstationId ?? "") + ",appSender: " + (applicationSender ?? "") + ") exceptioned: \r\n" + ex);
                //FDCPOSManager.tracer.WriteLine(string.Format("Exception! requestType='{0}': {1}", requestType, ex.Message));
            }

            if (result != OverallResult.Success || extresult != OverallResult.Success)
            {
                ((FDCPOSInterfaceServerManager)this.fdcPosManager).fdcPosInterface.messages
                    .SendErrorResponse(requestType, workstationId, applicationSender, requestId,
                        (extresult != OverallResult.Success) ? ErrorCode.ERRCD_COMMERR : ErrorCode.ERRCD_BADVAL,
                        result.ToString());
            }
            else
            {
                if (fdcPosManager.fdcClientList.TryGetValue(FDCPOSClient.getClientID(workstationId, applicationSender), out FDCPOSClient cachedFdcPosClient))
                    cachedFdcPosClient.heartbeat.StartClientDisconnectionTimer();
            }
            //FDCPOSManager.tracer.WriteLine(string.Format("end requestType='{0}'", requestType));
            return requestType;
        }

        #region misc

        protected string GetRequestType(string myString)
        {
            return GetElemValue("RequestType", myString);
        }

        protected string GetMessageType(string myString)
        {
            return GetElemValue("MessageType", myString);
        }

        protected string GetApplicationSender(string myString)
        {
            return GetElemValue("ApplicationSender", myString); ;
        }

        protected string GetWorkstationID(string myString)
        {
            return GetElemValue("WorkstationID", myString); ;
        }

        protected string GetElemValue(string field, string myString)
        {
            // TODO
            string value = "";
            try
            {
                if (myString.IndexOf(field) >= 0)
                {
                    myString = myString.Substring(myString.IndexOf(field));
                    myString = myString.Substring(myString.IndexOf('\"') + 1);
                    value = myString.Substring(0, myString.IndexOf('\"'));
                }
            }
            catch (Exception ex)
            {
                fdcSocketLogger.LogError("GetElemValue exceptioned: " + ex.ToString());
                //FDCPOSManager.tracer.WriteLine("Exception!" + ex.Message);
            }
            return value;
        }

        #endregion

        #region Deserialize

        public T Deserialize<T>(string xmlString, ref OverallResult result)
        {
            if (string.IsNullOrEmpty(xmlString))
                throw new ArgumentNullException("Target string for Deserialize must not null or empty");
            // Create an instance of the XmlSerializer class;
            // specify the type of object to be deserialized.
            result = OverallResult.Success;

            //===========================
            Exception firstException = null;


            System.Xml.Schema.XmlSchemaSet smSet;

            SchemasSG sgmInst = SchemasSG.Instance;
            if (sgmInst.GetSchemas.ContainsKey((typeof(T).Name)))
            {
                smSet = sgmInst.GetSchemas[typeof(T).Name];
            }
            else
            {
                smSet = null;
            }
            if (smSet != null)
            {
                var settings = new XmlReaderSettings
                {
                    Schemas = smSet,
                    CheckCharacters = true,
                    IgnoreComments = true,
                    IgnoreProcessingInstructions = true,
                    IgnoreWhitespace = true,
                    MaxCharactersInDocument = 999999, // most xml files have 450 characters, if this increases, we need to enlarge the number
                    ValidationType = ValidationType.Schema,
                    ValidationFlags =
                        XmlSchemaValidationFlags.ProcessIdentityConstraints |
                        XmlSchemaValidationFlags.ReportValidationWarnings
                };
                settings.ValidationEventHandler +=
                    delegate (object sender, ValidationEventArgs args)
                    {
                        if (args.Severity == XmlSeverityType.Warning)
                        {
                            //Console.WriteLine("Warning: " + args.Message);
                            fdcSocketLogger.LogInformation("XmlSchema Validation has a Warning : " + (args.Message ?? "")
                                + Environment.NewLine + (args.Exception?.ToString() ?? "")
                                + Environment.NewLine + xmlString);
                        }
                        else
                        {
                            if (firstException == null)
                            {
                                firstException = args.Exception;
                            }

                            fdcSocketLogger.LogError("XmlSchema Validation has an ERROR: " + (args.Message ?? "")
                                + Environment.NewLine + (args.Exception?.ToString() ?? "")
                                + Environment.NewLine + xmlString);
                            //Console.WriteLine("Exception: " + args.Exception.ToString());
                            //FDCPOSManager.tracer.WriteLine("Exception: " + args.Exception.ToString());
                        }
                    };

                //======================================
                T sr = default(T);

                try
                {
                    using (var tempStream = new System.IO.StringReader(xmlString))
                    {
                        using (var reader = XmlReader.Create(tempStream, settings))
                        {
                            XmlSerializer serializer = new XmlSerializer(typeof(T));
                            serializer.UnknownNode += new XmlNodeEventHandler((_, n) =>
                            {
                                //the target object may miss to defined a Property?
                                fdcSocketLogger.LogInformation("XmlSerializer read an Unknown Node with Name: " + (n.Name ?? "") + ", text: " + (n.Text ?? "")
                                    + System.Environment.NewLine + xmlString);
                            });
                            serializer.UnknownAttribute += new XmlAttributeEventHandler((_, e) =>
                            {
                                //the target object may miss to defined a Property?
                                System.Xml.XmlAttribute attr = e.Attr;
                                fdcSocketLogger.LogInformation("XmlSerializer read an Unknown Attr with Name: " + (attr.Name ?? "") + ", value: " + (attr.Value ?? "")
                                    + System.Environment.NewLine + xmlString);
                            });
                            sr = (T)serializer.Deserialize(reader);
                        }
                    }

                    if (firstException != null)
                        throw firstException;
                }
                catch (Exception ex)
                {
                    result = OverallResult.ParsingError;
                    //FDCPOSManager.tracer.WriteLine("Exception! " + ex.Message);
                    fdcSocketLogger.LogError("Deserialize<T>(string ,ref OverallResult) exceptioned for string: " + Environment.NewLine + xmlString
                                + Environment.NewLine + "exception detail: " + ex);
                }

                return sr;
            }
            else
            {
                result = OverallResult.ParsingError;
                return default(T);
            }

        } // end of Deserialize

        #endregion

        /// <summary>
        /// 4 bytes Length(16 bytes hash excluded) + 16 bytes hash + UTF8 encoded xml content
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sr"></param>
        /// <param name="enableHashHeader">if false, will set 0 for all 16 bytes</param>
        /// <returns>string is the serialized Message xml string</returns>
        public static Tuple<byte[], string> SerializeFdcMessageToNetworkBytes<T>(T sr, bool enableHashHeader)
        {
            var xmlMsgBodyMemStream = new MemoryStream();
            XmlSerializer serializer = new XmlSerializer(typeof(T));
            serializer.Serialize(xmlMsgBodyMemStream, (T)sr);
            xmlMsgBodyMemStream.Position = 0;
            string xmlBodyStr = "";
            byte[] xmlBodyBytes = null;
            using (StreamReader _ = new StreamReader(xmlMsgBodyMemStream, Encoding.UTF8))
            {
                xmlBodyStr = _.ReadToEnd();
                xmlBodyBytes = Encoding.UTF8.GetBytes(xmlBodyStr);
            }

            #region msg header, 4 bytes of msg body length

            byte[] lengthBytes = new byte[Define.HeaderLength];
            lengthBytes[3] = (byte)(xmlBodyBytes.Length & 0x000000FF);
            lengthBytes[2] = (byte)((xmlBodyBytes.Length & 0x0000FF00) / Math.Pow(2, 8));
            lengthBytes[1] = (byte)((xmlBodyBytes.Length & 0x00FF0000) / Math.Pow(2, 16));
            lengthBytes[0] = (byte)((xmlBodyBytes.Length & 0xFF000000) / Math.Pow(2, 24));

            #endregion

            #region msg encription Bytes, 16 bytes

            var hashBytes = new byte[Define.EncriptionLength];
            if (enableHashHeader)
            {
                MD5Crypter crypter = new MD5Crypter();
                byte[] hashingbytes = new byte[xmlBodyBytes.Length + crypter.getPassphrase().Length];
                Array.Copy(xmlBodyBytes, hashingbytes, xmlBodyBytes.Length);
                Array.Copy(crypter.getPassphrase(), 0, hashingbytes, xmlBodyBytes.Length, crypter.getPassphrase().Length);
                hashBytes = crypter.ComputeHash(hashingbytes);
            }
            else
            {
                for (int i = 0; i < Define.EncriptionLength; i++)
                    hashBytes[i] = 0;
            }

            #endregion

            // 3 parts concat.
            var finalBytes = lengthBytes.Concat(hashBytes).Concat(xmlBodyBytes).ToArray();
            return new Tuple<byte[], string>(finalBytes, xmlBodyStr);
        }

        public bool SendResponse<T>(FDCPOSClient fdcPosClient, T sr)
        {
            try
            {
                if (fdcPosClient == null)
                {
                    fdcSocketLogger.LogInformation("SendResponse, client is NULL!");
                    //FDCPOSManager.tracer.WriteLine(string.Format("client is NULL!"));
                    return false;
                }

                if (!fdcPosClient.connected)
                {
                    fdcSocketLogger.LogInformation(string.Format("client '{0}' NOT connected, will skip send this response", fdcPosClient.sID));
                    //FDCPOSManager.tracer.WriteLine(string.Format("client '{0}' NOT connected", fdcposClient.sID));
                    return false;
                }

                Interlocked.Increment(ref FDCPOSManager.messageIdCounter);

                var result = SerializeFdcMessageToNetworkBytes(sr, this.fdcPosManager.encryptedHeader);

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

                lock (fdcPosClient)
                {
                    if (fdcSocketLogger.IsEnabled(LogLevel.Debug))
                        fdcSocketLogger.LogDebug("Will Send Fdc Response(full message include header bytes count: " + result.Item1.Length + "): "
                            + sr.GetType().Name + ", content:\r\n"
                            + result.Item2
                            + "\r\n to client(wId: " + (fdcPosClient.workstationID ?? "")
                            + ", appSender: " + (fdcPosClient.applicationSender ?? "") + ")");
                    var networkStream = fdcPosClient.socketChannelResponse.GetStream();
                    networkStream.Write(result.Item1);
                    if (fdcSocketLogger.IsEnabled(LogLevel.Debug))
                    {
                        fdcSocketLogger.LogDebug("  done send Fdc Response: " + sr.GetType().Name);
                    }
                }

                try
                {
                    if (false && traceXML)
                    {
                        //DateTime now = DateTime.Now;
                        //string sdate = now.Day.ToString() + "-" + now.Month.ToString() + "-";
                        //System.IO.StreamWriter testwriter = new StreamWriter(SINPConfigurazione.TracePath + sdate + "xmlServerResponse.xml", true);
                        //serializer.Serialize(testwriter, sr);
                        //testwriter.Close();
                    }
                }
                catch (Exception Ex)
                {
                    fdcSocketLogger.LogError(string.Format("Exception tracing xml file: {0}", Ex.Message));
                    //FDCPOSManager.tracer.WriteLine(string.Format("Exception tracing xml file: {0}", Ex.Message));
                }
            }
            catch (Exception ex)
            {
                fdcSocketLogger.LogError("SendResponse " + typeof(T).Name + " to client: " + fdcPosClient.sID
                    + " Exceptioned: " + ex
                    + System.Environment.NewLine + "Will disconect this client");
                fdcPosClient.Dispose();
                this.fdcPosManager.DisconnectClient(fdcPosClient);
                return false;
            }

            return true;
        }

        public void Dispose()
        {
            try
            {
                this.disposed = true;
                this.fdcSocketLogger.LogError($"FdcServerTcpHandler is on stopping, and will Dispose all fdcClientTcpHandlers(total: {this.fdcClientTcpHandlers.Count}) as well... ");
                this.tcpListener.Stop();
                this.fdcClientTcpHandlers.ForEach(c => { try { c.Dispose(); } catch { } });
                this.fdcClientTcpHandlers.Clear();
            }
            finally
            {
            }
        }
    }
}