Full trust Wino Server implementation. (#295)

* Separation of messages. Introducing Wino.Messages library.

* Wino.Server and Wino.Packaging projects. Enabling full trust for UWP and app service connection manager basics.

* Remove debug code.

* Enable generating assembly info to deal with unsupported os platform warnings.

* Fix server-client connection.

* UIMessage communication. Single instancing for server and re-connection mechanism on suspension.

* Removed IWinoSynchronizerFactory from UWP project.

* Removal of background task service from core.

* Delegating changes to UI and triggering new background synchronization.

* Fix build error.

* Moved core lib messages to Messaging project.

* Better client-server communication. Handling of requests in the server. New synchronizer factory in the server.

* WAM broker and MSAL token caching for OutlookAuthenticator. Handling account creation for Outlook.

* WinoServerResponse basics.

* Delegating protocol activation for Gmail authenticator.

* Adding margin to searchbox to match action bar width.

* Move libraries into lib folder.

* Storing base64 encoded mime on draft creation instead of MimeMessage object. Fixes serialization/deserialization issue with S.T.Json

* Scrollbar adjustments

* WınoExpander for thread expander layout ıssue.

* Handling synchronizer state changes.

* Double init on background activation.

* FIxing packaging issues and new Wino Mail launcher protocol for activation from full thrust process.

* Remove debug deserialization.

* Remove debug code.

* Making sure the server connection is established when the app is launched.

* Thrust -> Trust string replacement...

* Rename package to Wino Mail

* Enable translated values in the server.

* Fixed an issue where toast activation can't find the clicked mail after the folder is initialized.

* Revert debug code.

* Change server background sync to every 3 minute and Inbox only synchronization.

* Revert google auth changes.

* App preferences page.

* Changing tray icon visibility on preference change.

* Start the server with invisible tray icon if set to invisible.

* Reconnect button on the title bar.

* Handling of toast actions.

* Enable x86 build for server during packaging.

* Get rid of old background tasks and v180 migration.

* Terminate client when Exit clicked in server.

* Introducing SynchronizationSource to prevent notifying UI after server tick synchronization.

* Remove confirmAppClose restricted capability and unused debug code in manifest.

* Closing the reconnect info popup when reconnect is clicked.

* Custom RetryHandler for OutlookSynchronizer and separating client/server logs.

* Running server on Windows startup.

* Fix startup exe.

* Fix for expander list view item paddings.

* Force full sync on app launch instead of Inbox.

* Fix draft creation.

* Fix an issue with custom folder sync logic.

* Reporting back account sync progress from server.

* Fix sending drafts and missing notifications for imap.

* Changing imap folder sync requirements.

* Retain file  count is set to 3.

* Disabled swipe gestures temporarily due to native crash
 with SwipeControl

* Save all attachments implementation.

* Localization for save all attachments button.

* Fix logging dates for logs.

* Fixing ARM64 build.

* Add ARM64 build config to packaging project.

* Comment out OutOfProcPDB for ARM64.

* Hnadling GONE response for Outlook folder synchronization.

Wino.Core/Integration/Json/ServerRequestTypeInfoResolver.cs

@@ -0,0 +1,49 @@
+using System.Text.Json.Serialization.Metadata;
+using Wino.Core.Domain.Entities;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.MailItem;
+using Wino.Core.Requests;
+
+namespace Wino.Core.Integration.Json
+{
+    public class ServerRequestTypeInfoResolver : DefaultJsonTypeInfoResolver
+    {
+        public ServerRequestTypeInfoResolver()
+        {
+            Modifiers.Add(new System.Action<JsonTypeInfo>(t =>
+            {
+                if (t.Type == typeof(IRequestBase))
+                {
+                    t.PolymorphismOptions = new()
+                    {
+                        DerivedTypes =
+                        {
+                            new JsonDerivedType(typeof(AlwaysMoveToRequest), nameof(AlwaysMoveToRequest)),
+                            new JsonDerivedType(typeof(ArchiveRequest), nameof(ArchiveRequest)),
+                            new JsonDerivedType(typeof(ChangeFlagRequest), nameof(ChangeFlagRequest)),
+                            new JsonDerivedType(typeof(CreateDraftRequest), nameof(CreateDraftRequest)),
+                            new JsonDerivedType(typeof(DeleteRequest), nameof(DeleteRequest)),
+                            new JsonDerivedType(typeof(EmptyFolderRequest), nameof(EmptyFolderRequest)),
+                            new JsonDerivedType(typeof(MarkFolderAsReadRequest), nameof(MarkFolderAsReadRequest)),
+                            new JsonDerivedType(typeof(MarkReadRequest), nameof(MarkReadRequest)),
+                            new JsonDerivedType(typeof(MoveRequest), nameof(MoveRequest)),
+                            new JsonDerivedType(typeof(MoveToFocusedRequest), nameof(MoveToFocusedRequest)),
+                            new JsonDerivedType(typeof(RenameFolderRequest), nameof(RenameFolderRequest)),
+                            new JsonDerivedType(typeof(SendDraftRequest), nameof(SendDraftRequest)),
+                        }
+                    };
+                }
+                else if (t.Type == typeof(IMailItem))
+                {
+                    t.PolymorphismOptions = new JsonPolymorphismOptions()
+                    {
+                        DerivedTypes =
+                        {
+                            new JsonDerivedType(typeof(MailCopy), nameof(MailCopy)),
+                        }
+                    };
+                }
+            }));
+        }
+    }
+}

Wino.Core/Integration/Processors/DefaultChangeProcessor.cs

@@ -62,6 +62,15 @@ namespace Wino.Core.Integration.Processors
         /// <returns>Whether the mime has b</returns>
         Task<bool> IsMailExistsAsync(string messageId);
 
+        /// <summary>
+        /// Checks whether the mail exists in the folder.
+        /// When deciding Create or Update existing mail, we need to check if the mail exists in the folder.
+        /// </summary>
+        /// <param name="messageId">Message id</param>
+        /// <param name="folderId">Folder's local id.</param>
+        /// <returns>Whether mail exists in the folder or not.</returns>
+        Task<bool> IsMailExistsInFolderAsync(string messageId, Guid folderId);
+
         /// <summary>
         /// Updates Folder's delta synchronization identifier.
         /// Only used in Outlook since it does per-folder sync.
@@ -70,6 +79,24 @@ namespace Wino.Core.Integration.Processors
         /// <param name="synchronizationIdentifier">New synchronization identifier.</param>
         /// <returns>New identifier if success.</returns>
         Task UpdateFolderDeltaSynchronizationIdentifierAsync(Guid folderId, string deltaSynchronizationIdentifier);
+
+        /// <summary>
+        /// Outlook may expire folder's delta token after a while.
+        /// Recommended action for this scenario is to reset token and do full sync.
+        /// This method resets the token for the given folder.
+        /// </summary>
+        /// <param name="folderId">Local folder id to reset token for.</param>
+        /// <returns>Empty string to assign folder delta sync for.</returns>
+        Task<string> ResetFolderDeltaTokenAsync(Guid folderId);
+
+        /// <summary>
+        /// Outlook may expire account's delta token after a while.
+        /// This will result returning 410 GONE response from the API for synchronizing folders.
+        /// This method resets the token for the given account for re-syncing folders.
+        /// </summary>
+        /// <param name="accountId">Account identifier to reset delta token for.</param>
+        /// <returns>Empty string to assign account delta sync for.</returns>
+        Task<string> ResetAccountDeltaTokenAsync(Guid accountId);
     }
 
     public interface IImapChangeProcessor : IDefaultChangeProcessor
