public static IDtoCapable GetAndPatchConcrete(this IDtoBase dto, IEnumerable <string> permittedFields = null)
{
var concrete = dto.GetConcrete();
dto.PatchConcrete(concrete, permittedFields);
// return....
return(concrete);
}
public static IDtoCapable ToConcrete(this IDtoBase dto)
{
var dtoType = dto.GetDtoType();
var concrete = dtoType.CreateConcreteInstance();
dto.PatchConcrete(concrete);
// return...
return(concrete);
}
internal override void SetValue(IDtoBase dto, object value)
{
if (HasChanged(_value, value))
{
_value = value;
this.NumChanges++;
}
// record...
this.NumTouches++;
}
public static IDtoCapable GetConcrete(this IDtoBase dto)
{
var type = DtoType.GetDtoType(dto.GetType());
if (dto.IsNew())
{
return(type.CreateConcreteInstance());
}
else
{
// load...
var item = (IDtoCapable)type.ConcreteEntityType.Persistence.GetById(new object[] { dto.Id }, OnNotFound.ReturnNull);
return(item);
}
}
internal override void SetValue(IDtoBase dto, object value)
{
// stage the values...
var existing = this.GetValue(dto);
value = this.Field.ConvertValueForSet(value);
// check...
if (HasChanged(existing, value))
{
this.Field.DtoProperty.SetValue(dto, value);
this.NumChanges++;
}
// add...
this.NumTouches++;
}
internal abstract void SetValue(IDtoBase dto, object value);
internal abstract object GetValue(IDtoBase dto);
public static T GetValue <T>(this IDtoBase dto, DtoField field)
{
return(ConversionHelper.ChangeType <T>(dto[field]));
}
public static T GetAndPatchConcrete <T>(this IDtoBase dto, IEnumerable <string> permittedFields = null)
where T : IDtoCapable
{
return((T)dto.GetAndPatchConcrete(permittedFields));
}
public static bool IsNew(this IDtoBase dto)
{
return(dto.Id == 0);
}
public static void PatchConcrete(this IDtoBase dto, IDtoCapable concrete, IEnumerable <string> permittedFields = null)
{
var dtoType = dto.GetDtoType();
// ok...
var wasNew = dto.IsNew();
concrete.OnPatching(dto, wasNew);
// if we don't have permitted fields, get them, but skip the key...
if (permittedFields == null)
{
var toUse = new List <string>();
var et = concrete.GetType().ToEntityType();
foreach (EntityField field in et.Fields)
{
if (!(field.IsKey()))
{
toUse.Add(field.Name);
}
}
// set...
permittedFields = toUse;
}
// walk...
var values = dto.GetTouchedValues();
foreach (var field in values.Keys)
{
var value = values[field];
// are we allowed to set it?
if (permittedFields.Contains(field.Name, StringComparer.InvariantCultureIgnoreCase))
{
// member...
var member = concrete.EntityType.GetMember(field.Name, OnNotFound.ReturnNull);
if (member != null)
{
var canSet = true;
if (member is EntityField && ((EntityField)member).IsKey())
{
canSet = false;
}
if (canSet)
{
member.SetValue(concrete, value, BootFX.Common.Entities.SetValueReason.UserSet);
}
}
else
{
var prop = concrete.EntityType.Type.GetProperty(field.Name, BindingFlags.Instance | BindingFlags.Public);
if (prop != null && prop.CanWrite)
{
try
{
prop.SetValue(concrete, value);
}
catch (Exception ex)
{
throw new InvalidOperationException(string.Format("Failed to set value '{0}' on '{1}'.\r\nValue: {2}", prop.Name, prop.DeclaringType.Name, value), ex);
}
}
else
{
// don't do anything in here -- this needs to be loose....
}
}
}
}
// signal...
concrete.OnPatched(dto, wasNew);
}
public static DtoType GetDtoType(this IDtoBase dto)
{
return(DtoType.GetDtoType(dto.GetType()));
}
protected void SetLink(IDtoBase dto, [CallerMemberName] string name = null)
{
var link = this.Type.GetLinkByName(name);
this.SetLink(link, dto);
}
public void SetLink(DtoLink link, IDtoBase dto)
{
this.Links[link].Dto = dto;
}
internal override object GetValue(IDtoBase dto)
{
return(this.Field.DtoProperty.GetValue(dto));
}
public static T ToConcrete <T>(this IDtoBase dto)
where T : IDtoCapable
{
return((T)dto.ToConcrete());
}
internal override object GetValue(IDtoBase dto)
{
return(_value);
}
