MockUseDeviceTasks.cs

Go to the documentation of this file.

using System;
using System.ComponentModel;
using System.Drawing.Design;
using System.Linq;
using System.Windows.Forms.Design;
using System.Xml.Serialization;
using AxelSemrau.Chronos.Plugin;
using AxelSemrau.Chronos.Plugin.Consumables;
using Ctc.Palplus.Integration.Driver.Entities;
using MockPlugin.Consumables;
using MockPlugin.Device;
using MockPlugin.Properties;
using MockPlugin.SampleListColumns;
 
// ReSharper disable UnusedMember.Global
// ReSharper disable MemberCanBePrivate.Global
// ReSharper disable AutoPropertyCanBeMadeGetOnly.Global
// ReSharper disable ClassNeverInstantiated.Global
// ReSharper disable UnusedAutoPropertyAccessor.Global
 
namespace MockPlugin.Tasks
{
    public abstract class CoffeeMachineBaseTask : IConsumer
    {
        protected MockDevice mDevice;
 
        protected void CheckForCoffeeMachine(IDevice yourDevice)
        {
            mDevice = yourDevice as MockDevice;
            if (mDevice == null && yourDevice != null)
            {
                throw new ArgumentException(
                    $"Device type {yourDevice.DisplayedTypeName} is not usable for a {GetType().Name}.");
            }
            if (yourDevice == null)
            {
                throw new ArgumentException("This kind of task needs an autosampler.");
            }
        }
 
        public void SetDevice(IDevice yourDevice)
        {
            CheckForCoffeeMachine(yourDevice);
        }
 
        public virtual void PreValidate()
        {
        }
 
        public virtual void PostValidate()
        {
        }
 
        public abstract void Execute();
        public abstract string GetTaskAction();
 
        public IConsumableManipulator Consumables { get; set; }
    }
 
    public class CoffeeCategory : CustomTaskCategoryAttribute
    {
        public CoffeeCategory(int ranking) : base(ranking)
        {
        }
 
        public override string Name => LocalizeMockPlugin.CoffeeCategory_Name_Coffee;
    }
 
    [CoffeeCategory(1)]
    [ScheduleDiagramColor("Sienna")]
    public class BrewCoffee : CoffeeMachineBaseTask, ITaskForDevice
    {
        public override void Execute()
        {
            mDevice.ShowTheMessage(Message);
            RegisterCoffeeConsumption();
        }
 
        public override void PostValidate()
        {
            RegisterCoffeeConsumption();
        }
 
        private void RegisterCoffeeConsumption()
        {
            Consumables.ModifyLevel(CoffeeConsumableManager.GetLocationIdentifier(mDevice, MockConsumablesForCoffeeMakerDevice.Coffee.Name), new Quantity(-7, Units.Gram));
        }
 
        public override string GetTaskAction()
        {
            return LocalizeMockPlugin.BrewCoffee_GetTaskAction_Send_a_message_to_my_device;
        }
 
        public string Message { get; set; } = LocalizeMockPlugin.BrewCoffee_mMessage_Do_you_want_sugar_;
    }
 
    [CoffeeCategory(2)]
    public class BrewFrappuccino : CoffeeMachineBaseTask, ITaskForDevice, IWantEditorUpdates, IGiveARuntimeHint , INotifyPropertyChanged
    {
        [TypeConverter(typeof(CreamTypeConverter))]
        public enum CreamType
        {
            Normal,
            LowFat,
            Vegan
        }
 
        [Editor(typeof(CompositionEditor), typeof(UITypeEditor))]
        public class CompositionData
        {
            [XmlIgnore]
            public MockDevice DevInEditor { get; set; }
 
            public CreamType Cream
            {
                get;
                set;
            }
 
            public bool MuchIce { get; set; }
 
            public bool DeCaffeinated { get; set; }
 
            public uint Volume { get; set; }
 
            public CompositionData()
            {
                Cream = CreamType.LowFat;
                MuchIce = false;
                DeCaffeinated = false;
                Volume = 250;
            }
 
            public override string ToString()
            {
                return String.Format(LocalizeMockPlugin.CompositionData_ToString_Cream___0___MuchIce___1___Decaffeinated___2___Size___3__mL,
                    Cream, MuchIce, DeCaffeinated, Volume);
            }
        }
 
        #region Component model UI type editor
 
        public class CompositionEditor : UITypeEditor
        {
            public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
            {
                // we want a real dialog, not just a drop down box
                return UITypeEditorEditStyle.Modal;
            }
 
            public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
            {
                var editProvider = (IWindowsFormsEditorService)provider?.GetService(typeof(IWindowsFormsEditorService));
                // create the editor form
                var compData = (CompositionData)value;
                // we could get a reference to the task here: var theTask = context.Instance as BrewFrappuccino;
                using (var myEditor = new FrappuccinoCompositionEditor(compData))
                {
                    // our editor will only modify the parameters if it has been closed by clicking OK
                    editProvider?.ShowDialog(myEditor);
                }
                return value;
            }
        }
 
        #endregion Component model UI type editor
 
        private CompositionData mComposition;
 
