javier/Wino-Mail
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Separation of core library from the UWP app.

Browse Source
This commit is contained in:
Burak Kaan Köse
2024-11-30 23:05:07 +01:00
parent 4e25dbf5e3
commit 0cd1568c64
88 changed files with 481 additions and 353 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
Wino.Core.Domain/MenuItems/AccountMenuItem.cs Normal file
View File

@@ -0,0 +1,103 @@
using System;
using System.Collections.Generic;
using System.Linq;
using CommunityToolkit.Mvvm.ComponentModel;
using Wino.Core.Domain.Entities.Shared;
using Wino.Core.Domain.Enums;
using Wino.Core.Domain.Interfaces;
using Wino.Core.Domain.Models.Folders;
namespace Wino.Core.Domain.MenuItems
{
public partial class AccountMenuItem : MenuItemBase<MailAccount, MenuItemBase<IMailItemFolder, FolderMenuItem>>, IAccountMenuItem
{
[ObservableProperty]
private int unreadItemCount;
[ObservableProperty]
[NotifyPropertyChangedFor(nameof(IsSynchronizationProgressVisible))]
private double synchronizationProgress;
[ObservableProperty]
private bool _isEnabled = true;
public bool IsAttentionRequired => AttentionReason != AccountAttentionReason.None;
public bool IsSynchronizationProgressVisible => SynchronizationProgress > 0 && SynchronizationProgress < 100;
// We can't determine the progress for gmail synchronization since it is based on history changes.
public bool IsProgressIndeterminate => Parameter?.ProviderType == MailProviderType.Gmail;
public Guid AccountId => Parameter.Id;
private AccountAttentionReason attentionReason;
public AccountAttentionReason AttentionReason
{
get => attentionReason;
set
{
if (SetProperty(ref attentionReason, value))
{
OnPropertyChanged(nameof(IsAttentionRequired));
UpdateFixAccountIssueMenuItem();
}
}
}
public string AccountName
{
get => Parameter.Name;
set => SetProperty(Parameter.Name, value, Parameter, (u, n) => u.Name = n);
}
public string Base64ProfilePicture
{
get => Parameter.Name;
set => SetProperty(Parameter.Base64ProfilePictureData, value, Parameter, (u, n) => u.Base64ProfilePictureData = n);
}
public IEnumerable<MailAccount> HoldingAccounts => new List<MailAccount> { Parameter };
public AccountMenuItem(MailAccount account, IMenuItem parent = null) : base(account, account.Id, parent)
{
UpdateAccount(account);
}
public void UpdateAccount(MailAccount account)
{
Parameter = account;
AccountName = account.Name;
AttentionReason = account.AttentionReason;
Base64ProfilePicture = account.Base64ProfilePictureData;
if (SubMenuItems == null) return;
foreach (var item in SubMenuItems)
{
if (item is IFolderMenuItem folderMenuItem)
{
folderMenuItem.UpdateParentAccounnt(account);
}
}
}
private void UpdateFixAccountIssueMenuItem()
{
if (AttentionReason != AccountAttentionReason.None && !SubMenuItems.Any(a => a is FixAccountIssuesMenuItem))
{
// Add fix issue item if not exists.
SubMenuItems.Insert(0, new FixAccountIssuesMenuItem(Parameter, this));
}
else
{
// Remove existing if issue is resolved.
var fixAccountIssueItem = SubMenuItems.FirstOrDefault(a => a is FixAccountIssuesMenuItem);
if (fixAccountIssueItem != null)
{
SubMenuItems.Remove(fixAccountIssueItem);
}
}
}
}
}

16
Wino.Core.Domain/MenuItems/FixAccountIssuesMenuItem.cs Normal file
View File

@@ -0,0 +1,16 @@
using Wino.Core.Domain.Entities.Shared;
using Wino.Core.Domain.Interfaces;
using Wino.Core.Domain.Models.Folders;
namespace Wino.Core.Domain.MenuItems
{
public class FixAccountIssuesMenuItem : MenuItemBase<IMailItemFolder, FolderMenuItem>
{
public MailAccount Account { get; }
public FixAccountIssuesMenuItem(MailAccount account, IMenuItem parentAccountMenuItem) : base(null, null, parentAccountMenuItem)
{
Account = account;
}
}
}

