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/Synchronizers/BaseSynchronizer.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -14,57 +15,12 @@ using Wino.Core.Domain.Interfaces;
 using Wino.Core.Domain.Models.MailItem;
 using Wino.Core.Domain.Models.Synchronization;
 using Wino.Core.Integration;
-using Wino.Core.Messages.Mails;
-using Wino.Core.Messages.Synchronization;
 using Wino.Core.Misc;
 using Wino.Core.Requests;
+using Wino.Messaging.UI;
 
 namespace Wino.Core.Synchronizers
 {
-    public interface IBaseSynchronizer
-    {
-        /// <summary>
-        /// Account that is assigned for this synchronizer.
-        /// </summary>
-        MailAccount Account { get; }
-
-        /// <summary>
-        /// Synchronizer state.
-        /// </summary>
-        AccountSynchronizerState State { get; }
-
-        /// <summary>
-        /// Queues a single request to be executed in the next synchronization.
-        /// </summary>
-        /// <param name="request">Request to queue.</param>
-        void QueueRequest(IRequestBase request);
-
-        /// <summary>
-        /// TODO
-        /// </summary>
-        /// <returns>Whether active synchronization is stopped or not.</returns>
-        bool CancelActiveSynchronization();
-
-        /// <summary>
-        /// Performs a full synchronization with the server with given options.
-        /// This will also prepares batch requests for execution.
-        /// Requests are executed in the order they are queued and happens before the synchronization.
-        /// Result of the execution queue is processed during the synchronization.
-        /// </summary>
-        /// <param name="options">Options for synchronization.</param>
-        /// <param name="cancellationToken">Cancellation token.</param>
-        /// <returns>Result summary of synchronization.</returns>
-        Task<SynchronizationResult> SynchronizeAsync(SynchronizationOptions options, CancellationToken cancellationToken = default);
-
-        /// <summary>
-        /// Downloads a single MIME message from the server and saves it to disk.
-        /// </summary>
-        /// <param name="mailItem">Mail item to download from server.</param>
-        /// <param name="transferProgress">Optional progress reporting for download operation.</param>
-        /// <param name="cancellationToken">Cancellation token.</param>
-        Task DownloadMissingMimeMessageAsync(IMailItem mailItem, ITransferProgress transferProgress, CancellationToken cancellationToken = default);
-    }
-
     public abstract class BaseSynchronizer<TBaseRequest, TMessageType> : BaseMailIntegrator<TBaseRequest>, IBaseSynchronizer
     {
         private SemaphoreSlim synchronizationSemaphore = new(1);
@@ -88,7 +44,7 @@ namespace Wino.Core.Synchronizers
             {
                 state = value;
 
-                WeakReferenceMessenger.Default.Send(new AccountSynchronizerStateChanged(this, value));
+                WeakReferenceMessenger.Default.Send(new AccountSynchronizerStateChanged(Account.Id, value));
             }
         }
 
@@ -166,18 +122,21 @@ namespace Wino.Core.Synchronizers
             }
             catch (OperationCanceledException)
             {
-                Logger.Warning("Synchronization cancelled.");
+                Logger.Warning("Synchronization canceled.");
+
                 return SynchronizationResult.Canceled;
             }
