imsInterface/interface/asm/dotnet/AdapterApplication3x/Itac.Oib/SetupCenterReceiver.cs

#region Namespace
using System;
using System.Diagnostics;
using com.itac.mes.tools;
using com.itac.mes.proxy.business;
using System.Threading;
using OibClient = Asm.As.Oib.Client;
using www.siplace.com.OIB._2008._05.SetupCenter.Contracts.Data;
#endregion

namespace Itac.Oib
{
    public class SetupCenterReceiver : IDisposable, IReceiver
    {
        #region Fields
        public OIBEventHandler _eventHandler { get; set; }
        private readonly String _lineFullPath;
        private readonly OibClient.OibSetupCenterEvents _oibSetupCenterEvents;
        private bool _isSetupStation;
        #endregion

        #region Constructor

        public SetupCenterReceiver(OibClient.OibSetupCenterEvents oibSetupCenterEvents, string lineFullPath, bool isSetupStation)
        {
            _oibSetupCenterEvents = oibSetupCenterEvents;
            _lineFullPath = lineFullPath;
            _isSetupStation = isSetupStation;

            oibSetupCenterEvents.FeederPlaced += SetupCenterFeederPlaced;
            oibSetupCenterEvents.FeederRemoved += SetupCenterFeederRemoved;
            oibSetupCenterEvents.NewSetupActive += SetupCenterNewSetupActive;
            oibSetupCenterEvents.PackagingQuantityChanged += SetupCenterPackagingQuantityChanged;
            oibSetupCenterEvents.SetupChanged += SetupCenterSetupChanged;
            oibSetupCenterEvents.PackagingUnitConsumed += SetupCenterPackagingUnitConsumed;
            oibSetupCenterEvents.MaterialMoved += SetupCenterMaterialMoved;
                }
        #endregion

        #region Start/Stop

        public void Start()
        {
            if (!_oibSetupCenterEvents.IsStarted)
            {
                _oibSetupCenterEvents.Start();
            }
        }

        public void Stop()
        {
            _oibSetupCenterEvents.Stop();
        }

        #endregion

        #region Handling of events
        private void startSetupcenterEvent(Object args)
        {
            LogHandler.log(Constants.LOGGER, TraceEventType.Information, String.Format("SetupCenterReceiver.{0}", args.GetType().Name));
        }
        private void setupcenterEventFailed(Object args, Exception e)
        {
            LogHandler.log(Constants.LOGGER, TraceEventType.Information, String.Format("calling SetupCenterNotifyReceiver.{0} failed", args.GetType().Name), e);
        }

