public override IEnumerable <SearchResultViewModel> Search(string searchText)
{
List <SearchResultViewModel> results = new List <SearchResultViewModel>();
foreach (Page page in Pages.Where(p => p.Title.ToLowerInvariant().Contains(searchText.ToLowerInvariant())))
{
results.Add(new SearchResultViewModel()
{
Id = page.Id,
Title = page.Title,
ContentSummary = PageContents.Single(p => p.Page == page).Text
});
}
foreach (PageContent pageContent in PageContents.Where(p => p.Text.ToLowerInvariant().Contains(searchText.ToLowerInvariant())))
{
results.Add(new SearchResultViewModel()
{
Id = pageContent.Page.Id,
ContentSummary = pageContent.Text,
Title = pageContent.Page.Title
});
}
return(results);
}
private static void CreatePages()
{
context.CreateQuery <Category>().LoadRelated(c => c.Website.Templates, c => c.Tenant.Users).ToList()
.ForEach(category =>
{
var author = category.Tenant.Users.First();
var templates = category.Website.Templates.ToArray();
var pageContent = new PageContents();
pageContent.Add("MainContent", "<strong>Sample MainContent</strong>");
//if (category.Website.Type != WEBSITE_TYPE.BLOG)
//{
// context.AddObject(Page.Create("index", author, PAGE_CONTENT_TYPE.HTML, pageContent.ToList().ToXml(),
// (category.Website.Type == WEBSITE_TYPE.BLOG) ? templates[3] : templates[0], category, new[] { "default", "technology" }, true, CreateDefaultPermissionSet(category.Tenant)));
//}
pageContent.Add("Title", "Sample Page Title");
//context.AddObject(Page.Create("page1", author, PAGE_CONTENT_TYPE.HTML, pageContent.ToList().ToXml(),
// (category.Website.Type == WEBSITE_TYPE.BLOG) ? templates[3] : templates[1], category, new[] { "default", "technology" }, true, CreateDefaultPermissionSet(category.Tenant)));
pageContent.Add("Category", "Good");
context.AddObject(Page.Create("page2", author, PAGE_CONTENT_TYPE.HTML, pageContent.ToList().ToXml(),
(category.Website.Type == WEBSITE_TYPE.BLOG) ? templates[1] : templates[0], category, new[] { "default", "technology" }, true, CreateDefaultPermissionSet(category.Tenant)));
context.SaveChanges();
});
}
public async Task <IActionResult> Edit(int id, [Bind("Title,ShortDesc,LongDesc,FooterText,Facebook,Linkedin,Id,File,OurTeamImageFile")] PageContents pageContents)
{
if (id != pageContents.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var pc = _context.PageContents.AsNoTracking().First();
if (pageContents.SliderVideoURL != null)
{
string img = pc.SliderVideoURL;
if (img != null && System.IO.File.Exists(img))
{
System.IO.File.Delete(img);
}
}
else
{
pageContents.SliderVideoURL = pc.SliderVideoURL;
}
if (pageContents.OurTeamImage != null)
{
string img = pc.OurTeamImage;
if (img != null && System.IO.File.Exists(img))
{
System.IO.File.Delete(img);
}
}
else
{
pageContents.OurTeamImage = pc.OurTeamImage;
}
_context.Update(pageContents);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PageContentsExists(pageContents.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(pageContents));
}
public async Task <IHttpActionResult> GetAsync(string uri)
{
PageContents pageContents = await _service.ParseAsync(uri);
if (pageContents == null)
{
return(NotFound());
}
return(Ok(pageContents));
}
public async Task <IActionResult> Create([Bind("Title,ShortDesc,LongDesc,FooterText,Facebook,Linkedin,Id,File,OurTeamImageFile")] PageContents pageContents)
{
if (ModelState.IsValid)
{
_context.Add(pageContents);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(pageContents));
}
private string GetPageContents(FormCollection coll)
{
var pageContents = new PageContents();
var prefix = "Contents-";
foreach (var key in coll.AllKeys.Where(x => x.StartsWith(prefix)))
{
pageContents.Add(key.Substring(prefix.Length), coll[key]);
}
return(pageContents.ToXml());
}
public PageContent AddNewPageContentVersion(Page page, string text, string editedBy, DateTime editedOn, int version)
{
PageContent content = new PageContent();
content.Id = Guid.NewGuid();
page.ModifiedBy = content.EditedBy = editedBy;
page.ModifiedOn = content.EditedOn = editedOn;
content.Page = page;
content.Text = text;
content.VersionNumber = FindPageContentsByPageId(page.Id).Max(x => x.VersionNumber) + 1;
PageContents.Add(content);
return(content);
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
PageContents = await _context.PageInfo.FirstOrDefaultAsync(m => m.Id == id);
if (PageContents == null)
{
return(NotFound());
}
return(Page());
}
public async Task <IActionResult> OnGet(int?Id)
{
if (Id == null)
{
return(NotFound());
}
PageContents = await _Context.PageInfo.FindAsync(Id);
ViewData["Content"] = PageContents.PageContent;
if (PageContents == null)
{
return(NotFound());
}
return(Page());
}
public void UpdatePageContent(PageContent content)
{
PageContent existingContent = PageContents.FirstOrDefault(x => x.Id == content.Id);
if (existingContent == null)
{
// Do nothing
}
else
{
existingContent.EditedOn = content.EditedOn;
existingContent.EditedBy = content.EditedBy;
existingContent.Text = content.Text;
existingContent.VersionNumber = content.VersionNumber;
}
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
PageContents = await _context.PageInfo.FindAsync(id);
if (PageContents != null)
{
_context.PageInfo.Remove(PageContents);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public PageContent AddNewPage(Page page, string text, string editedBy, DateTime editedOn)
{
page.Id = Pages.Count + 1;
Pages.Add(page);
PageContent content = new PageContent();
content.Id = Guid.NewGuid();
content.EditedBy = editedBy;
content.EditedOn = editedOn;
content.Page = page;
content.Text = text;
content.VersionNumber = 1;
PageContents.Add(content);
return(content);
}
public PageContent GetLatestPageContent(int pageId)
{
PageContentEntity entity = PageContents.Where(x => x.Page.Id == pageId).OrderByDescending(x => x.EditedOn).FirstOrDefault();
return(FromEntity.ToPageContent(entity));
}
public PageContent GetPageContentById(Guid id)
{
PageContentEntity entity = PageContents.FirstOrDefault(p => p.Id == id);
return(FromEntity.ToPageContent(entity));
}
public IEnumerable <PageContent> AllPageContents()
{
List <PageContentEntity> entities = PageContents.ToList();
return(FromEntity.ToPageContentList(entities));
}
public IEnumerable <PageContent> FindPageContentsByPageId(int pageId)
{
List <PageContentEntity> entities = PageContents.Where(p => p.Page.Id == pageId).ToList();
return(FromEntity.ToPageContentList(entities));
}
public PageContent GetPageContentByVersionId(Guid versionId)
{
return(PageContents.FirstOrDefault(p => p.Id == versionId));
}
public PageContent GetLatestPageContent(int pageId)
{
return(PageContents.Where(p => p.Page.Id == pageId).OrderByDescending(x => x.EditedOn).FirstOrDefault());
}
public IEnumerable <PageContent> AllPageContents()
{
return(PageContents.ToList());
}
public async Task <PageContents> ParseAsync(string url)
{
// instance or static variable
HttpClient client = new HttpClient();
PageContents pageContents = new PageContents();
try
{
// get answer in non-blocking way
using (var response = await client.GetAsync(url))
{
using (var content = response.Content)
{
// get base address of url for images defined relatively
Uri uri = new Uri(url);
// location after domain
int y = uri.AbsoluteUri.LastIndexOf(uri.PathAndQuery);
string baseAddress = uri.AbsoluteUri.Substring(0, y);
// read answer in non-blocking way
var result = await content.ReadAsStringAsync();
var document = new HtmlDocument();
document.LoadHtml(result);
var nodes = document.DocumentNode.SelectNodes("//img[@src]");
foreach (HtmlNode img in nodes)
{
HtmlAttribute srcAttribute = img.Attributes["src"];
string src = srcAttribute.Value;
// convert relative path to url
if (!src.StartsWith("http"))
{
src = baseAddress + src;
}
//prevent duplicates
if (!pageContents.ImageUrls.Contains(src))
{
pageContents.ImageUrls.Add(src);
}
}
// Prepare for word count
// only concerned with <body> element
string textBody = document.DocumentNode.SelectSingleNode("//body").InnerHtml;
// remove HTML tags
textBody = Regex.Replace(textBody, "</?[a-z][a-z0-9]*[^<>]*>", " ");
// remove HTML comments
textBody = Regex.Replace(textBody, @"<!--(.|\s)*?-->", " ");
// remove script tags
textBody = Regex.Replace(textBody, "<script.*?</script>", " ", RegexOptions.Singleline | RegexOptions.IgnoreCase);
// remove styles
textBody = Regex.Replace(textBody, "<style.*?</style>", " ", RegexOptions.Singleline | RegexOptions.IgnoreCase);
// remove formatting
textBody = textBody.Replace("\n", "").Replace("\t", "").Replace("\r", "");
// grab all words
string[] words = textBody.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
// total number of words
pageContents.WordCount = words.Length;
// compile counts by word
Dictionary <string, int> wordCounts = new Dictionary <string, int>();
foreach (string word in words)
{
if (wordCounts.ContainsKey(word))
{
wordCounts[word] += 1;
}
else
{
wordCounts.Add(word, 1);
}
}
// sort words by count
var wordCountsList = wordCounts.ToList();
wordCountsList.Sort((pair1, pair2) => pair1.Value.CompareTo(pair2.Value));
wordCountsList.Reverse();
// grab top 10 words
int top10 = (wordCountsList.Count > 10) ? 10 : wordCountsList.Count;
for (int i = 0; i < top10; i++)
{
pageContents.TopTen.Add(wordCountsList[i]);
}
}
}
}
catch
{
return(null);
}
return(pageContents);
}
public PageContent GetPageContentByPageIdAndVersionNumber(int id, int versionNumber)
{
return(PageContents.FirstOrDefault(p => p.Page.Id == id && p.VersionNumber == versionNumber));
}
public IEnumerable <PageContent> FindPageContentsByPageId(int pageId)
{
return(PageContents.Where(p => p.Page.Id == pageId));
}
public PageContent GetPageContentById(Guid id)
{
return(PageContents.FirstOrDefault(p => p.Id == id));
}
public void DeletePageContent(PageContent pageContent)
{
PageContents.Remove(pageContent);
}
private IHtmlContent RenderContentItem(PlaceHolder placeHolder)
{
IHtmlContent htmlContentItems = null;
if (placeHolder != null)
{
//string currentResult = "";
var htmlCurrentResult = new HtmlContentBuilder();
List <ContentResult> currentResults = new List <ContentResult>();
List <ContentResult> moduleResult = null;
var layoutType = placeHolder.Type;
ViewContext.ViewData["isEditMode"] = false;
if (ModuleActionResults.ContainsKey(placeHolder.Id.ToString()))
{
//Modules
if (ModuleActionResults.TryGetValue(placeHolder.Id.ToString(), out moduleResult))
{
//sb.Append(moduleResult);
ModuleActionResults.Remove(placeHolder.Id.ToString());
currentResults.AddRange(moduleResult);
}
}
if (PageContents.Any(pc => pc.ContainerId == placeHolder.Id))
{
//Page contents
var pageContents = PageContents
.Where(pc => pc.ContainerId == placeHolder.Id)
.OrderBy(pc => pc.SortOrder).ToList();
foreach (var pageContent in pageContents)
{
string typeName = pageContent.ContentType.Name;
var contentTranslation = pageContent.PageContentTranslation.FirstOrDefault(t => t.CultureCode.ToLower() == CurrentCulture.ToString().ToLower());
dynamic content = (contentTranslation != null) ? SDJsonConvert.DeserializeObject <dynamic>(contentTranslation.ContentData) : null;
if (content != null)
{
var dynamicContent = new DynamicContent
{
PageContent = pageContent,
Content = content
};
string contentTypesViewPath = string.Format(Globals.ContentTypesViewPath, _scopeService.PageContext.SelectedTheme, typeName);
var htmlPageContent = _htmlHelper.Partial(contentTypesViewPath, dynamicContent);
//var contentResult = GetString(htmlContent);
currentResults.Add(new ContentResult
{
//Result = contentResult,
HtmlResult = htmlPageContent,
SortOrder = pageContent.SortOrder
});
}
}
}
//var placeHolderResult = RenderContentItems(placeHolder.PlaceHolders);
//currentResults.Add(new ContentResult
//{
// HtmlResult = placeHolderResult,
// SortOrder = placeHolder.SortOrder
//});
if (placeHolder.PlaceHolders != null && placeHolder.PlaceHolders.Count > 0)
{
foreach (var childPlaceHolder in placeHolder.PlaceHolders)
{
var placeHolderResult = RenderContentItem(childPlaceHolder);
currentResults.Add(new ContentResult
{
HtmlResult = placeHolderResult,
SortOrder = childPlaceHolder.SortOrder
});
}
}
var sortedResult = currentResults.OrderBy(r => r.SortOrder).ToList();
foreach (var contentResult in sortedResult)
{
//currentResult += contentResult.Result;
htmlCurrentResult.AppendHtml(contentResult.HtmlResult);
}
var layoutContent = new LayoutContent
{
PlaceHolder = placeHolder,
ContentResult = htmlCurrentResult
};
htmlContentItems = _htmlHelper.Partial(string.Format(Globals.LayoutTypesPath, _scopeService.PageContext.SelectedTheme, layoutType), layoutContent);
//var layoutResult = GetString(htmlContent);
//sb.Append(layoutResult);
}
return(htmlContentItems);
}
public PageContent GetPageContentByPageIdAndVersionNumber(int id, int versionNumber)
{
PageContentEntity entity = PageContents.FirstOrDefault(p => p.Page.Id == id && p.VersionNumber == versionNumber);
return(FromEntity.ToPageContent(entity));
}
public IEnumerable <PageContent> FindPageContentsEditedBy(string username)
{
return(PageContents.Where(p => p.EditedBy == username));
}
public IEnumerable <PageContent> GetPageContentByEditedBy(string username)
{
List <PageContentEntity> entities = PageContents.Where(p => p.EditedBy == username).ToList();
return(FromEntity.ToPageContentList(entities));
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
if (CurrentPage == null)
{
output.Content.SetHtmlContent("Page object (sde-page) cannot be null");
return;
}
if (ModuleActionResults == null)
{
output.Content.SetHtmlContent("Module action results (sde-module-results) cannot be null");
return;
}
if (CurrentPage.Layout == null)
{
output.Content.SetHtmlContent("Layout is not configured, choose a layout");
return;
}
try
{
((HtmlHelper)_htmlHelper).Contextualize(ViewContext);
PageLayout pageLayout = new PageLayout();
pageLayout.Name = CurrentPage.Layout.Name;
var properties = _propertyRepository.GetProperties();
pageLayout.PlaceHolders = JsonConvert.DeserializeObject <List <PlaceHolder> >(CurrentPage.Layout.Config);
GetPropertyValue(pageLayout.PlaceHolders, properties);
PageContents = Mapper.Map <ICollection <PageContent> >(CurrentPage.PageContent);
//Copy property options from master data
if (PageContents != null && PageContents.Count > 0)
{
foreach (var pageContent in PageContents)
{
if (pageContent.ContentType.Properties != null && pageContent.ContentType.Properties.Count > 0)
{
foreach (var prop in pageContent.ContentType.Properties)
{
var propValue = pageContent.Properties.FirstOrDefault(p => p.Id == prop.Id);
if (propValue != null)
{
propValue.OptionListId = prop.OptionListId;
propValue.OptionList = prop.OptionList;
}
}
}
}
}
if (pageLayout.PlaceHolders != null && pageLayout.PlaceHolders.Count > 0)
{
HtmlContentBuilder result = RenderContentItems(pageLayout.PlaceHolders);
if (ModuleActionResults.Count > 0)
{
//One or more modules are not added in containers
foreach (var moduleActionResult in ModuleActionResults)
{
if (moduleActionResult.Value != null && moduleActionResult.Value.Count > 0)
{
foreach (var contentResult in moduleActionResult.Value)
{
//result += contentResult.HtmlResult;
result.AppendHtml(contentResult.HtmlResult);
}
}
}
}
output.Content.SetHtmlContent(result);
//Release all resources
pageLayout.RegisterForDispose(ViewContext.HttpContext);
PageContents.GetEnumerator().RegisterForDispose(ViewContext.HttpContext);
ModuleActionResults.GetEnumerator().RegisterForDispose(ViewContext.HttpContext);
pageLayout.RegisterForDispose(ViewContext.HttpContext);
}
}
catch (Exception ex)
{
throw ex;
}
}
