public async Task <FluidValue> ProcessAsync(FluidValue input, FilterArguments arguments, TemplateContext ctx) { var latest = arguments["latest"].ToBooleanValue(); var mode = arguments["mode"].Or(arguments.At(0)); if (mode.IsNil() || mode.ToStringValue() == "id") { var contentItemId = input.ToStringValue(); var contentItem = await _contentManager.GetAsync(contentItemId, latest?VersionOptions.Latest : VersionOptions.Published); return(FluidValue.Create(contentItem)); } if (mode.ToStringValue() == "alias") { var contentItemId = await _contentAliasManager.GetContentItemIdAsync(input.ToStringValue()); if (contentItemId != null) { var contentItem = await _contentManager.GetAsync(contentItemId, latest?VersionOptions.Latest : VersionOptions.Published); return(FluidValue.Create(contentItem)); } } else if (mode.ToStringValue() == "version") { var contentItemVersionId = input.ToStringValue(); var contentItem = await _contentManager.GetVersionAsync(contentItemVersionId); return(FluidValue.Create(contentItem)); } return(FluidValue.Create(null)); }
public async Task <string> GetAdvFormSubmissionsCSVstring(IEnumerable <ContentItem> pageOfContentItems) { ContentItem selectedContent; Dictionary <string, dynamic> submissionHtml; List <string> column = new List <string>(); column.Add("Form Name"); column.Add("Submitted Date"); column.Add("Created By"); column.Add("Status"); StringBuilder csv = new StringBuilder(); foreach (var contentItem in pageOfContentItems) { csv.Append(string.Format("{0},", contentItem.Content.AutoroutePart.Path.ToString().Split("/")[1].Replace("-", " "))); csv.Append(string.Format("{0},", contentItem.CreatedUtc.Value)); csv.Append(string.Format("{0},", contentItem.Owner)); selectedContent = await _contentManager.GetAsync(contentItem.Content.AdvancedFormSubmissions.Status.Text.ToString(), VersionOptions.Published); if (selectedContent == null) { selectedContent = await _contentManager.GetAsync(contentItem.Content.AdvancedFormSubmissions.Status.Text.ToString(), VersionOptions.DraftRequired); } csv.Append(string.Format("{0},", selectedContent != null && selectedContent.DisplayText != null ? selectedContent.DisplayText : string.Empty)); submissionHtml = JsonConvert.DeserializeObject <Dictionary <string, dynamic> >(contentItem.Content.AdvancedFormSubmissions.Submission.Html.ToString()); column.AddRange(this.GetNewColumns(submissionHtml, column)); csv.Append(this.GetCSVString(submissionHtml, column)); csv.AppendLine(); } StringBuilder file = new StringBuilder(string.Join(",", column)); file.AppendLine(); file.Append(csv.ToString()); return(file.ToString()); }
public async Task <IActionResult> Display(string contentItemId) { if (contentItemId == null) { return(NotFound()); } var contentItem = await _contentManager.GetAsync(contentItemId); if (contentItem == null) { return(NotFound()); } if (!await _authorizationService.AuthorizeAsync(User, Permissions.ViewContent, contentItem)) { return(this.ChallengeOrForbid()); } //set to a global variable" // _httpContextAccessor.HttpContext.Items["Content.CurrentContentItemId"] =contentItem.ContentItemId; // _httpContextAccessor.HttpContext.Items["CurrentContentItem"] =contentItem; var model = await _contentItemDisplayManager.BuildDisplayAsync(contentItem, _updateModelAccessor.ModelUpdater); return(View(model)); }
public override IDisplayResult Edit(TaxonomyField field, BuildFieldEditorContext context) { return(Initialize <EditTagTaxonomyFieldViewModel>(GetEditorShapeType(context), async model => { var settings = context.PartFieldDefinition.GetSettings <TaxonomyFieldSettings>(); model.Taxonomy = await _contentManager.GetAsync(settings.TaxonomyContentItemId, VersionOptions.Latest); if (model.Taxonomy != null) { var termEntries = new List <TermEntry>(); TaxonomyFieldDriverHelper.PopulateTermEntries(termEntries, field, model.Taxonomy.As <TaxonomyPart>().Terms, 0); var tagTermEntries = termEntries.Select(te => new TagTermEntry { ContentItemId = te.ContentItemId, Selected = te.Selected, DisplayText = te.Term.DisplayText, IsLeaf = te.IsLeaf }); model.TagTermEntries = JsonConvert.SerializeObject(tagTermEntries, SerializerSettings); } model.Field = field; model.Part = context.ContentPart; model.PartFieldDefinition = context.PartFieldDefinition; })); }
public async Task <IActionResult> Display(string contentItemId, bool latest = false) { if (!await _authorizationService.AuthorizeAsync(User, OrchardCore.Deployment.CommonPermissions.Export)) { return(Forbid()); } var contentItem = await _contentManager.GetAsync(contentItemId, latest == false?VersionOptions.Published : VersionOptions.Latest); if (contentItem == null) { return(NotFound()); } // Export permission is required as the overriding permission. // Requesting EditContent would allow custom permissions to deny access to this content item. if (!await _authorizationService.AuthorizeAsync(User, Permissions.EditContent, contentItem)) { return(Forbid()); } var model = new DisplayJsonContentItemViewModel { ContentItem = contentItem, ContentItemJson = JObject.FromObject(contentItem).ToString() }; return(View(model)); }
public async Task <IActionResult> NextContentItemInList(string currentContentItemId) { var allFlattendedNodes = await AllFlattendedNodes(currentContentItemId); //https://stackoverflow.com/questions/2680228/linq-next-item-in-list var index = allFlattendedNodes.FindIndex((x => x.Id == currentContentItemId)); try { var nextContentItem = allFlattendedNodes[index + 1]; //next item in list by index if (nextContentItem == null) { return(NotFound()); } var displayRouteValues = (await _contentManager.PopulateAspectAsync <ContentItemMetadata>(nextContentItem.ContentItem)).DisplayRouteValues; return(RedirectToRoute(displayRouteValues)); } catch (ArgumentOutOfRangeException) { //this means we are at end of list . notify user and stay on current item //throw new ArgumentOutOfRangeException("index", ex); var currentContentItem = await _contentManager.GetAsync(currentContentItemId, VersionOptions.Published); var currentContentdisplayRouteValues = (await _contentManager.PopulateAspectAsync <ContentItemMetadata>(currentContentItem)) .DisplayRouteValues; _notifier.Information(H["Already at the last list item."]); return(RedirectToRoute(currentContentdisplayRouteValues)); } }
public async Task <IActionResult> Display(string alias) { if (String.IsNullOrWhiteSpace(alias)) { await Index(); } var contentItemId = await _contentAliasManager.GetContentItemIdAsync("slug:AdvancedForms/" + alias); var contentItem = await _contentManager.GetAsync(contentItemId, VersionOptions.Published); if (contentItem == null) { return(NotFound()); } if (!await _authorizationService.AuthorizeAsync(User, Permissions.ViewContent, contentItem)) { return(Unauthorized()); } var model = new AdvancedFormViewModel { Id = contentItemId, Title = contentItem.Content.AdvancedForm.Title, Container = contentItem.Content.AdvancedForm.Container.Html, Description = contentItem.Content.AdvancedForm.Description.Html, Instructions = contentItem.Content.AdvancedForm.Instructions.Html }; return(View(model)); }
public async Task <IActionResult> Edit(string contentItemId, string returnUrl) { var contentItem = await _contentManager.GetAsync(contentItemId, VersionOptions.Latest); if (contentItem == null) { return(NotFound()); } if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageAdvancedForms, contentItem)) { return(Unauthorized()); } var model = new AdvancedFormViewModel { Id = contentItemId, EntryType = Enums.EntryType.Edit, Title = contentItem.DisplayText, Container = contentItem.Content.AdvancedForm.Container.Html, Description = contentItem.Content.AdvancedForm.Description.Html, Instructions = contentItem.Content.AdvancedForm.Instructions.Html, Header = contentItem.Content.AdvancedForm.Header.Html, Footer = contentItem.Content.AdvancedForm.Footer.Html, Tag = contentItem.Content.AdvancedForm.Tag.Text }; return(View("Create", model)); }
private async Task <IActionResult> CreatePOST(string id, string containerId, string returnUrl, CompleteActionOutCome onCompleteSubmitAction, Func <ContentItem, Task> conditionallyPublish) { var contentItem = await _contentManager.NewAsync(id); // Set the current user as the owner to check for ownership permissions on creation contentItem.Owner = User.Identity.Name; if (!await _authorizationService.AuthorizeAsync(User, CommonPermissions.EditContent, contentItem)) { return(Unauthorized()); } var model = await _contentItemDisplayManager.UpdateEditorAsync(contentItem, _updateModelAccessor.ModelUpdater, true); if (!ModelState.IsValid) { _session.Cancel(); return(View(model)); } if (!string.IsNullOrEmpty(containerId)) { //add parent content reference var rootContentItem = await _contentManager.GetAsync(containerId, VersionOptions.Latest); if (rootContentItem != null) { await _listContainerService.AddChildContentItemReference(rootContentItem, contentItem); } } await _contentManager.CreateAsync(contentItem, VersionOptions.Draft); await conditionallyPublish(contentItem); return(await RedirectSelectActionResult(contentItem, onCompleteSubmitAction, returnUrl)); /*if ((!string.IsNullOrEmpty(returnUrl)) && (stayOnSamePage)) * { * return LocalRedirect(returnUrl); * } * * var adminRouteValues = (await _contentManager.PopulateAspectAsync<ContentItemMetadata>(contentItem)).AdminRouteValues; * * if (!string.IsNullOrEmpty(returnUrl)) * { * adminRouteValues.Add("returnUrl", returnUrl); * } * * return RedirectToRoute(adminRouteValues);*/ }
public async Task <ActionResult> Display(int id) { var contentItem = await _contentManager.GetAsync(id); if (contentItem == null) { return(NotFound()); } return(View(contentItem)); }
public async Task <JsonResult> UpdateTypeContents() { var temp = this.DeserializeObject <IEnumerable <NewPartVM> >(); foreach (var item in temp) { ContentItem DevicesInfoContentItem = await _contentManager.GetAsync(item.NewID); DevicesInfoContentItem.Alter <NewPart>(x => x.NewDisplayName = item.NewDisplayName); DevicesInfoContentItem.Alter <NewPart>(x => x.NewDescription = item.NewDescription); DevicesInfoContentItem.Alter <NewPart>(x => x.Classify = item.Classify); item.Name = "ContentType_" + item.NewDisplayName; if (_contentDefinitionManager.GetTypeDefinition(item.Name) == null) { } else { if (item.Classify == false) { var BodyPartSetting = new BodyPartSettings { }; BodyPartSetting.Editor = "Wysiwyg"; _contentDefinitionManager.AlterTypeDefinition(item.Name, bulid => bulid .DisplayedAs(item.NewDisplayName) .Draftable() .Creatable() .Listable() .WithPart("TitlePart") .WithPart("BodyPart", part => part.WithSettings(BodyPartSetting)) ); } else { var BodyPartSetting = new BodyPartSettings { }; BodyPartSetting.Editor = "Wysiwyg"; _contentDefinitionManager.AlterTypeDefinition(item.Name, bulid => bulid .DisplayedAs(item.NewDisplayName) .Draftable() .Creatable() .Listable() .WithPart("TitlePart", part => part.WithPosition("2")) .WithPart("BodyPart", part => part.WithSettings(BodyPartSetting).WithPosition("3")) .WithPart("TypeNewClassifyPart", part => part.WithPosition("1")) ); } } DevicesInfoContentItem.Alter <NewPart>(x => x.Name = item.Name); DevicesInfoContentItem.Alter <TitlePart>(x => x.Title = item.NewDisplayName); _contentDefinitionManager.GetTypeDefinition(item.Name); _session.Save(DevicesInfoContentItem); } return(this.Jsonp(temp)); }
public async Task <IActionResult> GetById(string id) { var contentItem = await _contentManager.GetAsync(id); if (contentItem == null) { return(NotFound()); } return(new ObjectResult(contentItem)); }
public async Task <ContentTreeItem> BuildContentTreebByRootContentItemIdAsync(string rootContentItemId, string selectedContentItemId) { //this will get all records with one sql query var rootContentItem = await _contentManager.GetAsync(rootContentItemId); var urlHelperFactory = _serviceProvider.GetRequiredService <IUrlHelperFactory>(); _urlHelper = urlHelperFactory.GetUrlHelper(_actionContextAccessor.ActionContext); return(await BuildContentTreeByRootContentItem(rootContentItem, selectedContentItemId)); }
public async Task <ActionResult> Display(string contentItemId) { var contentItem = await _contentManager.GetAsync(contentItemId); if (contentItem == null) { return(NotFound()); } var shape = await _contentDisplay.BuildDisplayAsync(contentItem, this); return(View(shape)); }
public async Task <IActionResult> Edit(string contentItemId) { var contentItem = await _contentManager.GetAsync(contentItemId, VersionOptions.Latest); if (contentItem == null) { return(NotFound()); } var model = await _contentItemDisplayManager.BuildEditorAsync(contentItem, _updateModelAccessor.ModelUpdater, false); return(View(model)); }
public async Task <ContentItem> GetParent(ContentItem current, VersionOptions options = null) { options ??= VersionOptions.Published; var containedPart = current?.As <ContainedPart>(); if (containedPart == null) { return(null); } return(await _contentManager.GetAsync(containedPart.ListContentItemId, options)); }
public async Task <ActionResult <IEnumerable <object> > > GetFolders(string contentitemid, string contentitemalias = "") //path { // if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageOwnMedia)) // { // return Unauthorized(); // } // if (string.IsNullOrEmpty(contentitemid)) // { // contentitemid = ""; // } string actualcontentItemId = !string.IsNullOrEmpty(contentitemalias) ? await _contentAliasManager.GetContentItemIdAsync("alias:" + contentitemalias) : contentitemid; if (actualcontentItemId == null) { return(NotFound()); } var contentItem = await _contentManager.GetAsync(actualcontentItemId); if (contentItem == null) { return(NotFound()); } IEnumerable <ContentItem> queryResults = null; if (!String.IsNullOrEmpty(contentitemalias)) { var realcontentItemId = await _contentAliasManager.GetContentItemIdAsync("alias:" + contentitemalias); queryResults = await _listContainerService.GetChildContentItems(realcontentItemId); } else if (!String.IsNullOrEmpty(contentitemid)) { queryResults = await _listContainerService.GetChildContentItems(contentitemid); } var directoryItems = queryResults ?.Where(x => x.ContentType == "Folder" || x.ContentType == "MaterialLibraryFolder").ToList(); return(directoryItems?.Select(CreateContentItemResult).ToArray()); }
public async Task <ActionResult> OnGetAsync() { var contentItem = await _contentManager.GetAsync(Id); if (contentItem == null) { return(NotFound()); } Title = contentItem.DisplayText ?? "Foo Title"; Text = contentItem.Content.TestContentPartA.Line; return(Page()); }
public async Task <ContentItem> Next(string currentContentItemId) { var currentContentItem = await _contentManager.GetAsync(currentContentItemId, VersionOptions.Latest); if (currentContentItem == null) { return(null); } return(await _iSession.Query <ContentItem, ContentItemIndex>(x => x.Published) .Where(x => x.CreatedUtc > currentContentItem.CreatedUtc) // .Where(x => x.ContentItemId == current.ContentItemId && x.CreatedUtc >= current.CreatedUtc) // .Where(x => x.CreatedUtc > current.CreatedUtc) .OrderBy(cr => cr.CreatedUtc).Take(1).FirstOrDefaultAsync()); }
public override IDisplayResult Display(ContentPickerField field, BuildFieldDisplayContext context) { return(Initialize <DisplayContentPickerFieldViewModel>(GetDisplayShapeType(context), async model => { model.Field = field; model.Part = context.ContentPart; model.PartFieldDefinition = context.PartFieldDefinition; model.Updater = context.Updater; model.SelectedContentItemIds = string.Join(",", field.ContentItemIds); model.ContentItems = await _contentManager.GetAsync(field.ContentItemIds); }) .Location("Content") .Location("SummaryAdmin", "")); }
public async ValueTask <FluidValue> ProcessAsync(FluidValue input, FilterArguments arguments, LiquidTemplateContext ctx) { if (input.Type == FluidValues.Array) { // List of content item ids var contentItemIds = input.Enumerate(ctx).Select(x => x.ToStringValue()).ToArray(); return(FluidValue.Create(await _contentManager.GetAsync(contentItemIds), ctx.Options)); } else { var contentItemId = input.ToStringValue(); return(FluidValue.Create(await _contentManager.GetAsync(contentItemId), ctx.Options)); } }
public async ValueTask <IActionResult> EditPost(EditContentViewModel model) { if (string.IsNullOrEmpty(model.TargetId)) { return(NotFound()); } var contentItem = await _session.Query <ContentItem>() .With <ContentItemIndex>(x => x.ContentItemId == model.TargetId && x.Owner == User.Identity.Name && x.Latest && x.ContentType == PublishContent) .FirstOrDefaultAsync(); if (contentItem == null) { return(NotFound()); } contentItem = await _contentManager.GetAsync(model.TargetId, VersionOptions.DraftRequired); var shape = await _contentItemDisplayManager.UpdateEditorAsync(contentItem, _updateModelAccessor.ModelUpdater, false); if (!ModelState.IsValid) { await _session.CancelAsync(); return(View("Edit", model)); } await _contentManager.PublishAsync(contentItem); _notifier.Success(H["发布成功"]); return(RedirectToAction("index")); }
public override IDisplayResult Edit(ContentPickerField field, BuildFieldEditorContext context) { return(Initialize <EditContentPickerFieldViewModel>(GetEditorShapeType(context), async model => { model.ContentItemIds = string.Join(",", field.ContentItemIds); model.Field = field; model.Part = context.ContentPart; model.PartFieldDefinition = context.PartFieldDefinition; model.SelectedItems = new List <ContentPickerItemViewModel>(); foreach (var contentItemId in field.ContentItemIds) { var contentItem = await _contentManager.GetAsync(contentItemId, VersionOptions.Latest); if (contentItem == null) { continue; } model.SelectedItems.Add(new ContentPickerItemViewModel { ContentItemId = contentItemId, DisplayText = contentItem.ToString(), HasPublished = await _contentManager.HasPublishedVersionAsync(contentItem) }); } })); }
public async Task <IActionResult> Get(string contentItemId) { var contentItem = await _contentManager.GetAsync(contentItemId); if (contentItem == null) { return(NotFound()); } if (!await _authorizationService.AuthorizeAsync(User, Permissions.ViewContent, contentItem)) { return(Unauthorized()); } return(Ok(contentItem)); }
public async Task <IActionResult> Submit(string formId) { var form = await _contentManager.GetAsync(formId, VersionOptions.Published); if (form == null) { return(NotFound()); } var formPart = form.As <VueForm>(); // Verify if the form is enabled if (!formPart.Enabled.Value) { return(NotFound()); } // form validation server side script var errorsDictionary = new Dictionary <string, List <string> >(); var scriptingProvider = new VueFormMethodsProvider(form, errorsDictionary); var script = form.As <VueFormScripts>(); if (!string.IsNullOrEmpty(script?.OnValidation?.Text)) { _scriptingManager.EvaluateJs(script.OnValidation.Text, scriptingProvider); } if (errorsDictionary.Count > 0) { return(Json(new { validationError = true, errors = errorsDictionary })); } if (!string.IsNullOrEmpty(script?.OnSubmitted?.Text)) { _scriptingManager.EvaluateJs(script.OnSubmitted.Text, scriptingProvider); } // _workflow manager is null if workflow feature is not enabled if (_workflowManager != null) { //todo: make sure this does not create issues if the workflows has a blocking event await _workflowManager.TriggerEventAsync(nameof(VueFormSubmittedEvent), input : new { VueForm = form }, correlationId : form.ContentItemId ); } // 302 are equivalent to 301 in this case. No permanent redirect if (HttpContext.Response.StatusCode == 301 || HttpContext.Response.StatusCode == 302) { var returnValue = new { redirect = WebUtility.UrlDecode(HttpContext.Response.Headers["Location"]) }; HttpContext.Response.Clear(); return(Json(returnValue)); } var formSuccessMessage = await _liquidTemplateManager.RenderAsync(formPart.SuccessMessage?.Text, _htmlEncoder); // everything worked fine. send the success signal to the client return(Json(new { success = true, successMessage = formSuccessMessage })); }
public async Task <IActionResult> ListBinderTemplates() { string alias = "binder-templates"; string contentItemId = alias != null ? await _contentAliasManager.GetContentItemIdAsync("alias:" + alias) : "NotFound"; if (contentItemId == "NotFound") { return(NotFound()); } var contentItem = await _contentManager.GetAsync(contentItemId, VersionOptions.Latest); if (contentItem == null) { return(NotFound()); } if (!await _authorizationService.AuthorizeAsync(User, OrchardCore.Contents.Permissions.ViewContent, contentItem)) { return(Unauthorized()); } var model = await _contentItemDisplayManager.BuildDisplayAsync(contentItem, this, "DetailAdmin"); return(View("DisplayByAlias", model)); }
public override IDisplayResult Edit(LocalizationSetContentPickerField field, BuildFieldEditorContext context) { return(Initialize <EditLocalizationSetContentPickerFieldViewModel>(GetEditorShapeType(context), async model => { model.LocalizationSets = string.Join(",", field.LocalizationSets); model.Field = field; model.Part = context.ContentPart; model.PartFieldDefinition = context.PartFieldDefinition; model.SelectedItems = new List <VueMultiselectItemViewModel>(); foreach (var kvp in await _contentLocalizationManager.GetFirstItemIdForSetsAsync(field.LocalizationSets)) { var contentItem = await _contentManager.GetAsync(kvp.Value, VersionOptions.Latest); if (contentItem == null) { continue; } model.SelectedItems.Add(new VueMultiselectItemViewModel { Id = kvp.Key, //localization set DisplayText = contentItem.ToString(), HasPublished = await _contentManager.HasPublishedVersionAsync(contentItem) }); } })); }
private async Task <object> UpdateMediaToContentItemFolder(string contentItemId) { try { var fileToUpload = GetFileToUpload(null); var contentItem = await _contentManager.GetAsync((contentItemId)); return(await _attachedMediaToContentItemService.UploadToContentItemsFolderAsync(fileToUpload, contentItem)); } catch (Exception e) { return(Json(e)); // updater.ModelState.AddModelError(Prefix, S["{0}: There was an error handling the files.", context.PartFieldDefinition.DisplayName()]); } }
private async Task AssignGroupToProfiles(string[] contentItemIds, string groupContentItemId) { foreach (var contentItemId in contentItemIds) { await _profileGroupsService.AssignGroupAsync(await _contentManager.GetAsync(contentItemId), groupContentItemId); } }
public async Task UpdateContentItemOrdersAsync(IEnumerable <ContentItem> contentItems, int orderOfFirstItem) { var i = 0; foreach (var contentItem in contentItems) { var containedPart = contentItem.As <ContainedPart>(); if (containedPart != null && containedPart.Order != orderOfFirstItem + i) { containedPart.Order = orderOfFirstItem + i; containedPart.Apply(); // Keep the published and draft orders the same to avoid confusion in the admin list. if (!contentItem.IsPublished()) { var publishedItem = await _contentManager.GetAsync(contentItem.ContentItemId, VersionOptions.Published); if (publishedItem != null) { publishedItem.Alter <ContainedPart>(x => x.Order = orderOfFirstItem + i); await _contentManager.UpdateAsync(publishedItem); } } await _contentManager.UpdateAsync(contentItem); } i++; } }