79
Wino.Core.Domain/MenuItems/FolderMenuItem.cs Normal file
View File

@@ -0,0 +1,79 @@
using System.Collections.Generic;
using System.Linq;
using CommunityToolkit.Mvvm.ComponentModel;
using Wino.Core.Domain;
using Wino.Core.Domain.Entities.Shared;
using Wino.Core.Domain.Enums;
using Wino.Core.Domain.Interfaces;
using Wino.Core.Domain.Models.Folders;
namespace Wino.Core.Domain.MenuItems
{
public partial class FolderMenuItem : MenuItemBase<IMailItemFolder, FolderMenuItem>, IFolderMenuItem
{
[ObservableProperty]
private int unreadItemCount;
public bool HasTextColor => !string.IsNullOrEmpty(Parameter.TextColorHex);
public bool IsMoveTarget => HandlingFolders.All(a => a.IsMoveTarget);
public SpecialFolderType SpecialFolderType => Parameter.SpecialFolderType;
public bool IsSticky => Parameter.IsSticky;
public bool IsSystemFolder => Parameter.IsSystemFolder;
/// <summary>
/// Display name of the folder. More and Category folders have localized display names.
/// </summary>
public string FolderName
{
get
{
if (Parameter.SpecialFolderType == SpecialFolderType.More)
return Translator.MoreFolderNameOverride;
else if (Parameter.SpecialFolderType == SpecialFolderType.Category)
return Translator.CategoriesFolderNameOverride;
else
return Parameter.FolderName;
}
set => SetProperty(Parameter.FolderName, value, Parameter, (u, n) => u.FolderName = n);
}
public bool IsSynchronizationEnabled
{
get => Parameter.IsSynchronizationEnabled;
set => SetProperty(Parameter.IsSynchronizationEnabled, value, Parameter, (u, n) => u.IsSynchronizationEnabled = n);
}
public IEnumerable<IMailItemFolder> HandlingFolders => new List<IMailItemFolder>() { Parameter };
public MailAccount ParentAccount { get; private set; }
public string AssignedAccountName => ParentAccount?.Name;
public bool ShowUnreadCount => Parameter.ShowUnreadCount;
IEnumerable<IMenuItem> IBaseFolderMenuItem.SubMenuItems => SubMenuItems;
public FolderMenuItem(IMailItemFolder folderStructure, MailAccount parentAccount, IMenuItem parentMenuItem) : base(folderStructure, folderStructure.Id, parentMenuItem)
{
ParentAccount = parentAccount;
}
public void UpdateFolder(IMailItemFolder folder)
{
Parameter = folder;
OnPropertyChanged(nameof(IsSynchronizationEnabled));
OnPropertyChanged(nameof(ShowUnreadCount));
OnPropertyChanged(nameof(HasTextColor));
OnPropertyChanged(nameof(IsSystemFolder));
OnPropertyChanged(nameof(SpecialFolderType));
OnPropertyChanged(nameof(IsSticky));
OnPropertyChanged(nameof(FolderName));
}
public override string ToString() => FolderName;
public void UpdateParentAccounnt(MailAccount account) => ParentAccount = account;
}
}

4
Wino.Core.Domain/MenuItems/ManageAccountsMenuItem.cs Normal file
View File

@@ -0,0 +1,4 @@
namespace Wino.Core.Domain.MenuItems
{
public class ManageAccountsMenuItem : MenuItemBase { }
}

63
Wino.Core.Domain/MenuItems/MenuItemBase.cs Normal file
View File

