private void SetPropertyValueOnModel(object objectInstance, PropertyRegistration registration, object umbracoStoredValue)
{
if (registration.DataType.ConverterType != null)
{
IDataTypeConverter converter = (IDataTypeConverter)Activator.CreateInstance(registration.DataType.ConverterType);
var val = converter.Create(umbracoStoredValue, x => CodeFirstModelContext.MoveNextContext(x, registration));
if (val != null)
{
CodeFirstModelContext.MoveNextContext(val, registration);
var attr = registration.Metadata.GetCodeFirstAttribute <ContentPropertyAttribute>();
if (attr != null && attr is IDataTypeRedirect)
{
val = (attr as IDataTypeRedirect).GetRedirectedValue(val);
if (val != null)
{
//Keep a second context so wrapped types can still find their property
//Will add nothing if the Redirector registered a context already (e.g. called ConvertToModel to create the value).
//Hopefully said redirector passed in a parent context so the converted value can still find its way back here.
CodeFirstModelContext.MoveNextContext(val, registration);
}
}
registration.Metadata.SetValue(objectInstance, val);
}
}
else if (umbracoStoredValue != null)
{
//Context currently not supported for PEVCs - many are value types, very unlikely to have unique hashes for all values in a request context, none except custom ones would have
//code to use the context anyway.
registration.Metadata.SetValue(objectInstance, umbracoStoredValue);
}
}
public IList <T> ToObjects <T>(DataRow[] dataRows, IDataTypeConverter dataTypeConverter, ExtendedPropertyInfo[] mappings, DataTableParserSettings settings)
{
Guard.ArgumentNotNull(dataRows);
Guard.ArgumentNotNull(dataTypeConverter);
Guard.ArgumentNotNull(mappings);
Guard.ArgumentNotNull(settings);
List <T> objectList = new List <T>(capacity: dataRows.Length);
var dbNullConverter = new DbNullConverter(settings);
IEnumerable <DelegateColumnMapping <T> > delegates = GetDelegatesForType <T>(mappings);
for (int rowIndex = 0; rowIndex < dataRows.Length; rowIndex++)
{
T returnObject = ObjectInstantiator <T> .CreateNew();
foreach (var setterDelegate in delegates)
{
object value = dataTypeConverter.FieldToObject(dataRows[rowIndex][setterDelegate.ExtendedPropertyInfo.ColumnIndex], setterDelegate.ExtendedPropertyInfo.PropertyInfo.PropertyType, settings, dbNullConverter);
setterDelegate.SetterDelegate(returnObject, value);
}
objectList.Add(returnObject);
}
return(objectList);
}
public virtual IList <T> ToObjects <T>(DataRow[] dataRows,
IDataTypeConverter dataTypeConverter,
ExtendedPropertyInfo[] mappings,
DataTableParserSettings settings)
{
Guard.ArgumentNotNull(dataRows);
Guard.ArgumentNotNull(dataTypeConverter);
Guard.ArgumentNotNull(mappings);
Guard.ArgumentNotNull(settings);
var dbNullConverter = GetDbNullConverter(settings);
var objectList = new T[dataRows.Length];
for (int rowIndex = 0; rowIndex < dataRows.Length; rowIndex++)
{
var returnObject = ObjectInstantiator <T> .CreateNew();
foreach (var mapping in mappings)
{
object value = dataTypeConverter.FieldToObject(dataRows[rowIndex][mapping.ColumnIndex],
mapping.PropertyInfo.PropertyType,
settings,
dbNullConverter);
mapping.PropertyInfo.SetValue(returnObject, value);
}
objectList[rowIndex] = returnObject;
}
return(objectList);
}
public IList <T> ToObjects <T>(DataRow[] dataRows, IDataTypeConverter dataTypeConverter, ExtendedPropertyInfo[] mappings, DataTableParserSettings settings)
{
Guard.ArgumentNotNull(dataRows);
Guard.ArgumentNotNull(dataTypeConverter);
Guard.ArgumentNotNull(mappings);
Guard.ArgumentNotNull(settings);
ConcurrentBag <T> objectList = new ConcurrentBag <T>();
var dbNullConverter = new DbNullConverter(settings);
Parallel.For(0, dataRows.Length, (rowIndex) =>
{
T returnObject = ObjectInstantiator <T> .CreateNew();
foreach (var mapping in mappings)
{
object value = dataTypeConverter.FieldToObject(dataRows[rowIndex][mapping.ColumnIndex], mapping.PropertyInfo.PropertyType, settings, dbNullConverter);
mapping.PropertyInfo.SetValue(returnObject, value);
}
objectList.Add(returnObject);
});
return(objectList.ToList());
}
protected void SetPropertyOnContent(IContentBase content, PropertyRegistration property, object propertyValue)
{
object convertedValue;
if (property.DataType.ConverterType != null)
{
object toConvert;
var attr = property.Metadata.GetCodeFirstAttribute <ContentPropertyAttribute>();
if (attr != null && attr is IDataTypeRedirect)
{
toConvert = (attr as IDataTypeRedirect).GetOriginalDataTypeObject(propertyValue);
}
else
{
toConvert = propertyValue;
}
IDataTypeConverter converter = (IDataTypeConverter)Activator.CreateInstance(property.DataType.ConverterType);
convertedValue = converter.Serialise(toConvert);
}
else if (!property.DataType.CodeFirstControlled && property.DataType.DbType == DatabaseType.None)
{
throw new CodeFirstException("Cannot persist PEVC-based properties or use events which attempt to persist PEVC-based properties. " + Environment.NewLine +
"PEVCs only support retrieving a value from IPublishedContent & cannot persist a property back to IContent." + Environment.NewLine +
"Property: " + property.Metadata.DeclaringType.FullName + "." + property.Name);
}
else
{
//No converter is given so we push the value back into umbraco as is (this will fail in many cases for PEVC properties)
convertedValue = propertyValue;
}
content.SetValue(property.Alias, convertedValue);
}
public AttributeTypeRepository(IConnectionProvider connectionProvider, IDataTypeConverter dataTypeConverter,
IEntityAttributeTypeRepository entityAttributeTypeRepository)
{
_connectionProvider = connectionProvider;
_dataTypeConverter = dataTypeConverter;
_entityAttributeTypeRepository = entityAttributeTypeRepository;
}
public WhereParser(IDataTypeConverter dataTypeConverter)
{
Ensure.That(dataTypeConverter, "dataTypeConverter").IsNotNull();
DataTypeConverter = dataTypeConverter;
_lock = new object();
VirtualPrefixMembers = new List<MemberExpression>();
}
public WhereParser(IDataTypeConverter dataTypeConverter)
{
Ensure.That(dataTypeConverter, "dataTypeConverter").IsNotNull();
DataTypeConverter = dataTypeConverter;
_lock = new object();
VirtualPrefixMembers = new List <MemberExpression>();
}
public ConversionManager(DataTableParserSettings dataTableParserSettings,
IMappingResolver mappingResolver,
IDataTableResolver dataTableResolver,
IDataTypeConverter dataTypeConverter)
{
this.dataTableParserSettings = dataTableParserSettings;
this.mappingResolver = mappingResolver;
this.dataTableResolver = dataTableResolver;
this.dataTypeConverter = dataTypeConverter;
}
public AutoStructureSchemaBuilder()
{
DataTypeConverter = new DataTypeConverter();
}
public IList <T> ToObjects <T>(DataRow[] dataRows, IDataTypeConverter dataTypeConverter, ExtendedPropertyInfo[] mappings, DataTableParserSettings settings)
{
return(new List <T>());
}
public AutoStructureSchemaBuilder()
{
DataTypeConverter = new DataTypeConverter();
}
public ExpressionParsers(IDataTypeConverter dataTypeConverter)
{
IncludeParser = new IncludeParser(dataTypeConverter);
WhereParser = new WhereParser(dataTypeConverter);
OrderByParser = new OrderByParser(dataTypeConverter);
}
public OrderByParser(IDataTypeConverter dataTypeConverter)
{
Ensure.That(dataTypeConverter, "dataTypeConverter").IsNotNull();
DataTypeConverter = dataTypeConverter;
}
public StructureSchemaFactory(IDataTypeConverter dataTypeConverter = null)
{
DataTypeConverter = dataTypeConverter ?? new DataTypeConverter();
}
public OrderByParser(IDataTypeConverter dataTypeConverter)
{
Ensure.That(dataTypeConverter, "dataTypeConverter").IsNotNull();
DataTypeConverter = dataTypeConverter;
}
public ExpressionParsers(IDataTypeConverter dataTypeConverter)
{
WhereParser = new WhereParser(dataTypeConverter);
OrderByParser = new OrderByParser(dataTypeConverter);
}
public ColumnAggregate(SourceMap sourceMap, IDataTypeConverter converter, IDataLoader loader)
{
_sourceMap = sourceMap;
_converter = converter;
_loader = loader;
}
protected override void OnFixtureInitialize()
{
_converter = new DataTypeConverter();
}
private static IStructureSchemaFactory CreateSut(IDataTypeConverter converter = null) => new StructureSchemaFactory(converter ?? Mock.Of <IDataTypeConverter>());
protected override void OnFixtureInitialize()
{
_converter = new DataTypeConverter();
}
public DataTypeConverterTests()
{
_converter = new DataTypeConverter();
}