@@ -90,11 +117,11 @@ namespace Wino.Core.Integration.Processors
         protected IMailService MailService = mailService;
 
         protected IFolderService FolderService = folderService;
-        private readonly IAccountService _accountService = accountService;
+        protected IAccountService AccountService = accountService;
         private readonly IMimeFileService _mimeFileService = mimeFileService;
 
         public Task<string> UpdateAccountDeltaSynchronizationIdentifierAsync(Guid accountId, string synchronizationDeltaIdentifier)
-            => _accountService.UpdateSynchronizationIdentifierAsync(accountId, synchronizationDeltaIdentifier);
+            => AccountService.UpdateSynchronizationIdentifierAsync(accountId, synchronizationDeltaIdentifier);
 
         public Task ChangeFlagStatusAsync(string mailCopyId, bool isFlagged)
             => MailService.ChangeFlagStatusAsync(mailCopyId, isFlagged);

Wino.Core/Integration/Processors/OutlookChangeProcessor.cs

@@ -9,11 +9,29 @@ namespace Wino.Core.Integration.Processors
                                         IFolderService folderService,
                                         IMailService mailService,
                                         IAccountService accountService,
-                                        IMimeFileService mimeFileService) : DefaultChangeProcessor(databaseService, folderService, mailService, accountService, mimeFileService), IOutlookChangeProcessor
+                                        IMimeFileService mimeFileService) : DefaultChangeProcessor(databaseService, folderService, mailService, accountService, mimeFileService)
+        , IOutlookChangeProcessor
     {
         public Task<bool> IsMailExistsAsync(string messageId)
             => MailService.IsMailExistsAsync(messageId);
 
+        public Task<bool> IsMailExistsInFolderAsync(string messageId, Guid folderId)
+            => MailService.IsMailExistsAsync(messageId, folderId);
+
+        public Task<string> ResetAccountDeltaTokenAsync(Guid accountId)
+            => AccountService.UpdateSynchronizationIdentifierAsync(accountId, null);
+
+        public async Task<string> ResetFolderDeltaTokenAsync(Guid folderId)
+        {
+            var folder = await FolderService.GetFolderAsync(folderId);
+
+            folder.DeltaToken = null;
+
+            await FolderService.UpdateFolderAsync(folder);
+
+            return string.Empty;
+        }
+
         public Task UpdateFolderDeltaSynchronizationIdentifierAsync(Guid folderId, string synchronizationIdentifier)
             => Connection.ExecuteAsync("UPDATE MailItemFolder SET DeltaToken = ? WHERE Id = ?", synchronizationIdentifier, folderId);
     }