@@ -0,0 +1,63 @@
using System;
using System.Collections.ObjectModel;
using CommunityToolkit.Mvvm.ComponentModel;
using Wino.Core.Domain.Interfaces;
namespace Wino.Core.Domain.MenuItems
{
public partial class MenuItemBase : ObservableObject, IMenuItem
{
[ObservableProperty]
private bool _isExpanded;
[ObservableProperty]
private bool _isSelected;
public IMenuItem ParentMenuItem { get; }
public Guid? EntityId { get; }
public MenuItemBase(Guid? entityId = null, IMenuItem parentMenuItem = null)
{
EntityId = entityId;
ParentMenuItem = parentMenuItem;
}
public void Expand()
{
// Recursively expand all parent menu items if parent exists, starting from parent.
if (ParentMenuItem != null)
{
IMenuItem parentMenuItem = ParentMenuItem;
while (parentMenuItem != null)
{
parentMenuItem.IsExpanded = true;
parentMenuItem = parentMenuItem.ParentMenuItem;
}
}
// Finally expand itself.
IsExpanded = true;
}
}
public partial class MenuItemBase<T> : MenuItemBase
{
[ObservableProperty]
private T _parameter;
public MenuItemBase(T parameter, Guid? entityId, IMenuItem parentMenuItem = null) : base(entityId, parentMenuItem) => Parameter = parameter;
}
public partial class MenuItemBase<TValue, TCollection> : MenuItemBase<TValue>
{
[ObservableProperty]
private bool _isChildSelected;
protected MenuItemBase(TValue parameter, Guid? entityId, IMenuItem parentMenuItem = null) : base(parameter, entityId, parentMenuItem) { }
public ObservableCollection<TCollection> SubMenuItems { get; set; } = [];
}
}

208
Wino.Core.Domain/MenuItems/MenuItemCollection.cs Normal file
View File

