MockUseDeviceTasks.cs File Reference

Go to the source code of this file.

Classes
class	MockPlugin.Tasks.CoffeeMachineBaseTask
	Base class for our example, just contains some empty default implementations and a check for the right device type. More...
class	MockPlugin.Tasks.CoffeeCategory
	Custom category in the method editor for coffee making related tasks. More...
class	MockPlugin.Tasks.BrewCoffee
	Calls a method of the device class with one if its task parameters. More...
class	MockPlugin.Tasks.BrewFrappuccino
	A task working on a complex parameter set. More...
class	MockPlugin.Tasks.BrewFrappuccino.CompositionData
	Let's pretend the composition is really complex and better done with a custom editor. More...
class	MockPlugin.Tasks.BrewFrappuccino.CompositionEditor
	Provide an editor for our complex parameter set, the standard component model way. More...
class	MockPlugin.Tasks.PretendCoffeeMachineIsBroken
	This task will trigger a timer in our device which will make it complain about an error situation, even if at that time no task is trying to use it. More...
class	MockPlugin.Tasks.CoffeeMachineDoesNotWorkProperly
	In contrast to PretendCoffeeMachineIsBroken, this simulates an error that an autosampler could have while it is used by a task. More...

Namespaces
namespace	MockPlugin
	An example Chronos plugin. This plugin demonstrates how to write plugins for Chronos. It should give you a rough idea how different things can be done, and which interfaces are needed to provide funtionality.
namespace	MockPlugin.Tasks
	Example task implementations. Since there are lots of things that can be done from a task, the demo was split into many different examples each showing only few facets of what's possible. If you still think this is confusing, please let us know where we could simplify these examples.

Variables
$	evicetype

Variable Documentation

evicetype

$ evicetype

Definition at line 48 of file MockUseDeviceTasks.cs.

{
            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}\"";
        }
    }
}