예제 #1
0
        /// <summary>
        /// Convierte el valor del filtro, al correspondiente tipo typeEntity  establecido en el fitro
        /// </summary>
        /// <param name="typeEntity"></param>
        /// <param name="filter"></param>
        /// <returns></returns>
        public static FilterEntity ConvertTypeFieldEntity(Type typeEntity, FilterEntity filter)
        {
            //TODO: Mejorar los mensajes de error lanzados...

            var valor = filter.Value as object;

            string error = string.Empty;

            if (typeEntity.Equals(typeof(string)))
            {
                filter.Value = filter.Value.ToString();
                return(filter);
            }

            if (typeEntity.Equals(typeof(int)) && filter.Value.GetType() != typeof(int))
            {
                try
                {
                    filter.Value = Convert.ToInt32(filter.Value);
                    return(filter);
                }
                catch (FormatException ex)
                {
                    error = string.Format("El valor [{0}], no tiene formato correcto para convertir al Tipo numerico configurado",
                                          valor);

                    throw new FormatException(error, ex);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }

            if (typeEntity.Equals(typeof(bool)))
            {
                try
                {
                    filter.Value = Convert.ToBoolean(filter.Value);
                    return(filter);
                }
                catch (FormatException ex)
                {
                    error = string.Format("El valor [{0}], no tiene formato correcto para convertir al Tipo booleano configurado",
                                          valor);

                    throw new FormatException(error, ex);
                }
                catch (Exception)
                {
                    throw;
                }
            }

            if (typeEntity.Equals(typeof(DateTime)))
            {
                try
                {
                    filter.Value = Convert.ToDateTime(filter.Value);
                    return(filter);
                }
                catch (FormatException ex)
                {
                    error = string.Format("El valor [{0}], no tiene formato correcto para convertir al Tipo fecha configurado",
                                          valor);

                    throw new FormatException(error, ex);
                }
                catch (Exception)
                {
                    throw;
                }
            }

            //Enum
            if (typeEntity.IsEnum)
            {
                try
                {
                    var result = Enum.Parse(typeEntity, filter.Value.ToString());
                    filter.Value = result;
                    return(filter);
                }
                catch (Exception)
                {
                    throw;
                }
            }

            if (typeEntity.Equals(typeof(int?))) // && filter.Value.GetType() != typeof(int?))
            {
                try
                {
                    if (filter.Value == null)
                    {
                        return(filter);
                    }

                    int?ValueNullable = Convert.ToInt32(filter.Value);
                    filter.Value = ValueNullable;
                    return(filter);
                }
                catch (FormatException ex)
                {
                    error = string.Format("El valor [{0}], no tiene formato correcto para convertir al Tipo numerico configurado",
                                          valor);

                    throw new FormatException(error, ex);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }

            if (typeEntity.Equals(typeof(bool?))) // && filter.Value.GetType() != typeof(bool?))
            {
                try
                {
                    if (filter.Value == null)
                    {
                        return(filter);
                    }

                    bool?ValueNullable = Convert.ToBoolean(filter.Value);
                    filter.Value = ValueNullable;
                    return(filter);
                }
                catch (FormatException)
                {
                    //error = string.Format("El valor [{0}] del parametro [{1}], no tiene formato correcto para convertir al Tipo [{2}] configurado",
                    //                    valor, parametro.Codigo, parametro.Tipo);

                    throw new FormatException(error);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }

            if (typeEntity.Equals(typeof(DateTime?)) && filter.Value.GetType() != typeof(DateTime?))
            {
                try
                {
                    DateTime?ValueNullable = Convert.ToDateTime(filter.Value);
                    filter.Value = ValueNullable;
                    return(filter);
                }
                catch (FormatException ex)
                {
                    error = string.Format("El valor [{0}], no tiene formato correcto para convertir al Tipo fecha configurado",
                                          valor);

                    throw new FormatException(error, ex);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }


            if (typeEntity.IsNullableEnum())
            {
                try
                {
                    if (filter.Value == null)
                    {
                        return(filter);
                    }

                    Type enumType = Nullable.GetUnderlyingType(typeEntity);

                    var result = Enum.Parse(enumType, filter.Value.ToString());
                    filter.Value = result;
                    return(filter);
                }
                catch (Exception)
                {
                    //
                    throw;
                }
            }


            error = string.Format("El  tipo de valor [{0}] no es soportado", typeEntity.Name);
            throw new GenericException(error, error);
        }