Winify – Diff between revs 29 and 30

Subversion Repositories:

?pathlinks?

Rev 29 – Rev 40 – Go to most recent revision – Details – Blame – Last modification – View Log

 ï»¿using System;
 using System.Collections.Concurrent;
 using System.ComponentModel;
-using System.Configuration;
-using System.Diagnostics;
+using System.Drawing;
 using System.IO;
+using System.Reflection;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Forms;
+using NetSparkleUpdater;
-using AutoUpdaterDotNET;
+using NetSparkleUpdater.Enums;
+using NetSparkleUpdater.SignatureVerifiers;
+using NetSparkleUpdater.UI.WinForms;
 using Serilog;
 using Servers;
 using Toasts;
 using Winify.Gotify;
-using Winify.Servers.Serialization;
 using Winify.Settings;
 using Winify.Utilities;
+using Winify.Utilities.Serialization;
 namespace Winify
 {
-    public partial class Form1 : Form
+    public partial class MainForm : Form
     {
+        #region Public Enums, Properties and Fields
+        public Configuration.Configuration Configuration { get; set; }
+        public ScheduledContinuation ChangedConfigurationContinuation { get; set; }
-        #region Private Delegates, Events, Enums, Properties, Indexers and Fields
+        #endregion
-        private readonly TaskScheduler _uiTaskScheduler;
+        #region Private Delegates, Events, Enums, Properties, Indexers and Fields
+        private AboutForm _aboutForm;
+        private ConcurrentBag<GotifyConnection> _gotifyConnections;
+        private SettingsForm _settingsForm;
-        private AboutForm _aboutForm;
+        private readonly SparkleUpdater _sparkle;
+        private readonly CancellationTokenSource _cancellationTokenSource;
+        private readonly CancellationToken _cancellationToken;
+        #endregion
+        #region Constructors, Destructors and Finalizers
-        private ConcurrentBag<GotifyConnection> _gotifyConnections;
+        public MainForm()
+        {
-        private SettingsForm _settingsForm;
+            _cancellationTokenSource = new CancellationTokenSource();
             _cancellationToken = _cancellationTokenSource.Token;
         #endregion
             ChangedConfigurationContinuation = new ScheduledContinuation();
         #region Constructors, Destructors and Finalizers
-        public Form1(Mutex mutex)
+        public MainForm(Mutex mutex) : this()
         {
-            InitializeComponent();
-            Log.Logger = new LoggerConfiguration()
-                .MinimumLevel.Debug()
-                .WriteTo.File(Path.Combine(Constants.UserApplicationDirectory, "Logs", $"{Constants.AssemblyName}.log"),
-                    rollingInterval: RollingInterval.Day)
-                .CreateLogger();
-            // Upgrade settings if required.
-            if (!ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.PerUserRoamingAndLocal).HasFile)
+            InitializeComponent();
-                if (Properties.Settings.Default.UpdateRequired)
-                {
-                    Properties.Settings.Default.Upgrade();
-                    Properties.Settings.Default.Reload();
-                    Properties.Settings.Default.UpdateRequired = false;
-                    Properties.Settings.Default.Save();
-                    mutex.ReleaseMutex();
-                    Process.Start(Application.ExecutablePath);
-                    Environment.Exit(0);
+            Log.Logger = new LoggerConfiguration()
                 .MinimumLevel.Debug()
+                .WriteTo.File(Path.Combine(Constants.UserApplicationDirectory, "Logs", $"{Constants.AssemblyName}.log"),
-            // Bind to settings changed event.
-            Properties.Settings.Default.SettingsLoaded += Default_SettingsLoaded;
-            Properties.Settings.Default.SettingsSaving += Default_SettingsSaving;
-            Properties.Settings.Default.PropertyChanged += Default_PropertyChanged;
-            // Store UI thread context.
-            _uiTaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
+                    rollingInterval: RollingInterval.Day)
-            LoadServers().ContinueWith(async task =>
-            {
-                var restoredServers = await task;
+                .CreateLogger();
-                _gotifyConnections = new ConcurrentBag<GotifyConnection>();
-                foreach (var server in restoredServers.Server)
+            // Start application update.
             var manifestModuleName = Assembly.GetEntryAssembly().ManifestModule.FullyQualifiedName;
-                    var gotifyConnection = new GotifyConnection(server);
+            var icon = Icon.ExtractAssociatedIcon(manifestModuleName);
                     gotifyConnection.GotifyNotification += GotifyConnection_GotifyNotification;
-                    gotifyConnection.Start();
+            _sparkle = new SparkleUpdater("https://winify.grimore.org/update/appcast.xml",
-                    _gotifyConnections.Add(gotifyConnection);
+                new Ed25519Checker(SecurityMode.Strict, "LonrgxVjSF0GnY4hzwlRJnLkaxnDn2ikdmOifILzLJY="))
+            {
-            });
+                UIFactory = new UIFactory(icon),
-            // Start application update.
-            AutoUpdater.Start("http://winify.grimore.org/update/winify.xml");
-        }
-        /// <summary>
-        ///     Clean up any resources being used.
-        /// </summary>
+                RelaunchAfterUpdate = true
-        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+            };
-        protected override void Dispose(bool disposing)
+            _sparkle.StartLoop(true, true);
+        }
-            if (disposing && components != null)
         /// <summary>
-                Properties.Settings.Default.SettingsLoaded -= Default_SettingsLoaded;
+        ///     Clean up any resources being used.
-                Properties.Settings.Default.SettingsSaving -= Default_SettingsSaving;
+        /// </summary>
-                Properties.Settings.Default.PropertyChanged -= Default_PropertyChanged;
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && components != null) components.Dispose();
-                components.Dispose();
+            base.Dispose(disposing);
-            }
+        }
-            base.Dispose(disposing);
         #endregion
