/// <summary>
/// Report the changes for a folder
/// </summary>
/// <param name="folder">Folder to run the report for</param>
/// <param name="handlerOptions">Options to use for the report - used to load the handlers.</param>
/// <param name="callbacks">Callback functions to keep UI uptodate</param>
/// <returns>List of actions detailing what would and wouldn't change</returns>
public IEnumerable <uSyncAction> Report(string folder, SyncHandlerOptions handlerOptions, uSyncCallbacks callbacks = null)
{
if (handlerOptions == null)
{
handlerOptions = new SyncHandlerOptions();
}
handlerOptions.Action = HandlerActions.Report;
var handlers = handlerFactory.GetValidHandlers(handlerOptions);
return(Report(folder, handlers, callbacks));
}
/// <summary>
/// Peform a paged Import post import against a given folder
/// </summary>
public IEnumerable <uSyncAction> ImportPartialPostImport(IEnumerable <uSyncAction> actions, uSyncPagedImportOptions options)
{
if (actions == null || !actions.Any())
{
return(Enumerable.Empty <uSyncAction>());
}
lock (_importLock)
{
using (var pause = _mutexService.ImportPause())
{
SyncHandlerOptions syncHandlerOptions = HandlerOptionsFromPaged(options);
var aliases = actions.Select(x => x.HandlerAlias).Distinct();
var folders = actions
.Where(x => x.RequiresPostProcessing)
.Select(x => new { alias = x.HandlerAlias, folder = Path.GetDirectoryName(x.FileName), actions = x })
.SafeDistinctBy(x => x.folder)
.GroupBy(x => x.alias)
.ToList();
var results = new List <uSyncAction>();
var index = 0;
foreach (var actionItem in folders.SelectMany(actionGroup => actionGroup))
{
var handlerPair = _handlerFactory.GetValidHandler(actionItem.alias, syncHandlerOptions);
if (handlerPair == null)
{
_logger.LogWarning("No handler was found for {alias} item might not process correctly", actionItem.alias);
}
else
{
if (handlerPair.Handler is ISyncPostImportHandler postImportHandler)
{
options.Callbacks?.Update?.Invoke(actionItem.alias, index, folders.Count);
var handlerActions = actions.Where(x => x.HandlerAlias.InvariantEquals(handlerPair.Handler.Alias));
results.AddRange(postImportHandler.ProcessPostImport(actionItem.folder, handlerActions, handlerPair.Settings));
}
}
index++;
}
return(results);
}
}
}
public IEnumerable <uSyncAction> ImportPartial(string folder, uSyncPagedImportOptions options, out int total)
{
lock (_importLock)
{
using (var pause = new uSyncImportPause())
{
var orderedNodes = LoadOrderedNodes(folder);
total = orderedNodes.Count;
var actions = new List <uSyncAction>();
var lastType = string.Empty;
var range = options.ProgressMax - options.ProgressMin;
SyncHandlerOptions syncHandlerOptions = new SyncHandlerOptions(options.HandlerSet);
ExtendedHandlerConfigPair handlerPair = null;
var index = options.PageNumber * options.PageSize;
foreach (var item in orderedNodes.Skip(options.PageNumber * options.PageSize).Take(options.PageSize))
{
var itemType = item.Node.GetItemType();
if (!itemType.InvariantEquals(lastType))
{
lastType = itemType;
handlerPair = handlerFactory.GetValidHandlerByTypeName(itemType, syncHandlerOptions);
}
options.Callbacks?.Update?.Invoke(item.Node.GetAlias(),
CalculateProgress(index, total, options.ProgressMin, options.ProgressMax), 100);
if (handlerPair != null)
{
if (handlerPair.Handler is ISyncItemHandler itemHandler)
{
actions.AddRange(itemHandler.ImportElement(item.Node, item.FileName, handlerPair.Settings, options));
}
else
{
actions.AddRange(handlerPair.Handler.ImportElement(item.Node, options.Flags.HasFlag(SerializerFlags.Force)));
}
}
index++;
}
return(actions);
}
}
}
/// <summary>
/// Peform a paged Import against a given folder
/// </summary>
public IEnumerable <uSyncAction> ImportPartial(string folder, uSyncPagedImportOptions options, out int total)
{
lock (_importLock)
{
using (var pause = _mutexService.ImportPause())
{
var orderedNodes = LoadOrderedNodes(folder);
total = orderedNodes.Count;
var actions = new List <uSyncAction>();
var lastType = string.Empty;
var range = options.ProgressMax - options.ProgressMin;
SyncHandlerOptions syncHandlerOptions = HandlerOptionsFromPaged(options);
HandlerConfigPair handlerPair = null;
var index = options.PageNumber * options.PageSize;
foreach (var item in orderedNodes.Skip(options.PageNumber * options.PageSize).Take(options.PageSize))
{
var itemType = item.Node.GetItemType();
if (!itemType.InvariantEquals(lastType))
{
lastType = itemType;
handlerPair = _handlerFactory.GetValidHandlerByTypeName(itemType, syncHandlerOptions);
}
if (handlerPair == null)
{
_logger.LogWarning("No handler was found for {alias} item might not process correctly", itemType);
continue;
}
options.Callbacks?.Update?.Invoke(item.Node.GetAlias(),
CalculateProgress(index, total, options.ProgressMin, options.ProgressMax), 100);
if (handlerPair != null)
{
actions.AddRange(handlerPair.Handler.ImportElement(item.Node, item.FileName, handlerPair.Settings, options));
}
index++;
}
return(actions);
}
}
}
/// <summary>
/// Initialize uSync elements (run start up import etc).
/// </summary>
private void InituSync()
{
var sw = Stopwatch.StartNew();
try
{
using (var reference = _umbracoContextFactory.EnsureUmbracoContext())
{
if (IsExportAtStatupEnabled() || (IsExportOnSaveOn() && !_syncFileService.RootExists(_uSyncConfig.GetRootFolder())))
{
var options = new SyncHandlerOptions
{
Group = _uSyncConfig.Settings.ExportOnSave
};
_logger.LogInformation("uSync: Running export at startup");
_uSyncService.Export(_uSyncConfig.GetRootFolder(), options);
}
if (IsImportAtStatupEnabled())
{
_logger.LogInformation("uSync: Running Import at startup {group}", _uSyncConfig.Settings.ImportAtStartup);
if (!HasStopFile(_uSyncConfig.GetRootFolder()))
{
_uSyncService.Import(_uSyncConfig.GetRootFolder(), false, new SyncHandlerOptions
{
Group = _uSyncConfig.Settings.ImportAtStartup
});
ProcessOnceFile(_uSyncConfig.GetRootFolder());
}
else
{
_logger.LogInformation("Startup Import blocked by usync.stop file");
}
}
}
}
catch (Exception ex)
{
_logger.LogWarning(ex, "uSync: Error during startup {message}", ex.Message);
}
finally
{
sw.Stop();
_logger.LogInformation("uSync: Startup Complete {elapsed}ms", sw.ElapsedMilliseconds);
}
}
public IEnumerable <SyncHandlerSummary> GetHandlers(string set)
{
var handlerSet = !string.IsNullOrWhiteSpace(set) ? set : uSyncConfig.Settings.DefaultSet;
var options = new SyncHandlerOptions(handlerSet)
{
Group = uSyncConfig.Settings.UIEnabledGroups,
};
return(handlerFactory.GetValidHandlers(options)
.Select(x => new SyncHandlerSummary()
{
Icon = x.Handler.Icon,
Name = x.Handler.Name,
Status = HandlerStatus.Pending
}));
}
/// <summary>
/// Peform a paged Import second pass against a given folder
/// </summary>
public IEnumerable <uSyncAction> ImportPartialSecondPass(IEnumerable <uSyncAction> actions, uSyncPagedImportOptions options)
{
lock (_importLock)
{
using (var pause = _mutexService.ImportPause())
{
SyncHandlerOptions syncHandlerOptions = HandlerOptionsFromPaged(options);
var secondPassActions = new List <uSyncAction>();
var total = actions.Count();
var lastType = string.Empty;
HandlerConfigPair handlerPair = null;
var index = options.PageNumber * options.PageSize;
foreach (var action in actions.Skip(options.PageNumber * options.PageSize).Take(options.PageSize))
{
if (!action.HandlerAlias.InvariantEquals(lastType))
{
lastType = action.HandlerAlias;
handlerPair = _handlerFactory.GetValidHandler(action.HandlerAlias, syncHandlerOptions);
}
if (handlerPair == null)
{
_logger.LogWarning("No handler was found for {alias} item might not process correctly", action.HandlerAlias);
continue;
}
options.Callbacks?.Update?.Invoke($"Second Pass: {action.Name}",
CalculateProgress(index, total, options.ProgressMin, options.ProgressMax), 100);
secondPassActions.AddRange(handlerPair.Handler.ImportSecondPass(action, handlerPair.Settings, options));
index++;
}
return(secondPassActions);
}
}
}
public IDictionary <string, string> GetHandlerGroups(string set)
{
var handlerSet = !string.IsNullOrWhiteSpace(set) ? set : uSyncConfig.Settings.DefaultSet;
var options = new SyncHandlerOptions(handlerSet)
{
Group = uSyncConfig.Settings.UIEnabledGroups
};
var groups = handlerFactory.GetValidHandlerGroupsAndIcons(options);
// if nothing is set, we add everything marker.
if (string.IsNullOrWhiteSpace(uSyncConfig.Settings.UIEnabledGroups) ||
uSyncConfig.Settings.UIEnabledGroups.InvariantContains("all"))
{
groups.Add("_everything", "");
}
return(groups);
}
/// <summary>
/// Peform a paged Clean after import for a given folder
/// </summary>
public IEnumerable <uSyncAction> ImportPostCleanFiles(IEnumerable <uSyncAction> actions, uSyncPagedImportOptions options)
{
if (actions == null)
{
return(Enumerable.Empty <uSyncAction>());
}
lock (_importLock)
{
using (var pause = _mutexService.ImportPause())
{
SyncHandlerOptions syncHandlerOptions = new SyncHandlerOptions(options.HandlerSet);
var cleans = actions
.Where(x => x.Change == ChangeType.Clean && !string.IsNullOrWhiteSpace(x.FileName))
.Select(x => new { alias = x.HandlerAlias, folder = Path.GetDirectoryName(x.FileName), actions = x })
.SafeDistinctBy(x => x.folder)
.GroupBy(x => x.alias)
.ToList();
var results = new List <uSyncAction>();
var index = 0;
foreach (var actionItem in cleans.SelectMany(actionGroup => actionGroup))
{
var handlerPair = _handlerFactory.GetValidHandler(actionItem.alias, syncHandlerOptions);
if (handlerPair.Handler is ISyncCleanEntryHandler cleanEntryHandler)
{
options.Callbacks?.Update?.Invoke(actionItem.alias, index, cleans.Count);
var handlerActions = actions.Where(x => x.HandlerAlias.InvariantEquals(handlerPair.Handler.Alias));
results.AddRange(cleanEntryHandler.ProcessCleanActions(actionItem.folder, handlerActions, handlerPair.Settings));
}
index++;
}
return(results);
}
}
}
public IEnumerable <uSyncAction> ImportPartialSecondPass(IEnumerable <uSyncAction> actions, uSyncPagedImportOptions options)
{
lock (_importLock)
{
using (var pause = new uSyncImportPause())
{
SyncHandlerOptions syncHandlerOptions = new SyncHandlerOptions(options.HandlerSet);
var secondPassActions = new List <uSyncAction>();
var total = actions.Count();
var lastType = string.Empty;
ExtendedHandlerConfigPair handlerPair = null;
var index = options.PageNumber * options.PageSize;
foreach (var action in actions.Skip(options.PageNumber * options.PageSize).Take(options.PageSize))
{
if (!action.HandlerAlias.InvariantEquals(lastType))
{
lastType = action.HandlerAlias;
handlerPair = handlerFactory.GetValidHandler(action.HandlerAlias, syncHandlerOptions);
}
options.Callbacks?.Update?.Invoke($"Second Pass: {action.Name}",
CalculateProgress(index, total, options.ProgressMin, options.ProgressMax), 100);
if (handlerPair != null && handlerPair.Handler is ISyncItemHandler itemHandler)
{
secondPassActions.AddRange(itemHandler.ImportSecondPass(action, handlerPair.Settings, options));
}
index++;
}
return(secondPassActions);
}
}
}
public IEnumerable <uSyncAction> ImportPartialPostImport(IEnumerable <uSyncAction> actions, uSyncPagedImportOptions options)
{
lock (_importLock)
{
using (var pause = new uSyncImportPause())
{
SyncHandlerOptions syncHandlerOptions = new SyncHandlerOptions(options.HandlerSet);
var aliases = actions.Select(x => x.HandlerAlias).Distinct();
var folders = actions
.Where(x => x.RequiresPostProcessing)
.Select(x => new { alias = x.HandlerAlias, folder = Path.GetDirectoryName(x.FileName), actions = x })
.DistinctBy(x => x.folder)
.GroupBy(x => x.alias)
.ToList();
var results = new List <uSyncAction>();
var index = 0;
foreach (var actionItem in folders.SelectMany(actionGroup => actionGroup))
{
var handlerPair = handlerFactory.GetValidHandler(actionItem.alias, syncHandlerOptions);
if (handlerPair.Handler is ISyncPostImportHandler postImportHandler)
{
options.Callbacks?.Update?.Invoke(actionItem.alias, index, folders.Count);
var handlerActions = actions.Where(x => x.HandlerAlias.InvariantEquals(handlerPair.Handler.Alias));
results.AddRange(postImportHandler.ProcessPostImport(actionItem.folder, handlerActions, handlerPair.Settings));
}
index++;
}
return(results);
}
}
}
/// <summary>
/// Get a list of handlers for a set of entity types.
/// </summary>
/// <param name="entityTypes">Entity types to find handlers for</param>
/// <param name="handlerOptions">Options to use when loading the handlers</param>
/// <returns>List of Handler/Config pairs for handlers for entity types</returns>
private IList <ExtendedHandlerConfigPair> GetHandlersByEntitytype(IEnumerable <string> entityTypes, SyncHandlerOptions handlerOptions)
{
var handlers = new List <ExtendedHandlerConfigPair>();
foreach (var entityType in entityTypes)
{
var handler = handlerFactory.GetValidHandlerByEntityType(entityType, handlerOptions);
if (handler != null)
{
handlers.Add(handler);
}
}
return(handlers);
}
public static void TriggerImport(string folder, IEnumerable <string> entityTypes, SyncHandlerOptions options)
{
DoImport?.Invoke(new uSyncTriggerArgs()
{
EntityTypes = entityTypes,
Folder = folder,
HandlerOptions = options
});
}