@@ -0,0 +1,208 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Wino.Core.Domain.Collections;
using Wino.Core.Domain.Enums;
using Wino.Core.Domain.Interfaces;
namespace Wino.Core.Domain.MenuItems
{
public class MenuItemCollection : ObservableRangeCollection<IMenuItem>
{
// Which types to remove from the list when folders are changing due to selection of new account.
// We don't clear the whole list since we want to keep the New Mail button and account menu items.
private readonly Type[] _preservingTypesForFolderArea = [typeof(AccountMenuItem), typeof(NewMailMenuItem), typeof(MergedAccountMenuItem)];
private readonly IDispatcher _dispatcher;
public MenuItemCollection(IDispatcher dispatcher)
{
_dispatcher = dispatcher;
}
public IEnumerable<IAccountMenuItem> GetAllAccountMenuItems()
{
foreach (var item in this)
{
if (item is MergedAccountMenuItem mergedAccountMenuItem)
{
foreach (var singleItem in mergedAccountMenuItem.SubMenuItems.OfType<IAccountMenuItem>())
{
yield return singleItem;
}
yield return mergedAccountMenuItem;
}
else if (item is IAccountMenuItem accountMenuItem)
yield return accountMenuItem;
}
}
public IEnumerable<IBaseFolderMenuItem> GetAllFolderMenuItems(Guid folderId)
{
foreach (var item in this)
{
if (item is IBaseFolderMenuItem folderMenuItem)
{
if (folderMenuItem.HandlingFolders.Any(a => a.Id == folderId))
{
yield return folderMenuItem;
}
else if (folderMenuItem.SubMenuItems.Any())
{
foreach (var subItem in folderMenuItem.SubMenuItems.OfType<IBaseFolderMenuItem>())
{
if (subItem.HandlingFolders.Any(a => a.Id == folderId))
{
yield return subItem;
}
}
}
}
}
}
public bool TryGetAccountMenuItem(Guid accountId, out IAccountMenuItem value)
{
value = this.OfType<AccountMenuItem>().FirstOrDefault(a => a.AccountId == accountId);
value ??= this.OfType<MergedAccountMenuItem>().FirstOrDefault(a => a.SubMenuItems.OfType<AccountMenuItem>().Where(b => b.AccountId == accountId) != null);
return value != null;
}
// Pattern: Look for special folder menu item inside the loaded folders for Windows Mail style menu items.
public bool TryGetWindowsStyleRootSpecialFolderMenuItem(Guid accountId, SpecialFolderType specialFolderType, out FolderMenuItem value)
{
value = this.OfType<IBaseFolderMenuItem>()
.FirstOrDefault(a => a.HandlingFolders.Any(b => b.MailAccountId == accountId && b.SpecialFolderType == specialFolderType)) as FolderMenuItem;
return value != null;
}
// Pattern: Find the merged account menu item and return the special folder menu item that belongs to the merged account menu item.
// This will not look for the folders inside individual account menu items inside merged account menu item.
public bool TryGetMergedAccountSpecialFolderMenuItem(Guid mergedInboxId, SpecialFolderType specialFolderType, out IBaseFolderMenuItem value)
{
value = this.OfType<MergedAccountFolderMenuItem>()
.Where(a => a.MergedInbox.Id == mergedInboxId)
.FirstOrDefault(a => a.SpecialFolderType == specialFolderType);
return value != null;
}
public bool TryGetFolderMenuItem(Guid folderId, out IBaseFolderMenuItem value)
{
// Root folders
value = this.OfType<IBaseFolderMenuItem>()
.FirstOrDefault(a => a.HandlingFolders.Any(b => b.Id == folderId));
value ??= this.OfType<FolderMenuItem>()
.SelectMany(a => a.SubMenuItems)
.OfType<IBaseFolderMenuItem>()
.FirstOrDefault(a => a.HandlingFolders.Any(b => b.Id == folderId));
return value != null;
}
public void UpdateUnreadItemCountsToZero()
{
// Handle the root folders.
foreach (var item in this.OfType<IBaseFolderMenuItem>())
{
RecursivelyResetUnreadItemCount(item);
}
}
private void RecursivelyResetUnreadItemCount(IBaseFolderMenuItem baseFolderMenuItem)
{
baseFolderMenuItem.UnreadItemCount = 0;
if (baseFolderMenuItem.SubMenuItems == null) return;
foreach (var subMenuItem in baseFolderMenuItem.SubMenuItems.OfType<IBaseFolderMenuItem>())
{
RecursivelyResetUnreadItemCount(subMenuItem);
}
}
public bool TryGetSpecialFolderMenuItem(Guid accountId, SpecialFolderType specialFolderType, out FolderMenuItem value)
{
value = this.OfType<IBaseFolderMenuItem>()
.FirstOrDefault(a => a.HandlingFolders.Any(b => b.MailAccountId == accountId && b.SpecialFolderType == specialFolderType)) as FolderMenuItem;
return value != null;
}
/// <summary>
/// Skips the merged account menu item, but directly returns the Account menu item inside the merged account menu item.
/// </summary>
/// <param name="accountId">Account id to look for.</param>
/// <returns>Direct AccountMenuItem inside the Merged Account menu item if exists.</returns>
public AccountMenuItem GetSpecificAccountMenuItem(Guid accountId)
{
AccountMenuItem accountMenuItem = null;
accountMenuItem = this.OfType<AccountMenuItem>().FirstOrDefault(a => a.HoldingAccounts.Any(b => b.Id == accountId));
// Look for the items inside the merged accounts if regular menu item is not found.
accountMenuItem ??= this.OfType<MergedAccountMenuItem>()
.FirstOrDefault(a => a.HoldingAccounts.Any(b => b.Id == accountId))?.SubMenuItems
.OfType<AccountMenuItem>()
.FirstOrDefault(a => a.AccountId == accountId);
return accountMenuItem;
}
public async Task ReplaceFoldersAsync(IEnumerable<IMenuItem> folders)
{
await _dispatcher.ExecuteOnUIThread(() => ClearFolderAreaMenuItems());
await _dispatcher.ExecuteOnUIThread(() => Items.Add(new SeperatorItem()));
await _dispatcher.ExecuteOnUIThread(() => AddRange(folders, System.Collections.Specialized.NotifyCollectionChangedAction.Reset));
}
/// <summary>
/// Enables/disables account menu items in the list.
/// </summary>
/// <param name="isEnabled">Whether menu items should be enabled or disabled.</param>
public async Task SetAccountMenuItemEnabledStatusAsync(bool isEnabled)
{
var accountItems = this.Where(a => a is IAccountMenuItem).Cast<IAccountMenuItem>();
await _dispatcher.ExecuteOnUIThread(() =>
{
foreach (var item in accountItems)
{
item.IsEnabled = isEnabled;
}
});
}
public void AddAccountMenuItem(IAccountMenuItem accountMenuItem)
{
var lastAccount = Items.OfType<IAccountMenuItem>().LastOrDefault();
// Index 0 is always the New Mail button.
var insertIndex = lastAccount == null ? 1 : Items.IndexOf(lastAccount) + 1;
Insert(insertIndex, accountMenuItem);
}
private void ClearFolderAreaMenuItems()
{
var itemsToRemove = this.Where(a => !_preservingTypesForFolderArea.Contains(a.GetType())).ToList();
itemsToRemove.ForEach(item =>
{
item.IsExpanded = false;
item.IsSelected = false;
try
{
Remove(item);
}
catch (Exception) { }
});
}
}
}

