dotnet format refactorings.

Wino.Calendar/Services/AccountCalendarStateService.cs

@@ -7,108 +7,107 @@ using Wino.Calendar.ViewModels.Data;
 using Wino.Calendar.ViewModels.Interfaces;
 using Wino.Core.Domain.Entities.Shared;
 
-namespace Wino.Calendar.Services
+namespace Wino.Calendar.Services;
+
+/// <summary>
+/// Encapsulated state manager for collectively managing the state of account calendars.
+/// Callers must react to the events to update their state only from this service.
+/// </summary>
+public partial class AccountCalendarStateService : ObservableObject, IAccountCalendarStateService
 {
-    /// <summary>
-    /// Encapsulated state manager for collectively managing the state of account calendars.
-    /// Callers must react to the events to update their state only from this service.
-    /// </summary>
-    public partial class AccountCalendarStateService : ObservableObject, IAccountCalendarStateService
+    public event EventHandler<GroupedAccountCalendarViewModel> CollectiveAccountGroupSelectionStateChanged;
+    public event EventHandler<AccountCalendarViewModel> AccountCalendarSelectionStateChanged;
+
+    [ObservableProperty]
+    public partial ReadOnlyObservableCollection<GroupedAccountCalendarViewModel> GroupedAccountCalendars { get; set; }
+
+    private ObservableCollection<GroupedAccountCalendarViewModel> _internalGroupedAccountCalendars = new ObservableCollection<GroupedAccountCalendarViewModel>();
+
+    public IEnumerable<AccountCalendarViewModel> ActiveCalendars
     {
-        public event EventHandler<GroupedAccountCalendarViewModel> CollectiveAccountGroupSelectionStateChanged;
-        public event EventHandler<AccountCalendarViewModel> AccountCalendarSelectionStateChanged;
-
-        [ObservableProperty]
-        private ReadOnlyObservableCollection<GroupedAccountCalendarViewModel> groupedAccountCalendars;
-
-        private ObservableCollection<GroupedAccountCalendarViewModel> _internalGroupedAccountCalendars = new ObservableCollection<GroupedAccountCalendarViewModel>();
-
-        public IEnumerable<AccountCalendarViewModel> ActiveCalendars
+        get
         {
-            get
-            {
-                return GroupedAccountCalendars
-                .SelectMany(a => a.AccountCalendars)
-                .Where(b => b.IsChecked);
-            }
+            return GroupedAccountCalendars
+            .SelectMany(a => a.AccountCalendars)
+            .Where(b => b.IsChecked);
         }
+    }
 
-        public IEnumerable<IGrouping<MailAccount, AccountCalendarViewModel>> GroupedAccountCalendarsEnumerable
+    public IEnumerable<IGrouping<MailAccount, AccountCalendarViewModel>> GroupedAccountCalendarsEnumerable
+    {
+        get
         {
-            get
-            {
-                return GroupedAccountCalendars
-                .Select(a => a.AccountCalendars)
-                .SelectMany(b => b)
-                .GroupBy(c => c.Account);
-            }
+            return GroupedAccountCalendars
+            .Select(a => a.AccountCalendars)
+            .SelectMany(b => b)
+            .GroupBy(c => c.Account);
         }
+    }
 
-        public AccountCalendarStateService()
+    public AccountCalendarStateService()
+    {
+        GroupedAccountCalendars = new ReadOnlyObservableCollection<GroupedAccountCalendarViewModel>(_internalGroupedAccountCalendars);
+    }
+
+    private void SingleGroupCalendarCollectiveStateChanged(object sender, EventArgs e)
+        => CollectiveAccountGroupSelectionStateChanged?.Invoke(this, sender as GroupedAccountCalendarViewModel);
+
+    private void SingleCalendarSelectionStateChanged(object sender, AccountCalendarViewModel e)
+        => AccountCalendarSelectionStateChanged?.Invoke(this, e);
+
+    public void AddGroupedAccountCalendar(GroupedAccountCalendarViewModel groupedAccountCalendar)
+    {
+        groupedAccountCalendar.CalendarSelectionStateChanged += SingleCalendarSelectionStateChanged;
+        groupedAccountCalendar.CollectiveSelectionStateChanged += SingleGroupCalendarCollectiveStateChanged;
+
+        _internalGroupedAccountCalendars.Add(groupedAccountCalendar);
+    }
+
+    public void RemoveGroupedAccountCalendar(GroupedAccountCalendarViewModel groupedAccountCalendar)
+    {
+        groupedAccountCalendar.CalendarSelectionStateChanged -= SingleCalendarSelectionStateChanged;
+        groupedAccountCalendar.CollectiveSelectionStateChanged -= SingleGroupCalendarCollectiveStateChanged;
+
+        _internalGroupedAccountCalendars.Remove(groupedAccountCalendar);
+    }
+
+    public void ClearGroupedAccountCalendar()
+    {
+        foreach (var groupedAccountCalendar in _internalGroupedAccountCalendars)
         {
-            GroupedAccountCalendars = new ReadOnlyObservableCollection<GroupedAccountCalendarViewModel>(_internalGroupedAccountCalendars);
+            RemoveGroupedAccountCalendar(groupedAccountCalendar);
         }
+    }
 
-        private void SingleGroupCalendarCollectiveStateChanged(object sender, EventArgs e)
-            => CollectiveAccountGroupSelectionStateChanged?.Invoke(this, sender as GroupedAccountCalendarViewModel);
+    public void AddAccountCalendar(AccountCalendarViewModel accountCalendar)
+    {
+        // Find the group that this calendar belongs to.
+        var group = _internalGroupedAccountCalendars.FirstOrDefault(g => g.Account.Id == accountCalendar.Account.Id);
 
-        private void SingleCalendarSelectionStateChanged(object sender, AccountCalendarViewModel e)
-            => AccountCalendarSelectionStateChanged?.Invoke(this, e);
-
-        public void AddGroupedAccountCalendar(GroupedAccountCalendarViewModel groupedAccountCalendar)
+        if (group == null)
         {
-            groupedAccountCalendar.CalendarSelectionStateChanged += SingleCalendarSelectionStateChanged;
-            groupedAccountCalendar.CollectiveSelectionStateChanged += SingleGroupCalendarCollectiveStateChanged;
-
-            _internalGroupedAccountCalendars.Add(groupedAccountCalendar);
+            // If the group doesn't exist, create it.
+            group = new GroupedAccountCalendarViewModel(accountCalendar.Account, new[] { accountCalendar });
+            AddGroupedAccountCalendar(group);
         }
-
-        public void RemoveGroupedAccountCalendar(GroupedAccountCalendarViewModel groupedAccountCalendar)
+        else
         {
-            groupedAccountCalendar.CalendarSelectionStateChanged -= SingleCalendarSelectionStateChanged;
-            groupedAccountCalendar.CollectiveSelectionStateChanged -= SingleGroupCalendarCollectiveStateChanged;
-
-            _internalGroupedAccountCalendars.Remove(groupedAccountCalendar);
+            group.AccountCalendars.Add(accountCalendar);
         }
+    }
 
-        public void ClearGroupedAccountCalendar()
+    public void RemoveAccountCalendar(AccountCalendarViewModel accountCalendar)
+    {
+        var group = _internalGroupedAccountCalendars.FirstOrDefault(g => g.Account.Id == accountCalendar.Account.Id);
+
+        // We don't expect but just in case.
+        if (group == null) return;
+
+        group.AccountCalendars.Remove(accountCalendar);
+
+        if (group.AccountCalendars.Count == 0)
         {
-            foreach (var groupedAccountCalendar in _internalGroupedAccountCalendars)
-            {
-                RemoveGroupedAccountCalendar(groupedAccountCalendar);
-            }
-        }
-
-        public void AddAccountCalendar(AccountCalendarViewModel accountCalendar)
-        {
-            // Find the group that this calendar belongs to.
-            var group = _internalGroupedAccountCalendars.FirstOrDefault(g => g.Account.Id == accountCalendar.Account.Id);
-
-            if (group == null)
-            {
-                // If the group doesn't exist, create it.
-                group = new GroupedAccountCalendarViewModel(accountCalendar.Account, new[] { accountCalendar });
-                AddGroupedAccountCalendar(group);
-            }
-            else
-            {
-                group.AccountCalendars.Add(accountCalendar);
-            }
-        }
-
-        public void RemoveAccountCalendar(AccountCalendarViewModel accountCalendar)
-        {
-            var group = _internalGroupedAccountCalendars.FirstOrDefault(g => g.Account.Id == accountCalendar.Account.Id);
-
-            // We don't expect but just in case.
-            if (group == null) return;
-
-            group.AccountCalendars.Remove(accountCalendar);
-
-            if (group.AccountCalendars.Count == 0)
-            {
-                RemoveGroupedAccountCalendar(group);
-            }
+            RemoveGroupedAccountCalendar(group);
         }
     }
 }

