Example #1
0
        /// <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 &amp; 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 <HandlerConfigPair> 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 = _mutexService.ImportPause())
                {
                    // pre import event
                    _mutexService.FireBulkStarting(new uSyncImportStartingNotification());

                    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
                    _mutexService.FireBulkComplete(new uSyncImportCompletedNotification(actions));

                    _logger.LogInformation("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);
                }
            }
        }