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

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

namespace Wayne.ForecourtControl.Fusion
{
    public class IFSFMessages
    {
        private Queue<BasePOSRequest> _serviceRequestChannelA = null;
        public Queue<BasePOSRequest> serviceRequestChannelA
        {
            get { return _serviceRequestChannelA; }
        }

        private IFSFSockets _ifsfSockets;
        public IFSFSockets ifsfSockets
        {
            get { return _ifsfSockets; }
        }

        public event EventHandler OnIFSFSMessageEnqueued;
        public event EventHandler<MessageEnqueuedEventArgs> OnIFSFSMessageEnqueuing;
        public event EventHandler OnResponseTimeout;

        private readonly DebugLogger debugLogger;

        public IFSFMessages(IFSFSockets myifsfSockets, DebugLogger debugLogger)
        {
            _ifsfSockets = myifsfSockets;
            _serviceRequestChannelA = new Queue<BasePOSRequest>();
            serializers = new Hashtable();

            this.debugLogger = debugLogger;

            this._asyncResponseManager = new AsyncResponseManager(debugLogger);
            this._asyncResponseManager.OnResponseTimeout += new EventHandler(asyncResponseManager_OnResponseTimeout);
            OnIFSFSMessageEnqueuing += new EventHandler<MessageEnqueuedEventArgs>(this.asyncResponseManager.OnMessageEnqueuing);
        }

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

        private Hashtable serializers;
        public XmlSerializer GetXmlSerializer(Type T)
        {
            XmlSerializer ser = (XmlSerializer)serializers[T];
            if (ser == null)
            {
                ser = new XmlSerializer(T);
                serializers[T] = ser;
                /* If the XML document has been altered with unknown nodes or attributes, handle them with the UnknownNode and UnknownAttribute events.*/
                ser.UnknownNode += new XmlNodeEventHandler(serializer_UnknownNode);
                ser.UnknownAttribute += new XmlAttributeEventHandler(serializer_UnknownAttribute);
            }
            return ser;
        }

        private AsyncResponseManager _asyncResponseManager;
        public AsyncResponseManager asyncResponseManager
        {
            get
            {
                return this._asyncResponseManager;
            }
        }

        private void asyncResponseManager_OnResponseTimeout(object sender, EventArgs e)
        {
            DebugLog("OnResponseTimeout init");

            if (OnResponseTimeout != null)
                OnResponseTimeout.Invoke(this, null);

            DebugLog("OnResponseTimeout end");
        }

        public void EnqueueMessage(ServiceRequest sr, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src, bool responseRequired, int responseTimeout)
        {
            DebugLog(string.Format("EnqueueMessage init: RequestType='{0}', requestId={1}", sr.RequestType, sr.RequestID));
            // invoke enqueuing event
            if (this.OnIFSFSMessageEnqueuing != null)
            {
                int requestId = 0;
                try
                {
                    requestId = (sr.RequestID != null && sr.RequestID != "") ? Convert.ToInt32(sr.RequestID) : 0;
                }
                catch (Exception ex)
                {
                    DebugLog("EnqueueMessage Exception! " + ex.ToString());
                }
                if (requestId > 0)
                    this.OnIFSFSMessageEnqueuing.Invoke(this, new MessageEnqueuedEventArgs(requestId, sr.RequestType, responseTimeout, requestCompleted, userToken, src, responseRequired));
            }

            // enqueue the object in the socket elaboration queue
            lock (serviceRequestChannelA)
            {
                serviceRequestChannelA.Enqueue(sr);
                DebugLog(string.Format("enqueued: count='{0}'", serviceRequestChannelA.Count));
                if (this.OnIFSFSMessageEnqueued != null)
                {
                    this.OnIFSFSMessageEnqueued.Invoke(this, null);
                }
            }
            DebugLog(string.Format("EnqueueMessage end: RequestType='{0}', requestId={1}", sr.RequestType, sr.RequestID));
        }


        public void EnqueueMessage(FDCMessage msg, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src, bool responseRequired, int responseTimeout)
        {
            DebugLog(string.Format("EnqueueMessage init: MessageType='{0}', MessageId={1}", msg.MessageType, msg.MessageID));
            // invoke enqueuing event
            if (this.OnIFSFSMessageEnqueuing != null)
            {
                int requestId = 0;
                try
                {
                    requestId = (msg.MessageID != null && msg.MessageID != "") ? Convert.ToInt32(msg.MessageID) : 0;
                }
                catch (Exception ex)
                {
                    DebugLog("Exception EnqueueMessage " + ex.ToString());
                }
                if (requestId > 0)
                    this.OnIFSFSMessageEnqueuing.Invoke(this, new MessageEnqueuedEventArgs(requestId, msg.MessageType, responseTimeout, requestCompleted, userToken, src, responseRequired));
            }

            // enqueue the object in the socket elaboration queue
            lock (serviceRequestChannelA)
            {
                serviceRequestChannelA.Enqueue(msg);
                DebugLog(string.Format("enqueued: count='{0}'", serviceRequestChannelA.Count));
                if (this.OnIFSFSMessageEnqueued != null)
                {
                    this.OnIFSFSMessageEnqueued.Invoke(this, null);
                }
            }

            DebugLog(string.Format("EnqueueMessage end: MessageType='{0}', MessageId={1}", msg.MessageType, msg.MessageID));
        }




        public T Deserialize<T>(string myString, ref OverallResult result)
        {
            T sr = default(T);
            try
            {
                // get the instance of the XmlSerializer class;
                // specify the type of object to be deserialized.
                var serializer = this.GetXmlSerializer(typeof(T));
                // Declare an object variable of the type to be deserialized.
                using (var tempStream = System.Xml.XmlReader.Create(new StringReader(myString)))
                {
                    /* Use the Deserialize method to restore the object's state with data from the XML document. */
                    sr = (T)serializer.Deserialize(tempStream);
                }
            }
            catch (Exception ex)
            {
                result = OverallResult.ParsingError;
                DebugLog("Exception Deserialize: " + ex.ToString());
            }
            return sr;
        }

        private void serializer_UnknownNode(object sender, XmlNodeEventArgs e)
        {
            DebugLog("Unknown Node:" + e.Name + "\t" + e.Text);
        }

        private void serializer_UnknownAttribute(object sender, XmlAttributeEventArgs e)
        {
            System.Xml.XmlAttribute attr = e.Attr;
            DebugLog("Unknown attribute " + attr.Name + "='" + attr.Value + "'");
        }

    }
}