/// <summary>
        /// Método para consultar el detalle de una persona
        /// </summary>
        /// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
        /// <returns>Retorna objeto de tipo Entidad con la informacion detallada de una persona</returns>
        public Entidad ConsultarXId(Entidad parametro)
        {
            List<Parametro> parametros;
            Parametro parametroQuery = new Parametro();
            PersonaM7 idPersona = (PersonaM7)parametro;
            PersonaM7 persona;

            try
            {
                if (idPersona.Id> 0)
                {
                    parametros = new List<Parametro>();
                    persona = (PersonaM7)FabricaEntidades.ObtenerPersonaM7();
                    parametroQuery = new Parametro(RecursosDAOModulo7.ParamIdUsuarioLogueado, SqlDbType.Int, idPersona.Id.ToString(), false);
                    parametros.Add(parametroQuery);

                    DataTable dt = this.EjecutarStoredProcedureTuplas(
                                   RecursosDAOModulo7.ConsultaPersonaXId, parametros);

                    foreach (DataRow row in dt.Rows)
                    {
                        persona.Nombre = row[RecursosDAOModulo7.AliasPersonaNombre].ToString();
                        persona.Apellido = row[RecursosDAOModulo7.AliasPersonaApellido].ToString();
                        persona.FechaNacimiento = DateTime.Parse(row[RecursosDAOModulo7.AliasPersonaFechaNacimiento].ToString());
                        persona.Direccion = row[RecursosDAOModulo7.AliasPersonaDireccion].ToString();
                        persona.DojoPersona = int.Parse(row[RecursosDAOModulo7.AliasPersonaDojoId].ToString());
                    }
                }
                else
                {
                    throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
                }
            }
            catch (SqlException ex)
            {
                throw new ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
                    RecursoGeneralBD.Mensaje, ex);
            }
            catch (NumeroEnteroInvalidoException ex)
            {
                throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
            }
            catch (FormatException ex)
            {
                throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
            }
            catch (ExceptionSKDConexionBD ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new ExceptionSKD(RecursosDAOModulo7.MensajeExceptionSKD, ex);
            }

            return persona;
        }

        public static List<Rol> consultarRolesUsuario(string idUsuario)
        {
            BDConexion laConexion;
            List<Parametro> parametros;
            Parametro elParametro = new Parametro();

            try
            {
                laConexion = new BDConexion();
                parametros = new List<Parametro>();
                List<Rol> losRoles = new List<Rol>();
                elParametro = new Parametro(RecursosBDModulo2.aliasIdUsuario, SqlDbType.VarChar, idUsuario, false);
                parametros.Add(elParametro);
                DataTable dt= laConexion.EjecutarStoredProcedureTuplas(RecursosBDModulo2.ConsultarRolesUsuario, parametros);
                foreach (DataRow row in dt.Rows)
                {
                    Rol rol = new Rol();
                    rol.Id_rol = int.Parse(row[RecursosBDModulo2.AliasIdRol].ToString());
                    rol.Descripcion = row[RecursosBDModulo2.AliasDescripcionRol].ToString();
                    rol.Nombre = row[RecursosBDModulo2.AliasNombreRol].ToString();
                    rol.Fecha_creacion = (DateTime)row[RecursosBDModulo2.aliasFechaCreacion];
                    losRoles.Add(rol);

                }

                return losRoles;

            }
            catch (Exception e)
            {
                throw e;
            }
        }

        /// <summary>
        /// Implementación del método de la interfaz.
        /// </summary>
        public void saveResultado(Gestion gestion, Parametro tipo, string descripcion, DateTime fecha, Persona titular, Contacto contacto)
        {
            if (gestion != null) {
                // Primero graba y actualiza algunas cosas
                try {
                    long scn = Persistencia.Controlador.iniciarTransaccion();
                    gestion.FechaInicio = fecha;
                    gestion.Resultado = tipo;
                    gestion.ResultadoDesc = descripcion;
                    gestion.Contactado = titular;
                    gestion.Contacto = contacto;
                    gestion.Usuario = Sistema.Controlador.SecurityService.getUsuario();
                    gestion.Estado = _finalizada;
                    gestion.Cuenta.agregarGestion(gestion);
                    gestion.FechaCierre = DateTime.Now;
                    gestion.save();
                    Persistencia.Controlador.commitTransaccion(scn);
                } catch (Exception e) {
                    Persistencia.Controlador.rollbackTransaccion();
                    throw new DataErrorException("DATA-SAVENOK", e.ToString());
                }

                // Finalmente ejecuta el resultado y finaliza la gestion
                try {
                    ResultadoGestion.EjecutarResultado(gestion, gestion.Resultado);
                    gestion.save();
                } catch (Exception e) {
                    throw new DataErrorException("ERROR-EJECUTAR-RESULTADO", e.ToString());
                }
            }
        }

        public static Boolean ValidarCorreoUsuario(string correo_usuario)
        {
            BDConexion laConexion;
            List<Parametro> parametros;
            Parametro elParametro = new Parametro();

            try
            {
                laConexion = new BDConexion();
                parametros = new List<Parametro>();
                List<String> elCorreo = new List<String>();

                elParametro = new Parametro(RecursosBDModulo1.aliasCorreoUsuario, SqlDbType.VarChar, correo_usuario, false);
                parametros.Add(elParametro);
                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosBDModulo1.ValidarCorreo, parametros);

                foreach (DataRow row in dt.Rows)
                {
                    elCorreo.Add(row[RecursosBDModulo1.aliasCorreoUsuario].ToString());
                }
                bool respuesta = false;
                if (elCorreo.Count == 1)
                    respuesta = true;
                else if (elCorreo.Count > 1)
                    throw new Exception(RecursosBDModulo1.exceptionCorreoMasUno);

                return respuesta;

            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public static bool RestablecerContrasena(string usuarioId,string contraseña)
        {
            BDConexion laConexion;
            List<Parametro> parametros;
            Parametro elParametro = new Parametro();

            try
            {
                laConexion = new BDConexion();
                parametros = new List<Parametro>();
                Cuenta laCuenta = new Cuenta();
                elParametro = new Parametro(RecursosBDModulo1.AliasIdUsuario, SqlDbType.Int, usuarioId, false);
                parametros.Add(elParametro);
                elParametro = new Parametro(RecursosBDModulo1.AliasContrasena, SqlDbType.VarChar,contraseña, false);
                parametros.Add(elParametro);

                laConexion.EjecutarStoredProcedureTuplas(
                      RecursosBDModulo1.CambiarContraseña, parametros);

                return true;

            }
            catch (Exception e)
            {
                throw e;
            }
        }

        /// <summary>
        /// Método para consultar el detalle de una cinta 
        /// </summary>
        /// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
        /// <returns>Retorna objeto de tipo Entidad con la informacion de la cinta</returns>
        public Entidad ConsultarXId(Entidad parametro)
        {
            List<Parametro> parametros;
            Parametro parametroQuery = new Parametro();
            CintaM7 idCinta = (CintaM7)parametro;
            CintaM7 cinta = (CintaM7)FabricaEntidades.ObtenerCintaM7();

            try
            {
                if (idCinta.Id > 0)
                {
                    parametros = new List<Parametro>();
                    parametroQuery = new Parametro(RecursosDAOModulo7.ParamIdCinta, SqlDbType.Int, idCinta.Id.ToString(), false);
                    parametros.Add(parametroQuery);

                    DataTable dt = this.EjecutarStoredProcedureTuplas(
                                    RecursosDAOModulo7.ConsultarCintaXId, parametros);

                    foreach (DataRow row in dt.Rows)
                    {
                        cinta.Id = int.Parse(row[RecursosDAOModulo7.AliasIdCinta].ToString());
                        cinta.Color_nombre = row[RecursosDAOModulo7.AliasCintaNombre].ToString();
                        cinta.Rango = row[RecursosDAOModulo7.AliasCintaRango].ToString();
                        cinta.Clasificacion = row[RecursosDAOModulo7.AliasCintaClasificacion].ToString();
                        cinta.Significado = row[RecursosDAOModulo7.AliasCintaSignificado].ToString();
                        cinta.Orden = int.Parse(row[RecursosDAOModulo7.AliasCintaOrden].ToString());
                    }
                }
                else
                {
                    throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                 RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
                }

            }
            catch (SqlException ex)
            {
                throw new ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,RecursoGeneralBD.Mensaje, ex);
            }
            catch (NumeroEnteroInvalidoException ex)
            {
                throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                 RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
            }
            catch (FormatException ex)
            {
                throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                 RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
            }
            catch (ExceptionSKDConexionBD ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new ExceptionSKD(RecursosDAOModulo7.MensajeExceptionSKD, ex);
            }

            return cinta;
        }

        /// <summary>
        /// Se hace la conexion a la base de datos para Agregar un rol  al usuario
        /// </summary>
        /// <param name="idUsuario">id del usuario que se le Agregar el rol</param>
        /// <param name="idRol">id del rol a Agregar</param>
        /// <returns> true si  se pudo Agregar false si no se pudo Agregar el rol</returns>
        public bool AgregarRol(string idUsuario, string idRol)
        {
            List<Parametro> parametros;
            Parametro elParametro = new Parametro();

            try
            {
                parametros = new List<Parametro>();
                elParametro = new Parametro(RecursosBDM2.AliasIdRol, SqlDbType.VarChar, idRol, false);
                parametros.Add(elParametro);
                elParametro = new Parametro(RecursosBDM2.aliasIdUsuario, SqlDbType.VarChar, idUsuario, false);
                parametros.Add(elParametro);
                this.EjecutarStoredProcedureTuplas(RecursosBDM2.AgregarRolProcedure, parametros);
                return true;

            }
            catch (SqlException e)
            {
                throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
                    RecursoGeneralBD.Mensaje, e);
            }
            catch (ExcepcionesSKD.ExceptionSKDConexionBD e)
            {
                throw e;
            }
            catch (Exception e)
            {
                throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, e);
            }
        }

        /// <summary>
        /// Método para consultar el detalle de una organizacion
        /// </summary>
        /// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
        /// <returns>Retorna objeto de tipo Entidad con la informacion detallada de una organizacion</returns>
        public Entidad ConsultarXId(Entidad parametro)
        {
            List<Parametro> parametros;
            Parametro parametroQuery = new Parametro();
            OrganizacionM7 idOrganizacion = (OrganizacionM7)parametro;
            OrganizacionM7 organizacion;

            try
            {
                if (idOrganizacion.Id > 0)
                {
                    parametros = new List<Parametro>();
                    organizacion = (OrganizacionM7)FabricaEntidades.ObtenerOrganizacionM7();
                    parametroQuery = new Parametro(RecursosDAOModulo7.ParamIdOrganizacion, SqlDbType.Int, idOrganizacion.Id.ToString(), false);
                    parametros.Add(parametroQuery);

                    DataTable dt = this.EjecutarStoredProcedureTuplas(
                               RecursosDAOModulo7.ConsultaOrganizacionXId, parametros);

                    foreach (DataRow row in dt.Rows)
                    {
                        organizacion.Id = int.Parse(row[RecursosDAOModulo7.AliasOrganizacionId].ToString());
                        organizacion.Nombre = row[RecursosDAOModulo7.AliasOrganizacionNombre].ToString();
                        organizacion.Direccion = row[RecursosDAOModulo7.AliasOrganizacionDireccion].ToString();
                        organizacion.Telefono = int.Parse(row[RecursosDAOModulo7.AliasOrganizacionTelefono].ToString());
                        organizacion.Email = row[RecursosDAOModulo7.AliasOrganizacionEmail].ToString();
                    }
                }
                else
                {
                    throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
                }

            }
            catch (SqlException ex)
            {
                throw new ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,RecursoGeneralBD.Mensaje, ex);
            }
            catch (NumeroEnteroInvalidoException ex)
            {
                throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
            }
            catch (FormatException ex)
            {
                throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
            }
            catch (ExceptionSKDConexionBD ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new ExceptionSKD(RecursosDAOModulo7.MensajeExceptionSKD, ex);
            }

            return organizacion;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Parametro parametro = new Parametro();
            parametro.IdLancamento = cbTipoLAncamentoPadrao.SelectedValue.ToString();
            parametro.CdEventoCredito = cbEventoCredito.SelectedValue.ToString();
            parametro.CdHistoricoCredito = cbHistoricoCredito.SelectedValue.ToString();
            parametro.CdEventoDebito = cbEventoDebito.SelectedValue.ToString();
            parametro.CdHistoricoDebito = cbHistoricoDebito.SelectedValue.ToString();

            if (ckTodosOrgaos.Checked)
            {

                DataTable dados = getUnidadesGestoras();
                foreach (DataRow linha in dados.Rows)
                {
                    parametro.CdUnidadeGestora = linha[0].ToString();

                    gravaRegistro(parametro);
                }

            }
            else {
                parametro.CdUnidadeGestora = cbUnidadeGestora.SelectedValue.ToString();
                gravaRegistro(parametro);
            }

            MessageExcept.messageFacede("Registro(s) Salvo(s)", 2);
            listaPareados();
        }

        /// <summary>
        /// Se hace la conexion a la base de datos para cambiar la contraseña del usuario
        /// </summary>
        /// <param name="usuarioId"> Id del usuario que solicito el cambio de contraseña</param>
        /// <param name="contraseña">nueva contraseña del usuario</param>
        /// <returns></returns>
        public bool RestablecerContrasena(string usuarioId, string contraseña)
        {
            List<Parametro> parametros;
            Parametro elParametro = new Parametro();

            try
            {
                parametros = new List<Parametro>();
                Cuenta laCuenta = (Cuenta) laFabrica.ObtenerCuenta_M1();
                elParametro = new Parametro(RecursosBDM1.AliasIdUsuario, SqlDbType.Int, usuarioId, false);
                parametros.Add(elParametro);
                elParametro = new Parametro(RecursosBDM1.AliasContrasena, SqlDbType.VarChar, contraseña, false);
                parametros.Add(elParametro);

                this.EjecutarStoredProcedureTuplas(
                      RecursosBDM1.CambiarContraseña, parametros);
                return true;
            }
            catch (SqlException e)
            {
                throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
                    RecursoGeneralBD.Mensaje, e);
            }
            catch (ExcepcionesSKD.ExceptionSKDConexionBD e)
            {
                throw e;
            }
            catch (Exception e)
            {
                throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, e);
            }
        }

 public void insertarUsuario(Usuario pUsuario)
 {
     try
     {
         String cmdText;
         cmdText = "INSERT INTO usuarios(nombre,apellido1,apellido2,usuario) VALUES(valor01,valor02,valor03,valor04)";
         DaoObject.crearConexion(Properties.Resources.conexionStr);
         Parametro tmpParametro;
         List<Parametro> parametros;
         parametros = new List<Parametro>();
         tmpParametro = new Parametro("valor01", pUsuario.nombre);
         parametros.Add(tmpParametro);
         tmpParametro = new Parametro("valor02", pUsuario.apellido);
         parametros.Add(tmpParametro);
         tmpParametro = new Parametro("valor03", pUsuario.sApellido);
         parametros.Add(tmpParametro);
         tmpParametro = new Parametro("valor04", pUsuario.usuario);
         parametros.Add(tmpParametro);
         DaoObject.accesoDatos.ejecutar(cmdText, parametros);
         DaoObject.accesoDatos.cerrarConexion();
     }
     catch (SqlException e)
     {
         throw e;
     }
 }

        public Usuario buscar(String pNombreUsuario)
        {
            Usuario tmpUsuario = new Usuario();
            try
            {
                String cmdText;
                cmdText = "SELECT usuario,nombre,apellido1,apellido2 FROM usuarios WHERE usuario = valor01";
                Parametro tmpParametro;
                List<Parametro> parametros;
                parametros = new List<Parametro>();
                tmpParametro = new Parametro("valor01", pNombreUsuario);
                parametros.Add(tmpParametro);
                DaoObject.crearConexion(Properties.Resources.conexionStr);
                SqlDataReader reader = DaoObject.accesoDatos.ejecutarSelect(cmdText, parametros, CommandBehavior.Default);

                //recorror el data reader para ir creando las estructuras y agregarlas a la coleccion
                while (reader.Read())
                {
                    tmpUsuario.nombre = reader.GetValue(1).ToString();
                    tmpUsuario.apellido = reader.GetValue(2).ToString();
                    tmpUsuario.sApellido = reader.GetValue(3).ToString();
                    tmpUsuario.usuario = reader.GetValue(0).ToString();
                }
                reader.Close();
                // accesoDatos.cerrarReader();
                DaoObject.accesoDatos.cerrarConexion();
                return tmpUsuario;
            }
            catch (SqlException e)
            {
                throw e;
            }
        }

        /// <summary>
        /// Método para consultar el detalle de una ubicacion
        /// </summary>
        /// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
        /// <returns>Retorna objeto de tipo Entidad con la informacion detallada de la ubicacion</returns>
        public Entidad ConsultarXId(Entidad parametro)
        {
            List<Parametro> parametros;
            Parametro parametroQuery = new Parametro();
            UbicacionM7 idUbicacion = (UbicacionM7)parametro;
            UbicacionM7 ubicacion;

            try
            {
                if (idUbicacion.Id > 0)
                {
                    parametros = new List<Parametro>();
                    ubicacion = (UbicacionM7)FabricaEntidades.ObtenerUbicacionM7();
                    parametroQuery = new Parametro(RecursosDAOModulo7.ParamIdUbicacion, SqlDbType.Int, idUbicacion.Id.ToString(), false);
                    parametros.Add(parametroQuery);

                    DataTable dt = this.EjecutarStoredProcedureTuplas(
                                   RecursosDAOModulo7.ConsultaUbicacionXId, parametros);

                    foreach (DataRow row in dt.Rows)
                    {
                        ubicacion.Id = int.Parse(row[RecursosDAOModulo7.AliasIdUbicacion].ToString());
                        ubicacion.Ciudad = row[RecursosDAOModulo7.AliasCiudad].ToString();
                        ubicacion.Estado = row[RecursosDAOModulo7.AliasEstado].ToString();
                        ubicacion.Direccion = row[RecursosDAOModulo7.AliasDireccion].ToString();
                    }
                }
                else
                {
                    throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
                }
            }
            catch (SqlException ex)
            {
                throw new ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
                    RecursoGeneralBD.Mensaje, ex);
            }
            catch (NumeroEnteroInvalidoException ex)
            {
                throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
            }
            catch (FormatException ex)
            {
                throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
            }
            catch (ExceptionSKDConexionBD ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new ExceptionSKD(RecursosDAOModulo7.MensajeExceptionSKD, ex);
            }

            return ubicacion;
        }

 public frmTomaActivo(string _Usuario, Inventario _Inventario, Parametro ubicacion, Empleado custodio)
 {
     InitializeComponent();
     mUsuario = _Usuario;
     mInventario = _Inventario;
     pUbicacion = ubicacion;
     eCustodio = custodio;
 }

        /// <summary>
        /// Método de Dao que se conecta a Base de Datos
        /// para agregar un Actor
        /// </summary>
        /// <param name="parametro">Objeto de tipo Entidad Actor
        /// con los datos del actor a ser agregado</param>
        /// <returns>True si lo agregó, false en caso contrario</returns>
        public bool Agregar(Entidad parametro)
        {
            Actor actor = parametro as Actor;

               List<Parametro> parametros = new List<Parametro>();
               Parametro elParametro = new Parametro(RecursosDAOModulo6.NOMBRE_ACTOR,
               SqlDbType.VarChar,actor.NombreActor,false);
               parametros.Add(elParametro);
               elParametro = new Parametro(RecursosDAOModulo6.DESC_ACTOR,SqlDbType.VarChar,
               actor.DescripcionActor,false);
               parametros.Add(elParametro);
              //falta el id del proyecto

               try
               {
               List<Resultado> tmp = EjecutarStoredProcedure(RecursosDAOModulo6.PROCEDURE_INSERTAR_ACTOR,
                   parametros);
               return (tmp.ToArray().Length > 0);
               }
               catch (SqlException e)
               {

                  AgregarActorBDDAOException exDaoActor = new AgregarActorBDDAOException(
                   RecursosDAOModulo6.CodigoExcepcionAgregarActorBD,
                   RecursosDAOModulo6.MensajeExcepcionAgregarActorBD,
                   e);

                  Logger.EscribirError(RecursosDAOModulo6.ClaseDAOActor,
                      exDaoActor);

                  throw exDaoActor;

               }
               catch (NullReferenceException e)
               {
               AgregarActorNuloDAOException exDaoActor = new AgregarActorNuloDAOException(
                   RecursosDAOModulo6.CodigoExcepcionAgregarActorNulo,
                   RecursosDAOModulo6.MensajeExcepcionAgregarActorNulo,
                   e);
               Logger.EscribirError(RecursosDAOModulo6.ClaseDAOActor,
                      exDaoActor);

               throw exDaoActor;

               }
               catch (Exception e)
               {
               AgregarActorDAOException exDaoActor =  new AgregarActorDAOException(
                   RecursosDAOModulo6.CodigoExcepcionAgregarActorError,
                   RecursosDAOModulo6.MensajeExcepcionAgregarActorError,
                   e);

               Logger.EscribirError(RecursosDAOModulo6.ClaseDAOActor,
                     exDaoActor);

               throw exDaoActor;
               }
        }

        /// <summary>
        /// Metodo para agregar una restriccion de evento a la base de datos.
        /// </summary>
        /// <param name="parametro">objeto de tipo RestriccionEvento para agregar en bd</param>
        /// <returns>true si fue agregado</returns>
        public Boolean AgregarRestriccionEvento(DominioSKD.Entidad parametro)
        {
            DominioSKD.Entidades.Modulo8.RestriccionEvento laRestriccionEvento =
                (DominioSKD.Entidades.Modulo8.RestriccionEvento)parametro;

            try
            {
                List<Parametro> parametros = new List<Parametro>();

                Parametro elParametro = new Parametro(RecursosDAORestriccionEvento.ParamDescripcionRestricionEvento, SqlDbType.VarChar,
                        laRestriccionEvento.Descripcion, false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAORestriccionEvento.ParamEdadMinimaRestricionEvento, SqlDbType.Int,
                        laRestriccionEvento.EdadMinima.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAORestriccionEvento.ParamEdadMaximaRestricionEvento, SqlDbType.Int,
                        laRestriccionEvento.EdadMaxima.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAORestriccionEvento.ParamSexoRestricionEvento, SqlDbType.VarChar,
                        laRestriccionEvento.Sexo.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAORestriccionEvento.ParamIdEvento, SqlDbType.Int,
                        laRestriccionEvento.IdEvento.ToString(), false);
                parametros.Add(elParametro);

                List<Resultado> resultados = this.EjecutarStoredProcedure(RecursosDAORestriccionEvento.AgregarRestriccionEvento
                                             , parametros);
            }

            catch (SqlException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
                    RecursoGeneralBD.Mensaje, ex);
            }
            catch (FormatException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExcepcionesSKD.Modulo8.FormatoIncorrectoException(RecursosDAORestriccionEvento.CodigoErrorFormato,
                     RecursosDAORestriccionEvento.MensajeErrorFormato, ex);
            }
            catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw ex;
            }
            catch (Exception ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }

            return true;
        }

        /// <summary>
        /// Método para consultar el detalle de una matricula 
        /// </summary>
        /// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
        /// <returns>Retorna objeto de tipo Entidad con la informacion de la matricula</returns>
        public Entidad ConsultarXId(Entidad parametro)
        {
            List<Parametro> parametros;
            Parametro parametroQuery = new Parametro();
            MatriculaM7 idMatricula = (MatriculaM7)parametro;
            MatriculaM7 matricula = (MatriculaM7)FabricaEntidades.ObtenerMatriculaM7();

            try
            {
                if (idMatricula.Id > 0)
                {
                    parametros = new List<Parametro>();
                    parametroQuery = new Parametro(RecursosDAOModulo7.ParamIdMatricula, SqlDbType.Int, idMatricula.Id.ToString(), false);
                    parametros.Add(parametroQuery);

                    DataTable dt = this.EjecutarStoredProcedureTuplas(
                                    RecursosDAOModulo7.ConsultarMatriculaXId, parametros);

                    foreach (DataRow row in dt.Rows)
                    {
                      matricula.Id = int.Parse(row[RecursosDAOModulo7.AliasIdMatricula].ToString());
                      matricula.Identificador = row[RecursosDAOModulo7.AliasIdentificadorMatricula].ToString();
                      matricula.FechaCreacion = DateTime.Parse(row[RecursosDAOModulo7.AliasFechaPagoMatricula].ToString());
                      matricula.UltimaFechaPago = DateTime.Parse(row[RecursosDAOModulo7.AliasFechaUltimoPagoMatricula].ToString());
                    }
                }
                else
                {
                    throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                 RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
                }

            }
            catch (SqlException ex)
            {
                throw new ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,RecursoGeneralBD.Mensaje, ex);
            }
            catch (NumeroEnteroInvalidoException ex)
            {
                throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                 RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
            }
            catch (FormatException ex)
            {
                throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                 RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
            }
            catch (ExceptionSKDConexionBD ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new ExceptionSKD(RecursosDAOModulo7.MensajeExceptionSKD, ex);
            }

            return matricula;
        }

        /// <summary>
        /// Método para consultar el detalle de un tipo de evento
        /// </summary>
        /// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
        /// <returns>Retorna objeto de tipo Entidad con la informacion detallada del tipo de evento</returns>
        public Entidad ConsultarXId(Entidad parametro)
        {
            List<Parametro> parametros;
            Parametro parametroQuery = new Parametro();
            TipoEventoM7 idTipoEvento = (TipoEventoM7)parametro;
            TipoEventoM7 tipoEvento;

            try
            {
                if (idTipoEvento.Id > 0)
                {
                    parametros = new List<Parametro>();
                    tipoEvento = (TipoEventoM7)FabricaEntidades.ObtenerTipoEventoM7();
                    parametroQuery = new Parametro(RecursosDAOModulo7.ParamIdTipoEvento, SqlDbType.Int, idTipoEvento.Id.ToString(), false);
                    parametros.Add(parametroQuery);
                    DataTable dt = this.EjecutarStoredProcedureTuplas(
                                   RecursosDAOModulo7.ConsultarTipoEventoXId, parametros);

                    foreach (DataRow row in dt.Rows)
                    {
                        tipoEvento.Id = int.Parse(row[RecursosDAOModulo7.AliasIdTipoEvento].ToString());
                        tipoEvento.Nombre = row[RecursosDAOModulo7.AliasTipoEventoNombre].ToString();
                    }
                }
                else
                {
                    throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
                }

            }
            catch (SqlException ex)
            {
                throw new ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,RecursoGeneralBD.Mensaje, ex);
            }
            catch (NumeroEnteroInvalidoException ex)
            {
                throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
            }
            catch (FormatException ex)
            {
                throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
                                RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
            }
            catch (ExceptionSKDConexionBD ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new ExceptionSKD(RecursosDAOModulo7.MensajeExceptionSKD, ex);
            }

            return tipoEvento;
        }

        /// <summary>
        /// Método para consultar el detalle de un horario
        /// </summary>
        /// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
        /// <returns>Retorna objeto de tipo Entidad con la informacion detallada del horario/returns>
        public Entidad ConsultarXId(Entidad parametro)
        {
            List<Parametro> parametros;
            Parametro parametroQuery = new Parametro();
            HorarioM7 idHorario = (HorarioM7)parametro;
            HorarioM7 horario;
            try
            {
                if (idHorario.Id > 0)
                {
                    parametros = new List<Parametro>();
                    horario = (HorarioM7)FabricaEntidades.ObtenerHorarioM7();
                    parametroQuery = new Parametro(RecursosDAOModulo7.ParamId