27 add wpf gui client

GUI/WPF/App.xaml

@@ -0,0 +1,13 @@
+<Application x:Class="Upsilon.Apps.Passkey.GUI.WPF.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="clr-namespace:Upsilon.Apps.Passkey.GUI.WPF"
+             StartupUri="MainWindow.xaml">
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <ResourceDictionary Source="Themes/DarkTheme.xaml"/>
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>

GUI/WPF/App.xaml.cs

@@ -0,0 +1,12 @@
+using System.Windows;
+
+namespace Upsilon.Apps.Passkey.GUI.WPF
+{
+   /// <summary>
+   /// Interaction logic for App.xaml
+   /// </summary>
+   public partial class App : Application
+   {
+   }
+
+}

GUI/WPF/AssemblyInfo.cs

@@ -0,0 +1,10 @@
+using System.Windows;
+
+[assembly: ThemeInfo(
+    ResourceDictionaryLocation.None,            //where theme specific resource dictionaries are located
+                                                //(used if a resource is not found in the page,
+                                                // or application resource dictionaries)
+    ResourceDictionaryLocation.SourceAssembly   //where the generic resource dictionary is located
+                                                //(used if a resource is not found in the page,
+                                                // app, or any theme specific resource dictionaries)
+)]

GUI/WPF/Helper/EnumHelper.cs

@@ -0,0 +1,74 @@
+using Upsilon.Apps.Passkey.Core.Utils;
+using Upsilon.Apps.Passkey.Interfaces.Enums;
+
+namespace Upsilon.Apps.Passkey.GUI.WPF.Helper
+{
+   internal static class EnumHelper
+   {
+      public static string ToReadableString(this ActivityEventType eventType)
+      {
+         return eventType switch
+         {
+            ActivityEventType.None => "All",
+            ActivityEventType.MergeAndSaveThenRemoveAutoSaveFile => "Auto-save merged then saved",
+            ActivityEventType.MergeWithoutSavingAndKeepAutoSaveFile => "Auto-save merged but not saved",
+            ActivityEventType.DontMergeAndRemoveAutoSaveFile => "Auto-save discarded",
+            ActivityEventType.DontMergeAndKeepAutoSaveFile => "Auto-save not merged and keeped",
+            ActivityEventType.DatabaseCreated
+              or ActivityEventType.DatabaseOpened
+              or ActivityEventType.DatabaseSaved
+              or ActivityEventType.DatabaseClosed
+              or ActivityEventType.LoginSessionTimeoutReached
+              or ActivityEventType.LoginFailed
+              or ActivityEventType.UserLoggedIn
+              or ActivityEventType.UserLoggedOut
+              or ActivityEventType.ImportingDataStarted
+              or ActivityEventType.ImportingDataSucceded
+              or ActivityEventType.ImportingDataFailed
+              or ActivityEventType.ExportingDataStarted
+              or ActivityEventType.ExportingDataSucceded
+              or ActivityEventType.ExportingDataFailed
+              or ActivityEventType.ItemUpdated
+              or ActivityEventType.ItemAdded
+              or ActivityEventType.ItemDeleted => eventType.ToString().ToSentenceCase(),
+            _ => throw new InvalidOperationException($"'{eventType}' event type not handled"),
+         };
+      }
+
+      public static ActivityEventType ActivityEventTypeFromReadableString(string readableString)
+      {
+         try
+         {
+            return Enum.GetValues<ActivityEventType>()
+               .Cast<ActivityEventType>()
+               .First(x => x.ToReadableString() == readableString);
+         }
+         catch
+         {
+            throw new InvalidOperationException($"'{readableString}' event type not handled");
+         }
+      }
+
+      public static string ToReadableString(this WarningType warningType)
+      {
+         return warningType switch
+         {
+            WarningType.PasswordUpdateReminderWarning | WarningType.PasswordLeakedWarning => "All",
+            WarningType.PasswordUpdateReminderWarning => "Expired passwords",
+            WarningType.PasswordLeakedWarning => "Leaked passwords",
+            _ => throw new InvalidOperationException($"'{warningType}' warning type not handled"),
+         };
+      }
+
+      public static WarningType ActivityWarningTypeFromReadableString(string readableString)
+      {
+         return readableString switch
+         {
+            "All" => WarningType.PasswordUpdateReminderWarning | WarningType.PasswordLeakedWarning,
+            "Expired passwords" => WarningType.PasswordUpdateReminderWarning,
+            "Leaked passwords" => WarningType.PasswordLeakedWarning,
+            _ => throw new InvalidOperationException($"'{readableString}' warning type not handled"),
+         };
+      }
+   }
+}

