public ActionResult Show(PagePath pagePath, string id) { var loadContext = _pageService.Load(pagePath); if (loadContext == null) { return this.RedirectToWikiPage(pagePath); } var tocBuilder = new TableOfContentsBuilder(); tocBuilder.Compile(loadContext.Body); var tree = _pageTreeRepository.Get(loadContext.Page.Id); var model = new ShowViewModel { Body = loadContext.Body, PagePath = pagePath, Title = loadContext.Page.Title, UpdatedAt = loadContext.Page.UpdatedAt, UserName = loadContext.Page.UpdatedBy.DisplayName, BackLinks = loadContext.Page.BackReferences.ToList(), TableOfContents = tocBuilder.GenerateList(), Path = tree.CreateLinksForPath(Url.WikiRoot()) }; return View("Show", model); }
private async Task <PageMetadata> GetPageMetadataAsync(PagePath pagePath) { string metadata = await _pageIOManager.LoadMetadataAsync(pagePath.Location.GetDirectoryPath()); PageMetadata pageMetadata = new PageMetadata(); if (!string.IsNullOrWhiteSpace(metadata)) { try { pageMetadata = JsonConvert.DeserializeObject <PageMetadata>(metadata); } catch (Exception ex) { _logger.LogError(ex, "Metadata invalid"); } } if (string.IsNullOrWhiteSpace(pageMetadata.Title)) { pageMetadata.Title = pagePath.Location.GetDestinationFolder().VirtualName; } return(pageMetadata); }
public ActionResult Improve(PagePath id, int revision) { var page = _repository.Get(id); var subject = page.Revisions.Single(x => x.Id == revision); subject.ApproveButWillImprove(); return RedirectToRoute("WikiAdmin", new { controller = "Page", action = "Edit", id = id.ToString() }); }
private async Task <PageData> GetPageDataAsync(PagePath pagePath) { DirectoryInfo pagesDirectory = _pageIOManager.GetPagesDirectory(); DirectoryInfo cacheDirectory = _cacheManager.GetCacheDirectory(); _cacheManager.ClearCache(); FileInfo pageFileInfo = new FileInfo(Path.Combine(pagesDirectory.FullName, pagePath.ToString())); string pageLocationHash = Hasher.GetMd5Hash(pagePath.Location.GetDirectoryPath()); string pageCachename = pageLocationHash + "_" + pageFileInfo.LastWriteTime.ToString("yyyyMMddHHmmss") + Cache.PagePostfix; string pageCache = await _cacheManager.LoadFromCacheAsync(pageCachename); string markdown = await _pageIOManager.LoadPage(pageFileInfo.FullName); string html; if (!string.IsNullOrEmpty(pageCache)) { html = pageCache; } else { _cacheManager.ClearCache(pageLocationHash + "*" + Cache.PagePostfix); html = _markdownConverter.ConvertToHtml(markdown); await _cacheManager.SaveToCacheAsync(pageCachename, html); } return(new PageData(markdown, html)); }
public ActionResult Approve(PagePath id, int revision) { var page = _repository.Get(id); var subject = page.Revisions.Single(x => x.Id == revision); subject.Approve(); if (Request.IsAjaxRequest()) return Json(new { success = true }); return RedirectToAction("Index"); }
/// <summary> /// Find three depths (-1, current, children) /// </summary> /// <param name="pagePath">Page to get map from</param> /// <returns>Items sorted by depths and titles</returns> public IEnumerable<WikiPageTreeNode> GetPartial(PagePath pagePath) { var myNode = _session.Query<WikiPageTreeNode>().First(x => x.Page.PagePath == pagePath); return (from x in _session.Query<WikiPageTreeNode>().Fetch(x => x.Page) where (x.Depth == myNode.Depth - 1 && x.Lineage.StartsWith(myNode.ParentLinage)) || (x.Depth == myNode.Depth && x.Lineage.StartsWith(myNode.ParentLinage)) || (x.Depth == myNode.Depth + 1 && x.Lineage.StartsWith(myNode.Lineage)) orderby x.Depth, x.Titles select x).ToList(); }
private string CreateHtmlLink(PagePath parsedPage, WikiLink link) { if (link.Exists) { return string.Format(@"<a href=""{0}"" class=""wiki-link"">{1}</a>", parsedPage.GetPathRelativeTo(link.PagePath), link.Title); } return string.Format( @"<a href=""{0}?title={1}"" class=""wiki-link missing"">{2}</a>", parsedPage.GetPathRelativeTo(link.PagePath), link.Title, link.Title); }
private Control getPagePath() { var pagePath = new PagePath( currentPageBehavior: getEntityResourceGroups().Any() ? PagePathCurrentPageBehavior.IncludeCurrentPageAndExcludePageNameIfEntitySetupExists : PagePathCurrentPageBehavior.IncludeCurrentPage); return(pagePath.IsEmpty ? null : pagePath); }
public async Task <PageContext> GetPageContextAsync(string virtualPath) { PagePath pagePath = GetPagePath(virtualPath); if (pagePath == null) { throw new AppException("Page not found"); } PageMetadata pageMetadata = await GetPageMetadataAsync(pagePath); return(new PageContext(pagePath, pageMetadata)); }
private Control getPagePath() { var entitySetupInfo = EwfPage.Instance.InfoAsBaseType.EsInfoAsBaseType; var pagePath = new PagePath( currentPageBehavior: entitySetupInfo != null && EwfPage.Instance.InfoAsBaseType.ParentResource == null && entitySetupInfo.Resources.Any() ? PagePathCurrentPageBehavior.IncludeCurrentPageAndExcludePageNameIfEntitySetupExists : PagePathCurrentPageBehavior.IncludeCurrentPage); return(pagePath.IsEmpty ? null : pagePath); }
/// <summary> /// default constructor /// the route parameter can be obtained from NavigationManager.Uri on client or HttpContext.Request.GetEncodedUrl() on server /// the aliaspath parameter can be obtained from PageState.Alias.Path on client or TenantManager.GetAlias().Path on server /// </summary> public Route(string route, string aliaspath) { Uri uri = new Uri(route); Authority = uri.Authority; Scheme = uri.Scheme; Host = uri.Host; Port = uri.Port.ToString(); Query = uri.Query; Fragment = uri.Fragment; AbsolutePath = uri.AbsolutePath; AliasPath = aliaspath; PagePath = AbsolutePath; ModuleId = ""; Action = ""; UrlParameters = ""; if (AliasPath.Length != 0 && PagePath.StartsWith("/" + AliasPath)) { PagePath = PagePath.Substring(AliasPath.Length + 1); } int pos = PagePath.IndexOf("/" + Constants.UrlParametersDelimiter + "/"); if (pos != -1) { UrlParameters = PagePath.Substring(pos + 3); PagePath = PagePath.Substring(1, pos); } pos = PagePath.IndexOf("/" + Constants.ModuleDelimiter + "/"); if (pos != -1) { ModuleId = PagePath.Substring(pos + 3); PagePath = PagePath.Substring(1, pos); } if (ModuleId.Length != 0) { pos = ModuleId.IndexOf("/"); if (pos != -1) { Action = ModuleId.Substring(pos + 1); ModuleId = ModuleId.Substring(0, pos); } } if (PagePath.StartsWith("/")) { PagePath = (PagePath.Length == 1) ? "" : PagePath.Substring(1); } if (PagePath.EndsWith("/")) { PagePath = PagePath.Substring(0, PagePath.Length - 1); } }
/// <summary> /// Initializes a new instance of the <see cref="WikiPage" /> class. /// </summary> /// <param name="parent"> Parent page. </param> /// <param name="pagePath"> Absolute path from wiki root. </param> /// <param name="title"> Page title. </param> /// <param name="template"> Template to use for child pages (if any). </param> public WikiPage(WikiPage parent, PagePath pagePath, string title, PageTemplate template) { if (pagePath == null) throw new ArgumentNullException("pagePath"); if (title == null) throw new ArgumentNullException("title"); Parent = parent; PagePath = pagePath; Title = title; CreatedBy = WikiContext.Current.User; CreatedAt = DateTime.Now; UpdatedAt = DateTime.Now; ChildTemplate = template; _backReferences = new List<WikiPage>(); }
public ActionResult Show(PagePath id, int revision) { var page = _repository.Get(id); var subject = page.Revisions.Single(x => x.Id == revision); return View(new ShowViewModel { Body = subject.HtmlBody, CreatedBy = subject.CreatedBy.DisplayName, PagePath = page.PagePath, RevisionId = revision }); }
private void AddChildren(PagePath pagePath, string pageUri, SiteMapNode currentMapNode, WikiPageTreeNode currentTreeNode, IEnumerable<WikiPageTreeNode> completeTree) { foreach (var childTreeNode in completeTree.Where(x => x.ParentLinage == currentTreeNode.Lineage)) { var child = new SiteMapNode(childTreeNode.Page.Title, childTreeNode.Path, childTreeNode.CreateLink(pageUri), childTreeNode.CreateLinksForPath(pageUri)); if (child.Path.Equals(pagePath)) child.IsCurrent = true; currentMapNode.AddChild(child); AddChildren(pagePath, pageUri, child, childTreeNode, completeTree); } }
public async Task <Page> GetPageAsync(string virtualPath) { PagePath pagePath = GetPagePath(virtualPath); if (pagePath == null) { return(null); } PageData pageData = await GetPageDataAsync(pagePath); PageMetadata pageMetadata = await GetPageMetadataAsync(pagePath); return(new Page(new PageContext(pagePath, pageMetadata), pageData)); }
/// <summary> /// Get a site map for three levels only (previous, current, children) /// </summary> /// <param name="pagePath"> /path/to/page/ of the page to generate the partial map for </param> /// <param name="pageUri"> Uri to the action that shows a page </param> /// <returns> Hierchical site map </returns> /// <example> /// var map = siteMapService.Get("BestPractices", Url.Action("Show", "Page")); /// </example> public IEnumerable<SiteMapNode> GetPartial(PagePath pagePath, string pageUri) { if (!_pageTreeRepository.Exists(pagePath)) return new LinkedList<SiteMapNode>(); var completeTree = _pageTreeRepository.GetPartial(pagePath); var nodes = new List<SiteMapNode>(); var minDepth = completeTree.OrderBy(x => x.Depth).FirstOrDefault().Depth; foreach (var pageTreeNode in completeTree.Where(x => x.Depth == minDepth)) { var node = new SiteMapNode(pageTreeNode.Page.Title, pageTreeNode.Path, pageTreeNode.CreateLink(pageUri), pageTreeNode.CreateLinksForPath(pageUri)); if (node.Path.Equals(pagePath)) node.IsCurrent = true; nodes.Add(node); AddChildren(pagePath, pageUri, node, pageTreeNode, completeTree); } return nodes; }
public ActionResult Index(PagePath id = null) { _logger.Warning("Get id " + id); var images = id == null ? _repository.FindAll() : _repository.FindForPage(id); if (Request.Headers["Accept"].Contains("json")) { var response = new { success = true, body = images.Select(CreateImageModel).ToList() }; return Json(response, JsonRequestBehavior.AllowGet); } return ViewOrPartial(new IndexViewModel { Images = images, PagePath = (id ?? new WikiRoot()).ToString() }); }
public async Task <Page> EditPageAsync(PagePath pagePath, string markdown) { if (pagePath == null) { throw new ArgumentNullException(nameof(pagePath)); } DirectoryInfo pagesDirectory = _pageIOManager.GetPagesDirectory(); FileInfo pageFileInfo = new FileInfo(Path.Combine(pagesDirectory.FullName, pagePath.ToString())); string pageLocationHash = Hasher.GetMd5Hash(pagePath.Location.GetDirectoryPath()); string pageCachename = pageLocationHash + "_" + pageFileInfo.LastWriteTime.ToString("yyyyMMddHHmmss") + Cache.PagePostfix; _cacheManager.ClearCache(pageCachename); await _pageIOManager.SavePage(pageFileInfo.FullName, markdown); PageData pageData = await GetPageDataAsync(pagePath); PageMetadata pageMetadata = await GetPageMetadataAsync(pagePath); return(new Page(new PageContext(pagePath, pageMetadata), pageData)); }
public async Task ModifyPageAsync(PageModifyCommand command) { if (command == null) { throw new ArgumentNullException(nameof(command)); } PagePath pagePath = GetPagePath(command.VirtualPath); if (pagePath == null) { throw new AppException("Page not found"); } _cacheManager.ClearCache("*" + Cache.NavPostfix); string pageDirectoryPath = pagePath.Location.GetDirectoryPath(); PageMetadata pageMetadata = await GetPageMetadataAsync(pagePath); pageMetadata.Title = command.Title; pageMetadata.Description = command.Description; await _pageIOManager.SaveMetadataAsync(pageDirectoryPath, pageMetadata); if (!command.VirtualName.Equals(pagePath.Location.GetDestinationFolder().VirtualName)) { string pagesDirectoryPath = _pageIOManager.GetPagesDirectory().FullName; string oldPageDirectoryName = pagePath.Location.GetDestinationFolder().DirectoryName; string newPageDirectoryPath = pageDirectoryPath.Remove(pageDirectoryPath.LastIndexOf(Separator.Path) + 1) + oldPageDirectoryName.Split(Separator.Sequence)[0] + Separator.Sequence + command.VirtualName; string fakePageDirectoryPath = newPageDirectoryPath + "_"; Directory.Move(Path.Combine(pagesDirectoryPath, pageDirectoryPath), Path.Combine(pagesDirectoryPath, fakePageDirectoryPath)); Directory.Move(Path.Combine(pagesDirectoryPath, fakePageDirectoryPath), Path.Combine(pagesDirectoryPath, newPageDirectoryPath)); } }
public ActionResult ReviewRequired(PagePath id) { return View(id); }
/// <summary> /// Initializes a new instance of the <see cref="MissingPageLink"/> class. /// </summary> /// <param name="page">Page that links to a missing page.</param> /// <param name="missingPagePath">Name of the missing page.</param> public MissingPageLink(WikiPage page, PagePath missingPagePath) { Page = page; MissingPagePath = missingPagePath.ToString(); }
private PagePath CreatePath(PagePath pagePath, string linkPath) { // child page if (!linkPath.Contains("..") && !linkPath.Contains("/")) return new PagePath(pagePath + linkPath + "/"); if (linkPath.Contains("..")) return new RelativePagePath(pagePath, linkPath).ToAbsolute(); return linkPath.StartsWith("/") ? new PagePath(linkPath) : pagePath.CreateChildPath(linkPath); }
public WikiPageTreeNode GetByPath(PagePath pageName) { return _session.Query<WikiPageTreeNode>().FirstOrDefault(x => x.Page.PagePath == pageName); }
public ActionResult Upload(string pagePath, string title, HttpPostedFileBase imageFile) { if (string.IsNullOrEmpty(pagePath)) pagePath = "/"; var path = new PagePath(pagePath); object result = null; if (imageFile == null || imageFile.ContentLength == 0) { result = new { success = false, body = "No file was uploaded." }; } else if (imageFile.ContentLength > 5000000) { result = new { succcess = false, body = "Too large image, 5Mb is the limit." }; } else { var image = _repository.Create(path, Path.GetFileName(imageFile.FileName), title, imageFile.ContentType, imageFile.InputStream); result = new { success = true, body = CreateImageModel(image) }; } return new WrappedJsonResult(result); }
public ActionResult Edit(PagePath id) { var path = id ?? new WikiRoot(); var page = _repository.Get(path); var revision = page.GetLatestRevision(); var model = new EditViewModel {Path = path, Title = page.Title, Content = revision.RawBody}; return View(model); }
public bool Exists(PagePath pagePath) { return _session.Query<WikiPageTreeNode>().Any(x => x.Page.PagePath == pagePath); }
public ActionResult Delete(DeleteViewModel model) { var path = new PagePath(model.PageName); _pageService.DeletePage(path); return this.RedirectToWikiPage(new PagePath("/")); }
public ActionResult Delete(PagePath id) { var page = _repository.Get(id); return View(new DeleteViewModel { PageName = page.PagePath.ToString(), Title = page.Title, Children = page.Children.Select(x => x.PagePath.ToString()).ToList() }); }
public WikiPageTreeNode GetByPath(string wikiPath) { var path = new PagePath(wikiPath); return _session.Query<WikiPageTreeNode>().FirstOrDefault(x => x.Path == path); }
/// <summary> /// LUA结构支持 /// </summary> /// <returns></returns> public override void GetLuaStruct(StringBuilder code) { base.GetLuaStruct(code); int idx; idx = 0; code.AppendLine("['ApiItems'] ={"); foreach (var val in ApiItems) { if (idx++ > 0) { code.Append(','); } code.AppendLine($@"{val.GetLuaStruct()}"); } code.AppendLine("},"); idx = 0; code.AppendLine("['Entities'] ={"); foreach (var val in Entities) { if (idx++ > 0) { code.Append(','); } code.AppendLine($@"{val.GetLuaStruct()}"); } code.AppendLine("},"); code.AppendLine($@"['ReadOnly'] ={(ReadOnly.ToString().ToLower())},"); if (!string.IsNullOrWhiteSpace(DataBaseObjectName)) { code.AppendLine($@"['DataBaseObjectName'] = '{DataBaseObjectName.ToLuaString()}',"); } else { code.AppendLine($@"['DataBaseObjectName'] = nil,"); } if (!string.IsNullOrWhiteSpace(NameSpace)) { code.AppendLine($@"['NameSpace'] = '{NameSpace.ToLuaString()}',"); } else { code.AppendLine($@"['NameSpace'] = nil,"); } if (!string.IsNullOrWhiteSpace(PagePath)) { code.AppendLine($@"['PagePath'] = '{PagePath.ToLuaString()}',"); } else { code.AppendLine($@"['PagePath'] = nil,"); } if (!string.IsNullOrWhiteSpace(BusinessPath)) { code.AppendLine($@"['BusinessPath'] = '{BusinessPath.ToLuaString()}',"); } else { code.AppendLine($@"['BusinessPath'] = nil,"); } if (!string.IsNullOrWhiteSpace(ClientCsPath)) { code.AppendLine($@"['ClientCsPath'] = '{ClientCsPath.ToLuaString()}',"); } else { code.AppendLine($@"['ClientCsPath'] = nil,"); } if (!string.IsNullOrWhiteSpace(ModelPath)) { code.AppendLine($@"['ModelPath'] = '{ModelPath.ToLuaString()}',"); } else { code.AppendLine($@"['ModelPath'] = nil,"); } if (!string.IsNullOrWhiteSpace(CodePath)) { code.AppendLine($@"['CodePath'] = '{CodePath.ToLuaString()}',"); } else { code.AppendLine($@"['CodePath'] = nil,"); } code.AppendLine($@"['DbType'] ='{DbType}',"); if (!string.IsNullOrWhiteSpace(DbHost)) { code.AppendLine($@"['DbHost'] = '{DbHost.ToLuaString()}',"); } else { code.AppendLine($@"['DbHost'] = nil,"); } if (!string.IsNullOrWhiteSpace(DbSoruce)) { code.AppendLine($@"['DbSoruce'] = '{DbSoruce.ToLuaString()}',"); } else { code.AppendLine($@"['DbSoruce'] = nil,"); } if (!string.IsNullOrWhiteSpace(DbPassWord)) { code.AppendLine($@"['DbPassWord'] = '******',"); } else { code.AppendLine($@"['DbPassWord'] = nil,"); } if (!string.IsNullOrWhiteSpace(DbUser)) { code.AppendLine($@"['DbUser'] = '******',"); } else { code.AppendLine($@"['DbUser'] = nil,"); } }
public ActionResult Create(PagePath id, string title = null) { if (!User.IsInRole(WikiRole.Contributor)) return View("MayNotCreate"); var model = new CreateViewModel { PagePath = id, Title = title ?? id.Name, Content = "", Templates = new List<SelectListItem>(), }; var parent = _repository.Get(id.ParentPath); if (parent != null) { model.ParentId = parent.Id; model.ParentPath = parent.PagePath.ToString(); if (parent.ChildTemplate != null) { model.TemplateId = parent.ChildTemplate.Id; model.Content = parent.ChildTemplate.Content; } } model.Templates = _templateRepository.Find().Select(x => new SelectListItem { Selected = x.Id == model.TemplateId, Text = x.Title, Value = x.Id.ToString( CultureInfo.InvariantCulture) }); return View(model); }
public ConsoleResultModel Run() { TabController tc = new TabController(); List <PageModelBase> lst = new List <PageModelBase>(); List <PageModelBase> lstOut = new List <PageModelBase>(); if (ParentId.HasValue) { lst = GetPagesByParentId((int)ParentId); } else { TabCollection tabs = tc.GetTabsByPortal(PortalId); foreach (KeyValuePair <int, TabInfo> kvp in tabs) { lst.Add(new PageModelBase(kvp.Value)); } } // filter results if needed if (Deleted.HasValue) { var query = from page in lst where page.IsDeleted == Deleted select page; List <PageModelBase> filteredList = query.ToList(); lst = filteredList; } bool bSearchTitle = false; string searchTitle = null; bool bSearchName = false; string searchName = null; bool bSearchPath = false; string searchPath = null; bool bSearchSkin = false; string searchSkin = null; bool bMatchVisibility = PageVisible.HasValue; if (!string.IsNullOrEmpty(PageName)) { searchName = PageName.Replace("*", ".*"); bSearchName = true; } if (!string.IsNullOrEmpty(PageTitle)) { searchTitle = PageTitle.Replace("*", ".*"); bSearchTitle = true; } if (!string.IsNullOrEmpty(PagePath)) { searchPath = PagePath.Replace("*", ".*"); bSearchPath = true; } if (!string.IsNullOrEmpty(PageSkin)) { searchSkin = PageSkin.Replace("*", ".*"); bSearchSkin = true; } if (bSearchTitle || bSearchName || bSearchPath || bSearchSkin || bMatchVisibility) { bool bIsMatch = false; foreach (PageModelBase pim in lst) { bIsMatch = true; if (bSearchTitle) { bIsMatch = bIsMatch & Regex.IsMatch(pim.Title, searchTitle, RegexOptions.IgnoreCase); } if (bSearchName) { bIsMatch = bIsMatch & Regex.IsMatch(pim.Name, searchName, RegexOptions.IgnoreCase); } if (bSearchPath) { bIsMatch = bIsMatch & Regex.IsMatch(pim.Path, searchPath, RegexOptions.IgnoreCase); } if (bSearchSkin) { bIsMatch = bIsMatch & Regex.IsMatch(pim.Skin, searchSkin, RegexOptions.IgnoreCase); } if (bMatchVisibility) { bIsMatch = bIsMatch & (pim.IncludeInMenu == PageVisible); } if (bIsMatch) { lstOut.Add(pim); } } } else { lstOut = lst; } var msg = string.Format("{0} page{1} found", lstOut.Count, (lstOut.Count != 1 ? "s" : "")); return(new ConsoleResultModel(msg) { data = lstOut, fieldOrder = new string[] { "TabId", "ParentId", "Name", "Title", "Skin", "Path", "IncludeInMenu", "IsDeleted" } }); }
public ActionResult Revisions(string id) { if (string.IsNullOrEmpty(id)) id = "/"; else if (!id.StartsWith("/")) id = "/" + id; var path = new PagePath(id); var page = _repository.Get(path); var userIds = page.Revisions.Select(k => k.CreatedBy).ToList(); if (!userIds.Contains(page.UpdatedBy)) userIds.Add(page.UpdatedBy); var items = page.Revisions.Select(history => new DiffViewModelItem { RevisionId = history.Id, CreatedAt = history.CreatedAt, UserDisplayName = page.UpdatedBy.DisplayName, Comment = history.ChangeDescription }).OrderByDescending(x => x.CreatedAt).ToList(); return View(new DiffViewModel { Path = path, Revisions = items }); }