-            catch (Exception)
+            catch (Exception ex)
             {
-                // Disable maybe?
+                Logger.Error(ex, "Synchronization failed for {Name}", Account.Name);
+                Debugger.Break();
+
                 throw;
             }
             finally
             {
                 // Reset account progress to hide the progress.
-                options.ProgressListener?.AccountProgressUpdated(Account.Id, 0);
+                PublishSynchronizationProgress(0);
 
                 State = AccountSynchronizerState.Idle;
                 synchronizationSemaphore.Release();
@@ -191,6 +150,9 @@ namespace Wino.Core.Synchronizers
         private void PublishUnreadItemChanges()
             => WeakReferenceMessenger.Default.Send(new RefreshUnreadCountsMessage(Account.Id));
 
+        public void PublishSynchronizationProgress(double progress)
+            => WeakReferenceMessenger.Default.Send(new AccountSynchronizationProgressUpdatedMessage(Account.Id, progress));
+
         /// <summary>
         /// 1. Group all requests by operation type.
         /// 2. Group all individual operation type requests with equality check.
@@ -302,20 +264,31 @@ namespace Wino.Core.Synchronizers
         /// <returns>New synchronization options with minimal HTTP effort.</returns>
         private SynchronizationOptions GetSynchronizationOptionsAfterRequestExecution(IEnumerable<IRequestBase> requests)
         {
-            bool isAllCustomSynchronizationRequests = requests.All(a => a is ICustomFolderSynchronizationRequest);
+            List<Guid> synchronizationFolderIds = new();
+
+            if (requests.All(a => a is IBatchChangeRequest))
+            {
+                var requestsInsideBatches = requests.Cast<IBatchChangeRequest>().SelectMany(b => b.Items);
+
+                // Gather FolderIds to synchronize.
+                synchronizationFolderIds = requestsInsideBatches
+                    .Where(a => a is ICustomFolderSynchronizationRequest)
+                    .Cast<ICustomFolderSynchronizationRequest>()
+                    .SelectMany(a => a.SynchronizationFolderIds)
+                    .ToList();
+            }
 
             var options = new SynchronizationOptions()
             {
                 AccountId = Account.Id,
-                Type = SynchronizationType.FoldersOnly
             };
 
-            if (isAllCustomSynchronizationRequests)
+            if (synchronizationFolderIds.Count > 0)
             {
                 // Gather FolderIds to synchronize.
 
                 options.Type = SynchronizationType.Custom;
-                options.SynchronizationFolderIds = requests.Cast<ICustomFolderSynchronizationRequest>().SelectMany(a => a.SynchronizationFolderIds).ToList();
+                options.SynchronizationFolderIds = synchronizationFolderIds;
             }
             else
             {

Wino.Core/Synchronizers/GmailSynchronizer.cs

@@ -212,7 +212,7 @@ namespace Wino.Core.Synchronizers
             }
 
             // Start downloading missing messages.
-            await BatchDownloadMessagesAsync(missingMessageIds, options.ProgressListener, cancellationToken).ConfigureAwait(false);
+            await BatchDownloadMessagesAsync(missingMessageIds, cancellationToken).ConfigureAwait(false);
 
             // Map remote drafts to local drafts.
             await MapDraftIdsAsync(cancellationToken).ConfigureAwait(false);
@@ -353,7 +353,7 @@ namespace Wino.Core.Synchronizers
         /// </summary>
         /// <param name="messageIds">Gmail message ids to download.</param>
         /// <param name="cancellationToken">Cancellation token.</param>
-        private async Task BatchDownloadMessagesAsync(IEnumerable<string> messageIds, ISynchronizationProgress progressListener = null, CancellationToken cancellationToken = default)
+        private async Task BatchDownloadMessagesAsync(IEnumerable<string> messageIds, CancellationToken cancellationToken = default)
         {
             var totalDownloadCount = messageIds.Count();
 
@@ -396,7 +396,7 @@ namespace Wino.Core.Synchronizers
 
                         var progressValue = downloadedItemCount * 100 / Math.Max(1, totalDownloadCount);
 
-                        progressListener?.AccountProgressUpdated(Account.Id, progressValue);
+                        PublishSynchronizationProgress(progressValue);
                     });
                 });
 

Wino.Core/Synchronizers/ImapSynchronizer.cs

