Created editor for scheduled events

prs.classes/Entities/Timesheet/Timesheet.cs

@@ -37,12 +37,12 @@ namespace Comal.Classes
         [LoggableProperty(Format = "hh\\:mm")]
         public TimeSpan Finish { get; set; }
 
-        [DurationEditor]
+        [TimeOfDayEditor]
         [EditorSequence(7)]
         [LoggableProperty(Format = "hh\\:mm")]
         public TimeSpan ApprovedStart { get; set; }
 
-        [DurationEditor]
+        [TimeOfDayEditor]
         [EditorSequence(8)]
         [LoggableProperty(Format = "hh\\:mm")]
         public TimeSpan ApprovedFinish { get; set; }

prs.shared/Grids/EventEditor/EventEditor.xaml.cs

@@ -209,7 +209,7 @@ public partial class EventEditor : UserControl, INotifyPropertyChanged
         if (Data?.Event is not IPropertiesEvent<TProperties> propertiesEvent) return;
 
         var props = propertiesEvent.GetProperties();
-        if (DynamicGridUtils.EditObject(props))
+        if (DynamicGridUtils.EditEntity(props))
         {
             propertiesEvent.SetProperties(props);
             DoChanged();

prs.shared/Grids/EventEditor/Properties Editors/ScheduledEventPropertiesGrid.cs

@@ -0,0 +1,138 @@
+using Comal.Classes;
+using InABox.Core;
+using InABox.DynamicGrid;
+using InABox.WPF;
+using PRS.Shared.Events;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Markup.Localizer;
+using System.Windows.Media.Imaging;
+
+namespace PRS.Shared.Grids.EventEditor;
+
+internal class ScheduledEventDayOfWeekGrid : DynamicItemsListGrid<ScheduledEventDayOfWeek>
+{
+    private static readonly BitmapImage _tick = InABox.Wpf.Resources.tick.AsBitmapImage();
+
+    public SchedulePeriod Period { get; set; }
+
+    protected override void Init()
+    {
+        base.Init();
+
+        HiddenColumns.Add(x => x.Enabled);
+
+        ActionColumns.Add(new DynamicTickColumn<ScheduledEventDayOfWeek, bool>(x => x.Enabled, _tick, _tick, null, Enabled_Click));
+    }
+
+    protected override void DoReconfigure(DynamicGridOptions options)
+    {
+        base.DoReconfigure(options);
+
+        options.DirectEdit = true;
+        options.HideDirectEditButton = true;
+        options.EditRows = false;
+    }
+
+    private bool Enabled_Click(CoreRow? row)
+    {
+        if (row is null) return false;
+
+        var item = LoadItem(row);
+        item.Enabled = !item.Enabled;
+        SaveItem(item);
+        return true;
+    }
+
+    protected override DynamicGridColumns LoadColumns()
+    {
+        var columns = new DynamicGridColumns<ScheduledEventDayOfWeek>();
+        columns.Add(x => x.DayOfWeek);
+        columns.Add(x => x.StartTime, caption: Period == SchedulePeriod.Day ? "Time" : "StartTime");
+        if(Period != SchedulePeriod.Day)
+        {
+            columns.Add(x => x.EndTime);
+        }
+
+        return columns;
+    }
+}
+
+internal class ScheduledEventPropertiesGrid : DynamicItemsListGrid<ScheduledEventProperties>
+{
+    private readonly Column<ScheduledEventProperties> PeriodColumn = new(x => x.Period);
+    private readonly Column<ScheduledEventProperties> DayOfWeekSettingsColumn = new(x => x.DayOfWeekSettings);
+    private readonly Column<ScheduledEventProperties> NextScheduleColumn = new(x => x.NextSchedule);
+
+    protected override void CustomiseEditor(IDynamicEditorForm form, ScheduledEventProperties[] items, DynamicGridColumn column, BaseEditor editor)
+    {
+        base.CustomiseEditor(form, items, column, editor);
+
+        var item = items[0];
+        if (DayOfWeekSettingsColumn.IsEqualTo(column.ColumnName))
+        {
+            editor.Editable = item.Period == SchedulePeriod.Minute || item.Period == SchedulePeriod.Hour || item.Period == SchedulePeriod.Day
+                ? Editable.Enabled
+                : Editable.Disabled;
+        }
+        else if (NextScheduleColumn.IsEqualTo(column.ColumnName))
+        {
+            editor.Editable = item.Period == SchedulePeriod.Minute || item.Period == SchedulePeriod.Hour || item.Period == SchedulePeriod.Day
+                ? Editable.Disabled
+                : Editable.Enabled;
+        }
+    }
+
+    protected override void DoReconfigureEditors(DynamicEditorGrid grid, ScheduledEventProperties[] items)
+    {
+        base.DoReconfigureEditors(grid, items);
+
+        if(grid.Form.TryFindEditor<ListEmbeddedListEditorControl>(DayOfWeekSettingsColumn.Property, out var editor))
+        {
+            editor.CustomiseGrid = g =>
+            {
+                if (g is ScheduledEventDayOfWeekGrid dowGrid)
+                {
+                    dowGrid.Period = items[0].Period;
+                }
+            };
+        }
+    }
+
+    protected override void OnAfterEditorValueChanged(DynamicEditorGrid? grid, ScheduledEventProperties[] items, AfterEditorValueChangedArgs args, Dictionary<string, object?> changes)
+    {
+        base.OnAfterEditorValueChanged(grid, items, args, changes);
+
+        if(grid is null)
+        {
+            return;
+        }
+
+        if(args.ChangedValues.TryGetValue(PeriodColumn.Property, out var value) && value is SchedulePeriod period)
+        {
+            var daysOfWeekEditor = grid.Form.FindEditor<ListEmbeddedListEditorControl>(DayOfWeekSettingsColumn.Property);
+            var nextScheduleEditor = grid.Form.FindEditor<DateTimeEditorControl>(NextScheduleColumn.Property);
+            if(daysOfWeekEditor is not null && nextScheduleEditor is not null)
+            {
+                switch (period)
+                {
+                    case SchedulePeriod.Minute:
+                    case SchedulePeriod.Hour:
+                    case SchedulePeriod.Day:
+                        daysOfWeekEditor.IsEnabled = true;
+                        nextScheduleEditor.IsEnabled = false;
+                        break;
+                    case SchedulePeriod.Week:
+                    case SchedulePeriod.Month:
+                    case SchedulePeriod.Year:
+                        daysOfWeekEditor.IsEnabled = false;
+                        nextScheduleEditor.IsEnabled = true;
+                        break;
+                }
+            }
+        }
+    }
+}

prs.stores/Events/ScheduledEvent.cs

@@ -10,22 +10,67 @@ using System.Threading.Tasks;
 
 namespace PRS.Shared.Events;
 
-public class ScheduledEventProperties : BaseObject
+public class ScheduledEventDayOfWeek : BaseObject
 {
     [EditorSequence(1)]
-    public int Frequency { get; set; } = 1;
+    [Editable(Editable.Disabled)]
+    public DayOfWeek DayOfWeek { get; set; }
 
     [EditorSequence(2)]
-    public SchedulePeriod Period { get; set; } = SchedulePeriod.Hour;
+    [TimeOfDayEditor]
+    public TimeSpan StartTime { get; set; } = TimeSpan.Zero;
+
+    [EditorSequence(3)]
+    [TimeOfDayEditor]
+    public TimeSpan EndTime { get; set; } = new TimeSpan(23, 59, 59);
+
+    [EditorSequence(4)]
+    public bool Enabled { get; set; } = true;
+
+    public ScheduledEventDayOfWeek()
+    {
+    }
+
+    public ScheduledEventDayOfWeek(DayOfWeek dayOfWeek)
+    {
+        DayOfWeek = dayOfWeek;
+    }
+
+    static ScheduledEventDayOfWeek()
+    {
+        DefaultColumns.Add<ScheduledEventDayOfWeek>(x => x.DayOfWeek);
+        DefaultColumns.Add<ScheduledEventDayOfWeek>(x => x.StartTime);
+        DefaultColumns.Add<ScheduledEventDayOfWeek>(x => x.EndTime);
+    }
 }
 
-public class ScheduledEvent : IEvent<ScheduledEventDataModel>, IPropertiesEvent<ScheduledEventProperties>
+public class ScheduledEventProperties : BaseObject
 {
+    [EditorSequence(1)]
     public int Frequency { get; set; } = 1;
 
+    [EditorSequence(2)]
     public SchedulePeriod Period { get; set; } = SchedulePeriod.Hour;
 
-    public DateTime LastExecution { get; set; }
+    [EditorSequence(3)]
+    public DateTime NextSchedule { get; set; }
+
+    [EmbeddedListEditor(typeof(ScheduledEventDayOfWeek), AddRows = false)]
+    public List<ScheduledEventDayOfWeek> DayOfWeekSettings { get; set; } = new()
+    {
+        new(DayOfWeek.Monday),
+        new(DayOfWeek.Tuesday),
+        new(DayOfWeek.Wednesday),
+        new(DayOfWeek.Thursday),
+        new(DayOfWeek.Friday),
+        new(DayOfWeek.Saturday),
+        new(DayOfWeek.Sunday),
+    };
+}
+
+public class ScheduledEvent : IEvent<ScheduledEventDataModel>, IPropertiesEvent<ScheduledEventProperties>
+{
+    public ScheduledEventProperties Properties { get; set; } = new();
 
     public IEventDataModelDefinition DataModelDefinition()
     {
@@ -46,17 +91,12 @@ public class ScheduledEvent : IEvent<ScheduledEventDataModel>, IPropertiesEvent<
 
     public ScheduledEventProperties GetProperties()
     {
-        return new()
-        {
-            Frequency = Frequency,
-            Period = Period,
-        };
+        return Properties;
     }
 
     public void SetProperties(ScheduledEventProperties properties)
     {
-        Frequency = properties.Frequency;
-        Period = properties.Period;
+        Properties = properties;
     }
 }