Full trust Wino Server implementation.

Wino.BackgroundTasks/SessionConnectedTask.cs

@@ -1,13 +1,6 @@
 using System;
-using Microsoft.Extensions.DependencyInjection;
-using Serilog;
+using Windows.ApplicationModel;
 using Windows.ApplicationModel.Background;
-using Windows.Storage;
-using Wino.Core;
-using Wino.Core.Domain.Interfaces;
-using Wino.Core.Services;
-using Wino.Core.UWP;
-using Wino.Services;
 
 namespace Wino.BackgroundTasks
 {
@@ -17,32 +10,10 @@ public async void Run(IBackgroundTaskInstance taskInstance)
         {
             var def = taskInstance.GetDeferral();
 
-            try
-            {
-                var services = new ServiceCollection();
+            // Run server on session connected by launching the Full Thrust process.
+            await FullTrustProcessLauncher.LaunchFullTrustProcessForCurrentAppAsync();
 
-                services.RegisterCoreServices();
-                services.RegisterCoreUWPServices();
-
-                var providere = services.BuildServiceProvider();
-
-                var backgroundTaskService = providere.GetService<IBackgroundSynchronizer>();
-                var dbService = providere.GetService<IDatabaseService>();
-                var logInitializer = providere.GetService<ILogInitializer>();
-
-                logInitializer.SetupLogger(ApplicationData.Current.LocalFolder.Path);
-
-                await dbService.InitializeAsync();
-                await backgroundTaskService.RunBackgroundSynchronizationAsync(Core.Domain.Enums.BackgroundSynchronizationReason.SessionConnected);
-            }
-            catch (Exception ex)
-            {
-                Log.Error(ex, "Background synchronization failed from background task.");
-            }
-            finally
-            {
-                def.Complete();
-            }
+            def.Complete();
         }
     }
 }

Wino.BackgroundTasks/Wino.BackgroundTasks.csproj

@@ -18,25 +18,6 @@
     <ProjectTypeGuids>{A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <AllowCrossPlatformRetargeting>false</AllowCrossPlatformRetargeting>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
     <PlatformTarget>x86</PlatformTarget>
     <DebugSymbols>true</DebugSymbols>

Wino.Core.Domain/Constants.cs

@@ -8,8 +8,10 @@ public static class Constants
         public const string WinoLocalDraftHeader = "X-Wino-Draft-Id";
         public const string LocalDraftStartPrefix = "localDraft_";
 
-        public const string ToastMailItemIdKey = nameof(ToastMailItemIdKey);
-        public const string ToastMailItemRemoteFolderIdKey = nameof(ToastMailItemRemoteFolderIdKey);
+        public const string ToastMailUniqueIdKey = nameof(ToastMailUniqueIdKey);
         public const string ToastActionKey = nameof(ToastActionKey);
+
+        public const string ClientLogFile = "Client_.log";
+        public const string ServerLogFile = "Server_.log";
     }
 }

Wino.Core.Domain/Entities/TokenInformation.cs

@@ -11,6 +11,10 @@ public class TokenInformation : TokenInformationBase
 
         public Guid AccountId { get; set; }
 
+        /// <summary>
+        /// Unique object storage for authenticators if needed.
+        /// </summary>
+        public string UniqueId { get; set; }
         public string Address { get; set; }
 
         public void RefreshTokens(TokenInformationBase tokenInformationBase)

Wino.Core.Domain/Enums/ServerBackgroundMode.cs

@@ -0,0 +1,12 @@
+namespace Wino.Core.Domain.Enums
+{
+    /// <summary>
+    /// What should happen to server app when the client is terminated.
+    /// </summary>
+    public enum ServerBackgroundMode
+    {
+        MinimizedTray, // Still runs, tray icon is visible.
+        Invisible, // Still runs, tray icon is invisible.
+        Terminate // Server is terminated as Wino terminates.
+    }
+}

Wino.Core.Domain/Enums/StartupBehaviorResult.cs

