FCC/Extension/WayneClassicFdcClient/FControlFUSIONCF/IFSFMessages.cs

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

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;

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

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

        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 += serializer_UnknownNode;
                ser.UnknownAttribute += serializer_UnknownAttribute;
            }
            return ser;
        }

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

        private void asyncResponseManager_OnResponseTimeout(object sender, EventArgs e)
        {
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init OnResponseTimeout"));

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

            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end OnResponseTimeout"));
        }

#if !(_TEVENTARGS)
        public void EnqueueMessage(ServiceRequest sr, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src, bool responseRequired)
        {
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), 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)
                {
                    Trace.WriteLine(ex.Message + " - " + ex.StackTrace);
                }
                if (requestId > 0)
                    this.OnIFSFSMessageEnqueuing.Invoke(this, new MessageEnqueuedEventArgs(requestId, sr.RequestType, requestCompleted, userToken, src, responseRequired));
            }

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

        public void EnqueueMessage(ServiceRequest sr, EventHandler<AsyncCompletedEventArgs<long>> requestCompleted, object userToken, object src, bool responseRequired, long resultLong)
        {
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("EnqueueMessage(long) 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)
                {
                    Trace.WriteLine("Exception EnqueueMessage(long)! " + ex.Message + " - " + ex.StackTrace);
                }
                if (requestId > 0)
                    this.OnIFSFSMessageEnqueuing.Invoke(this, new MessageEnqueuedEventArgs(requestId, sr.RequestType, requestCompleted, userToken, src, responseRequired, resultLong));
            }

            // enqueue the object in the socket elaboration queue
            Monitor.Enter(serviceRequestChannelA);
            serviceRequestChannelA.Enqueue(sr);
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("enqueued(long): count='{0}'", serviceRequestChannelA.Count));
            if (this.OnIFSFSMessageEnqueued != null)
            {
                this.OnIFSFSMessageEnqueued.Invoke(this, null);
            }
            Monitor.Exit(serviceRequestChannelA);
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("EnqueueMessage(long) end: RequestType='{0}', requestId={1}", sr.RequestType, sr.RequestID));
        }
        public void EnqueueMessage(ServiceRequest sr, EventHandler<AsyncCompletedEventArgs<ITankReadingEx>> requestCompleted, object userToken, object src, bool responseRequired, ITankReadingEx resultITankreading)
        {
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("EnqueueMessage(ITankReadingEx) 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)
                {
                    Trace.WriteLine("Exception EnqueueMessage(ITankReadingEx)! " + ex.Message + " - " + ex.StackTrace);
                }
                if (requestId > 0)
                    this.OnIFSFSMessageEnqueuing.Invoke(this, new MessageEnqueuedEventArgs(requestId, sr.RequestType, requestCompleted, userToken, src, responseRequired, resultITankreading));
            }

            // enqueue the object in the socket elaboration queue
            Monitor.Enter(serviceRequestChannelA);
            serviceRequestChannelA.Enqueue(sr);
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("enqueued(ITankReadingEx): count='{0}'", serviceRequestChannelA.Count));
            if (this.OnIFSFSMessageEnqueued != null)
            {
                this.OnIFSFSMessageEnqueued.Invoke(this, null);
            }
            Monitor.Exit(serviceRequestChannelA);
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("EnqueueMessage(ITankReadingEx) end: RequestType='{0}', requestId={1}", sr.RequestType, sr.RequestID));
        }
        public void EnqueueMessage(ServiceRequest sr, EventHandler<AsyncCompletedEventArgs<PumpAccumulatorReading>> requestCompleted, object userToken, object src, bool responseRequired, PumpAccumulatorReading resultPumpAccumulatorReading)
        {
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("EnqueueMessage(PumpAccumulatorReading) 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)
                {
                    Trace.WriteLine("Exception EnqueueMessage(PumpAccumulatorReading)! " + ex.Message + " - " + ex.StackTrace);
                }
                if (requestId > 0)
                    this.OnIFSFSMessageEnqueuing.Invoke(this, new MessageEnqueuedEventArgs(requestId, sr.RequestType, requestCompleted, userToken, src, responseRequired, resultPumpAccumulatorReading));
            }

            // enqueue the object in the socket elaboration queue
            Monitor.Enter(serviceRequestChannelA);
            serviceRequestChannelA.Enqueue(sr);
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("enqueued(PumpAccumulatorReading): count='{0}'", serviceRequestChannelA.Count));
            if (this.OnIFSFSMessageEnqueued != null)
            {
                this.OnIFSFSMessageEnqueued.Invoke(this, null);
            }
            Monitor.Exit(serviceRequestChannelA);
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("EnqueueMessage(PumpAccumulatorReading) end: RequestType='{0}', requestId={1}", sr.RequestType, sr.RequestID));
        }
        public void EnqueueMessage(ServiceRequest sr, EventHandler<OptWriteCompletedEventArgs> requestCompleted, object userToken, object src, bool responseRequired, OptWriteCompletedEventArgs resultOptWrite)
        {
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("EnqueueMessage(opt) 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)
                {
                    Trace.WriteLine("Exception EnqueueMessage(opt)! " + ex.Message + " - " + ex.StackTrace);
                }
                if (requestId > 0)
                    this.OnIFSFSMessageEnqueuing.Invoke(this, new MessageEnqueuedEventArgs(requestId, sr.RequestType, requestCompleted, userToken, src, responseRequired, resultOptWrite));
            }

            // enqueue the object in the socket elaboration queue
            Monitor.Enter(serviceRequestChannelA);
            serviceRequestChannelA.Enqueue(sr);
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("enqueued(opt): count='{0}'", serviceRequestChannelA.Count));
            if (this.OnIFSFSMessageEnqueued != null)
            {
                this.OnIFSFSMessageEnqueued.Invoke(this, null);
            }
            Monitor.Exit(serviceRequestChannelA);
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("EnqueueMessage(opt) end: RequestType='{0}', requestId={1}", sr.RequestType, sr.RequestID));
        }
        public void EnqueueMessage(FDCMessage msg, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src, bool responseRequired)
        {
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), 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)
                {
                    Trace.WriteLine(ex.Message + " - " + ex.StackTrace);
                }
                if (requestId > 0)
                    this.OnIFSFSMessageEnqueuing.Invoke(this, new MessageEnqueuedEventArgs(requestId, msg.MessageType, requestCompleted, userToken, src, responseRequired));
            }

            // enqueue the object in the socket elaboration queue
            Monitor.Enter(serviceRequestChannelA);
            serviceRequestChannelA.Enqueue(msg);
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("enqueued: count='{0}'", serviceRequestChannelA.Count));
            if (this.OnIFSFSMessageEnqueued != null)
            {
                this.OnIFSFSMessageEnqueued.Invoke(this, null);
            }
            Monitor.Exit(serviceRequestChannelA);
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("EnqueueMessage end: MessageType='{0}', MessageId={1}", msg.MessageType, msg.MessageID));
        }
