private void applyToProperty(object model, PropertyInfo property, IBindManager binder, string prefix, string remainder)
{
// If (after taking the prefix into account) this is a complex property change
// Recurse, using the object referred to by the first part of the property name
// as the new model to apply the change to.
if (split(remainder).Count() > 1)
{
var value = getValue(model, property);
applyTo(value, binder, property.PropertyType, ExpressionHelper.Join(prefix, property.Name));
}
// Otherwise, if we are now at a simple property change, just bind the value
// and set the appropriate property
else
{
var existingValue = property.GetValue(model, null);
var value = binder.Bind(wrapped.Value, property.PropertyType, existingValue);
if (isEntityCollection(property) && existingValue != null)
{
// do nothing, its contents were already updated by the binder,
// and it's an error to use the property setter for an entity collection
}
else
{
property.SetValue(model, value, null);
}
}
}
public CollectionTranslator(IBindManager bindManager,
ISerializationManager serializationManager, IHistoryContext db)
{
this.bindManager = bindManager;
this.serializationManager = serializationManager;
this.db = db;
}
public HistoryExplorer(IHistoryContext<TChangeSet, TPrincipal> historyContext, IBindManager binder = null,
HistoryExplorerCloneStrategies cloneStrategy = HistoryExplorerCloneStrategies.Default)
{
this.binder = (binder ?? new ValueTranslationManager(historyContext));
this.cloneStrategy = cloneStrategy;
this.historyContext = historyContext;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="dataProvider">DataProvider</param>
/// <param name="planManager">Execute plan Manager</param>
/// <param name="bindManager">Bind Manager</param>
/// <param name="mappingManager">Mapping Manager</param>
/// <param name="typeRegister">Types register</param>
public GenericDomainsRepository(IDataProvider dataProvider, IExecutionPlanManager planManager,
IBindManager bindManager, IMappingManager mappingManager,
ITypeRegister typeRegister)
{
this._dataProvider = dataProvider;
this._planManager = planManager;
this._bindManager = bindManager;
this._mappingManager = mappingManager;
this._typeRegister = typeRegister;
this._mapedType = this._mappingManager.GetMapping(typeof(T));
}
private void applyTo(object model, IBindManager binder, Type modelType, string prefix)
{
string remainder = stripPrefix(prefix);
var propertyParts = split(remainder);
string propertyName = propertyParts.First();
var property = modelType.GetProperty(propertyName, BindingFlags.Public
| BindingFlags.NonPublic | BindingFlags.Instance);
if (property != null)
{
applyToProperty(model, property, binder, prefix, remainder);
}
else
{
throw new UnknownPropertyInLogException <TPrincipal>(wrapped);
}
}
/// <summary>
/// Apply the property change to the given model.
/// So if the IPropertyChange has property name "Foo", then model.Foo
/// will be set to the bound value of the IPropertyChange's value.
/// </summary>
/// <param name="prefix">
/// The prefix is used to apply a property change to an object that is an intermediate
/// part of a complex property change. For example, if you have a property change
/// "Foo.Bar", that relates to an object change on an object of type Example. To
/// apply the property change directly to the Example object, you would use an empty
/// prefix: "". However, if you instead had the object referenced by Example.Foo, you
/// could apply the property change directly to Foo, by using the prefix "Foo". Then,
/// this method will treat the property change as if it's name were just "Bar",
/// removing the "Foo." prefix.
/// </param>
public void ApplyTo <TModel>(TModel model, IBindManager binder, string prefix)
{
applyTo(model, binder, typeof(TModel), prefix);
}
public NullableBinder(IBindManager bindManager)
{
this.bindManager = bindManager;
}
public NullableBinder(IBindManager bindManager)
{
this.bindManager = bindManager;
}
