MockSimpleAcquisitionService.cs

Go to the documentation of this file.

using System;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Xml.Linq;
using AxelSemrau.Chronos.Plugin;
// ReSharper disable UnusedAutoPropertyAccessor.Global
 
namespace MockPlugin.AcquisitionService
{
    [SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
    [SuppressMessage("ReSharper", "UnusedAutoPropertyAccessor.Global")]
    [SuppressMessage("ReSharper", "AutoPropertyCanBeMadeGetOnly.Global")]
    public class SimpleParameters
    {
        public string InstrumentMethod { get; set; }
        public int InstrumentNumber { get; set; } = 1;
        public bool WaitForEmptyQueue { get; set; }
 
        [DefaultUnit("min")]
        public double GetReadyTimeout { get; set; }
 
        [SuppressMessage("ReSharper", "UnusedMember.Global")]
        public enum SampleTypeValue
        {
            Calibration,
            Analysis,
            Special
        }
 
        public SampleTypeValue SampleType { get; set; } = SampleTypeValue.Analysis;
 
        #region Overrides of Object
 
        public override string ToString()
        {
            return $"Method = {InstrumentMethod}, Instrument = {InstrumentNumber}, WaitForEmptyQueue = {WaitForEmptyQueue}, GetReadyTimeout = {GetReadyTimeout}, SampleType = {SampleType}";
        }
 
        #endregion
    }
    // ReSharper disable once UnusedMember.Global
    public class MockSimpleAcquisitionService : IAcquisitionService<SimpleParameters>, 
        ITraceLogger,
        IHaveConfigurator,
        IConfigurableAcquisitionService,
        ISequenceAwareAcquisitionService,
        IHaveRunlogOutput,
        ICommandUsingAcquisitionService<MockCommandAndParameters>,
        IPerseveringAcquisitionService
    {
        #region Implementation of IAcquisitionServiceBase
 
        public string Name => "MockSimpleAcquisition";
 
        private readonly Stopwatch mAvailabilityTimer = Stopwatch.StartNew();
 
        public static bool ImmediatelyAvailable { get; set; }
 
        public bool IsAvailable
        {
            get
            {
                if (ImmediatelyAvailable || mAvailabilityTimer.Elapsed > TimeSpan.FromMinutes(2))
                {
                    mAvailabilityTimer.Stop();
                    return true;
                }
 
                return false;
            }
        }
 
        public bool Abort { set => TraceLog($"Abort flag {(value ? "set" : "reset")}"); }
        public void ValidateCommand(MockCommandAndParameters cmdAndPars)
        {
            WriteToRunlog?.Invoke($"Validating command '{cmdAndPars.SomeFakeCommand}' for instrument {cmdAndPars.InstrumentNumber}");
        }
 
        public void RunCommand(MockCommandAndParameters cmdAndPars)
        {
            WriteToRunlog?.Invoke($"Running command '{cmdAndPars.SomeFakeCommand}' for instrument {cmdAndPars.InstrumentNumber}");
        }
 
        #endregion
 
        #region Implementation of IAcquisitionService<SimpleParameters>
 
        public void Validate(SimpleParameters parameters)
        {
            TraceLog($"Validating simple parameters: {parameters}");
        }
 
        public void RunAcquisition(SimpleParameters parameters)
        {
            TraceLog($"Running acquisition with parameters: {parameters}");
        }
 
        #endregion
 
        private void TraceLog(string txt)
        {
            TraceWrite?.Invoke(this, new TraceWriteEventArgs(txt));
        }
 
        #region Implementation of ITraceLogger
 
        public event EventHandler<TraceWriteEventArgs> TraceWrite;
 
        private const string RootEl = "MockServiceConfigRootElement";
 
        #endregion
 
        private string mConfigParam = "Foobar";
 
        #region Implementation of IHaveConfigurator
 
        public string ShowConfigDialog(IntPtr owner, string oldConfig)
        {
 
            var dlg = new ConfigDialog()
            {
                ParamText = ConfigFromXml(oldConfig)
            };
            var dummy = new System.Windows.Interop.WindowInteropHelper(dlg) { Owner = owner };
            if (dlg.ShowDialog() ?? false)
            {
                return ConfigToXml(dlg.ParamText);
            }
            return oldConfig;
        }
 
        #endregion
 
        #region Implementation of IConfigurableAcquisitionService
 
        public string Configuration
        {
            get => ConfigToXml(mConfigParam);
            set => mConfigParam = ConfigFromXml(value);
        }
 
        private string ConfigFromXml(string value)
        {
            if (!string.IsNullOrEmpty(value))
            {
                var el = XElement.Parse(value);
                if (el.Name == RootEl)
                {
                    return el.Value;
                }
            }
            return mConfigParam;
        }
 
 
        private string ConfigToXml(string configParam)
        {
            var el = new XElement(RootEl) {Value = configParam};
            return el.ToString();
        }
 
        #endregion
 
        #region Implementation of ISequenceAwareAcquisitionService
 
        public void BeginSequence(string pathToChronosSampleList)
        {
            TraceLog($"Sequence ${pathToChronosSampleList} was started.");
        }
 
        public void EndSequence()
        {
            TraceLog("Sequence has ended.");
        }
 
        #endregion
 
        public event Action<string> WriteToRunlog;
 
        #region Implementation of IPreseveringAcquisitionService
 
        public TimeSpan RetryInterval => TimeSpan.FromSeconds(30);
 
        #endregion
 
    }
 
    public class MockCommandAndParameters
    {
        public int InstrumentNumber { get; set; }
        public string SomeFakeCommand { get; set; } = "SayHello";
        public override string ToString() => $"'{SomeFakeCommand}' (instrument {InstrumentNumber})";
    }
}