public ActionResult ImportPOST()
        {
            if (!Services.Authorizer.Authorize(Permissions.Import, T("Not allowed to import.")))
            {
                return(new HttpUnauthorizedResult());
            }

            var actions   = _importActions.OrderByDescending(x => x.Priority).ToList();
            var viewModel = new ImportViewModel {
                Actions = actions.Select(x => new ImportActionViewModel {
                    Editor = x.UpdateEditor(Services.New, this)
                }).Where(x => x != null).ToList()
            };

            if (!ModelState.IsValid)
            {
                return(View(viewModel));
            }

            var context     = new ImportActionContext();
            var executionId = _importExportService.Import(context, actions);

            return(!String.IsNullOrEmpty(executionId)
                ? RedirectToAction("ImportResult", new { executionId = context.ExecutionId })
                : RedirectToAction("Import"));
        }
Beispiel #2
0
 public string Import(ImportActionContext context, IEnumerable <IImportAction> actions = null)
 {
     foreach (var action in actions ?? _importActions)
     {
         action.Execute(context);
     }
     return(context.ExecutionId);
 }
Beispiel #3
0
        public static string Import(this IImportExportService service, string recipeText)
        {
            var context = new ImportActionContext {
                RecipeDocument = XDocument.Parse(recipeText, LoadOptions.PreserveWhitespace)
            };

            service.Import(context);
            return(context.ExecutionId);
        }
        public override void Execute(ImportActionContext context)
        {
            var recipeDocument = context.RecipeDocument ?? RecipeDocument;

            if (recipeDocument == null)
            {
                return;
            }

            // Give each execution step a chance to augment the recipe step before it will be scheduled.
            PrepareRecipe(recipeDocument);

            // Sets the request timeout to a configurable amount of seconds to give enough time to execute custom recipes.
            if (_orchardServices.WorkContext.HttpContext != null)
            {
                _orchardServices.WorkContext.HttpContext.Server.ScriptTimeout = RecipeExecutionTimeout;
            }

            // Suspend background task execution.
            _sweepGenerator.Terminate();

            // Import or setup using the specified recipe.
            var executionId = ResetSite ? Setup(recipeDocument) : ExecuteRecipe(recipeDocument);

            if (executionId == null)
            {
                _orchardServices.Notifier.Warning(T("The recipe contained no steps. No work was scheduled."));
                _sweepGenerator.Activate();
                return;
            }

            // Resume background tasks once import/setup completes.
            var recipe = _recipeParser.ParseRecipe(recipeDocument);
            var activateSweepGeneratorStep = new RecipeStep(Guid.NewGuid().ToString("N"), recipe.Name, "ActivateSweepGenerator", new XElement("ActivateSweepGenerator"));

            _recipeStepQueue.Enqueue(executionId, activateSweepGeneratorStep);
            _recipeStepResultRepository.Create(new RecipeStepResultRecord {
                ExecutionId = executionId,
                RecipeName  = recipe.Name,
                StepId      = activateSweepGeneratorStep.Id,
                StepName    = activateSweepGeneratorStep.Name
            });

            context.ExecutionId    = executionId;
            context.RecipeDocument = recipeDocument;
        }
 public abstract void Execute(ImportActionContext context);