private static void UpdatePageTreeRecursive(Entities.Page pageEntity, Dictionary <Guid, Entities.Page> dbPageDict)
{
if (pageEntity == null || pageEntity.Id == Guid.Empty)
{
return;
}
var dbPage = dbPageDict[pageEntity.Id];
dbPage.PageLevel = pageEntity.PageLevel;
dbPage.PageOrder = pageEntity.PageOrder;
dbPage.ParentId = pageEntity.ParentId;
foreach (var pageTranslation in pageEntity.PageTranslation)
{
var dbPageTranslation = dbPage.PageTranslation.First(pt => string.Equals(pt.Locale, pageTranslation.Locale, StringComparison.InvariantCultureIgnoreCase));
dbPageTranslation.URL = pageTranslation.URL;
}
if (pageEntity.ChildPage == null || pageEntity.ChildPage.Count <= 0)
{
return;
}
foreach (var child in pageEntity.ChildPage.Select((value, index) => new { index, value }))
{
child.value.ParentId = dbPage.Id;
UpdatePageTreeRecursive(child.value, dbPageDict);
}
}
public Entities.Page GetPage(Entities.Page root, string url)
{
//if (Context.FileSystem.FileExists(url)) return null;
if (string.IsNullOrEmpty(url))
{
url = string.Empty;
}
var urls = url.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
var depth = 0;
var current = root;
while (current.Children.Any())
{
if (depth >= urls.Length)
{
break;
}
foreach (var child in current.Children)
{
if (child.Url.ToLower() == urls[depth].ToLower())
{
current = child;
depth++;
break;
}
}
depth++;
}
return(current);
}
private void UpdatePageTreeTree(DeviserDbContext context, Entities.Page page)
{
if (page != null && page.ChildPage != null)
{
context.Page.Update(page);
context.SaveChanges();
if (page.ChildPage.Count > 0)
{
foreach (var child in page.ChildPage)
{
if (child != null && child.ChildPage != null)
{
if (child.ChildPage.Count > 0)
{
UpdatePageTreeTree(context, child);
}
else if (child.Id != Guid.Empty)
{
context.Page.Update(page);
context.SaveChanges();
}
}
}
}
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
var user = await _userService.GetByUsername(User.Identity.Name);
if (user == null)
{
return(Unauthorized());
}
if (id == null)
{
id = user.MainPageId;
}
CurrentPage = await _pageService.GetByIdWithAllParents(id.Value);
if (CurrentPage == null)
{
return(NotFound());
}
if (!_pageService.CheckAccess(CurrentPage, user))
{
return(Unauthorized());
}
return(Page());
}
public List <Entities.Content> GetPageContent(Entities.Page page)
{
var store = new ContentStore(Context.FileSystem);
//store.Add(new Content() { Name = "Test", PageId = page.Id, Type = "string", Data = "test" });
return(store.GetAll(page).MakeTree().ToList());
}
public void SaveContentTree(Entities.Page page, ContentItem content, Entities.Content parent)
{
var newParent = new Entities.Content {
PageId = page.Id, ParentId = parent?.Id, Name = content.Name, Type = content.Type, Data = content.Data
};
SaveContent(newParent);
content.Items.ForEach(x => SaveContentTree(page, x, newParent));
}
public Entities.Page GetPage(Entities.Page root, string value)
{
var component = new PageComponent(Context);
var content = new ContentComponent(Context);
var page = component.GetPage(root, value);
page.Contents = content.GetPageContent(page);
return(page);
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (!User.Identity.IsAuthenticated)
{
return(Unauthorized());
}
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userService.GetByUsername(User.Identity.Name);
if (user == null)
{
return(RedirectToPage("/Index"));
}
if (id == null)
{
id = user.MainPageId;
}
CurrentPage = await _pageService.GetByIdWithAllParents(id.Value);
if (CurrentPage == null)
{
return(NotFound());
}
if (!_pageService.CheckAccess(CurrentPage, user))
{
return(Unauthorized());
}
try
{
if (string.IsNullOrWhiteSpace(PageModel.Color))
{
PageModel.Color = Colors[0];
}
var page = _mapper.Map <Entities.Page>(PageModel);
page.Parent = CurrentPage;
await _pageService.Create(page);
}
catch (ApplicationException)
{
return(BadRequest());
}
return(RedirectToPage("/Page/PageView", new { id = CurrentPage.Id }));
}
private void SaveContent(Entities.Page page, Entities.Content contentTree)
{
contentTree.PageId = page.Id;
SaveContent(contentTree);
foreach (var item in contentTree.Children)
{
item.ParentId = contentTree.Id;
SaveContent(page, item);
}
}
/// <summary>
/// Updates the given <see cref="Page"/>.
/// </summary>
/// <param name="pageId">Id of the object being updated.</param>
/// <param name="page">The <see cref="Page"/> to update.</param>
/// <param name="cancellationToken">Cancellation Token</param>
/// <returns>The updated <see cref="Page"/>.</returns>
public virtual async Task <Entities.Page> UpdateAsync(long pageId, Entities.Page page, CancellationToken cancellationToken = default)
{
var req = PrepareRequest($"pages/{pageId}.json");
var content = new JsonContent(new
{
page = page
});
var response = await ExecuteRequestAsync <Entities.Page>(req, HttpMethod.Put, cancellationToken, content, "page");
return(response.Result);
}
public void Add(Entities.Page page)
{
var pageStore = new PageStore(Context.FileSystem);
if (pageStore.FindAll(x => x.SiteId == Context.Site.Id && x.ParentId == page.ParentId && x.Url == page.Url).Any())
{
throw new Exception(string.Format("Page with url: {0} already exists.", page.Url));
}
//set the siteId of the current url
page.SiteId = Context.Site.Id;
pageStore.Add(page);
}
private void AddDefaultContent(Entities.Page page)
{
var pageDefinitionStore = new PageDefinitionStore(Context.FileSystem);
var contentComponent = new ContentComponent(Context);
var definition = pageDefinitionStore.FindAll(x => x.Name == page.Template).FirstOrDefault();
if (definition == null)
{
definition = CreateDefinition(pageDefinitionStore, page.Template);
}
foreach (var content in definition.Items)
{
contentComponent.SaveContentTree(page, content, null);
}
}
private UserTypeEnum getUserType(User user, Entities.Page page)
{
if (user == null)
{
return(UserTypeEnum.Stranger);
}
if (_pageService.CheckAccess(page, user))
{
return(UserTypeEnum.Owner);
}
else
{
return(UserTypeEnum.Registered);
}
}
public IEnumerable<Entities.Page> GetAll()
{
//var siteStore = new SiteStore(Context.FileSystem);
var pageStore = new PageStore(Context.FileSystem);
//var site = siteStore.GetSite(Context.HostString);
var pages = pageStore.GetForSite(Context.Site);
if (!pages.Any())
{
var page = new Entities.Page {Name = "Home", Url = "", SiteId = Context.Site.Id, Template = "Index"};
pageStore.Add(page);
AddDefaultContent(page);
pages = new List<Entities.Page> {page};
}
return pages;
}
private void GetPageTree(List <Entities.Page> pagesInFlat, Entities.Page page)
{
//Page resultPage = null;
page.ChildPage = pagesInFlat
.Where(p => p.ParentId == page.Id)
.OrderBy(p => p.PageOrder)
.ToList();
if (page.ChildPage != null)
{
foreach (var child in page.ChildPage)
{
GetPageTree(pagesInFlat, child);
}
}
//return resultPage;
}
private void UpdatePageAndTranslationRecursive(Entities.Page pageEntity, DeviserDbContext context)
{
if (pageEntity == null)
{
return;
}
pageEntity.LastModifiedDate = DateTime.Now;
var dbPage = context.Page.Where(p => p.Id == pageEntity.Id).FirstOrDefault();
_mapper.Map(pageEntity, dbPage);
//context.Page.Update(pageEntity);
//context.PageTranslation.UpdateRange(pageEntity.PageTranslation);
foreach (var translationEntity in pageEntity.PageTranslation)
{
translationEntity.PageId = pageEntity.Id;
var dbPageTranslation = context.PageTranslation.FirstOrDefault(pt =>
pt.PageId == pageEntity.Id && pt.Locale == translationEntity.Locale);
if (dbPageTranslation != null)
{
_mapper.Map(translationEntity, dbPageTranslation);
}
else
{
context.PageTranslation.Add(translationEntity);
}
}
//Update URL of child pages, if any
if (pageEntity.ChildPage.Count <= 0)
{
return;
}
foreach (var child in pageEntity.ChildPage)
{
UpdatePageAndTranslationRecursive(child, context);
}
}
public IEnumerable <Entities.Page> GetAll()
{
//var siteStore = new SiteStore(Context.FileSystem);
var pageStore = new PageStore(Context.FileSystem);
//var site = siteStore.GetSite(Context.HostString);
var pages = pageStore.GetForSite(Context.Site);
if (!pages.Any())
{
var page = new Entities.Page {
Name = "Home", Url = "", SiteId = Context.Site.Id, Template = "Index"
};
pageStore.Add(page);
AddDefaultContent(page);
pages = new List <Entities.Page> {
page
};
}
return(pages);
}
/// <summary>
/// Creates a new <see cref="Page"/> on the store.
/// </summary>
/// <param name="page">A new <see cref="Page"/>. Id should be set to null.</param>
/// <param name="options">Options for creating the page.</param>
/// <param name="cancellationToken">Cancellation Token</param>
/// <returns>The new <see cref="Page"/>.</returns>
public virtual async Task <Entities.Page> CreateAsync(Entities.Page page, PageCreateOptions options = null, CancellationToken cancellationToken = default)
{
var req = PrepareRequest("pages.json");
var body = page.ToDictionary();
if (options != null)
{
foreach (var option in options.ToDictionary())
{
body.Add(option);
}
}
var content = new JsonContent(new
{
page = body
});
var response = await ExecuteRequestAsync <Entities.Page>(req, HttpMethod.Post, cancellationToken, content, "page");
return(response.Result);
}
private void GetFlatPagesFromRoot(Entities.Page pageEntity, Dictionary <Guid, Dictionary <string, Entities.PageTranslation> > flatPages)
{
if (pageEntity == null)
{
return;
}
var pageTranslations = pageEntity.PageTranslation.ToDictionary(pt => pt.Locale, pt => pt);
flatPages.Add(pageEntity.Id, pageTranslations);
//Update URL of child pages, if any
if (pageEntity.ChildPage.Count <= 0)
{
return;
}
foreach (var child in pageEntity.ChildPage)
{
GetFlatPagesFromRoot(child, flatPages);
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
var user = await _userService.GetByUsername(User.Identity.Name);
if (id.HasValue)
{
PageEntity = await _pageService.GetByIdWithAllParents(id.Value);
}
else
{
if (user == null)
{
return(RedirectToPage("/Account/Login"));
}
id = user.MainPageId;
PageEntity = user.MainPage;
}
if (PageEntity == null)
{
return(NotFound());
}
UserType = getUserType(user, PageEntity);
if (!PageEntity.PublicAccess && !UserType.Equals(UserTypeEnum.Owner))
{
return(Unauthorized());
}
var pages = await _pageService.GetPagesFromPage(PageEntity.Id);
Pages.AddRange(pages.OrderBy(x => x.OrdinalNumber));
return(Page());
}
public void Post(Entities.Page page)
{
var pageComponent = new PageComponent(Context);
pageComponent.Add(page);
}
public Entities.Page GetCurrentPage(Entities.Page root)
{
return(GetPage(root, Context.Path));
}
public void AddContentToPage(Entities.Page page, Entities.Content content)
{
var component = new ContentComponent(Context);
component.AddContent(page, content);
}
public IEnumerable <Entities.Content> GetAll(Entities.Page page)
{
return(FindAll(x => x.PageId == page.Id));
}
public void DeleteContent(Entities.Page page)
{
var store = new ContentStore(Context.FileSystem);
store.Delete(x => x.PageId == page.Id);
}
public void AddContent(Entities.Page page, Entities.Content contentTree)
{
var store = new ContentStore(Context.FileSystem);
SaveContent(page, contentTree);
}
