Gary Sharp
473 lines
17 KiB
C#
473 lines
17 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using Disco.Data.Repository;
|
|
using Disco.Models.Repository;
|
|
using System.IO;
|
|
using System.Security.Cryptography;
|
|
using Disco.Models.BI.Interop.Community;
|
|
using Newtonsoft.Json;
|
|
|
|
namespace Disco.Data.Configuration
|
|
{
|
|
public class ConfigurationContext
|
|
{
|
|
private DiscoDataContext _dbContext;
|
|
private DiscoDataContext dbContext
|
|
{
|
|
get
|
|
{
|
|
if (_dbContext != null)
|
|
return _dbContext;
|
|
else
|
|
throw new InvalidOperationException("Cache-miss where Configuration Item requested from Cache-Only Configuration Context");
|
|
}
|
|
}
|
|
|
|
public bool CacheOnly
|
|
{
|
|
get
|
|
{
|
|
return _dbContext == null;
|
|
}
|
|
}
|
|
|
|
public ConfigurationContext(DiscoDataContext dbContext)
|
|
{
|
|
this._dbContext = dbContext;
|
|
|
|
// Init Modules
|
|
this.moduleBootstrapperConfiguration = new Lazy<Modules.BootstrapperConfiguration>(() => new Modules.BootstrapperConfiguration(this));
|
|
this.moduleDeviceProfilesConfiguration = new Lazy<Modules.DeviceProfilesConfiguration>(() => new Modules.DeviceProfilesConfiguration(this));
|
|
this.moduleOrganisationAddressesConfiguration = new Lazy<Modules.OrganisationAddressesConfiguration>(() => new Modules.OrganisationAddressesConfiguration(this));
|
|
this.moduleWirelessConfiguration = new Lazy<Modules.WirelessConfiguration>(() => new Modules.WirelessConfiguration(this));
|
|
}
|
|
|
|
#region Item Cache
|
|
|
|
private static Dictionary<String, Dictionary<String, ConfigurationItem>> configDictionary = new Dictionary<string, Dictionary<string, ConfigurationItem>>();
|
|
private static List<ConfigurationItem> configurationItems = new List<ConfigurationItem>();
|
|
private static object configurationItemsLock = new object();
|
|
|
|
private void loadConfigurationItems(string Scope, bool Reload)
|
|
{
|
|
if (Reload || !configDictionary.ContainsKey(Scope))
|
|
{
|
|
lock (configurationItemsLock)
|
|
{
|
|
if (Reload || !configDictionary.ContainsKey(Scope))
|
|
{
|
|
var newItems = this.dbContext.ConfigurationItems.Where(ci => ci.Scope == Scope).ToArray();
|
|
|
|
if (configDictionary.ContainsKey(Scope))
|
|
{
|
|
var existingItems = configDictionary[Scope];
|
|
foreach (var existingItem in existingItems.Values)
|
|
{
|
|
configurationItems.Remove(existingItem);
|
|
}
|
|
}
|
|
configurationItems.AddRange(newItems);
|
|
configDictionary[Scope] = newItems.ToDictionary(ci => ci.Key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public Dictionary<string, Dictionary<string, ConfigurationItem>> ConfigurationDictionary(string IncludingScope)
|
|
{
|
|
this.loadConfigurationItems(IncludingScope, false);
|
|
return configDictionary;
|
|
}
|
|
public ConfigurationItem ConfigurationItem(string Scope, string Key)
|
|
{
|
|
Dictionary<string, ConfigurationItem> scopeDict = default(Dictionary<string, ConfigurationItem>);
|
|
if (this.ConfigurationDictionary(Scope).TryGetValue(Scope, out scopeDict))
|
|
{
|
|
ConfigurationItem item = default(ConfigurationItem);
|
|
if (scopeDict.TryGetValue(Key, out item))
|
|
return item;
|
|
}
|
|
return null;
|
|
}
|
|
private List<ConfigurationItem> ConfigurationItems(string IncludingScope)
|
|
{
|
|
this.loadConfigurationItems(IncludingScope, false);
|
|
return configurationItems;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Helpers
|
|
public ValueType GetConfigurationValue<ValueType>(string Scope, string Key, ValueType Default)
|
|
{
|
|
var ci = this.ConfigurationItem(Scope, Key);
|
|
if (ci == null)
|
|
return Default;
|
|
else
|
|
return (ValueType)Convert.ChangeType(ci.Value, typeof(ValueType));
|
|
}
|
|
public void SetConfigurationValue<ValueType>(string Scope, string Key, ValueType Value)
|
|
{
|
|
if (CacheOnly)
|
|
throw new InvalidOperationException("Cannot save changes with a CacheOnly Context");
|
|
|
|
var ci = this.ConfigurationItem(Scope, Key);
|
|
if (ci == null && Value != null)
|
|
{
|
|
lock (configurationItemsLock)
|
|
{
|
|
ci = this.ConfigurationItem(Scope, Key);
|
|
if (ci == null)
|
|
{
|
|
// Create Configuration Item
|
|
ci = new ConfigurationItem() { Scope = Scope, Key = Key, Value = Value.ToString() };
|
|
// Add Item to DB & Internal Collections
|
|
this.dbContext.ConfigurationItems.Add(ci);
|
|
this.ConfigurationItems(Scope).Add(ci);
|
|
this.ConfigurationDictionary(Scope)[Scope].Add(Key, ci);
|
|
ci = null;
|
|
}
|
|
}
|
|
}
|
|
if (ci != null)
|
|
{
|
|
lock (configurationItemsLock)
|
|
{
|
|
var entityInfo = dbContext.Entry(ci);
|
|
if (entityInfo.State == System.Data.EntityState.Detached)
|
|
{
|
|
// Reload Scope from DB
|
|
this.loadConfigurationItems(Scope, true);
|
|
ci = this.ConfigurationItem(Scope, Key);
|
|
}
|
|
|
|
if (Value == null)
|
|
{
|
|
dbContext.ConfigurationItems.Remove(ci);
|
|
configurationItems.Remove(ci);
|
|
configDictionary[Scope].Remove(Key);
|
|
}
|
|
else
|
|
{
|
|
ci.Value = Value.ToString();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static string ObsfucateValue(string Value)
|
|
{
|
|
if (string.IsNullOrEmpty(Value))
|
|
return Value;
|
|
else
|
|
return Convert.ToBase64String(Encoding.Unicode.GetBytes(Value));
|
|
}
|
|
public static string DeobsfucateValue(string ObsfucatedValue)
|
|
{
|
|
if (string.IsNullOrEmpty(ObsfucatedValue))
|
|
return ObsfucatedValue;
|
|
else
|
|
return Encoding.Unicode.GetString(Convert.FromBase64String(ObsfucatedValue));
|
|
}
|
|
#endregion
|
|
|
|
#region Configuration Modules
|
|
|
|
private Lazy<Modules.BootstrapperConfiguration> moduleBootstrapperConfiguration;
|
|
private Lazy<Modules.DeviceProfilesConfiguration> moduleDeviceProfilesConfiguration;
|
|
private Lazy<Modules.OrganisationAddressesConfiguration> moduleOrganisationAddressesConfiguration;
|
|
private Lazy<Modules.WirelessConfiguration> moduleWirelessConfiguration;
|
|
|
|
public Modules.BootstrapperConfiguration Bootstrapper
|
|
{
|
|
get
|
|
{
|
|
return moduleBootstrapperConfiguration.Value;
|
|
}
|
|
}
|
|
public Modules.DeviceProfilesConfiguration DeviceProfiles
|
|
{
|
|
get
|
|
{
|
|
return moduleDeviceProfilesConfiguration.Value;
|
|
}
|
|
}
|
|
public Modules.OrganisationAddressesConfiguration OrganisationAddresses
|
|
{
|
|
get
|
|
{
|
|
return moduleOrganisationAddressesConfiguration.Value;
|
|
}
|
|
}
|
|
public Modules.WirelessConfiguration Wireless
|
|
{
|
|
get
|
|
{
|
|
return moduleWirelessConfiguration.Value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region System Configuration Items
|
|
|
|
public string Scope { get { return "System"; } }
|
|
|
|
public string DataStoreLocation
|
|
{
|
|
get
|
|
{
|
|
var result = this.GetConfigurationValue<string>(this.Scope, "DataStoreLocation", null);
|
|
if (result == null)
|
|
{
|
|
var appDataPath = System.Web.HttpContext.Current.Server.MapPath("~/App_Data");
|
|
if (appDataPath.EndsWith("\\"))
|
|
return appDataPath;
|
|
else
|
|
return string.Concat(appDataPath, '\\');
|
|
}
|
|
else
|
|
return result;
|
|
}
|
|
set
|
|
{
|
|
if (value == null)
|
|
throw new ArgumentNullException("value");
|
|
if (!System.IO.Directory.Exists(value))
|
|
throw new System.IO.DirectoryNotFoundException(string.Format("DataStoreLocation: '{0}' could not be found", value));
|
|
string storePath;
|
|
if (value.EndsWith("\\"))
|
|
storePath = value;
|
|
else
|
|
storePath = string.Concat(value, '\\');
|
|
this.SetConfigurationValue(this.Scope, "DataStoreLocation", storePath);
|
|
}
|
|
}
|
|
public string PluginsLocation
|
|
{
|
|
get
|
|
{
|
|
return System.IO.Path.Combine(this.DataStoreLocation, @"Plugins\");
|
|
}
|
|
}
|
|
public string PluginStorageLocation
|
|
{
|
|
get
|
|
{
|
|
return System.IO.Path.Combine(this.DataStoreLocation, @"PluginStorage\");
|
|
}
|
|
}
|
|
#region Organisation Logo
|
|
private string OrganisationLogoPath
|
|
{
|
|
get
|
|
{
|
|
return System.IO.Path.Combine(DataStoreLocation, "OrganisationLogo.png");
|
|
}
|
|
}
|
|
//private static string _OrganisationLogoHash;
|
|
//private static byte[] _OrganisationLogo;
|
|
//private static object _OrganisationLogoLock = new object();
|
|
//private static void LoadOrganisationLogo(ConfigurationContext context, bool reload = false)
|
|
//{
|
|
// if (_OrganisationLogoHash == null || reload)
|
|
// {
|
|
// lock (_OrganisationLogoLock)
|
|
// {
|
|
// if (_OrganisationLogoHash == null || reload)
|
|
// {
|
|
// _OrganisationLogo = null;
|
|
// _OrganisationLogoHash = null;
|
|
|
|
// string organisationLogoPath = context.OrganisationLogoPath;
|
|
// if (System.IO.File.Exists(organisationLogoPath))
|
|
// _OrganisationLogo = System.IO.File.ReadAllBytes(organisationLogoPath);
|
|
// }
|
|
// if (_OrganisationLogo == null || _OrganisationLogo.Length == 0)
|
|
// {
|
|
// _OrganisationLogo = Disco.Data.Properties.Resources.EmptyLogo;
|
|
// }
|
|
// if (_OrganisationLogoHash == null)
|
|
// {
|
|
// using (SHA256 h = SHA256.Create())
|
|
// {
|
|
// _OrganisationLogoHash = Convert.ToBase64String(h.ComputeHash(_OrganisationLogo));
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
//}
|
|
public string OrganisationLogoHash
|
|
{
|
|
get
|
|
{
|
|
var path = this.OrganisationLogoPath;
|
|
if (File.Exists(path))
|
|
return File.GetLastWriteTimeUtc(path).ToBinary().ToString();
|
|
else
|
|
return "-1";
|
|
}
|
|
}
|
|
public Stream OrganisationLogo
|
|
{
|
|
get
|
|
{
|
|
//LoadOrganisationLogo(this);
|
|
//if (_OrganisationLogo == null || _OrganisationLogo.Length != 0)
|
|
// return new MemoryStream(_OrganisationLogo);
|
|
//else
|
|
// return null;
|
|
var path = this.OrganisationLogoPath;
|
|
if (File.Exists(path))
|
|
return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
|
|
else
|
|
return new MemoryStream(Disco.Data.Properties.Resources.EmptyLogo);
|
|
}
|
|
set
|
|
{
|
|
string organisationLogoPath = this.OrganisationLogoPath;
|
|
if (value == null)
|
|
{
|
|
if (System.IO.File.Exists(organisationLogoPath))
|
|
System.IO.File.Delete(organisationLogoPath);
|
|
}
|
|
else
|
|
{
|
|
using (FileStream fs = new FileStream(organisationLogoPath, FileMode.Create, FileAccess.Write, FileShare.None))
|
|
{
|
|
value.CopyTo(fs);
|
|
}
|
|
}
|
|
//LoadOrganisationLogo(this, true);
|
|
}
|
|
}
|
|
#endregion
|
|
public string OrganisationName
|
|
{
|
|
get
|
|
{
|
|
return this.GetConfigurationValue<string>(this.Scope, "OrganisationName", null);
|
|
}
|
|
set
|
|
{
|
|
this.SetConfigurationValue(this.Scope, "OrganisationName", value);
|
|
}
|
|
}
|
|
public bool MultiSiteMode
|
|
{
|
|
get
|
|
{
|
|
return this.GetConfigurationValue<bool>(this.Scope, "MultiSiteMode", false);
|
|
}
|
|
set
|
|
{
|
|
this.SetConfigurationValue(this.Scope, "MultiSiteMode", value);
|
|
}
|
|
}
|
|
|
|
#region Proxy Configuration
|
|
public string ProxyAddress
|
|
{
|
|
get
|
|
{
|
|
return this.GetConfigurationValue<string>(this.Scope, "ProxyAddress", null);
|
|
}
|
|
set
|
|
{
|
|
this.SetConfigurationValue(this.Scope, "ProxyAddress", value);
|
|
}
|
|
}
|
|
public int ProxyPort
|
|
{
|
|
get
|
|
{
|
|
return this.GetConfigurationValue(this.Scope, "ProxyPort", 8080);
|
|
}
|
|
set
|
|
{
|
|
this.SetConfigurationValue(this.Scope, "ProxyPort", value);
|
|
}
|
|
}
|
|
public string ProxyUsername
|
|
{
|
|
get
|
|
{
|
|
return this.GetConfigurationValue<string>(this.Scope, "ProxyUsername", null);
|
|
}
|
|
set
|
|
{
|
|
this.SetConfigurationValue(this.Scope, "ProxyUsername", value);
|
|
}
|
|
}
|
|
public string ProxyPassword
|
|
{
|
|
get
|
|
{
|
|
return DeobsfucateValue(this.GetConfigurationValue<string>(this.Scope, "ProxyPassword", null));
|
|
}
|
|
set
|
|
{
|
|
this.SetConfigurationValue(this.Scope, "ProxyPassword", ObsfucateValue(value));
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region UpdateCheck
|
|
public string DeploymentId
|
|
{
|
|
get
|
|
{
|
|
return this.GetConfigurationValue<string>(this.Scope, "DeploymentId", null);
|
|
}
|
|
}
|
|
public UpdateResponse UpdateLastCheck
|
|
{
|
|
get
|
|
{
|
|
var json = this.GetConfigurationValue<string>(this.Scope, "UpdateLastCheck", null);
|
|
if (json != null)
|
|
{
|
|
try
|
|
{
|
|
return JsonConvert.DeserializeObject<UpdateResponse>(json);
|
|
}
|
|
catch (Exception)
|
|
{ }// Ignore Serialization Issues
|
|
}
|
|
return null;
|
|
}
|
|
set
|
|
{
|
|
if (value == null)
|
|
this.SetConfigurationValue<string>(this.Scope, "UpdateLastCheck", null);
|
|
|
|
var json = JsonConvert.SerializeObject(value);
|
|
this.SetConfigurationValue<string>(this.Scope, "UpdateLastCheck", json);
|
|
}
|
|
}
|
|
public bool UpdateBetaDeployment
|
|
{
|
|
get
|
|
{
|
|
return this.GetConfigurationValue<bool>(this.Scope, "UpdateBetaDeployment", false);
|
|
}
|
|
}
|
|
public string InstalledDatabaseVersion
|
|
{
|
|
get
|
|
{
|
|
return this.GetConfigurationValue<string>(this.Scope, "InstalledDatabaseVersion", null);
|
|
}
|
|
set
|
|
{
|
|
this.SetConfigurationValue<string>(this.Scope, "InstalledDatabaseVersion", value);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|