112
Wino.Core.Domain/MenuItems/MergedAccountFolderMenuItem.cs Normal file
View File

@@ -0,0 +1,112 @@
using System.Collections.Generic;
using System.Linq;
using CommunityToolkit.Diagnostics;
using CommunityToolkit.Mvvm.ComponentModel;
using Wino.Core.Domain;
using Wino.Core.Domain.Entities.Mail;
using Wino.Core.Domain.Enums;
using Wino.Core.Domain.Interfaces;
using Wino.Core.Domain.Models.Folders;
namespace Wino.Core.Domain.MenuItems
{
/// <summary>
/// Menu item that holds a list of folders under the merged account menu item.
/// </summary>
public partial class MergedAccountFolderMenuItem : MenuItemBase<List<IMailItemFolder>, IMenuItem>, IMergedAccountFolderMenuItem
{
public SpecialFolderType FolderType { get; }
public string FolderName { get; private set; }
// Any of the folders is enough to determine the synchronization enable/disable state.
public bool IsSynchronizationEnabled => HandlingFolders.Any(a => a.IsSynchronizationEnabled);
public bool IsMoveTarget => HandlingFolders.All(a => a.IsMoveTarget);
public IEnumerable<IMailItemFolder> HandlingFolders => Parameter;
// All folders in the list should have the same type.
public SpecialFolderType SpecialFolderType => HandlingFolders.First().SpecialFolderType;
public bool IsSticky => true;
public bool IsSystemFolder => true;
public string AssignedAccountName => MergedInbox?.Name;
public MergedInbox MergedInbox { get; set; }
public bool ShowUnreadCount => HandlingFolders?.Any(a => a.ShowUnreadCount) ?? false;
public new IEnumerable<IMenuItem> SubMenuItems => base.SubMenuItems;
[ObservableProperty]
private int unreadItemCount;
// Merged account's shared folder menu item does not have an entity id.
// Navigations to specific folders are done by explicit folder id if needed.
public MergedAccountFolderMenuItem(List<IMailItemFolder> parameter, IMenuItem parentMenuItem, MergedInbox mergedInbox) : base(parameter, null, parentMenuItem)
{
Guard.IsNotNull(mergedInbox, nameof(mergedInbox));
Guard.IsNotNull(parameter, nameof(parameter));
Guard.HasSizeGreaterThan(parameter, 0, nameof(parameter));
MergedInbox = mergedInbox;
SetFolderName();
// All folders in the list should have the same type.
FolderType = parameter[0].SpecialFolderType;
}
private void SetFolderName()
{
// Folders that hold more than 1 folder belong to merged account.
// These folders will be displayed as their localized names based on the
// special type they have.
if (HandlingFolders.Count() > 1)
{
FolderName = GetSpecialFolderName(HandlingFolders.First());
}
else
{
// Folder only holds 1 Id, but it's displayed as merged account folder.
FolderName = HandlingFolders.First().FolderName;
}
}
private string GetSpecialFolderName(IMailItemFolder folder)
{
var specialType = folder.SpecialFolderType;
// We only handle 5 different types for combining folders.
// Rest of the types are not supported.
return specialType switch
{
SpecialFolderType.Inbox => Translator.MergedAccountCommonFolderInbox,
SpecialFolderType.Draft => Translator.MergedAccountCommonFolderDraft,
SpecialFolderType.Sent => Translator.MergedAccountCommonFolderSent,
SpecialFolderType.Deleted => Translator.MergedAccountCommonFolderTrash,
SpecialFolderType.Junk => Translator.MergedAccountCommonFolderJunk,
SpecialFolderType.Archive => Translator.MergedAccountCommonFolderArchive,
_ => folder.FolderName,
};
}
public void UpdateFolder(IMailItemFolder folder)
{
var existingFolder = Parameter.FirstOrDefault(a => a.Id == folder.Id);
if (existingFolder == null) return;
Parameter.Remove(existingFolder);
Parameter.Add(folder);
SetFolderName();
OnPropertyChanged(nameof(ShowUnreadCount));
OnPropertyChanged(nameof(IsSynchronizationEnabled));
}
}
}

