Vertical slice

YMouseButtonControl.Core/Mappings/ButtonMappingMapper.cs

@@ -1,33 +1,168 @@
 using System;
-using Riok.Mapperly.Abstractions;
 using YMouseButtonControl.Core.ViewModels.Models;
-using YMouseButtonControl.DataAccess.Models;
+using YMouseButtonControl.Domain.Models;
 
 namespace YMouseButtonControl.Core.Mappings;
 
-[Mapper]
-public static partial class ButtonMappingMapper
+public static class ButtonMappingMapper
 {
-    [MapDerivedType<DisabledMapping, DisabledMappingVm>]
-    [MapDerivedType<NothingMapping, NothingMappingVm>]
-    [MapDerivedType<SimulatedKeystroke, SimulatedKeystrokeVm>]
-    [MapDerivedType<RightClick, RightClickVm>]
-    public static partial BaseButtonMappingVm Map(ButtonMapping? buttonMapping);
-
-    [MapDerivedType<DisabledMappingVm, DisabledMapping>]
-    [MapDerivedType<NothingMappingVm, NothingMapping>]
-    [MapDerivedType<SimulatedKeystrokeVm, SimulatedKeystroke>]
-    [MapDerivedType<RightClickVm, RightClick>]
-    public static partial ButtonMapping Map(BaseButtonMappingVm buttonMapping);
-
-    [MapDerivedType<DisabledMappingVm, DisabledMapping>]
-    [MapDerivedType<NothingMappingVm, NothingMapping>]
-    [MapDerivedType<SimulatedKeystrokeVm, SimulatedKeystroke>]
-    [MapDerivedType<RightClickVm, RightClick>]
-    public static partial void Map(BaseButtonMappingVm src, ButtonMapping dst);
+    public static BaseButtonMappingVm MapToViewModel(ButtonMapping buttonMapping)
+    {
+        return buttonMapping switch
+        {
+            DisabledMapping disabledMapping => MapDisabledMapping(disabledMapping),
+            NothingMapping nothingMapping => MapNothingMapping(nothingMapping),
+            SimulatedKeystroke simulatedKeystroke => MapSimulatedKeystroke(simulatedKeystroke),
+            RightClick rightClick => MapRightClick(rightClick),
+            _ => throw new InvalidOperationException("Unknown button mapping type"),
+        };
+    }
+
+    private static DisabledMappingVm MapDisabledMapping(DisabledMapping disabledMapping) =>
+        new()
+        {
+            Id = disabledMapping.Id,
+            ProfileId = disabledMapping.ProfileId,
+            MouseButton = disabledMapping.MouseButton,
+            Keys = disabledMapping.Keys,
+            AutoRepeatDelay = disabledMapping.AutoRepeatDelay,
+            AutoRepeatRandomizeDelayEnabled = disabledMapping.AutoRepeatRandomizeDelayEnabled,
+            BlockOriginalMouseInput = disabledMapping.BlockOriginalMouseInput,
+            Selected = disabledMapping.Selected,
+        };
+
+    private static NothingMappingVm MapNothingMapping(NothingMapping nothingMapping) =>
+        new()
+        {
+            Id = nothingMapping.Id,
+            ProfileId = nothingMapping.ProfileId,
+            MouseButton = nothingMapping.MouseButton,
+            Keys = nothingMapping.Keys,
+            AutoRepeatDelay = nothingMapping.AutoRepeatDelay,
+            AutoRepeatRandomizeDelayEnabled = nothingMapping.AutoRepeatRandomizeDelayEnabled,
+            BlockOriginalMouseInput = nothingMapping.BlockOriginalMouseInput,
+            Selected = nothingMapping.Selected,
+        };
+
+    private static SimulatedKeystrokeVm MapSimulatedKeystroke(SimulatedKeystroke simulatedKeystroke)
+    {
+        var viewModel = new SimulatedKeystrokeVm
+        {
+            Id = simulatedKeystroke.Id,
+            ProfileId = simulatedKeystroke.ProfileId,
+            MouseButton = simulatedKeystroke.MouseButton,
+            Keys = simulatedKeystroke.Keys,
+            AutoRepeatDelay = simulatedKeystroke.AutoRepeatDelay,
+            AutoRepeatRandomizeDelayEnabled = simulatedKeystroke.AutoRepeatRandomizeDelayEnabled,
+            BlockOriginalMouseInput = simulatedKeystroke.BlockOriginalMouseInput,
+            Selected = simulatedKeystroke.Selected,
+        };
+
+        if (simulatedKeystroke.SimulatedKeystrokeType != null)
+        {
+            viewModel.SimulatedKeystrokeType = MapSimulatedKeystrokeType(
+                simulatedKeystroke.SimulatedKeystrokeType
+            );
+        }
+
+        return viewModel;
+    }
+
+    private static RightClickVm MapRightClick(RightClick rightClick) =>
+        new()
+        {
+            Id = rightClick.Id,
+            ProfileId = rightClick.ProfileId,
+            MouseButton = rightClick.MouseButton,
+            Keys = rightClick.Keys,
+            AutoRepeatDelay = rightClick.AutoRepeatDelay,
+            AutoRepeatRandomizeDelayEnabled = rightClick.AutoRepeatRandomizeDelayEnabled,
+            BlockOriginalMouseInput = rightClick.BlockOriginalMouseInput,
+            Selected = rightClick.Selected,
+        };
+
+    public static ButtonMapping MapToEntity(BaseButtonMappingVm buttonMappingVm)
+    {
+        return buttonMappingVm switch
+        {
+            DisabledMappingVm disabledMappingVm => MapDisabledMappingVm(disabledMappingVm),
+            NothingMappingVm nothingMappingVm => MapNothingMappingVm(nothingMappingVm),
+            SimulatedKeystrokeVm simulatedKeystrokeVm => MapSimulatedKeystrokeVm(
+                simulatedKeystrokeVm
+            ),
+            RightClickVm rightClickVm => MapRightClickVm(rightClickVm),
+            _ => throw new InvalidOperationException("Unknown button mapping VM type"),
+        };
+    }
+
+    private static DisabledMapping MapDisabledMappingVm(DisabledMappingVm disabledMappingVm) =>
+        new()
+        {
+            Id = disabledMappingVm.Id,
+            ProfileId = disabledMappingVm.ProfileId,
+            MouseButton = disabledMappingVm.MouseButton,
+            Keys = disabledMappingVm.Keys,
+            AutoRepeatDelay = disabledMappingVm.AutoRepeatDelay,
+            AutoRepeatRandomizeDelayEnabled = disabledMappingVm.AutoRepeatRandomizeDelayEnabled,
+            BlockOriginalMouseInput = disabledMappingVm.BlockOriginalMouseInput,
+            Selected = disabledMappingVm.Selected,
+        };
+
+    private static NothingMapping MapNothingMappingVm(NothingMappingVm nothingMappingVm) =>
+        new()
+        {
+            Id = nothingMappingVm.Id,
+            ProfileId = nothingMappingVm.ProfileId,
+            MouseButton = nothingMappingVm.MouseButton,
+            Keys = nothingMappingVm.Keys,
+            AutoRepeatDelay = nothingMappingVm.AutoRepeatDelay,
+            AutoRepeatRandomizeDelayEnabled = nothingMappingVm.AutoRepeatRandomizeDelayEnabled,
+            BlockOriginalMouseInput = nothingMappingVm.BlockOriginalMouseInput,
+            Selected = nothingMappingVm.Selected,
+        };
+
+    private static SimulatedKeystroke MapSimulatedKeystrokeVm(
+        SimulatedKeystrokeVm simulatedKeystrokeVm
+    )
+    {
+        var entity = new SimulatedKeystroke
+        {
+            Id = simulatedKeystrokeVm.Id,
+            ProfileId = simulatedKeystrokeVm.ProfileId,
+            MouseButton = simulatedKeystrokeVm.MouseButton,
+            Keys = simulatedKeystrokeVm.Keys,
+            AutoRepeatDelay = simulatedKeystrokeVm.AutoRepeatDelay,
+            AutoRepeatRandomizeDelayEnabled = simulatedKeystrokeVm.AutoRepeatRandomizeDelayEnabled,
+            BlockOriginalMouseInput = simulatedKeystrokeVm.BlockOriginalMouseInput,
+            Selected = simulatedKeystrokeVm.Selected,
+        };
+
+        // Assuming BaseSimulatedKeystrokeTypeVm has a method or constructor that can map SimulatedKeystrokeType to it
+        if (simulatedKeystrokeVm.SimulatedKeystrokeType != null)
+        {
+            entity.SimulatedKeystrokeType = MapSimulatedKeystrokeTypeVm(
+                simulatedKeystrokeVm.SimulatedKeystrokeType
+            );
+        }
+
+        return entity;
+    }
+
+    private static RightClick MapRightClickVm(RightClickVm rightClickVm) =>
+        new()
+        {
+            Id = rightClickVm.Id,
+            ProfileId = rightClickVm.ProfileId,
+            MouseButton = rightClickVm.MouseButton,
+            Keys = rightClickVm.Keys,
+            AutoRepeatDelay = rightClickVm.AutoRepeatDelay,
+            AutoRepeatRandomizeDelayEnabled = rightClickVm.AutoRepeatRandomizeDelayEnabled,
+            BlockOriginalMouseInput = rightClickVm.BlockOriginalMouseInput,
+            Selected = rightClickVm.Selected,
+        };
 
     public static BaseSimulatedKeystrokeTypeVm MapSimulatedKeystrokeType(
-        SimulatedKeystrokeType simulatedKeystrokeType
+        SimulatedKeystrokeType? simulatedKeystrokeType
     ) =>
         simulatedKeystrokeType switch
         {

YMouseButtonControl.Core/Mappings/ProfileMapper.cs

@@ -1,25 +1,50 @@
-using System.Collections.Generic;
-using System.Linq;
-using Riok.Mapperly.Abstractions;
+using System.Linq;
 using YMouseButtonControl.Core.ViewModels.Models;
-using YMouseButtonControl.DataAccess.Models;
+using YMouseButtonControl.Domain.Models;
 
 namespace YMouseButtonControl.Core.Mappings;
 
-[Mapper]
-public static partial class ProfileMapper
+public static class ProfileMapper
 {
-    public static partial ProfileVm Map(Profile? profile);
+    public static ProfileVm MapToViewModel(Profile profile)
+    {
+        var buttonMappings = profile
+            .ButtonMappings.Select(ButtonMappingMapper.MapToViewModel)
+            .ToList();
+        var viewModel = new ProfileVm(buttonMappings)
+        {
+            Id = profile.Id,
+            IsDefault = profile.IsDefault,
+            Checked = profile.Checked,
+            Name = profile.Name,
+            Description = profile.Description,
+            WindowCaption = profile.WindowCaption,
+            Process = profile.Process,
+            WindowClass = profile.WindowClass,
+            ParentClass = profile.ParentClass,
+            MatchType = profile.MatchType,
+            DisplayPriority = profile.DisplayPriority,
+        };
 
-    public static partial Profile Map(ProfileVm vm);
+        return viewModel;
+    }
 
-    public static partial void Map(ProfileVm src, Profile dst);
-
-    private static List<BaseButtonMappingVm> MapButtonMapping(
-        ICollection<ButtonMapping> buttonMappings
-    ) => buttonMappings.Select(ButtonMappingMapper.Map).ToList();
-
-    private static ICollection<ButtonMapping> MapButtonMappingVms(
-        List<BaseButtonMappingVm> buttonMappings
-    ) => buttonMappings.Select(ButtonMappingMapper.Map).ToList();
+    public static Profile MapToEntity(ProfileVm profileVm) =>
+        new()
+        {
+            Id = profileVm.Id,
+            IsDefault = profileVm.IsDefault,
+            Checked = profileVm.Checked,
+            Name = profileVm.Name,
+            Description = profileVm.Description,
+            WindowCaption = profileVm.WindowCaption,
+            Process = profileVm.Process,
+            WindowClass = profileVm.WindowClass,
+            ParentClass = profileVm.ParentClass,
+            MatchType = profileVm.MatchType,
+            DisplayPriority = profileVm.DisplayPriority,
+            ButtonMappings = profileVm
+                .ButtonMappings.Select(ButtonMappingMapper.MapToEntity)
+                .ToList(),
+        };
 }