public PagePropertiesChangingEventArgs OnPagePropertiesChanging(UpdatingPagePropertiesModel beforeUpdate, UpdatingPagePropertiesModel afterUpdate)
{
var args = new PagePropertiesChangingEventArgs(beforeUpdate, afterUpdate);
if (PagePropertiesChanging != null)
{
PagePropertiesChanging(args);
}
return(args);
}
public void ShouldMapModelCorrectly()
{
var entity = TestDataProvider.CreateNewPageProperties();
entity.MasterPage = TestDataProvider.CreateNewPageProperties();
entity.PublishedOn = TestDataProvider.ProvideRandomDateTime();
entity.IsInSitemap = TestDataProvider.ProvideRandomBooleanValue();
var model = new UpdatingPagePropertiesModel(entity);
Assert.AreEqual(entity.Title, model.Title);
Assert.AreEqual(entity.PageUrl, model.PageUrl);
Assert.AreEqual(entity.PageUrlHash, model.PageUrlHash);
Assert.AreEqual(entity.Description, model.Description);
Assert.AreEqual(entity.CustomCss, model.CustomCss);
Assert.AreEqual(entity.CustomJS, model.CustomJS);
Assert.AreEqual(entity.MetaTitle, model.MetaTitle);
Assert.AreEqual(entity.MetaKeywords, model.MetaKeywords);
Assert.AreEqual(entity.MetaDescription, model.MetaDescription);
Assert.AreEqual(entity.Status, model.Status);
Assert.AreEqual(entity.PublishedOn, model.PublishedOn);
Assert.AreEqual(entity.HasSEO, model.HasSEO);
Assert.AreEqual(entity.UseCanonicalUrl, model.UseCanonicalUrl);
Assert.AreEqual(entity.UseNoFollow, model.UseNoFollow);
Assert.AreEqual(entity.UseNoIndex, model.UseNoIndex);
Assert.AreEqual(entity.IsMasterPage, model.IsMasterPage);
Assert.AreEqual(entity.IsArchived, model.IsArchived);
Assert.AreEqual(entity.IsInSitemap, model.IsInSitemap);
Assert.AreEqual(entity.Layout.Id, model.LayoutId);
Assert.AreEqual(entity.MasterPage.Id, model.MasterPageId);
foreach (var category in entity.Categories)
{
Assert.Contains(category.Id, model.Categories.ToArray());
}
Assert.AreEqual(entity.Image.Id, model.MainImageId);
Assert.AreEqual(entity.SecondaryImage.Id, model.SecondaryImageId);
Assert.AreEqual(entity.FeaturedImage.Id, model.FeaturedImageId);
}
public void ShouldMapModelCorrectly_WithNullReferences()
{
var entity = TestDataProvider.CreateNewPageProperties();
entity.Layout = null;
entity.MasterPage = null;
entity.Category = null;
entity.Image = null;
entity.SecondaryImage = null;
entity.FeaturedImage = null;
var model = new UpdatingPagePropertiesModel(entity);
Assert.IsNull(model.LayoutId);
Assert.IsNull(model.MasterPageId);
Assert.IsNull(model.CategoryId);
Assert.IsNull(model.MainImageId);
Assert.IsNull(model.SecondaryImageId);
Assert.IsNull(model.FeaturedImageId);
}
/// <summary>
/// Initializes a new instance of the <see cref="PagePropertiesChangingEventArgs" /> class.
/// </summary>
/// <param name="beforeUpdate">The old page.</param>
/// <param name="afterUpdate">The new page.</param>
public PagePropertiesChangingEventArgs(UpdatingPagePropertiesModel beforeUpdate, UpdatingPagePropertiesModel afterUpdate)
{
BeforeUpdate = beforeUpdate;
AfterUpdate = afterUpdate;
CancellationErrorMessages = new List <string>();
}
/// <summary>
/// Puts the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns><c>PutPageResponse</c> with created or updated item id.</returns>
public PutPagePropertiesResponse Put(PutPagePropertiesRequest request)
{
if (request.Data.IsMasterPage)
{
accessControlService.DemandAccess(securityService.GetCurrentPrincipal(), RootModuleConstants.UserRoles.Administration);
}
else
{
accessControlService.DemandAccess(securityService.GetCurrentPrincipal(), RootModuleConstants.UserRoles.EditContent);
}
PageProperties pageProperties = null;
var isNew = !request.Id.HasValue || request.Id.Value.HasDefaultValue();
if (!isNew)
{
pageProperties =
repository.AsQueryable <PageProperties>(e => e.Id == request.Id.GetValueOrDefault())
.FetchMany(p => p.Options)
.Fetch(p => p.Layout)
.ThenFetchMany(l => l.LayoutOptions)
.FetchMany(p => p.MasterPages)
.FetchMany(f => f.AccessRules)
.ToList()
.FirstOrDefault();
isNew = pageProperties == null;
}
UpdatingPagePropertiesModel beforeChange = null;
if (isNew)
{
pageProperties = new PageProperties
{
Id = request.Id.GetValueOrDefault(),
Status = PageStatus.Unpublished,
AccessRules = new List <AccessRule>()
};
}
else if (request.Data.Version > 0)
{
pageProperties.Version = request.Data.Version;
}
if (!isNew)
{
beforeChange = new UpdatingPagePropertiesModel(pageProperties);
}
if (!isNew && pageProperties.IsMasterPage != request.Data.IsMasterPage)
{
const string message = "IsMasterPage cannot be changed for updating page. It can be modified only when creating a page.";
var logMessage = string.Format("{0} PageId: {1}", message, request.Id);
throw new ValidationException(() => message, logMessage);
}
// Load master pages for updating page's master path and page's children master path
IList <Guid> newMasterIds;
IList <Guid> oldMasterIds;
IList <Guid> childrenPageIds;
IList <MasterPage> existingChildrenMasterPages;
masterPageService.PrepareForUpdateChildrenMasterPages(pageProperties, request.Data.MasterPageId, out newMasterIds, out oldMasterIds, out childrenPageIds, out existingChildrenMasterPages);
unitOfWork.BeginTransaction();
if (!string.IsNullOrEmpty(request.Data.PageUrl) || string.IsNullOrEmpty(pageProperties.PageUrl))
{
var pageUrl = request.Data.PageUrl;
if (string.IsNullOrEmpty(pageUrl) && !string.IsNullOrWhiteSpace(request.Data.Title))
{
pageUrl = pageService.CreatePagePermalink(request.Data.Title, null, null, request.Data.LanguageId, request.Data.CategoryId);
}
else
{
pageUrl = urlService.FixUrl(pageUrl);
pageService.ValidatePageUrl(pageUrl, request.Id);
}
pageProperties.PageUrl = pageUrl;
pageProperties.PageUrlHash = pageUrl.UrlHash();
}
pageProperties.Title = request.Data.Title;
pageProperties.Description = request.Data.Description;
var newStatus = request.Data.IsMasterPage || request.Data.IsPublished ? PageStatus.Published : PageStatus.Unpublished;
if (!request.Data.IsMasterPage && pageProperties.Status != newStatus)
{
accessControlService.DemandAccess(securityService.GetCurrentPrincipal(), RootModuleConstants.UserRoles.PublishContent);
}
pageProperties.Status = newStatus;
pageProperties.PublishedOn = request.Data.IsPublished && !request.Data.PublishedOn.HasValue ? DateTime.Now : request.Data.PublishedOn;
masterPageService.SetMasterOrLayout(pageProperties, request.Data.MasterPageId, request.Data.LayoutId);
pageProperties.Category = request.Data.CategoryId.HasValue
? repository.AsProxy <Category>(request.Data.CategoryId.Value)
: null;
pageProperties.IsArchived = request.Data.IsArchived;
pageProperties.IsMasterPage = request.Data.IsMasterPage;
pageProperties.LanguageGroupIdentifier = request.Data.LanguageGroupIdentifier;
pageProperties.Language = request.Data.LanguageId.HasValue && !request.Data.LanguageId.Value.HasDefaultValue()
? repository.AsProxy <Language>(request.Data.LanguageId.Value)
: null;
pageProperties.Image = request.Data.MainImageId.HasValue
? repository.AsProxy <MediaImage>(request.Data.MainImageId.Value)
: null;
pageProperties.FeaturedImage = request.Data.FeaturedImageId.HasValue
? repository.AsProxy <MediaImage>(request.Data.FeaturedImageId.Value)
: null;
pageProperties.SecondaryImage = request.Data.SecondaryImageId.HasValue
? repository.AsProxy <MediaImage>(request.Data.SecondaryImageId.Value)
: null;
pageProperties.CustomCss = request.Data.CustomCss;
pageProperties.CustomJS = request.Data.CustomJavaScript;
pageProperties.UseCanonicalUrl = request.Data.UseCanonicalUrl;
pageProperties.UseNoFollow = request.Data.UseNoFollow;
pageProperties.UseNoIndex = request.Data.UseNoIndex;
if (request.Data.MetaData != null)
{
pageProperties.MetaTitle = request.Data.MetaData.MetaTitle;
pageProperties.MetaDescription = request.Data.MetaData.MetaDescription;
pageProperties.MetaKeywords = request.Data.MetaData.MetaKeywords;
}
IList <Tag> newTags = null;
if (request.Data.Tags != null)
{
tagService.SavePageTags(pageProperties, request.Data.Tags, out newTags);
}
if (request.Data.AccessRules != null)
{
pageProperties.AccessRules.RemoveDuplicateEntities();
var accessRules =
request.Data.AccessRules.Select(
r => (IAccessRule) new AccessRule {
AccessLevel = (Core.Security.AccessLevel)(int) r.AccessLevel, Identity = r.Identity, IsForRole = r.IsForRole
})
.ToList();
accessControlService.UpdateAccessControl(pageProperties, accessRules);
}
if (request.Data.PageOptions != null)
{
var options = request.Data.PageOptions.ToServiceModel();
var pageOptions = pageProperties.Options != null?pageProperties.Options.Distinct() : null;
pageProperties.Options = optionService.SaveOptionValues(options, pageOptions, () => new PageOption {
Page = pageProperties
});
}
if (!isNew)
{
// Notify about page properties changing.
var cancelEventArgs = Events.PageEvents.Instance.OnPagePropertiesChanging(beforeChange, new UpdatingPagePropertiesModel(pageProperties));
if (cancelEventArgs.Cancel)
{
throw new CmsApiValidationException(
cancelEventArgs.CancellationErrorMessages != null && cancelEventArgs.CancellationErrorMessages.Count > 0
? string.Join(",", cancelEventArgs.CancellationErrorMessages)
: "Page properties saving was canceled.");
}
}
repository.Save(pageProperties);
//
// If creating new page, page id is unknown when children pages are loaded, so Guid may be empty
// Updating id to saved page's Id manually
//
if (isNew && childrenPageIds != null && childrenPageIds.Count == 1 && childrenPageIds[0].HasDefaultValue())
{
childrenPageIds[0] = pageProperties.Id;
}
masterPageService.UpdateChildrenMasterPages(existingChildrenMasterPages, oldMasterIds, newMasterIds, childrenPageIds);
unitOfWork.Commit();
// Fire events.
Events.RootEvents.Instance.OnTagCreated(newTags);
if (isNew)
{
Events.PageEvents.Instance.OnPageCreated(pageProperties);
}
else
{
Events.PageEvents.Instance.OnPagePropertiesChanged(pageProperties);
}
return(new PutPagePropertiesResponse {
Data = pageProperties.Id
});
}
/// <summary>
/// Executes the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Save response.</returns>
/// <exception cref="CmsException">Failed to save page properties.</exception>
public SavePageResponse Execute(EditPagePropertiesViewModel request)
{
var isMultilanguageEnabled = cmsConfiguration.EnableMultilanguage;
ValidateRequest(request, isMultilanguageEnabled);
var pageQuery =
Repository.AsQueryable <PageProperties>(p => p.Id == request.Id)
.FetchMany(p => p.Options)
.Fetch(p => p.Layout)
.ThenFetchMany(l => l.LayoutOptions)
.FetchMany(p => p.MasterPages)
.AsQueryable();
if (cmsConfiguration.Security.AccessControlEnabled)
{
pageQuery = pageQuery.FetchMany(f => f.AccessRules);
}
var page = pageQuery.ToList().FirstOne();
var beforeChange = new UpdatingPagePropertiesModel(page);
var roles = page.IsMasterPage
? new[]
{
RootModuleConstants.UserRoles.EditContent, RootModuleConstants.UserRoles.PublishContent, RootModuleConstants.UserRoles.Administration
}
: new[] { RootModuleConstants.UserRoles.EditContent, RootModuleConstants.UserRoles.PublishContent };
if (cmsConfiguration.Security.AccessControlEnabled)
{
AccessControlService.DemandAccess(page, Context.Principal, AccessLevel.ReadWrite, roles);
}
else
{
AccessControlService.DemandAccess(Context.Principal, roles);
}
var canEdit = page.IsMasterPage
? SecurityService.IsAuthorized(
Context.Principal,
RootModuleConstants.UserRoles.MultipleRoles(RootModuleConstants.UserRoles.EditContent, RootModuleConstants.UserRoles.Administration))
: SecurityService.IsAuthorized(Context.Principal, RootModuleConstants.UserRoles.EditContent);
IList <PageProperties> translations = null;
if (canEdit && isMultilanguageEnabled && !page.IsMasterPage)
{
translations = LoadAndValidateTranslations(page, request);
}
// Load master pages for updating page's master path and page's children master path
IList <Guid> newMasterIds;
IList <Guid> oldMasterIds;
IList <Guid> childrenPageIds;
IList <MasterPage> existingChildrenMasterPages;
masterPageService.PrepareForUpdateChildrenMasterPages(page, request.MasterPageId, out newMasterIds, out oldMasterIds, out childrenPageIds, out existingChildrenMasterPages);
IList <SitemapNode> updatedNodes = null;
// Start transaction, only when everything is already loaded
UnitOfWork.BeginTransaction();
Models.Redirect redirectCreated = null;
var initialSeoStatus = page.HasSEO;
request.PageUrl = urlService.FixUrl(request.PageUrl);
if (canEdit && !string.Equals(page.PageUrl, request.PageUrl))
{
pageService.ValidatePageUrl(request.PageUrl, request.Id);
if (request.RedirectFromOldUrl)
{
var redirect = redirectService.CreateRedirectEntity(page.PageUrl, request.PageUrl);
if (redirect != null)
{
Repository.Save(redirect);
redirectCreated = redirect;
}
}
if (request.UpdateSitemap)
{
updatedNodes = sitemapService.ChangeUrlsInAllSitemapsNodes(page.PageUrl, request.PageUrl);
}
page.PageUrl = request.PageUrl;
}
List <PageProperties> updatePageTranslations = null;
if (canEdit)
{
page.PageUrlHash = page.PageUrl.UrlHash();
page.ForceAccessProtocol = request.ForceAccessProtocol;
categoryService.CombineEntityCategories <PageProperties, PageCategory>(page, request.Categories);
page.Title = request.PageName;
page.CustomCss = request.PageCSS;
page.CustomJS = request.PageJavascript;
masterPageService.SetMasterOrLayout(page, request.MasterPageId, request.TemplateId);
if (isMultilanguageEnabled && !page.IsMasterPage)
{
updatePageTranslations = UpdatePageTranslations(page, translations, request);
}
}
var publishDraftContent = false;
if (request.CanPublishPage && !page.IsMasterPage)
{
AccessControlService.DemandAccess(Context.Principal, RootModuleConstants.UserRoles.PublishContent);
if (request.IsPagePublished)
{
if (page.Status != PageStatus.Published)
{
page.Status = PageStatus.Published;
page.PublishedOn = DateTime.Now;
publishDraftContent = true;
}
}
else
{
page.Status = PageStatus.Unpublished;
}
}
IList <PageOption> pageOptions = page.Options.Distinct().ToList();
if (canEdit)
{
if (!page.IsMasterPage)
{
page.UseNoFollow = request.UseNoFollow;
page.UseNoIndex = request.UseNoIndex;
page.IsArchived = request.IsArchived;
}
page.UseCanonicalUrl = request.UseCanonicalUrl;
page.Version = request.Version;
page.Image = request.Image != null && request.Image.ImageId.HasValue ? Repository.AsProxy <MediaImage>(request.Image.ImageId.Value) : null;
page.SecondaryImage = request.SecondaryImage != null && request.SecondaryImage.ImageId.HasValue
? Repository.AsProxy <MediaImage>(request.SecondaryImage.ImageId.Value)
: null;
page.FeaturedImage = request.FeaturedImage != null && request.FeaturedImage.ImageId.HasValue
? Repository.AsProxy <MediaImage>(request.FeaturedImage.ImageId.Value)
: null;
pageOptions = optionService.SaveOptionValues(request.OptionValues, pageOptions, () => new PageOption {
Page = page
});
if (cmsConfiguration.Security.AccessControlEnabled)
{
page.AccessRules.RemoveDuplicateEntities();
var accessRules = request.UserAccessList != null?request.UserAccessList.Cast <IAccessRule>().ToList() : null;
accessControlService.UpdateAccessControl(page, accessRules);
}
}
// Notify about page properties changing.
var cancelEventArgs = Events.PageEvents.Instance.OnPagePropertiesChanging(beforeChange, new UpdatingPagePropertiesModel(page));
if (cancelEventArgs.Cancel)
{
Context.Messages.AddError(cancelEventArgs.CancellationErrorMessages.ToArray());
return(null);
}
Repository.Save(page);
IList <Tag> newTags = null;
if (canEdit)
{
masterPageService.UpdateChildrenMasterPages(existingChildrenMasterPages, oldMasterIds, newMasterIds, childrenPageIds);
tagService.SavePageTags(page, request.Tags, out newTags);
}
if (publishDraftContent)
{
contentService.PublishDraftContent(page.Id);
}
UnitOfWork.Commit();
// Notify about page properties change.
page.Options = pageOptions;
Events.PageEvents.Instance.OnPagePropertiesChanged(page);
// Notify about translation properties changed
if (updatePageTranslations != null)
{
updatePageTranslations.ForEach(Events.PageEvents.Instance.OnPagePropertiesChanged);
}
// Notify about redirect creation.
if (redirectCreated != null)
{
Events.PageEvents.Instance.OnRedirectCreated(redirectCreated);
}
// Notify about SEO status change.
if (initialSeoStatus != page.HasSEO)
{
Events.PageEvents.Instance.OnPageSeoStatusChanged(page);
}
// Notify about new tags.
Events.RootEvents.Instance.OnTagCreated(newTags);
// Notify about updated sitemap nodes.
if (updatedNodes != null)
{
var updatedSitemaps = new List <Models.Sitemap>();
foreach (var node in updatedNodes)
{
Events.SitemapEvents.Instance.OnSitemapNodeUpdated(node);
if (!updatedSitemaps.Contains(node.Sitemap))
{
updatedSitemaps.Add(node.Sitemap);
}
}
foreach (var updatedSitemap in updatedSitemaps)
{
Events.SitemapEvents.Instance.OnSitemapUpdated(updatedSitemap);
}
}
return(new SavePageResponse(page));
}
/// <summary>
/// Saves SEO information.
/// </summary>
/// <param name="model">The SEO information model.</param>
/// <returns>
/// true if SEO information saved successfully; false otherwise.
/// </returns>
public virtual EditSeoViewModel Execute(EditSeoViewModel model)
{
var pageQuery =
Repository.AsQueryable <PageProperties>(p => p.Id == model.PageId)
.FetchMany(p => p.Options)
.Fetch(p => p.Layout)
.ThenFetchMany(l => l.LayoutOptions)
.FetchMany(p => p.MasterPages)
.AsQueryable();
if (cmsConfiguration.Security.AccessControlEnabled)
{
pageQuery = pageQuery.FetchMany(f => f.AccessRules);
}
var page = pageQuery.ToList().FirstOne();
var beforeChange = new UpdatingPagePropertiesModel(page);
var roles = new[] { RootModuleConstants.UserRoles.EditContent };
if (cmsConfiguration.Security.AccessControlEnabled)
{
AccessControlService.DemandAccess(page, Context.Principal, AccessLevel.ReadWrite, roles);
}
else
{
AccessControlService.DemandAccess(Context.Principal, roles);
}
bool initialHasSeo = page.HasSEO;
Models.Redirect newRedirect = null;
page.Version = model.Version;
page.Title = model.PageTitle;
model.ChangedUrlPath = urlService.FixUrl(model.ChangedUrlPath);
IList <SitemapNode> updatedNodes = null;
if (!string.Equals(model.PageUrlPath, model.ChangedUrlPath))
{
pageService.ValidatePageUrl(model.ChangedUrlPath, model.PageId);
if (model.CreatePermanentRedirect)
{
var redirect = redirectService.CreateRedirectEntity(model.PageUrlPath, model.ChangedUrlPath);
if (redirect != null)
{
Repository.Save(redirect);
newRedirect = redirect;
}
}
if (model.UpdateSitemap)
{
updatedNodes = sitemapService.ChangeUrlsInAllSitemapsNodes(page.PageUrl, model.ChangedUrlPath);
}
page.PageUrl = model.ChangedUrlPath;
}
page.PageUrlHash = page.PageUrl.UrlHash();
page.MetaTitle = model.MetaTitle;
page.MetaKeywords = model.MetaKeywords;
page.MetaDescription = model.MetaDescription;
page.UseCanonicalUrl = model.UseCanonicalUrl;
// Notify about page properties changing.
var cancelEventArgs = Events.PageEvents.Instance.OnPagePropertiesChanging(beforeChange, new UpdatingPagePropertiesModel(page));
if (cancelEventArgs.Cancel)
{
Context.Messages.AddError(cancelEventArgs.CancellationErrorMessages.ToArray());
return(null);
}
Repository.Save(page);
UnitOfWork.Commit();
Events.PageEvents.Instance.OnPagePropertiesChanged(page);
// Notify about SEO change.
if (page.HasSEO != initialHasSeo)
{
Events.PageEvents.Instance.OnPageSeoStatusChanged(page);
}
// Notify about new redirect creation.
if (newRedirect != null)
{
Events.PageEvents.Instance.OnRedirectCreated(newRedirect);
}
// Notify about updated sitemap nodes.
if (updatedNodes != null)
{
var updatedSitemaps = new List <Models.Sitemap>();
foreach (var node in updatedNodes)
{
Events.SitemapEvents.Instance.OnSitemapNodeUpdated(node);
if (!updatedSitemaps.Contains(node.Sitemap))
{
updatedSitemaps.Add(node.Sitemap);
}
}
foreach (var updatedSitemap in updatedSitemaps)
{
Events.SitemapEvents.Instance.OnSitemapUpdated(updatedSitemap);
}
}
return(new EditSeoViewModel {
PageUrlPath = page.PageUrl
});
}