@@ -407,21 +407,19 @@ namespace Wino.Core.Synchronizers
 
         public override async Task<SynchronizationResult> SynchronizeInternalAsync(SynchronizationOptions options, CancellationToken cancellationToken = default)
         {
-            // options.Type = SynchronizationType.FoldersOnly;
-
             var downloadedMessageIds = new List<string>();
 
             _logger.Information("Internal synchronization started for {Name}", Account.Name);
             _logger.Information("Options: {Options}", options);
 
-            options.ProgressListener?.AccountProgressUpdated(Account.Id, 1);
+            PublishSynchronizationProgress(1);
 
-            // Only do folder sync for these types.
-            // Opening folder and checking their UidValidity is slow.
-            // Therefore this should be avoided as many times as possible.
+            bool shouldDoFolderSync = options.Type == SynchronizationType.Full || options.Type == SynchronizationType.FoldersOnly;
 
-            // This may create some inconsistencies, but nothing we can do...
-            await SynchronizeFoldersAsync(cancellationToken).ConfigureAwait(false);
+            if (shouldDoFolderSync)
+            {
+                await SynchronizeFoldersAsync(cancellationToken).ConfigureAwait(false);
+            }
 
             if (options.Type != SynchronizationType.FoldersOnly)
             {
@@ -432,14 +430,14 @@ namespace Wino.Core.Synchronizers
                     var folder = synchronizationFolders[i];
                     var progress = (int)Math.Round((double)(i + 1) / synchronizationFolders.Count * 100);
 
-                    options.ProgressListener?.AccountProgressUpdated(Account.Id, progress);
+                    PublishSynchronizationProgress(progress);
 
                     var folderDownloadedMessageIds = await SynchronizeFolderInternalAsync(folder, cancellationToken).ConfigureAwait(false);
                     downloadedMessageIds.AddRange(folderDownloadedMessageIds);
                 }
             }
 
-            options.ProgressListener?.AccountProgressUpdated(Account.Id, 100);
+            PublishSynchronizationProgress(100);
 
             // Get all unread new downloaded items and return in the result.
             // This is primarily used in notifications.
@@ -943,7 +941,12 @@ namespace Wino.Core.Synchronizers
 
                         foreach (var mailPackage in createdMailPackages)
                         {
-                            await _imapChangeProcessor.CreateMailAsync(Account.Id, mailPackage).ConfigureAwait(false);
+                            bool isCreated = await _imapChangeProcessor.CreateMailAsync(Account.Id, mailPackage).ConfigureAwait(false);
+
+                            if (isCreated)
+                            {
+                                downloadedMessageIds.Add(mailPackage.Copy.Id);
+                            }
                         }
                     }
                 }

Wino.Core/Synchronizers/OutlookSynchronizer.cs

@@ -13,6 +13,8 @@ using Microsoft.Graph;
 using Microsoft.Graph.Models;
 using Microsoft.Kiota.Abstractions;
 using Microsoft.Kiota.Abstractions.Authentication;
+using Microsoft.Kiota.Http.HttpClientLibrary.Middleware;
+using Microsoft.Kiota.Http.HttpClientLibrary.Middleware.Options;
 using MimeKit;
 using MoreLinq.Extensions;
 using Serilog;
@@ -73,19 +75,59 @@ namespace Wino.Core.Synchronizers
         {
             var tokenProvider = new MicrosoftTokenProvider(Account, authenticator);
 
-            // Add immutable id preffered client.
+            // Update request handlers for Graph client.
             var handlers = GraphClientFactory.CreateDefaultHandlers();
-            handlers.Add(new MicrosoftImmutableIdHandler());
+
+            handlers.Add(GetMicrosoftImmutableIdHandler());
+
+            // Remove existing RetryHandler and add a new one with custom options.
+            var existingRetryHandler = handlers.FirstOrDefault(a => a is RetryHandler);
+            if (existingRetryHandler != null)
+                handlers.Remove(existingRetryHandler);
+
+            // Add custom one.
+            handlers.Add(GetRetryHandler());
 
             var httpClient = GraphClientFactory.Create(handlers);
-
             _graphClient = new GraphServiceClient(httpClient, new BaseBearerTokenAuthenticationProvider(tokenProvider));
+
             _outlookChangeProcessor = outlookChangeProcessor;
 
             // Specify to use TLS 1.2 as default connection
-            System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
+            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
         }
 