Wino.Calendar/Services/DialogService.cs

@@ -2,14 +2,13 @@
 using Wino.Core.Domain.Interfaces;
 using Wino.Core.UWP.Services;
 
-namespace Wino.Calendar.Services
+namespace Wino.Calendar.Services;
+
+public class DialogService : DialogServiceBase, ICalendarDialogService
 {
-    public class DialogService : DialogServiceBase, ICalendarDialogService
+    public DialogService(IThemeService themeService,
+                         IConfigurationService configurationService,
+                         IApplicationResourceManager<ResourceDictionary> applicationResourceManager) : base(themeService, configurationService, applicationResourceManager)
     {
-        public DialogService(IThemeService themeService,
-                             IConfigurationService configurationService,
-                             IApplicationResourceManager<ResourceDictionary> applicationResourceManager) : base(themeService, configurationService, applicationResourceManager)
-        {
-        }
     }
 }

Wino.Calendar/Services/NavigationService.cs

@@ -10,54 +10,53 @@ using Wino.Core.Domain.Models.Navigation;
 using Wino.Core.UWP.Services;
 using Wino.Views;
 
-namespace Wino.Calendar.Services
+namespace Wino.Calendar.Services;
+
+public class NavigationService : NavigationServiceBase, INavigationService
 {
-    public class NavigationService : NavigationServiceBase, INavigationService
+    public Type GetPageType(WinoPage winoPage)
     {
-        public Type GetPageType(WinoPage winoPage)
+        return winoPage switch
         {
-            return winoPage switch
-            {
-                WinoPage.CalendarPage => typeof(CalendarPage),
-                WinoPage.SettingsPage => typeof(SettingsPage),
-                WinoPage.CalendarSettingsPage => typeof(CalendarSettingsPage),
-                WinoPage.AccountManagementPage => typeof(AccountManagementPage),
-                WinoPage.ManageAccountsPage => typeof(ManageAccountsPage),
-                WinoPage.PersonalizationPage => typeof(PersonalizationPage),
-                WinoPage.AccountDetailsPage => typeof(AccountDetailsPage),
-                WinoPage.EventDetailsPage => typeof(EventDetailsPage),
-                _ => throw new Exception("Page is not implemented yet."),
-            };
-        }
+            WinoPage.CalendarPage => typeof(CalendarPage),
+            WinoPage.SettingsPage => typeof(SettingsPage),
+            WinoPage.CalendarSettingsPage => typeof(CalendarSettingsPage),
+            WinoPage.AccountManagementPage => typeof(AccountManagementPage),
+            WinoPage.ManageAccountsPage => typeof(ManageAccountsPage),
+            WinoPage.PersonalizationPage => typeof(PersonalizationPage),
+            WinoPage.AccountDetailsPage => typeof(AccountDetailsPage),
+            WinoPage.EventDetailsPage => typeof(EventDetailsPage),
+            _ => throw new Exception("Page is not implemented yet."),
+        };
+    }
 