@@ -0,0 +1,11 @@
+namespace Wino.Core.Domain.Enums
+{
+    public enum StartupBehaviorResult
+    {
+        Enabled,
+        Disabled,
+        DisabledByUser,
+        DisabledByPolicy,
+        Fatal
+    }
+}

Wino.Core.Domain/Enums/SynchronizationSource.cs

@@ -0,0 +1,12 @@
+namespace Wino.Core.Domain.Enums
+{
+    /// <summary>
+    /// Enumeration for the source of synchronization.
+    /// Right now it can either be from the client or the server.
+    /// </summary>
+    public enum SynchronizationSource
+    {
+        Client,
+        Server
+    }
+}

Wino.Core.Domain/Enums/WinoPage.cs

@@ -21,6 +21,7 @@ public enum WinoPage
         MailListPage,
         ReadComposePanePage,
         LanguageTimePage,
+        AppPreferencesPage,
         SettingOptionsPage,
     }
 }

Wino.Core.Domain/Enums/WinoServerConnectionStatus.cs

@@ -0,0 +1,11 @@
+namespace Wino.Core.Domain.Enums
+{
+    public enum WinoServerConnectionStatus
+    {
+        None,
+        Connecting,
+        Connected,
+        Disconnected,
+        Failed
+    }
+}

Wino.Core.Domain/Exceptions/WinoServerException.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace Wino.Core.Domain.Exceptions
+{
+    /// <summary>
+    /// All server crash types. Wino Server ideally should not throw anything else than this Exception type.
+    /// </summary>
+    public class WinoServerException : Exception
+    {
+        public WinoServerException(string message) : base(message) { }
+    }
+}

Wino.Core.Domain/Extensions/MimeExtensions.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace Wino.Core.Domain.Extensions
+{
+    public static class MimeExtensions
+    {
+        public static string GetBase64MimeMessage(this MimeKit.MimeMessage message)
+        {
+            using System.IO.MemoryStream memoryStream = new();
+            message.WriteTo(MimeKit.FormatOptions.Default, memoryStream);
+            byte[] buffer = memoryStream.GetBuffer();
+            int count = (int)memoryStream.Length;
+
+            return Convert.ToBase64String(buffer);
+        }
+
+        public static MimeKit.MimeMessage GetMimeMessageFromBase64(this string base64)
+            => MimeKit.MimeMessage.Load(new System.IO.MemoryStream(Convert.FromBase64String(base64)));
+    }
+}

Wino.Core.Domain/Interfaces/IApplicationConfiguration.cs

@@ -0,0 +1,21 @@
+namespace Wino.Core.Domain.Interfaces
+{
+    /// <summary>
+    /// Singleton object that holds the application data folder path and the publisher shared folder path.
+    /// Load the values before calling any service.
+    /// App data folder is used for storing files.
+    /// Pubhlisher cache folder is only used for database file so other apps can access it in the same package by same publisher.
+    /// </summary>
+    public interface IApplicationConfiguration
+    {
+        /// <summary>
+        /// Application data folder.
+        /// </summary>
+        string ApplicationDataFolderPath { get; set; }
+
+        /// <summary>
+        /// Publisher shared folder path.
+        /// </summary>
+        string PublisherSharedFolderPath { get; set; }
+    }
+}

Wino.Core.Domain/Interfaces/IAuthenticator.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using Wino.Core.Domain.Entities;
 using Wino.Core.Domain.Enums;
 
@@ -23,28 +22,12 @@ public interface IAuthenticator
 
         /// <summary>
         /// Initial creation of token. Requires user interaction.
-        /// This will save token into database, but still returns for account creation
+        /// This will cache the token but still returns for account creation
         /// since account address is required.
         /// </summary>
-        /// <param name="expectedAccountAddress">Token cache might ask for regeneration of token for specific
-        /// account address. If one is provided and re-generation native token doesn't belong to this address
-        /// token saving to database won't happen.</param>
         /// <returns>Freshly created TokenInformation..</returns>
         Task<TokenInformation> GenerateTokenAsync(MailAccount account, bool saveToken);
 