        public CompositionData Composition
        {
            get
            {
                if (mComposition != null && mComposition.DevInEditor == null)
                {
                    mComposition.DevInEditor = mDevInEditor;
                }
                return mComposition;
            }
            set 
            { 
                mComposition = value;
                if (mComposition != null)
                {
                    mComposition.DevInEditor = mDevInEditor;
                }
                RaiseVolumeChanged();
            }
        }
 
        public override string GetTaskAction()
        {
            return LocalizeMockPlugin.BrewFrappuccino_GetTaskAction_Brew_a_frappuccino__composition__ + Composition;
        }
 
 
        [DefaultUnit(Units.MilliLiter)]
        public uint Volume
        {
            get => mComposition.Volume;
            set
            {
                if(mComposition.Volume == value) return;
                mComposition.Volume = value;
                RaiseVolumeChanged();
            }
        }
        internal void RaiseVolumeChanged()
        {
            PropertyChanged?.Invoke(this,new PropertyChangedEventArgs(nameof(Volume)));
        }
        [DefaultUnit("mL")]
        public uint CupSize
        {
            get;
            set;
        }
 
        public BrewFrappuccino()
        {
            Composition = new CompositionData();
            CupSize = 250;
        }
 
        public override void Execute()
        {
            mDevice.BrewFrappuccino(Composition);
            RegisterConsumption(Composition);
        }
 
        public override void PostValidate()
        {
            RegisterConsumption(Composition);
        }
 
        private void RegisterConsumption(CompositionData composition)
        {
            var sizeFactor = composition.Volume / 125.0;
            Consumables.ModifyLevel(CoffeeConsumableManager.GetLocationIdentifier(mDevice,MockConsumablesForCoffeeMakerDevice.Coffee.Name),new Quantity(-7*sizeFactor, Units.Gram));
            string creamName;
            switch (composition.Cream)
            {
                case CreamType.LowFat:
                    // intentionally picked name of a component that is not tracked. Results just in a log entry, not visible on tracker's page.
                    creamName = "Low Fat Milk";
                    break;
                case CreamType.Normal:
                    creamName = MockConsumablesForCoffeeMakerDevice.Milk.Name;
                    break;
                case CreamType.Vegan:
                    creamName = MockConsumablesForCoffeeMakerDevice.VeganCream.Name;
                    break;
                default:
                    creamName = "";
                    break;
            }
            Consumables.ModifyLevel(CoffeeConsumableManager.GetLocationIdentifier(mDevice, creamName),new Quantity(-10*sizeFactor,Units.MilliLiter));
        }
 
        public void PropertyEdited(string propName, object propValue)
        {
            if (propName == nameof(Volume))
            {
                // the uint32 converter can't convert from uint32 to uint32 but throws an exception.
                if (propValue is uint u)
                {
                    Volume = u;
                }
                else
                {
                    var conv = TypeDescriptor.GetConverter(Volume, true);
                    if (conv.IsValid(propValue))
                    {
                        // ReSharper disable once PossibleNullReferenceException
                        Volume = (uint)conv.ConvertFrom(null, System.Globalization.CultureInfo.InvariantCulture, propValue);
                    }
                }
            }
            else if (propName == "Autosampler")
            {
                mDevInEditor = MockDevice.Instances.FirstOrDefault(someDev => someDev.Name == propValue?.ToString());
                if (mComposition != null)
                {
                    mComposition.DevInEditor = mDevInEditor;
                }
            }           
        }
 
        private MockDevice mDevInEditor;
 
        public event PropertyChangedEventHandler PropertyChanged;
 
        #region Implementation of IGiveARuntimeHint
 
        public int? CalculatedRuntime
        {
            get
            {
                if (Volume > 250)
                {
                    return 30;
                }
 
                if (Volume > 100)
                {
                    return 15;
                }
 
                return 10;
            }
        }
 
        #endregion
    }
 
    [CoffeeCategory(3)]
    // ReSharper disable once UnusedType.Global
    public class PretendCoffeeMachineIsBroken : CoffeeMachineBaseTask, ITaskForDevice
    {
        public bool SoftStop { get; set; }
        public override void Execute()
        {
            mDevice.TriggerAbort(LocalizeMockPlugin
                    .PretendCoffeeMachineIsBroken_Execute_The_coffee_machine_s_heater_failed_,SoftStop);
        }
 
        public override string GetTaskAction()
        {
            return String.Format(LocalizeMockPlugin.PretendCoffeeMachineIsBroken_GetTaskAction_Will_make_the_device_abort_the_schedule_after_a_few_seconds_,SoftStop);
        }
    }
    [CoffeeCategory(4)]
    public class CoffeeMachineDoesNotWorkProperly : CoffeeMachineBaseTask, ITaskForDevice
    {
        public string ErrorDescription { get; set; } = "Some random error message that is shown to the user";
        public ErrorType ErrorType { get; set; } = ErrorType.MissingVial;
        public bool ResolvedAfterHandling { get; set; } = false;
        public override void Execute()
        {
            mDevice.RaiseError(ErrorDescription,ErrorType, ResolvedAfterHandling);
        }
 
        public override string GetTaskAction()
        {
            return $"Raising error type {ErrorType} with description \"{ErrorDescription}\"";
        }
    }
}