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