Winify – Diff between revs 24 and 25

Subversion Repositories:

?pathlinks?

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

 ï»¿using System;
-using System.Collections.Specialized;
+using System.Collections.Concurrent;
 using System.ComponentModel;
 using System.Configuration;
 using System.Diagnostics;
 using System.IO;
-using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Forms;
 using AutoUpdaterDotNET;
 using Serilog;
 using Servers;
 using ToastNotifications;
 using Winify.Gotify;
-using Winify.Properties;
 using Winify.Servers.Serialization;
+using Winify.Settings;
 using Winify.Utilities;
 namespace Winify
+{
     public partial class Form1 : Form
+    {
-        #region Private Delegates, Events, Enums, Properties, Indexers and Fields
-        private readonly Announcements.Announcements _announcements;
-        private readonly global::Servers.Servers _servers;
+        #region Private Delegates, Events, Enums, Properties, Indexers and Fields
         private readonly TaskScheduler _uiTaskScheduler;
         private AboutForm _aboutForm;
                 .CreateLogger();
             // Upgrade settings if required.
             if (!ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.PerUserRoamingAndLocal).HasFile)
             {
-                if (Settings.Default.UpdateRequired)
+                if (Properties.Settings.Default.UpdateRequired)
                 {
-                    Settings.Default.Upgrade();
+                    Properties.Settings.Default.Upgrade();
-                    Settings.Default.Reload();
+                    Properties.Settings.Default.Reload();
-                    Settings.Default.UpdateRequired = false;
+                    Properties.Settings.Default.UpdateRequired = false;
-                    Settings.Default.Save();
+                    Properties.Settings.Default.Save();
                     mutex.ReleaseMutex();
                     Process.Start(Application.ExecutablePath);
                     Environment.Exit(0);
                 }
             }
-            // Bind to settings changed event.
-            Settings.Default.SettingsLoaded += Default_SettingsLoaded;
-            Settings.Default.SettingsSaving += Default_SettingsSaving;
-            Settings.Default.PropertyChanged += Default_PropertyChanged;
-            _servers = new global::Servers.Servers();
-            _servers.Server.CollectionChanged += Server_CollectionChanged;
+            // Bind to settings changed event.
-            _servers.Server.ListChanged += Server_ListChanged;
+            Properties.Settings.Default.SettingsLoaded += Default_SettingsLoaded;
-            _announcements = new Announcements.Announcements();
-            _announcements.Announcement.CollectionChanged += Announcements_CollectionChanged;
-            _announcements.Announcement.ListChanged += Announcement_ListChanged;
             Properties.Settings.Default.SettingsSaving += Default_SettingsSaving;
-            _uiTaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
+            Properties.Settings.Default.PropertyChanged += Default_PropertyChanged;
-            _gotifyConnectionManager = new GotifyConnectionManager(_servers);
+            // Store UI thread context.
-            _gotifyConnectionManager.GotifyNotification += GotifyConnectionManager_GotifyNotification;
-            LoadServers().ContinueWith(async task =>
-            {
-                var restoredServers = await task;
-                foreach (var server in restoredServers.Server)
-                {
-                    _servers.Server.Add(server);
+            _uiTaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
+            LoadServers().ContinueWith(async task =>
+            {
+                var restoredServers = await task;
-            });
                 _gotifyConnections = new ConcurrentBag<GotifyConnection>();
             LoadAnnouncements().ContinueWith(async task =>
                 foreach (var server in restoredServers.Server)
                 var restoreAnnouncements = await task;
         /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
         protected override void Dispose(bool disposing)
+        {
             if (disposing && components != null)
+            {
-                _servers.Server.CollectionChanged -= Server_CollectionChanged;
-                _announcements.Announcement.CollectionChanged -= Announcements_CollectionChanged;
-                Settings.Default.SettingsLoaded -= Default_SettingsLoaded;
+                Properties.Settings.Default.SettingsLoaded -= Default_SettingsLoaded;
-                Settings.Default.SettingsSaving -= Default_SettingsSaving;
+                Properties.Settings.Default.SettingsSaving -= Default_SettingsSaving;
-                Settings.Default.PropertyChanged -= Default_PropertyChanged;
+                Properties.Settings.Default.PropertyChanged -= Default_PropertyChanged;
-                _gotifyConnectionManager.GotifyNotification -= GotifyConnectionManager_GotifyNotification;
-                _gotifyConnectionManager?.Dispose();
-                _gotifyConnectionManager = null;
                 components.Dispose();
+            }
         #endregion
+        #region Event Handlers
+        private static void Default_PropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            Properties.Settings.Default.Save();
         #region Event Handlers
         private async void Announcement_ListChanged(object sender, ListChangedEventArgs e)
-        {
+        private static void Default_SettingsSaving(object sender, CancelEventArgs e)
             await SaveAnnouncements();
-        }
+        }
-        private async void Server_ListChanged(object sender, ListChangedEventArgs e)
         private static void Default_SettingsLoaded(object sender, SettingsLoadedEventArgs e)
+        {
+        }
+        private async void SettingsToolStripMenuItem_Click(object sender, EventArgs e)
+        {
+            if (_settingsForm != null)
-            await SaveServers();
+            {
+                return;
+            }
+            var servers = await LoadServers();
+            var announcements = await LoadAnnouncements();
+            _settingsForm = new SettingsForm(servers, announcements);
+            _settingsForm.Save += SettingsForm_Save;
+            _settingsForm.Closing += SettingsForm_Closing;
+            _settingsForm.Show();
+        }
+        private async void SettingsForm_Save(object sender, SettingsSavedEventArgs e)
+        {
+            // Save the servers.
+            await Task.WhenAll(SaveServers(e.Servers), SaveAnnouncements(e.Announcements));
+            // Update connections to gotify servers.
+            while (_gotifyConnections.TryTake(out var gotifyConnection))
+            {
+                gotifyConnection.GotifyNotification -= GotifyConnection_GotifyNotification;
+                gotifyConnection.Stop();
+                gotifyConnection.Dispose();
+                gotifyConnection = null;
+            }
+            foreach (var server in e.Servers.Server)
+            {
                 var gotifyConnection = new GotifyConnection(server);
+                gotifyConnection.GotifyNotification += GotifyConnection_GotifyNotification;
-        private async void Announcements_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+                gotifyConnection.Start();
-        {
+                _gotifyConnections.Add(gotifyConnection);
             await SaveAnnouncements();
+        }
-        }
+        private void GotifyConnection_GotifyNotification(object sender, GotifyNotificationEventArgs e)
+        {
-        private void GotifyConnectionManager_GotifyNotification(object sender, GotifyNotificationEventArgs e)
+            Task.Factory.StartNew(async () =>
+            {
+                var announcements = await LoadAnnouncements();
-            Task.Factory.StartNew(() =>
-            {
+                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 Notification(
                             $"{e.Notification.Title} ({e.Notification.Server.Name}/{e.Notification.AppId})",
-                        var configuredNotification = new Notification($"{e.Notification.Title} ({e.Notification.Server.Name}/{e.Notification.AppId})",
+                            e.Notification.Message, announcement.LingerTime, e.Image,
+                            FormAnimator.AnimationMethod.Slide,
-                            e.Notification.Message, announcement.LingerTime, e.Image, FormAnimator.AnimationMethod.Slide,
+                            FormAnimator.AnimationDirection.Up);
                             FormAnimator.AnimationDirection.Up);
                         configuredNotification.Show();
                         configuredNotification.Show();
+                        return;
-                        return;
-                    }
-                }
-                var notification = new Notification($"{e.Notification.Title} ({e.Notification.Server.Name}/{e.Notification.AppId})",
-                    e.Notification.Message, 5000, e.Image, FormAnimator.AnimationMethod.Slide,
-                    FormAnimator.AnimationDirection.Up);
-                notification.Show();
-            }, CancellationToken.None, TaskCreationOptions.None, _uiTaskScheduler);
-        }
-        private async void Server_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
-        {
-            await SaveServers();
-        }
-        private static void Default_PropertyChanged(object sender, PropertyChangedEventArgs e)
-        {
-            Settings.Default.Save();
-        }
-        private static void Default_SettingsSaving(object sender, CancelEventArgs e)
-        {
-        }
-        private static void Default_SettingsLoaded(object sender, SettingsLoadedEventArgs e)
-        {
-        }
         private void SettingsToolStripMenuItem_Click(object sender, EventArgs e)
+                }
             if (_settingsForm != null)
                 var notification = new Notification(
-                return;
+                    $"{e.Notification.Title} ({e.Notification.Server.Name}/{e.Notification.AppId})",
                     e.Notification.Message, 5000, e.Image, FormAnimator.AnimationMethod.Slide,
                     FormAnimator.AnimationDirection.Up);
-            _settingsForm = new SettingsForm(_servers, _announcements);
+                notification.Show();
-            _settingsForm.Closing += SettingsForm_Closing;
+            }, CancellationToken.None, TaskCreationOptions.LongRunning, _uiTaskScheduler);
             _settingsForm.Show();
         #endregion
         #region Private Methods
-        private async Task SaveAnnouncements()
+        private static async Task SaveAnnouncements(Announcements.Announcements announcements)
+        {
-            switch (await ServersSerialization.Serialize(_announcements, Constants.NotificationsFile, "Announcements",
+            switch (await ServersSerialization.Serialize(announcements, Constants.AnnouncementsFile, "Announcements",
                 "<!ATTLIST Announcements xmlns:xsi CDATA #IMPLIED xsi:noNamespaceSchemaLocation CDATA #IMPLIED>"))
+            {
                 case SerializationFailure serializationFailure:
                     Log.Warning(serializationFailure.Exception, "Unable to serialize announcements.");
                     break;
+            }
+        }
-        private async Task SaveServers()
+        private static async Task SaveServers(global::Servers.Servers servers)
+        {
             // Encrypt password for all servers.
             var deviceId = Miscellaneous.GetMachineGuid();
             var @protected = new global::Servers.Servers
+            {
                 Server = new BindingListWithCollectionChanged<Server>()
             };
-            foreach (var server in _servers.Server)
+            foreach (var server in servers.Server)
+            {
                 Directory.CreateDirectory(Constants.UserApplicationDirectory);
+            }
             var deserializationResult =
-                await ServersSerialization.Deserialize<Announcements.Announcements>(Constants.NotificationsFile,
+                await ServersSerialization.Deserialize<Announcements.Announcements>(Constants.AnnouncementsFile,
                     "urn:winify-announcements-schema", "Announcements.xsd");
             switch (deserializationResult)