1511 lines
63 KiB
C#
1511 lines
63 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Web;
|
|
using System.Xml.Linq;
|
|
using Umbraco.Core.Auditing;
|
|
using Umbraco.Core.Events;
|
|
using Umbraco.Core.IO;
|
|
using Umbraco.Core.Logging;
|
|
using Umbraco.Core.Models;
|
|
using Umbraco.Core.Models.EntityBase;
|
|
using Umbraco.Core.Models.Rdbms;
|
|
using Umbraco.Core.Persistence;
|
|
using Umbraco.Core.Persistence.Querying;
|
|
using Umbraco.Core.Persistence.UnitOfWork;
|
|
using Umbraco.Core.Publishing;
|
|
|
|
namespace Umbraco.Core.Services
|
|
{
|
|
/// <summary>
|
|
/// Represents the Content Service, which is an easy access to operations involving <see cref="IContent"/>
|
|
/// </summary>
|
|
public class ContentService : IContentService
|
|
{
|
|
private readonly IDatabaseUnitOfWorkProvider _uowProvider;
|
|
private readonly IPublishingStrategy _publishingStrategy;
|
|
private readonly IUserService _userService;
|
|
private readonly RepositoryFactory _repositoryFactory;
|
|
private HttpContextBase _httpContext;
|
|
|
|
public ContentService()
|
|
: this(new RepositoryFactory())
|
|
{}
|
|
|
|
public ContentService(RepositoryFactory repositoryFactory)
|
|
: this(new PetaPocoUnitOfWorkProvider(), repositoryFactory, new PublishingStrategy())
|
|
{}
|
|
|
|
public ContentService(IDatabaseUnitOfWorkProvider provider)
|
|
: this(provider, new RepositoryFactory(), new PublishingStrategy())
|
|
{ }
|
|
|
|
public ContentService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory)
|
|
: this(provider, repositoryFactory, new PublishingStrategy())
|
|
{ }
|
|
|
|
internal ContentService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, IPublishingStrategy publishingStrategy)
|
|
{
|
|
_uowProvider = provider;
|
|
_publishingStrategy = publishingStrategy;
|
|
_repositoryFactory = repositoryFactory;
|
|
}
|
|
|
|
internal ContentService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, IPublishingStrategy publishingStrategy, IUserService userService)
|
|
{
|
|
_uowProvider = provider;
|
|
_publishingStrategy = publishingStrategy;
|
|
_userService = userService;
|
|
_repositoryFactory = repositoryFactory;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
|
|
/// that this Content is based on.
|
|
/// </summary>
|
|
/// <param name="name">Name of the Content object</param>
|
|
/// <param name="parentId">Id of Parent for the new Content</param>
|
|
/// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
|
|
/// <param name="userId">Optional id of the user creating the content</param>
|
|
/// <returns><see cref="IContent"/></returns>
|
|
public IContent CreateContent(string name, int parentId, string contentTypeAlias, int userId = -1)
|
|
{
|
|
IContentType contentType = null;
|
|
IContent content = null;
|
|
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentTypeRepository(uow))
|
|
{
|
|
var query = Query<IContentType>.Builder.Where(x => x.Alias == contentTypeAlias);
|
|
var contentTypes = repository.GetByQuery(query);
|
|
|
|
if (!contentTypes.Any())
|
|
throw new Exception(string.Format("No ContentType matching the passed in Alias: '{0}' was found",
|
|
contentTypeAlias));
|
|
|
|
contentType = contentTypes.First();
|
|
|
|
if (contentType == null)
|
|
throw new Exception(string.Format("ContentType matching the passed in Alias: '{0}' was null",
|
|
contentTypeAlias));
|
|
}
|
|
|
|
content = new Content(name, parentId, contentType);
|
|
|
|
if (Creating.IsRaisedEventCancelled(new NewEventArgs<IContent>(content, contentTypeAlias, parentId), this))
|
|
return content;
|
|
|
|
SetUser(content, userId);
|
|
SetWriter(content, userId);
|
|
|
|
Created.RaiseEvent(new NewEventArgs<IContent>(content, false, contentTypeAlias, parentId), this);
|
|
|
|
Audit.Add(AuditTypes.New, "", content.CreatorId, content.Id);
|
|
|
|
return content;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an <see cref="IContent"/> object by Id
|
|
/// </summary>
|
|
/// <param name="id">Id of the Content to retrieve</param>
|
|
/// <returns><see cref="IContent"/></returns>
|
|
public IContent GetById(int id)
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
return repository.Get(id);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an <see cref="IContent"/> object by its 'UniqueId'
|
|
/// </summary>
|
|
/// <param name="key">Guid key of the Content to retrieve</param>
|
|
/// <returns><see cref="IContent"/></returns>
|
|
public IContent GetById(Guid key)
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
var query = Query<IContent>.Builder.Where(x => x.Key == key);
|
|
var contents = repository.GetByQuery(query);
|
|
return contents.SingleOrDefault();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a collection of <see cref="IContent"/> objects by the Id of the <see cref="IContentType"/>
|
|
/// </summary>
|
|
/// <param name="id">Id of the <see cref="IContentType"/></param>
|
|
/// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
|
|
public IEnumerable<IContent> GetContentOfContentType(int id)
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
var query = Query<IContent>.Builder.Where(x => x.ContentTypeId == id);
|
|
var contents = repository.GetByQuery(query);
|
|
|
|
return contents;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a collection of <see cref="IContent"/> objects by Level
|
|
/// </summary>
|
|
/// <param name="level">The level to retrieve Content from</param>
|
|
/// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
|
|
public IEnumerable<IContent> GetByLevel(int level)
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
var query = Query<IContent>.Builder.Where(x => x.Level == level);
|
|
var contents = repository.GetByQuery(query);
|
|
|
|
return contents;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a specific version of an <see cref="IContent"/> item.
|
|
/// </summary>
|
|
/// <param name="versionId">Id of the version to retrieve</param>
|
|
/// <returns>An <see cref="IContent"/> item</returns>
|
|
public IContent GetByVersion(Guid versionId)
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
return repository.GetByVersion(versionId);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a collection of an <see cref="IContent"/> objects versions by Id
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
|
|
public IEnumerable<IContent> GetVersions(int id)
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
var versions = repository.GetAllVersions(id);
|
|
return versions;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a collection of <see cref="IContent"/> objects by Parent Id
|
|
/// </summary>
|
|
/// <param name="id">Id of the Parent to retrieve Children from</param>
|
|
/// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
|
|
public IEnumerable<IContent> GetChildren(int id)
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
var query = Query<IContent>.Builder.Where(x => x.ParentId == id);
|
|
var contents = repository.GetByQuery(query);
|
|
|
|
return contents;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a collection of <see cref="IContent"/> objects by its name or partial name
|
|
/// </summary>
|
|
/// <param name="parentId">Id of the Parent to retrieve Children from</param>
|
|
/// <param name="name">Full or partial name of the children</param>
|
|
/// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
|
|
public IEnumerable<IContent> GetChildrenByName(int parentId, string name)
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
var query = Query<IContent>.Builder.Where(x => x.ParentId == parentId && x.Name.Contains(name));
|
|
var contents = repository.GetByQuery(query);
|
|
|
|
return contents;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a collection of <see cref="IContent"/> objects by Parent Id
|
|
/// </summary>
|
|
/// <param name="id">Id of the Parent to retrieve Descendants from</param>
|
|
/// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
|
|
public IEnumerable<IContent> GetDescendants(int id)
|
|
{
|
|
var content = GetById(id);
|
|
return GetDescendants(content);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a collection of <see cref="IContent"/> objects by Parent Id
|
|
/// </summary>
|
|
/// <param name="content"><see cref="IContent"/> item to retrieve Descendants from</param>
|
|
/// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
|
|
public IEnumerable<IContent> GetDescendants(IContent content)
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(content.Path) && x.Id != content.Id);
|
|
var contents = repository.GetByQuery(query);
|
|
|
|
return contents;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the published version of an <see cref="IContent"/> item
|
|
/// </summary>
|
|
/// <param name="id">Id of the <see cref="IContent"/> to retrieve version from</param>
|
|
/// <returns>An <see cref="IContent"/> item</returns>
|
|
public IContent GetPublishedVersion(int id)
|
|
{
|
|
var version = GetVersions(id);
|
|
return version.FirstOrDefault(x => x.Published == true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a collection of <see cref="IContent"/> objects, which reside at the first level / root
|
|
/// </summary>
|
|
/// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
|
|
public IEnumerable<IContent> GetRootContent()
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
var query = Query<IContent>.Builder.Where(x => x.ParentId == -1);
|
|
var contents = repository.GetByQuery(query);
|
|
|
|
return contents;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a collection of <see cref="IContent"/> objects, which has an expiration date less than or equal to today.
|
|
/// </summary>
|
|
/// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
|
|
public IEnumerable<IContent> GetContentForExpiration()
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
var query = Query<IContent>.Builder.Where(x => x.Published == true && x.ExpireDate <= DateTime.Now);
|
|
var contents = repository.GetByQuery(query);
|
|
|
|
return contents;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a collection of <see cref="IContent"/> objects, which has a release date less than or equal to today.
|
|
/// </summary>
|
|
/// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
|
|
public IEnumerable<IContent> GetContentForRelease()
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
var query = Query<IContent>.Builder.Where(x => x.Published == false && x.ReleaseDate <= DateTime.Now);
|
|
var contents = repository.GetByQuery(query);
|
|
|
|
return contents;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a collection of an <see cref="IContent"/> objects, which resides in the Recycle Bin
|
|
/// </summary>
|
|
/// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
|
|
public IEnumerable<IContent> GetContentInRecycleBin()
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
var query = Query<IContent>.Builder.Where(x => x.ParentId == -20);
|
|
var contents = repository.GetByQuery(query);
|
|
|
|
return contents;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks whether an <see cref="IContent"/> item has any children
|
|
/// </summary>
|
|
/// <param name="id">Id of the <see cref="IContent"/></param>
|
|
/// <returns>True if the content has any children otherwise False</returns>
|
|
public bool HasChildren(int id)
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
var query = Query<IContent>.Builder.Where(x => x.ParentId == id);
|
|
int count = repository.Count(query);
|
|
return count > 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks whether an <see cref="IContent"/> item has any published versions
|
|
/// </summary>
|
|
/// <param name="id">Id of the <see cref="IContent"/></param>
|
|
/// <returns>True if the content has any published version otherwise False</returns>
|
|
public bool HasPublishedVersion(int id)
|
|
{
|
|
using (var repository = _repositoryFactory.CreateContentRepository(_uowProvider.GetUnitOfWork()))
|
|
{
|
|
var query = Query<IContent>.Builder.Where(x => x.Published == true && x.Id == id);
|
|
int count = repository.Count(query);
|
|
return count > 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the passed in <see cref="IContent"/> can be published based on the anscestors publish state.
|
|
/// </summary>
|
|
/// <param name="content"><see cref="IContent"/> to check if anscestors are published</param>
|
|
/// <returns>True if the Content can be published, otherwise False</returns>
|
|
public bool IsPublishable(IContent content)
|
|
{
|
|
//If the passed in content has yet to be saved we "fallback" to checking the Parent
|
|
//because if the Parent is publishable then the current content can be Saved and Published
|
|
if (content.HasIdentity == false)
|
|
{
|
|
IContent parent = GetById(content.ParentId);
|
|
return IsPublishable(parent, true);
|
|
}
|
|
|
|
return IsPublishable(content, false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Re-Publishes all Content
|
|
/// </summary>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <returns>True if publishing succeeded, otherwise False</returns>
|
|
public bool RePublishAll(int userId = -1)
|
|
{
|
|
return RePublishAllDo(false, userId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Publishes a single <see cref="IContent"/> object
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to publish</param>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <returns>True if publishing succeeded, otherwise False</returns>
|
|
public bool Publish(IContent content, int userId = -1)
|
|
{
|
|
return SaveAndPublishDo(content, false, userId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Publishes a <see cref="IContent"/> object and all its children
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <returns>True if publishing succeeded, otherwise False</returns>
|
|
public bool PublishWithChildren(IContent content, int userId = -1)
|
|
{
|
|
return PublishWithChildrenDo(content, false, userId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// UnPublishes a single <see cref="IContent"/> object
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to publish</param>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <returns>True if unpublishing succeeded, otherwise False</returns>
|
|
public bool UnPublish(IContent content, int userId = -1)
|
|
{
|
|
return UnPublishDo(content, false, userId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Saves and Publishes a single <see cref="IContent"/> object
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to save and publish</param>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <returns>True if publishing succeeded, otherwise False</returns>
|
|
public bool SaveAndPublish(IContent content, int userId = -1)
|
|
{
|
|
return SaveAndPublishDo(content, false, userId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Saves a single <see cref="IContent"/> object
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to save</param>
|
|
/// <param name="userId">Optional Id of the User saving the Content</param>
|
|
public void Save(IContent content, int userId = -1)
|
|
{
|
|
Save(content, true, userId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Saves a collection of <see cref="IContent"/> objects.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// If the collection of content contains new objects that references eachother by Id or ParentId,
|
|
/// then use the overload Save method with a collection of Lazy <see cref="IContent"/>.
|
|
/// </remarks>
|
|
/// <param name="contents">Collection of <see cref="IContent"/> to save</param>
|
|
/// <param name="userId">Optional Id of the User saving the Content</param>
|
|
public void Save(IEnumerable<IContent> contents, int userId = -1)
|
|
{
|
|
if (Saving.IsRaisedEventCancelled(new SaveEventArgs<IContent>(contents), this))
|
|
return;
|
|
|
|
var containsNew = contents.Any(x => x.HasIdentity == false);
|
|
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentRepository(uow))
|
|
{
|
|
if (containsNew)
|
|
{
|
|
foreach (var content in contents)
|
|
{
|
|
SetWriter(content, userId);
|
|
|
|
//Only change the publish state if the "previous" version was actually published
|
|
if (content.Published)
|
|
content.ChangePublishedState(PublishedState.Saved);
|
|
|
|
repository.AddOrUpdate(content);
|
|
uow.Commit();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach (var content in contents)
|
|
{
|
|
SetWriter(content, userId);
|
|
repository.AddOrUpdate(content);
|
|
}
|
|
uow.Commit();
|
|
}
|
|
}
|
|
|
|
Saved.RaiseEvent(new SaveEventArgs<IContent>(contents, false), this);
|
|
|
|
Audit.Add(AuditTypes.Save, "Bulk Save content performed by user", userId == -1 ? 0 : userId, -1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes all content of specified type. All children of deleted content is moved to Recycle Bin.
|
|
/// </summary>
|
|
/// <remarks>This needs extra care and attention as its potentially a dangerous and extensive operation</remarks>
|
|
/// <param name="contentTypeId">Id of the <see cref="IContentType"/></param>
|
|
/// <param name="userId">Optional Id of the user issueing the delete operation</param>
|
|
public void DeleteContentOfType(int contentTypeId, int userId = -1)
|
|
{
|
|
using (var uow = _uowProvider.GetUnitOfWork())
|
|
{
|
|
var repository = _repositoryFactory.CreateContentRepository(uow);
|
|
//NOTE What about content that has the contenttype as part of its composition?
|
|
var query = Query<IContent>.Builder.Where(x => x.ContentTypeId == contentTypeId);
|
|
var contents = repository.GetByQuery(query);
|
|
|
|
if (Deleting.IsRaisedEventCancelled(new DeleteEventArgs<IContent>(contents), this))
|
|
return;
|
|
|
|
foreach (var content in contents.OrderByDescending(x => x.ParentId))
|
|
{
|
|
//Look for children of current content and move that to trash before the current content is deleted
|
|
var c = content;
|
|
var childQuery = Query<IContent>.Builder.Where(x => x.Path.StartsWith(c.Path));
|
|
var children = repository.GetByQuery(childQuery);
|
|
|
|
foreach (var child in children)
|
|
{
|
|
if (child.ContentType.Id != contentTypeId)
|
|
MoveToRecycleBin(child, userId);
|
|
}
|
|
|
|
//Permantly delete the content
|
|
Delete(content, userId);
|
|
}
|
|
}
|
|
|
|
Audit.Add(AuditTypes.Delete,
|
|
string.Format("Delete Content of Type {0} performed by user", contentTypeId),
|
|
userId == -1 ? 0 : userId, -1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Permanently deletes an <see cref="IContent"/> object.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This method will also delete associated media files, child content and possibly associated domains.
|
|
/// </remarks>
|
|
/// <remarks>Please note that this method will completely remove the Content from the database</remarks>
|
|
/// <param name="content">The <see cref="IContent"/> to delete</param>
|
|
/// <param name="userId">Optional Id of the User deleting the Content</param>
|
|
public void Delete(IContent content, int userId = -1)
|
|
{
|
|
if (Deleting.IsRaisedEventCancelled(new DeleteEventArgs<IContent>(content), this))
|
|
return;
|
|
|
|
//Make sure that published content is unpublished before being deleted
|
|
if (HasPublishedVersion(content.Id))
|
|
{
|
|
UnPublish(content, userId);
|
|
}
|
|
|
|
//Delete children before deleting the 'possible parent'
|
|
var children = GetChildren(content.Id);
|
|
foreach (var child in children)
|
|
{
|
|
Delete(child, userId);
|
|
}
|
|
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentRepository(uow))
|
|
{
|
|
//TODO: Why are we setting a writer if we are just deleting the object? (I'm probably overlooking something here...?)
|
|
SetWriter(content, userId);
|
|
repository.Delete(content);
|
|
uow.Commit();
|
|
}
|
|
|
|
Deleted.RaiseEvent(new DeleteEventArgs<IContent>(content, false), this);
|
|
|
|
Audit.Add(AuditTypes.Delete, "Delete Content performed by user", userId == -1 ? 0 : userId, content.Id);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Permanently deletes versions from an <see cref="IContent"/> object prior to a specific date.
|
|
/// </summary>
|
|
/// <param name="id">Id of the <see cref="IContent"/> object to delete versions from</param>
|
|
/// <param name="versionDate">Latest version date</param>
|
|
/// <param name="userId">Optional Id of the User deleting versions of a Content object</param>
|
|
public void DeleteVersions(int id, DateTime versionDate, int userId = -1)
|
|
{
|
|
//TODO: We should check if we are going to delete the most recent version because if that happens it means the
|
|
// entity is completely deleted and we should raise the normal Deleting/Deleted event
|
|
|
|
if (DeletingVersions.IsRaisedEventCancelled(new DeleteRevisionsEventArgs(id, dateToRetain: versionDate), this))
|
|
return;
|
|
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentRepository(uow))
|
|
{
|
|
repository.DeleteVersions(id, versionDate);
|
|
uow.Commit();
|
|
}
|
|
|
|
DeletedVersions.RaiseEvent(new DeleteRevisionsEventArgs(id, false, dateToRetain: versionDate), this);
|
|
|
|
Audit.Add(AuditTypes.Delete, "Delete Content by version date performed by user", userId == -1 ? 0 : userId, -1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Permanently deletes specific version(s) from an <see cref="IContent"/> object.
|
|
/// </summary>
|
|
/// <param name="id">Id of the <see cref="IContent"/> object to delete a version from</param>
|
|
/// <param name="versionId">Id of the version to delete</param>
|
|
/// <param name="deletePriorVersions">Boolean indicating whether to delete versions prior to the versionId</param>
|
|
/// <param name="userId">Optional Id of the User deleting versions of a Content object</param>
|
|
public void DeleteVersion(int id, Guid versionId, bool deletePriorVersions, int userId = -1)
|
|
{
|
|
//TODO: We should check if we are going to delete the most recent version because if that happens it means the
|
|
// entity is completely deleted and we should raise the normal Deleting/Deleted event
|
|
|
|
if (deletePriorVersions)
|
|
{
|
|
var content = GetByVersion(versionId);
|
|
DeleteVersions(id, content.UpdateDate, userId);
|
|
}
|
|
|
|
if (DeletingVersions.IsRaisedEventCancelled(new DeleteRevisionsEventArgs(id, specificVersion: versionId), this))
|
|
return;
|
|
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentRepository(uow))
|
|
{
|
|
repository.DeleteVersion(versionId);
|
|
uow.Commit();
|
|
}
|
|
|
|
DeletedVersions.RaiseEvent(new DeleteRevisionsEventArgs(id, false, specificVersion:versionId), this);
|
|
|
|
Audit.Add(AuditTypes.Delete, "Delete Content by version performed by user", userId == -1 ? 0 : userId, -1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes an <see cref="IContent"/> object by moving it to the Recycle Bin
|
|
/// </summary>
|
|
/// <remarks>Move an item to the Recycle Bin will result in the item being unpublished</remarks>
|
|
/// <param name="content">The <see cref="IContent"/> to delete</param>
|
|
/// <param name="userId">Optional Id of the User deleting the Content</param>
|
|
public void MoveToRecycleBin(IContent content, int userId = -1)
|
|
{
|
|
if (Trashing.IsRaisedEventCancelled(new MoveEventArgs<IContent>(content, -20), this))
|
|
return;
|
|
|
|
//Make sure that published content is unpublished before being moved to the Recycle Bin
|
|
if (HasPublishedVersion(content.Id))
|
|
{
|
|
UnPublish(content, userId);
|
|
}
|
|
|
|
//Move children to Recycle Bin before the 'possible parent' is moved there
|
|
var children = GetChildren(content.Id);
|
|
foreach (var child in children)
|
|
{
|
|
MoveToRecycleBin(child, userId);
|
|
}
|
|
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentRepository(uow))
|
|
{
|
|
SetWriter(content, userId);
|
|
content.ChangeTrashedState(true);
|
|
repository.AddOrUpdate(content);
|
|
uow.Commit();
|
|
}
|
|
|
|
Trashed.RaiseEvent(new MoveEventArgs<IContent>(content, false, -20), this);
|
|
|
|
Audit.Add(AuditTypes.Move, "Move Content to Recycle Bin performed by user", userId == -1 ? 0 : userId,
|
|
content.Id);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Moves an <see cref="IContent"/> object to a new location by changing its parent id.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// If the <see cref="IContent"/> object is already published it will be
|
|
/// published after being moved to its new location. Otherwise it'll just
|
|
/// be saved with a new parent id.
|
|
/// </remarks>
|
|
/// <param name="content">The <see cref="IContent"/> to move</param>
|
|
/// <param name="parentId">Id of the Content's new Parent</param>
|
|
/// <param name="userId">Optional Id of the User moving the Content</param>
|
|
public void Move(IContent content, int parentId, int userId = -1)
|
|
{
|
|
//This ensures that the correct method is called if this method is used to Move to recycle bin.
|
|
if (parentId == -20)
|
|
{
|
|
MoveToRecycleBin(content, userId);
|
|
return;
|
|
}
|
|
|
|
if (Moving.IsRaisedEventCancelled(new MoveEventArgs<IContent>(content, parentId), this))
|
|
return;
|
|
|
|
SetWriter(content, userId);
|
|
var parent = GetById(parentId);
|
|
content.Path = string.Concat(parent.Path, ",", content.Id);
|
|
content.Level = parent.Level + 1;
|
|
|
|
//If Content is being moved away from Recycle Bin, its state should be un-trashed
|
|
if (content.Trashed && parentId != -20)
|
|
{
|
|
content.ChangeTrashedState(false, parentId);
|
|
}
|
|
else
|
|
{
|
|
content.ParentId = parentId;
|
|
}
|
|
|
|
//If Content is published, it should be (re)published from its new location
|
|
if (content.Published)
|
|
{
|
|
//If Content is Publishable its saved and published
|
|
//otherwise we save the content without changing the publish state, and generate new xml because the Path, Level and Parent has changed.
|
|
if (IsPublishable(content))
|
|
{
|
|
SaveAndPublish(content, userId);
|
|
}
|
|
else
|
|
{
|
|
Save(content, false, userId);
|
|
|
|
using (var uow = _uowProvider.GetUnitOfWork())
|
|
{
|
|
var xml = content.ToXml();
|
|
var poco = new ContentXmlDto {NodeId = content.Id, Xml = xml.ToString(SaveOptions.None)};
|
|
var exists =
|
|
uow.Database.FirstOrDefault<ContentXmlDto>("WHERE nodeId = @Id", new {Id = content.Id}) !=
|
|
null;
|
|
int result = exists
|
|
? uow.Database.Update(poco)
|
|
: Convert.ToInt32(uow.Database.Insert(poco));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Save(content, userId);
|
|
}
|
|
|
|
//Ensure that Path and Level is updated on children
|
|
var children = GetChildren(content.Id);
|
|
if (children.Any())
|
|
{
|
|
foreach (var child in children)
|
|
{
|
|
Move(child, content.Id, userId);
|
|
}
|
|
}
|
|
|
|
Moved.RaiseEvent(new MoveEventArgs<IContent>(content, false, parentId), this);
|
|
|
|
Audit.Add(AuditTypes.Move, "Move Content performed by user", userId == -1 ? 0 : userId, content.Id);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Empties the Recycle Bin by deleting all <see cref="IContent"/> that resides in the bin
|
|
/// </summary>
|
|
public void EmptyRecycleBin()
|
|
{
|
|
//TODO: Why don't we have a base class to share between MediaService/ContentService as some of this is exacty the same?
|
|
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentRepository(uow))
|
|
{
|
|
var query = Query<IContent>.Builder.Where(x => x.ParentId == -20);
|
|
var contents = repository.GetByQuery(query);
|
|
|
|
foreach (var content in contents)
|
|
{
|
|
if (Deleting.IsRaisedEventCancelled(new DeleteEventArgs<IContent>(content), this))
|
|
continue;
|
|
|
|
repository.Delete(content);
|
|
|
|
Deleted.RaiseEvent(new DeleteEventArgs<IContent>(content, false), this);
|
|
}
|
|
uow.Commit();
|
|
}
|
|
|
|
Audit.Add(AuditTypes.Delete, "Empty Recycle Bin performed by user", 0, -20);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies an <see cref="IContent"/> object by creating a new Content object of the same type and copies all data from the current
|
|
/// to the new copy which is returned.
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to copy</param>
|
|
/// <param name="parentId">Id of the Content's new Parent</param>
|
|
/// <param name="relateToOriginal">Boolean indicating whether the copy should be related to the original</param>
|
|
/// <param name="userId">Optional Id of the User copying the Content</param>
|
|
/// <returns>The newly created <see cref="IContent"/> object</returns>
|
|
public IContent Copy(IContent content, int parentId, bool relateToOriginal, int userId = -1)
|
|
{
|
|
var copy = ((Content)content).Clone();
|
|
copy.ParentId = parentId;
|
|
|
|
// A copy should never be set to published automatically even if the original was.
|
|
copy.ChangePublishedState(PublishedState.Unpublished);
|
|
|
|
if (Copying.IsRaisedEventCancelled(new CopyEventArgs<IContent>(content, copy, parentId), this))
|
|
return null;
|
|
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentRepository(uow))
|
|
{
|
|
SetWriter(content, userId);
|
|
|
|
repository.AddOrUpdate(copy);
|
|
uow.Commit();
|
|
|
|
//Special case for the Upload DataType
|
|
var uploadDataTypeId = new Guid("5032a6e6-69e3-491d-bb28-cd31cd11086c");
|
|
if (content.Properties.Any(x => x.PropertyType.DataTypeId == uploadDataTypeId))
|
|
{
|
|
bool isUpdated = false;
|
|
var fs = FileSystemProviderManager.Current.GetFileSystemProvider<MediaFileSystem>();
|
|
|
|
//Loop through properties to check if the content contains media that should be deleted
|
|
foreach (var property in content.Properties.Where(x => x.PropertyType.DataTypeId == uploadDataTypeId
|
|
&& string.IsNullOrEmpty(x.Value.ToString()) == false))
|
|
{
|
|
if (fs.FileExists(IOHelper.MapPath(property.Value.ToString())))
|
|
{
|
|
var currentPath = fs.GetRelativePath(property.Value.ToString());
|
|
var propertyId = copy.Properties.First(x => x.Alias == property.Alias).Id;
|
|
var newPath = fs.GetRelativePath(propertyId, System.IO.Path.GetFileName(currentPath));
|
|
|
|
fs.CopyFile(currentPath, newPath);
|
|
copy.SetValue(property.Alias, fs.GetUrl(newPath));
|
|
|
|
//Copy thumbnails
|
|
foreach (var thumbPath in fs.GetThumbnails(currentPath))
|
|
{
|
|
var newThumbPath = fs.GetRelativePath(propertyId, System.IO.Path.GetFileName(thumbPath));
|
|
fs.CopyFile(thumbPath, newThumbPath);
|
|
}
|
|
isUpdated = true;
|
|
}
|
|
}
|
|
|
|
if (isUpdated)
|
|
{
|
|
repository.AddOrUpdate(copy);
|
|
uow.Commit();
|
|
}
|
|
}
|
|
|
|
//Special case for the Tags DataType
|
|
var tagsDataTypeId = new Guid("4023e540-92f5-11dd-ad8b-0800200c9a66");
|
|
if (content.Properties.Any(x => x.PropertyType.DataTypeId == tagsDataTypeId))
|
|
{
|
|
var tags = uow.Database.Fetch<TagRelationshipDto>("WHERE nodeId = @Id", new {Id = content.Id});
|
|
foreach (var tag in tags)
|
|
{
|
|
uow.Database.Insert(new TagRelationshipDto {NodeId = copy.Id, TagId = tag.TagId});
|
|
}
|
|
}
|
|
}
|
|
|
|
//NOTE This 'Relation' part should eventually be delegated to a RelationService
|
|
if (relateToOriginal)
|
|
{
|
|
RelationType relationType = null;
|
|
using (var relationTypeRepository = _repositoryFactory.CreateRelationTypeRepository(uow))
|
|
{
|
|
relationType = relationTypeRepository.Get(1);
|
|
}
|
|
|
|
using (var relationRepository = _repositoryFactory.CreateRelationRepository(uow))
|
|
{
|
|
var relation = new Relation(content.Id, copy.Id, relationType);
|
|
relationRepository.AddOrUpdate(relation);
|
|
uow.Commit();
|
|
}
|
|
|
|
Audit.Add(AuditTypes.Copy,
|
|
string.Format("Copied content with Id: '{0}' related to original content with Id: '{1}'",
|
|
copy.Id, content.Id), copy.WriterId, copy.Id);
|
|
}
|
|
|
|
//Look for children and copy those as well
|
|
var children = GetChildren(content.Id);
|
|
foreach (var child in children)
|
|
{
|
|
Copy(child, copy.Id, relateToOriginal, userId);
|
|
}
|
|
|
|
Copied.RaiseEvent(new CopyEventArgs<IContent>(content, copy, false, parentId), this);
|
|
|
|
Audit.Add(AuditTypes.Copy, "Copy Content performed by user", content.WriterId, content.Id);
|
|
|
|
return copy;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sends an <see cref="IContent"/> to Publication, which executes handlers and events for the 'Send to Publication' action.
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to send to publication</param>
|
|
/// <param name="userId">Optional Id of the User issueing the send to publication</param>
|
|
/// <returns>True if sending publication was succesfull otherwise false</returns>
|
|
internal bool SendToPublication(IContent content, int userId = -1)
|
|
{
|
|
|
|
if (SendingToPublish.IsRaisedEventCancelled(new SendToPublishEventArgs<IContent>(content), this))
|
|
return false;
|
|
|
|
//TODO: Do some stuff here.. RunActionHandlers
|
|
|
|
SentToPublish.RaiseEvent(new SendToPublishEventArgs<IContent>(content, false), this);
|
|
|
|
Audit.Add(AuditTypes.SendToPublish, "Send to Publish performed by user", content.WriterId, content.Id);
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Rollback an <see cref="IContent"/> object to a previous version.
|
|
/// This will create a new version, which is a copy of all the old data.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The way data is stored actually only allows us to rollback on properties
|
|
/// and not data like Name and Alias of the Content.
|
|
/// </remarks>
|
|
/// <param name="id">Id of the <see cref="IContent"/>being rolled back</param>
|
|
/// <param name="versionId">Id of the version to rollback to</param>
|
|
/// <param name="userId">Optional Id of the User issueing the rollback of the Content</param>
|
|
/// <returns>The newly created <see cref="IContent"/> object</returns>
|
|
public IContent Rollback(int id, Guid versionId, int userId = -1)
|
|
{
|
|
var content = GetByVersion(versionId);
|
|
|
|
if (RollingBack.IsRaisedEventCancelled(new RollbackEventArgs<IContent>(content), this))
|
|
return content;
|
|
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentRepository(uow))
|
|
{
|
|
SetUser(content, userId);
|
|
SetWriter(content, userId);
|
|
|
|
repository.AddOrUpdate(content);
|
|
uow.Commit();
|
|
}
|
|
|
|
RolledBack.RaiseEvent(new RollbackEventArgs<IContent>(content, false), this);
|
|
|
|
Audit.Add(AuditTypes.RollBack, "Content rollback performed by user", content.WriterId, content.Id);
|
|
|
|
return content;
|
|
}
|
|
|
|
#region Internal Methods
|
|
/// <summary>
|
|
/// Internal method to set the HttpContextBase for testing.
|
|
/// </summary>
|
|
/// <param name="httpContext"><see cref="HttpContextBase"/></param>
|
|
internal void SetHttpContext(HttpContextBase httpContext)
|
|
{
|
|
_httpContext = httpContext;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Internal method to Re-Publishes all Content for legacy purposes.
|
|
/// </summary>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <param name="omitCacheRefresh">Optional boolean to avoid having the cache refreshed when calling this RePublish method. By default this method will not update the cache.</param>
|
|
/// <returns>True if publishing succeeded, otherwise False</returns>
|
|
internal bool RePublishAll(bool omitCacheRefresh = true, int userId = -1)
|
|
{
|
|
return RePublishAllDo(omitCacheRefresh, userId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Internal method that Publishes a single <see cref="IContent"/> object for legacy purposes.
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to publish</param>
|
|
/// <param name="omitCacheRefresh">Optional boolean to avoid having the cache refreshed when calling this Publish method. By default this method will not update the cache.</param>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <returns>True if publishing succeeded, otherwise False</returns>
|
|
internal bool Publish(IContent content, bool omitCacheRefresh = true, int userId = -1)
|
|
{
|
|
return SaveAndPublishDo(content, omitCacheRefresh, userId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Internal method that Publishes a <see cref="IContent"/> object and all its children for legacy purposes.
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
|
|
/// <param name="omitCacheRefresh">Optional boolean to avoid having the cache refreshed when calling this Publish method. By default this method will not update the cache.</param>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <returns>True if publishing succeeded, otherwise False</returns>
|
|
internal bool PublishWithChildren(IContent content, bool omitCacheRefresh = true, int userId = -1)
|
|
{
|
|
return PublishWithChildrenDo(content, omitCacheRefresh, userId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Internal method that UnPublishes a single <see cref="IContent"/> object for legacy purposes.
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to publish</param>
|
|
/// <param name="omitCacheRefresh">Optional boolean to avoid having the cache refreshed when calling this Unpublish method. By default this method will not update the cache.</param>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <returns>True if unpublishing succeeded, otherwise False</returns>
|
|
internal bool UnPublish(IContent content, bool omitCacheRefresh = true, int userId = -1)
|
|
{
|
|
return UnPublishDo(content, omitCacheRefresh, userId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Saves and Publishes a single <see cref="IContent"/> object
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to save and publish</param>
|
|
/// <param name="omitCacheRefresh">Optional boolean to avoid having the cache refreshed when calling this Publish method. By default this method will not update the cache.</param>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <returns>True if publishing succeeded, otherwise False</returns>
|
|
internal bool SaveAndPublish(IContent content, bool omitCacheRefresh = true, int userId = -1)
|
|
{
|
|
return SaveAndPublishDo(content, omitCacheRefresh, userId);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private Methods
|
|
|
|
/// <summary>
|
|
/// Re-Publishes all Content
|
|
/// </summary>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <param name="omitCacheRefresh">Optional boolean to avoid having the cache refreshed when calling this RePublish method. By default this method will update the cache.</param>
|
|
/// <returns>True if publishing succeeded, otherwise False</returns>
|
|
private bool RePublishAllDo(bool omitCacheRefresh = false, int userId = -1)
|
|
{
|
|
var list = new List<IContent>();
|
|
var updated = new List<IContent>();
|
|
|
|
//Consider creating a Path query instead of recursive method:
|
|
//var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith("-1"));
|
|
|
|
var rootContent = GetRootContent();
|
|
foreach (var content in rootContent)
|
|
{
|
|
if (content.IsValid())
|
|
{
|
|
list.Add(content);
|
|
list.AddRange(GetChildrenDeep(content.Id));
|
|
}
|
|
}
|
|
|
|
//Publish and then update the database with new status
|
|
var published = _publishingStrategy.PublishWithChildren(list, userId);
|
|
if (published)
|
|
{
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentRepository(uow))
|
|
{
|
|
//Only loop through content where the Published property has been updated
|
|
foreach (var item in list.Where(x => ((ICanBeDirty)x).IsPropertyDirty("Published")))
|
|
{
|
|
SetWriter(item, userId);
|
|
repository.AddOrUpdate(item);
|
|
updated.Add(item);
|
|
}
|
|
|
|
uow.Commit();
|
|
|
|
foreach (var c in updated)
|
|
{
|
|
var xml = c.ToXml();
|
|
var poco = new ContentXmlDto { NodeId = c.Id, Xml = xml.ToString(SaveOptions.None) };
|
|
var exists = uow.Database.FirstOrDefault<ContentXmlDto>("WHERE nodeId = @Id", new { Id = c.Id }) !=
|
|
null;
|
|
int result = exists
|
|
? uow.Database.Update(poco)
|
|
: Convert.ToInt32(uow.Database.Insert(poco));
|
|
}
|
|
}
|
|
//Updating content to published state is finished, so we fire event through PublishingStrategy to have cache updated
|
|
if (omitCacheRefresh == false)
|
|
_publishingStrategy.PublishingFinalized(updated, true);
|
|
}
|
|
|
|
Audit.Add(AuditTypes.Publish, "RePublish All performed by user", userId == -1 ? 0 : userId, -1);
|
|
|
|
return published;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Publishes a <see cref="IContent"/> object and all its children
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
|
|
/// <param name="omitCacheRefresh">Optional boolean to avoid having the cache refreshed when calling this Publish method. By default this method will update the cache.</param>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <returns>True if publishing succeeded, otherwise False</returns>
|
|
private bool PublishWithChildrenDo(IContent content, bool omitCacheRefresh = false, int userId = -1)
|
|
{
|
|
//Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
|
|
if (content.ParentId != -1 && content.ParentId != -20 && IsPublishable(content) == false)
|
|
{
|
|
LogHelper.Info<ContentService>(
|
|
string.Format(
|
|
"Content '{0}' with Id '{1}' could not be published because its parent or one of its ancestors is not published.",
|
|
content.Name, content.Id));
|
|
return false;
|
|
}
|
|
|
|
//Content contains invalid property values and can therefore not be published - fire event?
|
|
if (!content.IsValid())
|
|
{
|
|
LogHelper.Info<ContentService>(
|
|
string.Format("Content '{0}' with Id '{1}' could not be published because of invalid properties.",
|
|
content.Name, content.Id));
|
|
return false;
|
|
}
|
|
|
|
//Consider creating a Path query instead of recursive method:
|
|
//var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(content.Path));
|
|
|
|
var updated = new List<IContent>();
|
|
var list = new List<IContent>();
|
|
list.Add(content);
|
|
list.AddRange(GetChildrenDeep(content.Id));
|
|
|
|
//Publish and then update the database with new status
|
|
var published = _publishingStrategy.PublishWithChildren(list, userId);
|
|
if (published)
|
|
{
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentRepository(uow))
|
|
{
|
|
//Only loop through content where the Published property has been updated
|
|
foreach (var item in list.Where(x => ((ICanBeDirty)x).IsPropertyDirty("Published")))
|
|
{
|
|
SetWriter(item, userId);
|
|
repository.AddOrUpdate(item);
|
|
updated.Add(item);
|
|
}
|
|
|
|
uow.Commit();
|
|
|
|
foreach (var c in updated)
|
|
{
|
|
var xml = c.ToXml();
|
|
var poco = new ContentXmlDto { NodeId = c.Id, Xml = xml.ToString(SaveOptions.None) };
|
|
var exists = uow.Database.FirstOrDefault<ContentXmlDto>("WHERE nodeId = @Id", new { Id = c.Id }) !=
|
|
null;
|
|
int result = exists
|
|
? uow.Database.Update(poco)
|
|
: Convert.ToInt32(uow.Database.Insert(poco));
|
|
}
|
|
}
|
|
//Save xml to db and call following method to fire event:
|
|
if (omitCacheRefresh == false)
|
|
_publishingStrategy.PublishingFinalized(updated, false);
|
|
|
|
Audit.Add(AuditTypes.Publish, "Publish with Children performed by user", userId == -1 ? 0 : userId,
|
|
content.Id);
|
|
}
|
|
|
|
return published;
|
|
}
|
|
|
|
/// <summary>
|
|
/// UnPublishes a single <see cref="IContent"/> object
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to publish</param>
|
|
/// <param name="omitCacheRefresh">Optional boolean to avoid having the cache refreshed when calling this Unpublish method. By default this method will update the cache.</param>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <returns>True if unpublishing succeeded, otherwise False</returns>
|
|
private bool UnPublishDo(IContent content, bool omitCacheRefresh = false, int userId = -1)
|
|
{
|
|
var unpublished = _publishingStrategy.UnPublish(content, userId);
|
|
if (unpublished)
|
|
{
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentRepository(uow))
|
|
{
|
|
repository.AddOrUpdate(content);
|
|
|
|
//Remove 'published' xml from the cmsContentXml table for the unpublished content
|
|
uow.Database.Delete<ContentXmlDto>("WHERE nodeId = @Id", new { Id = content.Id });
|
|
|
|
uow.Commit();
|
|
}
|
|
//Delete xml from db? and call following method to fire event through PublishingStrategy to update cache
|
|
if (omitCacheRefresh == false)
|
|
_publishingStrategy.UnPublishingFinalized(content);
|
|
|
|
Audit.Add(AuditTypes.UnPublish, "UnPublish performed by user", userId == -1 ? 0 : userId, content.Id);
|
|
}
|
|
|
|
return unpublished;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Saves and Publishes a single <see cref="IContent"/> object
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to save and publish</param>
|
|
/// <param name="omitCacheRefresh">Optional boolean to avoid having the cache refreshed when calling this Publish method. By default this method will update the cache.</param>
|
|
/// <param name="userId">Optional Id of the User issueing the publishing</param>
|
|
/// <returns>True if publishing succeeded, otherwise False</returns>
|
|
private bool SaveAndPublishDo(IContent content, bool omitCacheRefresh = false, int userId = -1)
|
|
{
|
|
if (Saving.IsRaisedEventCancelled(new SaveEventArgs<IContent>(content), this))
|
|
return false;
|
|
|
|
//Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
|
|
if (content.ParentId != -1 && content.ParentId != -20 && IsPublishable(content) == false)
|
|
{
|
|
LogHelper.Info<ContentService>(
|
|
string.Format(
|
|
"Content '{0}' with Id '{1}' could not be published because its parent is not published.",
|
|
content.Name, content.Id));
|
|
return false;
|
|
}
|
|
|
|
//Content contains invalid property values and can therefore not be published - fire event?
|
|
if (!content.IsValid())
|
|
{
|
|
LogHelper.Info<ContentService>(
|
|
string.Format(
|
|
"Content '{0}' with Id '{1}' could not be published because of invalid properties.",
|
|
content.Name, content.Id));
|
|
return false;
|
|
}
|
|
|
|
//Publish and then update the database with new status
|
|
bool published = _publishingStrategy.Publish(content, userId);
|
|
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentRepository(uow))
|
|
{
|
|
//Since this is the Save and Publish method, the content should be saved even though the publish fails or isn't allowed
|
|
SetWriter(content, userId);
|
|
repository.AddOrUpdate(content);
|
|
|
|
uow.Commit();
|
|
|
|
if (published)
|
|
{
|
|
var xml = content.ToXml();
|
|
var poco = new ContentXmlDto { NodeId = content.Id, Xml = xml.ToString(SaveOptions.None) };
|
|
var exists = uow.Database.FirstOrDefault<ContentXmlDto>("WHERE nodeId = @Id", new { Id = content.Id }) != null;
|
|
int result = exists
|
|
? uow.Database.Update(poco)
|
|
: Convert.ToInt32(uow.Database.Insert(poco));
|
|
}
|
|
}
|
|
|
|
Saved.RaiseEvent(new SaveEventArgs<IContent>(content, false), this);
|
|
|
|
//Save xml to db and call following method to fire event through PublishingStrategy to update cache
|
|
if (omitCacheRefresh == false)
|
|
_publishingStrategy.PublishingFinalized(content);
|
|
|
|
//We need to check if children and their publish state to ensure that we republish content that was previously published
|
|
if (HasChildren(content.Id))
|
|
{
|
|
var children = GetDescendants(content);
|
|
var shouldBeRepublished = children.Where(child => HasPublishedVersion(child.Id));
|
|
|
|
if (omitCacheRefresh == false)
|
|
_publishingStrategy.PublishingFinalized(shouldBeRepublished, false);
|
|
}
|
|
|
|
Audit.Add(AuditTypes.Publish, "Save and Publish performed by user", userId == -1 ? 0 : userId, content.Id);
|
|
|
|
return published;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Saves a single <see cref="IContent"/> object
|
|
/// </summary>
|
|
/// <param name="content">The <see cref="IContent"/> to save</param>
|
|
/// <param name="changeState">Boolean indicating whether or not to change the Published state upon saving</param>
|
|
/// <param name="userId">Optional Id of the User saving the Content</param>
|
|
private void Save(IContent content, bool changeState, int userId = -1)
|
|
{
|
|
if (Saving.IsRaisedEventCancelled(new SaveEventArgs<IContent>(content), this))
|
|
return;
|
|
|
|
var uow = _uowProvider.GetUnitOfWork();
|
|
using (var repository = _repositoryFactory.CreateContentRepository(uow))
|
|
{
|
|
SetWriter(content, userId);
|
|
|
|
//Only change the publish state if the "previous" version was actually published
|
|
if (changeState && content.Published)
|
|
content.ChangePublishedState(PublishedState.Saved);
|
|
|
|
repository.AddOrUpdate(content);
|
|
uow.Commit();
|
|
}
|
|
|
|
Saved.RaiseEvent(new SaveEventArgs<IContent>(content, false), this);
|
|
|
|
Audit.Add(AuditTypes.Save, "Save Content performed by user", userId == -1 ? 0 : userId, content.Id);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a flat list of decendents of content from parent id
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Only contains valid <see cref="IContent"/> objects, which means
|
|
/// that everything in the returned list can be published.
|
|
/// If an invalid <see cref="IContent"/> object is found it will not
|
|
/// be added to the list neither will its children.
|
|
/// </remarks>
|
|
/// <param name="parentId">Id of the parent to retrieve children from</param>
|
|
/// <returns>A list of valid <see cref="IContent"/> that can be published</returns>
|
|
private IEnumerable<IContent> GetChildrenDeep(int parentId)
|
|
{
|
|
var list = new List<IContent>();
|
|
var children = GetChildren(parentId);
|
|
foreach (var child in children)
|
|
{
|
|
if (child.IsValid())
|
|
{
|
|
list.Add(child);
|
|
list.AddRange(GetChildrenDeep(child.Id));
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the passed in <see cref="IContent"/> can be published based on the anscestors publish state.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Check current is only used when falling back to checking the Parent of non-saved content, as
|
|
/// non-saved content doesn't have a valid path yet.
|
|
/// </remarks>
|
|
/// <param name="content"><see cref="IContent"/> to check if anscestors are published</param>
|
|
/// <param name="checkCurrent">Boolean indicating whether the passed in content should also be checked for published versions</param>
|
|
/// <returns>True if the Content can be published, otherwise False</returns>
|
|
private bool IsPublishable(IContent content, bool checkCurrent)
|
|
{
|
|
var ids = content.Path.Split(',').Select(int.Parse).ToList();
|
|
foreach (var id in ids)
|
|
{
|
|
//If Id equals that of the recycle bin we return false because nothing in the bin can be published
|
|
if (id == -20)
|
|
return false;
|
|
|
|
//We don't check the System Root, so just continue
|
|
if (id == -1) continue;
|
|
|
|
//If the current id equals that of the passed in content and if current shouldn't be checked we skip it.
|
|
if (checkCurrent == false && id == content.Id) continue;
|
|
|
|
//Check if the content for the current id is published - escape the loop if we encounter content that isn't published
|
|
var hasPublishedVersion = HasPublishedVersion(id);
|
|
if (hasPublishedVersion == false)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates a content object with the User (id), who created the content.
|
|
/// </summary>
|
|
/// <param name="content"><see cref="IContent"/> object to update</param>
|
|
/// <param name="userId">Optional Id of the User</param>
|
|
private void SetUser(IContent content, int userId)
|
|
{
|
|
if (userId > -1)
|
|
{
|
|
//If a user id was passed in we use that
|
|
content.CreatorId = userId;
|
|
}
|
|
else if (UserServiceOrContext())
|
|
{
|
|
var profile = _httpContext == null
|
|
? _userService.GetCurrentBackOfficeUser()
|
|
: _userService.GetCurrentBackOfficeUser(_httpContext);
|
|
content.CreatorId = profile.Id.SafeCast<int>();
|
|
}
|
|
else
|
|
{
|
|
//Otherwise we default to Admin user, which should always exist (almost always)
|
|
content.CreatorId = 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates a content object with a Writer (user id), who updated the content.
|
|
/// </summary>
|
|
/// <param name="content"><see cref="IContent"/> object to update</param>
|
|
/// <param name="userId">Optional Id of the Writer</param>
|
|
private void SetWriter(IContent content, int userId)
|
|
{
|
|
if (userId > -1)
|
|
{
|
|
//If a user id was passed in we use that
|
|
content.WriterId = userId;
|
|
}
|
|
else if (UserServiceOrContext())
|
|
{
|
|
var profile = _httpContext == null
|
|
? _userService.GetCurrentBackOfficeUser()
|
|
: _userService.GetCurrentBackOfficeUser(_httpContext);
|
|
content.WriterId = profile.Id.SafeCast<int>();
|
|
}
|
|
else
|
|
{
|
|
//Otherwise we default to Admin user, which should always exist (almost always)
|
|
content.WriterId = 0;
|
|
}
|
|
}
|
|
|
|
private bool UserServiceOrContext()
|
|
{
|
|
return _userService != null && (HttpContext.Current != null || _httpContext != null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Event Handlers
|
|
/// <summary>
|
|
/// Occurs before Delete
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> Deleting;
|
|
|
|
/// <summary>
|
|
/// Occurs after Delete
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> Deleted;
|
|
|
|
/// <summary>
|
|
/// Occurs before Delete Versions
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, DeleteRevisionsEventArgs> DeletingVersions;
|
|
|
|
/// <summary>
|
|
/// Occurs after Delete Versions
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, DeleteRevisionsEventArgs> DeletedVersions;
|
|
|
|
/// <summary>
|
|
/// Occurs before Save
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> Saving;
|
|
|
|
/// <summary>
|
|
/// Occurs after Save
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> Saved;
|
|
|
|
/// <summary>
|
|
/// Occurs before Create
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, NewEventArgs<IContent>> Creating;
|
|
|
|
/// <summary>
|
|
/// Occurs after Create
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Please note that the Content object has been created, but not saved
|
|
/// so it does not have an identity yet (meaning no Id has been set).
|
|
/// </remarks>
|
|
public static event TypedEventHandler<IContentService, NewEventArgs<IContent>> Created;
|
|
|
|
/// <summary>
|
|
/// Occurs before Copy
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, CopyEventArgs<IContent>> Copying;
|
|
|
|
/// <summary>
|
|
/// Occurs after Copy
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, CopyEventArgs<IContent>> Copied;
|
|
|
|
/// <summary>
|
|
/// Occurs before Content is moved to Recycle Bin
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Trashing;
|
|
|
|
/// <summary>
|
|
/// Occurs after Content is moved to Recycle Bin
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Trashed;
|
|
|
|
/// <summary>
|
|
/// Occurs before Move
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Moving;
|
|
|
|
/// <summary>
|
|
/// Occurs after Move
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Moved;
|
|
|
|
/// <summary>
|
|
/// Occurs before Rollback
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, RollbackEventArgs<IContent>> RollingBack;
|
|
|
|
/// <summary>
|
|
/// Occurs after Rollback
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, RollbackEventArgs<IContent>> RolledBack;
|
|
|
|
/// <summary>
|
|
/// Occurs before Send to Publish
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, SendToPublishEventArgs<IContent>> SendingToPublish;
|
|
|
|
/// <summary>
|
|
/// Occurs after Send to Publish
|
|
/// </summary>
|
|
public static event TypedEventHandler<IContentService, SendToPublishEventArgs<IContent>> SentToPublish;
|
|
#endregion
|
|
}
|
|
} |