private static int CheckGroupKey <T>(CommandResult data, Property propData, IMapperMain <T> entryPoint)
{
var propName = propData.GroupingProperty?.ColumnName ?? propData.PrimaryKeyProperty?.ColumnName;
if (string.IsNullOrWhiteSpace(propName))
{
return(-1); //No Groupping or Primary Key property was found
}
var val = data.Columns[propName];
foreach (var prop in entryPoint.Groups)
{
if (prop.Name == propName && prop.Value.Equals(val))
{
return(prop.Index);
}
}
entryPoint.Groups.Add(new GrouppingProperties
{
Name = propName,
Value = val,
Index = entryPoint.ItemsList.Count
});
return(-1);
}
public void Map <T, TMapper>(T model, CommandResult data, Property propData, IMapperMain <TMapper> entryPoint)
{
if (data.ResultSetIndex != propData.ResultSetIndex)
{
return;
}
var obj = Activator.CreateInstance(propData.UnderlyingType);
var properties = propData.UnderlyingType.GetTypeProperties(ExcludeTypes.Select, propData);
foreach (var property in properties)
{
property.Mapper.Map(obj, data, property, entryPoint);
}
propData.SetPropertyValue(model, obj);
}
public void Map <T, TMapper>(T model, CommandResult data, Property propData, IMapperMain <TMapper> entryPoint)
{
if (data.ResultSetIndex != propData.ResultSetIndex)
{
return;
}
var keyIndex = CheckGroupKey(data, propData, entryPoint);
if (keyIndex > -1)
{
AddDataToExistingRecord(keyIndex, data, propData, entryPoint);
entryPoint.AddToItems = false;
}
else
{
AddDataToNewRecord(model, data, propData, entryPoint);
}
}
public void Map <T, TMapper>(T model, CommandResult data, Property propData, IMapperMain <TMapper> entryPoint)
{
if (data.ResultSetIndex != propData.ResultSetIndex)
{
return;
}
if (propData.IsValueFromOutputParameter)
{
var parameter = GetParameterByName(data.Parameters, propData.ParameterName);
if (parameter != null)
{
SetPropertyValue(model, propData, parameter.Value);
}
}
else
{
SetPropertyValue(model, propData, data.Columns[propData.ColumnName]);
}
}
public void Map <T, TMapper>(T model, CommandResult data, Property propData, IMapperMain <TMapper> entryPoint)
{
if (data.ResultSetIndex != propData.ResultSetIndex)
{
return;
}
var instance = CheckGroupKey(model, data, propData, entryPoint);
if (instance != null)
{
AddDataToExistingRecord(instance, data, propData, entryPoint);
entryPoint.AddToItems = false;
// ReSharper disable once RedundantAssignment
model = (T)instance;
}
else
{
AddDataToNewRecord(model, data, propData, entryPoint);
}
}
private static void AddDataToExistingRecord <TMapper>(int index, CommandResult data, Property propData, IMapperMain <TMapper> entryPoint)
{
var underlyingType = propData.UnderlyingTypeInfo.GetGenericArguments()[0];
var classInstance = Activator.CreateInstance(underlyingType);
var classPropertyData = new Property {
UnderlyingType = underlyingType, ResultSetIndex = propData.ResultSetIndex
};
ClassMapper.Instance.MapForList(classInstance, data, classPropertyData, entryPoint);
var record = entryPoint.ItemsList[index];
var listProperty = record.GetType().GetTypeInfo().GetProperty(propData.PropertyName);
propData.UnderlyingTypeInfo.GetMethod("Add").Invoke(listProperty.GetValue(record, null), new[] { classInstance });
}
private static void AddDataToNewRecord <T, TMapper>(T model, CommandResult data, Property propData, IMapperMain <TMapper> entryPoint)
{
var underlyingType = propData.UnderlyingTypeInfo.GetGenericArguments()[0];
var returnList = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(underlyingType), 50);
returnList.AddFromList(model, propData);
var classInstance = Activator.CreateInstance(underlyingType);
var classPropertyData = new Property {
UnderlyingType = underlyingType, ResultSetIndex = propData.ResultSetIndex
};
ClassMapper.Instance.MapForList(classInstance, data, classPropertyData, entryPoint);
returnList.Add(classInstance);
propData.PropertyInfo.SetValue(model, returnList, null);
}
public void MapForList <T, TMapper>(T classInstance, CommandResult data, Property propData, IMapperMain <TMapper> entryPoint)
{
if (data.ResultSetIndex != propData.ResultSetIndex)
{
return;
}
var properties = propData.UnderlyingType.GetTypeProperties(ExcludeTypes.Select, propData);
foreach (var property in properties)
{
property.Mapper.Map(classInstance, data, property, entryPoint);
}
}
private static void AddDataToExistingRecord <T, TMapper>(T model, CommandResult data, Property propData, IMapperMain <TMapper> entryPoint)
{
var underlyingType = propData.UnderlyingTypeInfo.GetGenericArguments()[0];
var classInstance = Activator.CreateInstance(underlyingType);
var classPropertyData = new Property {
UnderlyingType = underlyingType, ResultSetIndex = propData.ResultSetIndex
};
ClassMapper.Instance.MapForList(classInstance, data, classPropertyData, entryPoint);
if (!entryPoint.AddToItems)
{
return;
}
var listProperty = model.GetType().GetTypeInfo().GetProperty(propData.PropertyName);
if (listProperty != null)
{
propData.UnderlyingTypeInfo.GetMethod("Add").Invoke(listProperty.GetValue(model, null), new[] { classInstance });
}
}
private static object CheckGroupKey <T, TMapper>(T model, CommandResult data, Property propData, IMapperMain <TMapper> entryPoint)
{
var propName = propData.GroupingProperty?.ColumnName ?? propData.PrimaryKeyProperty?.ColumnName;
if (string.IsNullOrWhiteSpace(propName))
{
return(null); //No Groupping or Primary Key property was found
}
var val = data.Columns[propName];
foreach (var prop in entryPoint.Groups)
{
if (prop.Name == propName && prop.Value.Equals(val))
{
return(prop.Instance);
}
}
entryPoint.Groups.Add(new GrouppingProperties
{
Name = propName,
Value = val,
Instance = model
});
return(null);
}