GUI/WPF/Helper/HotKeyHelper.cs

@@ -0,0 +1,92 @@
+using System.Runtime.InteropServices;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Interop;
+
+namespace Upsilon.Apps.Passkey.GUI.WPF.Helper
+{
+   public static class HotkeyHelper
+   {
+      private static int _id = 0;
+
+      public static event EventHandler<HotkeyEventArgs>? HotkeyPressed;
+
+      public static int Register(Window window, ModifierKeys modifiers, Key key)
+      {
+         int hotkeyId = Interlocked.Increment(ref _id);
+         uint virtualKey = (uint)KeyInterop.VirtualKeyFromKey(key);
+
+         IntPtr hWnd = new WindowInteropHelper(window).Handle;
+         if (hWnd == IntPtr.Zero)
+            return -1;
+
+         bool success = RegisterHotKey(hWnd, hotkeyId, (uint)modifiers, virtualKey);
+         if (!success)
+            return -1;
+
+         if (PresentationSource.FromVisual(window) is HwndSource source)
+         {
+            source.AddHook((hwnd, msg, wParam, lParam, ref handled) =>
+            {
+               if (msg == 0x0312 && (int)wParam == hotkeyId)
+               {
+                  HotkeyEventArgs e = new(lParam);
+                  HotkeyPressed?.Invoke(window, e);
+                  handled = true;
+               }
+               return IntPtr.Zero;
+            });
+         }
+
+         return hotkeyId;
+      }
+
+      public static bool Unregister(Window window, int hotkeyId)
+      {
+         if (window is null)
+            return false;
+
+         IntPtr hWnd = new WindowInteropHelper(window).Handle;
+         return hWnd != nint.Zero && UnregisterHotKey(hWnd, hotkeyId);
+      }
+
+      public static void Send(ModifierKeys modifiers, Key key)
+      {
+         //byte[] modifiers = [];
+         byte virtualKey = (byte)KeyInterop.VirtualKeyFromKey(key);
+
+         keybd_event((byte)modifiers, 0, 0, UIntPtr.Zero);
+
+         keybd_event(virtualKey, 0, 0, UIntPtr.Zero);
+         keybd_event(virtualKey, 0, 0x0002, UIntPtr.Zero);
+
+         keybd_event((byte)modifiers, 0, 0x0002, UIntPtr.Zero);
+      }
+
+      [DllImport("user32.dll")]
+      private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
+
+      [DllImport("user32.dll")]
+      private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
+
+      [DllImport("user32.dll")]
+      private static extern uint MapVirtualKey(uint uCode, uint uMapType);
+
+      [DllImport("user32.dll")]
+      private static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo);
+   }
+
+   public class HotkeyEventArgs : EventArgs
+   {
+      public readonly Key Key;
+      public readonly ModifierKeys Modifiers;
+
+      internal HotkeyEventArgs(IntPtr hotKeyParam)
+      {
+         uint param = (uint)hotKeyParam.ToInt64();
+         int virtualKey = (int)((param & 0xffff0000) >> 16);
+         Key = KeyInterop.KeyFromVirtualKey(virtualKey);
+         Modifiers = (ModifierKeys)(param & 0x0000ffff);
+      }
+   }
+}

GUI/WPF/Helper/IItemHelper.cs

