private void MapPageResourceToDao(PageResource p, PageDao dao)
{
dao.IsEnabled = p.IsEnabled;
dao.Path = p.Path;
dao.Alias = p.Alias;
dao.MaintainCountryList(_dataContext, p.Countries);
dao.OverridesSiteCountryList = p.Countries.Any();
}
public static PageResourceContext Build(this PageResourceContext context, PageResource resource)
{
context.ResourceType = resource.ResourceType;
context.Scope = resource.Scope;
foreach (var property in resource.ResourceData.Properties)
{
context.Attributes.Add(property.Name.ToLower(), property.Value);
}
return(context);
}
protected override void ExecuteWorkImplementation()
{
var now = DateTime.UtcNow;
var user = m_resourceRepository.Load <User>(m_userId);
if ((m_projectId == null && m_resourceId == null) || (m_projectId != null && m_resourceId != null))
{
throw new MainServiceException(MainServiceErrorCode.ProjectIdOrResourceId, "Exactly one parameter (ProjectId or ResourceId) has to be specified");
}
var pageResource = new PageResource
{
Name = m_pageData.Name,
Comment = m_pageData.Comment,
Position = m_pageData.Position,
Resource = null,
VersionNumber = 0,
CreateTime = now,
CreatedByUser = user,
Terms = null, // Terms must be also updated
};
if (m_resourceId != null)
{
var latestPageResource = m_resourceRepository.GetLatestResourceVersion <PageResource>(m_resourceId.Value);
if (latestPageResource == null)
{
throw new MainServiceException(MainServiceErrorCode.EntityNotFound, "The entity was not found.");
}
pageResource.Resource = latestPageResource.Resource;
pageResource.VersionNumber = latestPageResource.VersionNumber + 1;
pageResource.Terms = new List <Term>(latestPageResource.Terms); // Lazy fetch
}
else
{
var resource = new Resource
{
ContentType = ContentTypeEnum.Page,
ResourceType = ResourceTypeEnum.Page,
Project = m_resourceRepository.Load <Project>(m_projectId),
};
pageResource.Resource = resource;
pageResource.VersionNumber = 1;
}
pageResource.Resource.Name = m_pageData.Name;
pageResource.Resource.LatestVersion = pageResource;
m_resourceRepository.Create(pageResource);
ResourceId = pageResource.Resource.Id;
VersionId = pageResource.Id;
}
public virtual IList <Term> GetLatestPageTermList(long resourcePageId)
{
PageResource pageResourceAlias = null;
Resource resourceAlias = null;
Project projectAlias = null;
return(GetSession().QueryOver <Term>()
.JoinAlias(x => x.PageResources, () => pageResourceAlias)
.JoinAlias(() => pageResourceAlias.Resource, () => resourceAlias)
.JoinAlias(() => resourceAlias.Project, () => projectAlias)
.Where(() => resourceAlias.Id == resourcePageId && pageResourceAlias.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved && projectAlias.IsRemoved == false)
.OrderBy(x => x.Position).Asc
.List());
}
public async Task Can_RoleAccess_To_Menu()
{
using (var ctx = await TestDbContext.Create(nameof(Can_RoleAccess_To_Menu)))
{
var mapper = new MapperConfiguration(cfg => cfg.AddProfile(new MappingProfile()));
var menu = new MenuResource
{
Title = "someMenu",
Icon = "",
Name = "Mn1",
Order = 1,
};
var page = new PageResource
{
Link = "http://abc",
Name = "p1",
Title = "Some",
};
menu.Page = page;
ctx.MenuResources.Add(menu);
ctx.PageResources.Add(page);
await ctx.SaveChangesAsync();
Application.Access.GenericRoleToResourceHandler genericRoleToResourceHandler = new Application.Access.GenericRoleToResourceHandler(ctx, mapper.CreateMapper());
var mediator = new Mock <IMediator>();
mediator
.Setup(m => m.Send(It.IsAny <RoleAccessToPage>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true)
.Verifiable();
var model = new AssignRoleToResourceDto("Role1", menu.Id, DotNetAccessControl.domain.enums.Permission.Allow);
var handler = new AssignRoleToMenuHandler(genericRoleToResourceHandler, ctx, mediator.Object);
var result = await handler.Handle(new RoleAccessToMenu(model, true), CancellationToken.None);
var saved = await ctx.AccessControls.OfType <RoleAccessControl>().SingleAsync(x => x.ResourceId == menu.Id);
Assert.Equal(model.RoleName, saved.RoleName);
mediator.Verify(x => x.Send(It.IsAny <RoleAccessToPage>(), It.IsAny <CancellationToken>()), Times.Once);
}
}
public virtual IList <PageCountResult> GetAllPageCount(IEnumerable <long> projectIdList)
{
PageResource pageResourceAlias = null;
Resource resourceAlias = null;
Project projectAlias = null;
PageCountResult resultAlias = null;
var result = GetSession().QueryOver(() => pageResourceAlias)
.JoinAlias(x => x.Resource, () => resourceAlias)
.JoinAlias(() => resourceAlias.Project, () => projectAlias)
.WhereRestrictionOn(() => resourceAlias.Project.Id).IsInG(projectIdList)
.And(x => x.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved && projectAlias.IsRemoved == false)
.SelectList(list => list
.SelectGroup(() => resourceAlias.Project.Id).WithAlias(() => resultAlias.ProjectId)
.SelectCount(() => pageResourceAlias.Id).WithAlias(() => resultAlias.PageCount))
.TransformUsing(Transformers.AliasToBean <PageCountResult>())
.List <PageCountResult>();
return(result);
}
private Dictionary <string, PageResource> CreateImageToPageResourceDictionary(BookData bookData, List <PageResource> dbPageResources)
{
if (dbPageResources == null || bookData.Pages == null)
{
return(new Dictionary <string, PageResource>());
}
var dbPagesByPosition = new PageResource[dbPageResources.Count + 1];
foreach (var dbPage in dbPageResources)
{
dbPagesByPosition[dbPage.Position] = dbPage;
}
var dbPagesByImage = new Dictionary <string, PageResource>();
foreach (var pageWithImageData in bookData.Pages.Where(x => x.Image != null))
{
var dbPage = dbPagesByPosition[pageWithImageData.Position];
dbPagesByImage.Add(pageWithImageData.Image, dbPage);
}
return(dbPagesByImage);
}
public async Task <IActionResult> AddResource(AddPageResourceViewModel model)
{
if (!ModelState.IsValid)
{
this.AlertDanger(sr["Invalid request"], true);
return(RedirectToRoute(pageRoutes.PageDevelopRouteName, new { slug = model.Slug }));
}
var project = await projectService.GetCurrentProjectSettings();
if (project == null)
{
log.LogInformation("redirecting to index because project settings not found");
return(RedirectToRoute(pageRoutes.PageRouteName));
}
var canEdit = await User.CanEditPages(project.Id, authorizationService);
if (!canEdit)
{
log.LogInformation("redirecting to index because user is not allowed to edit");
return(RedirectToRoute(pageRoutes.PageRouteName));
}
var canDev = editOptions.AlwaysShowDeveloperLink ? true : User.IsInRole(editOptions.DeveloperAllowedRole);
if (!canDev)
{
log.LogInformation("redirecting to index because user is not allowed by edit config for developer tools");
return(RedirectToRoute(pageRoutes.PageRouteName));
}
IPage page = null;
if (!string.IsNullOrEmpty(model.Slug))
{
page = await pageService.GetPageBySlug(model.Slug);
}
if (page == null)
{
log.LogInformation("page not found, redirecting");
return(RedirectToRoute(pageRoutes.PageRouteName, new { slug = "" }));
}
if ((!string.IsNullOrEmpty(page.ViewRoles)))
{
if (!User.IsInRoles(page.ViewRoles))
{
log.LogWarning($"page {page.Title} is protected by roles that user is not in so redirecting");
return(RedirectToRoute(pageRoutes.PageRouteName));
}
}
var resource = new PageResource();
resource.ContentId = page.Id;
resource.Type = model.Type;
resource.Environment = model.Environment;
resource.Sort = model.Sort;
resource.Url = model.Url;
page.Resources.Add(resource);
await pageService.Update(page, page.IsPublished);
return(RedirectToRoute(pageRoutes.PageDevelopRouteName, new { slug = page.Slug }));
}
public static string Caption(this IHtmlHelper htmlHelper, PageResource resource)
{
return(resource.GetDescription());
}
public void UpdatePages(long projectId, long bookVersionId, int userId, BookData bookData, Dictionary <string, Term> dbTermCache)
{
m_allImportedResourceVersionIds = new List <long>();
if (bookData.Pages == null)
{
return;
}
var updatedPageResourceIds = new HashSet <long>();
var newPageTextResources = new List <NewPageTextData>();
var newPageImageResources = new List <ImageResource>();
var resultPageResourceList = new List <PageResource>();
var now = DateTime.UtcNow;
var project = m_resourceRepository.Load <Project>(projectId);
var user = m_resourceRepository.Load <User>(userId);
var bookVersion = m_resourceRepository.Load <BookVersionResource>(bookVersionId);
var dbPages = m_resourceRepository.GetProjectLatestPages(projectId);
var dbPagesDict = dbPages.ToDictionaryMultipleValues(x => x.Name);
// Update page list
foreach (var page in bookData.Pages)
{
List <PageResource> dbPageResources;
PageResource dbPageResource = null;
if (dbPagesDict.TryGetValue(page.Text, out dbPageResources))
{
dbPageResource = dbPageResources.Count == 1
? dbPageResources.First()
: dbPageResources.FirstOrDefault(x => x.Position == page.Position); // If multiple pages have the same name, try identify page by Position
}
var newPageResource = new PageResource
{
Resource = null,
Name = page.Text,
Comment = string.Empty,
CreateTime = now,
CreatedByUser = user,
Position = page.Position,
VersionNumber = 0,
Terms = PrepareTermList(page.TermXmlIds, dbTermCache),
};
if (dbPageResource == null)
{
newPageResource.Resource = new Resource
{
Project = project,
Name = page.Text,
ContentType = ContentTypeEnum.Page,
ResourceType = ResourceTypeEnum.Page,
};
newPageResource.VersionNumber = 1;
}
else
{
newPageResource.Resource = dbPageResource.Resource;
newPageResource.VersionNumber = dbPageResource.VersionNumber + 1;
updatedPageResourceIds.Add(dbPageResource.Id);
}
newPageResource.Resource.LatestVersion = newPageResource;
m_resourceRepository.Create(newPageResource);
// Create TextResource
if (!string.IsNullOrEmpty(page.XmlId))
{
var newTextResource = new TextResource
{
Resource = null,
Comment = string.Empty,
CreateTime = now,
CreatedByUser = user,
ExternalId = page.XmlId,
ResourcePage = newPageResource.Resource,
BookVersion = bookVersion,
VersionNumber = 0
};
newPageTextResources.Add(new NewPageTextData
{
NewTextResource = newTextResource,
BookPageData = page,
});
}
// Create ImageResource
if (!string.IsNullOrEmpty(page.Image))
{
var imageMimeType = MimeMapping.GetMimeMapping(page.Image);
bookData.FileNameMapping.TryGetValue(page.Image, out var fileInfo);
var newImageResource = new ImageResource
{
Resource = null,
Comment = string.Empty,
CreateTime = now,
CreatedByUser = user,
FileName = page.Image,
FileId = fileInfo?.NewNameInStorage,
MimeType = imageMimeType,
Size = fileInfo != null ? fileInfo.NewFileSize : 0L,
ResourcePage = newPageResource.Resource,
VersionNumber = 0
};
newPageImageResources.Add(newImageResource);
}
m_allImportedResourceVersionIds.Add(newPageResource.Id);
resultPageResourceList.Add(newPageResource);
}
ResultPageResourceList = resultPageResourceList;
// Remove unused pages
var unusedDbPages = dbPages.Where(x => !updatedPageResourceIds.Contains(x.Id));
foreach (var unusedDbPage in unusedDbPages)
{
var resourceToRemove = unusedDbPage.Resource;
resourceToRemove.IsRemoved = true;
m_resourceRepository.Update(resourceToRemove);
// Related resources are remove in own subtask
}
UpdateTextResources(project, newPageTextResources);
UpdateImageResources(project, newPageImageResources);
}
private static PageResources CollectPages(Site site)
{
PageResources pages = new();
// Collect Embedded Pages
foreach (var path in Directory.EnumerateFiles(site.EmbedsDirectory, "*", SearchOption.AllDirectories))
{
DoProcessPath(path, ResourceLocation.Embed);
}
// Collect Site Pages
foreach (var path in Directory.EnumerateFiles(site.Directory, "*", SearchOption.AllDirectories).Where(p => p.EndsWith(".md") || p.EndsWith(".gen")))
{
DoProcessPath(path, ResourceLocation.Site);
}
CollectGeneratedPages();
return(pages);
void DoProcessPath(string path, ResourceLocation location)
{
string fullPath = Path.GetFullPath(path);
if (!TryGetNewResource(fullPath, location, out var page))
{
return;
}
if (page !.Type != ResourceType.Markdown)
{
return;
}
// Collect all the links from this markdown page - and add them to the PageResources.
string text = File.ReadAllText(fullPath);
foreach (var embed in EmbedsAsLocalEmbedPaths(text))
{
string fullEmbedPath = LocalEmbedToFullPath(embed.localPath, site);
page.AddEmbedded(fullEmbedPath);
if (!TryGetNewResource(fullEmbedPath, ResourceLocation.Embed, out PageResource? embeddedPage))
{
continue;
}
embeddedPage !.AddEmbeddedInto(fullPath);
}
}
//Returns true if a new page is created
bool TryGetNewResource(string fullPath, ResourceLocation location, out PageResource?page)
{
if (pages.TryGetValue(fullPath, out page))
{
return(true);
}
string extension = Path.GetExtension(fullPath);
switch (extension)
{
case ".md":
page = new PageResource(fullPath, ResourceType.Markdown, location);
break;
case ".gen":
page = new PageResource(fullPath, ResourceType.Generator, location);
break;
case ".rtf":
page = new PageResource(fullPath, ResourceType.RichText, location);
break;
case ".html":
case ".nomnoml":
page = new PageResource(fullPath, ResourceType.Html, location);
break;
default:
// Ignore content that is not buildable page content.
page = null;
return(false);
}
pages.Add(fullPath, page);
return(true);
}
void CollectGeneratedPages()
{
PageResources toAppend = new();
foreach ((_, PageResource page) in pages)
{
foreach ((string key, PageResource value) in ProcessGenerator(site, pages, page))
{
toAppend.Add(key, value);
}
}
foreach (KeyValuePair <string, PageResource> pair in toAppend)
{
pages.Add(pair.Key, pair.Value);
}
}
}
protected override void ExecuteWorkImplementation()
{
var now = DateTime.UtcNow;
var user = m_resourceRepository.Load <User>(m_userId);
var dbPages = m_resourceRepository.GetProjectLatestPages(m_projectId);
var updatedResourcePageIds = new List <long>();
foreach (var newPage in m_newPages)
{
var pageResource = new PageResource
{
Name = newPage.Name,
Comment = null,
Position = newPage.Position,
Resource = null,
VersionNumber = 0,
CreateTime = now,
CreatedByUser = user,
Terms = null, // Terms must be also updated
};
if (newPage.Id == null)
{
var resource = new Resource
{
ContentType = ContentTypeEnum.Page,
ResourceType = ResourceTypeEnum.Page,
Project = m_resourceRepository.Load <Project>(m_projectId),
};
pageResource.Resource = resource;
pageResource.VersionNumber = 1;
}
else
{
var latestPageResource = m_resourceRepository.GetLatestResourceVersion <PageResource>(newPage.Id.Value);
if (latestPageResource == null)
{
throw new MainServiceException(MainServiceErrorCode.EntityNotFound, "The entity was not found.");
}
pageResource.Resource = latestPageResource.Resource;
pageResource.VersionNumber = latestPageResource.VersionNumber + 1;
pageResource.Terms = new List <Term>(latestPageResource.Terms); // Lazy fetch
updatedResourcePageIds.Add(newPage.Id.Value);
}
pageResource.Resource.Name = newPage.Name;
pageResource.Resource.LatestVersion = pageResource;
m_resourceRepository.Create(pageResource);
}
var removeResourceSubwork = new RemoveResourceSubwork(m_resourceRepository);
foreach (var dbPage in dbPages)
{
if (!updatedResourcePageIds.Contains(dbPage.Resource.Id))
{
removeResourceSubwork.RemoveResource(dbPage.Resource.Id);
}
}
}
