private static object HandleDiffrentTypes(ResolveModel sourceResolve, ResolveModel targetResolve, object value)
{
object result;
if (targetResolve.IsGenericModel)
{
result = HandleGenericModel(targetResolve, value);
}
else if (sourceResolve.IsGenericModel)
{
var method = sourceResolve.MapToMethod;
var methodType = method.MakeGenericMethod(targetResolve.PropertyType);
result = methodType.Invoke(value, new object[] { null });
}
else if (targetResolve.IsEnum || sourceResolve.IsEnum)
{
return(value);
}
else
{
var message =
string.Format(
"At least source or target need to be of type IGenericModel, source propertey is of type {0}, target propertey is of type {1}",
sourceResolve.PropertyType, targetResolve.PropertyType);
throw new Exception(message);
}
return(result);
}
private static object HandleEnumerables(ResolveModel sourceResolve, ResolveModel targetResolve, TypeEquality typeEquality, object value)
{
var result = value;
MethodInfo method = null;
if (typeEquality.AreEnumerablesTypesEquel)
{
if (sourceResolve.IsEnumerableTypeGenericModel)
{
method = sourceResolve.PropertyType.GetMethod("MapListOfModels",
new[] { targetResolve.PropertyType });
method = method.MakeGenericMethod(targetResolve.EnumerableTypes.First());
}
else if (targetResolve.IsEnumerableTypeGenericModel)
{
method =
typeof(GenericModel).GetMethods()
.Where(m => m.Name == "MapListOfModels")
.First(m => m.GetGenericArguments().Count() == 2);
method = method.MakeGenericMethod(sourceResolve.EnumerableTypes.First(),
targetResolve.EnumerableTypes.First());
}
else if (typeEquality.AreEnumerablesTypesSimple)
{
return(result);
}
else
{
var message =
string.Format(
"At least source or target need to be of type IGenericModel, source propertey is of type {0}, target propertey is of type {1}",
sourceResolve.PropertyType, targetResolve.PropertyType);
throw new Exception(message);
}
result = method.Invoke(null, new[] { value });
}
else
{
if (targetResolve.IsEnumerableTypeEnum && sourceResolve.IsEnumerableTypeNumeric ||
targetResolve.IsEnumerableTypeNumeric && sourceResolve.IsEnumerableTypeEnum)
{
var targetType = targetResolve.EnumerableTypes.First();
method = typeof(GenericModel).GetMethod("ConvertEnumerable", BindingFlags.NonPublic | BindingFlags.Static);
var generic = method.MakeGenericMethod(targetType);
result = generic.Invoke(null, new[] { value });
return(result);
}
}
return(result);
}
public ActionResult Resolve(FormCollection formValues)
{
var model = new ResolveModel();
if (TryUpdateModel(model))
{
var certs = Repository.Resolve(model.Owner, model.ShowData);
if (certs.Count() > 0)
{
return(View("ResolveResult",
Mapper.Map <IEnumerable <Certificate>, IEnumerable <CertificateModel> >(certs)));
}
ModelState.AddModelError("Owner", "No certificates found for this owner.");
}
return(View(model));
}
private static void MapObject <TResult>(object source, TResult target)
{
var sourceType = source.GetType();
var targetType = typeof(TResult);
var targetProperties = targetType.GetProperties().ToList();
var sourceProperties = sourceType.GetProperties().ToList();
foreach (var sourceProperty in sourceProperties)
{
var targetResolve = ResolveTarget(targetProperties, sourceProperty);
var sourceResolve = new ResolveModel(sourceProperty);
if (null == targetResolve.PropertyInfo || !targetResolve.CanWrite)
{
continue;
}
var value = sourceResolve.PropertyInfo.GetValue(source);
var typeEquality = CheckTypes(sourceResolve, targetResolve);
if (typeEquality.IsTargetString)
{
value = value.ToString();
}
else if (typeEquality.AreEnumerables)
{
value = HandleEnumerables(sourceResolve, targetResolve, typeEquality, value);
}
else if (!typeEquality.AreEquel)
{
value = HandleDiffrentTypes(sourceResolve, targetResolve, value);
}
targetResolve.PropertyInfo.SetValue(target, value, null);
}
}
public ActionResult Resolve(ResolveModel model)
{
return(View(model));
}
private static TypeEquality CheckTypes(ResolveModel source, ResolveModel target)
{
var typeEquality = new TypeEquality(source, target);
return(typeEquality);
}
private static object HandleDiffrentTypes(ResolveModel sourceResolve, ResolveModel targetResolve, object value)
{
throw new NotImplementedException();
}
private static TResult MapObject <TResult>(object source)
{
// Create an instance of the result object
var target = Activator.CreateInstance <TResult>();
var sourceType = source.GetType();
var targetType = typeof(TResult);
var targetProperties = targetType.GetProperties().ToList();
var sourceProperties = sourceType.GetProperties().ToList();
foreach (var sourceProperty in sourceProperties)
{
var targetResolve = ResolveTarget(targetProperties, sourceProperty);
var sourceResolve = new ResolveModel(sourceProperty);
if (null != targetResolve.PropertyInfo && targetResolve.CanWrite)
{
var value = sourceResolve.PropertyInfo.GetValue(source);
if (sourceResolve.PropertyType != targetResolve.PropertyType)
{
value = HandleDiffrentTypes(sourceResolve, targetResolve, value);
}
else
{
// if (targetResolve.IsEnumerable)
// {
// value = HandleEnumerable(targetResolve,);
// }
//}
//if ((sourceModelProp.PropertyType.Name.Contains("Collection") || sourceModelProp.PropertyType.Name.Contains("List")) && modelValue != null)
//{
// var targetListType = targetModelProp.PropertyType.GetGenericArguments()[0];
// var sourceListType = sourceModelProp.PropertyType.GetGenericArguments()[0];
// MethodInfo method;
// if (sourceListType.GetInterfaces().Contains(typeof(IGenericModel)))
// {
// method = sourceListType.GetMethodWithParent("GetListFromModels", BindingFlags.Public | BindingFlags.Static);
// method = method.MakeGenericMethod(targetListType);
// }
// else if (targetListType.GetInterfaces().Contains(typeof(IGenericModel)))
// {
// method = targetListType.GetMethodWithParent("GetListOfModels",
// BindingFlags.Public | BindingFlags.Static);
// method = method.MakeGenericMethod(sourceListType);
// }
// else
// {
// // targetModelProp.SetValue(targetModel, result, null);
// // throw new Exception("source or target need to be of type GenericModel");
// }
// //var methodType = method.MakeGenericMethod(targetListType);
// value = method.Invoke(null, new object[] { modelValue });
}
targetResolve.PropertyInfo.SetValue(target, value, null);
}
}
return(target);
}
private static object HandleGenericModel(ResolveModel targetResolve, object modelValue)
{
return(Activator.CreateInstance(targetResolve.PropertyType, modelValue));
}
