Desarrollo de la Clase para obtener los datos de configuración

En mis post anterior Membership Provider Parte 2. Creación de un Modelo de Bases de datos vimos como desarrollar un modelo de bases de datos para el Membership Provider reducido e independiente del modelo original que se crea con asp.net, pero que contiene todo lo necesario para asegurar correctamente una aplicación.

En este post daremos inicio con la creación de las clases que nos permitirán utilizar ese modelo de bases de datos con el Membership provider, pero esta vez personalizado y basado en Linq.

Nuestra primer clase se llamara ProviderUtils y será la encargada de recuperar los valores de configuración desde el web.config para ser utilizados en la clase Membership. Esta clase la declararemos como internal, de modo que solo pueda ser utilizada dentro del ámbito del espacio de nombres de la librería

   1: internal static class ProviderUtils
   2:     {}

 

Posterior a la declaración de la clase, crearemos el primer método, GetConfigValue que leerá los valores de configuración desde el archivo. No voy a entrar en muchos detalles pues en el código esta bien comentado que parámetros recibe y cual es el resultado esperado

   1: /// <summary>
   2:         /// A helper function to retrieve config values from the configuration file.
   3:         /// </summary>
   4:         /// <param name="config">Provider configuration.</param>
   5:         /// <param name="configKey">Key of the configuration that should be read.</param>
   6:         /// <param name="defaultValue">Default value being used if the config does not exist.</param>
   7:         /// <returns>Configuration value or default value if not exisiting.</returns>
   8:         public static object GetConfigValue(NameValueCollection config, string configKey, object defaultValue)
   9:         {
  10:             object configValue;
  11:  
  12:             try
  13:             {
  14:                 configValue = config[configKey];
  15:                 configValue = string.IsNullOrEmpty(configValue.ToString()) ? defaultValue : configValue;
  16:             }
  17:             catch
  18:             {
  19:                 configValue = defaultValue;
  20:             }
  21:  
  22:             return configValue;
  23:         }

El segundo método se denominara EnsureApplication, el cual se encargara de verificar que la aplicación que se especifico en la configuración del Membership Provider en el web.config exista, en caso de no existir entonces lo creara para asegurarse de que la aplicación no presente problemas

   1: /// <summary>
   2:        /// Ensure that application exists. If not -> create new application.
   3:        /// </summary>
   4:        /// <param name="applicationName">Application name.</param>
   5:        /// <param name="context">Entity Framework data context.</param>
   6:        /// <returns>The application object</returns>
   7:        public static Application EnsureApplication(string applicationName, Entities context)
   8:        {
   9:            Application application = context.Application.Where(a => a.Name == applicationName).FirstOrDefault();
  10:            if (application == null)
  11:            {
  12:                // Create application
  13:                application = Application.CreateApplication(Guid.NewGuid(), applicationName);
  14:                context.AddToApplication(application);
  15:                context.SaveChanges();
  16:            }
  17:  
  18:            return application;
  19:        }

 

El ultimo método llamado Expression, se encargara de recibir ciertos elementos y valores para luego construir una expresión contenedora

   1: /// <summary>
   2:      /// Builds a contains expression.
   3:      /// </summary>
   4:      /// <typeparam name="TElement">The type of the element.</typeparam>
   5:      /// <typeparam name="TValue">The type of the value.</typeparam>
   6:      /// <param name="valueSelector">The value selector.</param>
   7:      /// <param name="values">The values.</param>
   8:      /// <returns></returns>
   9:      public static Expression<Func<TElement, bool>> BuildContainsExpression<TElement, TValue>(Expression<Func<TElement, TValue>> valueSelector, IEnumerable<TValue> values)
  10:      {
  11:          if (null == valueSelector)
  12:          {
  13:              throw new ArgumentNullException("valueSelector");
  14:          }
  15:  
  16:          if (null == values)
  17:          {
  18:              throw new ArgumentNullException("values");
  19:          }
  20:  
  21:          ParameterExpression p = valueSelector.Parameters.Single();
  22:  
  23:          if (!values.Any())
  24:          {
  25:              return e => false;
  26:          }
  27:  
  28:          IEnumerable<Expression> equals = values.Select(value => (Expression)Expression.Equal(valueSelector.Body, Expression.Constant(value, typeof(TValue))));
  29:          Expression body = equals.Aggregate(Expression.Or);
  30:          return Expression.Lambda<Func<TElement, bool>>(body, p);
  31:      }

Como vemos esta clase es bastante sencilla y nos liberara bastante trabajo cuando implementemos las demás clases personalizadas

Por ultimo, el código completo se vería así

   1: internal static class ProviderUtils
   2:    {
   3:        /// <summary>
   4:        /// A helper function to retrieve config values from the configuration file.
   5:        /// </summary>
   6:        /// <param name="config">Provider configuration.</param>
   7:        /// <param name="configKey">Key of the configuration that should be read.</param>
   8:        /// <param name="defaultValue">Default value being used if the config does not exist.</param>
   9:        /// <returns>Configuration value or default value if not exisiting.</returns>
  10:        public static object GetConfigValue(NameValueCollection config, string configKey, object defaultValue)
  11:        {
  12:            object configValue;
  13:  
  14:            try
  15:            {
  16:                configValue = config[configKey];
  17:                configValue = string.IsNullOrEmpty(configValue.ToString()) ? defaultValue : configValue;
  18:            }
  19:            catch
  20:            {
  21:                configValue = defaultValue;
  22:            }
  23:  
  24:            return configValue;
  25:        }
  26:  
  27:        /// <summary>
  28:        /// Ensure that application exists. If not -> create new application.
  29:        /// </summary>
  30:        /// <param name="applicationName">Application name.</param>
  31:        /// <param name="context">Entity Framework data context.</param>
  32:        /// <returns>The application object</returns>
  33:        public static Application EnsureApplication(string applicationName, Entities context)
  34:        {
  35:            Application application = context.Application.Where(a => a.Name == applicationName).FirstOrDefault();
  36:            if (application == null)
  37:            {
  38:                // Create application
  39:                application = Application.CreateApplication(Guid.NewGuid(), applicationName);
  40:                context.AddToApplication(application);
  41:                context.SaveChanges();
  42:            }
  43:  
  44:            return application;
  45:        }
  46:  
  47:        /// <summary>
  48:        /// Builds a contains expression.
  49:        /// </summary>
  50:        /// <typeparam name="TElement">The type of the element.</typeparam>
  51:        /// <typeparam name="TValue">The type of the value.</typeparam>
  52:        /// <param name="valueSelector">The value selector.</param>
  53:        /// <param name="values">The values.</param>
  54:        /// <returns></returns>
  55:        public static Expression<Func<TElement, bool>> BuildContainsExpression<TElement, TValue>(Expression<Func<TElement, TValue>> valueSelector, IEnumerable<TValue> values)
  56:        {
  57:            if (null == valueSelector)
  58:            {
  59:                throw new ArgumentNullException("valueSelector");
  60:            }
  61:  
  62:            if (null == values)
  63:            {
  64:                throw new ArgumentNullException("values");
  65:            }
  66:  
  67:            ParameterExpression p = valueSelector.Parameters.Single();
  68:  
  69:            if (!values.Any())
  70:            {
  71:                return e => false;
  72:            }
  73:  
  74:            IEnumerable<Expression> equals = values.Select(value => (Expression)Expression.Equal(valueSelector.Body, Expression.Constant(value, typeof(TValue))));
  75:            Expression body = equals.Aggregate(Expression.Or);
  76:            return Expression.Lambda<Func<TElement, bool>>(body, p);
  77:        }
  78:    }