/// <summary>
/// Set the values for a handler
/// </summary>
private void SetHandlerValues(XElement node, HandlerSettings handler, uSyncSettings defaultSettings)
{
node.SetAttributeValue("Alias", handler.Alias);
node.SetAttributeValue("Enabled", handler.Enabled);
if (handler.GuidNames.IsOverridden)
{
node.SetAttributeValue("GuidNames", handler.GuidNames.Value);
}
if (handler.UseFlatStructure.IsOverridden)
{
node.SetAttributeValue("UseFlatStructure", handler.UseFlatStructure.Value);
}
if (handler.FailOnMissingParent.IsOverridden)
{
node.SetAttributeValue("FailOnMissingParent", handler.FailOnMissingParent.Value);
}
node.SetAttributeValue("Actions", string.Join(",", handler.Actions));
if (handler.Settings != null && handler.Settings.Count > 0)
{
foreach (var setting in handler.Settings)
{
var s = node.FindOrCreate("Add", "Key", setting.Key);
s.SetAttributeValue("Value", setting.Value);
}
node.RemoveMissingElements("Add", "Key", handler.Settings.Keys.ToList());
}
}
/// <summary>
/// load hte config for a single handler.
/// </summary>
public HandlerSettings LoadHandlerConfig(XElement node, uSyncSettings defaultSettings)
{
if (node == null)
{
return(null);
}
var alias = node.Attribute("Alias").ValueOrDefault(string.Empty);
if (string.IsNullOrEmpty(alias))
{
return(null);
}
var enabled = node.Attribute("Enabled").ValueOrDefault(true);
var settings = new HandlerSettings(alias, enabled);
// these values can be set locally, but if they aren't
// we get them from the global setting.
settings.GuidNames = GetLocalValue(node.Attribute("GuidNames"), defaultSettings.UseGuidNames);
settings.UseFlatStructure = GetLocalValue(node.Attribute("UseFlatStructure"), defaultSettings.UseFlatStructure);
settings.Actions = node.Attribute("Actions").ValueOrDefault("All").ToDelimitedList().ToArray();
settings.FailOnMissingParent = GetLocalValue(node.Attribute("FailOnMissingParent"), defaultSettings.FailOnMissingParent);
settings.Group = node.Attribute("Group").ValueOrDefault(string.Empty);
// handlers can have their own individual settings beneath a node
//
// <Handler Alias="simple" ... >
// <Add Key="settingName" Value="settingValue" />
// </Handler>
//
// These get added to a Settings dictionary for the handler, so it
// can access them as needed (v8.7+ also passed to serializers)
//
var perHandlerSettings = new Dictionary <string, string>();
// merge in the defaults
if (defaultSettings.DefaultHandlerSettings != null)
{
defaultSettings.DefaultHandlerSettings.ToList()
.ForEach(x => perHandlerSettings[x.Key] = x.Value);
}
// merge in the handler.
var handlerSettings = LoadKeyValueSettings(node);
if (handlerSettings != null)
{
handlerSettings.ToList()
.ForEach(x => perHandlerSettings[x.Key] = x.Value);
}
settings.Settings = perHandlerSettings;
return(settings);
}
/// <summary>
/// Save the settings to disk.
/// </summary>
/// <param name="settings"></param>
/// <param name="fireReload"></param>
/// <returns></returns>
public uSyncSettings SaveSettings(uSyncSettings settings, bool fireReload = false)
{
var node = GetSettingsFile(true);
node.CreateOrSetElement("Folder", settings.SettingsFolder);
node.CreateOrSetElement("FlatFolders", settings.UseFlatStructure);
node.CreateOrSetElement("ImportAtStartup", settings.ImportAtStartup);
node.CreateOrSetElement("ExportAtStartup", settings.ExportAtStartup);
node.CreateOrSetElement("ExportOnSave", settings.ExportOnSave);
node.CreateOrSetElement("UseGuidFilenames", settings.UseGuidNames);
node.CreateOrSetElement("ReportDebug", settings.ReportDebug);
node.CreateOrSetElement("RebuildCacheOnCompletion", settings.RebuildCacheOnCompletion);
node.CreateOrSetElement("FailOnMissingParent", settings.FailOnMissingParent);
node.CreateOrSetElement("ShowVersionCheckWarning", settings.ShowVersionCheckWarning);
node.CreateOrSetElement("EnableHistory", settings.EnableHistory);
if (settings.HandlerSets.Count > 0)
{
// remove the existing handlerSets node?
var handlerSets = node.FindOrCreate("HandlerSets");
handlerSets.SetAttributeValue("Default", settings.DefaultSet);
foreach (var set in settings.HandlerSets)
{
// find the handler node for this set.
var setNode = handlerSets.FindOrCreate("Handlers", "Name", set.Name);
foreach (var handler in set.Handlers)
{
var handlerNode = setNode.FindOrCreate("Handler", "Alias", handler.Alias);
SetHandlerValues(handlerNode, handler, settings);
}
// remove and missing handlers (so on disk but not in settings)
setNode.RemoveMissingElements("Handler", "Alias", set.Handlers.Select(x => x.Alias));
}
// remove missing HandlerSets (on disk not in settings)
handlerSets.RemoveMissingElements("Handlers", "Name", settings.HandlerSets.Select(x => x.Name));
var legacyNode = node.Element("Handlers");
if (legacyNode != null)
{
legacyNode.Remove();
}
}
SaveSettingsFile(node);
if (fireReload)
{
this.Settings = LoadSettings();
}
return(settings);
}
public void SaveHandlerConfig(XElement node, HandlerSettings config, uSyncSettings globalSettings)
{
if (node == null)
{
return;
}
node.SetAttributeValue("Alias", config.Alias);
node.SetAttributeValue("Enabled", config.Enabled);
if (config.GuidNames.IsOverridden)
{
node.SetAttributeValue("GuidNames", config.GuidNames);
}
if (config.UseFlatStructure.IsOverridden)
{
node.SetAttributeValue("UseFlatStructure", config.UseFlatStructure);
}
if (config.BatchSave.IsOverridden)
{
node.SetAttributeValue("BatchSave", config.BatchSave);
}
if (config.FailOnMissingParent.IsOverridden)
{
node.SetAttributeValue("FailOnMissingParent", config.FailOnMissingParent);
}
if (config.Actions.Length > 0 && !(config.Actions.Length == 1 && config.Actions[0].InvariantEquals("all")))
{
node.SetAttributeValue("Actions", string.Join(",", config.Actions));
}
if (config.Settings != null && config.Settings.Any())
{
var settingNode = new XElement("Settings");
foreach (var setting in config.Settings)
{
settingNode.Add(new XElement("Add",
new XAttribute("Key", setting.Key),
new XAttribute("Value", setting.Value)));
}
var existing = node.Element("Settings");
if (existing != null)
{
existing.Remove();
}
node.Add(settingNode);
}
}
/// <summary>
/// Load the usync settings from disk.
/// </summary>
public uSyncSettings LoadSettings()
{
uSyncSettings settings = new uSyncSettings();
var node = GetSettingsFile();
if (node == null)
{
logger.Warn <uSyncConfig>($"Failed to load the {uSyncBackOfficeConstants.ConfigFile} file from disk, working with defaults.");
return(SaveSettings(settings));
}
settings.RootFolder = ValueFromWebConfigOrDefault("Folder", node.Element("Folder").ValueOrDefault(settings.RootFolder));
settings.UseFlatStructure = ValueFromWebConfigOrDefault("FlatFolders", node.Element("FlatFolders").ValueOrDefault(true));
settings.ImportAtStartup = ValueFromWebConfigOrDefault("ImportAtStartup", node.Element("ImportAtStartup").ValueOrDefault(true));
settings.ExportAtStartup = ValueFromWebConfigOrDefault("ExportAtStartup", node.Element("ExportAtStartup").ValueOrDefault(false));
settings.ExportOnSave = ValueFromWebConfigOrDefault("ExportOnSave", node.Element("ExportOnSave").ValueOrDefault(true));
settings.UseGuidNames = ValueFromWebConfigOrDefault("UseGuidFilenames", node.Element("UseGuidFilenames").ValueOrDefault(false));
settings.ReportDebug = node.Element("ReportDebug").ValueOrDefault(false);
settings.AddOnPing = node.Element("AddOnPing").ValueOrDefault(true);
settings.RebuildCacheOnCompletion = node.Element("RebuildCacheOnCompletion").ValueOrDefault(false);
settings.FailOnMissingParent = node.Element("FailOnMissingParent").ValueOrDefault(true);
settings.CacheFolderKeys = node.Element("CacheFolderKeys").ValueOrDefault(true);
// load the handlers
var handlerSets = node.Element("HandlerSets");
if (handlerSets != null)
{
settings.HandlerSets = LoadHandlerSets(handlerSets, settings, out string defaultSet);
settings.DefaultSet = defaultSet;
}
else
{
var handlers = node.Element("Handlers");
if (handlers != null)
{
// old config, load as default :(
settings.HandlerSets = new List <HandlerSet>();
var defaultSet = LoadSingleHandlerSet(handlers, settings);
settings.HandlerSets.Add(defaultSet);
}
}
settings.CustomMappings = LoadAppKeysFromNode(node, "Mappings", true);
// fire the loaded event, so things can tell when they are loaded.
Reloaded?.Invoke(settings);
return(settings);
}
/// <summary>
/// load hte config for a single handler.
/// </summary>
public HandlerSettings LoadHandlerConfig(XElement node, uSyncSettings defaultSettings)
{
if (node == null)
{
return(null);
}
var alias = node.Attribute("Alias").ValueOrDefault(string.Empty);
if (string.IsNullOrEmpty(alias))
{
return(null);
}
var enabled = node.Attribute("Enabled").ValueOrDefault(true);
var settings = new HandlerSettings(alias, enabled);
// these values can be set locally, but if they aren't
// we get them from the global setting.
settings.GuidNames = GetLocalValue(node.Attribute("GuidNames"), defaultSettings.UseGuidNames);
settings.UseFlatStructure = GetLocalValue(node.Attribute("UseFlatStructure"), defaultSettings.UseFlatStructure);
settings.Actions = node.Attribute("Actions").ValueOrDefault("All").ToDelimitedList().ToArray();
settings.FailOnMissingParent = GetLocalValue(node.Attribute("FailOnMissingParent"), defaultSettings.FailOnMissingParent);
// handlers can have their own individual settings beneath a node
//
// <Handler Alias="simple" ... >
// <Add Key="settingName" Value="settingValue" />
// </Handler>
//
// These get added to a Settings dictionary for the handler, so it
// can access them as needed (v8.7+ also passed to serializers)
//
var perHandlerSettings = new Dictionary <string, string>();
foreach (var settingItem in node.Elements("Add"))
{
var key = settingItem.Attribute("Key").ValueOrDefault(string.Empty);
var value = settingItem.Attribute("Value").ValueOrDefault(string.Empty);
if (string.IsNullOrWhiteSpace(key) || string.IsNullOrWhiteSpace(value))
{
continue;
}
perHandlerSettings.Add(key, value);
}
settings.Settings = perHandlerSettings;
return(settings);
}
public uSyncSettings LoadSettings()
{
uSyncSettings settings = new uSyncSettings();
var node = GetSettingsFile();
if (node == null)
{
return(SaveSettings(settings));
}
settings.RootFolder = ValueFromWebConfigOrDefault("Folder", node.Element("Folder").ValueOrDefault(settings.RootFolder));
settings.UseFlatStructure = ValueFromWebConfigOrDefault("FlatFolders", node.Element("FlatFolders").ValueOrDefault(true));
settings.ImportAtStartup = ValueFromWebConfigOrDefault("ImportAtStartup", node.Element("ImportAtStartup").ValueOrDefault(true));
settings.ExportAtStartup = ValueFromWebConfigOrDefault("ExportAtStartup", node.Element("ExportAtStartup").ValueOrDefault(false));
settings.ExportOnSave = ValueFromWebConfigOrDefault("ExportOnSave", node.Element("ExportOnSave").ValueOrDefault(true));
settings.UseGuidNames = ValueFromWebConfigOrDefault("UseGuidFilenames", node.Element("UseGuidFilenames").ValueOrDefault(false));
settings.BatchSave = node.Element("BatchSave").ValueOrDefault(false);
settings.ReportDebug = node.Element("ReportDebug").ValueOrDefault(false);
settings.AddOnPing = node.Element("AddOnPing").ValueOrDefault(true);
settings.RebuildCacheOnCompletion = node.Element("RebuildCacheOnCompletion").ValueOrDefault(false);
settings.FailOnMissingParent = node.Element("FailOnMissingParent").ValueOrDefault(true);
// load the handlers
var handlerSets = node.Element("HandlerSets");
if (handlerSets != null)
{
settings.HandlerSets = LoadHandlerSets(handlerSets, settings, out string defaultSet);
settings.DefaultSet = defaultSet;
}
else
{
var handlers = node.Element("Handlers");
if (handlers != null)
{
// old config, load as default :(
settings.HandlerSets = new List <HandlerSet>();
var defaultSet = LoadSingleHandlerSet(handlers, settings);
settings.HandlerSets.Add(defaultSet);
}
}
// fire the loaded event, so things can tell when they are loaded.
Reloaded?.Invoke(settings);
return(settings);
}
public HandlerSettings LoadHandlerConfig(XElement node, uSyncSettings defaultSettings)
{
if (node == null)
{
return(null);
}
var alias = node.Attribute("Alias").ValueOrDefault(string.Empty);
if (string.IsNullOrEmpty(alias))
{
return(null);
}
var enabled = node.Attribute("Enabled").ValueOrDefault(true);
var settings = new HandlerSettings(alias, enabled);
// these values can be set locally, but if they aren't
// we get them from the global setting.
settings.GuidNames = GetLocalValue(node.Attribute("GuidNames"), defaultSettings.UseGuidNames);
settings.UseFlatStructure = GetLocalValue(node.Attribute("UseFlatStructure"), defaultSettings.UseFlatStructure);
settings.BatchSave = GetLocalValue(node.Attribute("BatchSave"), defaultSettings.BatchSave);
settings.Actions = node.Attribute("Actions").ValueOrDefault("All").ToDelimitedList().ToArray();
settings.FailOnMissingParent = GetLocalValue(node.Attribute("FailOnMissingParent"), defaultSettings.FailOnMissingParent);
// var settingNode = node.Element("Settings");
// if (settingNode != null)
// {
var perHandlerSettings = new Dictionary <string, string>();
foreach (var settingItem in node.Elements("Add"))
{
var key = settingItem.Attribute("Key").ValueOrDefault(string.Empty);
var value = settingItem.Attribute("Value").ValueOrDefault(string.Empty);
if (string.IsNullOrWhiteSpace(key) || string.IsNullOrWhiteSpace(value))
{
continue;
}
perHandlerSettings.Add(key, value);
}
settings.Settings = perHandlerSettings;
// }
return(settings);
}
/// <summary>
/// Load the handler sets from the 'Handlers' section of the file
/// </summary>
private IList <HandlerSet> LoadHandlerSets(XElement node, uSyncSettings defaultSettings, out string defaultSet)
{
var sets = new List <HandlerSet>();
defaultSet = ValueFromWebConfigOrDefault("DefaultHandlerSet", node.Attribute("Default").ValueOrDefault("default"));
logger.Debug <uSyncConfig>("Handlers : Default Set {defaultSet}", defaultSet);
foreach (var setNode in node.Elements("Handlers"))
{
var handlerSet = LoadSingleHandlerSet(setNode, defaultSettings);
if (handlerSet.Handlers.Count > 0)
{
sets.Add(handlerSet);
}
}
return(sets);
}
/// <summary>
/// Load the handler set (a collection of handlers)
/// </summary>
/// <remarks>
/// each handler set has a name, it lets us have diffrent sets for diffrent tasks
/// </remarks>
private HandlerSet LoadSingleHandlerSet(XElement setNode, uSyncSettings defaultSettings)
{
var handlerSet = new HandlerSet();
handlerSet.Name = setNode.Attribute("Name").ValueOrDefault("default");
foreach (var handlerNode in setNode.Elements("Handler"))
{
var handlerSettings = LoadHandlerConfig(handlerNode, defaultSettings);
if (handlerSettings != null)
{
logger.Debug <uSyncConfig>("Loading Handler {alias} {enabled} [{actions}]",
handlerSettings.Alias, handlerSettings.Enabled, string.Join(",", handlerSettings.Actions));
handlerSet.Handlers.Add(handlerSettings);
}
}
return(handlerSet);
}
public uSyncSettings LoadSettings()
{
uSyncSettings settings = new uSyncSettings();
var node = GetSettingsFile();
if (node == null)
{
return(SaveSettings(settings));
}
settings.RootFolder = node.Element("Folder").ValueOrDefault(settings.RootFolder);
settings.UseFlatStructure = node.Element("FlatFolders").ValueOrDefault(true);
settings.ImportAtStartup = node.Element("ImportAtStartup").ValueOrDefault(true);
settings.ExportAtStartup = node.Element("ExportAtStartup").ValueOrDefault(false);
settings.ExportOnSave = node.Element("ExportOnSave").ValueOrDefault(true);
settings.UseGuidNames = node.Element("UseGuidFilenames").ValueOrDefault(false);
settings.BatchSave = node.Element("BatchSave").ValueOrDefault(false);
settings.ReportDebug = node.Element("ReportDebug").ValueOrDefault(false);
settings.AddOnPing = node.Element("AddOnPing").ValueOrDefault(true);
var handlerConfig = node.Element("Handlers");
if (handlerConfig != null && handlerConfig.HasElements)
{
settings.EnableMissingHandlers = handlerConfig.Attribute("EnableMissing").ValueOrDefault(true);
foreach (var handlerNode in handlerConfig.Elements("Handler"))
{
var handlerSetting = LoadHandlerConfig(handlerNode, settings);
if (handlerSetting != null)
{
settings.Handlers.Add(handlerSetting);
}
}
}
return(settings);
}
/// <summary>
/// Load the usync settings from disk.
/// </summary>
public uSyncSettings LoadSettings()
{
uSyncSettings settings = new uSyncSettings();
var node = GetSettingsFile();
if (node == null)
{
logger.Warn <uSyncConfig>($"Failed to load the {uSyncBackOfficeConstants.ConfigFile} file from disk, working with defaults.");
return(SaveSettings(settings));
}
settings.SettingsFolder = ValueFromWebConfigOrDefault("Folder", node.Element("Folder").ValueOrDefault(settings.RootFolder));
var allowUnsafeFolder = ValueFromWebConfigOrDefault("AllowUnsafeFolder", node.Element("Folder").Attribute("AllowUnsafe").ValueOrDefault(false));
settings.RootFolder = GetPhysicalFolder(settings.SettingsFolder, allowUnsafeFolder);
settings.UseFlatStructure = ValueFromWebConfigOrDefault("FlatFolders", node.Element("FlatFolders").ValueOrDefault(true));
settings.ImportAtStartup = ValueFromWebConfigOrDefault("ImportAtStartup", node.Element("ImportAtStartup").ValueOrDefault(true));
// new add a group to use on import at startup (so say only import settings)
var startupGroup = string.Empty;
var importStartupNode = node.Element("ImportAtStartup");
if (importStartupNode != null)
{
startupGroup = importStartupNode.Attribute("Group").ValueOrDefault(startupGroup);
}
settings.ImportAtStartupGroup = ValueFromWebConfigOrDefault("ImportAtStartup.Group", startupGroup);
settings.ExportAtStartup = ValueFromWebConfigOrDefault("ExportAtStartup", node.Element("ExportAtStartup").ValueOrDefault(false));
settings.ExportOnSave = ValueFromWebConfigOrDefault("ExportOnSave", node.Element("ExportOnSave").ValueOrDefault(true));
settings.UseGuidNames = ValueFromWebConfigOrDefault("UseGuidFilenames", node.Element("UseGuidFilenames").ValueOrDefault(false));
settings.ReportDebug = node.Element("ReportDebug").ValueOrDefault(false);
settings.AddOnPing = node.Element("AddOnPing").ValueOrDefault(true);
settings.RebuildCacheOnCompletion = node.Element("RebuildCacheOnCompletion").ValueOrDefault(false);
settings.FailOnMissingParent = node.Element("FailOnMissingParent").ValueOrDefault(true);
settings.ShowVersionCheckWarning = node.Element("ShowVersionCheckWarning").ValueOrDefault(true);
settings.CacheFolderKeys = node.Element("CacheFolderKeys").ValueOrDefault(true);
settings.EnableHistory = node.Element("EnableHistory").ValueOrDefault(true);
settings.SignalRRoot = ValueFromWebConfigOrDefault("SignalRRoot", node.Element("SignalRRoot")
.ValueOrDefault("backoffice/signalr/hubs"))
.TrimStart(new[] { '/' });
settings.DefaultHandlerSettings = LoadKeyValueSettings(node.Element("HandlerDefaults"));
// load the handlers
var handlerSets = node.Element("HandlerSets");
if (handlerSets != null)
{
settings.HandlerSets = LoadHandlerSets(handlerSets, settings, out string defaultSet);
settings.DefaultSet = defaultSet;
}
else
{
var handlers = node.Element("Handlers");
if (handlers != null)
{
// old config, load as default :(
settings.HandlerSets = new List <HandlerSet>();
var defaultSet = LoadSingleHandlerSet(handlers, settings);
settings.HandlerSets.Add(defaultSet);
}
}
settings.CustomMappings = LoadAppKeysFromNode(node, "Mappings", true);
// fire the loaded event, so things can tell when they are loaded.
Reloaded?.Invoke(settings);
return(settings);
}
public uSyncConfig(IProfilingLogger logger)
{
this.logger = logger;
this.Settings = LoadSettings();
}
public uSyncSettings SaveSettings(uSyncSettings settings, bool fireReload = false)
{
var node = GetSettingsFile(true);
node.CreateOrSetElement("Folder", settings.RootFolder);
node.CreateOrSetElement("FlatFolders", settings.UseFlatStructure);
node.CreateOrSetElement("ImportAtStartup", settings.ImportAtStartup);
node.CreateOrSetElement("ExportAtStartup", settings.ExportAtStartup);
node.CreateOrSetElement("ExportOnSave", settings.ExportOnSave);
node.CreateOrSetElement("UseGuidFilenames", settings.UseGuidNames);
node.CreateOrSetElement("BatchSave", settings.BatchSave);
node.CreateOrSetElement("ReportDebug", settings.ReportDebug);
if (settings.Handlers != null && settings.Handlers.Any())
{
var handlerConfig = node.Element("Handlers");
if (handlerConfig == null)
{
handlerConfig = new XElement("Handlers",
new XAttribute("EnableMissing", true));
node.Add(handlerConfig);
}
foreach (var handler in settings.Handlers)
{
if (!handler.GuidNames.IsOverridden)
{
handler.GuidNames.SetDefaultValue(settings.UseGuidNames);
}
if (!handler.UseFlatStructure.IsOverridden)
{
handler.UseFlatStructure.SetDefaultValue(settings.UseFlatStructure);
}
if (!handler.BatchSave.IsOverridden)
{
handler.BatchSave.SetDefaultValue(settings.BatchSave);
}
var handlerNode = handlerConfig.Elements("Handler").FirstOrDefault(x => x.Attribute("Alias").Value == handler.Alias);
if (handlerNode == null)
{
handlerNode = new XElement("Handler");
handlerConfig.Add(handlerNode);
}
SaveHandlerConfig(handlerNode, handler, settings);
}
}
else
{
// if the handlers is null, we should write out the handlers we have loaded,
// so that there is something in the config
}
SaveSettingsFile(node);
if (fireReload)
{
this.Settings = LoadSettings();
Reloaded?.Invoke(settings);
}
return(settings);
}
public uSyncConfig()
{
this.Settings = LoadSettings();
}