public IEnumerable <uSyncAction> PerformPostImport(string rootFolder, string handlerSet, IEnumerable <uSyncAction> actions)
{
lock (_importLock)
{
using (var pause = new uSyncImportPause())
{
var handlers = handlerFactory.GetValidHandlers(new SyncHandlerOptions {
Set = handlerSet, Action = HandlerActions.Import
});
return(PerformPostImport(rootFolder, handlers, actions));
}
}
}
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);
}
}
}
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);
}
}
}
public IEnumerable <uSyncAction> ImportHandler(string handlerAlias, uSyncImportOptions options)
{
lock (_importLock)
{
using (var pause = new uSyncImportPause())
{
var handlerPair = handlerFactory.GetValidHandler(handlerAlias, new SyncHandlerOptions
{
Set = options.HandlerSet,
Action = HandlerActions.Import
});
if (handlerPair == null)
{
return(Enumerable.Empty <uSyncAction>());
}
var folder = GetHandlerFolder(options.RootFolder, handlerPair.Handler);
return(handlerPair.Handler.ImportAll(folder, handlerPair.Settings,
options.Flags.HasFlag(SerializerFlags.Force),
options.Callbacks?.Update));
}
}
}
/// <summary>
/// Import items into umbraco from a given folder
/// </summary>
/// <param name="folder">Folder to use for the import</param>
/// <param name="force">Push changes in even if there is no difference between the file and the item in umbraco</param>
/// <param name="handlers">List of Handlers & config to use for import</param>
/// <param name="callbacks">Callbacks to keep UI informed</param>
/// <returns>List of actions detailing what did and didn't change</returns>
public IEnumerable <uSyncAction> Import(string folder, bool force, IEnumerable <ExtendedHandlerConfigPair> handlers, uSyncCallbacks callbacks)
{
// if its blank, we just throw it back empty.
if (handlers == null || !handlers.Any())
{
return(Enumerable.Empty <uSyncAction>());
}
lock (_importLock)
{
var sw = Stopwatch.StartNew();
using (var pause = new uSyncImportPause())
{
// pre import event
fireBulkStarting(ImportStarting);
var actions = new List <uSyncAction>();
var summary = new SyncProgressSummary(handlers.Select(x => x.Handler), "Importing", handlers.Count() + 1);
summary.Handlers.Add(new SyncHandlerSummary()
{
Icon = "icon-defrag",
Name = "Post Import",
Status = HandlerStatus.Pending
});
foreach (var configuredHandler in handlers)
{
var handler = configuredHandler.Handler;
var handlerSettings = configuredHandler.Settings;
summary.Increment();
summary.UpdateHandler(
handler.Name, HandlerStatus.Processing, $"Importing {handler.Name}", 0);
callbacks?.Callback?.Invoke(summary);
var handlerActions = handler.ImportAll($"{folder}/{handler.DefaultFolder}", handlerSettings, force, callbacks?.Update);
actions.AddRange(handlerActions);
summary.UpdateHandler(handler.Name, HandlerStatus.Complete,
handlerActions.CountChanges(),
handlerActions.ContainsErrors());
}
// postImport things (mainly cleaning up folders)
summary.Increment();
summary.UpdateHandler("Post Import", HandlerStatus.Pending, "Post Import Actions", 0);
callbacks?.Callback?.Invoke(summary);
actions.AddRange(PerformPostImport(folder, handlers, actions));
sw.Stop();
summary.UpdateHandler("Post Import", HandlerStatus.Complete, "Import Completed", 0);
callbacks?.Callback?.Invoke(summary);
// fire complete
fireBulkComplete(ImportComplete, actions);
logger.Info <uSyncService>("uSync Import: {handlerCount} handlers, processed {itemCount} items, {changeCount} changes in {ElapsedMilliseconds}ms",
handlers.Count(),
actions.Count,
actions.CountChanges(),
sw.ElapsedMilliseconds);
callbacks?.Update?.Invoke($"Processed {actions.Count} items in {sw.ElapsedMilliseconds}ms", 1, 1);
return(actions);
}
}
}
