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)); } }