public ActionResult Page(PageEditModel m)
{
if (ModelState.IsValid)
{
if (m.SaveAll())
{
ModelState.Clear();
ViewBag.Title = Piranha.Resources.Template.EditPageTitleExisting;
SuccessMessage(Piranha.Resources.Template.MessagePageSaved);
}
else
{
ErrorMessage(Piranha.Resources.Template.MessagePageNotSaved);
}
}
else
{
if (m.Template.IsNew)
{
ViewBag.Title = Piranha.Resources.Template.EditPageTitleNew;
}
else
{
ViewBag.Title = Piranha.Resources.Template.EditPageTitleExisting;
}
}
return(View("PageEdit", m));
}
private async Task <IActionResult> CreateOrEdit(PageEditModel model, Func <UpdatePageRequest, Task <Guid> > pageServiceAction)
{
if (!string.IsNullOrWhiteSpace(model.CssContent))
{
var uglifyTest = Uglify.Css(model.CssContent);
if (uglifyTest.HasErrors)
{
foreach (var err in uglifyTest.Errors)
{
ModelState.AddModelError(model.CssContent, err.ToString());
}
return(BadRequest(ModelState.CombineErrorMessages()));
}
}
var req = new UpdatePageRequest
{
HtmlContent = model.RawHtmlContent,
CssContent = model.CssContent,
HideSidebar = model.HideSidebar,
Slug = model.Slug,
MetaDescription = model.MetaDescription,
Title = model.Title,
IsPublished = model.IsPublished
};
var uid = await pageServiceAction(req);
_cache.Remove(CacheDivision.Page, req.Slug.ToLower());
return(Ok(new { PageId = uid }));
}
public ActionResult Copy(int ID, string ID2)
{
if (ID <= 0)
{
return(RedirectToAction("Index"));
}
var model = new PageEditModel();
model.Copying = true;
model.Page = Page.Load(ID);
model.Page.Environment = ID2;
model.Page.PageID = -1;
if (string.IsNullOrWhiteSpace(model.Page.Environment))
{
model.OldTitle = model.Page.Title;
model.Page.Title = "";
model.OldPageNo = model.Page.PageNo.ToString();
model.Page.PageNo = 0;
model.OldFrame = model.Page.Frame;
model.Page.Frame = "";
model.OldToPageNo = model.Page.ToPageNo.ToString();
model.Page.ToPageNo = 0;
model.OldToFrame = model.Page.ToFrame;
model.Page.ToFrame = "";
}
Session["PageCopy"] = model;
return(RedirectToAction("Edit"));
}
public ActionResult Edit(int?ID, string ID2)
{
int id = ID ?? -1;
var model = new PageEditModel();
bool sendURL = id == -2;
if (sendURL)
{
id = -1;
}
var copy = Session["PageCopy"] as PageEditModel;
if (copy == null)
{
model.Page = Page.Load(id);
}
else
{
model = copy;
model.Page.Environment = copy.Page.Environment;
}
model.SendURL = sendURL;
Session["PageCopy"] = null;
if (id != -1 && model.Page.PageID <= 0)
{
return(RedirectToAction("Index"));
}
model.Permissions = Permissions.Load(User);
return(View(model));
}
public ActionResult Delete(Page Page)
{
Page.Fixup();
var perms = Permissions.Load(User);
bool can = perms.Can(Page);
if (!can)
{
ModelState.AddModelError("", "You can't delete this page. Check your <a href='"
+ Url.Action("Index", "Manage")
+ "' target='_blank'>permissions</a>.");
var model2 = new PageEditModel();
model2.Page = Page;
model2.Permissions = perms;
return(View("Edit", model2));
}
PageEditModel model;
if (Page == null || Page.PageID <= 0)
{
return(RedirectToAction("Index"));
}
string err;
if (!Page.Delete(out err))
{
ModelState.AddModelError("", err);
model = new PageEditModel();
model.Page = Page;
model.Permissions = perms;
return(View("Edit", model));
}
return(RedirectToAction("Index"));
}
public ActionResult Edit(PageEditModel request)
{
PageModelFactory pageModelFactory = new PageModelFactory();
PageEditModel model = ModelState.IsValid ? pageModelFactory.EditPage(request) : pageModelFactory.LoadEdit(request.PageID, request.LanguageID);
return(CheckViewModel(model));
}
public ActionResult Edit(long pageID, long?languageID)
{
PageModelFactory pageModelFactory = new PageModelFactory();
PageEditModel model = pageModelFactory.LoadEdit(pageID, languageID);
return(View(model));
}
public void UnPublish_WithExistingPageUpdatesAndRedirects(int pageIdAsInt)
{
#region Arrange
Guid pageId = ConvertIntToGuid(pageIdAsInt);
string pageTitleUpdate = $"Updated title {pageIdAsInt}";
DynamicPage page = pages.FirstOrDefault(p => p.Id == pageId);
PageEditModel pageToPublish = PageEditModelForPageType(new Guid(page.TypeId));
DateTime? originalPublishTime = pageToPublish.Published;
pageToPublish.Id = pageId;
pageToPublish.Title = pageTitleUpdate;
pageToPublish.Published = originalPublishTime;
#endregion
#region Act
RedirectToActionResult result = controller.UnPublish(pageToPublish) as RedirectToActionResult;
#endregion
#region Assert
Assert.NotNull(result);
Assert.Equal("List", result.ActionName);
Assert.Equal(pageTitleUpdate, page.Title);
Assert.Null(page.Published);
mockApi.Verify(a => a.Pages.Save(It.Is <DynamicPage>(p => p.Id == pageId)), Times.Once);
#endregion
}
/// <summary>
/// Loads the available blocks from the source model into the destination.
/// </summary>
/// <param name="src">The source</param>
/// <param name="dest">The destination</param>
private void LoadBlocks(Piranha.Models.DynamicPage src, PageEditModel dest)
{
foreach (var srcBlock in src.Blocks)
{
var block = new ContentEditBlock
{
Id = srcBlock.Id,
CLRType = srcBlock.GetType().FullName,
IsGroup = typeof(Extend.BlockGroup).IsAssignableFrom(srcBlock.GetType()),
Value = srcBlock
};
if (typeof(Extend.BlockGroup).IsAssignableFrom(srcBlock.GetType()))
{
foreach (var subBlock in ((Extend.BlockGroup)srcBlock).Items)
{
block.Items.Add(new ContentEditBlock
{
Id = subBlock.Id,
CLRType = subBlock.GetType().FullName,
Value = subBlock
});
}
}
dest.Blocks.Add(block);
}
}
public Task <PageEditModel> SaveUnpublish(PageEditModel model)
{
// Remove published date
model.Published = null;
return(Save(model, false));
}
public async Task <ActionResult> Create([Bind(Include = "PageId,PageTitle,PageBody,Keywords,Description")] PageEditModel pageedit)
{
if (ModelState.IsValid)
{
var p = db.Pages.Find(pageedit.PageId);
if (p != null)
{
ViewBag.Error = "PageId is in use!";
}
else
{
var userId = User.Identity.GetUserId();
var today = DateTime.Now;
var page = new Page();
page.PageId = pageedit.PageId;
page.PageTitle = pageedit.PageTitle;
page.PageBody = pageedit.PageBody;
page.Keywords = pageedit.Keywords;
page.Description = pageedit.Description;
page.CreateDate = today;
page.UpdateDate = today;
page.UpdateUser = userId;
page.CreateUser = userId;
db.Pages.Add(page);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
}
return(View(pageedit));
}
/// <summary>
/// Saves all of the regions from the source model into the destination.
/// </summary>
/// <param name="api">The current api</param>
/// <param name="src">The source</param>
/// <param name="dest">The destination</param>
private void SaveRegions(PageEditModel src, Piranha.Models.DynamicPage dest)
{
var modelRegions = (IDictionary <string, object>)dest.Regions;
foreach (var region in src.Regions)
{
if (region is PageEditRegion)
{
if (!modelRegions.ContainsKey(region.Id))
{
modelRegions[region.Id] = Piranha.Models.DynamicPage.CreateRegion(api, dest.TypeId, region.Id);
}
var reg = (PageEditRegion)region;
if (reg.FieldSet.Count == 1)
{
modelRegions[region.Id] = reg.FieldSet[0].Value;
}
else
{
var modelFields = (IDictionary <string, object>)modelRegions[region.Id];
foreach (var field in reg.FieldSet)
{
modelFields[field.Id] = field.Value;
}
}
}
else
{
if (modelRegions.ContainsKey(region.Id))
{
var list = (Piranha.Models.IRegionList)modelRegions[region.Id];
var reg = (PageEditRegionCollection)region;
// At this point we clear the values and rebuild them
list.Clear();
foreach (var set in reg.FieldSets)
{
if (set.Count == 1)
{
list.Add(set[0].Value);
}
else
{
var modelFields = (IDictionary <string, object>)Piranha.Models.DynamicPage.CreateRegion(api, dest.TypeId, region.Id);
foreach (var field in set)
{
modelFields[field.Id] = field.Value;
}
list.Add(modelFields);
}
}
}
}
}
}
public async Task <StatusMessage> Save(PageEditModel model)
{
try
{
await _service.Save(model);
}
catch (ValidationException e)
{
// Validation did not succeed
return(new StatusMessage
{
Type = StatusMessage.Error,
Body = e.Message
});
}
catch
{
return(new StatusMessage
{
Type = StatusMessage.Error,
Body = "An error occured while saving the page"
});
}
return(new StatusMessage
{
Type = StatusMessage.Success,
Body = "The page was successfully saved"
});
}
public async Task <IActionResult> OnGetAsync(Guid?id)
{
if (id is null)
{
return(Page());
}
var page = await _pageService.GetAsync(id.Value);
if (page is null)
{
return(NotFound());
}
PageEditModel = new()
{
Id = page.Id,
Title = page.Title,
Slug = page.Slug,
MetaDescription = page.MetaDescription,
CssContent = page.CssContent,
RawHtmlContent = page.RawHtmlContent,
HideSidebar = page.HideSidebar,
IsPublished = page.IsPublished
};
return(Page());
}
}
public ActionResult Edit(PageEditModel model)
{
try
{
if (ModelState.IsValid)
{
if (model != null)
{
var user = User.Identity.GetUserId().ToString();
var today = DateTime.Now;
var page = db.Pages.Find(model.PageId);
page.PageTitle = model.PageTitle;
page.PageBody = model.PageBody;
page.Keywords = model.Keywords;
page.Description = model.Description;
page.UpdateUser = user;
page.UpdateDate = today;
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
}
catch (Exception ex)
{
ViewBag.Error = ex.Message;
}
return(View());
}
public async Task <HttpResponseMessage> Index(string id, string app)
{
IPageViewDefinition siteDefinition;
var found = ResolveForApp <TerrificViewDefinitionRepository>(app).TryGetFromViewId(id, out siteDefinition);
var appViewEngine = ResolveForApp <IViewEngine>(app);
var tplInfo = await ResolveForApp <ITemplateRepository>(app).GetTemplateAsync(siteDefinition.Template).ConfigureAwait(false);
var data = new PageEditModel
{
PageJson = found ? JsonConvert.SerializeObject(siteDefinition, Formatting.Indented) : null,
PageHtml = await CreateSiteHtml(await appViewEngine.CreateViewAsync(tplInfo).ConfigureAwait(false), siteDefinition).ConfigureAwait(false),
Modules = CreateModules(app),
Layouts = CreateLayouts(app),
App = app,
Id = id
};
var viewDefinition = DefaultLayout.WithDefaultLayout(new PartialViewDefinition
{
Template = "components/modules/PageEditor/PageEditor",
Data = data
});
viewDefinition.IncludeScript("assets/pageEditor.js");
viewDefinition.IncludeStyle("assets/pageEditor.css");
viewDefinition.IncludeStyle("/web/page_edit/bundle_app.css?app=" + app);
return(await View(viewDefinition).ConfigureAwait(false));
}
/// <summary>
/// Saves the given model
/// </summary>
/// <param name="model">The model</param>
/// <param name="draft">If the page should be saved as a draft</param>
/// <returns>The result of the operation</returns>
private async Task <PageEditModel> Save(PageEditModel model, bool draft = false)
{
try
{
await _service.Save(model, draft);
}
catch (ValidationException e)
{
model.Status = new StatusMessage
{
Type = StatusMessage.Error,
Body = e.Message
};
return(model);
}
var ret = await _service.GetById(model.Id);
ret.Status = new StatusMessage
{
Type = StatusMessage.Success,
Body = draft ? _localizer.Page["The page was successfully saved"]
: string.IsNullOrEmpty(model.Published) ? _localizer.Page["The page was successfully unpublished"] : _localizer.Page["The page was successfully published"]
};
return(ret);
}
public IActionResult Edit(string Identity, PageEditModel pageedit)
{
var page = myDBContent.Pages.FirstOrDefault(p => p.Identity == Identity);
if (ModelState.IsValid)
{
page.AddTime = pageedit.AddTime;
page.Identity = pageedit.Identity;
page.Position = pageedit.Position;
page.Age = pageedit.Age;
page.Hobby = pageedit.Hobby;
page.Name = pageedit.Name;
page.Content = pageedit.Content;
}
int v = myDBContent.SaveChanges();
if (v > 0)
{
return(RedirectToAction("/Manage/Page/Index"));
}
else
{
ModelState.AddModelError("Identity", "修改失败！");
}
return(View(page));
}//改
public async Task <PageEditModel> SaveDraft(PageEditModel model)
{
var ret = await Save(model, true);
await _hub?.Clients.All.SendAsync("Update", model.Id);
return(ret);
}
/// <summary>
/// Refreshes the model after an unsuccessful save.
/// </summary>
public PageEditModel Refresh(PageEditModel model)
{
if (!string.IsNullOrWhiteSpace(model.TypeId))
{
model.PageType = _api.PageTypes.GetById(model.TypeId);
model.PageContentType = App.ContentTypes.GetById(model.PageType.ContentTypeId);
}
return(model);
}
/// <summary>
/// Verifies that the provided <see cref="PageEditModel" /> is a reference to
/// the given <see cref="DynamicPage" />
/// </summary>
/// <param name="page">The expected page</param>
/// <param name="Model">The model to verify</param>
private void AssertPageEditModelMatchesPage(DynamicPage page, PageEditModel Model)
{
Assert.NotNull(Model);
Assert.Equal(page.Id, Model.Id);
Assert.Equal(page.Title, Model.Title);
Assert.Equal(page.ParentId, Model.ParentId);
Assert.Equal(page.SortOrder, Model.SortOrder);
Assert.Equal(((ExpandoObject)page.Regions).Count(), Model.Regions.Count);
}
public Task <PageEditModel> Save(PageEditModel model)
{
// Ensure that we have a published date
if (string.IsNullOrEmpty(model.Published))
{
model.Published = DateTime.Now.ToString("yyyy-MM-dd HH:mm");
}
return(Save(model, false));
}
public async Task <IActionResult> CreateAsync(PageEditModel pageEditModel)
{
if (!ModelState.IsValid)
{
SetupMessages("Pages", PageType.Create, panelTitle: "Create a new page");
return(View("CreateEdit", pageEditModel));
}
return(await SaveAsync(pageEditModel, nameof(PageController.Create)));
}
public void EditPageShouldEditPageContentOrTitle()
{
//arrange
var user = new GetShreddedUser
{
Id = "UserId",
UserName = "******",
};
var diary = new GetShreddedDiary
{
Id = 1,
User = user,
Summary = "Summary",
Title = "Title",
UserId = "UserId",
};
var page = new Page
{
Id = 1,
Content = "Content",
UserId = user.Id,
GetShreddedUser = user,
GetShreddedDiary = diary,
GetShreddedDiaryId = diary.Id,
Title = "Title",
CreatedOn = DateTime.UtcNow
};
var record = new PageEditModel
{
User = user.UserName,
Content = "Some New Content",
CreatedOn = page.CreatedOn,
Id = page.Id,
DiaryId = diary.Id,
Title = "New Title"
};
userManager.CreateAsync(user).GetAwaiter();
this.Context.Pages.Add(page);
this.Context.GetShreddedDiaries.Add(diary);
this.Context.SaveChanges();
//act
this.pageService.EditPage(record);
//assert
var result = this.Context.Pages.ProjectTo <PageEditModel>().FirstOrDefault(x => x.Id == page.Id);
result.Should().NotBeNull().And.Subject.Should().BeEquivalentTo(record);
}
private void SaveBlocks(PageEditModel src, Piranha.Models.DynamicPage dest)
{
// Clear the block list
dest.Blocks.Clear();
// And rebuild it
foreach (var srcBlock in src.Blocks)
{
dest.Blocks.Add(srcBlock.Value);
}
}
public async Task <Response <Page> > Handle(PageEditModel model)
{
Page page;
if (model.Page.Id != 0)
{
page = await _mediator.Send(new GetByIdQuery <Page>(model.Page.Id));
}
else
{
page = new Page();
page.Published = DateTimeOffset.Now;
page.CreatedBy = model.User.Id;
}
var response = new Response <Page>(page);
var slug = model.Page.Slug.ToLower();
var existing = await _mediator.Send(new GetAllQuery <Page>(
x => x.Slug.ToLower() == slug && x.Id != model.Page.Id,
new PagedOptions <Page>(pageSize: 1, orderBy: x => x.Id)));
if (existing.Any())
{
response.AddError("Slug", "Slug already in use, please choose another");
return(response);
}
page.Title = model.Page.Title;
page.Slug = slug;
page.Content = model.Page.Content;
page.ModifiedBy = model.User.Id;
page.Modified = DateTimeOffset.Now;
try
{
if (page.Id == 0)
{
_uow.Add(page);
}
else
{
_uow.Update(page);
}
await _uow.CommitAsync();
}
catch (Exception e)
{
response.AddError("", e.Unwrap().Message);
}
return(response);
}
public void EditPage(PageEditModel editModel)
{
var chapter = this.Context.Pages.Find(editModel.Id);
chapter.Content = editModel.Content;
chapter.Title = editModel.Title;
chapter.CreatedOn = editModel.CreatedOn;
this.Context.Pages.Update(chapter);
this.Context.SaveChanges();
}
public async Task <PageEditModel> SaveUnpublish(PageEditModel model)
{
// Remove published date
model.Published = null;
var ret = await Save(model, false);
await _hub?.Clients.All.SendAsync("Update", model.Id);
return(ret);
}
/// <summary>
/// Loads the available blocks from the source model into the destination.
/// </summary>
/// <param name="src">The source</param>
/// <param name="dest">The destination</param>
private void LoadBlocks(Piranha.Models.DynamicPage src, PageEditModel dest)
{
foreach (var srcBlock in src.Blocks)
{
dest.Blocks.Add(new ContentEditBlock()
{
Id = srcBlock.Id,
CLRType = srcBlock.GetType().FullName,
Value = srcBlock
});
}
}
public IActionResult PageEditor(int pageId, PageEnums.PageType pageType, int directoryId)
{
PageEditModel editModel = pageType switch {
PageEnums.PageType.Directory => _serviceManager.DirectoryService.GetDirectoryEditModel(pageId),
PageEnums.PageType.Material =>
_serviceManager.MaterialService.GetMaterialEditModel(pageId, directoryId),
_ => null
};
ViewBag.PageType = pageType;
return(View(editModel));
}
