public async Task <IActionResult> Purge()
{
if (!await _authorizationService.AuthorizeAsync(User, MediaCachePermissions.ManageAssetCache))
{
return(Forbid());
}
if (_mediaFileStoreCache == null)
{
await _notifier.ErrorAsync(H["The asset cache feature is enabled, but a remote media store feature is not enabled, or not configured with appsettings.json."]);
RedirectToAction(nameof(Index));
}
var hasErrors = await _mediaFileStoreCache.PurgeAsync();
if (hasErrors)
{
await _notifier.ErrorAsync(H["Asset cache purged, with errors."]);
}
else
{
await _notifier.InformationAsync(H["Asset cache purged."]);
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Delete(string id)
{
var user = await _userManager.FindByIdAsync(id) as User;
if (user == null)
{
return(NotFound());
}
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageUsers, user))
{
return(Forbid());
}
var result = await _userManager.DeleteAsync(user);
if (result.Succeeded)
{
await _notifier.SuccessAsync(H["User deleted successfully."]);
}
else
{
await _session.CancelAsync();
await _notifier.ErrorAsync(H["Could not delete the user."]);
foreach (var error in result.Errors)
{
await _notifier.ErrorAsync(H[error.Description]);
}
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Delete(string id)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageRoles))
{
return(Forbid());
}
var currentRole = await _roleManager.FindByIdAsync(id);
if (currentRole == null)
{
return(NotFound());
}
var result = await _roleManager.DeleteAsync(currentRole);
if (result.Succeeded)
{
await _notifier.SuccessAsync(H["Role deleted successfully."]);
}
else
{
await _documentStore.CancelAsync();
await _notifier.ErrorAsync(H["Could not delete this role."]);
foreach (var error in result.Errors)
{
await _notifier.ErrorAsync(H[error.Description]);
}
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Import(IFormFile importedPackage)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.Import))
{
return(Forbid());
}
if (importedPackage != null)
{
var tempArchiveName = Path.GetTempFileName() + Path.GetExtension(importedPackage.FileName);
var tempArchiveFolder = PathExtensions.Combine(Path.GetTempPath(), Path.GetRandomFileName());
try
{
using (var stream = new FileStream(tempArchiveName, FileMode.Create))
{
await importedPackage.CopyToAsync(stream);
}
if (importedPackage.FileName.EndsWith(".zip"))
{
ZipFile.ExtractToDirectory(tempArchiveName, tempArchiveFolder);
}
else if (importedPackage.FileName.EndsWith(".json"))
{
Directory.CreateDirectory(tempArchiveFolder);
System.IO.File.Move(tempArchiveName, Path.Combine(tempArchiveFolder, "Recipe.json"));
}
else
{
await _notifier.ErrorAsync(H["Only zip or json files are supported."]);
return(RedirectToAction(nameof(Index)));
}
await _deploymentManager.ImportDeploymentPackageAsync(new PhysicalFileProvider(tempArchiveFolder));
await _notifier.SuccessAsync(H["Deployment package imported."]);
}
finally
{
if (System.IO.File.Exists(tempArchiveName))
{
System.IO.File.Delete(tempArchiveName);
}
if (Directory.Exists(tempArchiveFolder))
{
Directory.Delete(tempArchiveFolder, true);
}
}
}
else
{
await _notifier.ErrorAsync(H["Please add a file to import."]);
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Delete(string name)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageLayers))
{
return(Forbid());
}
var layers = await _layerService.LoadLayersAsync();
var layer = layers.Layers.FirstOrDefault(x => String.Equals(x.Name, name));
if (layer == null)
{
return(NotFound());
}
var widgets = await _layerService.GetLayerWidgetsMetadataAsync(c => c.Latest == true);
if (!widgets.Any(x => String.Equals(x.Layer, name, StringComparison.OrdinalIgnoreCase)))
{
layers.Layers.Remove(layer);
await _layerService.UpdateAsync(layers);
await _notifier.SuccessAsync(H["Layer deleted successfully."]);
}
else
{
await _notifier.ErrorAsync(H["The layer couldn't be deleted: you must remove any associated widgets first."]);
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> PurgeAll()
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageSitemaps))
{
return(Forbid());
}
var hasErrors = await _sitemapCacheProvider.PurgeAllAsync();
if (hasErrors)
{
await _notifier.ErrorAsync(H["Sitemap cache purged, with errors."]);
}
else
{
await _notifier.InformationAsync(H["Sitemap cache purged."]);
}
return(RedirectToAction(nameof(List)));
}
public async Task <IActionResult> Disable(string id)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageTenants))
{
return(Forbid());
}
if (!_currentShellSettings.IsDefaultShell())
{
return(Forbid());
}
var shellSettings = _shellHost.GetAllSettings()
.Where(s => String.Equals(s.Name, id, StringComparison.OrdinalIgnoreCase))
.FirstOrDefault();
if (shellSettings == null)
{
return(NotFound());
}
if (String.Equals(shellSettings.Name, ShellHelper.DefaultShellName, StringComparison.OrdinalIgnoreCase))
{
await _notifier.ErrorAsync(H["You cannot disable the default tenant."]);
return(RedirectToAction(nameof(Index)));
}
if (shellSettings.State != TenantState.Running)
{
await _notifier.ErrorAsync(H["You can only disable an Enabled tenant."]);
return(RedirectToAction(nameof(Index)));
}
shellSettings.State = TenantState.Disabled;
await _shellHost.UpdateShellSettingsAsync(shellSettings);
return(RedirectToAction(nameof(Index)));
}
public async Task <ActionResult> Execute(string basePath, string fileName)
{
if (!await _authorizationService.AuthorizeAsync(User, StandardPermissions.SiteOwner))
{
return(Forbid());
}
var features = await _shellFeaturesManager.GetAvailableFeaturesAsync();
var recipes = await GetRecipesAsync(features);
var recipe = recipes.FirstOrDefault(c => c.RecipeFileInfo.Name == fileName && c.BasePath == basePath);
if (recipe == null)
{
await _notifier.ErrorAsync(H["Recipe was not found."]);
return(RedirectToAction(nameof(Index)));
}
var environment = new Dictionary <string, object>();
await _environmentProviders.OrderBy(x => x.Order).InvokeAsync((provider, env) => provider.PopulateEnvironmentAsync(env), environment, _logger);
var executionId = Guid.NewGuid().ToString("n");
// Set shell state to "Initializing" so that subsequent HTTP requests
// are responded to with "Service Unavailable" while running the recipe.
_shellSettings.State = TenantState.Initializing;
try
{
await _recipeExecutor.ExecuteAsync(executionId, recipe, environment, CancellationToken.None);
}
finally
{
// Don't lock the tenant if the recipe fails.
_shellSettings.State = TenantState.Running;
}
await _shellHost.ReleaseShellContextAsync(_shellSettings);
await _notifier.SuccessAsync(H["The recipe '{0}' has been run successfully.", recipe.DisplayName]);
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Edit(AdminNodeEditViewModel model)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageAdminMenu))
{
return(Forbid());
}
var adminMenuList = await _adminMenuService.LoadAdminMenuListAsync();
var adminMenu = _adminMenuService.GetAdminMenuById(adminMenuList, model.AdminMenuId);
if (adminMenu == null)
{
return(NotFound());
}
var treeNode = adminMenu.GetMenuItemById(model.AdminNodeId);
if (treeNode == null)
{
return(NotFound());
}
var editor = await _displayManager.UpdateEditorAsync(treeNode, updater : _updateModelAccessor.ModelUpdater, isNew : false);
if (ModelState.IsValid)
{
treeNode.Priority = model.Priority;
treeNode.Position = model.Position;
await _adminMenuService.SaveAsync(adminMenu);
await _notifier.SuccessAsync(H["Admin node updated successfully."]);
return(RedirectToAction(nameof(List), new { id = model.AdminMenuId }));
}
await _notifier.ErrorAsync(H["The admin node has validation errors."]);
model.Editor = editor;
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> Edit(LayerRuleEditViewModel model)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageLayers))
{
return(Forbid());
}
var layers = await _layerService.LoadLayersAsync();
var layer = layers.Layers.FirstOrDefault(x => String.Equals(x.Name, model.Name));
if (layer == null)
{
return(NotFound());
}
var condition = FindCondition(layer.LayerRule, model.ConditionId);
if (condition == null)
{
return(NotFound());
}
var editor = await _displayManager.UpdateEditorAsync(condition, updater : _updateModelAccessor.ModelUpdater, isNew : false);
if (ModelState.IsValid)
{
await _layerService.UpdateAsync(layers);
await _notifier.SuccessAsync(H["Condition updated successfully."]);
return(RedirectToAction(nameof(Edit), "Admin", new { name = model.Name }));
}
await _notifier.ErrorAsync(H["The condition has validation errors."]);
model.Editor = editor;
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> Edit(EditSourceViewModel model)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageSitemaps))
{
return(Forbid());
}
var sitemap = await _sitemapManager.LoadSitemapAsync(model.SitemapId);
if (sitemap == null)
{
return(NotFound());
}
var source = sitemap.SitemapSources.FirstOrDefault(x => String.Equals(x.Id, model.SitemapSourceId, StringComparison.OrdinalIgnoreCase));
if (source == null)
{
return(NotFound());
}
var editor = await _displayManager.UpdateEditorAsync(source, updater : _updateModelAccessor.ModelUpdater, isNew : false);
if (ModelState.IsValid)
{
await _sitemapManager.UpdateSitemapAsync(sitemap);
await _notifier.SuccessAsync(H["Sitemap source updated successfully."]);
return(RedirectToAction("Display", "Admin", new { sitemapId = model.SitemapId }));
}
await _notifier.ErrorAsync(H["The sitemap source has validation errors."]);
model.Editor = editor;
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> Edit(EditDeploymentPlanStepViewModel model)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageDeploymentPlan))
{
return(Forbid());
}
var deploymentPlan = await _session.GetAsync <DeploymentPlan>(model.DeploymentPlanId);
if (deploymentPlan == null)
{
return(NotFound());
}
var step = deploymentPlan.DeploymentSteps.FirstOrDefault(x => String.Equals(x.Id, model.DeploymentStepId, StringComparison.OrdinalIgnoreCase));
if (step == null)
{
return(NotFound());
}
var editor = await _displayManager.UpdateEditorAsync(step, updater : _updateModelAccessor.ModelUpdater, isNew : false);
if (ModelState.IsValid)
{
_session.Save(deploymentPlan);
await _notifier.SuccessAsync(H["Deployment plan step updated successfully."]);
return(RedirectToAction("Display", "DeploymentPlan", new { id = model.DeploymentPlanId }));
}
await _notifier.ErrorAsync(H["The deployment plan step has validation errors."]);
model.Editor = editor;
// If we got this far, something failed, redisplay form
return(View(model));
}
public override async Task <IDisplayResult> UpdateAsync(ContentItem model, IUpdateModel updater)
{
var httpContext = _httpContextAccessor.HttpContext;
var action = (string)httpContext.Request.Form["submit.Save"] ?? httpContext.Request.Form["submit.Publish"];
if (action?.StartsWith("user-task.", StringComparison.Ordinal) == true)
{
action = action.Substring("user-task.".Length);
var availableActions = await GetUserTaskActionsAsync(model.ContentItemId);
if (!availableActions.Contains(action))
{
await _notifier.ErrorAsync(H["Not authorized to trigger '{0}'.", action]);
}
else
{
var contentEvent = new ContentEventContext()
{
Name = nameof(UserTaskEvent),
ContentType = model.ContentType,
ContentItemId = model.ContentItemId
};
var input = new Dictionary <string, object>
{
{ ContentEventConstants.UserActionInputKey, action },
{ ContentEventConstants.ContentItemInputKey, model },
{ ContentEventConstants.ContentEventInputKey, contentEvent }
};
await _workflowManager.TriggerEventAsync(nameof(UserTaskEvent), input, correlationId : model.ContentItemId);
}
}
return(Edit(model));
}
public async Task <IActionResult> Execute(int id, string remoteInstanceId, string returnUrl)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.Export))
{
return(Forbid());
}
var deploymentPlan = await _session.GetAsync <DeploymentPlan>(id);
if (deploymentPlan == null)
{
return(NotFound());
}
var remoteInstance = await _service.GetRemoteInstanceAsync(remoteInstanceId);
if (remoteInstance == null)
{
return(NotFound());
}
string archiveFileName;
var filename = deploymentPlan.Name.ToSafeName() + ".zip";
using (var fileBuilder = new TemporaryFileBuilder())
{
archiveFileName = PathExtensions.Combine(Path.GetTempPath(), filename);
var deploymentPlanResult = new DeploymentPlanResult(fileBuilder, new RecipeDescriptor());
await _deploymentManager.ExecuteDeploymentPlanAsync(deploymentPlan, deploymentPlanResult);
if (System.IO.File.Exists(archiveFileName))
{
System.IO.File.Delete(archiveFileName);
}
ZipFile.CreateFromDirectory(fileBuilder.Folder, archiveFileName);
}
HttpResponseMessage response;
try
{
using (var requestContent = new MultipartFormDataContent())
{
requestContent.Add(new StreamContent(
new FileStream(archiveFileName,
FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 1, FileOptions.Asynchronous | FileOptions.SequentialScan)
),
nameof(ImportViewModel.Content), Path.GetFileName(archiveFileName));
requestContent.Add(new StringContent(remoteInstance.ClientName), nameof(ImportViewModel.ClientName));
requestContent.Add(new StringContent(remoteInstance.ApiKey), nameof(ImportViewModel.ApiKey));
response = await _httpClient.PostAsync(remoteInstance.Url, requestContent);
}
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
await _notifier.SuccessAsync(H["Deployment executed successfully."]);
}
else
{
await _notifier.ErrorAsync(H["An error occurred while sending the deployment to the remote instance: \"{0} ({1})\"", response.ReasonPhrase, (int)response.StatusCode]);
}
}
finally
{
System.IO.File.Delete(archiveFileName);
}
if (!string.IsNullOrEmpty(returnUrl))
{
return(this.LocalRedirect(returnUrl, true));
}
return(RedirectToAction("Display", "DeploymentPlan", new { area = "OrchardCore.Deployment", id }));
}
public async Task <IActionResult> Edit(EditShapePlacementViewModel viewModel, string submit, string returnUrl = null)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManagePlacements))
{
return(Forbid());
}
ViewData["ReturnUrl"] = returnUrl;
if (viewModel.Creating && await _placementsManager.GetShapePlacementsAsync(viewModel.ShapeType) != null)
{
// Prevent overriding existing rules on creation
await _notifier.WarningAsync(H["Placement rules for \"{0}\" already exists. Please edit existing rule.", viewModel.ShapeType]);
return(View(viewModel));
}
try
{
IEnumerable <PlacementNode> placementNodes = JsonConvert.DeserializeObject <PlacementNode[]>(viewModel.Nodes) ?? new PlacementNode[0];
// Remove empty nodes
placementNodes = placementNodes.Where(node => !IsEmpty(node));
if (placementNodes.Any())
{
// Save
await _placementsManager.UpdateShapePlacementsAsync(viewModel.ShapeType, placementNodes);
viewModel.Creating = false;
await _notifier.SuccessAsync(H["The \"{0}\" placement have been saved.", viewModel.ShapeType]);
}
else if (viewModel.Creating)
{
await _notifier.WarningAsync(H["The \"{0}\" placement is empty.", viewModel.ShapeType]);
return(View(viewModel));
}
else
{
// Remove if empty
await _placementsManager.RemoveShapePlacementsAsync(viewModel.ShapeType);
await _notifier.SuccessAsync(H["The \"{0}\" placement has been deleted.", viewModel.ShapeType]);
}
}
catch (JsonReaderException jsonException)
{
await _notifier.ErrorAsync(H["An error occurred while parsing the placement<br/>{0}", jsonException.Message]);
return(View(viewModel));
}
catch (Exception e)
{
await _notifier.ErrorAsync(H["An error occurred while saving the placement."]);
_logger.LogError(e, "An error occurred while saving the placement.");
return(View(viewModel));
}
if (submit != "SaveAndContinue")
{
return(RedirectToReturnUrlOrIndex(returnUrl));
}
return(View(viewModel));
}
public async Task <ActionResult> EditPost(LuceneIndexSettingsViewModel model, string[] indexedContentTypes)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageIndexes))
{
return(Forbid());
}
ValidateModel(model);
if (model.IsCreate)
{
if (_luceneIndexManager.Exists(model.IndexName))
{
ModelState.AddModelError(nameof(LuceneIndexSettingsViewModel.IndexName), S["An index named {0} already exists.", model.IndexName]);
}
}
else
{
if (!_luceneIndexManager.Exists(model.IndexName))
{
ModelState.AddModelError(nameof(LuceneIndexSettingsViewModel.IndexName), S["An index named {0} doesn't exist.", model.IndexName]);
}
}
if (!ModelState.IsValid)
{
model.Cultures = CultureInfo.GetCultures(CultureTypes.AllCultures)
.Select(x => new SelectListItem {
Text = x.Name + " (" + x.DisplayName + ")", Value = x.Name
}).Prepend(new SelectListItem {
Text = S["Any culture"], Value = "any"
});
model.Analyzers = _luceneAnalyzerManager.GetAnalyzers()
.Select(x => new SelectListItem {
Text = x.Name, Value = x.Name
});
return(View(model));
}
if (model.IsCreate)
{
try
{
var settings = new LuceneIndexSettings {
IndexName = model.IndexName, AnalyzerName = model.AnalyzerName, IndexLatest = model.IndexLatest, IndexedContentTypes = indexedContentTypes, Culture = model.Culture ?? ""
};
// We call Rebuild in order to reset the index state cursor too in case the same index
// name was also used previously.
await _luceneIndexingService.CreateIndexAsync(settings);
}
catch (Exception e)
{
await _notifier.ErrorAsync(H["An error occurred while creating the index."]);
_logger.LogError(e, "An error occurred while creating an index.");
return(View(model));
}
await _notifier.SuccessAsync(H["Index <em>{0}</em> created successfully.", model.IndexName]);
}
else
{
try
{
var settings = new LuceneIndexSettings {
IndexName = model.IndexName, AnalyzerName = model.AnalyzerName, IndexLatest = model.IndexLatest, IndexedContentTypes = indexedContentTypes, Culture = model.Culture ?? ""
};
await _luceneIndexingService.UpdateIndexAsync(settings);
}
catch (Exception e)
{
await _notifier.ErrorAsync(H["An error occurred while editing the index."]);
_logger.LogError(e, "An error occurred while editing an index.");
return(View(model));
}
await _notifier.SuccessAsync(H["Index <em>{0}</em> modified successfully, <strong>please consider doing a rebuild on the index.</strong>", model.IndexName]);
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> List(ContentOptions options, PagerParameters pagerParameters)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageAdminMenu))
{
return(Forbid());
}
var siteSettings = await _siteService.GetSiteSettingsAsync();
var pager = new Pager(pagerParameters, siteSettings.PageSize);
var adminMenuList = (await _adminMenuService.GetAdminMenuListAsync()).AdminMenu;
if (!string.IsNullOrWhiteSpace(options.Search))
{
adminMenuList = adminMenuList.Where(x => x.Name.Contains(options.Search, StringComparison.OrdinalIgnoreCase)).ToList();
}
var count = adminMenuList.Count();
var startIndex = pager.GetStartIndex();
var pageSize = pager.PageSize;
IEnumerable <Models.AdminMenu> results = new List <Models.AdminMenu>();
//todo: handle the case where there is a deserialization exception on some of the presets.
// load at least the ones without error. Provide a way to delete the ones on error.
try
{
results = adminMenuList
.Skip(startIndex)
.Take(pageSize)
.ToList();
}
catch (Exception ex)
{
_logger.LogError(ex, "Error when retrieving the list of admin menus.");
await _notifier.ErrorAsync(H["Error when retrieving the list of admin menus."]);
}
// Maintain previous route data when generating page links
var routeData = new RouteData();
routeData.Values.Add("Options.Search", options.Search);
var pagerShape = (await New.Pager(pager)).TotalItemCount(count).RouteData(routeData);
var model = new AdminMenuListViewModel
{
AdminMenu = results.Select(x => new AdminMenuEntry {
AdminMenu = x
}).ToList(),
Options = options,
Pager = pagerShape
};
model.Options.ContentsBulkAction = new List <SelectListItem>()
{
new SelectListItem()
{
Text = S["Delete"], Value = nameof(ContentsBulkAction.Remove)
}
};
return(View(model));
}
