/// <inheritdoc />
public IEntitySlim Get(Guid key, UmbracoObjectTypes objectType)
{
using (ScopeProvider.CreateScope(autoComplete: true))
{
return(_entityRepository.Get(key, objectType.GetGuid()));
}
}
/// <summary>
/// Returns a paged collection of descendants
/// </summary>
/// <param name="id"></param>
/// <param name="umbracoObjectType"></param>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="totalRecords"></param>
/// <param name="orderBy"></param>
/// <param name="orderDirection"></param>
/// <param name="filter"></param>
/// <returns></returns>
public IEnumerable <IUmbracoEntity> GetPagedDescendants(int id, UmbracoObjectTypes umbracoObjectType, long pageIndex, int pageSize, out long totalRecords,
string orderBy = "path", Direction orderDirection = Direction.Ascending, string filter = "")
{
var objectTypeId = umbracoObjectType.GetGuid();
using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
{
var repository = RepositoryFactory.CreateEntityRepository(uow);
var query = Query <IUmbracoEntity> .Builder;
//if the id is System Root, then just get all
if (id != Constants.System.Root)
{
//lookup the path so we can use it in the prefix query below
var itemPaths = repository.GetAllPaths(objectTypeId, id).ToArray();
if (itemPaths.Length == 0)
{
totalRecords = 0;
return(Enumerable.Empty <IUmbracoEntity>());
}
var itemPath = itemPaths[0].Path;
query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", itemPath), TextColumnType.NVarchar));
}
IQuery <IUmbracoEntity> filterQuery = null;
if (filter.IsNullOrWhiteSpace() == false)
{
filterQuery = Query <IUmbracoEntity> .Builder.Where(x => x.Name.Contains(filter));
}
var contents = repository.GetPagedResultsByQuery(query, objectTypeId, pageIndex, pageSize, out totalRecords, orderBy, orderDirection, filterQuery);
return(contents);
}
}
/// <summary>
/// Returns a paged collection of descendants
/// </summary>
/// <param name="id"></param>
/// <param name="umbracoObjectType"></param>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="totalRecords"></param>
/// <param name="orderBy"></param>
/// <param name="orderDirection"></param>
/// <param name="filter"></param>
/// <returns></returns>
public IEnumerable <IUmbracoEntity> GetPagedDescendants(int id, UmbracoObjectTypes umbracoObjectType, long pageIndex, int pageSize, out long totalRecords,
string orderBy = "path", Direction orderDirection = Direction.Ascending, string filter = "")
{
var objectTypeId = umbracoObjectType.GetGuid();
using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
{
var repository = RepositoryFactory.CreateEntityRepository(uow);
var query = Query <IUmbracoEntity> .Builder;
//if the id is System Root, then just get all
if (id != Constants.System.Root)
{
query.Where(x => x.Path.SqlContains(string.Format(",{0},", id), TextColumnType.NVarchar));
}
IQuery <IUmbracoEntity> filterQuery = null;
if (filter.IsNullOrWhiteSpace() == false)
{
filterQuery = Query <IUmbracoEntity> .Builder.Where(x => x.Name.Contains(filter));
}
var contents = repository.GetPagedResultsByQuery(query, objectTypeId, pageIndex, pageSize, out totalRecords, orderBy, orderDirection, filterQuery);
return(contents);
}
}
/// <inheritdoc />
public virtual IEnumerable <IEntitySlim> GetRootEntities(UmbracoObjectTypes objectType)
{
using (ScopeProvider.CreateScope(autoComplete: true))
{
return(_entityRepository.GetByQuery(QueryRootEntity, objectType.GetGuid()));
}
}
/// <summary>
/// Returns a paged collection of descendants from the root
/// </summary>
/// <param name="umbracoObjectType"></param>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="totalRecords"></param>
/// <param name="orderBy"></param>
/// <param name="orderDirection"></param>
/// <param name="filter"></param>
/// <param name="includeTrashed">true/false to include trashed objects</param>
/// <returns></returns>
public IEnumerable <IUmbracoEntity> GetPagedDescendantsFromRoot(UmbracoObjectTypes umbracoObjectType, long pageIndex, int pageSize, out long totalRecords,
string orderBy = "path", Direction orderDirection = Direction.Ascending, string filter = "", bool includeTrashed = true)
{
var objectTypeId = umbracoObjectType.GetGuid();
using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
{
var repository = RepositoryFactory.CreateEntityRepository(uow);
var query = Query <IUmbracoEntity> .Builder;
//don't include trashed if specfied
if (includeTrashed == false)
{
query.Where(x => x.Trashed == false);
}
IQuery <IUmbracoEntity> filterQuery = null;
if (filter.IsNullOrWhiteSpace() == false)
{
filterQuery = Query <IUmbracoEntity> .Builder.Where(x => x.Name.Contains(filter));
}
var contents = repository.GetPagedResultsByQuery(query, objectTypeId, pageIndex, pageSize, out totalRecords, orderBy, orderDirection, filterQuery);
return(contents);
}
}
/// <inheritdoc />
public virtual IEnumerable <IEntitySlim> GetChildren(int parentId, UmbracoObjectTypes objectType)
{
using (ScopeProvider.CreateScope(autoComplete: true))
{
var query = Query <IUmbracoEntity>().Where(x => x.ParentId == parentId);
return(_entityRepository.GetByQuery(query, objectType.GetGuid()));
}
}
/// <summary>
/// Returns a paged collection of descendants.
/// </summary>
public IEnumerable <IUmbracoEntity> GetPagedDescendants(IEnumerable <int> ids, UmbracoObjectTypes umbracoObjectType, long pageIndex, int pageSize, out long totalRecords,
string orderBy = "path", Direction orderDirection = Direction.Ascending, string filter = "")
{
totalRecords = 0;
var idsA = ids.ToArray();
if (idsA.Length == 0)
{
return(Enumerable.Empty <IUmbracoEntity>());
}
var objectTypeId = umbracoObjectType.GetGuid();
using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
{
var repository = RepositoryFactory.CreateEntityRepository(uow);
var query = Query <IUmbracoEntity> .Builder;
if (idsA.All(x => x != Constants.System.Root))
{
//lookup the paths so we can use it in the prefix query below
var itemPaths = repository.GetAllPaths(objectTypeId, idsA).ToArray();
if (itemPaths.Length == 0)
{
totalRecords = 0;
return(Enumerable.Empty <IUmbracoEntity>());
}
var clauses = new List <Expression <Func <IUmbracoEntity, bool> > >();
foreach (var id in idsA)
{
//if the id is root then don't add any clauses
if (id != Constants.System.Root)
{
var itemPath = itemPaths.FirstOrDefault(x => x.Id == id);
if (itemPath == null)
{
continue;
}
var path = itemPath.Path;
var qid = id;
clauses.Add(x => x.Path.SqlStartsWith(string.Format("{0},", path), TextColumnType.NVarchar) || x.Path.SqlEndsWith(string.Format(",{0}", qid), TextColumnType.NVarchar));
}
}
query.WhereAny(clauses);
}
IQuery <IUmbracoEntity> filterQuery = null;
if (filter.IsNullOrWhiteSpace() == false)
{
filterQuery = Query <IUmbracoEntity> .Builder.Where(x => x.Name.Contains(filter));
}
var contents = repository.GetPagedResultsByQuery(query, objectTypeId, pageIndex, pageSize, out totalRecords, orderBy, orderDirection, filterQuery);
return(contents);
}
}
/// <inheritdoc />
public virtual IEnumerable <IEntitySlim> GetDescendants(int id, UmbracoObjectTypes objectType)
{
using (ScopeProvider.CreateScope(autoComplete: true))
{
var entity = _entityRepository.Get(id);
var query = Query <IUmbracoEntity>().Where(x => x.Path.StartsWith(entity.Path) && x.Id != id);
return(_entityRepository.GetByQuery(query, objectType.GetGuid()));
}
}
/// <inheritdoc />
public IEnumerable <IEntitySlim> GetPagedChildren(int id, UmbracoObjectTypes objectType, long pageIndex, int pageSize, out long totalRecords,
IQuery <IUmbracoEntity> filter = null, Ordering ordering = null)
{
using (ScopeProvider.CreateScope(autoComplete: true))
{
var query = Query <IUmbracoEntity>().Where(x => x.ParentId == id && x.Trashed == false);
return(_entityRepository.GetPagedResultsByQuery(query, objectType.GetGuid(), pageIndex, pageSize, out totalRecords, filter, ordering));
}
}
private static Guid GetNodeObjectTypeGuid(UmbracoObjectTypes umbracoObjectType)
{
var guid = umbracoObjectType.GetGuid();
if (guid == Guid.Empty)
{
throw new NotSupportedException("Unsupported object type (" + umbracoObjectType + ").");
}
return(guid);
}
/// <inheritdoc />
public IEnumerable <IEntitySlim> GetAll(UmbracoObjectTypes objectType, Guid[] keys)
{
var entityType = objectType.GetClrType();
GetObjectType(entityType);
using (ScopeProvider.CreateScope(autoComplete: true))
{
return(_entityRepository.GetAll(objectType.GetGuid(), keys));
}
}
/// <summary>
/// Gets an UmbracoEntity by its Id and UmbracoObjectType, and optionally loads the complete object graph.
/// </summary>
/// <returns>
/// By default this will load the base type <see cref="IUmbracoEntity"/> with a minimum set of properties.
/// </returns>
/// <param name="id">Id of the object to retrieve</param>
/// <param name="umbracoObjectType">UmbracoObjectType of the entity to retrieve</param>
// <returns>An <see cref="IUmbracoEntity"/></returns>
public virtual IUmbracoEntity Get(int id, UmbracoObjectTypes umbracoObjectType)
{
var objectTypeId = umbracoObjectType.GetGuid();
using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
{
var repository = RepositoryFactory.CreateEntityRepository(uow);
var ret = repository.Get(id, objectTypeId);
return(ret);
}
}
/// <inheritdoc />
public virtual IEnumerable <TreeEntityPath> GetAllPaths(UmbracoObjectTypes objectType, params Guid[] keys)
{
var entityType = objectType.GetClrType();
GetObjectType(entityType);
using (ScopeProvider.CreateScope(autoComplete: true))
{
return(_entityRepository.GetAllPaths(objectType.GetGuid(), keys));
}
}
/// <summary>
/// Gets a collection of children by the parents Id and UmbracoObjectType
/// </summary>
/// <param name="parentId">Id of the parent to retrieve children for</param>
/// <param name="umbracoObjectType">UmbracoObjectType of the children to retrieve</param>
/// <returns>An enumerable list of <see cref="IUmbracoEntity"/> objects</returns>
public virtual IEnumerable <IUmbracoEntity> GetChildren(int parentId, UmbracoObjectTypes umbracoObjectType)
{
var objectTypeId = umbracoObjectType.GetGuid();
using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
{
var repository = RepositoryFactory.CreateEntityRepository(uow);
var query = Query <IUmbracoEntity> .Builder.Where(x => x.ParentId == parentId);
return(repository.GetByQuery(query, objectTypeId));
}
}
/// <inheritdoc />
public virtual IEntitySlim GetParent(int id, UmbracoObjectTypes objectType)
{
using (ScopeProvider.CreateScope(autoComplete: true))
{
var entity = _entityRepository.Get(id);
if (entity.ParentId == -1 || entity.ParentId == -20 || entity.ParentId == -21)
{
return(null);
}
return(_entityRepository.Get(entity.ParentId, objectType.GetGuid()));
}
}
/// <summary>
/// Gets a collection of the entities at the root, which corresponds to the entities with a Parent Id of -1.
/// </summary>
/// <param name="umbracoObjectType">UmbracoObjectType of the root entities to retrieve</param>
/// <returns>An enumerable list of <see cref="IUmbracoEntity"/> objects</returns>
public virtual IEnumerable <IUmbracoEntity> GetRootEntities(UmbracoObjectTypes umbracoObjectType)
{
var objectTypeId = umbracoObjectType.GetGuid();
using (var repository = _repositoryFactory.CreateEntityRepository(_uowProvider.GetUnitOfWork()))
{
var query = Query <IUmbracoEntity> .Builder.Where(x => x.ParentId == -1);
var entities = repository.GetByQuery(query, objectTypeId);
return(entities);
}
}
/// <summary>
/// Gets the parent of entity by its id and UmbracoObjectType
/// </summary>
/// <param name="id">Id of the entity to retrieve the Parent for</param>
/// <param name="umbracoObjectType">UmbracoObjectType of the parent to retrieve</param>
/// <returns>An <see cref="IUmbracoEntity"/></returns>
public virtual IUmbracoEntity GetParent(int id, UmbracoObjectTypes umbracoObjectType)
{
using (var repository = _repositoryFactory.CreateEntityRepository(_uowProvider.GetUnitOfWork()))
{
var entity = repository.Get(id);
if (entity.ParentId == -1 || entity.ParentId == -20 || entity.ParentId == -21)
{
return(null);
}
var objectTypeId = umbracoObjectType.GetGuid();
return(repository.Get(entity.ParentId, objectTypeId));
}
}
/// <summary>
/// Gets a collection of descendents by the parents Id
/// </summary>
/// <param name="id">Id of entity to retrieve descendents for</param>
/// <param name="umbracoObjectType">UmbracoObjectType of the descendents to retrieve</param>
/// <returns>An enumerable list of <see cref="IUmbracoEntity"/> objects</returns>
public virtual IEnumerable <IUmbracoEntity> GetDescendents(int id, UmbracoObjectTypes umbracoObjectType)
{
var objectTypeId = umbracoObjectType.GetGuid();
using (var repository = _repositoryFactory.CreateEntityRepository(_uowProvider.GetUnitOfWork()))
{
var entity = repository.Get(id);
var query = Query <IUmbracoEntity> .Builder.Where(x => x.Path.StartsWith(entity.Path) && x.Id != id);
var entities = repository.GetByQuery(query, objectTypeId);
return(entities);
}
}
/// <inheritdoc />
public IEnumerable <IEntitySlim> GetPagedDescendants(IEnumerable <int> ids, UmbracoObjectTypes objectType, long pageIndex, int pageSize, out long totalRecords,
IQuery <IUmbracoEntity> filter = null, Ordering ordering = null)
{
totalRecords = 0;
var idsA = ids.ToArray();
if (idsA.Length == 0)
{
return(Enumerable.Empty <IEntitySlim>());
}
using (ScopeProvider.CreateScope(autoComplete: true))
{
var objectTypeGuid = objectType.GetGuid();
var query = Query <IUmbracoEntity>();
if (idsA.All(x => x != Constants.System.Root))
{
var paths = _entityRepository.GetAllPaths(objectTypeGuid, idsA).ToArray();
if (paths.Length == 0)
{
totalRecords = 0;
return(Enumerable.Empty <IEntitySlim>());
}
var clauses = new List <Expression <Func <IUmbracoEntity, bool> > >();
foreach (var id in idsA)
{
// if the id is root then don't add any clauses
if (id == Constants.System.Root)
{
continue;
}
var entityPath = paths.FirstOrDefault(x => x.Id == id);
if (entityPath == null)
{
continue;
}
var path = entityPath.Path;
var qid = id;
clauses.Add(x => x.Path.SqlStartsWith(path + ",", TextColumnType.NVarchar) || x.Path.SqlEndsWith("," + qid, TextColumnType.NVarchar));
}
query.WhereAny(clauses);
}
return(_entityRepository.GetPagedResultsByQuery(query, objectTypeGuid, pageIndex, pageSize, out totalRecords, filter, ordering));
}
}
/// <inheritdoc />
public IEnumerable <IEntitySlim> GetPagedDescendants(UmbracoObjectTypes objectType, long pageIndex, int pageSize, out long totalRecords,
IQuery <IUmbracoEntity> filter = null, Ordering ordering = null, bool includeTrashed = true)
{
using (ScopeProvider.CreateScope(autoComplete: true))
{
var query = Query <IUmbracoEntity>();
if (includeTrashed == false)
{
query.Where(x => x.Trashed == false);
}
return(_entityRepository.GetPagedResultsByQuery(query, objectType.GetGuid(), pageIndex, pageSize, out totalRecords, filter, ordering));
}
}
/// <inheritdoc />
public virtual IEnumerable <IEntitySlim> GetAll(UmbracoObjectTypes objectType, params int[] ids)
{
var entityType = objectType.GetClrType();
if (entityType == null)
{
throw new NotSupportedException($"Type \"{objectType}\" is not supported here.");
}
GetObjectType(entityType);
using (ScopeProvider.CreateScope(autoComplete: true))
{
return(_entityRepository.GetAll(objectType.GetGuid(), ids));
}
}
/// <summary>
/// Gets a collection of the entities at the root, which corresponds to the entities with a Parent Id of -1.
/// </summary>
/// <param name="umbracoObjectType">UmbracoObjectType of the root entities to retrieve</param>
/// <returns>An enumerable list of <see cref="IUmbracoEntity"/> objects</returns>
public virtual IEnumerable <IUmbracoEntity> GetRootEntities(UmbracoObjectTypes umbracoObjectType)
{
//create it once if it is needed (no need for locking here)
if (_rootEntityQuery == null)
{
_rootEntityQuery = Query <IUmbracoEntity> .Builder.Where(x => x.ParentId == -1);
}
var objectTypeId = umbracoObjectType.GetGuid();
using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
{
var repository = RepositoryFactory.CreateEntityRepository(uow);
var entities = repository.GetByQuery(_rootEntityQuery, objectTypeId);
return(entities);
}
}
/// <summary>
/// Gets an UmbracoEntity by its Id and UmbracoObjectType, and optionally loads the complete object graph.
/// </summary>
/// <returns>
/// By default this will load the base type <see cref="IUmbracoEntity"/> with a minimum set of properties.
/// </returns>
/// <param name="id">Id of the object to retrieve</param>
/// <param name="umbracoObjectType">UmbracoObjectType of the entity to retrieve</param>
/// <param name="loadBaseType">Optional bool to load the complete object graph when set to <c>False</c>.</param>
/// <returns>An <see cref="IUmbracoEntity"/></returns>
public virtual IUmbracoEntity Get(int id, UmbracoObjectTypes umbracoObjectType, bool loadBaseType = true)
{
if (loadBaseType)
{
var objectTypeId = umbracoObjectType.GetGuid();
using (var repository = _repositoryFactory.CreateEntityRepository(_uowProvider.GetUnitOfWork()))
{
return(repository.Get(id, objectTypeId));
}
}
var entityType = GetEntityType(umbracoObjectType);
var typeFullName = entityType.FullName;
var entity = _supportedObjectTypes[typeFullName].Item2(id);
return(entity);
}
/// <summary>
/// Gets a collection of all <see cref="IUmbracoEntity"/> of a given type.
/// </summary>
/// <param name="umbracoObjectType">UmbracoObjectType of the entities to return</param>
/// <returns>An enumerable list of <see cref="IUmbracoEntity"/> objects</returns>
public virtual IEnumerable <IUmbracoEntity> GetAll(UmbracoObjectTypes umbracoObjectType)
{
var entityType = GetEntityType(umbracoObjectType);
var typeFullName = entityType.FullName;
Mandate.That <NotSupportedException>(_supportedObjectTypes.ContainsKey(typeFullName), () =>
{
throw new NotSupportedException
("The passed in type is not supported");
});
var objectTypeId = umbracoObjectType.GetGuid();
using (var repository = _repositoryFactory.CreateEntityRepository(_uowProvider.GetUnitOfWork()))
{
return(repository.GetAll(objectTypeId));
}
}
public virtual IEnumerable <EntityPath> GetAllPaths(UmbracoObjectTypes umbracoObjectType, params Guid[] keys)
{
var entityType = GetEntityType(umbracoObjectType);
var typeFullName = entityType.FullName;
Mandate.That <NotSupportedException>(_supportedObjectTypes.ContainsKey(typeFullName), () =>
{
throw new NotSupportedException
("The passed in type is not supported");
});
var objectTypeId = umbracoObjectType.GetGuid();
using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
{
var repository = RepositoryFactory.CreateEntityRepository(uow);
return(repository.GetAllPaths(objectTypeId, keys));
}
}
public IUmbracoEntity GetByKey(Guid key, UmbracoObjectTypes umbracoObjectType, bool loadBaseType = true)
{
if (loadBaseType)
{
var objectTypeId = umbracoObjectType.GetGuid();
using (var repository = RepositoryFactory.CreateEntityRepository(UowProvider.GetUnitOfWork()))
{
return(repository.GetByKey(key, objectTypeId));
}
}
//SD: TODO: Need to enable this at some stage ... just need to ask Morten what the deal is with what this does.
throw new NotSupportedException();
//var entityType = GetEntityType(umbracoObjectType);
//var typeFullName = entityType.FullName;
//var entity = _supportedObjectTypes[typeFullName].Item2(id);
//return entity;
}
/// <summary>
/// Returns a paged collection of children
/// </summary>
/// <param name="parentId">The parent id to return children for</param>
/// <param name="umbracoObjectType"></param>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="totalRecords"></param>
/// <param name="orderBy"></param>
/// <param name="orderDirection"></param>
/// <param name="filter"></param>
/// <returns></returns>
public IEnumerable <IUmbracoEntity> GetPagedChildren(int parentId, UmbracoObjectTypes umbracoObjectType, long pageIndex, int pageSize, out long totalRecords,
string orderBy = "SortOrder", Direction orderDirection = Direction.Ascending, string filter = "")
{
var objectTypeId = umbracoObjectType.GetGuid();
using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
{
var repository = RepositoryFactory.CreateEntityRepository(uow);
var query = Query <IUmbracoEntity> .Builder.Where(x => x.ParentId == parentId && x.Trashed == false);
IQuery <IUmbracoEntity> filterQuery = null;
if (filter.IsNullOrWhiteSpace() == false)
{
filterQuery = Query <IUmbracoEntity> .Builder.Where(x => x.Name.Contains(filter));
}
var contents = repository.GetPagedResultsByQuery(query, objectTypeId, pageIndex, pageSize, out totalRecords, orderBy, orderDirection, filterQuery);
return(contents);
}
}
/// <inheritdoc />
public IEnumerable <IEntitySlim> GetPagedDescendants(int id, UmbracoObjectTypes objectType, long pageIndex, int pageSize, out long totalRecords,
IQuery <IUmbracoEntity> filter = null, Ordering ordering = null)
{
using (ScopeProvider.CreateScope(autoComplete: true))
{
var objectTypeGuid = objectType.GetGuid();
var query = Query <IUmbracoEntity>();
if (id != Constants.System.Root)
{
// lookup the path so we can use it in the prefix query below
var paths = _entityRepository.GetAllPaths(objectTypeGuid, id).ToArray();
if (paths.Length == 0)
{
totalRecords = 0;
return(Enumerable.Empty <IEntitySlim>());
}
var path = paths[0].Path;
query.Where(x => x.Path.SqlStartsWith(path + ",", TextColumnType.NVarchar));
}
return(_entityRepository.GetPagedResultsByQuery(query, objectTypeGuid, pageIndex, pageSize, out totalRecords, filter, ordering));
}
}