@@ -0,0 +1,57 @@
+using Upsilon.Apps.Passkey.Interfaces.Models;
+
+namespace Upsilon.Apps.Passkey.GUI.WPF.Helper
+{
+   public static class IItemHelper
+   {
+      public static void Shake(this IUser user)
+      {
+         _ = user.ItemId;
+      }
+
+      public static bool MeetsFilterConditions(this IService service, string serviceFilter, string identifierFilter, string globalTextFilter, bool changedItemsOnly)
+      {
+         serviceFilter = serviceFilter.ToLower().Trim();
+         identifierFilter = identifierFilter.ToLower().Trim();
+         globalTextFilter = globalTextFilter.ToLower().Trim();
+
+         string serviceId = service.ItemId.Replace(service.User.ItemId, string.Empty).ToLower().Trim();
+         string serviceName = service.ServiceName.ToLower().Trim();
+         string url = service.Url.ToLower().Trim();
+         string notes = service.Notes.ToLower().Trim();
+
+         return (!string.IsNullOrWhiteSpace(globalTextFilter)
+            ? serviceId == globalTextFilter
+               || serviceName.Contains(globalTextFilter)
+               || url.Contains(globalTextFilter)
+               || notes.Contains(globalTextFilter)
+               || service.Accounts.Any(x => x.MeetsFilterConditions(string.Empty, globalTextFilter, changedItemsOnly))
+            : (string.IsNullOrWhiteSpace(serviceFilter)
+                  || (!string.IsNullOrWhiteSpace(serviceFilter) && serviceName.Contains(serviceFilter)))
+               && (string.IsNullOrWhiteSpace(identifierFilter)
+                  || service.Accounts.Any(x => x.MeetsFilterConditions(identifierFilter, globalTextFilter, changedItemsOnly))))
+            && (!changedItemsOnly || service.HasChanged());
+      }
+
+      public static bool MeetsFilterConditions(this IAccount account, string identifierFilter, string globalTextFilter, bool changedItemsOnly)
+      {
+         identifierFilter = identifierFilter.ToLower().Trim();
+         globalTextFilter = globalTextFilter.ToLower().Trim();
+
+         string accountId = account.ItemId.Replace(account.Service.ItemId, string.Empty).ToLower().Trim();
+         string label = account.Label.ToLower().Trim();
+         string notes = account.Notes.ToLower().Trim();
+         string identifiers = string.Join("\n", account.Identifiers.Select(x => x.ToLower().Trim()));
+
+         return (!string.IsNullOrWhiteSpace(globalTextFilter)
+            ? accountId == globalTextFilter
+               || identifiers.Contains(globalTextFilter)
+               || label.ToLower().Contains(globalTextFilter)
+               || notes.ToLower().Contains(globalTextFilter)
+            : string.IsNullOrWhiteSpace(identifierFilter)
+               || identifiers.Contains(identifierFilter)
+               || label.Contains(identifierFilter))
+            && (!changedItemsOnly || account.HasChanged());
+      }
+   }
+}

GUI/WPF/Helper/NumericTextBoxHelper.cs

@@ -0,0 +1,57 @@
+using System.Text.RegularExpressions;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+
+namespace Upsilon.Apps.Passkey.GUI.WPF.Helper
+{
+   public static class NumericTextBoxHelper
+   {
+      private static readonly Regex _regex = new("[^0-9]+"); //regex that matches disallowed text
+
+      private static bool _isTextAllowed(string text)
+      {
+         bool isValid = !_regex.IsMatch(text);
+
+         if (isValid)
+         {
+            isValid = int.TryParse(text, out _);
+         }
+
+         return isValid;
+      }
+
+      public static void TextChanged(object sender, TextChangedEventArgs e)
+      {
+         TextBox textBox = (TextBox)sender;
+
+         e.Handled = !_isTextAllowed(textBox.Text);
+
+         if (e.Handled)
+         {
+            textBox.Text = textBox.Text.Replace(" ", "");
+         }
+      }
+
+      public static void PreviewTextInput(object sender, TextCompositionEventArgs e)
+      {
+         e.Handled = !_isTextAllowed(e.Text);
+      }
+
+      public static void Pasting(object sender, DataObjectPastingEventArgs e)
+      {
+         if (e.DataObject.GetDataPresent(typeof(string)))
+         {
+            string text = (string)e.DataObject.GetData(typeof(string));
+            if (!_isTextAllowed(text))
+            {
+               e.CancelCommand();
+            }
+         }
+         else
+         {
+            e.CancelCommand();
+         }
+      }
+   }
+}

GUI/WPF/Helper/PropertyHelper.cs

@@ -0,0 +1,25 @@
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+
+namespace Upsilon.Apps.Passkey.GUI.WPF.Helper
+{
+   public static class PropertyHelper
+   {
+      public static bool SetProperty<T>(ref T field,
+         T newValue,
+         INotifyPropertyChanged sender,
+         PropertyChangedEventHandler? PropertyChanged,
+         [CallerMemberName] string? propertyName = null)
+      {
+         if (!Equals(field, newValue))
+         {
+            field = newValue;
+            PropertyChanged?.Invoke(sender, new PropertyChangedEventArgs(propertyName));
+
+            return true;
+         }
+
+         return false;
+      }
+   }
+}

GUI/WPF/Helper/WindowHelper.cs

@@ -0,0 +1,24 @@
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+
+namespace Upsilon.Apps.Passkey.GUI.WPF.Helper
+{
+   public static class WindowHelper
+   {
+      public static bool GetIsBusy(this Window window)
+      {
+         return window.Cursor == Cursors.Wait;
+      }
+
+      public static void SetIsBusy(this Window window, bool isBusy)
+      {
+         window.Cursor = isBusy ? Cursors.Wait : Cursors.Arrow;
+      }
+
+      public static bool GetIsBusy(this UserControl control)
+      {
+         return Window.GetWindow(control).GetIsBusy();
+      }
+   }
+}