initialize

interface/asm/dotnet/AdapterApplication3x/com.itac.mes.proxy.business/OIBServiceImpl.cs

@@ -0,0 +1,711 @@
+#region Namespace
+using Asm.As.Oib.Client;
+using Asm.As.Oib.SiplacePro.LineControl.Contracts;
+using Asm.As.Oib.SiplacePro.Proxy.Architecture.Objects;
+using com.itac.mes.domain;
+using com.itac.oib;
+using Tools = com.itac.mes.tools;
+using  com.itac.mes.tools;
+
+using com.itac.oib.displayservice.contracts.data;
+using com.itac.oib.linecontrol.contracts.data;
+using com.itac.oib.siplacesetupcenter.contracts.data;
+using com.itac.oib.siplacepro.service;
+using com.itac.oib.siplacepro.contracts.data;
+using Itac.Oib;
+using System;
+using System.Diagnostics;
+using LcTypes = Asm.As.Oib.SiplacePro.LineControl.Contracts;
+using OibSpiTyp = Asm.As.Oib.SiplacePro.Proxy.Types;
+using Asm.As.Oib.Client.CustomExtensions;
+using com.itac.oib.client.customextensions;
+using com.itac.oib.traceability.contracts.data;
+using com.itac.oib.linecontrol.data;
+using System.Collections.Generic;
+using Asm.As.Oib.DisplayService.Contracts.Messages;
+#endregion
+
+namespace com.itac.mes.proxy.business
+{
+    public class OIBServiceImpl : OIBService, IDisposable
+    {
+        #region Fields
+
+        private IAdapterControl _adapterControl;
+        private readonly MessageWriter _messageWriter;
+        public ChangeoverReceiver ChangeoverReceiver { get; set; }
+
+        #endregion
+
+        public OIBServiceImpl(IAdapterControl adapterControl, MessageWriter messageWriter)
+        {
+            _adapterControl = adapterControl;
+            _messageWriter = messageWriter;
+        }
+
+        public OibSetupCenterAccess OibSetupCenterAccess { get; set; }
+        public OibLineControlAccess OibLineControlAccess { get; set; }
+        public SiplacePro SiplacePro { set; get; }
+        public OibDisplayServiceAccess DisplayServiceAccess { get; set; }
+        public string configuredLineFullPath { get; set; }
+        public string firstMachineInLine { get; set; }
+        public string lastMachineInLine { get; set; }
+
+        public void Shutdown()
+        {
+        }
+
+        internal void SetAdapterControl(IAdapterControl adapterControl)
+        {
+            _adapterControl = adapterControl;
+        }
+
+        #region ISiplaceSetupCenter Member
+
+        public void set(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnitLocation[] packagingUnitLocations)
+        {
+            try
+            {
+                OibSetupCenterAccess.Set(PackagingUnitLocationMapper.get(packagingUnitLocations));
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "Class OIBServiceImpl, Call ISiplaceSetupCenter.Set failed: ", e);
+            }
+        }
+
+        public void refill(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnitLocation[] packagingUnitLocations)
+        {
+            try
+            {
+                OibSetupCenterAccess.Refill(PackagingUnitLocationMapper.get(packagingUnitLocations));
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "Class OIBServiceImpl, Call ISiplaceSetupCenter.Refill failed: ", e);
+            }
+        }
+
+        public void tearDown(string strSetup, com.itac.oib.siplacesetupcenter.contracts.data.ComponentLocation[] componentLocations)
+        {
+            try
+            {
+                OibSetupCenterAccess.TearDown(strSetup, ComponentLocationMapper.get(componentLocations));
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "Class OIBServiceImpl, Call ISiplaceSetupCenter.TearDown failed: ", e);
+            }
+        }
+
+        public com.itac.oib.siplacesetupcenter.contracts.data.MachineSetup getReducedActualSetup(string machineId)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to SetupCenter.GetReducedActualSetup(machineId=" + machineId + ")");
+            try
+            {
+                www.siplace.com.OIB._2008._05.SetupCenter.Contracts.Data.MachineSetup oibMachineSetup = OibSetupCenterAccess.GetReducedActualSetup(machineId);
+                if (oibMachineSetup == null)
+                {
+                    LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to SetupCenter.GetReducedActualSetup returned null");
+                    return null;
+                }
+                MachineSetup machineSetup = MachineSetupMapper.get(oibMachineSetup);
+                Evaluate(machineSetup);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to SetupCenter.GetReducedActualSetup returned");
+                return machineSetup;
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to SetupCenter.GetReducedActualSetup failed", e);
+                return null;
+            }
+        }
+
+        public PackagingUnitResult[] update(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnit[] packagingUnits)
+        {
+            try
+            {
+                return PackagingUnitResultMapper.getArray(OibSetupCenterAccess.Get(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnitMapper.get(packagingUnits)));
+            }
+            catch (Exception) { return null; }
+        }
+
+        public PackagingUnitResult[] get(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnit[] packagingUnits)
+        {
+            try
+            {
+                return PackagingUnitResultMapper.getArray(OibSetupCenterAccess.Get(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnitMapper.get(packagingUnits)));
+            }
+            catch (Exception) { return null; }
+        }
+
+        public com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnitResult[] create(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnit[] packagingUnits)
+        {
+            try { return PackagingUnitResultMapper.getArray(OibSetupCenterAccess.Get(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnitMapper.get(packagingUnits))); }
+            catch (Exception) { return null; }
+        }
+
+        public PackagingUnitResult[] delete(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnit[] packagingUnits)
+        {
+            return PackagingUnitResultMapper.getArray(OibSetupCenterAccess.Get(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnitMapper.get(packagingUnits)));
+        }
+
+        public void activate(ComponentLocation[] componentLocations)
+        {
+            try
+            {
+                OibSetupCenterAccess.Activate(ComponentLocationMapper.get(componentLocations));
+            }
+            catch (Exception) { }
+        }
+
+        public void deactivate(com.itac.oib.siplacesetupcenter.contracts.data.ComponentLocation[] componentLocations, string reason)
+        {
+            try
+            {
+                OibSetupCenterAccess.Deactivate(ComponentLocationMapper.get(componentLocations), reason);
+            }
+            catch (Exception) { }
+        }
+
+        public void lockUids(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnit[] puIDs, string reason)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to SetupCenter.Lock(reason=" + reason + ")");
+            try
+            {
+                OibSetupCenterAccess.Lock(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnitMapper.get(puIDs), reason);
+                Evaluate(puIDs);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to SetupCenter.Lock returned");
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to SetupCenter.Lock failed", e);
+            }
+        }
+
+        public void unlockUids(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnit[] puIDs)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to SetupCenter.Unlock");
+            try
+            {
+                OibSetupCenterAccess.Unlock(com.itac.oib.siplacesetupcenter.contracts.data.PackagingUnitMapper.get(puIDs));
+                Evaluate(puIDs);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to SetupCenter.Unlock returned");
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to SetupCenter.Unlock failed", e);
+            }
+        }
+
+        public Configuration getConfiguration()
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to SetupCenter.GetConfiguration");
+            try
+            {
+                var configuration = ConfigurationMapper.get(OibSetupCenterAccess.GetConfiguration());
+                Evaluate(configuration);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to SetupCenter.GetConfiguration returned");
+
+                return configuration;
+            }
+            catch(Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to SetupCenter.GetConfiguration failed", e);
+                return null;
+            }
+        }
+
+        public bool isConnected()
+        {
+            try
+            {
+                return OibSetupCenterAccess.IsConnected();
+            }
+            catch { return false; }
+        }
+
+        public void setMessageLevel(int messageLevel)
+        {
+            try
+            {
+                OibSetupCenterAccess.SetMessageLevel(messageLevel);
+            }
+            catch { }
+        }
+
+        public string getDatabaseName()
+        {
+            try
+            {
+                return OibSetupCenterAccess.GetDatabaseName();
+            }
+            catch { return null; }
+        }
+
+        #endregion
+
+        #region ILineControl Member
+
+        public string getDatabaseId()
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to LineControl.getDatabaseId");
+            try
+            {
+                String result = OibLineControlAccess.LineControlSession.DatabaseId;
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to LineControl.getDatabaseId returned " + result);
+                return result;
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to LineControl.getDatabaseId failed, return false ", e);
+                return null;
+            }
+        }
+
+        public string getAdapterTimeZone()
+        {
+            try
+            {
+                return OibLineControlAccess.LineControlSession.GetAdapterTimeZone();
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to LineControl.getAdapterTimeZone failed, return empty string ", e);
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// full path required (including folders)
+        /// </summary>
+        /// <param name="lineName"></param>
+        /// <returns></returns>
+        public bool stopLine(string lineName)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to LineControl.StopLine(" + lineName + ")");
+            try
+            {
+                bool b = OibLineControlAccess.LineControlSession.StopLine(lineName);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to LineControl.StopLine returned " + b);
+                return b;
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to LineControl.StopLine failed, return false ", e);
+                return false;
+            }
+        }
+
+        public bool stopLineConveyor(string lineName, int nLanes)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to LineControl.StopLineConveyor(" + lineName + "," + nLanes + ")");
+            try
+            {
+                var oibLanes = (LcTypes.ConveyorLanes)Enum.ToObject(typeof(LcTypes.ConveyorLanes), nLanes);
+                bool b = OibLineControlAccess.LineControlSession.StopLineConveyor(lineName, oibLanes);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to LineControl.StopLineConveyor returned " + b);
+                return b;
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to LineControl.StopLineConveyor failed, return false", e);
+                return false;
+            }
+        }
+
+        public bool continueLine(string lineName)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to LineControl.ContinueLine(" + lineName + ")");
+            try
+            {
+                bool b = OibLineControlAccess.LineControlSession.ContinueLine(lineName);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to LineControl.ContinueLine returned " + b);
+                return b;
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to LineControl.ContinueLine failed, return false", e);
+                return false;
+            }
+        }
+
+        public bool continueLineConveyor(string lineName, int nLanes)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to LineControl.ContinueLineConveyor(" + lineName + "," + nLanes + ")");
+            try
+            {
+                var oibLanes = (LcTypes.ConveyorLanes)Enum.ToObject(typeof(LcTypes.ConveyorLanes), nLanes);
+                bool b = OibLineControlAccess.LineControlSession.ContinueLineConveyor(lineName, oibLanes);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to LineControl.ContinueLineConveyor returned " + b);
+                return b;
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to LineControl.ContinueLineConveyor failed, return false", e);
+                return false;
+            }
+        }
+
+        public bool blockStationInputConveyor(string station, bool bLock, string strBlockingApplicationName)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to LineControl.BlockStationInputConveyor(" + station + "," + bLock + ", " + strBlockingApplicationName + ")");
+            try
+            {
+                bool b = OibLineControlAccess.LineControlSession.BlockStationInputConveyor(station, bLock, strBlockingApplicationName);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to LineControl.BlockStationInputConveyor returned " + b);
+                return b;
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to LineControl.BlockStationInputConveyor failed, return false", e);
+                return false;
+            }
+        }
+
+        public bool unBlockStationInputConveyor(string station, string strUnblockingApplicationName)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to LineControl.UnBlockStationInputConveyor(" + station + ", " + strUnblockingApplicationName + ")");
+            try
+            {
+                bool b = OibLineControlAccess.LineControlSession.UnBlockStationInputConveyor(station, strUnblockingApplicationName);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to LineControl.UnBlockStationInputConveyor returned " + b);
+                return b;
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to LineControl.UnBlockStationInputConveyor failed, return false", e);
+                return false;
+            }
+        }
+
+        public string getActiveProductionSchedule(string lineName)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to LineControl.GetActiveProductionSchedule(" + lineName + ")");
+            String result = null;
+            try
+            {
+                result = OibLineControlAccess.LineControlSession.GetActiveProductionSchedule(lineName);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to LineControl.GetActiveProductionSchedule(" + lineName + ") returned " + result);
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to LineControl.GetActiveProductionSchedule failed", e);
+            }
+            return result;
+        }
+
+        public LineControlLineStatus getLineStatus(string lineName)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to LineControl.GetLineStatus(" + lineName + ")");
+            LineControlLineStatus result = null;
+            try
+            {
+                result = LineControlLineStatusMapper.get(OibLineControlAccess.LineControlSession.GetLineStatus(lineName));
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to LineControl.GetLineStatus(" + lineName + ") returned ");
+                Evaluate(result);
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, ".NET call to LineControl.GetLineStatus failed", e);
+            }
+            return result;
+        }
+
+        public StartJobResult startPlacementRecipe(string productionSchedule, string jobName, int conveyor)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to LineControl.startPlacementRecipe(schedule=" + productionSchedule + ", job=" + jobName + ", conveyor=" + conveyor + ")");
+
+            StartJobResult startJobResult = new StartJobResult();
+            try
+            {
+                // evtl. ist productionSchedule leer, dann den aktuellen Schedule der Linie nehmen
+                LcTypes.ConveyorLanes lcLane = (LcTypes.ConveyorLanes)conveyor;
+
+                // Get the SIPLACE Pro session for the SPI adapter on the local host
+                Session session = SiplacePro.oibSpiAccess.Session;
+
+                // Get the line the production schedule will be for.
+                Object line = session.GetObject(configuredLineFullPath, OibSpiTyp.ObjectServerType.Line);
+                if (line == null)
+                {
+                    startJobResult.errorText = string.Format("Line '{0}' does not exist in SIPLACE Pro.", configuredLineFullPath);
+                    startJobResult.result = false;
+                    return startJobResult;
+                }
+
+                if (productionSchedule.Equals("") || productionSchedule.Equals("*"))
+                {
+                    // automatic resolving of current production schedule
+                    productionSchedule = OibLineControlAccess.LineControlSession.GetActiveProductionSchedule(configuredLineFullPath);
+                    LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "automatic resolved ProductionSchedule is " + productionSchedule);
+                }
+
+                Asm.As.Oib.SiplacePro.Proxy.Business.Objects.ProductionSchedule prodSched = session.GetObject(productionSchedule, OibSpiTyp.ObjectServerType.ProductionSchedule) as Asm.As.Oib.SiplacePro.Proxy.Business.Objects.ProductionSchedule;
+                if (prodSched == null)
+                {
+                    startJobResult.errorText = string.Format("ProductionSchedule '{0}' not found in SIPLACE Pro.", productionSchedule);
+                    startJobResult.result = false;
+                    return startJobResult;
+                }
+                bool found = false;
+                Asm.As.Oib.SiplacePro.Proxy.Business.Objects.ProductionScheduleElement productionScheduleElement = null;
+                foreach (Asm.As.Oib.SiplacePro.Proxy.Business.Objects.ProductionScheduleElement prodSchedElem in prodSched.ProductionScheduleElements.Values)
+                {
+                    if (prodSchedElem.Recipe.Name.Equals(jobName) || prodSchedElem.Recipe.FullPath.Equals(jobName))
+                    {
+                        found = true;
+                        productionScheduleElement = prodSchedElem;
+                        break;
+                    }
+                }
+                if (!found)
+                {
+                    startJobResult.errorText = string.Format("Job {0} not found in ProductionSchedule '{1}'.", jobName, productionSchedule);
+                    startJobResult.result = false;
+                    return startJobResult;
+                }
+
+                Asm.As.Oib.SiplacePro.LineControl.Contracts.Data.DownloadResult result = OibLineControlAccess.LineControlSession.DownloadIC(
+                    prodSched.FullPath, //Name of the production schedule
+                    prodSched.ProductionScheduleElements.IndexOf(productionScheduleElement), //Zero based index of the ProductionScheduleElement
+                    "", // ProductionScheduleElement ID, if this is empty, Index will be used
+                    lcLane,//
+                   LcTypes.IntegrityCheckMode.AllowHeadstepRecalcuation,
+                  LcTypes.IntegrityCheckModeForRepartitioning.AvoidRepartitioning,
+                   LcTypes.DownloadProcessingOptions.AutoWidthAdjust | LcTypes.DownloadProcessingOptions.OverwriteFeederSettings)
+                    as Asm.As.Oib.SiplacePro.LineControl.Contracts.Data.DownloadResult;
+                startJobResult.result = result.Succeeded;
+                startJobResult.errorText = result.DetailedResults.ToString();
+            }
+            catch (Exception e)
+            {
+                startJobResult.errorText = e.Message;
+                startJobResult.result = false;
+                return startJobResult;
+            }
+            Evaluate(startJobResult);
+            return startJobResult;
+        }
+
+
+        #endregion
+
+        #region IAdapterControl Member
+
+        public void startSetupCenterNotifyReceiver()
+        {
+            if (_adapterControl != null) { _adapterControl.startSetupCenterNotifyReceiver(); }
+        }
+
+        public void stopSetupCenterNotifyReceiver()
+        {
+            if (_adapterControl != null) { _adapterControl.stopSetupCenterNotifyReceiver(); }
+        }
+
+        public void startMonitoringReceiver()
+        {
+            _adapterControl.startMonitoringReceiver();
+        }
+
+        public void stopMonitoringReceiver()
+        {
+            _adapterControl.stopMonitoringReceiver();
+        }
+
+        public bool ping()
+        {
+            return _adapterControl.ping();
+        }
+
+        public bool isSetupStation()
+        {
+            return _adapterControl.isSetupStation();
+        }
+
+        public void setInterfaceHost(int port, string ipAddress, string canonicalHostName, string hostName)
+        {
+            _adapterControl.setInterfaceHost(port, ipAddress, canonicalHostName, hostName);
+        }
+
+        public void setChannelName(string channelName)
+        {
+            _adapterControl.setChannelName(channelName);
+        }
+
+        public void startTraceReceiver()
+        {
+            _adapterControl.startTraceReceiver();
+        }
+
+        public void stopTraceReceiver()
+        {
+            _adapterControl.stopTraceReceiver();
+        }
+
+        public void startBoardGateKeeper()
+        {
+            _adapterControl.startBoardGateKeeper();
+        }
+
+        public void stopBoardGateKeeper()
+        {
+            _adapterControl.stopBoardGateKeeper();
+        }
+
+        public void startDekReceiver()
+        {
+            _adapterControl.startDekReceiver();
+        }
+
+        public void stopDekReceiver()
+        {
+            _adapterControl.stopDekReceiver();
+        }
+
+        #endregion
+
+        #region ISiplacePro Member
+
+        public BoardCheckInRequest completeCheckinData(BoardCheckInRequest checkinData)
+        {
+            return SiplacePro.completeCheckinData(checkinData);
+        }
+
+        public BoardElement[] getPlacementForBoard(String boardFullName)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to SiplacePro.getPlacementForBoard(" + boardFullName + ")");
+            BoardElement[] placeInfo = null;
+            try
+            {
+                placeInfo = SiplacePro.getPlacementForBoard(boardFullName);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, ".NET call to SiplacePro.getPlacementForBoard(" + boardFullName + ") returned ");
+                Evaluate(placeInfo);
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, "java call to SiplacePro.getPlacementForBoard failed", e);
+            }
+            return placeInfo;
+        }
+
+        // beim starten des interface ermittelt sich das Interface darueber einmalig den Status und die Rüstng der Linie, und
+        // kann damit die Rüstung neu aufbauen
+        oib.client.customextensions.LineChangeoverEventArgs ISiplacePro.getCurrentLineProductionData()
+        {
+            if (ChangeoverReceiver == null) { return null; }
+            return ChangeoverReceiver.getCurrentLineProductionData();
+        }
+
+        #endregion
+
+        #region Logging Utils
+
+        private void Evaluate(Object arg)
+        {
+            if (_messageWriter != null)
+            {
+                _messageWriter.output(arg);
+            }
+        }
+
+        #endregion
+
+        #region IDisposable
+
+        public void Dispose()
+        {
+            if (OibLineControlAccess != null)
+                OibLineControlAccess.Dispose();
+            if (OibSetupCenterAccess != null)
+                OibSetupCenterAccess.Dispose();
+            if (OibLineControlAccess != null)
+                OibLineControlAccess.Dispose();
+            if (OibLineControlAccess != null)
+                OibLineControlAccess.Dispose();
+        }
+
+        #endregion
+
+
+        public void sendMessageByLinePathAllStations(string linePath, string messageText, string extendedDescription, AcknowledgementType acknowledgementType,
+            bool callbackRequest, SeverityLevel severityLevel)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to SendMessageByLinePathAllStations");
+            // wenn default-Wert (*) dann den konfigurierten Wert für die Linie benutzen
+            if (linePath == null || linePath.Length == 0 || linePath.Equals("*"))
+            {
+                linePath = configuredLineFullPath;
+            }
+            try
+            {
+                Asm.As.Oib.DisplayService.Proxy.Architecture.Objects.DisplayServiceClient displaySession = DisplayServiceAccess.DisplayServiceSession;
+                Asm.As.Oib.DisplayService.Contracts.Data.Types.AcknowledgementType ackType = AcknowledgementTypeMapper.get(acknowledgementType);
+                Asm.As.Oib.DisplayService.Contracts.Data.Types.SeverityLevel severity = SeverityLevelMapper.get(severityLevel);
+                Asm.As.Oib.DisplayService.Contracts.Messages.SendMessageResponse sendMessageResponse = displaySession.
+                    SendMessageByLinePathAllStations(linePath, messageText, extendedDescription, ackType, callbackRequest, 0, severity, null, null);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to SendMessageByStationPath finished");
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, "java call to SendMessageByStationPath finished", e);
+            }
+        }
+
+        public void sendMessageByLinePathFirstStation(string linePath, string messageText, string extendedDescription, AcknowledgementType acknowledgementType,
+            bool callbackRequest, SeverityLevel severityLevel)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to SendMessageByLinePathFirstStation");
+            if (linePath.Equals("*"))
+            {
+                linePath = configuredLineFullPath;
+            }
+            try
+            {
+                Asm.As.Oib.DisplayService.Proxy.Architecture.Objects.DisplayServiceClient displaySession = DisplayServiceAccess.DisplayServiceSession;
+                Asm.As.Oib.DisplayService.Contracts.Data.Types.AcknowledgementType ackType = AcknowledgementTypeMapper.get(acknowledgementType);
+                Asm.As.Oib.DisplayService.Contracts.Data.Types.SeverityLevel severity = SeverityLevelMapper.get(severityLevel);
+                Asm.As.Oib.DisplayService.Contracts.Messages.SendMessageResponse sendMessageResponse = displaySession.
+                    SendMessageByLinePathFirstStation(linePath, messageText, extendedDescription, ackType, callbackRequest, 0, severity, null, null);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to SendMessageByLinePathFirstStation finished");
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, "java call to SendMessageByLinePathFirstStation finished", e);
+            }
+        }
+
+        public void sendMessageByStationPath(string stationPath, string messageText, string extendedDescription, AcknowledgementType acknowledgementType,
+            bool callbackRequest, SeverityLevel severityLevel, Answer[] answerList)
+        {
+            LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to SendMessageByStationPath");
+            if (stationPath.Equals("*"))
+            {
+                stationPath = firstMachineInLine;
+            }
+            else if (stationPath.Equals("#"))
+            {
+                stationPath = lastMachineInLine;
+            }
+            try
+            {
+                Asm.As.Oib.DisplayService.Proxy.Architecture.Objects.DisplayServiceClient displaySession = DisplayServiceAccess.DisplayServiceSession;
+
+                Asm.As.Oib.DisplayService.Contracts.Data.Types.AcknowledgementType ackType = AcknowledgementTypeMapper.get(acknowledgementType);
+                Asm.As.Oib.DisplayService.Contracts.Data.Types.SeverityLevel severity = SeverityLevelMapper.get(severityLevel);
+
+                List<Asm.As.Oib.DisplayService.Contracts.Data.Answer> asmAnswerList = new List<Asm.As.Oib.DisplayService.Contracts.Data.Answer>();
+
+                Asm.As.Oib.DisplayService.Contracts.Messages.SendMessageResponse sendMessageResponse = displaySession.
+                    SendMessageByStationPath(stationPath, messageText, extendedDescription, ackType, callbackRequest, 0, severity, asmAnswerList, null);
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Information, "java call to SendMessageByStationPath finished with failure");
+            }
+            catch (Exception e)
+            {
+                LogHandler.log(Tools.Constants.LOGGER, TraceEventType.Error, "java call to SendMessageByStationPath finished", e);
+            }
+        }
+
+
+    }
+}