UserSettingsBase.cs

/* Settings.cs
 * part of Bovender framework
 * 
 * Copyright 2014-2018 Daniel Kraus
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using YamlDotNet.Core;
using YamlDotNet.Serialization;

namespace Bovender.UserSettings
{
    public class UserSettingsBase
    {
        #region Singleton

        public static UserSettingsBase Default
        {
            get
            {
                return _lazy.Value;
            }
            set
            {
                _lazy = new Lazy<UserSettingsBase>(() => value);
            }
        }

        private static Lazy<UserSettingsBase> _lazy = new Lazy<UserSettingsBase>(() => new UserSettingsBase());

        #endregion

        #region Factory

        protected static T FromFileOrDefault<T>(string yamlFile, DeserializerBuilder deserializerBuilder)
            where T: UserSettingsBase, new()
        {
            if (deserializerBuilder == null)
          {
            throw new ArgumentNullException("deserializerBuilder",
                    "Must provide a DeserializerBuilder object to load settings.");
          }
            T optionsStore = null;
            if (File.Exists(yamlFile))
            {
                try
                {
                    using (FileStream fs = File.Open(yamlFile, FileMode.Open, FileAccess.Read, FileShare.Read))
                    {
                        StreamReader sr = new StreamReader(fs);
                        Deserializer des = deserializerBuilder.Build();
                        optionsStore = des.Deserialize<T>(sr);
                        if (optionsStore != null)
                        {
                            optionsStore.WasFromFile = true;
                        }
                    }
                    Logger.Info("Loaded user settings from file '{0}'", yamlFile);
                }
                catch (IOException e)
                {
                    optionsStore = CreateDefaultOnException<T>(e);
                }
                catch (YamlException e)
                {
                    optionsStore = CreateDefaultOnException<T>(e);
                }
            }
            if (optionsStore == null)
          {
                Logger.Info("Creating user settings object from scratch");
                optionsStore = new T();
          }
            return optionsStore;
        }

        protected static T FromFileOrDefault<T>(string yamlFile)
            where T : UserSettingsBase, new()
        {
            return FromFileOrDefault<T>(yamlFile, new DeserializerBuilder().IgnoreUnmatchedProperties());
        }

        #endregion

        #region User settings

        public string User
        {
            get
            {
                if (_user == null)
                {
                    _user = "";
                }
                return _user;
            }
            set
            {
                _user = value;
            }
        }

        public string Email
        {
            get
            {
                if (_email == null)
                {
                    _email = "";
                }
                return _email;
            }
            set
            {
                _email = value;
            }
        }

        public bool CcUserOnExceptionReport
        {
            get
            {
                if (_ccUserOnExceptionReport == null)
                {
                    _ccUserOnExceptionReport = true;
                }
                return (bool)_ccUserOnExceptionReport;
            }
            set
            {
                _ccUserOnExceptionReport = value;
            }
        }

        public string DownloadFolder
        {
            get
            {
                if (_downloadFolder == null)
                {
                    _downloadFolder = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
                }
                return _downloadFolder;
            }
            set
            {
                _downloadFolder = value;
            }
        }

        #endregion

        #region Public static methods

        public static void LoadDefaults()
        {
            _lazy = new Lazy<UserSettingsBase>(() => new UserSettingsBase());
        }

        #endregion

        #region Properties that are not being saved to the YAML file

        [YamlIgnore]
        public bool WasFromFile { get; protected set; }

        [YamlIgnore]
        public Exception Exception { get; protected set; }

        #endregion

        #region Constructor

        public UserSettingsBase() { }
        
        #endregion

        #region Save to file

        public void Save()
        {
            try
            {
                string fn = GetSettingsFilePath();
                Directory.CreateDirectory(System.IO.Path.GetDirectoryName(fn));
                using (FileStream fs = File.Open(fn, FileMode.Create, FileAccess.Write))
                {
                    StreamWriter sw = new StreamWriter(fs, Encoding.UTF8);
                    WriteYamlHeader(sw);
                    Serializer ser = ConstructSerializerBuilder().Build();
                    ser.Serialize(sw, this);
                    sw.Flush();
                }
                Exception = null;
                Logger.Info("Saved user settings to file '{0}'", fn);
            }
            catch (IOException e)
            {
                Logger.Warn("Could not save user settings", e);
                Exception = e;
            }
        }

        protected virtual SerializerBuilder ConstructSerializerBuilder()
        {
            return new SerializerBuilder();
        }

        public virtual string GetSettingsFilePath()
        {
            return System.IO.Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
                Properties.Settings.Default.UserSettingsPath,
                Properties.Settings.Default.UserSettingsFile);
        }

        protected virtual void WriteYamlHeader(StreamWriter streamWriter)
        {
            streamWriter.WriteLine("# !!! DO NOT EDIT THIS FILE WHILE THE APPLICATION IS RUNNING !!!");
        }
        
        #endregion

        #region Private fields

        private string _user;
        private string _email;

        private bool? _ccUserOnExceptionReport;

        private string _downloadFolder;

        #endregion

        #region Private static method

        private static T CreateDefaultOnException<T>(Exception e)
            where T: UserSettingsBase, new()
        {
            Logger.Warn(e, "Exception during loading of user settings, using default");
            T options = new T();
            options.Exception = e;
            return options;
        }

        #endregion

        #region Class logger

        private static NLog.Logger Logger { get { return _logger.Value; } }

        private static readonly Lazy<NLog.Logger> _logger = new Lazy<NLog.Logger>(() => NLog.LogManager.GetCurrentClassLogger());

        #endregion
    }
}