-        /// <summary>
-        /// Required for external authorization on launched browser to continue.
-        /// Used for Gmail.
-        /// </summary>
-        /// <param name="authorizationResponseUri">Response's redirect uri.</param>
-        void ContinueAuthorization(Uri authorizationResponseUri);
-
-        /// <summary>
-        /// For external browser required authentications.
-        /// Canceling Gmail authentication dialog etc.
-        /// </summary>
-        void CancelAuthorization();
-
         /// <summary>
         /// ClientId in case of needed for authorization/authentication.
         /// </summary>

Wino.Core.Domain/Interfaces/IAuthenticatorTypes.cs

@@ -0,0 +1,6 @@
+namespace Wino.Core.Domain.Interfaces
+{
+    public interface IOutlookAuthenticator : IAuthenticator { }
+    public interface IGmailAuthenticator : IAuthenticator { }
+    public interface IImapAuthenticator : IAuthenticator { }
+}

Wino.Core.Domain/Interfaces/IBaseSynchronizer.cs

@@ -0,0 +1,54 @@
+using System.Threading;
+using System.Threading.Tasks;
+using MailKit;
+using Wino.Core.Domain.Entities;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Models.MailItem;
+using Wino.Core.Domain.Models.Synchronization;
+
+namespace Wino.Core.Domain.Interfaces
+{
+    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);
+    }
+}

Wino.Core.Domain/Interfaces/IClientMessage.cs

@@ -0,0 +1,8 @@
+namespace Wino.Core.Domain.Interfaces
+{
+    /// <summary>
+    /// All messages that Client sends to Server and awaits a response in return.
+    /// For example; triggering a new synchronization request.
+    /// </summary>
+    public interface IClientMessage;
+}

Wino.Core.Domain/Interfaces/ILogInitializer.cs

@@ -2,7 +2,7 @@
 {
     public interface ILogInitializer
     {
-        void SetupLogger(string logFolderPath);
+        void SetupLogger(string fullLogFilePath);
 
         void RefreshLoggingLevel();
     }

Wino.Core.Domain/Interfaces/IMailService.cs

@@ -11,7 +11,7 @@ public interface IMailService
     {
         Task<MailCopy> GetSingleMailItemAsync(string mailCopyId, string remoteFolderId);
         Task<MailCopy> GetSingleMailItemAsync(Guid uniqueMailId);
-        Task<MailCopy> CreateDraftAsync(MailAccount composerAccount, MimeMessage generatedReplyMime, MimeMessage replyingMimeMessage = null, IMailItem replyingMailItem = null);
+        Task<MailCopy> CreateDraftAsync(MailAccount composerAccount, string generatedReplyMimeMessageBase64, MimeMessage replyingMimeMessage = null, IMailItem replyingMailItem = null);
         Task<List<IMailItem>> FetchMailsAsync(MailListInitializationOptions options);
 
         /// <summary>
@@ -51,7 +51,16 @@ public interface IMailService
         /// <param name="newThreadId"></param>
         Task MapLocalDraftAsync(string newMailCopyId, string newDraftId, string newThreadId);
 
-        Task<MimeMessage> CreateDraftMimeMessageAsync(Guid accountId, DraftCreationOptions options);
+        /// <summary>
+        /// Creates a draft message with the given options.
+        /// </summary>
+        /// <param name="accountId">Account to create draft for.</param>
+        /// <param name="options">Draft creation options.</param>
+        /// <returns>
+        /// Base64 encoded string of MimeMessage object.
+        /// This is mainly for serialization purposes.
+        /// </returns>
+        Task<string> CreateDraftMimeBase64Async(Guid accountId, DraftCreationOptions options);
         Task UpdateMailAsync(MailCopy mailCopy);
 
         /// <summary>
@@ -92,5 +101,14 @@ public interface IMailService
         /// </summary>
         /// <param name="folderId">Folder id to get unread mails for.</param>
         Task<List<MailCopy>> GetUnreadMailsByFolderIdAsync(Guid folderId);
+
+        /// <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> IsMailExistsAsync(string mailCopyId, Guid folderId);
     }
 }