public override void Execute(RecipeExecutionContext context)
{
if (!_authorizer.Authorize(Permissions.ImportAuditTrail)) {
Logger.Warning("Blocked {0} from importing an audit trail because this user does not have the ImportauditTrail permission.", _wca.GetContext().CurrentUser.UserName);
return;
}
var elements = context.RecipeStep.Step.Elements().ToArray();
for (var i = 0; i < elements.Length; i ++) {
var eventElement = elements[i];
Logger.Information("Importing audit trail event {0}/{1}.", i + 1, elements.Length);
try {
var record = new AuditTrailEventRecord {
EventName = eventElement.Attr<string>("Name"),
FullEventName = eventElement.Attr<string>("FullName"),
Category = eventElement.Attr<string>("Category"),
UserName = eventElement.Attr<string>("User"),
CreatedUtc = eventElement.Attr<DateTime>("CreatedUtc"),
EventFilterKey = eventElement.Attr<string>("EventFilterKey"),
EventFilterData = eventElement.Attr<string>("EventFilterData"),
Comment = eventElement.El("Comment"),
EventData = eventElement.Element("EventData").ToString(),
};
_auditTrailEventRepository.Create(record);
}
catch (Exception ex) {
Logger.Error(ex, "Error while importing audit trail event {0}/{1}.", i + 1, elements.Length);
throw;
}
}
}
/*
<Recipes>
<Recipe ExtensionId="Orchard.Setup" Name="Core" />
</Recipes>
*/
public override void Execute(RecipeExecutionContext context) {
var recipeElements = context.RecipeStep.Step.Elements();
var recipesDictionary = new Dictionary<string, IDictionary<string, Recipe>>();
foreach (var recipeElement in recipeElements) {
var extensionId = recipeElement.Attr("ExtensionId");
var recipeName = recipeElement.Attr("Name");
Logger.Information("Executing recipe '{0}' in extension '{1}'.", recipeName, extensionId);
try {
var recipes = recipesDictionary.ContainsKey(extensionId) ? recipesDictionary[extensionId] : default(IDictionary<string, Recipe>);
if (recipes == null)
recipes = recipesDictionary[extensionId] = HarvestRecipes(extensionId);
if (!recipes.ContainsKey(recipeName))
throw new Exception(String.Format("No recipe named '{0}' was found in extension '{1}'.", recipeName, extensionId));
EnqueueRecipe(context.ExecutionId, recipes[recipeName]);
}
catch (Exception ex) {
Logger.Error(ex, "Error while executing recipe '{0}' in extension '{1}'.", recipeName, extensionId);
throw;
}
}
}
/*
<Aliases>
<Alias Path="Profile/Edit" Area="Custom.Profile">
<RouteValues>
<Add Key="area" Value="Custom.Profile" />
<Add Key="controller" Value="Profile" />
<Add Key="action" Value="Edit" />
</RouteValues>
</Alias>
*/
public override void Execute(RecipeExecutionContext context) {
foreach (var aliasElement in context.RecipeStep.Step.Elements()) {
var aliasPath = aliasElement.Attribute("Path").Value;
Logger.Information("Importing alias '{0}'.", aliasPath);
try {
var rvd = new RouteValueDictionary();
var routeValuesElement = aliasElement.Descendants("RouteValues").FirstOrDefault();
if (routeValuesElement != null) {
foreach (var routeValue in routeValuesElement.Descendants("Add")) {
rvd.Add(routeValue.Attribute("Key").Value, routeValue.Attribute("Value").Value);
}
}
_aliasService.Set(aliasPath, rvd, "Custom", false);
}
catch (Exception ex) {
Logger.Error(ex, "Error while processing alias '{0}'.", aliasPath);
throw;
}
}
}
/*
{
"name": "recipes",
"recipes": [
{ "executionid": "Orchard.Setup", name="Core" }
]
}
*/
public override async Task ExecuteAsync(RecipeExecutionContext context)
{
var step = context.RecipeStep.Step.ToObject<InternalStep>();
var recipesDictionary = new Dictionary<string, IDictionary<string, RecipeDescriptor>>();
foreach (var recipe in step.Values)
{
Logger.LogInformation("Executing recipe '{0}' in extension '{1}'.", recipe.Name, recipe.ExecutionId);
try
{
var recipes = recipesDictionary.ContainsKey(recipe.ExecutionId) ? recipesDictionary[recipe.ExecutionId] : default(IDictionary<string, RecipeDescriptor>);
if (recipes == null)
{
recipes = recipesDictionary[recipe.ExecutionId] = HarvestRecipes(recipe.ExecutionId);
}
if (!recipes.ContainsKey(recipe.Name))
{
throw new Exception(string.Format("No recipe named '{0}' was found in extension '{1}'.", recipe.Name, recipe.ExecutionId));
}
await _recipeManager.ExecuteAsync(context.ExecutionId, recipes[recipe.Name]);
}
catch
{
Logger.LogError("Error while executing recipe '{0}' in extension '{1}'.", recipe.Name, recipe.ExecutionId);
throw;
}
}
}
public async Task ExecuteRecipeStepAsync(RecipeContext recipeContext)
{
var recipeExecutionSteps = _serviceProvider.GetServices<IRecipeExecutionStep>();
var executionStep = recipeExecutionSteps
.FirstOrDefault(x => x.Names.Contains(recipeContext.RecipeStep.Name, StringComparer.OrdinalIgnoreCase));
if (executionStep != null)
{
var recipeExecutionContext = new RecipeExecutionContext
{
ExecutionId = recipeContext.ExecutionId,
RecipeStep = recipeContext.RecipeStep
};
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("Executing recipe step '{0}'.", recipeContext.RecipeStep.Name);
}
await executionStep.ExecuteAsync(recipeExecutionContext);
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("Finished executing recipe step '{0}'.", recipeContext.RecipeStep.Name);
}
recipeContext.Executed = true;
}
}
public override void Execute(RecipeExecutionContext context) {
var installedPermissions = _roleService.GetInstalledPermissions().SelectMany(p => p.Value).ToList();
foreach (var roleElement in context.RecipeStep.Step.Elements()) {
var roleName = roleElement.Attribute("Name").Value;
Logger.Information("Importing role '{0}'.", roleName);
try {
var role = _roleService.GetRoleByName(roleName);
if (role == null) {
_roleService.CreateRole(roleName);
role = _roleService.GetRoleByName(roleName);
}
var permissions = roleElement.Attribute("Permissions").Value.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
// Only import permissions for currenlty installed modules.
var permissionsValid = permissions.Where(permission => installedPermissions.Any(x => x.Name == permission)).ToList();
// Union to keep existing permissions.
_roleService.UpdateRole(role.Id, role.Name, permissionsValid.Union(role.RolesPermissions.Select(p => p.Permission.Name)));
}
catch (Exception ex) {
Logger.Error(ex, "Error while importing role '{0}'.", roleName);
throw;
}
}
}
/*
<Settings>
<SiteSettingsPart PageSize="30" />
<CommentSettingsPart ModerateComments="true" />
</Settings>
*/
// Set site and part settings.
public override void Execute(RecipeExecutionContext context) {
var siteContentItem = _siteService.GetSiteSettings().ContentItem;
var importContentSession = new ImportContentSession(_contentManager);
var importContentContext = new ImportContentContext(siteContentItem, context.RecipeStep.Step, importContentSession);
foreach (var contentHandler in Handlers) {
contentHandler.Importing(importContentContext);
}
foreach (var contentPart in siteContentItem.Parts) {
var partElement = importContentContext.Data.Element(contentPart.PartDefinition.Name);
if (partElement == null) {
continue;
}
Logger.Information("Importing settings part '{0}'.", contentPart.PartDefinition.Name);
try {
ImportSettingPart(contentPart, partElement);
}
catch (Exception ex) {
Logger.Error(ex, "Error while importing settings part '{0}'.", contentPart.PartDefinition.Name);
throw;
}
}
foreach (var contentHandler in Handlers) {
contentHandler.Imported(importContentContext);
}
}
public override void Execute(RecipeExecutionContext context) {
foreach (var rule in context.RecipeStep.Step.Elements()) {
var ruleName = rule.Attribute("Name").Value;
Logger.Information("Importing rule '{0}'.", ruleName);
try {
var ruleRecord = _rulesServices.CreateRule(ruleName);
ruleRecord.Enabled = bool.Parse(rule.Attribute("Enabled").Value);
ruleRecord.Actions = rule.Element("Actions").Elements().Select(action =>
new ActionRecord {
Type = action.Attribute("Type").Value,
Category = action.Attribute("Category").Value,
Position = int.Parse(action.Attribute("Position").Value),
Parameters = action.Attribute("Parameters").Value,
RuleRecord = ruleRecord
}).ToList();
ruleRecord.Events = rule.Element("Events").Elements().Select(action =>
new EventRecord {
Type = action.Attribute("Type").Value,
Category = action.Attribute("Category").Value,
Parameters = action.Attribute("Parameters").Value,
RuleRecord = ruleRecord
}).ToList();
}
catch (Exception ex) {
Logger.Error(ex, "Error while importing rule '{0}'.", ruleName);
throw;
}
}
}
// <Module packageId="module1" [repository="somerepo"] version="1.1" />
// Install modules from feed.
public override void Execute(RecipeExecutionContext context) {
string packageId = null, version = null, repository = null;
foreach (var attribute in context.RecipeStep.Step.Attributes()) {
if (String.Equals(attribute.Name.LocalName, "packageId", StringComparison.OrdinalIgnoreCase)) {
packageId = attribute.Value;
}
else if (String.Equals(attribute.Name.LocalName, "version", StringComparison.OrdinalIgnoreCase)) {
version = attribute.Value;
}
else if (String.Equals(attribute.Name.LocalName, "repository", StringComparison.OrdinalIgnoreCase)) {
repository = attribute.Value;
}
else {
throw new InvalidOperationException(String.Format("Unrecognized attribute {0} encountered in step Module.", attribute.Name.LocalName));
}
}
if (packageId == null) {
throw new InvalidOperationException("PackageId is required in a module declaration in a recipe file.");
}
// download and install module from the orchard feed or a custom feed if repository is specified.
var enforceVersion = version != null;
var installed = false;
PackagingEntry packagingEntry = null;
var packagingSource = _packagingSourceManager.GetSources().FirstOrDefault();
if (repository != null) {
packagingSource = new PackagingSource {FeedTitle = repository, FeedUrl = repository};
}
if (enforceVersion) {
packagingEntry = _packagingSourceManager.GetExtensionList(false, packagingSource,
packages => packages.Where(package =>
package.PackageType.Equals(DefaultExtensionTypes.Module) &&
package.Id.Equals(packageId, StringComparison.OrdinalIgnoreCase) &&
package.Version.Equals(version, StringComparison.OrdinalIgnoreCase))).FirstOrDefault();
}
else {
packagingEntry = _packagingSourceManager.GetExtensionList(false, packagingSource,
packages => packages.Where(package =>
package.PackageType.Equals(DefaultExtensionTypes.Module) &&
package.Id.Equals(packageId, StringComparison.OrdinalIgnoreCase) &&
package.IsLatestVersion)).FirstOrDefault();
}
if (packagingEntry != null) {
if (!ModuleAlreadyInstalled(packagingEntry.PackageId)) {
Logger.Information("Installing module {0}.", packagingEntry.Title);
_packageManager.Install(packagingEntry.PackageId, packagingEntry.Version, packagingSource.FeedUrl, HostingEnvironment.MapPath("~/"));
}
installed = true;
}
if (!installed) {
throw new InvalidOperationException(String.Format("Module {0} was not found in the specified location.", packageId));
}
}
public void ExecuteRecipeStep(RecipeContext recipeContext) {
var executionStep = _recipeExecutionSteps.FirstOrDefault(x => x.Names.Contains(recipeContext.RecipeStep.Name));
var recipeExecutionContext = new RecipeExecutionContext {ExecutionId = recipeContext.ExecutionId, RecipeStep = recipeContext.RecipeStep};
if (executionStep != null) {
Logger.Information("Executing recipe step '{0}'.", recipeContext.RecipeStep.Name);
executionStep.Execute(recipeExecutionContext);
Logger.Information("Finished executing recipe step '{0}'.", recipeContext.RecipeStep.Name);
recipeContext.Executed = true;
}
}
// <Data />
// Import Data.
public override void Execute(RecipeExecutionContext context) {
// Run the import.
BatchedInvoke(context, "Import", (itemId, nextIdentityValue, element, importContentSession, elementDictionary) => {
_orchardServices.ContentManager.Import(element, importContentSession);
});
// Invoke ImportCompleted.
BatchedInvoke(context, "ImportCompleted", (itemId, nextIdentityValue, element, importContentSession, elementDictionary) => {
_orchardServices.ContentManager.CompleteImport(element, importContentSession);
});
}
public override void Execute(RecipeExecutionContext context) {
var themeId = context.RecipeStep.Step.Attribute("id").Value;
Logger.Information("Setting site theme to '{0}'.", themeId);
try {
_siteThemeService.SetSiteTheme(themeId);
}
catch (Exception ex) {
Logger.Error(ex, "Error while setting site theme to '{0}'.", themeId);
throw;
}
}
public override void Execute(RecipeExecutionContext context) {
var root = context.RecipeStep.Step;
var homePageIdentifier = root.Attr("Id");
var homePageIdentity = !String.IsNullOrWhiteSpace(homePageIdentifier) ? new ContentIdentity(homePageIdentifier) : default(ContentIdentity);
var homePage = homePageIdentity != null ? _contentManager.ResolveIdentity(homePageIdentity) : default(ContentItem);
if (homePage != null)
_homeAliasService.PublishHomeAlias(homePage);
else {
var routeValueDictionary = root.Elements().ToDictionary(x => x.Name.LocalName.ToLower(), x => (object) x.Value);
_homeAliasService.PublishHomeAlias(new RouteValueDictionary(routeValueDictionary));
}
}
public override async Task ExecuteAsync(RecipeExecutionContext recipeContext)
{
var model = recipeContext.RecipeStep.Step.ToObject<ThemeStepModel>();
if (!String.IsNullOrEmpty(model.Site))
{
await _siteThemeService.SetSiteThemeAsync(model.Site);
}
if (!String.IsNullOrEmpty(model.Admin))
{
await _adminThemeService.SetAdminThemeAsync(model.Admin);
}
}
public override void Execute(RecipeExecutionContext context) {
foreach (var workflowDefinitionElement in context.RecipeStep.Step.Elements()) {
var workflowName = workflowDefinitionElement.Attribute("Name").Value;
Logger.Information("Importing workflow '{0}'.", workflowName);
try {
var workflowDefinition = GetOrCreateWorkflowDefinition(workflowName);
var activitiesElement = workflowDefinitionElement.Element("Activities");
var transitionsElement = workflowDefinitionElement.Element("Transitions");
var activitiesDictionary = new Dictionary<int, ActivityRecord>();
workflowDefinition.Enabled = Boolean.Parse(workflowDefinitionElement.Attribute("Enabled").Value);
foreach (var activityElement in activitiesElement.Elements()) {
var localId = Int32.Parse(activityElement.Attribute("Id").Value);
var activityName = activityElement.Attribute("Name").Value;
Logger.Information("Importing activity '{0}' with ID '{1}'.", activityName, localId);
var activity = new ActivityRecord {
Name = activityName,
Start = Boolean.Parse(activityElement.Attribute("Start").Value),
X = Int32.Parse(activityElement.Attribute("X").Value),
Y = Int32.Parse(activityElement.Attribute("Y").Value),
State = activityElement.Element("State").Value
};
activitiesDictionary.Add(localId, activity);
workflowDefinition.ActivityRecords.Add(activity);
}
foreach (var transitionElement in transitionsElement.Elements()) {
var sourceActivityId = Int32.Parse(transitionElement.Attribute("SourceActivityId").Value);
var sourceEndpoint = transitionElement.Attribute("SourceEndpoint").Value;
var destinationActivityId = Int32.Parse(transitionElement.Attribute("DestinationActivityId").Value);
var destinationEndpoint = transitionElement.Attribute("DestinationEndpoint").Value;
Logger.Information("Importing transition between activities '{0}' and '{1}'.", sourceActivityId, destinationActivityId);
workflowDefinition.TransitionRecords.Add(new TransitionRecord {
SourceActivityRecord = activitiesDictionary[sourceActivityId],
SourceEndpoint = sourceEndpoint,
DestinationActivityRecord = activitiesDictionary[destinationActivityId],
DestinationEndpoint = destinationEndpoint
});
}
}
catch (Exception ex) {
Logger.Error(ex, "Error while importing workflow '{0}'.", workflowName);
throw;
}
}
}
/*
<ContentDefinition>
<Types>
<Blog creatable="true">
<Body format="abodyformat"/>
</Blog>
</Types>
<Parts>
</Parts>
</ContentDefinition>
*/
// Set type settings and attach parts to types.
// Create dynamic parts.
public override void Execute(RecipeExecutionContext context) {
foreach (var metadataElement in context.RecipeStep.Step.Elements()) {
Logger.Debug("Processing element '{0}'.", metadataElement.Name.LocalName);
switch (metadataElement.Name.LocalName) {
case "Types":
foreach (var element in metadataElement.Elements()) {
var typeElement = element;
var typeName = XmlConvert.DecodeName(element.Name.LocalName);
Logger.Information("Importing content type '{0}'.", typeName);
try {
_contentDefinitonEventHandlers.ContentTypeImporting(new ContentTypeImportingContext { ContentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(typeName), ContentTypeName = typeName });
_contentDefinitionManager.AlterTypeDefinition(typeName, alteration => _contentDefinitionReader.Merge(typeElement, alteration));
_contentDefinitonEventHandlers.ContentTypeImported(new ContentTypeImportedContext { ContentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(typeName) });
}
catch (Exception ex) {
Logger.Error(ex, "Error while importing content type '{0}'.", typeName);
throw;
}
}
break;
case "Parts":
foreach (var element in metadataElement.Elements()) {
var partElement = element;
var partName = XmlConvert.DecodeName(element.Name.LocalName);
Logger.Information("Importing content part '{0}'.", partName);
try {
_contentDefinitonEventHandlers.ContentPartImporting(new ContentPartImportingContext { ContentPartDefinition = _contentDefinitionManager.GetPartDefinition(partName), ContentPartName = partName });
_contentDefinitionManager.AlterPartDefinition(partName, alteration => _contentDefinitionReader.Merge(partElement, alteration));
_contentDefinitonEventHandlers.ContentPartImported(new ContentPartImportedContext { ContentPartDefinition = _contentDefinitionManager.GetPartDefinition(partName)});
}
catch (Exception ex) {
Logger.Error(ex, "Error while importing content part '{0}'.", partName);
throw;
}
}
break;
default:
Logger.Warning("Unrecognized element '{0}' encountered; skipping", metadataElement.Name.LocalName);
break;
}
}
}
// <RemoveContent>
// <Page Id="{identifier}" />
// <BlogPost Id="{identifier}" />
// ...
// </RemoveContent>
public override void Execute(RecipeExecutionContext context) {
var identitiesQuery =
from element in context.RecipeStep.Step.Elements()
let id = element.Attr("Id")
where !String.IsNullOrWhiteSpace(id)
select new ContentIdentity(id);
foreach (var identity in identitiesQuery) {
Logger.Information("Removing content item with identity '{0}'...", identity);
var contentItem = _contentManager.ResolveIdentity(identity);
if (contentItem == null) {
Logger.Warning("No content item with identity '{0}' could be found.", identity);
continue;
}
_contentManager.Remove(contentItem);
Logger.Information("Content item with identity '{0}' was found with id '{1}' and has been successfully removed.", identity, contentItem.Id);
}
}
public override void Execute(RecipeExecutionContext context)
{
foreach (var elementElement in context.RecipeStep.Step.Elements()) {
var typeName = elementElement.Attribute("ElementTypeName").Value;
Logger.Information("Importing custom element '{0}'.", typeName);
try {
var element = GetOrCreateElement(typeName);
element.BaseElementTypeName = elementElement.Attribute("BaseElementTypeName").Value;
element.ElementDisplayName = elementElement.Attribute("ElementDisplayName").Value;
element.ElementDescription = elementElement.Attribute("ElementDescription").Value;
element.ElementCategory = elementElement.Attribute("ElementCategory").Value;
element.BaseElementState = elementElement.Element("BaseElementState").Value;
}
catch (Exception ex) {
Logger.Error(ex, "Error while importing custom element '{0}'.", typeName);
throw;
}
}
}
public override async Task ExecuteAsync(RecipeExecutionContext recipeContext)
{
var step = recipeContext.RecipeStep.Step.ToObject<InternalStep>();
var availableFeatures = _featureManager.GetAvailableFeaturesAsync().Result.Select(x => x.Id).ToArray();
foreach (var featureName in step.Disable)
{
if (!availableFeatures.Contains(featureName))
{
throw new InvalidOperationException(string.Format("Could not disable feature {0} because it was not found.", featureName));
}
}
foreach (var featureName in step.Enable)
{
if (!availableFeatures.Contains(featureName))
{
throw new InvalidOperationException(string.Format("Could not enable feature {0} because it was not found.", featureName));
}
}
if (step.Disable.Any())
{
if (Logger.IsEnabled(LogLevel.Information))
{
Logger.LogInformation("Disabling features: {0}", string.Join(";", step.Disable));
}
await _featureManager.DisableFeaturesAsync(step.Disable, true);
}
if (step.Enable.Any())
{
if (Logger.IsEnabled(LogLevel.Information))
{
Logger.LogInformation("Enabling features: {0}", string.Join(";", step.Enable));
}
await _featureManager.EnableFeaturesAsync(step.Enable, true);
}
}
/*
<Command>
command1
command2
command3
</Command>
*/
// Run Orchard commands.
public override void Execute(RecipeExecutionContext context)
{
var commands =
context.RecipeStep.Step.Value
.Split(new[] {"\r\n", "\n"}, StringSplitOptions.RemoveEmptyEntries)
.Select(commandEntry => commandEntry.Trim());
foreach (var command in commands) {
if (!String.IsNullOrEmpty(command)) {
Logger.Information("Executing command: {0}", command);
try {
var commandParameters = _commandParser.ParseCommandParameters(command);
var input = new StringReader("");
var output = new StringWriter();
_commandManager.Execute(new CommandParameters { Arguments = commandParameters.Arguments, Input = input, Output = output, Switches = commandParameters.Switches });
}
catch (Exception ex) {
Logger.Error(ex, "Error while executing command: {0}", command);
throw;
}
}
}
}
// <Migration features="f1, f2" />
// <Migration features="*" />
// Run migration for features.
public override void Execute(RecipeExecutionContext context) {
var runAll = false;
var features = new List<string>();
foreach (var attribute in context.RecipeStep.Step.Attributes()) {
if (String.Equals(attribute.Name.LocalName, "features", StringComparison.OrdinalIgnoreCase)) {
features = ParseFeatures(attribute.Value);
if (features.Contains("*"))
runAll = true;
}
else {
Logger.Warning("Unrecognized attribute '{0}' encountered; skipping.", attribute.Name.LocalName);
}
}
if (runAll) {
foreach (var feature in _dataMigrationManager.GetFeaturesThatNeedUpdate()) {
Logger.Information("Updating feature '{0}'.", feature);
try {
_dataMigrationManager.Update(feature);
}
catch (Exception ex) {
Logger.Error(ex, "Error while updating feature '{0}'", feature);
throw;
}
}
}
else {
Logger.Information("Updating features: {0}", String.Join(";", features));
try {
_dataMigrationManager.Update(features);
}
catch (Exception ex) {
Logger.Error(ex, "Error while updating features: {0}", String.Join(";", features));
throw;
}
}
}
// <Feature enable="f1,f2,f3" disable="f4" />
// Enable/Disable features.
public override void Execute(RecipeExecutionContext recipeContext) {
var featuresToEnable = new List<string>();
var featuresToDisable = new List<string>();
foreach (var attribute in recipeContext.RecipeStep.Step.Attributes()) {
if (String.Equals(attribute.Name.LocalName, "disable", StringComparison.OrdinalIgnoreCase)) {
featuresToDisable = ParseFeatures(attribute.Value);
}
else if (String.Equals(attribute.Name.LocalName, "enable", StringComparison.OrdinalIgnoreCase)) {
featuresToEnable = ParseFeatures(attribute.Value);
}
else {
Logger.Warning("Unrecognized attribute '{0}' encountered; skipping", attribute.Name.LocalName);
}
}
var availableFeatures = _featureManager.GetAvailableFeatures().Select(x => x.Id).ToArray();
foreach (var featureName in featuresToDisable) {
if (!availableFeatures.Contains(featureName)) {
throw new InvalidOperationException(string.Format("Could not disable feature {0} because it was not found.", featureName));
}
}
foreach (var featureName in featuresToEnable) {
if (!availableFeatures.Contains(featureName)) {
throw new InvalidOperationException(string.Format("Could not enable feature {0} because it was not found.", featureName));
}
}
if (featuresToDisable.Any()) {
Logger.Information("Disabling features: {0}", String.Join(";", featuresToDisable));
_featureManager.DisableFeatures(featuresToDisable, true);
}
if (featuresToEnable.Any()) {
Logger.Information("Enabling features: {0}", String.Join(";", featuresToEnable));
_featureManager.EnableFeatures(featuresToEnable, true);
}
}
public override void Execute(RecipeExecutionContext context) {
var formElements = context.RecipeStep.Step.Elements();
foreach (var formElement in formElements) {
var formName = formElement.Attr<string>("Name");
Logger.Information("Importing form '{0}'.", formName);
try {
var submissionElements = formElement.Element("Submissions").Elements().ToArray();
for (var i = 0; i < submissionElements.Length; i++) {
Logger.Information("Importing form submission {0}/{1}.", i + 1, submissionElements.Length);
var submissionElement = submissionElements[i];
_formService.CreateSubmission(new Submission {
FormName = formName,
CreatedUtc = submissionElement.Attr<DateTime>("CreatedUtc"),
FormData = submissionElement.Value
});
}
}
catch (Exception ex) {
Logger.Error(ex, "Error while importing form '{0}'.", formName);
throw;
}
}
}
private void BatchedInvoke(RecipeExecutionContext context, string batchLabel, Action<string, string, XElement, ImportContentSession, IDictionary<string, XElement>> contentItemAction) {
var importContentSession = new ImportContentSession(_orchardServices.ContentManager);
// Populate local dictionary with elements and their ids.
var elementDictionary = CreateElementDictionary(context.RecipeStep.Step);
// Populate import session with all identities to be imported.
foreach (var identity in elementDictionary.Keys) {
importContentSession.Set(identity, elementDictionary[identity].Name.LocalName);
}
// Determine if the import is to be batched in multiple transactions.
var batchSize = GetBatchSizeForDataStep(context.RecipeStep.Step);
var startIndex = 0;
var itemIndex = 0;
Logger.Debug("Using batch size {0} for '{1}'.", batchSize, batchLabel);
try {
while (startIndex < elementDictionary.Count) {
Logger.Debug("Batch '{0}' execution starting at index {1}.", batchLabel, startIndex);
importContentSession.InitializeBatch(startIndex, batchSize);
// The session determines which items are included in the current batch
// so that dependencies can be managed within the same transaction.
var nextIdentity = importContentSession.GetNextInBatch();
while (nextIdentity != null) {
var itemId = "";
var nextIdentityValue = nextIdentity.ToString();
if (elementDictionary[nextIdentityValue].HasAttributes) {
itemId = elementDictionary[nextIdentityValue].FirstAttribute.Value;
}
Logger.Information("Handling content item '{0}' (item {1}/{2} of '{3}').", itemId, itemIndex + 1, elementDictionary.Count, batchLabel);
try {
contentItemAction(itemId, nextIdentityValue, elementDictionary[nextIdentityValue], importContentSession, elementDictionary);
}
catch (Exception ex) {
Logger.Error(ex, "Error while handling content item '{0}' (item {1}/{2} of '{3}').", itemId, itemIndex + 1, elementDictionary.Count, batchLabel);
throw;
}
itemIndex++;
nextIdentity = importContentSession.GetNextInBatch();
}
startIndex += batchSize;
// Create a new transaction for each batch.
if (startIndex < elementDictionary.Count) {
_transactionManager.RequireNew();
}
Logger.Debug("Finished batch '{0}' starting at index {1}.", batchLabel, startIndex);
}
}
catch (Exception) {
// Ensure a failed batch is rolled back.
_transactionManager.Cancel();
throw;
}
}
public void ExecuteRecipeStepTest() {
_folders.Manifests.Add("SuperWiki", @"
Name: SuperWiki
Version: 1.0.3
OrchardVersion: 1
Features:
SuperWiki:
Description: My super wiki theme for Orchard.
");
_packagesInRepository.AddPublishedPackage(new PublishedPackage {
Id = "Orchard.Theme.SuperWiki",
PackageType = DefaultExtensionTypes.Theme,
Title = "SuperWiki",
Version = "1.0.3",
IsLatestVersion = true,
});
IShellDescriptorManager shellDescriptorManager = _container.Resolve<IShellDescriptorManager>();
// No features enabled.
shellDescriptorManager.UpdateShellDescriptor(0,
Enumerable.Empty<ShellFeature>(),
Enumerable.Empty<ShellParameter>());
var themeStep = _container.Resolve<ThemeStep>();
var recipeExecutionContext = new RecipeExecutionContext {RecipeStep = new RecipeStep (id: "1", recipeName: "Test", name: "Theme", step: new XElement("SuperWiki")) };
recipeExecutionContext.RecipeStep.Step.Add(new XAttribute("packageId", "Orchard.Theme.SuperWiki"));
recipeExecutionContext.RecipeStep.Step.Add(new XAttribute("repository", "test"));
var featureManager = _container.Resolve<IFeatureManager>();
var enabledFeatures = featureManager.GetEnabledFeatures();
Assert.That(enabledFeatures.Count(), Is.EqualTo(0));
themeStep.Execute(recipeExecutionContext);
// Without setting enable no feature should be activated...
featureManager.GetEnabledFeatures();
Assert.That(enabledFeatures.Count(), Is.EqualTo(0));
// Adding enable the feature should get active.
recipeExecutionContext.RecipeStep.Step.Add(new XAttribute("enable", true));
themeStep.Execute(recipeExecutionContext);
enabledFeatures = featureManager.GetEnabledFeatures();
Assert.That(enabledFeatures.FirstOrDefault(feature => feature.Id.Equals("SuperWiki")), Is.Not.Null);
Assert.That(enabledFeatures.Count(), Is.EqualTo(1));
}
public void ExecuteRecipeStepWithRepositoryAndVersionNotLatestTest() {
_packagesInRepository.AddPublishedPackage(new PublishedPackage {
Id = "Orchard.Theme.SuperWiki",
PackageType = DefaultExtensionTypes.Theme,
Title = "SuperWiki",
Version = "1.0.3",
IsLatestVersion = true,
});
_packagesInRepository.AddPublishedPackage(new PublishedPackage {
Id = "Orchard.Theme.SuperWiki",
PackageType = DefaultExtensionTypes.Theme,
Title = "SuperWiki",
Version = "1.0.2",
IsLatestVersion = false,
});
var themeStep = _container.Resolve<ThemeStep>();
var recipeExecutionContext = new RecipeExecutionContext { RecipeStep = new RecipeStep(id: "1", recipeName: "Test", name: "Theme", step: new XElement("SuperWiki")) };
recipeExecutionContext.RecipeStep.Step.Add(new XAttribute("packageId", "Orchard.Theme.SuperWiki"));
recipeExecutionContext.RecipeStep.Step.Add(new XAttribute("repository", "test"));
recipeExecutionContext.RecipeStep.Step.Add(new XAttribute("version", "1.0.2"));
themeStep.Execute(recipeExecutionContext);
var installedPackage = _packageManager.GetInstalledPackages().FirstOrDefault(info => info.ExtensionName == "Orchard.Theme.SuperWiki");
Assert.That(installedPackage, Is.Not.Null);
Assert.That(installedPackage.ExtensionVersion, Is.EqualTo("1.0.2"));
}
public void ExecuteRecipeStepNeedsNameTest() {
_folders.Manifests.Add("SuperWiki", @"
Name: SuperWiki
Version: 1.0.3
OrchardVersion: 1
Features:
SuperWiki:
Description: My super wiki module for Orchard.
");
var themeStep = _container.Resolve<ThemeStep>();
var recipeExecutionContext = new RecipeExecutionContext { RecipeStep = new RecipeStep(id: "1", recipeName: "Test", name: "Theme", step: new XElement("SuperWiki")) };
recipeExecutionContext.RecipeStep.Step.Add(new XAttribute("repository", "test"));
Assert.Throws(typeof (InvalidOperationException), () => themeStep.Execute(recipeExecutionContext));
}
public override void Execute(RecipeExecutionContext context)
{
_sweepGenerator.Activate();
}
public abstract void Execute(RecipeExecutionContext context);
public override async Task ExecuteAsync(RecipeExecutionContext recipeContext)
{
var model = recipeContext.RecipeStep.Step;
var site = await _siteService.GetSiteSettingsAsync();
if (model["BaseUrl"] != null)
{
site.BaseUrl = model["BaseUrl"].ToString();
}
if (model["Calendar"] != null)
{
site.Calendar = model["Calendar"].ToString();
}
if (model["Culture"] != null)
{
site.Culture = model["Culture"].ToString();
}
if (model["MaxPagedCount"] != null)
{
site.MaxPagedCount = model.Value<int>("MaxPagedCount");
}
if (model["MaxPageSize"] != null)
{
site.MaxPageSize = model.Value<int>("MaxPageSize");
}
if (model["PageSize"] != null)
{
site.PageSize = model.Value<int>("PageSize");
}
if (model["PageTitleSeparator"] != null)
{
site.PageTitleSeparator = model["PageTitleSeparator"].ToString();
}
if (model["ResourceDebugMode"] != null)
{
site.ResourceDebugMode = model.Value<ResourceDebugMode>("ResourceDebugMode");
}
if (model["SiteName"] != null)
{
site.SiteName = model["SiteName"].ToString();
}
if (model["SiteSalt"] != null)
{
site.SiteSalt = model["SiteSalt"].ToString();
}
if (model["SuperUser"] != null)
{
site.SuperUser = model["SuperUser"].ToString();
}
if (model["TimeZone"] != null)
{
site.TimeZone = model["TimeZone"].ToString();
}
if (model["UseCdn"] != null)
{
site.UseCdn = model.Value<bool>("UseCdn");
}
if (model["HomeRoute"] != null)
{
site.HomeRoute = model["HomeRoute"].ToObject<RouteValueDictionary>();
}
await _siteService.UpdateSiteSettingsAsync(site);
}