+        #region MS Graph Handlers
+
+        private MicrosoftImmutableIdHandler GetMicrosoftImmutableIdHandler() => new();
+
+        private RetryHandler GetRetryHandler()
+        {
+            var options = new RetryHandlerOption()
+            {
+                ShouldRetry = (delay, attempt, httpResponse) =>
+                {
+                    var statusCode = httpResponse.StatusCode;
+
+                    return statusCode switch
+                    {
+                        HttpStatusCode.ServiceUnavailable => true,
+                        HttpStatusCode.GatewayTimeout => true,
+                        (HttpStatusCode)429 => true,
+                        HttpStatusCode.Unauthorized => true,
+                        _ => false
+                    };
+                },
+                Delay = 3,
+                MaxRetry = 3
+            };
+
+            return new RetryHandler(options);
+        }
+
+        #endregion
+
+
         public override async Task<SynchronizationResult> SynchronizeInternalAsync(SynchronizationOptions options, CancellationToken cancellationToken = default)
         {
             var downloadedMessageIds = new List<string>();
@@ -95,7 +137,7 @@ namespace Wino.Core.Synchronizers
 
             try
             {
-                options.ProgressListener?.AccountProgressUpdated(Account.Id, 1);
+                PublishSynchronizationProgress(1);
 
                 await SynchronizeFoldersAsync(cancellationToken).ConfigureAwait(false);
 
@@ -111,7 +153,7 @@ namespace Wino.Core.Synchronizers
                         var folder = synchronizationFolders[i];
                         var progress = (int)Math.Round((double)(i + 1) / synchronizationFolders.Count * 100);
 
-                        options.ProgressListener?.AccountProgressUpdated(Account.Id, progress);
+                        PublishSynchronizationProgress(progress);
 
                         var folderDownloadedMessageIds = await SynchronizeFolderAsync(folder, cancellationToken).ConfigureAwait(false);
                         downloadedMessageIds.AddRange(folderDownloadedMessageIds);
@@ -120,13 +162,14 @@ namespace Wino.Core.Synchronizers
             }
             catch (Exception ex)
             {
-                _logger.Error(ex, "Synchronization failed for {Name}", Account.Name);
+                _logger.Error(ex, "Synchronizing folders for {Name}", Account.Name);
+                Debugger.Break();
 
                 throw;
             }
             finally
             {
-                options.ProgressListener?.AccountProgressUpdated(Account.Id, 100);
+                PublishSynchronizationProgress(100);
             }
 
             // Get all unred new downloaded items and return in the result.
@@ -238,20 +281,12 @@ namespace Wino.Core.Synchronizers
         private bool IsResourceDeleted(IDictionary<string, object> additionalData)
             => additionalData != null && additionalData.ContainsKey("@removed");
 
-        private bool IsResourceUpdated(IDictionary<string, object> additionalData)
-            => additionalData == null || !additionalData.Any();
-
         private async Task<bool> HandleFolderRetrievedAsync(MailFolder folder, OutlookSpecialFolderIdInformation outlookSpecialFolderIdInformation, CancellationToken cancellationToken = default)
         {
             if (IsResourceDeleted(folder.AdditionalData))
             {
                 await _outlookChangeProcessor.DeleteFolderAsync(Account.Id, folder.Id).ConfigureAwait(false);
             }
-            else if (IsResourceUpdated(folder.AdditionalData))
-            {
-                // TODO
-                Debugger.Break();
-            }
             else
             {
                 // New folder created.
@@ -297,38 +332,45 @@ namespace Wino.Core.Synchronizers
 
                 await _outlookChangeProcessor.DeleteAssignmentAsync(Account.Id, item.Id, folder.RemoteFolderId).ConfigureAwait(false);
             }
-            else if (IsResourceUpdated(item.AdditionalData))
-            {
-                // Some of the properties of the item are updated.
-
-                if (item.IsRead != null)
-                {
-                    await _outlookChangeProcessor.ChangeMailReadStatusAsync(item.Id, item.IsRead.GetValueOrDefault()).ConfigureAwait(false);
-                }
-
-                if (item.Flag?.FlagStatus != null)
-                {
-                    await _outlookChangeProcessor.ChangeFlagStatusAsync(item.Id, item.Flag.FlagStatus.GetValueOrDefault() == FollowupFlagStatus.Flagged)
-                                                 .ConfigureAwait(false);
-                }
-            }
             else
             {
-                // Package may return null on some cases mapping the remote draft to existing local draft.
+                // If the item exists in the local database, it means that it's already downloaded. Process as an Update.
 
-                var newMailPackages = await CreateNewMailPackagesAsync(item, folder, cancellationToken);
+                var isMailExists = await _outlookChangeProcessor.IsMailExistsInFolderAsync(item.Id, folder.Id);
 
-                if (newMailPackages != null)
+                if (isMailExists)
                 {
-                    foreach (var package in newMailPackages)
-                    {
-                        // Only add to downloaded message ids if it's inserted successfuly.
-                        // Updates should not be added to the list because they are not new.
-                        bool isInserted = await _outlookChangeProcessor.CreateMailAsync(Account.Id, package).ConfigureAwait(false);
+                    // Some of the properties of the item are updated.
 
-                        if (isInserted)
+                    if (item.IsRead != null)
+                    {
+                        await _outlookChangeProcessor.ChangeMailReadStatusAsync(item.Id, item.IsRead.GetValueOrDefault()).ConfigureAwait(false);
+                    }
+
+                    if (item.Flag?.FlagStatus != null)
+                    {
+                        await _outlookChangeProcessor.ChangeFlagStatusAsync(item.Id, item.Flag.FlagStatus.GetValueOrDefault() == FollowupFlagStatus.Flagged)
+                                                     .ConfigureAwait(false);
+                    }
+                }
+                else
+                {
+                    // Package may return null on some cases mapping the remote draft to existing local draft.
+
+                    var newMailPackages = await CreateNewMailPackagesAsync(item, folder, cancellationToken);
+
+                    if (newMailPackages != null)
+                    {
+                        foreach (var package in newMailPackages)
                         {
-                            downloadedMessageIds.Add(package.Copy.Id);
+                            // Only add to downloaded message ids if it's inserted successfuly.
+                            // Updates should not be added to the list because they are not new.
+                            bool isInserted = await _outlookChangeProcessor.CreateMailAsync(Account.Id, package).ConfigureAwait(false);
+
+                            if (isInserted)
+                            {
+                                downloadedMessageIds.Add(package.Copy.Id);
+                            }
                         }
                     }
                 }
@@ -339,11 +381,12 @@ namespace Wino.Core.Synchronizers
 
         private async Task SynchronizeFoldersAsync(CancellationToken cancellationToken = default)
         {
-            // Gather special folders by default.
-            // Others will be other type.
+        // Gather special folders by default.
+        // Others will be other type.
 
-            // Get well known folder ids by batch.
+        // Get well known folder ids by batch.
 
+        retry:
             var wellKnownFolderIdBatch = new BatchRequestContentCollection(_graphClient);
 
             var inboxRequest = _graphClient.Me.MailFolders[INBOX_NAME].ToGetRequestInformation((t) => { t.QueryParameters.Select = ["id"]; });
@@ -394,9 +437,19 @@ namespace Wino.Core.Synchronizers
 
                 deltaRequest.UrlTemplate = deltaRequest.UrlTemplate.Insert(deltaRequest.UrlTemplate.Length - 1, ",%24deltaToken");
                 deltaRequest.QueryParameters.Add("%24deltaToken", currentDeltaLink);
-                graphFolders = await _graphClient.RequestAdapter.SendAsync(deltaRequest,
+
+                try
+                {
+                    graphFolders = await _graphClient.RequestAdapter.SendAsync(deltaRequest,
                     Microsoft.Graph.Me.MailFolders.Delta.DeltaGetResponse.CreateFromDiscriminatorValue,
                     cancellationToken: cancellationToken).ConfigureAwait(false);
+                }
+                catch (ApiException apiException) when (apiException.ResponseStatusCode == 410)
+                {
+                    Account.SynchronizationDeltaIdentifier = await _outlookChangeProcessor.ResetAccountDeltaTokenAsync(Account.Id);
+
+                    goto retry;
+                }
             }
 
             var iterator = PageIterator<MailFolder, Microsoft.Graph.Me.MailFolders.Delta.DeltaGetResponse>.CreatePageIterator(_graphClient, graphFolders, (folder) =>
@@ -686,6 +739,8 @@ namespace Wino.Core.Synchronizers
                                                                    HttpResponseMessage httpResponseMessage,
                                                                    CancellationToken cancellationToken = default)
         {
+            if (httpResponseMessage == null) return;
+
             if (!httpResponseMessage.IsSuccessStatusCode)
             {
                 throw new SynchronizerException(string.Format(Translator.Exception_SynchronizerFailureHTTP, httpResponseMessage.StatusCode));