public Root.Models.Content DestroyDraftContent(Guid contentId, int version, IPrincipal principal)
{
var contentQuery = repository
.AsQueryable <Root.Models.Content>(p => p.Id == contentId)
.Fetch(f => f.Original).AsQueryable();
if (cmsConfiguration.Security.AccessControlEnabled)
{
contentQuery = contentQuery.FetchMany(f => f.PageContents).ThenFetch(f => f.Page).ThenFetchMany(f => f.AccessRules).AsQueryable();
}
var content = contentQuery.ToList().FirstOne();
// Throw concurrent data exception (user needs to reload page):
// - content may be null, if looking for already deleted draft
// - content may be changed, if looking for
if (version > 0 && version != content.Version)
{
throw new ConcurrentDataException(content);
}
var pageContents = content.PageContents;
// If content is published, try to get it's active draft
if (content.Status == ContentStatus.Published)
{
content = repository
.AsQueryable <Root.Models.Content>(p => p.Original == content)
.Where(c => c.Status == ContentStatus.Draft && !c.IsDeleted)
.Fetch(f => f.Original)
.FirstOrDefault();
if (content == null)
{
// Throw concurrent data exception (user needs to reload page):
// - content may be null, if looking for already deleted draft
throw new DraftNotFoundException(new Root.Models.Content());
}
}
if (content.Status != ContentStatus.Draft)
{
throw new CmsException(string.Format("Only draft version can be destroyed. Id: {0}, Status: {1}", content.Id, content.Status));
}
if (content.Original == null)
{
throw new CmsException(string.Format("Draft version cannot be destroyed - it has no published original version. Id: {0}, Status: {1}", content.Id, content.Status));
}
var contentType = content.GetType();
if (contentType == typeof(HtmlContentWidget) || contentType == typeof(ServerControlWidget))
{
accessControlService.DemandAccess(principal, RootModuleConstants.UserRoles.Administration);
}
else
{
bool checkedAccess = false;
if (content is HtmlContent)
{
var pageContent = pageContents.FirstOrDefault();
if (pageContent != null && pageContent.Page != null)
{
checkedAccess = true;
accessControlService.DemandAccess(pageContent.Page, principal, AccessLevel.ReadWrite, RootModuleConstants.UserRoles.EditContent);
}
}
if (!checkedAccess)
{
accessControlService.DemandAccess(principal, RootModuleConstants.UserRoles.EditContent);
}
}
repository.Delete(content);
unitOfWork.Commit();
Events.PageEvents.Instance.OnContentDraftDestroyed(content.Original);
return(content);
}
/// <summary>
/// Saves the blog post.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="childContentOptionValues">The child content option values.</param>
/// <param name="principal">The principal.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns>
/// Saved blog post entity
/// </returns>
/// <exception cref="System.ComponentModel.DataAnnotations.ValidationException"></exception>
/// <exception cref="SecurityException">Forbidden: Access is denied.</exception>
public BlogPost SaveBlogPost(BlogPostViewModel request, IList <ContentOptionValuesViewModel> childContentOptionValues, IPrincipal principal, out string[] errorMessages)
{
errorMessages = new string[0];
string[] roles;
if (request.DesirableStatus == ContentStatus.Published)
{
accessControlService.DemandAccess(principal, RootModuleConstants.UserRoles.PublishContent);
roles = new[] { RootModuleConstants.UserRoles.PublishContent };
}
else
{
accessControlService.DemandAccess(principal, RootModuleConstants.UserRoles.EditContent);
roles = new[] { RootModuleConstants.UserRoles.EditContent };
}
var isNew = request.Id.HasDefaultValue();
var userCanEdit = securityService.IsAuthorized(RootModuleConstants.UserRoles.EditContent);
ValidateData(isNew, request);
BlogPost blogPost;
BlogPostContent content;
PageContent pageContent;
GetBlogPostAndContentEntities(request, principal, roles, ref isNew, out content, out pageContent, out blogPost);
var beforeChange = new UpdatingBlogModel(blogPost);
// Master page / layout
Layout layout;
Page masterPage;
Region region;
LoadDefaultLayoutAndRegion(out layout, out masterPage, out region);
if (masterPage != null)
{
var level = accessControlService.GetAccessLevel(masterPage, principal);
if (level < AccessLevel.Read)
{
var message = BlogGlobalization.SaveBlogPost_FailedToSave_InaccessibleMasterPage;
const string logMessage = "Failed to save blog post. Selected master page for page layout is inaccessible.";
throw new ValidationException(() => message, logMessage);
}
}
if (pageContent.Region == null)
{
pageContent.Region = region;
}
// 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;
PrepareForUpdateChildrenMasterPages(isNew, blogPost, request, out newMasterIds, out oldMasterIds, out childrenPageIds, out existingChildrenMasterPages);
// TODO: TEST AND TRY TO FIX IT: TRANSACTION HERE IS REQUIRED!
// UnitOfWork.BeginTransaction(); // NOTE: this causes concurrent data exception.
Redirect redirectCreated = null;
if (!isNew && userCanEdit && !string.Equals(blogPost.PageUrl, request.BlogUrl) && !string.IsNullOrWhiteSpace(request.BlogUrl))
{
request.BlogUrl = urlService.FixUrl(request.BlogUrl);
pageService.ValidatePageUrl(request.BlogUrl, request.Id);
if (request.RedirectFromOldUrl)
{
var redirect = redirectService.CreateRedirectEntity(blogPost.PageUrl, request.BlogUrl);
if (redirect != null)
{
repository.Save(redirect);
redirectCreated = redirect;
}
}
blogPost.PageUrl = urlService.FixUrl(request.BlogUrl);
}
// Push to change modified data each time.
blogPost.ModifiedOn = DateTime.Now;
if (userCanEdit)
{
blogPost.Title = request.Title;
blogPost.Description = request.IntroText;
blogPost.Author = request.AuthorId.HasValue ? repository.AsProxy <Author>(request.AuthorId.Value) : null;
blogPost.Category = request.CategoryId.HasValue ? repository.AsProxy <Category>(request.CategoryId.Value) : null;
blogPost.Image = (request.Image != null && request.Image.ImageId.HasValue) ? repository.AsProxy <MediaImage>(request.Image.ImageId.Value) : null;
if (isNew || request.DesirableStatus == ContentStatus.Published)
{
blogPost.ActivationDate = request.LiveFromDate;
blogPost.ExpirationDate = TimeHelper.FormatEndDate(request.LiveToDate);
}
}
if (isNew)
{
if (!string.IsNullOrWhiteSpace(request.BlogUrl))
{
blogPost.PageUrl = urlService.FixUrl(request.BlogUrl);
pageService.ValidatePageUrl(blogPost.PageUrl);
}
else
{
blogPost.PageUrl = CreateBlogPermalink(request.Title, null, blogPost.Category != null ? (Guid?)blogPost.Category.Id : null);
}
blogPost.MetaTitle = request.MetaTitle ?? request.Title;
if (masterPage != null)
{
blogPost.MasterPage = masterPage;
masterPageService.SetPageMasterPages(blogPost, masterPage.Id);
}
else
{
blogPost.Layout = layout;
}
UpdateStatus(blogPost, request.DesirableStatus);
AddDefaultAccessRules(blogPost, principal, masterPage);
}
else if (request.DesirableStatus == ContentStatus.Published ||
blogPost.Status == PageStatus.Preview)
{
// Update only if publishing or current status is preview.
// Else do not change, because it may change from published to draft status
UpdateStatus(blogPost, request.DesirableStatus);
}
// Create content.
var newContent = new BlogPostContent
{
Id = content != null ? content.Id : Guid.Empty,
Name = request.Title,
Html = request.Content ?? string.Empty,
EditInSourceMode = request.EditInSourceMode,
ActivationDate = request.LiveFromDate,
ExpirationDate = TimeHelper.FormatEndDate(request.LiveToDate)
};
// Preserve content if user is not authorized to change it.
if (!userCanEdit)
{
if (content == null)
{
throw new SecurityException("Forbidden: Access is denied."); // User has no rights to create new content.
}
var contentToPublish = (BlogPostContent)(content.History != null
? content.History.FirstOrDefault(c => c.Status == ContentStatus.Draft) ?? content
: content);
newContent.Name = contentToPublish.Name;
newContent.Html = contentToPublish.Html;
}
content = SaveContentWithStatusUpdate(isNew, newContent, request, principal);
pageContent.Content = content;
optionService.SaveChildContentOptions(content, childContentOptionValues, request.DesirableStatus);
blogPost.PageUrlHash = blogPost.PageUrl.UrlHash();
blogPost.UseCanonicalUrl = request.UseCanonicalUrl;
MapExtraProperties(isNew, blogPost, content, pageContent, request, principal);
// Notify about page properties changing.
var cancelEventArgs = Events.BlogEvents.Instance.OnBlogChanging(beforeChange, new UpdatingBlogModel(blogPost));
if (cancelEventArgs.Cancel)
{
errorMessages = cancelEventArgs.CancellationErrorMessages.ToArray();
return(null);
}
repository.Save(blogPost);
repository.Save(content);
repository.Save(pageContent);
masterPageService.UpdateChildrenMasterPages(existingChildrenMasterPages, oldMasterIds, newMasterIds, childrenPageIds);
pageContent.Content = content;
blogPost.PageContents = new [] { pageContent };
IList <Tag> newTags = null;
if (userCanEdit)
{
newTags = SaveTags(blogPost, request);
}
// Commit
unitOfWork.Commit();
// Notify about new created tags.
Events.RootEvents.Instance.OnTagCreated(newTags);
// Notify about new or updated blog post.
if (isNew)
{
Events.BlogEvents.Instance.OnBlogCreated(blogPost);
}
else
{
Events.BlogEvents.Instance.OnBlogUpdated(blogPost);
}
// Notify about redirect creation.
if (redirectCreated != null)
{
Events.PageEvents.Instance.OnRedirectCreated(redirectCreated);
}
return(blogPost);
}
/// <summary>
/// Deletes the page.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="principal">The principal.</param>
/// <param name="messages">The messages.</param>
/// <returns>
/// Delete result
/// </returns>
/// <exception cref="ConcurrentDataException"></exception>
/// <exception cref="System.ComponentModel.DataAnnotations.ValidationException">
/// </exception>
public bool DeletePage(DeletePageViewModel model, IPrincipal principal, IMessagesIndicator messages = null)
{
var languagesFuture = repository.AsQueryable<Language>().ToFuture();
var page =
repository.AsQueryable<PageProperties>(p => p.Id == model.PageId)
.FetchMany(p => p.PageContents)
.ThenFetch(pc => pc.Content)
.ToFuture()
.ToList()
.FirstOne();
// Unidentified problem where in some cases proxy is returned.
if (page is INHibernateProxy)
{
page = repository.UnProxy(page);
}
if (model.Version > 0 && page.Version != model.Version)
{
throw new ConcurrentDataException(page);
}
if (page.IsMasterPage && repository.AsQueryable<MasterPage>(mp => mp.Master == page).Any())
{
var message = PagesGlobalization.DeletePageCommand_MasterPageHasChildren_Message;
var logMessage = string.Format("Failed to delete page. Page is selected as master page. Id: {0} Url: {1}", page.Id, page.PageUrl);
throw new ValidationException(() => message, logMessage);
}
var isRedirectInternal = false;
if (!string.IsNullOrWhiteSpace(model.RedirectUrl))
{
isRedirectInternal = urlService.ValidateInternalUrl(model.RedirectUrl);
if (!isRedirectInternal && urlService.ValidateInternalUrl(urlService.FixUrl(model.RedirectUrl)))
{
isRedirectInternal = true;
}
if (isRedirectInternal)
{
model.RedirectUrl = urlService.FixUrl(model.RedirectUrl);
}
}
if (model.UpdateSitemap)
{
accessControlService.DemandAccess(principal, RootModuleConstants.UserRoles.EditContent);
}
var sitemaps = new Dictionary<Sitemap, bool>();
var sitemapNodes = sitemapService.GetNodesByPage(page);
if (model.UpdateSitemap)
{
sitemapNodes.Select(node => node.Sitemap)
.Distinct()
.ToList()
.ForEach(
sitemap =>
sitemaps.Add(
sitemap,
!cmsConfiguration.Security.AccessControlEnabled || accessControlService.GetAccessLevel(sitemap, principal) == AccessLevel.ReadWrite));
foreach (var node in sitemapNodes)
{
if (sitemaps[node.Sitemap] && node.ChildNodes.Count > 0)
{
var logMessage = string.Format("In {0} sitemap node {1} has {2} child nodes.", node.Sitemap.Id, node.Id, node.ChildNodes.Count);
throw new ValidationException(() => PagesGlobalization.DeletePageCommand_SitemapNodeHasChildNodes_Message, logMessage);
}
}
}
unitOfWork.BeginTransaction();
// Update sitemap nodes
IList<SitemapNode> updatedNodes = new List<SitemapNode>();
IList<SitemapNode> deletedNodes = new List<SitemapNode>();
UpdateSitemapNodes(model, page, sitemapNodes, sitemaps, languagesFuture.ToList(), updatedNodes, deletedNodes);
Redirect redirect;
if (!string.IsNullOrWhiteSpace(model.RedirectUrl))
{
if (string.Equals(page.PageUrl, model.RedirectUrl, StringComparison.OrdinalIgnoreCase))
{
var logMessage = string.Format("Circular redirect loop from url {0} to url {0}.", model.RedirectUrl);
throw new ValidationException(() => PagesGlobalization.ValidatePageUrlCommand_SameUrlPath_Message, logMessage);
}
// Validate url
if (!urlService.ValidateExternalUrl(model.RedirectUrl))
{
var logMessage = string.Format("Invalid redirect url {0}.", model.RedirectUrl);
throw new ValidationException(() => PagesGlobalization.ValidatePageUrlCommand_InvalidUrlPath_Message, logMessage);
}
string patternsValidationMessage;
if (isRedirectInternal
&& !urlService.ValidateUrlPatterns(model.RedirectUrl, out patternsValidationMessage, PagesGlobalization.DeletePage_RedirectUrl_Name))
{
var logMessage = string.Format("{0}. URL: {1}.", patternsValidationMessage, model.RedirectUrl);
throw new ValidationException(() => patternsValidationMessage, logMessage);
}
redirect = redirectService.GetPageRedirect(page.PageUrl);
if (redirect != null)
{
redirect.RedirectUrl = model.RedirectUrl;
}
else
{
redirect = redirectService.CreateRedirectEntity(page.PageUrl, model.RedirectUrl);
}
if (redirect != null)
{
repository.Save(redirect);
}
}
else
{
redirect = null;
}
// Delete child entities.
if (page.PageTags != null)
{
foreach (var pageTag in page.PageTags)
{
repository.Delete(pageTag);
}
}
var deletedPageContents = new List<PageContent>();
var htmlContentsToDelete = new List<HtmlContent>();
if (page.PageContents != null)
{
foreach (var pageContent in page.PageContents)
{
// If content is HTML content, delete HTML content
var htmlContent = pageContent.Content as HtmlContent;
if (htmlContent != null)
{
var draft = pageContent.Content.History != null ? pageContent.Content.History.FirstOrDefault(c => c.Status == ContentStatus.Draft) : null;
if (draft != null)
{
repository.Delete(draft);
}
repository.Delete(htmlContent);
htmlContentsToDelete.Add(htmlContent);
}
repository.Delete(pageContent);
deletedPageContents.Add(pageContent);
}
}
if (page.Options != null)
{
foreach (var option in page.Options)
{
repository.Delete(option);
}
}
if (page.AccessRules != null)
{
var rules = page.AccessRules.ToList();
rules.ForEach(page.RemoveRule);
}
if (page.MasterPages != null)
{
foreach (var master in page.MasterPages)
{
repository.Delete(master);
}
}
// Delete page
repository.Delete<Root.Models.Page>(page);
// Commit
unitOfWork.Commit();
var updatedSitemaps = new List<Sitemap>();
foreach (var node in updatedNodes)
{
Events.SitemapEvents.Instance.OnSitemapNodeUpdated(node);
if (!updatedSitemaps.Contains(node.Sitemap))
{
updatedSitemaps.Add(node.Sitemap);
}
}
foreach (var node in deletedNodes)
{
Events.SitemapEvents.Instance.OnSitemapNodeDeleted(node);
if (!updatedSitemaps.Contains(node.Sitemap))
{
updatedSitemaps.Add(node.Sitemap);
}
}
foreach (var updatedSitemap in updatedSitemaps)
{
Events.SitemapEvents.Instance.OnSitemapUpdated(updatedSitemap);
}
// Notifying about redirect created
if (redirect != null)
{
Events.PageEvents.Instance.OnRedirectCreated(redirect);
}
// Notify about deleted page contents
foreach (var deletedPageContent in deletedPageContents)
{
Events.PageEvents.Instance.OnPageContentDeleted(deletedPageContent);
}
// Notify about deleted html contents
foreach (var htmlContent in htmlContentsToDelete)
{
Events.PageEvents.Instance.OnHtmlContentDeleted(htmlContent);
}
// Notifying, that page is deleted.
Events.PageEvents.Instance.OnPageDeleted(page);
if (sitemaps.Any(tuple => !tuple.Value) && messages != null)
{
// Some sitemaps where skipped, because user has no permission to edit.
messages.AddSuccess(PagesGlobalization.DeletePage_SitemapSkipped_Message);
}
return true;
}
/// <summary>
/// Puts the sitemap specified in request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// <c>PutSitemapsResponse</c> with updated sitemap data.
/// </returns>
public PutSitemapResponse Put(PutSitemapRequest request)
{
IEnumerable <SitemapNode> nodesFuture = null;
if (request.Data.Nodes != null)
{
nodesFuture =
repository.AsQueryable <SitemapNode>()
.Where(node => node.Sitemap.Id == request.Id && !node.IsDeleted)
.FetchMany(node => node.Translations)
.ToFuture();
}
var sitemap =
repository.AsQueryable <Module.Pages.Models.Sitemap>(e => e.Id == request.Id.GetValueOrDefault())
.FetchMany(f => f.AccessRules)
.ToFuture()
.ToList()
.FirstOrDefault();
var isNew = sitemap == null;
if (isNew)
{
sitemap = new Module.Pages.Models.Sitemap {
Id = request.Id.GetValueOrDefault(), AccessRules = new List <AccessRule>()
};
}
else if (request.Data.Version > 0)
{
sitemap.Version = request.Data.Version;
}
if (cmsConfiguration.Security.AccessControlEnabled)
{
accessControlService.DemandAccess(sitemap, securityService.GetCurrentPrincipal(), AccessLevel.ReadWrite);
}
unitOfWork.BeginTransaction();
if (!isNew)
{
sitemapService.ArchiveSitemap(sitemap.Id);
}
sitemap.Title = request.Data.Title;
IList <Tag> newTags = null;
if (request.Data.Tags != null)
{
tagService.SaveTags(sitemap, request.Data.Tags, out newTags);
}
if (request.Data.AccessRules != null)
{
sitemap.AccessRules.RemoveDuplicateEntities();
var accessRules =
request.Data.AccessRules.Select(
r => (IAccessRule) new AccessRule {
AccessLevel = (AccessLevel)(int)r.AccessLevel, Identity = r.Identity, IsForRole = r.IsForRole
})
.ToList();
accessControlService.UpdateAccessControl(sitemap, accessRules);
}
repository.Save(sitemap);
var createdNodes = (IList <SitemapNode>) new List <SitemapNode>();
var updatedNodes = (IList <SitemapNode>) new List <SitemapNode>();
var deletedNodes = (IList <SitemapNode>) new List <SitemapNode>();
if (request.Data.Nodes != null)
{
SaveNodes(sitemap, request.Data.Nodes, nodesFuture != null ? nodesFuture.ToList() : new List <SitemapNode>(), ref createdNodes, ref updatedNodes, ref deletedNodes);
}
unitOfWork.Commit();
// Fire events.
Events.RootEvents.Instance.OnTagCreated(newTags);
foreach (var node in createdNodes)
{
Events.SitemapEvents.Instance.OnSitemapNodeCreated(node);
}
foreach (var node in updatedNodes)
{
Events.SitemapEvents.Instance.OnSitemapNodeUpdated(node);
}
foreach (var node in deletedNodes)
{
Events.SitemapEvents.Instance.OnSitemapNodeDeleted(node);
}
if (isNew)
{
Events.SitemapEvents.Instance.OnSitemapCreated(sitemap);
}
else
{
Events.SitemapEvents.Instance.OnSitemapUpdated(sitemap);
}
return(new PutSitemapResponse {
Data = sitemap.Id
});
}
/// <summary>
/// Saves the blog post.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="principal">The principal.</param>
/// <returns>
/// Saved blog post entity
/// </returns>
public BlogPost SaveBlogPost(BlogPostViewModel request, IPrincipal principal)
{
string[] roles;
if (request.DesirableStatus == ContentStatus.Published)
{
accessControlService.DemandAccess(principal, RootModuleConstants.UserRoles.PublishContent);
roles = new[] { RootModuleConstants.UserRoles.PublishContent };
}
else
{
accessControlService.DemandAccess(principal, RootModuleConstants.UserRoles.EditContent);
roles = new[] { RootModuleConstants.UserRoles.EditContent };
}
Layout layout;
Page masterPage;
LoadLayout(out layout, out masterPage);
if (masterPage != null)
{
var level = accessControlService.GetAccessLevel(masterPage, principal);
if (level < AccessLevel.Read)
{
var message = BlogGlobalization.SaveBlogPost_FailedToSave_InaccessibleMasterPage;
const string logMessage = "Failed to save blog post. Selected master page for page layout is inaccessible.";
throw new ValidationException(() => message, logMessage);
}
}
var region = LoadRegion(layout, masterPage);
var isNew = request.Id.HasDefaultValue();
var userCanEdit = securityService.IsAuthorized(RootModuleConstants.UserRoles.EditContent);
// UnitOfWork.BeginTransaction(); // NOTE: this causes concurrent data exception.
BlogPost blogPost;
BlogPostContent content = null;
PageContent pageContent = null;
Pages.Models.Redirect redirectCreated = null;
// Loading blog post and it's content, or creating new, if such not exists
if (!isNew)
{
var blogPostFuture = repository
.AsQueryable <BlogPost>(b => b.Id == request.Id)
.ToFuture();
content = repository
.AsQueryable <BlogPostContent>(c => c.PageContents.Any(x => x.Page.Id == request.Id && !x.IsDeleted))
.ToFuture()
.FirstOrDefault();
blogPost = blogPostFuture.FirstOne();
if (cmsConfiguration.Security.AccessControlEnabled)
{
accessControlService.DemandAccess(blogPost, principal, AccessLevel.ReadWrite, roles);
}
if (content != null)
{
// Check if user has confirmed the deletion of content
if (!request.IsUserConfirmed && blogPost.IsMasterPage)
{
var hasAnyChildren = contentService.CheckIfContentHasDeletingChildren(blogPost.Id, content.Id, request.Content);
if (hasAnyChildren)
{
var message = PagesGlobalization.SaveContent_ContentHasChildrenContents_RegionDeleteConfirmationMessage;
var logMessage = string.Format("User is trying to delete content regions which has children contents. Confirmation is required. ContentId: {0}, PageId: {1}",
content.Id, blogPost.Id);
throw new ConfirmationRequestException(() => message, logMessage);
}
}
pageContent = repository.FirstOrDefault <PageContent>(c => c.Page == blogPost && !c.IsDeleted && c.Content == content);
}
if (userCanEdit && !string.Equals(blogPost.PageUrl, request.BlogUrl) && request.BlogUrl != null)
{
request.BlogUrl = urlService.FixUrl(request.BlogUrl);
pageService.ValidatePageUrl(request.BlogUrl, request.Id);
if (request.RedirectFromOldUrl)
{
var redirect = redirectService.CreateRedirectEntity(blogPost.PageUrl, request.BlogUrl);
if (redirect != null)
{
repository.Save(redirect);
redirectCreated = redirect;
}
}
blogPost.PageUrl = urlService.FixUrl(request.BlogUrl);
}
}
else
{
blogPost = new BlogPost();
}
if (pageContent == null)
{
pageContent = new PageContent {
Region = region, Page = blogPost
};
}
// Push to change modified data each time.
blogPost.ModifiedOn = DateTime.Now;
blogPost.Version = request.Version;
if (userCanEdit)
{
blogPost.Title = request.Title;
blogPost.Description = request.IntroText;
blogPost.Author = request.AuthorId.HasValue ? repository.AsProxy <Author>(request.AuthorId.Value) : null;
blogPost.Category = request.CategoryId.HasValue ? repository.AsProxy <Category>(request.CategoryId.Value) : null;
blogPost.Image = (request.Image != null && request.Image.ImageId.HasValue) ? repository.AsProxy <MediaImage>(request.Image.ImageId.Value) : null;
if (isNew || request.DesirableStatus == ContentStatus.Published)
{
blogPost.ActivationDate = request.LiveFromDate;
blogPost.ExpirationDate = TimeHelper.FormatEndDate(request.LiveToDate);
}
}
if (isNew)
{
if (!string.IsNullOrWhiteSpace(request.BlogUrl))
{
blogPost.PageUrl = urlService.FixUrl(request.BlogUrl);
pageService.ValidatePageUrl(blogPost.PageUrl);
}
else
{
blogPost.PageUrl = CreateBlogPermalink(request.Title);
}
blogPost.MetaTitle = request.MetaTitle ?? request.Title;
if (masterPage != null)
{
blogPost.MasterPage = masterPage;
masterPageService.SetPageMasterPages(blogPost, masterPage.Id);
}
else
{
blogPost.Layout = layout;
}
UpdateStatus(blogPost, request.DesirableStatus);
AddDefaultAccessRules(blogPost, principal, masterPage);
}
else if (request.DesirableStatus == ContentStatus.Published ||
blogPost.Status == PageStatus.Preview)
{
// Update only if publishing or current status is preview.
// Else do not change, because it may change from published to draft status
UpdateStatus(blogPost, request.DesirableStatus);
}
// Create content.
var newContent = new BlogPostContent
{
Id = content != null ? content.Id : Guid.Empty,
Name = request.Title,
Html = request.Content ?? string.Empty,
EditInSourceMode = request.EditInSourceMode,
ActivationDate = request.LiveFromDate,
ExpirationDate = TimeHelper.FormatEndDate(request.LiveToDate)
};
// Preserve content if user is not authorized to change it.
if (!userCanEdit)
{
if (content == null)
{
throw new SecurityException("Forbidden: Access is denied."); // User has no rights to create new content.
}
var contentToPublish = (BlogPostContent)(content.History != null
? content.History.FirstOrDefault(c => c.Status == ContentStatus.Draft) ?? content
: content);
newContent.Name = contentToPublish.Name;
newContent.Html = contentToPublish.Html;
}
content = (BlogPostContent)contentService.SaveContentWithStatusUpdate(newContent, request.DesirableStatus);
pageContent.Content = content;
blogPost.PageUrlHash = blogPost.PageUrl.UrlHash();
blogPost.UseCanonicalUrl = request.UseCanonicalUrl;
repository.Save(blogPost);
repository.Save(content);
repository.Save(pageContent);
pageContent.Content = content;
blogPost.PageContents = new [] { pageContent };
IList <Tag> newTags = null;
if (userCanEdit)
{
tagService.SavePageTags(blogPost, request.Tags, out newTags);
}
// Commit
unitOfWork.Commit();
// Notify about new or updated blog post.
if (isNew)
{
Events.BlogEvents.Instance.OnBlogCreated(blogPost);
}
else
{
Events.BlogEvents.Instance.OnBlogUpdated(blogPost);
}
// Notify about new created tags.
Events.RootEvents.Instance.OnTagCreated(newTags);
// Notify about redirect creation.
if (redirectCreated != null)
{
Events.PageEvents.Instance.OnRedirectCreated(redirectCreated);
}
return(blogPost);
}