44
Wino.Core.Domain/MenuItems/MergedAccountMenuItem.cs Normal file
View File

@@ -0,0 +1,44 @@
using System.Collections.Generic;
using System.Linq;
using CommunityToolkit.Mvvm.ComponentModel;
using Wino.Core.Domain.Entities.Mail;
using Wino.Core.Domain.Entities.Shared;
using Wino.Core.Domain.Interfaces;
namespace Wino.Core.Domain.MenuItems
{
public partial class MergedAccountMenuItem : MenuItemBase<MergedInbox, IMenuItem>, IMergedAccountMenuItem
{
public int MergedAccountCount => HoldingAccounts?.Count() ?? 0;
public IEnumerable<MailAccount> HoldingAccounts { get; }
[ObservableProperty]
private int unreadItemCount;
[ObservableProperty]
private double synchronizationProgress;
[ObservableProperty]
private string mergedAccountName;
[ObservableProperty]
private bool _isEnabled = true;
public MergedAccountMenuItem(MergedInbox mergedInbox, IEnumerable<MailAccount> holdingAccounts, IMenuItem parent) : base(mergedInbox, mergedInbox.Id, parent)
{
MergedAccountName = mergedInbox.Name;
HoldingAccounts = holdingAccounts;
}
public void RefreshFolderItemCount()
{
UnreadItemCount = SubMenuItems.OfType<IAccountMenuItem>().Sum(a => a.UnreadItemCount);
}
public void UpdateAccount(MailAccount account)
{
}
}
}

12
Wino.Core.Domain/MenuItems/MergedAccountMoreFolderMenuItem.cs Normal file
View File

@@ -0,0 +1,12 @@
using System;
using Wino.Core.Domain.Interfaces;
namespace Wino.Core.Domain.MenuItems
{
public class MergedAccountMoreFolderMenuItem : MenuItemBase<object, IMenuItem>
{
public MergedAccountMoreFolderMenuItem(object parameter, Guid? entityId, IMenuItem parentMenuItem = null) : base(parameter, entityId, parentMenuItem)
{
}
}
}

4
Wino.Core.Domain/MenuItems/NewMailMenuItem.cs Normal file
View File

@@ -0,0 +1,4 @@
namespace Wino.Core.Domain.MenuItems
{
public class NewMailMenuItem : MenuItemBase { }
}

4
Wino.Core.Domain/MenuItems/RateMenuItem.cs Normal file
View File

@@ -0,0 +1,4 @@
namespace Wino.Core.Domain.MenuItems
{
public class RateMenuItem : MenuItemBase { }
}

4
Wino.Core.Domain/MenuItems/SeperatorItem.cs Normal file
View File

@@ -0,0 +1,4 @@
namespace Wino.Core.Domain.MenuItems
{
public class SeperatorItem : MenuItemBase { }
}

4
Wino.Core.Domain/MenuItems/SettingsItem.cs Normal file
View File

@@ -0,0 +1,4 @@
namespace Wino.Core.Domain.MenuItems
{
public class SettingsItem : MenuItemBase { }
}