private async Task <IActionResult> EditPOST(string contentItemId, string displayText, string title, AdvancedFormSubmissions viewModel, Func <ContentItem, Task> conditionallyPublish)
{
var contentItem = await _contentManager.GetAsync(contentItemId, VersionOptions.DraftRequired);
if (contentItem == null)
{
return(NotFound());
}
//if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageAdvancedForms, contentItem))
//{
// return Unauthorized();
//}
string guid = contentItem.ContentItemId;
contentItem.Content.AdvancedFormSubmissions = JToken.FromObject(viewModel);
contentItem.DisplayText = displayText;
contentItem.Author = User.Identity.Name;
contentItem.Owner = viewModel.Owner;
contentItem.Content.AutoroutePart.Path = CreatePath(title, guid);
await conditionallyPublish(contentItem);
// The content item needs to be marked as saved (again) in case the drivers or the handlers have
// executed some query which would flush the saved entities. In this case the changes happening in handlers
// would not be taken into account.
_session.Save(contentItem);
var typeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType);
return(Ok(contentItem));
}
public void CreateOrUpdateDeploymentPlans(IEnumerable <DeploymentPlan> deploymentPlans)
{
foreach (var deploymentPlan in deploymentPlans)
{
_session.Save(deploymentPlan);
}
}
public async Task RecordEventAsync <TEvent>(AuditTrailContext <TEvent> context) where TEvent : class, new()
{
if (_shellSettings.State == TenantState.Initializing && String.IsNullOrEmpty(context.UserName))
{
var feature = _httpContextAccessor.HttpContext.Features.Get <RecipeEnvironmentFeature>();
if (feature != null && feature.Properties.TryGetValue(SetupConstants.AdminUsername, out var adminUsername))
{
context.UserName = (string)adminUsername;
}
}
var descriptor = DescribeEvent(context.Name, context.Category);
if (descriptor == null || !await IsEventEnabledAsync(descriptor))
{
return;
}
var createContext = new AuditTrailCreateContext <TEvent>(
context.Name,
context.Category,
context.CorrelationId,
context.UserId,
context.UserName,
context.AuditTrailEventItem
);
await _auditTrailEventHandlers.InvokeAsync((handler, context) => handler.CreateAsync(context), createContext, _logger);
var auditTrailEvent = new AuditTrailEvent
{
EventId = _auditTrailIdGenerator.GenerateUniqueId(),
Category = createContext.Category,
Name = createContext.Name,
CorrelationId = createContext.CorrelationId,
UserId = createContext.UserId,
UserName = createContext.UserName ?? "",
NormalizedUserName = String.IsNullOrEmpty(createContext.UserName) ? "" : _keyNormalizer.NormalizeName(createContext.UserName),
ClientIpAddress = String.IsNullOrEmpty(createContext.ClientIpAddress)
? await GetClientIpAddressAsync()
: createContext.ClientIpAddress,
CreatedUtc = createContext.CreatedUtc ?? _clock.UtcNow
};
auditTrailEvent.Put(createContext.AuditTrailEventItem);
await _auditTrailEventHandlers.InvokeAsync((handler, context, auditTrailEvent) => handler.AlterAsync(context, auditTrailEvent), createContext, auditTrailEvent, _logger);
_session.Save(auditTrailEvent, AuditTrailEvent.Collection);
}
public async Task CreateOrUpdateDeploymentPlansAsync(IEnumerable <DeploymentPlan> deploymentPlans)
{
var names = deploymentPlans.Select(x => x.Name);
var existingDeploymentPlans = (await _session.Query <DeploymentPlan, DeploymentPlanIndex>(x => x.Name.IsIn(names))
.ListAsync())
.ToDictionary(x => x.Name, StringComparer.OrdinalIgnoreCase);
foreach (var deploymentPlan in deploymentPlans)
{
if (existingDeploymentPlans.TryGetValue(deploymentPlan.Name, out var existingDeploymentPlan))
{
existingDeploymentPlan.Name = deploymentPlan.Name;
existingDeploymentPlan.DeploymentSteps.Clear();
existingDeploymentPlan.DeploymentSteps.AddRange(deploymentPlan.DeploymentSteps);
_session.Save(existingDeploymentPlan);
}
else
{
_session.Save(deploymentPlan);
}
}
}
public async Task <ActionResult> Restore(string auditTrailEventId)
{
var auditTrailEventToRestore = await _session.Query <AuditTrailEvent, AuditTrailEventIndex>()
.Where(auditTrailEventIndex => auditTrailEventIndex.AuditTrailEventId == auditTrailEventId)
.FirstOrDefaultAsync();
var contentItemToRestore = auditTrailEventToRestore.Get(auditTrailEventToRestore.EventName)
.ToObject <ContentItem>();
var auditTrailEvent = await _session.Query <AuditTrailEvent, ContentAuditTrailEventIndex>()
.Where(eventIndex => eventIndex.ContentItemId == contentItemToRestore.ContentItemId &&
eventIndex.EventName != "Saved")
.OrderByDescending(eventIndex => eventIndex.VersionNumber)
.FirstOrDefaultAsync();
var latestContentItem = auditTrailEvent.Get(auditTrailEvent.EventName).ToObject <ContentItem>();
if (!await _authorizationService.AuthorizeAsync(User, CommonPermissions.PublishContent, latestContentItem))
{
return(Forbid());
}
var activeVersions = await _session.Query <ContentItem, ContentItemIndex>()
.Where(contentItemIndex =>
contentItemIndex.ContentItemId == latestContentItem.ContentItemId &&
(contentItemIndex.Published || contentItemIndex.Latest)).ListAsync();
if (activeVersions.Any())
{
foreach (var version in activeVersions)
{
version.Published = false;
version.Latest = false;
_session.Save(version);
}
}
// Adding this item to HttpContenxt.Items is necessary to be able to know that an earlier version of this
// event has been restored, not a new one has been created.
_hca.HttpContext.Items.Add("OrchardCore.AuditTrail.Restored", contentItemToRestore);
contentItemToRestore.Latest = true;
await _contentManager.CreateAsync(contentItemToRestore, VersionOptions.Draft);
_notifier.Information(H["{0} has been restored.", contentItemToRestore.DisplayText]);
return(RedirectToAction(nameof(AdminController.Index), "Admin"));
}
public async Task AddAuditTrailEventAsync <TAuditTrailEventProvider>(AuditTrailContext auditTrailContext)
where TAuditTrailEventProvider : IAuditTrailEventProvider
{
var eventDescriptors = DescribeEvents(auditTrailContext.EventName, typeof(TAuditTrailEventProvider).FullName);
foreach (var eventDescriptor in eventDescriptors)
{
if (!await IsEventEnabledAsync(eventDescriptor))
{
return;
}
var auditTrailCreateContext = new AuditTrailCreateContext(
auditTrailContext.EventName,
auditTrailContext.UserName,
auditTrailContext.EventData,
auditTrailContext.EventFilterKey,
auditTrailContext.EventFilterData);
_auditTrailEventHandlers.Invoke((handler, context)
=> handler.CreateAsync(context), auditTrailCreateContext, Logger);
var auditTrailEvent = new AuditTrailEvent
{
Id = _iidGenerator.GenerateUniqueId(),
Category = eventDescriptor.CategoryDescriptor.Category,
EventName = auditTrailCreateContext.EventName,
FullEventName = eventDescriptor.FullEventName,
UserName = !string.IsNullOrEmpty(auditTrailCreateContext.UserName) ? auditTrailContext.UserName : T["[empty]"],
CreatedUtc = auditTrailCreateContext.CreatedUtc ?? _clock.UtcNow,
Comment = auditTrailCreateContext.Comment.NewlinesToHtml(),
EventFilterData = auditTrailCreateContext.EventFilterData,
EventFilterKey = auditTrailCreateContext.EventFilterKey,
ClientIpAddress = string.IsNullOrEmpty(auditTrailCreateContext.ClientIpAddress) ?
await GetClientAddressAsync() : auditTrailCreateContext.ClientIpAddress
};
eventDescriptor.BuildAuditTrailEvent(auditTrailEvent, auditTrailCreateContext.EventData);
_session.Save(auditTrailEvent);
}
}
public async Task <ContentItem> JoinTeam(string teamContentItemId, ModelStateDictionary modelState)
{
var user = await GetParticipantAsync();
if (user == null || !user.RoleNames.Contains("Hacker"))
{
modelState.AddModelError("error", T["You are not a hacker"].Value);
return(null);
}
if (user.HasTeam())
{
modelState.AddModelError("error", T["Already have a team"].Value);
return(null);
}
var team = await _contentManager.GetAsync(teamContentItemId);
if (team == null)
{
modelState.AddModelError("error", T["Team does not exist"].Value);
return(null);
}
if (await IsTeamFull(teamContentItemId))
{
modelState.AddModelError("error", T["Team is full"]);
return(null);
}
var contentItem = await GetSettings(user, "Hacker");
contentItem.Content.Hacker.Team = JObject.FromObject(new { ContentItemIds = new string[] { team.ContentItemId } });
user.Properties["Hacker"] = JObject.FromObject(contentItem);
_session.Save(user);
return(team);
}
public async Task SetInitialOrder(string contentType)
{
// Set initial order for published and drafts if they have never been published.
var contanerContentItemsQuery = _session.QueryIndex <ContentItemIndex>(x => x.ContentType == contentType && (x.Published || x.Latest));
var containerContentItems = await contanerContentItemsQuery.ListAsync();
if (!containerContentItems.Any())
{
return;
}
// Reduce duplicates to only set order for the published container item and the draft item if it has not been published.
var containerContentItemIds = containerContentItems.Select(x => x.ContentItemId).Distinct();
var containedItemsQuery = _session.Query <ContentItem>()
.With <ContainedPartIndex>(x => x.ListContentItemId.IsIn(containerContentItemIds))
.With <ContentItemIndex>(ci => ci.Latest || ci.Published)
.OrderByDescending(x => x.CreatedUtc);
// Load items so that loading handlers are invoked.
var contentItemGroups = (await containedItemsQuery.ListAsync(_contentManager)).ToLookup(l => l.As <ContainedPart>()?.ListContentItemId);
foreach (var contentItemGroup in contentItemGroups)
{
var i = 0;
foreach (var contentItem in contentItemGroup)
{
var containedPart = contentItem.As <ContainedPart>();
if (containedPart != null)
{
if (contentItem.Published && contentItem.Latest)
{
containedPart.Order = i;
containedPart.Apply();
}
else if (contentItem.Latest && !contentItem.Published)
{
// Update the latest order.
containedPart.Order = i;
containedPart.Apply();
// If a published version exists, find it, and set it to the same order as the draft.
var publishedItem = contentItemGroup.FirstOrDefault(p => p.Published == true && p.ContentItemId == contentItem.ContentItemId);
var publishedContainedPart = publishedItem?.As <ContainedPart>();
if (publishedContainedPart != null)
{
publishedContainedPart.Order = i;
publishedContainedPart.Apply();
}
}
else if (contentItem.Published && !contentItem.Latest)
{
// If a latest version exists, it will handle updating the order.
var latestItem = contentItemGroup.FirstOrDefault(l => l.Latest == true && l.ContentItemId == contentItem.ContentItemId);
if (latestItem == null)
{
// Apply order to the published item.
containedPart.Order = i;
containedPart.Apply();
}
else
{
// Order of this item will be updated when latest is iterated.
continue;
}
}
_session.Save(contentItem);
}
i++;
}
}
}
private async Task <IActionResult> EditPOST(AdvancedFormViewModel viewModel, string returnUrl, Func <ContentItem, Task> conditionallyPublish, bool isEditPage = false)
{
string contentItemId = viewModel.Id;
var contentItem = await _contentManager.GetAsync(contentItemId, VersionOptions.DraftRequired);
if (contentItem == null)
{
return(NotFound());
}
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageAdvancedForms, contentItem))
{
return(Unauthorized());
}
var advForm = new AdvancedForm(viewModel.Description, viewModel.Instructions,
viewModel.Container, viewModel.Title, viewModel.Header, viewModel.Footer, viewModel.Type, viewModel.AdminContainer, viewModel.HideFromListing, viewModel.IsGlobalHeader, viewModel.IsGlobalFooter, viewModel.Group, viewModel.FormFields);
contentItem.Content.AdvancedForm = JToken.FromObject(advForm);
contentItem.DisplayText = viewModel.Title;
var path = CreatePath(viewModel.Title);
contentItem.Content.AutoroutePart.Path = path;
contentItem.Alter <OrchardCore.Autoroute.Model.AutoroutePart>(x => x.Path = path);
var model = new AdvancedFormViewModel
{
Id = viewModel.Id,
Title = contentItem.DisplayText,
Container = contentItem.Content.AdvancedForm.Container.Html != null?JsonConvert.SerializeObject(contentItem.Content.AdvancedForm.Container.Html) : String.Empty,
FormFields = contentItem.Content.AdvancedForm.FormFields != null && contentItem.Content.AdvancedForm.FormFields.Html != null?JsonConvert.SerializeObject(contentItem.Content.AdvancedForm.FormFields.Html) : String.Empty,
AdminContainer = contentItem.Content.AdvancedForm.AdminContainer.Html != null?JsonConvert.SerializeObject(contentItem.Content.AdvancedForm.AdminContainer.Html) : String.Empty,
Description = contentItem.Content.AdvancedForm.Description.Html,
Instructions = contentItem.Content.AdvancedForm.Instructions.Html,
Header = contentItem.Content.AdvancedForm.Header.Html,
Footer = contentItem.Content.AdvancedForm.Footer.Html,
Type = contentItem.Content.AdvancedForm.Type.Text,
Group = contentItem.Content.AdvancedForm.Group.Text,
HideFromListing = contentItem.Content.AdvancedForm.HideFromListing.Value,
IsGlobalHeader = contentItem.Content.AdvancedForm.IsGlobalHeader.Value,
IsGlobalFooter = contentItem.Content.AdvancedForm.IsGlobalFooter.Value
};
if (!ModelState.IsValid)
{
_session.Cancel();
if (isEditPage)
{
return(View("Create", model));
}
else
{
return(View("Adminfields", model));
}
}
await conditionallyPublish(contentItem);
// The content item needs to be marked as saved (again) in case the drivers or the handlers have
// executed some query which would flush the saved entities. In this case the changes happening in handlers
// would not be taken into account.
_session.Save(contentItem);
var typeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType);
if (returnUrl == null)
{
if (isEditPage)
{
return(RedirectToAction("Edit", new RouteValueDictionary {
{ "ContentItemId", viewModel.Id }
}));
}
else
{
return(RedirectToAction("Adminfields", new RouteValueDictionary {
{ "ContentItemId", viewModel.Id }
}));
}
}
else
{
return(LocalRedirect(returnUrl));
}
}
