yv01p/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated EntityController to be consistent and now uses a new enum of all umbraco obj that should be accessible.

Browse Source
This commit is contained in:
Shannon
2013-09-18 15:00:32 +10:00
parent 422a22f150
commit 6155eb709a
3 changed files with 347 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

399
src/Umbraco.Web/Editors/EntityController.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.Net;
using System.Web.Http;
using System.Web.Http.Controllers;
using System.Web.Http.ModelBinding;
@@ -21,14 +22,14 @@ using Examine.SearchCriteria;
namespace Umbraco.Web.Editors
{
/// <summary>
/// API controller to deal with Macro data
/// </summary>
[PluginController("UmbracoApi")]
public class MacroController : UmbracoAuthorizedJsonController
{
}
///// <summary>
///// API controller to deal with Macro data
///// </summary>
//[PluginController("UmbracoApi")]
//public class MacroController : UmbracoAuthorizedJsonController
//{
// public EntityBasic Get
//}
/// <summary>
/// The API controller used for getting entity objects, basic name, icon, id representation of umbraco objects that are based on CMSNode
@@ -39,167 +40,293 @@ namespace Umbraco.Web.Editors
[PluginController("UmbracoApi")]
public class EntityController : UmbracoAuthorizedJsonController
{
[EnsureUserPermissionForContent("id")]
[UmbracoApplicationAuthorize(Constants.Applications.Content)]
public EntityBasic GetDocumentById(int id)
//[EnsureUserPermissionForContent("id")]
//[UmbracoApplicationAuthorize(Constants.Applications.Content)]
//public EntityBasic GetDocumentById(int id)
//{
// return Mapper.Map<EntityBasic>(Services.EntityService.Get(id, UmbracoObjectTypes.Document));
//}
//[EnsureUserPermissionForContent("id")]
//[UmbracoApplicationAuthorizeAttribute(Constants.Applications.Content)]
//[FilterAllowedOutgoingContent(typeof(IEnumerable<EntityBasic>))]
//public IEnumerable<EntityBasic> GetDocumentChildren(int id)
//{
// return GetChildren(id, UmbracoObjectTypes.Document);
//}
//[FilterAllowedOutgoingContent(typeof(IEnumerable<EntityBasic>))]
//[UmbracoApplicationAuthorizeAttribute(Constants.Applications.Content)]
//public IEnumerable<EntityBasic> GetDocumentsByIds([FromUri]int[] ids)
//{
// if (ids == null) throw new ArgumentNullException("ids");
// return GetEntitiesById(ids, UmbracoObjectTypes.Document);
//}
//[FilterAllowedOutgoingContent(typeof(IEnumerable<EntityBasic>))]
//[UmbracoApplicationAuthorizeAttribute(Constants.Applications.Content)]
//public IEnumerable<EntityBasic> SearchDocuments([FromUri]string query)
//{
// var internalSearcher = ExamineManager.Instance.SearchProviderCollection[Constants.Examine.InternalSearcher];
// var criteria = internalSearcher.CreateSearchCriteria("content", BooleanOperation.Or);
// var fields = new[] { "id", "__nodeName", "bodyText" };
// var term = new[] { query.ToLower().Escape() };
// var operation = criteria.GroupedOr(fields, term).Compile();
// var results = internalSearcher.Search(operation)
// .Select(x => int.Parse(x["id"]));
// return GetDocumentsByIds(results.ToArray());
//}
///// <summary>
///// The user must have access to either content or media for this to return data
///// </summary>
///// <param name="id"></param>
///// <returns></returns>
//[UmbracoApplicationAuthorizeAttribute(
// Constants.Applications.Media,
// Constants.Applications.Content)]
//[EnsureUserPermissionForMedia("id")]
//public EntityBasic GetMediaById(int id)
//{
// return GetEntityById(id, UmbracoObjectTypes.Media);
//}
///// <summary>
///// The user must have access to either content or media for this to return data
///// </summary>
///// <param name="id"></param>
///// <returns></returns>
//[UmbracoApplicationAuthorizeAttribute(
// Constants.Applications.Media,
// Constants.Applications.Content)]
//[EnsureUserPermissionForMedia("id")]
//[FilterAllowedOutgoingMedia(typeof(IEnumerable<EntityBasic>))]
//public IEnumerable<EntityBasic> GetMediaChildren(int id)
//{
// return GetChildren(id, UmbracoObjectTypes.Media);
//}
///// <summary>
///// The user must have access to either content or media for this to return data
///// </summary>
///// <param name="id"></param>
///// <returns></returns>
//[UmbracoApplicationAuthorizeAttribute(
// Constants.Applications.Media,
// Constants.Applications.Content)]
//[EnsureUserPermissionForMedia("id")]
//[FilterAllowedOutgoingMedia(typeof(IEnumerable<EntityBasic>))]
//public IEnumerable<EntityBasic> SearchMedia([FromUri]string query)
//{
// var internalSearcher = ExamineManager.Instance.SearchProviderCollection[Constants.Examine.InternalSearcher];
// var criteria = internalSearcher.CreateSearchCriteria("media", BooleanOperation.Or);
// var fields = new[] { "id", "__nodeName"};
// var term = new[] { query.ToLower().Escape() };
// var operation = criteria.GroupedOr(fields, term).Compile();
// var results = internalSearcher.Search(operation)
// .Select(x => int.Parse(x["id"]));
// return GetMediaByIds(results.ToArray());
//}
///// <summary>
///// The user must have access to either content or media for this to return data
///// </summary>
///// <param name="ids"></param>
///// <returns></returns>
//[UmbracoApplicationAuthorizeAttribute(
// Constants.Applications.Media,
// Constants.Applications.Content)]
//[FilterAllowedOutgoingMedia(typeof(IEnumerable<EntityBasic>))]
//public IEnumerable<EntityBasic> GetMediaByIds([FromUri]int[] ids)
//{
// if (ids == null) throw new ArgumentNullException("ids");
// return GetEntitiesById(ids, UmbracoObjectTypes.Media);
//}
public EntityBasic GetById(int id, UmbracoEntityTypes type)
{
return Mapper.Map<EntityBasic>(Services.EntityService.Get(id, UmbracoObjectTypes.Document));
return GetResultForId(id, type);
}
[EnsureUserPermissionForContent("id")]
[UmbracoApplicationAuthorizeAttribute(Constants.Applications.Content)]
[FilterAllowedOutgoingContent(typeof(IEnumerable<EntityBasic>))]
public IEnumerable<EntityBasic> GetDocumentChildren(int id)
public IEnumerable<EntityBasic> GetByIds([FromUri]int[] ids, UmbracoEntityTypes type)
{
return GetChildren(id, UmbracoObjectTypes.Document);
if (ids == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return GetResultForIds(ids, type);
}
[FilterAllowedOutgoingContent(typeof(IEnumerable<EntityBasic>))]
[UmbracoApplicationAuthorizeAttribute(Constants.Applications.Content)]
public IEnumerable<EntityBasic> GetDocumentsByIds([FromUri]int[] ids)
public IEnumerable<EntityBasic> GetChildren(int id, UmbracoEntityTypes type)
{
if (ids == null) throw new ArgumentNullException("ids");
return GetEntitiesById(ids, UmbracoObjectTypes.Document);
return GetResultForChildren(id, type);
}
[FilterAllowedOutgoingContent(typeof(IEnumerable<EntityBasic>))]
[UmbracoApplicationAuthorizeAttribute(Constants.Applications.Content)]
public IEnumerable<EntityBasic> SearchDocuments([FromUri]string query)
public IEnumerable<EntityBasic> GetAncestors(int id, UmbracoEntityTypes type)
{
var internalSearcher = ExamineManager.Instance.SearchProviderCollection[Constants.Examine.InternalSearcher];
var criteria = internalSearcher.CreateSearchCriteria("content", BooleanOperation.Or);
var fields = new[] { "id", "__nodeName", "bodyText" };
var term = new[] { query.ToLower().Escape() };
var operation = criteria.GroupedOr(fields, term).Compile();
var results = internalSearcher.Search(operation)
.Select(x => int.Parse(x["id"]));
return GetDocumentsByIds(results.ToArray());
return GetResultForAncestors(id, type);
}
/// <summary>
/// The user must have access to either content or media for this to return data
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[UmbracoApplicationAuthorizeAttribute(
Constants.Applications.Media,
Constants.Applications.Content)]
[EnsureUserPermissionForMedia("id")]
public EntityBasic GetMediaById(int id)
public IEnumerable<EntityBasic> GetAll(UmbracoEntityTypes type)
{
return GetEntityById(id, UmbracoObjectTypes.Media);
return GetResultForAll(type);
}
/// <summary>
/// The user must have access to either content or media for this to return data
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[UmbracoApplicationAuthorizeAttribute(
Constants.Applications.Media,
Constants.Applications.Content)]
[EnsureUserPermissionForMedia("id")]
[FilterAllowedOutgoingMedia(typeof(IEnumerable<EntityBasic>))]
public IEnumerable<EntityBasic> GetMediaChildren(int id)
private IEnumerable<EntityBasic> GetResultForChildren(int id, UmbracoEntityTypes entityType)
{
return GetChildren(id, UmbracoObjectTypes.Media);
var objectType = ConvertToObjectType(entityType);
if (objectType.HasValue)
{
//TODO: Need to check for Object types that support heirarchy here, some might not.
return Services.EntityService.GetChildren(id).Select(Mapper.Map<EntityBasic>);
}
//now we need to convert the unknown ones
switch (entityType)
{
case UmbracoEntityTypes.Domain:
case UmbracoEntityTypes.Language:
case UmbracoEntityTypes.User:
case UmbracoEntityTypes.Macro:
default:
throw new NotSupportedException("The " + typeof(EntityController) + " does not currently support data for the type " + entityType);
}
}
/// <summary>
/// The user must have access to either content or media for this to return data
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[UmbracoApplicationAuthorizeAttribute(
Constants.Applications.Media,
Constants.Applications.Content)]
[EnsureUserPermissionForMedia("id")]
[FilterAllowedOutgoingMedia(typeof(IEnumerable<EntityBasic>))]
public IEnumerable<EntityBasic> SearchMedia([FromUri]string query)
private IEnumerable<EntityBasic> GetResultForAncestors(int id, UmbracoEntityTypes entityType)
{
var internalSearcher = ExamineManager.Instance.SearchProviderCollection[Constants.Examine.InternalSearcher];
var criteria = internalSearcher.CreateSearchCriteria("media", BooleanOperation.Or);
var fields = new[] { "id", "__nodeName"};
var term = new[] { query.ToLower().Escape() };
var operation = criteria.GroupedOr(fields, term).Compile();
var objectType = ConvertToObjectType(entityType);
if (objectType.HasValue)
{
//TODO: Need to check for Object types that support heirarchy here, some might not.
var results = internalSearcher.Search(operation)
.Select(x => int.Parse(x["id"]));
var ids = Services.EntityService.Get(id).Path.Split(',').Select(int.Parse);
return ids.Select(m => Mapper.Map<EntityBasic>(Services.EntityService.Get(m)));
}
//now we need to convert the unknown ones
switch (entityType)
{
case UmbracoEntityTypes.Domain:
return GetMediaByIds(results.ToArray());
case UmbracoEntityTypes.Language:
case UmbracoEntityTypes.User:
case UmbracoEntityTypes.Macro:
default:
throw new NotSupportedException("The " + typeof(EntityController) + " does not currently support data for the type " + entityType);
}
}
/// <summary>
/// The user must have access to either content or media for this to return data
/// </summary>
/// <param name="ids"></param>
/// <returns></returns>
[UmbracoApplicationAuthorizeAttribute(
Constants.Applications.Media,
Constants.Applications.Content)]
[FilterAllowedOutgoingMedia(typeof(IEnumerable<EntityBasic>))]
public IEnumerable<EntityBasic> GetMediaByIds([FromUri]int[] ids)
private IEnumerable<EntityBasic> GetResultForAll(UmbracoEntityTypes entityType)
{
if (ids == null) throw new ArgumentNullException("ids");
return GetEntitiesById(ids, UmbracoObjectTypes.Media);
var objectType = ConvertToObjectType(entityType);
if (objectType.HasValue)
{
return Services.EntityService.GetAll(objectType.Value).Select(Mapper.Map<EntityBasic>);
}
//now we need to convert the unknown ones
switch (entityType)
{
case UmbracoEntityTypes.Domain:
case UmbracoEntityTypes.Language:
case UmbracoEntityTypes.User:
case UmbracoEntityTypes.Macro:
default:
throw new NotSupportedException("The " + typeof(EntityController) + " does not currently support data for the type " + entityType);
}
}
//TODO: Need to add app level security for all of this below
public EntityBasic GetById(int id, UmbracoObjectTypes? type = null)
private IEnumerable<EntityBasic> GetResultForIds(IEnumerable<int> ids, UmbracoEntityTypes entityType)
{
return type == null
? Mapper.Map<EntityBasic>(Services.EntityService.Get(id))
: GetEntityById(id, type.Value);
var objectType = ConvertToObjectType(entityType);
if (objectType.HasValue)
{
return ids.Select(id => Mapper.Map<EntityBasic>(Services.EntityService.Get(id)));
}
//now we need to convert the unknown ones
switch (entityType)
{
case UmbracoEntityTypes.Domain:
case UmbracoEntityTypes.Language:
case UmbracoEntityTypes.User:
case UmbracoEntityTypes.Macro:
default:
throw new NotSupportedException("The " + typeof(EntityController) + " does not currently support data for the type " + entityType);
}
}
public IEnumerable<EntityBasic> GetByIds([FromUri]int[] ids, UmbracoObjectTypes? type = null)
private EntityBasic GetResultForId(int id, UmbracoEntityTypes entityType)
{
if (ids == null) throw new ArgumentNullException("ids");
return type == null
? ids.Select(id => Mapper.Map<EntityBasic>(Services.EntityService.Get(id)))
: GetEntitiesById(ids, type.Value);
var objectType = ConvertToObjectType(entityType);
if (objectType.HasValue)
{
return Mapper.Map<EntityBasic>(Services.EntityService.Get(id, objectType.Value));
}
//now we need to convert the unknown ones
switch (entityType)
{
case UmbracoEntityTypes.Domain:
case UmbracoEntityTypes.Language:
case UmbracoEntityTypes.User:
case UmbracoEntityTypes.Macro:
default:
throw new NotSupportedException("The " + typeof(EntityController) + " does not currently support data for the type " + entityType);
}
}
public IEnumerable<EntityBasic> GetChildren(int id, UmbracoObjectTypes? type = null)
private static UmbracoObjectTypes? ConvertToObjectType(UmbracoEntityTypes entityType)
{
return type == null
? Services.EntityService.GetChildren(id).Select(Mapper.Map<EntityBasic>)
: GetChildren(id, type.Value);
}
public IEnumerable<EntityBasic> GetAncestors(int id, string type = null)
{
var ids = Services.EntityService.Get(id).Path.Split(',').Select(int.Parse);
return string.IsNullOrEmpty(type)
? ids.Select(m => Mapper.Map<EntityBasic>(Services.EntityService.Get(m)))
: GetEntitiesById(ids.ToArray(), (UmbracoObjectTypes)Enum.Parse(typeof(UmbracoObjectTypes),type) );
}
public IEnumerable<EntityBasic> GetAll(UmbracoObjectTypes type = UmbracoObjectTypes.Document)
{
return Services.EntityService.GetAll(type).Select(Mapper.Map<EntityBasic>);
}
private EntityBasic GetEntityById(int id, UmbracoObjectTypes type)
{
return Mapper.Map<EntityBasic>(Services.EntityService.Get(id, type));
}
private IEnumerable<EntityBasic> GetChildren(int id, UmbracoObjectTypes type)
{
return Services.EntityService.GetChildren(id, type).Select(Mapper.Map<EntityBasic>);
}
private IEnumerable<EntityBasic> GetEntitiesById(IEnumerable<int> ids, UmbracoObjectTypes type)
{
if (ids == null) throw new ArgumentNullException("ids");
return ids.Select(id => Mapper.Map<EntityBasic>(Services.EntityService.Get(id, type)));
switch (entityType)
{
case UmbracoEntityTypes.Document:
return UmbracoObjectTypes.Document;
case UmbracoEntityTypes.Media:
return UmbracoObjectTypes.Media;
case UmbracoEntityTypes.MemberType:
return UmbracoObjectTypes.MediaType;
case UmbracoEntityTypes.Template:
return UmbracoObjectTypes.Template;
case UmbracoEntityTypes.MemberGroup:
return UmbracoObjectTypes.MemberGroup;
case UmbracoEntityTypes.ContentItem:
return UmbracoObjectTypes.ContentItem;
case UmbracoEntityTypes.MediaType:
return UmbracoObjectTypes.MediaType;
case UmbracoEntityTypes.DocumentType:
return UmbracoObjectTypes.DocumentType;
case UmbracoEntityTypes.Stylesheet:
return UmbracoObjectTypes.Stylesheet;
case UmbracoEntityTypes.Member:
return UmbracoObjectTypes.Member;
case UmbracoEntityTypes.DataType:
return UmbracoObjectTypes.DataType;
default:
//There is no UmbracoEntity conversion (things like Macros, Users, etc...)
return null;
}
}
}

83
src/Umbraco.Web/Models/ContentEditing/UmbracoEntityTypes.cs Normal file
View File

@@ -0,0 +1,83 @@
namespace Umbraco.Web.Models.ContentEditing
{
/// <summary>
/// Represents the type's of Umbraco entities that can be resolved from the EntityController
/// </summary>
public enum UmbracoEntityTypes
{
/// <summary>
/// Domain
/// </summary>
Domain,
/// <summary>
/// Language
/// </summary>
Language,
/// <summary>
/// User
/// </summary>
User,
/// <summary>
/// Macro
/// </summary>
Macro,
/// <summary>
/// Document
/// </summary>
Document,
/// <summary>
/// Media
/// </summary>
Media,
/// <summary>
/// Member Type
/// </summary>
MemberType,
/// <summary>
/// Template
/// </summary>
Template,
/// <summary>
/// Member Group
/// </summary>
MemberGroup,
/// <summary>
/// Content Item
/// </summary>
ContentItem,
/// <summary>
/// "Media Type
/// </summary>
MediaType,
/// <summary>
/// Document Type
/// </summary>
DocumentType,
/// <summary>
/// Stylesheet
/// </summary>
Stylesheet,
/// <summary>
/// Member
/// </summary>
Member,
/// <summary>
/// Data Type
/// </summary>
DataType
}
}

1
src/Umbraco.Web/Umbraco.Web.csproj
View File

@@ -303,6 +303,7 @@
<Compile Include="Editors\DashboardController.cs" />
<Compile Include="Editors\DataTypeController.cs" />
<Compile Include="Editors\DataTypeValidateAttribute.cs" />
<Compile Include="Models\ContentEditing\UmbracoEntityTypes.cs" />
<Compile Include="PropertyEditors\RteEmbedController.cs" />
<Compile Include="Editors\EntityController.cs" />
<Compile Include="Editors\MediaPostValidateAttribute.cs" />