/// <summary>
/// Retorna un objeto desde un entitySearch, el tipo del objeto de retorno será del tipo que utilice el atributo EntityIndexAttribute .
/// para esto buscará todas las clases que tnengan el atributo EntityIndexAttribute que vincula la clase con el índice
/// del entitySearch, una vez encontrada hará lo mismo con los atributos de cada propiedad para finalmente crear un objeto tipado con todos los valores del entitySearch.
/// </summary>
/// <typeparam name="T">Las entidades tienen un tipo de dato geo, que depende de la base de datos a usar.</typeparam>
/// <param name="entitySearch">entitySearch a convertir</param>
/// <param name="anyElementInAssembly">assembly donde buscar la clase que sea del tipo de la entidad</param>
/// <param name="nms">namespace donde se encuentra la clase que sea del tipo de entidad</param>
/// <param name="geoConvert"></param>
/// <param name="sEntity"></param>
/// <param name="hash"></param>
/// <returns>objeto de una clase que representa una entidad</returns>
public static object GetEntityFromSearch <T>(IEntitySearch <T> entitySearch, Type anyElementInAssembly, string nms, Func <T, object> geoConvert, ISearchEntity <T> sEntity, IHashSearchHelper hash)
{
// obtiene el tipo de clase de acuerdo al índice de la entidad.
var type = GetEntityType(entitySearch.index, anyElementInAssembly, nms);
// crea una nueva instancia del tipo determinado por la entidad
// por ejemplo, si el indice de entidad correspondiera a 1 que es Persona, esta sería la clase persona.
var entity = Collections.CreateEntityInstance(type);
if (type.GetProperty("Id") == null)
{
throw new Exception("un elemento a convertir en EntitySearch debe llevar id");
}
// asigna el id del objeto convertido
// todas los elementos de la base de datos tienn la propiedad id.
type.GetProperty("Id")?.SetValue(entity, entitySearch.id);
// busca todas las propiedades que tengan el atributo baseIndexAttribute que identifica la metadata donde reside el índice y el tipo de dato.
var props = entity.GetType().GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(BaseIndexAttribute), true)).ToList();
// recorre las propiedades de una clase y le asigna los valores correspondientes a las propiedades del entitySearch
props.ForEach(prop => {
// obtiene el atributo y su metadata
var attr = prop.GetCustomAttribute <BaseIndexAttribute>(true);
// con la metadata de la propiedad (índice, tipo de dato y si es o no entidad, obtiene el valor o la colección de valores de una propiedad.
var values = Collections.FormatValues(prop, GetValues <T>(entitySearch, attr.IsEntity, attr.KindIndex, attr.Index, geoConvert, hash, sEntity, anyElementInAssembly, nms));
// asigna el valor a la clase.
prop.SetValue(entity, values);
});
var hashModel = hash.HashModel(entity);
var hashHeader = hash.HashHeader(type);
if (entitySearch.hh.Equals(hashHeader) && entitySearch.hm.Equals(hashModel))
{
// retorna un objeto tipado desde un entitySearch.
return(entity);
}
throw new Exception("Hash incorrectos");
}
/// <summary>
/// entrega un nuevo entitySearch sin considerar las referencias locales y sin asignarle un id.
/// </summary>
/// <typeparam name="T">Tipo de dato de la propiedad geo de una entidad </typeparam>
/// <param name="implements">objeto que mantiene todos los tipos a los que cada propiedad debe ser convertido</param>
/// <param name="typeToCast">tipo a convertir el entity, no debe implementar IEntitySearch pero cada propiedad debe tener el tipo de IEntitySearch<T></param>
/// <param name="mdl">diccionario con la metadata y los datos de cada propiedad.</param>
/// <returns>nueva entidad desde ub objeto</returns>
public static IEntitySearch <T> FillProps <T>(Implements <T> implements, Dictionary <BaseIndexAttribute, object> mdl, Type typeToCast)
{
var objSearch = Collections.CreateEntityInstance(typeToCast);
var entitySearch = GetEntityBaseSearch <T>(objSearch);
entitySearch.num32 = (INum32Property[])InvokeDynamicGeneric("GetNumProps", implements.num32, new object[] { mdl });
entitySearch.dbl = (IDblProperty[])InvokeDynamicGeneric("GetDblProps", implements.dbl, new object[] { mdl });
entitySearch.dt = (IDtProperty[])InvokeDynamicGeneric("GetDtProps", implements.dt, new object[] { mdl });
entitySearch.enm = (IEnumProperty[])InvokeDynamicGeneric("GetEnumProps", implements.enm, new object[] { mdl });
entitySearch.bl = (IBoolProperty[])InvokeDynamicGeneric("GetBoolProps", implements.bl, new object[] { mdl });
entitySearch.geo = (IProperty <T>[])InvokeDynamicGeneric("GetGeoProps", implements.geo, new object[] { mdl, implements.GeoObjetoToGeoSearch }, typeof(T));
entitySearch.num64 = (INum64Property[])InvokeDynamicGeneric("GetNum64Props", implements.num64, new object[] { mdl });
entitySearch.str = (IStrProperty[])InvokeDynamicGeneric("GetStrProps", implements.str, new object[] { mdl });
entitySearch.sug = (IStrProperty[])InvokeDynamicGeneric("GetSugProps", implements.sug, new object[] { mdl });
entitySearch.rel = GetReferences(mdl, implements.rel);
return(entitySearch);
}
