public async Task <ContentItem> CreateTeam(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 on a team"].Value); return(null); } var team = await _contentManager.NewAsync("Team"); team.Owner = user.UserId; await _contentManager.CreateAsync(team, VersionOptions.Published); team.Content.Team.TeamCaptain = JObject.FromObject(new { UserIds = new string[] { user.UserId } }); await _contentManager.UpdateAsync(team); 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 ExecuteAsync(RecipeExecutionContext context) { if (!String.Equals(context.Name, "Content", StringComparison.OrdinalIgnoreCase)) { return; } var model = context.Step.ToObject <ContentStepModel>(); foreach (JObject token in model.Data) { var contentItem = token.ToObject <ContentItem>(); var modifiedUtc = contentItem.ModifiedUtc; var publishedUtc = contentItem.PublishedUtc; var existing = await _contentManager.GetVersionAsync(contentItem.ContentItemVersionId); if (existing == null) { // Initializes the Id as it could be interpreted as an updated object when added back to YesSql contentItem.Id = 0; await _contentManager.CreateAsync(contentItem); // Overwrite ModifiedUtc & PublishedUtc values that handlers have changes // Should not be necessary if IContentManager had an Import method contentItem.ModifiedUtc = modifiedUtc; contentItem.PublishedUtc = publishedUtc; } else { // Replaces the id to force the current item to be updated existing.Id = contentItem.Id; _session.Save(existing); } } }
private async Task <IActionResult> CreatePOST(AdvancedFormViewModel viewModel, Func <ContentItem, Task> conditionallyPublish) { var contentItem = await _contentManager.NewAsync(_id); 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.Tag); contentItem.Content.AdvancedForm = JToken.FromObject(advForm); contentItem.DisplayText = viewModel.Title; contentItem.Content.AutoroutePart.Path = CreatePath(viewModel.Title); if (!ModelState.IsValid) { _session.Cancel(); return(View(viewModel)); } await _contentManager.CreateAsync(contentItem, VersionOptions.Draft); await conditionallyPublish(contentItem); return(RedirectToAction("Edit", new RouteValueDictionary { { "ContentItemId", contentItem.ContentItemId } })); }
private async Task <IActionResult> CreatePOST(string id, string returnUrl, Func <ContentItem, Task> conditionallyPublish) { var contentItem = await contentManager.NewAsync(id); contentItem.Owner = User.Identity.Name; if (!await authorizationService.AuthorizeAsync(User, Permissions.AddCommentsAccess)) { return(this.ChallengeOrForbid()); } var model = await contentItemDisplayManager.UpdateEditorAsync(contentItem, updateModelAccessor.ModelUpdater, true); if (!ModelState.IsValid) { session.Cancel(); return(PartialView(model)); } await contentManager.CreateAsync(contentItem, VersionOptions.Draft); await conditionallyPublish(contentItem); return(PartialView(model)); }
private async Task <IActionResult> CreatePOST(string id, string returnUrl, bool stayOnSamePage, 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; var model = await _contentItemDisplayManager.UpdateEditorAsync(contentItem, _updateModelAccessor.ModelUpdater, true); if (!ModelState.IsValid) { _session.Cancel(); return(View(model)); } await _contentManager.CreateAsync(contentItem, VersionOptions.Draft); await conditionallyPublish(contentItem); 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(returnUrl)); }
private async Task <IActionResult> CreatePOST(string id, string returnUrl, bool stayOnSamePage, Func <ContentItem, Task> conditionallyPublish) { var contentItem = await _contentManager.NewAsync(id); if (!await _authorizationService.AuthorizeAsync(User, Permissions.EditContent, contentItem)) { return(Unauthorized()); } var model = await _contentItemDisplayManager.UpdateEditorAsync(contentItem, this, true); if (!ModelState.IsValid) { _session.Cancel(); return(View(model)); } await _contentManager.CreateAsync(contentItem, VersionOptions.Draft); await conditionallyPublish(contentItem); 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 ExecuteAsync(RecipeExecutionContext context) { if (!String.Equals(context.Name, "Content", StringComparison.OrdinalIgnoreCase)) { return; } var model = context.Step.ToObject <ContentStepModel>(); foreach (JObject token in model.Data) { var contentItem = token.ToObject <ContentItem>(); var existing = await _contentManager.GetVersionAsync(contentItem.ContentItemVersionId); if (existing == null) { // Initializes the Id as it could be interpreted as an updated object when added back to YesSql contentItem.Id = 0; await _contentManager.CreateAsync(contentItem); } else { // Replaces the id to force the current item to be updated existing.Id = contentItem.Id; _session.Save(existing); } } }
public async Task <IActionResult> Entry(string submission, string title, string id, string container) { var contentItem = await _contentManager.NewAsync(_id); if (!await _authorizationService.AuthorizeAsync(User, Permissions.SubmitForm, contentItem)) { return(Unauthorized()); } var subObject = JObject.Parse(submission); string guid = contentItem.ContentItemId; string subTitle = title + " " + DateTime.Now.ToUniversalTime().ToString() + " " + guid; var advFormSub = new AdvancedFormSubmissions(subObject["data"].ToString(), subObject["metadata"].ToString(), subTitle, container); var titlePart = new TitlePart(subTitle); contentItem.Content.AdvancedFormSubmissions = JToken.FromObject(advFormSub); contentItem.Content.TitlePart = JToken.FromObject(titlePart); contentItem.Content.AutoroutePart.Path = CreatePath(title, guid); if (!ModelState.IsValid) { _session.Cancel(); return(StatusCode(StatusCodes.Status406NotAcceptable)); } await _contentManager.CreateAsync(contentItem, VersionOptions.Draft); await _contentManager.PublishAsync(contentItem); return(StatusCode(StatusCodes.Status201Created)); }
public async Task <IActionResult> Post(ContentItem newContentItem, bool draft = false) { var contentItem = await _contentManager.GetAsync(newContentItem.ContentItemId, VersionOptions.DraftRequired); if (contentItem == null) { await _contentManager.CreateAsync(newContentItem, VersionOptions.DraftRequired); } else { await _contentManager.UpdateAsync(newContentItem); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (!draft) { await _contentManager.PublishAsync(newContentItem); } return(Ok(newContentItem)); }
public async Task <IActionResult> CreateFolder(string returnUrl) { /* * if (!await _authorizationService.AuthorizeAsync(User, OrchardCore.Contents.Permissions.EditContent, contentItem)) * { * return Unauthorized(); * } */ // if (String.IsNullOrWhiteSpace(contentitemid)) // { // return NotFound(); // } // var versionOptions = Publish ? VersionOptions.Published : VersionOptions.Draft; // var contentItemtemplate = await _contentManager.GetAsync(contentitemid, VersionOptions.Published); // // if (contentItemtemplate == null) // return NotFound(); var newcontentItem = await _contentManager.NewAsync("Folder"); //set other properties like title newcontentItem.DisplayText = "New Folder"; // var titlePart = newcontentItem.Content.TitlePart; // .As<TitlePart>(); // if (titlePart != null) // { // titlePart.Title = contentItemtemplate.Content.TitlePart.Title + "- Untitled"; // } await AssignNewItemToToFilesRootObject(newcontentItem); //persist // services.ContentManager.Create(newcontentItem, VersionOptions.Published); await _contentManager.CreateAsync(newcontentItem, VersionOptions.Published); // Add UrlHelper, if we have an MVC Action context. var actionContext = _serviceProvider.GetService <IActionContextAccessor>()?.ActionContext; if (actionContext != null) { var urlHelperFactory = _serviceProvider.GetRequiredService <IUrlHelperFactory>(); _urlHelper = urlHelperFactory.GetUrlHelper(actionContext); } var metadataitem = await _contentManager.PopulateAspectAsync <ContentItemMetadata>(newcontentItem); String newItemUrl = _urlHelper.Action(metadataitem.DisplayRouteValues["action"].ToString(), metadataitem.DisplayRouteValues); _notifier.Success(T[ $"Successfully cloned.New folder was saved as a draft.<a href=\"{newItemUrl}\"> Click here </a> to display item"]); //redirect to lists page return(Redirect(returnUrl)); //, () => RedirectToAction("Search")); }
public async Task <IActionResult> OnPostAsync() { var contentItem = await _contentManager.NewAsync("Foo"); // Dynamic syntax contentItem.Content.TestContentPartA.Line = Text; await _contentManager.CreateAsync(contentItem); return(RedirectToPage()); }
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 <IActionResult> SavePublicComment(string id, string contentItemId, string comment, string attachment) { ContentItem content; if (!string.IsNullOrWhiteSpace(contentItemId)) { content = await _contentManager.GetAsync(contentItemId, VersionOptions.Latest); } else { content = await _contentManager.NewAsync("PublicComment"); await _contentManager.CreateAsync(content, VersionOptions.Draft); } attachment = string.IsNullOrEmpty(attachment) ? "" : attachment; var model = new CommentPart(comment, attachment); await _contentManager.PublishAsync(content); //return Ok(StatusCodes.Status200OK); int returnCode = await new ContentHelper(_contentManager, _session, _contentDefinitionManager, _contentAliasManager).EditCommentPOST(content.ContentItemId, true, id, User.Identity.Name, model, async contentItem => { await _contentManager.PublishAsync(contentItem); var typeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType); _notifier.Success(string.IsNullOrWhiteSpace(typeDefinition.DisplayName) ? T["Your content has been published."] : T["Your {0} has been published.", typeDefinition.DisplayName]); }); if (returnCode == StatusCodes.Status204NoContent) { return(NotFound()); } else { return(StatusCode(returnCode)); } }
public async Task <IActionResult> AddContent([FromBody] ContentItem contentItem) { if (!await _authorizationService.AuthorizeAsync(User, Permissions.DemoAPIAccess)) { return(Unauthorized()); } await _contentManager.CreateAsync(contentItem); return(new ObjectResult(contentItem)); }
public async Task <IActionResult> AddContent(ContentItem contentItem) { if (!await _authorizationService.AuthorizeAsync(User, Permissions.DemoAPIAccess)) { return(this.ChallengeOrForbid("Api")); } await _contentManager.CreateAsync(contentItem); return(new ObjectResult(contentItem)); }
public async Task <IActionResult> MakePublicComment(string id, string contentItemId) { ContentItem content = null; if (!string.IsNullOrWhiteSpace(contentItemId)) { content = await _contentManager.GetAsync(contentItemId, VersionOptions.Latest); } if (content == null) { return(NotFound()); } var model = new CommentPart(content.Content.AdminComment.Comment.Html.ToString(), content.Content.AdminComment.Attachment.Text.ToString()); await _contentManager.RemoveAsync(content); ContentItem contentPublic = await _contentManager.NewAsync("PublicComment"); await _contentManager.CreateAsync(contentPublic, VersionOptions.Draft); await _contentManager.PublishAsync(contentPublic); int returnCode = await new ContentHelper(_contentManager, _session, _contentDefinitionManager, _contentAliasManager).EditCommentPOST(contentPublic.ContentItemId, true, id, User.Identity.Name, model, async contentItem => { await _contentManager.PublishAsync(contentItem); var typeDefinition = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType); _notifier.Success(string.IsNullOrWhiteSpace(typeDefinition.DisplayName) ? T["Your content has been published."] : T["Your {0} has been published.", typeDefinition.DisplayName]); }); if (returnCode == StatusCodes.Status204NoContent) { return(NotFound()); } else { return(StatusCode(returnCode)); } }
public static async Task <ContentValidateResult> UpdateValidateAndCreateAsync(this IContentManager contentManager, ContentItem contentItem, VersionOptions options) { await contentManager.UpdateAsync(contentItem); var result = await contentManager.ValidateAsync(contentItem); if (result.Succeeded) { await contentManager.CreateAsync(contentItem, options); } return(result); }
public async Task <IActionResult> FormTableAsync(string jsonData) { ContentItem contentItem = await _contentManager.NewAsync("DatatableWidget"); // EXPLICIT syntax DataTablePart testPart = contentItem.As <DataTablePart>(); testPart.JsonData = jsonData; contentItem.Apply(testPart); await _contentManager.CreateAsync(contentItem); //do create here //send contentitemid return(RedirectToAction("Display", "Home", new { area = "DynamicViewModule", contentItemId = contentItem.ContentItemId })); }
public async Task <IActionResult> Post(ContentItem newContentItem, bool draft = false) { var contentItem = await _contentManager.GetAsync(newContentItem.ContentItemId, VersionOptions.DraftRequired); if (contentItem == null) { if (!await _authorizationService.AuthorizeAsync(User, Permissions.PublishContent)) { return(Unauthorized()); } await _contentManager.CreateAsync(newContentItem, VersionOptions.DraftRequired); contentItem = newContentItem; } else { if (!await _authorizationService.AuthorizeAsync(User, Permissions.EditContent, contentItem)) { return(Unauthorized()); } } if (contentItem != newContentItem) { contentItem.DisplayText = newContentItem.DisplayText; contentItem.ModifiedUtc = newContentItem.ModifiedUtc; contentItem.PublishedUtc = newContentItem.PublishedUtc; contentItem.CreatedUtc = newContentItem.CreatedUtc; contentItem.Owner = newContentItem.Owner; contentItem.Author = newContentItem.Author; contentItem.Apply(newContentItem); await _contentManager.UpdateAsync(contentItem); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (!draft) { await _contentManager.PublishAsync(contentItem); } return(Ok(contentItem)); }
public async Task <ActionResult <object> > CreateFolder(string contentitemid, string name, string foldercontenttype, [FromServices] IAuthorizationService authorizationService) { var newFolderContentItem = await _contentManager.NewAsync(foldercontenttype); //var newFolderContentItem = await _contentManager.NewAsync("Folder"); newFolderContentItem.DisplayText = name; await AssignNewItemToToFilesRootObject(newFolderContentItem, contentitemid); //persist await _contentManager.CreateAsync(newFolderContentItem, VersionOptions.Published); //GetUrlHelper(); return(new ObjectResult(CreateContentItemResult(newFolderContentItem, true))); /* * if (string.IsNullOrEmpty(path)) * { * path = ""; * } * * var newPath = _mediaFileStore.Combine(path, name); * * if (!await authorizationService.AuthorizeAsync(User, Permissions.ManageOwnMedia) || !await authorizationService.AuthorizeAsync(User, Permissions.ManageAttachedMediaFieldsFolder, (object)newPath)) || { || return Unauthorized(); || } || || var mediaFolder = await _mediaFileStore.GetDirectoryInfoAsync(newPath); || if (mediaFolder != null) || { || return StatusCode(StatusCodes.Status403Forbidden, T["Cannot create folder because a folder already exists with the same name"]); || } || || var existingFile = await _mediaFileStore.GetFileInfoAsync(newPath); || if (existingFile != null) || { || return StatusCode(StatusCodes.Status403Forbidden, T["Cannot create folder because a file already exists with the same name"]); || } || || await _mediaFileStore.TryCreateDirectoryAsync(newPath); || || mediaFolder = await _mediaFileStore.GetDirectoryInfoAsync(newPath); || || return new ObjectResult(mediaFolder); */ }
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 <IActionResult> Entry(string submission, string title, string id, string container, string header, string footer, string description, string tag, string submissionId, string instructions) { ContentItem contentItem; if (!string.IsNullOrWhiteSpace(submissionId)) { contentItem = await _contentManager.GetAsync(submissionId, VersionOptions.Latest); } else { contentItem = await _contentManager.NewAsync(_id); } if (!await _authorizationService.AuthorizeAsync(User, Permissions.SubmitForm, contentItem)) { return(Unauthorized()); } var subObject = JObject.Parse(submission); string guid = contentItem.ContentItemId; string subTitle = title + " " + DateTime.Now.ToUniversalTime().ToString() + " " + guid; var advFormSub = new AdvancedFormSubmissions(subObject["data"].ToString(), subObject["metadata"].ToString(), subTitle, container, header, footer, description, tag, instructions); contentItem.Content.AdvancedFormSubmissions = JToken.FromObject(advFormSub); contentItem.DisplayText = subTitle; contentItem.Content.AutoroutePart.Path = CreatePath(title, guid); if (!ModelState.IsValid) { _session.Cancel(); return(StatusCode(StatusCodes.Status406NotAcceptable)); } if (!string.IsNullOrWhiteSpace(submissionId)) { await _contentManager.UpdateAsync(contentItem); } else { await _contentManager.CreateAsync(contentItem, VersionOptions.Draft); } await _contentManager.PublishAsync(contentItem); return(StatusCode(StatusCodes.Status201Created)); }
private async Task <IActionResult> CreatePOST(string id, string returnUrl, bool stayOnSamePage, 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.FindFirstValue(ClaimTypes.NameIdentifier); if (!await _authorizationService.AuthorizeAsync(User, CommonPermissions.EditContent, contentItem)) { return(Forbid()); } var model = await _contentItemDisplayManager.UpdateEditorAsync(contentItem, _updateModelAccessor.ModelUpdater, true); if (ModelState.IsValid) { await _contentManager.CreateAsync(contentItem, VersionOptions.Draft); } if (!ModelState.IsValid) { await _session.CancelAsync(); return(View(model)); } await conditionallyPublish(contentItem); 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)); }
private async Task <ContentItem> CreateAsync(IContentManager contentManager, Posting posting) { var contentItem = await contentManager.NewAsync(Constants.Lever.ContentType); contentItem.DisplayText = posting.Text; contentItem.SetLeverPostingPart(posting); var autoroutePart = contentItem.As <AutoroutePart>(); autoroutePart.Path = $"{_slugService.Slugify(posting.Text)}/{posting.Id}"; contentItem.Apply(nameof(AutoroutePart), autoroutePart); ContentExtensions.Apply(contentItem, contentItem); await contentManager.CreateAsync(contentItem); await contentManager.PublishAsync(contentItem); return(contentItem); }
private async Task <IActionResult> CreatePOST(string id, string returnUrl, bool stayOnSamePage, Func <ContentItem, Task> conditionallyPublish) { var contentItem = await CreateContentItemForOwnedByCurrentAsync(id); if (!await IsAuthorizedAsync(CommonPermissions.EditContent, contentItem)) { return(Forbid()); } var model = await _contentItemDisplayManager.UpdateEditorAsync(contentItem, _updateModelAccessor.ModelUpdater, true); if (ModelState.IsValid) { await _contentManager.CreateAsync(contentItem, VersionOptions.Draft); } if (!ModelState.IsValid) { await _session.CancelAsync(); return(View(model)); } await conditionallyPublish(contentItem); if (!String.IsNullOrEmpty(returnUrl) && !stayOnSamePage) { return(this.LocalRedirect(returnUrl, true)); } var adminRouteValues = (await _contentManager.PopulateAspectAsync <ContentItemMetadata>(contentItem)).AdminRouteValues; if (!String.IsNullOrEmpty(returnUrl)) { adminRouteValues.Add("returnUrl", returnUrl); } return(RedirectToRoute(adminRouteValues)); }
public async Task <IActionResult> Index(string text) { var contentItem = await _contentManager.NewAsync("Foo"); // Dynamic syntax contentItem.Content.TestContentPartA.Line = text + "blah"; // Explicit syntax var testPart = contentItem.As <TestContentPartA>(); testPart.Line = text; contentItem.Apply(testPart); // "Alter" syntax contentItem.Alter <TestContentPartA>(x => x.Line = text); await _contentManager.CreateAsync(contentItem); _logger.LogInformation("This is some log"); return(RedirectToAction("Display", "Home", new { area = "OrchardCore.Demo", contentItemId = contentItem.ContentItemId })); }
public async Task <ContentResult> Upload() { if (!User.Identity.IsAuthenticated) { return(GetResult(string.Empty, "Unauthorized")); } if (Request.HasFormContentType && Request.Form.Files != null && Request.Form.Files.Count > 0) { var file = Request.Form.Files[0]; if (file != null && file.Length > 0) { var contentItem = await _contentManager.NewAsync("TransformalizeFile"); var part = contentItem.As <TransformalizeFilePart>(); part.OriginalName.Text = file.FileName; var filePath = Path.Combine(Common.GetSafeFilePath(part, HttpContext.User.Identity.Name)); using (var stream = file.OpenReadStream()) { await _formFileStore.CreateFileFromStreamAsync(filePath, stream, true); } var fileInfo = await _formFileStore.GetFileInfoAsync(filePath); part.FullPath.Text = fileInfo.Path; contentItem.Apply(part); await _contentManager.CreateAsync(contentItem); return(GetResult(contentItem.ContentItemId, file.FileName)); } } return(GetResult(string.Empty, "Error")); }
public async ValueTask <IActionResult> CreatePost(PublishContentViewModel model) { if (string.IsNullOrEmpty(model?.TargetId)) { return(NotFound()); } var validate = (await _siteService.LoadSiteSettingsAsync())?.As <PublishSetting>()?.ListContentItemIds.Contains(model.TargetId) ?? false; if (!validate) { return(NotFound()); } var contentItem = await _contentManager.NewAsync(PublishContent); contentItem.Alter <ContainedPart>(x => { x.ListContentItemId = model.TargetId; }); contentItem.Owner = User.Identity.Name; var shape = await _contentItemDisplayManager.UpdateEditorAsync(contentItem, _updateModelAccessor.ModelUpdater, true); if (!ModelState.IsValid) { await _session.CancelAsync(); return(View("Create", model)); } await _contentManager.CreateAsync(contentItem, VersionOptions.Draft); await _contentManager.PublishAsync(contentItem); _notifier.Success(H["发布成功"]); return(RedirectToAction("index")); }
/// <summary> /// Creates (persists) a new Published content item /// </summary> /// <param name="contentItem">The content instance filled with all necessary data</param> public static Task CreateAsync(this IContentManager contentManager, ContentItem contentItem) { return(contentManager.CreateAsync(contentItem, VersionOptions.Published)); }
private async Task <bool> ImportRowAsync(ImportRedirectRow row) { if (!ValidateRow(row)) { return(false); } var existing = await _session.Query <ContentItem>() .With <RedirectPartIndex>(x => x.Url == row.FromUrl) .ListAsync(); ContentItem redirectItem = null; var newItem = false; if (existing.Any()) { redirectItem = existing.FirstOrDefault(x => x.Published); } if (redirectItem == null) { redirectItem = await _contentManager.NewAsync(Constants.RedirectContentType); redirectItem.Owner = _httpContextAccessor.HttpContext.User.Identity.Name; redirectItem.CreatedUtc = DateTime.UtcNow; newItem = true; } if (redirectItem == null) { return(false); } var redirectPart = redirectItem.Get <RedirectPart>(nameof(RedirectPart)); if (redirectPart == null) { return(false); } redirectItem.Author = _httpContextAccessor.HttpContext.User.Identity.Name; redirectItem.DisplayText = row.Title; redirectPart.FromUrl = row.FromUrl?.Trim(); redirectPart.ToUrl = row.ToUrl?.Trim(); redirectPart.IsPermanent = true; redirectPart.Apply(); redirectItem.Apply(nameof(RedirectPart), redirectPart); ContentExtensions.Apply(redirectItem, redirectItem); if (newItem) { await _contentManager.CreateAsync(redirectItem); } else { await _contentManager.UpdateAsync(redirectItem); } await _contentManager.PublishAsync(redirectItem); return(true); }