-        #endregion
+        #region Event Handlers
-        #region Event Handlers
+        private async void MainForm_Load(object sender, EventArgs e)
+        {
-        private static void Default_PropertyChanged(object sender, PropertyChangedEventArgs e)
+            Configuration = await LoadConfiguration();
-        {
-            Properties.Settings.Default.Save();
+            var servers = await LoadServers();
-        }
+            _gotifyConnections = new ConcurrentBag<GotifyConnection>();
+            foreach (var server in servers.Server)
+            {
-        private static void Default_SettingsSaving(object sender, CancelEventArgs e)
+                var gotifyConnection = new GotifyConnection(server);
                 gotifyConnection.GotifyNotification += GotifyConnection_GotifyNotification;
                 gotifyConnection.Start();
                 _gotifyConnections.Add(gotifyConnection);
                 gotifyConnection.Start();
                 _gotifyConnections.Add(gotifyConnection);
+            }
+        }
-        private void GotifyConnection_GotifyNotification(object sender, GotifyNotificationEventArgs e)
+        private async void GotifyConnection_GotifyNotification(object sender, GotifyNotificationEventArgs e)
-        {
-            Task.Factory.StartNew(async () =>
-            {
+        {
-                var announcements = await LoadAnnouncements();
+            var announcements = await LoadAnnouncements();
-                foreach (var announcement in announcements.Announcement)
+            foreach (var announcement in announcements.Announcement)
-                    if (announcement.AppId == e.Notification.AppId)
+                if (announcement.AppId == e.Notification.AppId)
-                    {
+                {
-                        var configuredNotification = new ToastForm(
+                    var configuredNotification = new ToastForm(
-                            $"{e.Notification.Title} ({e.Notification.Server.Name}/{e.Notification.AppId})",
+                        $"{e.Notification.Title} ({e.Notification.Server.Name}/{e.Notification.AppId})",
-                            e.Notification.Message, announcement.LingerTime, e.Image);
+                        e.Notification.Message, announcement.LingerTime, e.Image);
-                        configuredNotification.Show();
+                    configuredNotification.Show();
-                        return;
+                    return;
-                    }
+                }
                 var notification = new ToastForm(
-                    $"{e.Notification.Title} ({e.Notification.Server.Name}/{e.Notification.AppId})",
+            var notification = new ToastForm(
-                    e.Notification.Message, 5000, e.Image);
+                $"{e.Notification.Title} ({e.Notification.Server.Name}/{e.Notification.AppId})",
                 e.Notification.Message, 5000, e.Image);
+        }
         private void QuitToolStripMenuItem_Click(object sender, EventArgs e)
+        {
+            Close();
+        }
+        private async void UpdateToolStripMenuItem_Click(object sender, EventArgs e)
+        {
+            // Manually check for updates, this will not show a ui
+            var result = await _sparkle.CheckForUpdatesQuietly();
+            if (result.Status == UpdateStatus.UpdateAvailable)
+            {
+                // if update(s) are found, then we have to trigger the UI to show it gracefully
+                _sparkle.ShowUpdateNeededUI();
+                return;
+            }
+            MessageBox.Show("No updates available at this time.", "Horizon", MessageBoxButtons.OK,
+                MessageBoxIcon.Asterisk,
+                MessageBoxDefaultButton.Button1, MessageBoxOptions.DefaultDesktopOnly, false);
+        }
+        #endregion
+        #region Public Methods
+        public async Task SaveConfiguration()
+        {
+            if (!Directory.Exists(Constants.UserApplicationDirectory))
+                Directory.CreateDirectory(Constants.UserApplicationDirectory);
+            switch (await Serialization.Serialize(Configuration, Constants.ConfigurationFile, "Configuration",
+                        "<!ATTLIST Configuration xmlns:xsi CDATA #IMPLIED xsi:noNamespaceSchemaLocation CDATA #IMPLIED>",
+                        CancellationToken.None))
+            {
+                case SerializationSuccess<Configuration.Configuration> _:
+                    Log.Information("Serialized configuration.");
+                    break;
-            Close();
+                case SerializationFailure serializationFailure:
+                    Log.Warning(serializationFailure.Exception.Message, "Failed to serialize configuration.");
                     break;
-            Environment.Exit(0);
+            }
+        }
+        public static async Task<Configuration.Configuration> LoadConfiguration()
+        {
+            if (!Directory.Exists(Constants.UserApplicationDirectory))
+                Directory.CreateDirectory(Constants.UserApplicationDirectory);
+            var deserializationResult =
+                await Serialization.Deserialize<Configuration.Configuration>(Constants.ConfigurationFile,
+                    Constants.ConfigurationNamespace, Constants.ConfigurationXsd, CancellationToken.None);
+            switch (deserializationResult)
+            {
+                case SerializationSuccess<Configuration.Configuration> serializationSuccess:
+                    return serializationSuccess.Result;
+                case SerializationFailure serializationFailure:
+                    Log.Warning(serializationFailure.Exception, "Failed to load configuration.");
+                    return new Configuration.Configuration();
-        private void UpdateToolStripMenuItem_Click(object sender, EventArgs e)
+                default:
                     return new Configuration.Configuration();
             AutoUpdater.Start("http://winify.grimore.org/update/winify.xml");
+        }
         #endregion
+        #region Private Methods
         #region Private Methods
         private static async Task SaveAnnouncements(Announcements.Announcements announcements)
         private static async Task SaveAnnouncements(Announcements.Announcements announcements)
             switch (await Serialization.Serialize(announcements, Constants.AnnouncementsFile, "Announcements",
-            switch (await ServersSerialization.Serialize(announcements, Constants.AnnouncementsFile, "Announcements",
+                        "<!ATTLIST Announcements xmlns:xsi CDATA #IMPLIED xsi:noNamespaceSchemaLocation CDATA #IMPLIED>",
-                        "<!ATTLIST Announcements xmlns:xsi CDATA #IMPLIED xsi:noNamespaceSchemaLocation CDATA #IMPLIED>"))
+                        CancellationToken.None))
             {
                 case SerializationFailure serializationFailure:
                     Log.Warning(serializationFailure.Exception, "Unable to serialize announcements.");
                     break;
             }
+        }
-        private static async Task SaveServers(global::Servers.Servers servers)
+        private static async Task SaveServers(Servers.Servers servers)
+        {
             // Encrypt password for all servers.
                 var armored = Convert.ToBase64String(encrypted);
                 @protected.Server.Add(new Server(server.Name, server.Url, server.Username, armored));
             }
+            switch (await Serialization.Serialize(@protected, Constants.ServersFile, "Servers",
-            switch (await ServersSerialization.Serialize(@protected, Constants.ServersFile, "Servers",
+                        "<!ATTLIST Servers xmlns:xsi CDATA #IMPLIED xsi:noNamespaceSchemaLocation CDATA #IMPLIED>",
-                        "<!ATTLIST Servers xmlns:xsi CDATA #IMPLIED xsi:noNamespaceSchemaLocation CDATA #IMPLIED>"))
+                        CancellationToken.None))
+            {
                 case SerializationFailure serializationFailure:
                     Log.Warning(serializationFailure.Exception, "Unable to serialize servers.");
+        {
             if (!Directory.Exists(Constants.UserApplicationDirectory))
                 Directory.CreateDirectory(Constants.UserApplicationDirectory);
             var deserializationResult =
-                await ServersSerialization.Deserialize<Announcements.Announcements>(Constants.AnnouncementsFile,
+                await Serialization.Deserialize<Announcements.Announcements>(Constants.AnnouncementsFile,
-                    "urn:winify-announcements-schema", "Announcements.xsd");
+                    "urn:winify-announcements-schema", "Announcements.xsd", CancellationToken.None);
             switch (deserializationResult)
+            {
                 default:
                     return new Announcements.Announcements();
+            }
+        }
-        private static async Task<global::Servers.Servers> LoadServers()
+        private static async Task<Servers.Servers> LoadServers()
+        {
             if (!Directory.Exists(Constants.UserApplicationDirectory))
                 Directory.CreateDirectory(Constants.UserApplicationDirectory);
             var deserializationResult =
-                await ServersSerialization.Deserialize<global::Servers.Servers>(Constants.ServersFile,
+                await Serialization.Deserialize<Servers.Servers>(Constants.ServersFile,
-                    "urn:winify-servers-schema", "Servers.xsd");
+                    "urn:winify-servers-schema", "Servers.xsd", CancellationToken.None);
             switch (deserializationResult)
+            {
-                case SerializationSuccess<global::Servers.Servers> serializationSuccess:
+                case SerializationSuccess<Servers.Servers> serializationSuccess:
                     // Decrypt password.
                     var deviceId = Miscellaneous.GetMachineGuid();
-                    var @protected = new global::Servers.Servers
+                    var @protected = new Servers.Servers
+                    {
                         Server = new BindingListWithCollectionChanged<Server>()
                     return @protected;
                 case SerializationFailure serializationFailure:
                     Log.Warning(serializationFailure.Exception, "Unable to load servers.");
-                    return new global::Servers.Servers();
+                    return new Servers.Servers();
                 default:
-                    return new global::Servers.Servers();
+                    return new Servers.Servers();
+            }