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

added readonly view to support showing value from legacy data types.

Browse Source
This commit is contained in:
Shannon
2013-06-10 17:12:59 -02:00
parent 711cc3629b
commit e750fda197
4 changed files with 165 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/Umbraco.Web.UI.Client/src/views/propertyeditors/umbraco/readonlyvalue/readonlyvalue.html Normal file
View File

@@ -0,0 +1,3 @@
<p>
{{model.value|json}}
</p>

4
src/Umbraco.Web.UI/App_Plugins/MyPackage/Package.manifest
View File

@@ -1,10 +1,10 @@
{
propertyEditors: [
propertyEditors: [
{
id: "30CA72BD-A349-4386-B935-FA532DF24B4B",
name: "Rich Text Editor",
editor: {
view: "~/umbraco/Views/propertyeditors/rte/rte.html"
view: "~/umbraco/Views/propertyeditors/umbraco/rte/editor.html"
}
},
{

3
src/Umbraco.Web.UI/umbraco/Views/propertyeditors/rte/rte.html
View File

@@ -1,3 +0,0 @@
<div ng-controller="Umbraco.Editors.RTEController" class="span7">
<textarea ng-model="model.value" rows="10" id="{{model.alias}}_rte"></textarea>
</div>

160
src/Umbraco.Web/Models/Mapping/BaseContentModelMapper.cs Normal file
View File

@@ -0,0 +1,160 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Umbraco.Core;
using Umbraco.Core.Configuration;
using Umbraco.Core.Models;
using Umbraco.Core.PropertyEditors;
using Umbraco.Web.Models.ContentEditing;
namespace Umbraco.Web.Models.Mapping
{
internal class BaseContentModelMapper
{
protected ApplicationContext ApplicationContext { get; private set; }
protected ProfileModelMapper ProfileMapper { get; private set; }
public BaseContentModelMapper(ApplicationContext applicationContext, ProfileModelMapper profileMapper)
{
ApplicationContext = applicationContext;
ProfileMapper = profileMapper;
}
protected ContentItemDto ToContentItemDtoBase(IContentBase content)
{
return CreateContent<ContentItemDto, ContentPropertyDto>(content, null, (propertyDto, originalProperty, propEditor) =>
{
propertyDto.Alias = originalProperty.Alias;
propertyDto.Description = originalProperty.PropertyType.Description;
propertyDto.Label = originalProperty.PropertyType.Name;
propertyDto.DataType = ApplicationContext.Services.DataTypeService.GetDataTypeDefinitionById(originalProperty.PropertyType.DataTypeDefinitionId);
propertyDto.PropertyEditor = PropertyEditorResolver.Current.GetById(originalProperty.PropertyType.DataTypeId);
});
}
protected ContentItemBasic<ContentPropertyBasic> ToContentItemSimpleBase(IContentBase content)
{
return CreateContent<ContentItemBasic<ContentPropertyBasic>, ContentPropertyBasic>(content, null, null);
}
protected IList<Tab<ContentPropertyDisplay>> GetTabs(IContentBase content)
{
var tabs = content.PropertyGroups.Select(propertyGroup =>
{
//get the properties for the current tab
var propertiesForTab = content.GetPropertiesForGroup(propertyGroup).ToArray();
//convert the properties to ContentPropertyDisplay objects
var displayProperties = propertiesForTab
.Select(ToContentPropertyDisplay);
//return the tab with the tab properties
return new Tab<ContentPropertyDisplay>
{
Id = propertyGroup.Id,
Alias = propertyGroup.Name,
Label = propertyGroup.Name,
Properties = displayProperties
};
}).ToList();
//now add the generic properties tab for any properties that don't belong to a tab
var orphanProperties = content.GetNonGroupedProperties();
//now add the generic properties tab
tabs.Add(new Tab<ContentPropertyDisplay>
{
Id = 0,
Label = "Generic properties",
Alias = "Generic properties",
Properties = orphanProperties.Select(ToContentPropertyDisplay).ToArray()
});
return tabs;
}
protected TContent CreateContent<TContent, TContentProperty>(IContentBase content,
Action<TContent, IContentBase> contentCreatedCallback = null,
Action<TContentProperty, Property, PropertyEditor> propertyCreatedCallback = null,
bool createProperties = true)
where TContent : ContentItemBasic<TContentProperty>, new()
where TContentProperty : ContentPropertyBasic, new()
{
var result = new TContent
{
Id = content.Id,
Owner = ProfileMapper.ToBasicUser(content.GetCreatorProfile()),
ParentId = content.ParentId,
UpdateDate = content.UpdateDate,
CreateDate = content.CreateDate,
Name = content.Name
};
if (createProperties)
result.Properties = content.Properties.Select(p => CreateProperty(p, propertyCreatedCallback)).ToArray();
if (contentCreatedCallback != null)
contentCreatedCallback(result, content);
return result;
}
protected ContentPropertyDisplay ToContentPropertyDisplay(Property property)
{
return CreateProperty<ContentPropertyDisplay>(property, (display, originalProp, propEditor) =>
{
//set the display properties after mapping
display.Alias = originalProp.Alias;
display.Description = originalProp.PropertyType.Description;
display.Label = property.PropertyType.Name;
display.Config = ApplicationContext.Services.DataTypeService.GetPreValuesByDataTypeId(property.PropertyType.DataTypeDefinitionId);
if (propEditor == null)
{
//if there is no property editor it means that it is a legacy data type
// we cannot support editing with that so we'll just render the readonly value view.
display.View = GlobalSettings.Path.EnsureEndsWith('/') + "views/propertyeditors/umbraco/readonlyvalue/readonlyvalue.html";
}
});
}
/// <summary>
/// Creates the property with the basic property values mapped
/// </summary>
/// <typeparam name="TContentProperty"></typeparam>
/// <param name="property"></param>
/// <param name="callback"></param>
/// <returns></returns>
protected static TContentProperty CreateProperty<TContentProperty>(
Property property,
Action<TContentProperty, Property, PropertyEditor> callback = null)
where TContentProperty : ContentPropertyBasic, new()
{
var editor = PropertyEditorResolver.Current.GetById(property.PropertyType.DataTypeId);
if (editor == null)
{
//TODO: Remove this check as we shouldn't support this at all!
var legacyEditor = DataTypesResolver.Current.GetById(property.PropertyType.DataTypeId);
if (legacyEditor == null)
{
throw new NullReferenceException("The property editor with id " + property.PropertyType.DataTypeId + " does not exist");
}
var legacyResult = new TContentProperty
{
Id = property.Id,
Value = property.Value.ToString(),
Alias = property.Alias
};
if (callback != null) callback(legacyResult, property, null);
return legacyResult;
}
var result = new TContentProperty
{
Id = property.Id,
Value = editor.ValueEditor.SerializeValue(property.Value),
Alias = property.Alias
};
if (callback != null) callback(result, property, editor);
return result;
}
}
}