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

#region Namespace
using System;
using System.Diagnostics;
using System.Threading;
using Asm.As.Oib.SiplaceSetupCenter.Contracts.Data;
using com.itac.mes.proxy.business;
using com.itac.mes.tools;
using Constants = com.itac.mes.tools.Constants;
using OibClient = Asm.As.Oib.Client;
#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;
            oibSetupCenterEvents.PrinterToolVerified += SetupCenterPrinterToolVerified;
            oibSetupCenterEvents.PrinterToolUnverified += SetupCenterPrinterToolUnVerified;
            oibSetupCenterEvents.PrinterCapabilitiesChanged += SetupCenterPrinterCapabilitiesChanged;
            oibSetupCenterEvents.PrinterConsumablesUpdated += SetupCenterPrinterConsumablesChanged;
            oibSetupCenterEvents.PrinterCoverClosed += SetupCenterPrintercoverClosed;
            oibSetupCenterEvents.PrinterCoverOpened += SetupCenterPrinterCoverOpened;
            oibSetupCenterEvents.PrinterMaterialUnverified += SetupCenterPrinterMaterialUnverified;
            oibSetupCenterEvents.PrinterMaterialVerified += SetupCenterPrinterMaterialVerified;
            oibSetupCenterEvents.PrinterRecipeVerified += SetupCenterPrinterRecipeVerified;
        }
        #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.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);
                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.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.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.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.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.MaterialMovedReport);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }
        #region PrinterFunctions Receiver
        public void SetupCenterPrinterToolVerified(object sender, OibClient.PrinterToolVerifiedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new PrinterToolVerifiedThread(_eventHandler, args.PrinterToolVerifiedReportRequest);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        public void SetupCenterPrinterRecipeVerified(object sender, OibClient.PrinterRecipeVerifiedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new PrinterRecipeVerifiedThread(_eventHandler, args.PrinterRecipeVerifiedReportRequest);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        public void SetupCenterPrinterMaterialVerified(object sender, OibClient.PrinterMaterialVerifiedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new PrinterMaterialVerifiedThread(_eventHandler, args.PrinterMaterialVerifiedReportRequest);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        public void SetupCenterPrinterMaterialUnverified(object sender, OibClient.PrinterMaterialUnverifiedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new PrinterMaterialUnverifiedThread(_eventHandler, args.PrinterMaterialUnverifiedReportRequest);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        public void SetupCenterPrinterCoverOpened(object sender, OibClient.PrinterCoverOpenedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new PrinterCoverOpenedThread(_eventHandler, args.PrinterCoverOpenedReportRequest);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        public void SetupCenterPrintercoverClosed(object sender, OibClient.PrinterCoverClosedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new PrinterCoverClosedThread(_eventHandler, args.PrinterCoverClosedReportRequest);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        public void SetupCenterPrinterConsumablesChanged(object sender, OibClient.PrinterConsumablesUpdatedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new PrinterConsumablesChangedThread(_eventHandler, args.PrinterConsumablesUpdatedReportRequest);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        public void SetupCenterPrinterCapabilitiesChanged(object sender, OibClient.PrinterCapabilitiesChangedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new PrinterCapabilitiesChangedThread(_eventHandler, args.PrinterCapabilitiesChangedReportRequest);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        public void SetupCenterPrinterToolUnVerified(object sender, OibClient.PrinterToolUnverifiedEventArgs args)
        {
            startSetupcenterEvent(args);
            try
            {
                var mmt = new PrinterToolUnVerifiedThread(_eventHandler, args.PrinterToolUnverifiedReportRequest);
                var thread = new Thread(mmt.ThreadFunction);
                thread.Start();
            }
            catch (Exception e)
            {
                setupcenterEventFailed(args, e);
            }
        }

        #endregion

        // 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);
            }
        }

        public class PrinterToolVerifiedThread : ThreadTemplate<PrinterToolVerifiedReport>
        {
            public PrinterToolVerifiedThread(OIBEventHandler eventHandler, PrinterToolVerifiedReport request) : base(eventHandler, request) { }

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

        public class PrinterMaterialVerifiedThread : ThreadTemplate<PrinterMaterialVerifiedReport>
        {
            public PrinterMaterialVerifiedThread(OIBEventHandler eventHandler, PrinterMaterialVerifiedReport request) : base(eventHandler, request) { }

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

        public class PrinterMaterialUnverifiedThread : ThreadTemplate<PrinterMaterialUnverifiedReport>
        {
            public PrinterMaterialUnverifiedThread(OIBEventHandler eventHandler, PrinterMaterialUnverifiedReport request) : base(eventHandler, request) { }

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

        public class PrinterCoverOpenedThread : ThreadTemplate<PrinterCoverOpenedReport>
        {
            public PrinterCoverOpenedThread(OIBEventHandler eventHandler, PrinterCoverOpenedReport request) : base(eventHandler, request) { }

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

        public class PrinterCoverClosedThread : ThreadTemplate<PrinterCoverClosedReport>
        {
            public PrinterCoverClosedThread(OIBEventHandler eventHandler, PrinterCoverClosedReport request) : base(eventHandler, request) { }

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

        public class PrinterConsumablesChangedThread : ThreadTemplate<PrinterConsumablesUpdatedReport>
        {
            public PrinterConsumablesChangedThread(OIBEventHandler eventHandler, PrinterConsumablesUpdatedReport request) : base(eventHandler, request) { }

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

        public class PrinterCapabilitiesChangedThread : ThreadTemplate<PrinterCapabilitiesChangedReport>
        {
            public PrinterCapabilitiesChangedThread(OIBEventHandler eventHandler, PrinterCapabilitiesChangedReport request) : base(eventHandler, request) { }

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

        public class PrinterToolUnVerifiedThread : ThreadTemplate<PrinterToolUnverifiedReport>
        {
            public PrinterToolUnVerifiedThread(OIBEventHandler eventHandler, PrinterToolUnverifiedReport request) : base(eventHandler, request) { }

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

        public class PrinterRecipeVerifiedThread : ThreadTemplate<PrinterRecipeVerifiedReport>
        {
            public PrinterRecipeVerifiedThread(OIBEventHandler eventHandler, PrinterRecipeVerifiedReport request) : base(eventHandler, request) { }

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

        #region IDisposeable

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