#else
        public void EnqueueMessage<TEventArgs, TResult>(ServiceRequest sr, EventHandler<TEventArgs> requestCompleted, object userToken, object src, bool responseRequired, TResult result) where TEventArgs : EventArgs
        {
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("EnqueueMessage(opt) 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)
                {
                    Trace.WriteLine("Exception EnqueueMessage(opt)! " + ex.Message + " - " + ex.StackTrace);
                }
                if (requestId > 0)
                    this.OnIFSFSMessageEnqueuing.Invoke(this, new MessageEnqueuedEventArgs<TEventArgs, TResult>(requestId, sr.RequestType, requestCompleted, userToken, src, responseRequired, result));
            }

            // enqueue the object in the socket elaboration queue
            Monitor.Enter(serviceRequestChannelA);
            serviceRequestChannelA.Enqueue(sr);
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("enqueued(opt): count='{0}'", serviceRequestChannelA.Count));
            if (this.OnIFSFSMessageEnqueued != null)
            {
                this.OnIFSFSMessageEnqueued.Invoke(this, null);
            }
            Monitor.Exit(serviceRequestChannelA);
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("EnqueueMessage(opt) end: RequestType='{0}', requestId={1}", sr.RequestType, sr.RequestID));
        }
#endif
        public T Deserialize<T>(string myString, ref OverallResult result)
        {
            T sr = default(T);
            try
            {
                // Create an instance of the XmlSerializer class;
                // specify the type of object to be deserialized.
                XmlSerializer serializer = new XmlSerializer(typeof(T));
                /* If the XML document has been altered with unknown nodes or attributes, handle them with the UnknownNode and UnknownAttribute events.*/
                serializer.UnknownNode += new XmlNodeEventHandler(serializer_UnknownNode);
                serializer.UnknownAttribute += new XmlAttributeEventHandler(serializer_UnknownAttribute);
                // Declare an object variable of the type to be deserialized.

                using (var tempStream = new System.IO.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 Exception)
            {
                result = OverallResult.ParsingError;
            }
            return sr;
        }

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

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

        private void TraceInXml(string msg)
        {                      
            if (_ifsfSockets.configParam.TraceXML)
            {
                var path = string.Format("{0}{1:00}-{2:00}-xmlClientMsg.xml", ConfigurationParams.tracePath,
                    DateTime.Now.Day, DateTime.Now.Month);

                using (var testwriter = new StreamWriter(path, true))
                {
                    testwriter.Write(msg);
                }
            }
        }

    }
}