-        public void GoBack()
+    public void GoBack()
+    {
+        if (Window.Current.Content is Frame appFrame && appFrame.Content is AppShell shellPage)
         {
-            if (Window.Current.Content is Frame appFrame && appFrame.Content is AppShell shellPage)
-            {
-                var shellFrame = shellPage.GetShellFrame();
+            var shellFrame = shellPage.GetShellFrame();
 
-                if (shellFrame.CanGoBack)
-                {
-                    shellFrame.GoBack();
-                }
+            if (shellFrame.CanGoBack)
+            {
+                shellFrame.GoBack();
             }
         }
-
-        public bool Navigate(WinoPage page, object parameter = null, NavigationReferenceFrame frame = NavigationReferenceFrame.ShellFrame, NavigationTransitionType transition = NavigationTransitionType.None)
-        {
-            // All navigations are performed on shell frame for calendar.
-
-            if (Window.Current.Content is Frame appFrame && appFrame.Content is AppShell shellPage)
-            {
-                var shellFrame = shellPage.GetShellFrame();
-
-                var pageType = GetPageType(page);
-
-                shellFrame.Navigate(pageType, parameter);
-                return true;
-            }
-
-            return false;
-        }
+    }
+
+    public bool Navigate(WinoPage page, object parameter = null, NavigationReferenceFrame frame = NavigationReferenceFrame.ShellFrame, NavigationTransitionType transition = NavigationTransitionType.None)
+    {
+        // All navigations are performed on shell frame for calendar.
+
+        if (Window.Current.Content is Frame appFrame && appFrame.Content is AppShell shellPage)
+        {
+            var shellFrame = shellPage.GetShellFrame();
+
+            var pageType = GetPageType(page);
+
+            shellFrame.Navigate(pageType, parameter);
+            return true;
+        }
+
+        return false;
     }
 }

