public ActionResult Create([ModelBinder(typeof(PageContentModelBinder))] PageContentModel pageContentModel)
{
if (ModelState.IsValid)
{
if (!IsAvailable(pageContentModel.PageUrl))
{
pageContentModel.PageUrl = CaseChange.TitleCase(pageContentModel.PageUrl);
if (!pageContentModel.PageUrl.StartsWith("/"))
{
pageContentModel.PageUrl = "/" + pageContentModel.PageUrl;
}
pageContentModel.PageName = CaseChange.TitleCase(pageContentModel.PageName);
PageContent objPageContent = PageContentMap.Map(pageContentModel);
_repPageContent.Add(objPageContent);
_repPageContent.Save();
TempData[LeonniConstants.SuccessMessage] = "Page Content added successfully";
return(RedirectToAction("Index"));
}
else
{
TempData[LeonniConstants.ErrorMessage] = "\"" + pageContentModel.PageUrl + "\"" + " already exists, Please select another PageUrl name";
return(RedirectToAction("Create"));
}
}
else
{
LoadLanguageDropdown();
return(View(pageContentModel));
}
}
public ViewResult Edit(int id)
{
PageContent pageContent = _pageContentSrv.GetPageContent(id);
PageContentModel model = _mapper.Map <PageContentModel>(pageContent);
return(View(model));
}
public ActionResult CreatePage(PageContentViewModel pageContent)
{
try {
if (ModelState.IsValid)
{
var pageSeoModel = new PageSeoModel {
Title = pageContent.Title,
KeyWords = pageContent.KeyWords,
Descriptions = pageContent.Descriptions
};
var htmlContentModel = new HtmlContentModel {
HtmlContent = pageContent.HtmlContent,
UniqueCode = System.Guid.NewGuid().ToString()
};
var pageContentModel = new PageContentModel {
Header = pageContent.Header,
Url = pageContent.Url,
IsPublished = false,
PageSeoModel = pageSeoModel,
HtmlContentModel = htmlContentModel
};
_pageContentEssenceManager.CreatePage(pageContentModel);
return(RedirectToAction("ManagementPage"));
}
}
catch (ValidationException ex) {
ModelState.AddModelError(ex.Property, ex.Message);
}
return(View(pageContent));
}
public void EditPage(PageContentModel pageContentModel)
{
if (pageContentModel == null)
{
throw new ValidationException("Страница не найдена", "");
}
var url = FriendlyUrls.GetFriendlyUrl(!string.IsNullOrEmpty(pageContentModel.Url) ? pageContentModel.Url : pageContentModel.Header);
if (!HasUrl(url, pageContentModel.Id))
{
throw new ValidationException("Такой url уже существует.", "");
}
var pageContentEssence = new PageContentEssence {
Id = pageContentModel.Id,
Header = pageContentModel.Header,
Url = url,
IsPublished = pageContentModel.IsPublished,
SeoID = pageContentModel.SeoID,
HtmlContentID = pageContentModel.HtmlContentID
};
using (EntitiesContext context = new EntitiesContext()) {
context.Entry(pageContentEssence).State = EntityState.Modified;
context.SaveChanges();
}
}
public void CreatePage(PageContentModel pageContentModel)
{
if (pageContentModel == null)
{
throw new ValidationException("Пустая страница", "");
}
var url = FriendlyUrls.GetFriendlyUrl(!string.IsNullOrEmpty(pageContentModel.Url) ? pageContentModel.Url : pageContentModel.Header);
if (!HasUrl(url, pageContentModel.Id))
{
throw new ValidationException("Такой url уже существует.", "");
}
var pageContentEssence = new PageContentEssence {
Header = pageContentModel.Header,
Url = url,
IsPublished = pageContentModel.IsPublished,
HtmlContent = new HtmlContentEssence {
HtmlContent = pageContentModel.HtmlContentModel.HtmlContent,
UniqueCode = pageContentModel.HtmlContentModel.UniqueCode
},
PageSeo = new PageSeoEssence {
Title = pageContentModel.PageSeoModel.Title,
KeyWords = pageContentModel.PageSeoModel.KeyWords,
Descriptions = pageContentModel.PageSeoModel.Descriptions
}
};
using (EntitiesContext context = new EntitiesContext()) {
context.PageContentEssences.Add(pageContentEssence);
context.SaveChanges();
}
}
public IActionResult Create(PageContentModel pageModel)
{
if (ModelState.IsValid)
{
var newCat = _pageContentService.Insert(base.UserId, pageModel);
}
return(Ok());
}
public ActionResult Create()
{
LoadLanguageDropdown();
PageContentModel objPageContentModel = new PageContentModel();
ViewBag.Contents = "current";
return(View(objPageContentModel));
}
public IActionResult Update(string id, PageContentModel pageModel)
{
if (ModelState.IsValid)
{
var updateCat = _pageContentService.Update(base.UserId, id, pageModel);
}
return(Ok());
}
public ActionResult Edit(int id)
{
PageContentModel objPageContentModel = PageContentMap.Map(_repPageContent.GetSingle(x => x.Id == id));
LoadLanguageDropdown();
ViewBag.Contents = "current";
return(View(objPageContentModel));
}
//
//====================================================================================================
//
public PageContentModel Clone(CPBaseClass cp)
{
PageContentModel result = (PageContentModel)this.Clone();
result.id = cp.Content.AddRecord(contentName);
result.ccguid = cp.Utils.CreateGuid();
result.save <PageContentModel>(cp);
return(result);
}
protected void Page_Load(object sender, EventArgs e)
{
YWC_StorageEntities db = new YWC_StorageEntities();
PageContentModel model = new PageContentModel();
PageContent content = model.GetPageContent();
MainTitle.Text = content.Donation_MainTitle;
Desc1.Text = content.Donation_Desc1;
}
public async Task <PageContentDataModel> UpdatePageContent(string token, PageContentModel pageContentModel)
{
string attachmentstring = JsonConvert.SerializeObject(pageContentModel);
var httpContent = new StringContent(attachmentstring, Encoding.UTF8, "application/json");
var requestUrl = CreateRequestUri(string.Format(System.Globalization.CultureInfo.InvariantCulture,
"api/PageContent/UpdatePageContent"));
return(await PostAsync <PageContentDataModel>(requestUrl, httpContent));
}
public ActionResult Edit(PageContentModel model)
{
if (ModelState.IsValid)
{
PageContent pageContent = _mapper.Map <PageContent>(model);
_pageContentSrv.UpdatePageContent(pageContent);
}
return(RedirectToAction("PageContents"));
}
public string GetReturnUrl()
{
if (PublishmentSystemId == 0)
{
return(PageAuxiliaryTable.GetRedirectUrl());
}
else
{
return(PageContentModel.GetRedirectUrl(PublishmentSystemId));
}
}
public async Task <DbStatusResult> UpdatePageContent(PageContentModel entity)
{
var cmd = new DbStatusCommand();
await ExecuteSQLWithParams("[dbo].UpdatePageContent",
GetJsonParam("@PageContent", entity),
cmd.IdParam,
cmd.StatusParam,
cmd.MessageParam);
return(cmd.StatusResult);
}
public async Task <IActionResult> SavePageContent([FromBody] PageContentModel model)
{
var connectionManager = HttpContext.RequestServices.GetService <IConnectionManager>();
await connectionManager.BroadcastAsyncFileChanged(model.Content, model.Fullname);
if (System.IO.File.Exists(model.Fullname))
{
System.IO.File.WriteAllText(model.Fullname, model.Content, Encoding.UTF8);
}
return(Json(new WebResult()));
}
private ActionResult GenerateResult(string methodName)
{
PageContent pageContent = _pageContentSrv.GetPageContentByCode(methodName);
if (pageContent != null)
{
PageContentModel model = _mapper.Map <PageContentModel>(pageContent);
return(View((object)model.Content));
}
else
{
return(RedirectToAction("Index", "Main"));
}
}
public static PageContent Map(PageContentModel objModel)
{
PageContent objPageContent = new PageContent()
{
Id = objModel.PageId,
LanguageId = objModel.LanguageId,
PageUrl = objModel.PageUrl.Trim(),
PageName = objModel.PageName.Trim(),
Content = objModel.Content.Trim(),
Language = LanguageMap.Map(objModel.Language)
};
return(objPageContent);
}
public static PageContentModel Map(PageContent objModel)
{
PageContentModel objPageContentModel = new PageContentModel()
{
PageId = objModel.Id,
//LanguageId = objModel.LanguageId,
PageUrl = objModel.PageUrl.Trim(),
PageName = objModel.PageName.Trim(),
Content = objModel.Content.Trim(),
Language = LanguageMap.Map(objModel.Language)
};
//objPageContentModel.Language = LanguageMap.Map(Language.FindSingleBy.Id(objModel.LanguageId));
return(objPageContentModel);
}
public ActionResult CreatePageContent(PageContentModel model)
{
if (ModelState.IsValid)
{
PageContent pageContent = _mapper.Map <PageContent>(model);
_pageContentSrv.Add(pageContent);
return(RedirectToAction("PageContents"));
}
else
{
_log.Error("[CreatePageContent] ModelState not valid...");
return(View("CreatePageContent"));
}
}
public PageContentModel Insert(string userCurrent, PageContentModel pageContent)
{
try
{
var newPageContent = _mapper.Map <PageContent>(pageContent);
newPageContent.CreatedBy = userCurrent;
newPageContent.Slug = StringHelper.ToUrlFriendlyWithDate(newPageContent.Name);
_pageContentRepo.Insert(newPageContent);
return(pageContent);
}
catch
{
throw;
}
}
//
public static void convertPageContentToAddonList(CoreController core, PageContentModel page)
{
//
// -- save copyFilename copy to new Text Block record
string textBlockInstanceGuid = GenericController.getGUID();
core.cpParent.Db.ExecuteNonQuery("insert into dbText (active,name,text,ccguid) values (1,'Text Block'," + core.cpParent.Db.EncodeSQLText(page.copyfilename.content) + "," + core.cpParent.Db.EncodeSQLText(textBlockInstanceGuid) + ")");
//
// -- assign all child pages without a childpageListname to this new childpageList addon
string childListInstanceGuid = GenericController.getGUID();
core.cpParent.Db.ExecuteNonQuery("update ccpagecontent set parentListName=" + core.cpParent.Db.EncodeSQLText(childListInstanceGuid) + " where (parentId=" + page.id + ")and((parentListName='')or(parentListName is null))");
//
// -- set defaultAddonList.json into page.addonList
string addonList = Resources.defaultAddonListJson.replace("{textBlockInstanceGuid}", textBlockInstanceGuid, StringComparison.InvariantCulture).replace("{childListInstanceGuid}", childListInstanceGuid, StringComparison.InvariantCulture);
core.cpParent.Db.ExecuteNonQuery("update ccpagecontent set addonList=" + core.cpParent.Db.EncodeSQLText(addonList) + " where (id=" + page.id + ")");
}
/// <summary>
/// return the top-level root page of a page id
/// </summary>
/// <param name="cp"></param>
/// <param name="pageId"></param>
/// <returns></returns>
public int getRootPageId(CPBaseClass cp, int pageId, List <int> usedIdList)
{
if (usedIdList.Contains(pageId))
{
return(pageId);
}
var Page = PageContentModel.create(cp, pageId);
if (Page == null)
{
return(pageId);
}
if (Page.ParentID == 0)
{
return(pageId);
}
usedIdList.Add(pageId);
return(getRootPageId(cp, Page.ParentID, usedIdList));
}
public ActionResult DeletePage(int?id)
{
PageContentModel page = _pageContentEssenceManager.Get(id.Value);
var pageContent = new PageContentViewModel {
Id = page.Id,
Header = page.Header,
Url = page.Url,
IsPublished = page.IsPublished,
SeoID = page.SeoID,
Title = page.PageSeoModel.Title,
Descriptions = page.PageSeoModel.Descriptions,
KeyWords = page.PageSeoModel.KeyWords,
HtmlContent = page.HtmlContentModel.HtmlContent,
UniqueCode = page.HtmlContentModel.UniqueCode
};
return(View(pageContent));
}
public PageContentModel Update(string userCurrent, string pageId, PageContentModel pageContent)
{
try
{
var updatePageContent = _pageContentRepo.GetById(pageId);
_mapper.Map(pageContent, updatePageContent);
updatePageContent.LastUpdatedBy = userCurrent;
_pageContentRepo.Update(updatePageContent);
return(pageContent);
}
catch
{
throw;
}
}
public PageContentModel GetPlacePageContent(DynamicContentResponseModel dynamicContentResponseModel)
{
PageContentModel placePageContent = new PageContentModel();
string title = String.Empty;
string description = string.Empty;
if (dynamicContentResponseModel.ParentCategoryName == "See & Do")
{
title = DynamicContent.PlacePage.SeeAndDoCategory.Title;
description = DynamicContent.PlacePage.SeeAndDoCategory.Description;
}
else if (dynamicContentResponseModel.ParentCategoryName == "Eat & Drink")
{
title = DynamicContent.PlacePage.EatAndDrink.Title;
description = DynamicContent.PlacePage.EatAndDrink.Description;
}
else if (dynamicContentResponseModel.ParentCategoryName == "Shop Local")
{
title = DynamicContent.PlacePage.ShopLocal.Title;
description = DynamicContent.PlacePage.ShopLocal.Description;
}
else if (dynamicContentResponseModel.ParentCategoryName == "Experiences & Activities")
{
title = DynamicContent.PlacePage.ExperiencesAndActivities.Title;
description = DynamicContent.PlacePage.ExperiencesAndActivities.Description;
}
else if (dynamicContentResponseModel.ParentCategoryName == "Live Stream" || dynamicContentResponseModel.MasterEventTypeId == MasterEventType.Online)
{
title = DynamicContent.PlacePage.LiveStream.Title;
description = DynamicContent.PlacePage.LiveStream.Description;
}
title = title.Replace("placeName", dynamicContentResponseModel.PlaceName).Replace("cityName", dynamicContentResponseModel.CityName).Replace("countryName", dynamicContentResponseModel.CountryName);
description = description.Replace("placeName", dynamicContentResponseModel.PlaceName).Replace("cityName", dynamicContentResponseModel.CityName).Replace("countryName", dynamicContentResponseModel.CountryName);
placePageContent.Title = title;
placePageContent.Description = description;
return(placePageContent);
}
public PageContentModel Get(int?id)
{
using (EntitiesContext context = new EntitiesContext()) {
if (id == null)
{
return(null);
}
//var item = context.PageContentEssences.Include(x => x.PageSeo).Include(x => x.HtmlContent).FirstOrDefault(a => a.Id.Equals(id));
var item = context.PageContentEssences.Find(id);
if (item == null)
{
throw new ValidationException("Страница не найдена", "");
}
var pageContentModel = new PageContentModel {
Id = item.Id,
Header = item.Header,
Url = item.Url,
IsPublished = item.IsPublished,
SeoID = item.SeoID,
HtmlContentID = item.HtmlContentID,
HtmlContentModel = new HtmlContentModel {
Id = item.HtmlContent.Id,
HtmlContent = item.HtmlContent.HtmlContent,
UniqueCode = item.HtmlContent.UniqueCode
},
PageSeoModel = new PageSeoModel {
Id = item.PageSeo.Id,
Title = item.PageSeo.Title,
KeyWords = item.PageSeo.KeyWords,
Descriptions = item.PageSeo.Descriptions
}
};
return(pageContentModel);
}
}
public ActionResult EditPage(PageContentViewModel pageContent)
{
try {
if (ModelState.IsValid)
{
var htmlContentModel = new HtmlContentModel {
HtmlContent = pageContent.HtmlContent,
UniqueCode = System.Guid.NewGuid().ToString()
};
_htmlContentEssenceManager.SaveHtmlContent(htmlContentModel);
int htmlContentId = _htmlContentEssenceManager.GetId(htmlContentModel.UniqueCode);
var pageSeoModel = new PageSeoModel {
Id = pageContent.SeoID.Value,
Title = pageContent.Title,
KeyWords = pageContent.KeyWords,
Descriptions = pageContent.Descriptions
};
_pageSeoEssenceManager.EditSeo(pageSeoModel);
var pageContentModel = new PageContentModel {
Id = pageContent.Id,
Header = pageContent.Header,
Url = pageContent.Url,
IsPublished = false,
SeoID = pageSeoModel.Id,
HtmlContentID = htmlContentId
};
_pageContentEssenceManager.EditPage(pageContentModel);
return(RedirectToAction("ManagementPage"));
}
}
catch (ValidationException ex) {
ModelState.AddModelError(ex.Property, ex.Message);
}
return(View(pageContent));
}
public async Task <ActionResult <ResponseModel> > UpdatePageContent([FromBody] PageContentModel pageContent)
{
var model = new ResponseModel();
var result = await _dataContext.UpdatePageContent(pageContent);
if (!result.Status)
{
model.StatusCode = 404;
model.Message = result.Message;
}
else
{
model.StatusCode = 200;
var objPrankList = await _dataContext.GetPageContentByPram(string.Empty, 0).ToListAsync();
if (objPrankList != null)
{
model.ResponseObject = objPrankList;
}
}
return(model);
}
public static PageContentModel GetPageInnerContent(string htmlResources)
{
var model = new PageContentModel();
try {
HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(htmlResources);
HtmlNode rootnode = doc.DocumentNode;
string XPathString = "//div[@id='main-contbox']";
var pageBox = rootnode.SelectSingleNode(XPathString);
var select01 = pageBox.SelectSingleNode("div[@class='mc-content fl']").SelectSingleNode("div[@id='content']");
model.Title = select01.SelectSingleNode("h2").InnerText;
model.PreviewContent = select01.SelectSingleNode("h3").InnerText;
var contents = select01.SelectNodes("p");
uint index = 0;
model.ContentImage = new List <ContentImages>();
model.ContentString = new List <ContentStrings>();
model.ContentGif = new List <ContentGifs>();
model.ContentVideo = new List <ContentVideos>();
model.ContentFlash = new List <ContentFlashs>();
model.ContentSelfUri = new List <ContentSelfUris>();
foreach (var item in contents)
{
try {
index++;
if (item.SelectSingleNode("a") != null)
{
if (item.SelectSingleNode("a").SelectSingleNode("img") != null)
{
if (item.SelectSingleNode("script") == null)
{
model.ContentImage.Add(new ContentImages {
ImageSource = new Uri(item.SelectSingleNode("a").SelectSingleNode("img").Attributes["src"].Value),
Index = index
});
}
}
}
else if (item.SelectSingleNode("script") != null)
{
// do nothing
}
else
{
model.ContentString.Add(new ContentStrings {
Content = item.InnerText, Index = index
});
}
} catch (NullReferenceException) {
ReportException(GetUIString("ValidToShow"));
} catch (ArgumentOutOfRangeException ex) {
Debug.WriteLine(ex.StackTrace);
} catch (ArgumentNullException ex) {
Debug.WriteLine(ex.StackTrace);
} catch (FormatException ex) {
Debug.WriteLine(ex.StackTrace);
} catch (Exception ex) {
Debug.WriteLine(ex.StackTrace);
}
}
} catch (Exception ex) {
Debug.WriteLine(ex.StackTrace);
}
return(model);
}