        void SetupCenterPackagingQuantityChanged(object sender, OibClient.PackagingQuantityChangedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new PackagingQuantityChangedThread(_eventHandler, args.PackagingQuantityChangedReportRequest.PackagingQuantityChangedReport);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        void SetupCenterFeederPlaced(object sender, OibClient.FeederPlacedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new FeederPlacedThread(_eventHandler, args.FeederPlacedReportRequest.FeederPlacedReport);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        void SetupCenterFeederRemoved(object sender, OibClient.FeederRemovedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new FeederRemovedThread(_eventHandler, args.FeederRemovedReportRequest.FeederRemovedReport);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        void SetupCenterNewSetupActive(object sender, OibClient.NewSetupActiveEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new NewSetupActiveThread(_eventHandler, args.NewSetupActiveReportRequest.NewSetupActiveReport);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        void SetupCenterSetupChanged(object sender, OibClient.SetupChangedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new SetupChangedThread(_eventHandler, args.SetupChangedReportRequest.SetupChangedReport);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        void SetupCenterPackagingUnitConsumed(object sender, OibClient.PackagingUnitConsumedEventArgs args)
        {
            if (_isSetupStation)
            {
                LogHandler.log(Constants.LOGGER, TraceEventType.Information, "ignore PackagingUnitConsumed because in SetupStation mode");
                return;
            }
            startSetupcenterEvent(args);
            try
            {
                var mmt = new PackagingUnitConsumedThread(_eventHandler, args.PackagingUnitConsumedReportRequest.PackagingUnitConsumedReport);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        public void SetupCenterMaterialMoved(object sender, OibClient.MaterialMovedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new MaterialMovedThread(_eventHandler, args.MaterialMovedReportRequest.MaterialMovedReport);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }
        // Calls delegieren an die eigentliche Implementierung

        public class FeederPlacedThread : ThreadTemplate<FeederPlacedReport>
        {
            public FeederPlacedThread(OIBEventHandler eventHandler, FeederPlacedReport request) : base(eventHandler, request) { }

            public void ThreadFunction()
            {
                var mesNamespaceConformRequest = com.itac.oib.siplacesetupcenter.contracts.data.FeederPlacedReportMapper.get(_request);
                getEventHandler().feederPlaced(mesNamespaceConformRequest);
            }
        }

        public class FeederRemovedThread : ThreadTemplate<FeederRemovedReport>
        {
            public FeederRemovedThread(OIBEventHandler eventHandler, FeederRemovedReport request) : base(eventHandler, request) { }

            public void ThreadFunction()
            {
                var mesNamespaceConformRequest = com.itac.oib.siplacesetupcenter.contracts.data.FeederRemovedReportMapper.get(_request);
                getEventHandler().feederRemoved(mesNamespaceConformRequest);
            }
        }

        public class NewSetupActiveThread : ThreadTemplate<NewSetupActiveReport>
        {
            public NewSetupActiveThread(OIBEventHandler eventHandler, NewSetupActiveReport request) : base(eventHandler, request) { }

            public void ThreadFunction()
            {
                var mesNamespaceConformRequest = com.itac.oib.siplacesetupcenter.contracts.data.NewSetupActiveReportMapper.get(_request);
                getEventHandler().newSetupActive(mesNamespaceConformRequest);
            }
        }

        public class PackagingQuantityChangedThread : ThreadTemplate<PackagingQuantityChangedReport>
        {
            public PackagingQuantityChangedThread(OIBEventHandler eventHandler, PackagingQuantityChangedReport request) : base(eventHandler, request) { }

            public void ThreadFunction()
            {
                var mesNamespaceConformRequest = com.itac.oib.siplacesetupcenter.contracts.data.PackagingQuantityChangedReportMapper.get(_request);
                getEventHandler().packagingQuantityChanged(mesNamespaceConformRequest);
            }
        }
        public class SetupChangedThread : ThreadTemplate<SetupChangedReport>
        {
            public SetupChangedThread(OIBEventHandler eventHandler, SetupChangedReport request) : base(eventHandler, request) { }

            public void ThreadFunction()
            {
                var mesNamespaceConformRequest = com.itac.oib.siplacesetupcenter.contracts.data.SetupChangedReportMapper.get(_request);
                getEventHandler().setupChanged(mesNamespaceConformRequest);
            }
        }

        public class PackagingUnitConsumedThread : ThreadTemplate<PackagingUnitConsumedReport>
        {
            public PackagingUnitConsumedThread(OIBEventHandler eventHandler, PackagingUnitConsumedReport request) : base(eventHandler, request) { }

            public void ThreadFunction()
            {
                var mesNamespaceConformRequest = com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnitConsumedReportMapper.get(_request);
                getEventHandler().packagingUnitConsumed(mesNamespaceConformRequest);
            }
        }



        // Calls delegieren an die eigentliche Implementierung


        public class MaterialMovedThread : ThreadTemplate<MaterialMovedReport>
        {
            public MaterialMovedThread(OIBEventHandler eventHandler, MaterialMovedReport request) : base(eventHandler, request) { }

            public void ThreadFunction()
            {
                var mesNamespaceConformRequest = com.itac.oib.siplacesetupcenter.contracts.data.MaterialMovedReportMapper.get(_request);
                getEventHandler().materialMoved(mesNamespaceConformRequest);
            }
        }
        #endregion

        #region IDisposeable

        public void Dispose()
        {
            if (_oibSetupCenterEvents != null)
                _oibSetupCenterEvents.Dispose();
        }
        #endregion
    }
}