Wino.Calendar/Services/ProviderService.cs

@@ -4,33 +4,32 @@ using Wino.Core.Domain.Enums;
 using Wino.Core.Domain.Interfaces;
 using Wino.Core.Domain.Models.Accounts;
 
-namespace Wino.Calendar.Services
+namespace Wino.Calendar.Services;
+
+public class ProviderService : IProviderService
 {
-    public class ProviderService : IProviderService
+    public IProviderDetail GetProviderDetail(MailProviderType type)
     {
-        public IProviderDetail GetProviderDetail(MailProviderType type)
-        {
-            var details = GetAvailableProviders();
+        var details = GetAvailableProviders();
 
-            return details.FirstOrDefault(a => a.Type == type);
+        return details.FirstOrDefault(a => a.Type == type);
+    }
+
+    public List<IProviderDetail> GetAvailableProviders()
+    {
+        var providerList = new List<IProviderDetail>();
+
+        var providers = new MailProviderType[]
+        {
+            MailProviderType.Outlook,
+            MailProviderType.Gmail
+        };
+
+        foreach (var type in providers)
+        {
+            providerList.Add(new ProviderDetail(type, SpecialImapProvider.None));
         }
 
-        public List<IProviderDetail> GetAvailableProviders()
-        {
-            var providerList = new List<IProviderDetail>();
-
-            var providers = new MailProviderType[]
-            {
-                MailProviderType.Outlook,
-                MailProviderType.Gmail
-            };
-
-            foreach (var type in providers)
-            {
-                providerList.Add(new ProviderDetail(type, SpecialImapProvider.None));
-            }
-
-            return providerList;
-        }
+        return providerList;
     }
 }