Exception/Error handling using the ObjectDataSource

Ariel Popovsky — Mon, 22 Jun 2009 13:54:26 GMT

This post was going to be a rant about how using the ObjectDataSource was impossible to handle exceptions thrown while retrieving or updating data. After some experiments and reading some misleading posts I saw only three possible ways:

Use a generic error handler like the Page Error event or the Application Error event in global.asax.
Implement handlers for the Updating, Selecting and Deleting events of the GridView bound to the datasource, set the event.Cancel to true and then manually call the Insert, Delete, Update and Select methods of the data source inside a try/catch block.
Throw away the data source and do everything manually.

Luckily I accidentally found the right way to do it while looking at the EventArgs class properties for the Selected event. When the ObjectDataSource calls your data object, if the result is an exception it will call your post event event-handler (Selected, Deleted, etc). The EventArgs has two properties for managing exceptions, one is the Exception itself, the other is a boolean, ExceptionHandled. If you want to handle the exception you just need to set the ExceptionHandled property to true.

  1:         protected void MyDataSource_Deleted(object sender, ObjectDataSourceStatusEventArgs e)
  2:         {
  3:             if(e.Exception!=null)
  4:             {
  5:                 ShowMessage(Constants.GenericErrorMessage, MessageType.Error);
  6:                 e.ExceptionHandled = true;
  7:             }
  8:             else
  9:             {
 10:                 ShowMessage("Entity deleted successfully.", MessageType.Success);                    
 11:             }            
 12:         }

Technorati Tags: ASP.net,ObjectDataSource,GridView

Validar un CUIT/CUIL con C#, Javascript y JQuery.Validate

Ariel Popovsky — Mon, 27 Apr 2009 19:18:56 GMT

Etiquetas de Technorati: ASP.net,JQuery,JQuery Validator,Javascript,CUIT

Hace tiempo que quiero armar un blog técnico para compartir experiencias y cosas de interes para desarrolladores web y finalmente me decidí.
Para el primer post quiero empezar con algo útil que tuve que armar para una aplicación que estamos desarrollando. Se trata de rutinas de validación de CUIT/CUIL (Código Unico de Identificación Tributaria / Laboral de Argentina). Hay varios ejemplos en la web en distintos lenguajes pero al no ver algo en c# o Javascript decidí armar mi versión.
La validación se basa en calcular el dígito verificador y compararlo con el suministrado. El algoritmo es muy simple, se multiplica cada dígito por un factor específico, la suma de todos los términos se divide por 11 y el dígito es igual a 0 si el resto es 0, 9 si el resto es 1 o 11-resto en los demás casos.
Esta es la versión de .net para calcular el dígito:

   1:          /// <summary>

   2:          /// Calcula el dígito verificador dado un CUIT completo o sin él.

   3:          /// </summary>

   4:          /// <param name="cuit">El CUIT como String sin guiones</param>

   5:          /// <returns>El valor del dígito verificador calculado.</returns>

   6:          public static int CalcularDigitoCuit(string cuit)

   7:          {

   8:              int[] mult = new[] { 5, 4, 3, 2, 7, 6, 5, 4, 3, 2 };

   9:              char[] nums = cuit.ToCharArray();

  10:              int total = 0;

  11:              for (int i = 0; i < mult.Length; i++)

  12:              {

  13:                  total += int.Parse(nums[i].ToString()) * mult[i];

  14:              }

  15:              var resto = total % 11;

  16:              return resto == 0 ? 0 : resto == 1 ? 9 : 11 - resto;

  17:          }

El código para validar simplemente compara el dígito suministrado con el calculado. Como mejora se podrían validar los primeros 2 dígitos que solo pueden tener ciertos valores pero preferí dejarlo afuera por ahora ya que quien sabe si el día de mañana no se agregan otros códigos.

   1:          /// <summary>

   2:          /// Valida el CUIT ingresado.

   3:          /// </summary>

   4:          /// <param name="cuit" />Número de CUIT como string con o sin guiones

   5:          /// <returns>True si el CUIT es válido y False si no.</returns>

   6:          public static bool ValidaCuit(string cuit)

   7:          {

   8:              if (cuit == null)

   9:              {

  10:                  return false;

  11:              }

  12:              //Quito los guiones, el cuit resultante debe tener 11 caracteres.

  13:              cuit = cuit.Replace("-", string.Empty);

  14:              if (cuit.Length != 11)

  15:              {

  16:                  return false;

  17:              }

  18:              else

  19:              {

  20:                  int calculado = CalcularDigitoCuit(cuit);

  21:                  int digito = int.Parse(cuit.Substring(10));

  22:                  return calculado == digito;

  23:              }

  24:          }

La versión Javascript es muy similar aunque no separé la generación del dígito de la validación. La última línea registra el método de validación en JQuery Validator.

   1:  function validaCuit(cuit) {

   2:      if (typeof (cuit) == 'undefined')

   3:          return true;

   4:      cuit = cuit.toString().replace(/[-_]/g, "");

   5:      if (cuit == '')

   6:          return true; //No estamos validando si el campo esta vacio, eso queda para el "required"

   7:      if (cuit.length != 11)

   8:          return false;

   9:      else {

  10:          var mult = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];

  11:          var total = 0;

  12:          for (var i = 0; i < mult.length; i++) {

  13:              total += parseInt(cuit[i]) * mult[i];

  14:          }

  15:          var mod = total % 11;

  16:          var digito = mod == 0 ? 0 : mod == 1 ? 9 : 11 - mod;

  17:      }

  18:      return digito == parseInt(cuit[10]);

  19:  }

20:

  21:  $.validator.addMethod("cuit", validaCuit, 'CUIT/CUIT Inválido');

Un ejemplo de uso del validador de Javascript:

   1:   <form id="test">

   2:      <input type="text" id="cuit" name="cuit" />

   3:   </form>

   1:      <script type="text/javascript">

   2:          $(function() {

   3:              $("#test").validate({

   4:                  rules: {

   5:                      cuit: "cuit"

   6:                  }

   7:              });

   8:              $("#cuit").keydown(function() {

   9:                  $(this).valid();

  10:              });

  11:          });

12:

  13:      </script>

Espero que a alguien le sea útil.