Winify – Diff between revs 14 and 15

Subversion Repositories:

?pathlinks?

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

 using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Configuration;
 using System.Diagnostics;
 using System.IO;
+using System.Text;
 using System.Threading.Tasks;
 using System.Windows.Forms;
 using AutoUpdaterDotNET;
+using Servers;
 using Winify.Gotify;
 using Winify.Properties;
 using Winify.Servers.Serialization;
+using Winify.Utilities;
 namespace Winify
+{
     public partial class Form1 : Form
+    {
+        #region Private Delegates, Events, Enums, Properties, Indexers and Fields
-        #region Private Delegates, Events, Enums, Properties, Indexers and Fields
+        private readonly Announcements.Announcements _notifications;
         private readonly global::Servers.Servers _servers;
             Settings.Default.SettingsSaving += Default_SettingsSaving;
             Settings.Default.PropertyChanged += Default_PropertyChanged;
             _servers = new global::Servers.Servers();
+            _servers.Server.CollectionChanged += Server_CollectionChanged;
+            _notifications = new Announcements.Announcements();
-            _servers.Server.CollectionChanged += Server_CollectionChanged;
+            _notifications.Announcement.CollectionChanged += Announcements_CollectionChanged;
                 foreach (var server in restoredServers.Server)
+                {
                     _servers.Server.Add(server);
+                }
             });
+            LoadAnnouncements().ContinueWith(async task =>
+            {
+                var restoreAnnouncements = await task;
+                foreach (var announcement in restoreAnnouncements.Announcement)
+                {
+                    _notifications.Announcement.Add(announcement);
+                }
+            });
+        }
         /// <summary>
         ///     Clean up any resources being used.
         protected override void Dispose(bool disposing)
+        {
             if (disposing && components != null)
+            {
                 _servers.Server.CollectionChanged -= Server_CollectionChanged;
+                _notifications.Announcement.CollectionChanged -= Announcements_CollectionChanged;
                 Settings.Default.SettingsLoaded -= Default_SettingsLoaded;
                 Settings.Default.SettingsSaving -= Default_SettingsSaving;
         #endregion
+        #region Event Handlers
+        private async void Announcements_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            switch (await ServersSerialization.Serialize(_notifications, Constants.NotificationsFile, "Announcements",
+                "<!ATTLIST Announcements xmlns:xsi CDATA #IMPLIED xsi:noNamespaceSchemaLocation CDATA #IMPLIED>"))
+            {
+                case SerializationFailure serializationFailure:
+                    Debug.WriteLine(serializationFailure.Exception.Message);
+                    break;
+            }
         #region Event Handlers
         private void GotifyConnectionManager_GotifyNotification(object sender, GotifyNotificationEventArgs e)
+        {
-            _notificationManager.ShowNotification(e);
+            _notificationManager.ShowNotification(e, _notifications);
+        }
+        private async void Server_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            // 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)
+            {
+                var encrypted = AES.Encrypt(Encoding.UTF8.GetBytes(server.Password), deviceId);
+                var armored = Convert.ToBase64String(encrypted);
-        }
+                @protected.Server.Add(new Server(server.Name, server.Url, server.Username, armored));
+            }
-        private async void Server_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
             switch (await ServersSerialization.Serialize(@protected, Constants.ServersFile, "Servers",
-            switch (await ServersSerialization.Serialize(_servers, Constants.ServersFile))
+                "<!ATTLIST Servers xmlns:xsi CDATA #IMPLIED xsi:noNamespaceSchemaLocation CDATA #IMPLIED>"))
+            {
-                case ServersSerializationFailure serializationFailure:
+                case SerializationFailure serializationFailure:
             if (_settingsForm != null)
+            {
                 return;
+            }
-            _settingsForm = new SettingsForm(_servers);
+            _settingsForm = new SettingsForm(_servers, _notifications);
             _settingsForm.Closing += SettingsForm_Closing;
             _settingsForm.Show();
+        }
         #endregion
+        #region Private Methods
+        private static async Task<Announcements.Announcements> LoadAnnouncements()
+        {
+            if (!Directory.Exists(Constants.UserApplicationDirectory))
+            {
+                Directory.CreateDirectory(Constants.UserApplicationDirectory);
+            }
+            var deserializationResult =
+                await ServersSerialization.Deserialize<Announcements.Announcements>(Constants.NotificationsFile,
+                    "urn:winify-announcements-schema", "Announcements.xsd");
+            switch (deserializationResult)
+            {
+                case SerializationSuccess<Announcements.Announcements> serializationSuccess:
+                    return serializationSuccess.Result;
+                default:
+                    return new Announcements.Announcements();
+            }
         #region Private Methods
         private static async Task<global::Servers.Servers> LoadServers()
+        {
             if (!Directory.Exists(Constants.UserApplicationDirectory))
+            {
-            {
+                Directory.CreateDirectory(Constants.UserApplicationDirectory);
+            }
                 Directory.CreateDirectory(Constants.UserApplicationDirectory);
             var deserializationResult =
+                await ServersSerialization.Deserialize<global::Servers.Servers>(Constants.ServersFile,
+                    "urn:winify-servers-schema", "Servers.xsd");
+            switch (deserializationResult)
+            {
+                case SerializationSuccess<global::Servers.Servers> serializationSuccess:
+                    // Decrypt password.
-            var deserializationResult = await ServersSerialization.Deserialize(Constants.ServersFile);
+                    var deviceId = Miscellaneous.GetMachineGuid();
+                    var @protected = new global::Servers.Servers
+                    {
+                        Server = new BindingListWithCollectionChanged<Server>()
+                    };
+                    foreach (var server in serializationSuccess.Result.Server)
+                    {
+                        var unarmored = Convert.FromBase64String(server.Password);
+                        var decrypted = Encoding.UTF8.GetString(AES.Decrypt(unarmored, deviceId));
-            switch (deserializationResult)
+                        @protected.Server.Add(new Server(server.Name, server.Url, server.Username, decrypted));
+                    }
                 case ServersSerializationSuccess serializationSuccess: