示例#1
0
        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;
            }
        }
示例#2
0
        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;
            }
        }
示例#3
0
        /// <summary>
        /// Metodo que retorma una lista de implementos del inventario
        /// </summary>
        /// <param name=NONE>Este metodo no posee paso de parametros</param>
        /// <returns>Todo lo que tiene actualmente el inventario</returns>
        public static List<DominioSKD.Entidades.Modulo16.Implemento> ListarInventario()
        {
            BDConexion laConexion;
            List<DominioSKD.Entidades.Modulo16.Implemento> laListaDeInventario = new List<DominioSKD.Entidades.Modulo16.Implemento>();
            List<Parametro> parametros;

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

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosBDModulo16.CONSULTAR_IMPLEMENTOS, parametros);

                foreach (DataRow row in dt.Rows)
                {
                    DominioSKD.Entidades.Modulo16.Implemento elInventario = new DominioSKD.Entidades.Modulo16.Implemento();

                    elInventario.Id_Implemento = int.Parse(row[RecursosBDModulo16.PARAMETRO_IDIMPLEMENTO].ToString());
                    elInventario.Imagen_implemento = row[RecursosBDModulo16.PARAMETRO_IMAGEN].ToString();
                    elInventario.Nombre_Implemento = row[RecursosBDModulo16.PARAMETRO_NOMBRE].ToString();
                    elInventario.Tipo_Implemento = row[RecursosBDModulo16.PARAMETRO_TIPO].ToString();
                    elInventario.Marca_Implemento = row[RecursosBDModulo16.PARAMETRO_MARCA].ToString();
                    elInventario.Precio_Implemento = int.Parse(row[RecursosBDModulo16.PARAMETRO_PRECIO].ToString());
                    laListaDeInventario.Add(elInventario);

                }

                return laListaDeInventario;
            }
            catch (Exception e)
            {
                throw e;
            }
        }
示例#4
0
文件: BDRol.cs 项目: ieba/sakaratedo
        public static List<Rol> ObtenerRolesSistema()
        {
            BDConexion laConexion;
            List<Rol> laListaDeRoles = new List<Rol>();
            List<Parametro> parametros;

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

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosBDModulo2.ConsultarRolesSistema, parametros);

                foreach (DataRow row in dt.Rows)
                {
                    Rol elRol = new Rol();
                    elRol.Id_rol = int.Parse(row[RecursosBDModulo2.AliasIdRol].ToString());
                    elRol.Nombre = row[RecursosBDModulo2.AliasNombreRol].ToString();
                    elRol.Descripcion = row[RecursosBDModulo2.AliasDescripcionRol].ToString();

                    laListaDeRoles.Add(elRol);
                }
            }
            catch (Exception e)
            {
                throw e;
            }
            return laListaDeRoles;
        }
示例#5
0
        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;
            }
        }
示例#6
0
        public static List<DominioSKD.Entidades.Modulo16.Matricula> mostrarMensualidadesmorosas()
        {
            BDConexion laConexion;
            List<DominioSKD.Entidades.Modulo16.Matricula> laListaDeMatriculas = new List<DominioSKD.Entidades.Modulo16.Matricula>();
            List<Parametro> parametros;

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

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosBDModulo16.StoreProcedureConsultarMatriculas, parametros);

                foreach (DataRow row in dt.Rows)
                {
                    DominioSKD.Entidades.Modulo16.Matricula laMatricula = new DominioSKD.Entidades.Modulo16.Matricula();

                    laMatricula.Id = int.Parse(row[RecursosBDModulo16.PARAMETRO_IDMATRICULA].ToString());
                    laMatricula.Identificador = (row[RecursosBDModulo16.aliasIdentificadorMatricula].ToString());
                    laMatricula.FechaCreacion = DateTime.Parse(row[RecursosBDModulo16.aliasFechainicio].ToString());
                    laMatricula.UltimaFechaPago = DateTime.Parse(row[RecursosBDModulo16.aliasFechatope].ToString());
                    laListaDeMatriculas.Add(laMatricula);

                }
                return laListaDeMatriculas;
            }

            catch (NullReferenceException ex)
            {

                throw new BDMatriculaException(RecursosBDModulo16.Codigo_ExcepcionNullReference,
                    RecursosBDModulo16.Mensaje_ExcepcionNullReference, ex);

            }

            catch (SqlException ex)
            {
                throw new BDMatriculaException(RecursosBDModulo16.Codigo_ExcepcionSql,
                    RecursosBDModulo16.Mensaje_ExcepcionSql, ex);

            }
            catch (ParametroIncorrectoException ex)
            {
                throw new ParametroIncorrectoException(RecursosBDModulo16.Codigo_ExcepcionParametro,
                    RecursosBDModulo16.Mensaje__ExcepcionParametro, ex);
            }
            catch (AtributoIncorrectoException ex)
            {
                throw new AtributoIncorrectoException(RecursosBDModulo16.Codigo_ExcepcionAtributo,
                    RecursosBDModulo16.Mensaje_ExcepcionAtributo, ex);
            }
            catch (Exception ex)
            {
                throw new BDMatriculaException(RecursosBDModulo16.Codigo_ExcepcionGeneral,
                   RecursosBDModulo16.Mensaje_ExcepcionGeneral, ex);

            }
        }
        /// <summary>
        /// Metodo para agregar una restriccion de cinta a la base de datos.
        /// </summary>
        /// <param name="parametro"></param>
        /// <returns></returns>
        public Boolean Agregar(DominioSKD.Entidad parametro)
        {
            DominioSKD.Entidades.Modulo8.RestriccionCinta laRestriccionCinta =
                (DominioSKD.Entidades.Modulo8.RestriccionCinta)parametro;
            try
            {
                List<Parametro> parametros = new List<Parametro>(); //declaras lista de parametros

                Parametro elParametro = new Parametro(RecursosDAORestriccionCinta.ParamDescripcionRestricionCinta, SqlDbType.VarChar,
                    laRestriccionCinta.Descripcion, false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAORestriccionCinta.ParamCintaNueva, SqlDbType.Int,
                        laRestriccionCinta.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAORestriccionCinta.ParamTiempoMinimo, SqlDbType.Int,
                        laRestriccionCinta.TiempoMinimo.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAORestriccionCinta.ParamHorasDocentes, SqlDbType.Int,
                        laRestriccionCinta.TiempoDocente.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAORestriccionCinta.ParamPuntosMinimos, SqlDbType.Int,
                        laRestriccionCinta.PuntosMinimos.ToString(), false);
                parametros.Add(elParametro);

                BDConexion laConexion = new BDConexion();
                laConexion.EjecutarStoredProcedure(RecursosDAORestriccionCinta.AgregarRestriccionCinta, parametros);
            }

            catch (SqlException ex)
            {
                throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
                        RecursoGeneralBD.Mensaje, ex);
            }
            catch (FormatException ex)
            {
                throw new ExcepcionesSKD.Modulo8.FormatoIncorrectoException(RecursosDAORestriccionCompetencia.Codigo_Error_Formato,
                     RecursosDAORestriccionCompetencia.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }

            return true;
        }
示例#8
0
        public static Cuenta ObtenerUsuario(string nombre_usuario)
        {
            BDConexion laConexion;//COnsultar la persona
            BDConexion laConexion2;//Consultar los roles de la persona
            List<Parametro> parametros;
            Parametro elParametro = new Parametro();

            try
            {
                laConexion = new BDConexion();
                laConexion2 = new BDConexion();
                parametros = new List<Parametro>();
                Cuenta laCuenta = new Cuenta();

                elParametro = new Parametro(RecursosBDModulo1.AliasNombreUsuario,SqlDbType.VarChar,nombre_usuario,false);

                parametros.Add(elParametro);

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosBDModulo1.ConsultarNombreUsuarioContrasena, parametros);

                foreach (DataRow row in dt.Rows)
                {

                    laCuenta.Id_usuario = int.Parse(row[RecursosBDModulo1.AliasIdUsuario].ToString());
                    laCuenta.Nombre_usuario = row[RecursosBDModulo1.AliasNombreUsuario].ToString();
                    laCuenta.Contrasena = row[RecursosBDModulo1.AliasContrasena].ToString();

                }

               DataTable dt1 = laConexion2.EjecutarStoredProcedureTuplas(
               RecursosBDModulo1.ConsultarRolesUsuario, parametros);
               List<Rol> listaRol = new List<Rol>();
               foreach (DataRow row in dt1.Rows)
               {

                    Rol elRol = new Rol();
                    elRol.Id_rol =int.Parse(row[RecursosBDModulo1.AliasIdRol].ToString());
                    elRol.Nombre = row[RecursosBDModulo1.AliasNombreRol].ToString();
                    elRol.Descripcion = row[RecursosBDModulo1.AliasDescripcionRol].ToString();
                    elRol.Fecha_creacion = (DateTime)row[RecursosBDModulo1.AliasFechaCreacion];
                    listaRol.Add(elRol);
               }
               laCuenta.Roles = listaRol;
                return laCuenta;

            }
            catch (Exception e)
            {
                throw e;
            }
        }
示例#9
0
        public static bool BuscarIDDojo(Dojo elDojo)
        {
            bool retorno = false;
            BDConexion laConexion;
            List<Parametro> parametros;

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

                Parametro elParametro = new Parametro(RecursosBDModulo4.ParamIdDojo, SqlDbType.Int
                                                      , elDojo.Id_dojo.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosBDModulo4.ParamSalidaNumDojo, SqlDbType.Int, true);
                parametros.Add(elParametro);

                List<Resultado> resultados = laConexion.EjecutarStoredProcedure(RecursosBDModulo4.BuscarIdDojo
                                             , parametros);

                foreach (Resultado elResultado in resultados)
                {
                    if (elResultado.etiqueta == RecursosBDModulo4.ParamSalidaNumDojo)
                        if (int.Parse(elResultado.valor) == 1)
                            retorno = true;
                        else
                            throw new ExcepcionesSKD.Modulo4.DojoInexistenteException(RecursosBDModulo4.Codigo_Dojo_Inexistente,
                                RecursosBDModulo4.Mensaje_Dojo_Inexistente, new Exception());
                }
            }
            catch (SqlException ex)
            {
                throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
                    RecursoGeneralBD.Mensaje, ex);
            }
            catch (FormatException ex)
            {
                throw new ExcepcionesSKD.Modulo4.FormatoIncorrectoException(RecursosBDModulo4.Codigo_Error_Formato,
                     RecursosBDModulo4.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }

            return retorno;
        }
示例#10
0
        /// <summary>
        /// Obtiene el cargo perteneciente a un usuario
        /// </summary>
        /// <param name="cargoUsuario">La clave foranea del cargo del usuario</param>
        /// <returns>returna el cargo del usuario a consultar</returns>
        public String ObtenerCargo(String userName)
        {
            SqlDataReader resultadoConsulta;
            BDConexion    conexionBd = new BDConexion();
            String        nombreCargo;

            conexionBd.Conectar();
            resultadoConsulta = conexionBd.EjecutarQuery(RecursosBaseDeDatosModulo7.QueryObtenerCargo + userName);
            conexionBd.Desconectar();
            if (resultadoConsulta.Read())
            {
                nombreCargo = resultadoConsulta.GetValue(0).ToString();
            }
            else
            {
                nombreCargo = "";
            }
            return(nombreCargo);
        }
示例#11
0
        /// <summary>
        /// Consulta la clave de un usuario
        /// </summary>
        /// <param name="userName">El nombre de usuario a buscar</param>
        /// <returns>returna true en caso de que el usuario se modifique y false en caso de que no</returns>
        public string ConsultarClaveUsuario(string userName)
        {
            Boolean          exito;
            string           claveUsuario = "";
            BDConexion       conexionBD   = new BDConexion();
            List <Parametro> parametros   = new List <Parametro>();
            Parametro        parametro    = new Parametro(RecursosBaseDeDatosModulo7.UsernameUsuario,
                                                          SqlDbType.VarChar, userName, false);

            parametros.Add(parametro);
            parametro = new Parametro(RecursosBaseDeDatosModulo7.ClaveUsuario,
                                      SqlDbType.VarChar, true);
            parametros.Add(parametro);
            string           query      = RecursosBaseDeDatosModulo7.ConsultarClaveUsuario;
            List <Resultado> resultados = conexionBD.EjecutarStoredProcedure(query, parametros);

            claveUsuario = resultados[0].valor;
            return(claveUsuario);
        }
示例#12
0
        /// <summary>
        /// Registra un Usuario nuevo en la base de datos
        /// </summary>
        /// <param name="elUsuario">El usuario que se registrara</param>
        /// <returns>returna true en caso de que se completara el registro, y false en caso de que no</returns>
        public Boolean RegitrarUsuario(Usuario elUsuario)
        {
            Boolean          exito;
            BDConexion       conexionBD = new BDConexion();
            List <Parametro> parametros = new List <Parametro>();

            try{
                Parametro parametro = new Parametro(RecursosBaseDeDatosModulo7.UsernameUsuario,
                                                    SqlDbType.VarChar, elUsuario.username, false);
                parametros.Add(parametro);
                parametro = new Parametro(RecursosBaseDeDatosModulo7.ClaveUsuario,
                                          SqlDbType.VarChar, elUsuario.clave, false);
                parametros.Add(parametro);
                parametro = new Parametro(RecursosBaseDeDatosModulo7.NombreUsuario,
                                          SqlDbType.VarChar, elUsuario.nombre, false);
                parametros.Add(parametro);
                parametro = new Parametro(RecursosBaseDeDatosModulo7.ApellidoUsuario,
                                          SqlDbType.VarChar, elUsuario.apellido, false);
                parametros.Add(parametro);
                parametro = new Parametro(RecursosBaseDeDatosModulo7.RolUsuario,
                                          SqlDbType.VarChar, elUsuario.rol, false);
                parametros.Add(parametro);
                parametro = new Parametro(RecursosBaseDeDatosModulo7.CorreoUsuario,
                                          SqlDbType.VarChar, elUsuario.correo, false);
                parametros.Add(parametro);
                parametro = new Parametro(RecursosBaseDeDatosModulo7.PreguntaUsuario,
                                          SqlDbType.VarChar, elUsuario.preguntaSeguridad, false);
                parametros.Add(parametro);
                parametro = new Parametro(RecursosBaseDeDatosModulo7.RespuestaUsuario,
                                          SqlDbType.VarChar, elUsuario.respuestaSeguridad, false);
                parametros.Add(parametro);
                parametro = new Parametro(RecursosBaseDeDatosModulo7.CargoUsuario,
                                          SqlDbType.VarChar, elUsuario.cargo, false);
                parametros.Add(parametro);
                string query = RecursosBaseDeDatosModulo7.ProcedimientoInsertarUsuario;
                //conexionBD.Conectar();
                List <Resultado> resultados = conexionBD.EjecutarStoredProcedure(query, parametros);
            }
            catch (SqlException) {
                return(false);
            }
            return(true);
        }
示例#13
0
        /// <summary>
        /// Verifica que la respuesta de seguridad sea correcta
        /// </summary>
        /// <param name="userName">El username del usuario</param>
        /// <param name="preguntaUsuario">la  pregunta del usuario</param>
        /// <param name="respuestaUsuario">la respuesta del usuario</param>
        /// <returns>returna true en caso de que la pregunta y a respuesta concuerde con lo que esta en la base de datos y false en caso de que no coincida</returns>
        public Boolean ConsultaPregunta(String userName, String preguntaUsuario, String respuestaUsuario)
        {
            SqlDataReader resultadoConsulta;
            BDConexion    conexionBd     = new BDConexion();
            Boolean       valorResultado = false;

            conexionBd.Conectar();
            resultadoConsulta = conexionBd.EjecutarQuery("SELECT * FROM USUARIO WHERE usu_username="******" AND usu_pregseguridad=" + preguntaUsuario + " AND usu_respseguridad=" + preguntaUsuario);
            conexionBd.Desconectar();
            if (resultadoConsulta.HasRows)
            {
                valorResultado = true;
            }
            else
            {
                valorResultado = false;
            }
            return(valorResultado);
        }
        public static int Actualizar(Mecanico pMecanico)
        {
            using (MySqlCommand cmd = new MySqlCommand())
            {
                try
                {
                    int retorno = 0;
                    // setear parametros del command
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.Connection  = BDConexion.ObtenerConexion();
                    cmd.CommandText = "ActualizarMec";

                    //asignar paramentros
                    cmd.Parameters.AddWithValue("_id", pMecanico.id);
                    cmd.Parameters.AddWithValue("_nombre", pMecanico.nombre);
                    cmd.Parameters.AddWithValue("_app", pMecanico.app);
                    cmd.Parameters.AddWithValue("_apm", pMecanico.apm);
                    cmd.Parameters.AddWithValue("_ciudad", pMecanico.ciudad);
                    cmd.Parameters.AddWithValue("_calle", pMecanico.calle);
                    cmd.Parameters.AddWithValue("_numero", pMecanico.numero);
                    cmd.Parameters.AddWithValue("_colonia", pMecanico.colonia);
                    cmd.Parameters.AddWithValue("_cp", pMecanico.cp);
                    cmd.Parameters.AddWithValue("_curp", pMecanico.curp);
                    cmd.Parameters.AddWithValue("_rfc", pMecanico.rfc);
                    cmd.Parameters.AddWithValue("_fechaN", pMecanico.fecha);
                    cmd.Parameters.AddWithValue("_tel", pMecanico.telefono);
                    //abrir la conexion
                    BDConexion.ObtenerConexion();

                    //ejecutar el query
                    retorno = cmd.ExecuteNonQuery();
                    return(retorno);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    BDConexion.CerrarConexion();
                } // end try
            }     // end using
        }         // end GuardarHuella
示例#15
0
        public List <String> LeerCargosUsuarios()
        {
            List <String>    laLista    = new List <String>();
            BDConexion       laConexion = new BDConexion();
            List <Parametro> parametros = new List <Parametro>();

            try
            {
                laConexion = new BDConexion();
                DataTable dt = laConexion.EjecutarStoredProcedureTuplas("seleccionarCargosUsuarios", parametros);
                foreach (DataRow row in dt.Rows)
                {
                    laLista.Add(row["nombreCargo"].ToString());
                }
            }
            catch (Exception ex)
            {
            }
            return(laLista);
        }
示例#16
0
        public List <Conductor> Listar()
        {
            List <Conductor> lista = new List <Conductor>();
            SqlConnection    cn    = new BDConexion().ObtenerConexion();

            try
            {
                SqlCommand cmd = new SqlCommand("SP_CONDUCTOR_LISTAR", cn);
                cmd.CommandType = CommandType.StoredProcedure;

                cn.Open();

                SqlDataReader dr = cmd.ExecuteReader();
                while (dr.Read())
                {
                    lista.Add(new Conductor()
                    {
                        ConductorId         = dr.GetInt32(0),
                        Dni                 = dr.GetString(1),
                        Nombre              = dr.GetString(2),
                        ApellidoPaterno     = dr.GetString(3),
                        ApellidoMaterno     = dr.GetString(4),
                        Brevete             = dr.GetString(5),
                        Telefono            = dr.GetString(6),
                        Estado              = dr.GetString(7),
                        IdTipoDocumento     = dr.GetInt32(8),
                        NombreTipoDocumento = dr.GetString(9)
                    });
                }
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                cn.Close();
            }

            return(lista);
        }
示例#17
0
        /// <summary>
        /// Método para consultar un proyecto en la bd
        /// </summary>
        /// <param name="username">nombre del usuario a consultar </param>
        /// <returns>Retrorna el proyecto</returns>
        public static DataTable ConsultarProyectosUsuario(String username)
        {
            try
            {
                //parametros para insertar un proyecto
                List <Parametro> parametros = new List <Parametro>();
                Parametro        parametro  = new Parametro(RecursosBDModulo4.ParametroUsuario, SqlDbType.VarChar, username, false);
                parametros.Add(parametro);

                /*parametro = new Parametro(RecursosBDModulo4.ParametroCodigoProyecto, SqlDbType.VarChar, true);
                 * parametros.Add(parametro);
                 * parametro = new Parametro(RecursosBDModulo4.ParametroNombreProyecto, SqlDbType.VarChar, true);
                 * parametros.Add(parametro);
                 * parametro = new Parametro(RecursosBDModulo4.ParametroEstadoProyecto, SqlDbType.Bit, true);
                 * parametros.Add(parametro);
                 * parametro = new Parametro(RecursosBDModulo4.ParametroDescripcionProyecto, SqlDbType.VarChar, true);
                 * parametros.Add(parametro);
                 * parametro = new Parametro(RecursosBDModulo4.ParametroCostoProyecto, SqlDbType.Int, true);
                 * parametros.Add(parametro);
                 * parametro = new Parametro(RecursosBDModulo4.ParametroMonedaProyecto, SqlDbType.VarChar, true);
                 * parametros.Add(parametro);*/

                BDConexion con        = new BDConexion();
                DataTable  resultados = con.EjecutarStoredProcedureTuplas(RecursosBDModulo4.ProcedimientosProyectosDeUsuario, parametros);


                if (resultados.Rows.Count > 0)
                {
                    return(resultados);
                }
                else
                {
                    throw new ExcepcionesTotem.Modulo4.InvolucradosInexistentesException(RecursosBDModulo4.CodigoInvolucradosInexistentes,
                                                                                         RecursosBDModulo4.MensajeInvolucradosInexistentes, new Exception());
                }
            }
            catch (ExcepcionesTotem.Modulo4.InvolucradosInexistentesException e)
            {
                throw e;
            }
        }
示例#18
0
        /// <summary>
        /// Metodo que devueve un tipoimplemnto dado su id
        /// </summary>
        /// <param name="Id_implemento">Indica el objeto a detallar</param>
        /// <returns>Retorna un implemento en especifico con todos sus detalles</returns>
        public static DominioSKD.Entidades.Modulo16.Implemento DetallarImplemento(int Id_implemento)
        {
            BDConexion laConexion;
            List<Parametro> parametros;
            Parametro elParametro = new Parametro();

            try
            {
                laConexion = new BDConexion();
                parametros = new List<Parametro>();
                DominioSKD.Entidades.Modulo16.Implemento elImplemento = new DominioSKD.Entidades.Modulo16.Implemento();

                elParametro = new Parametro(RecursosBDModulo16.PARAMETRO_ITEM, SqlDbType.Int, Id_implemento.ToString(),
                                            false);
                parametros.Add(elParametro);

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosBDModulo16.DETALLAR_IMPLEMENTO, parametros);

                foreach (DataRow row in dt.Rows)
                {
                    elImplemento.Imagen_implemento = row[RecursosBDModulo16.PARAMETRO_IMAGEN].ToString();
                    elImplemento.Nombre_Implemento = row[RecursosBDModulo16.PARAMETRO_NOMBRE].ToString();
                    elImplemento.Tipo_Implemento = row[RecursosBDModulo16.PARAMETRO_TIPO].ToString();
                    elImplemento.Marca_Implemento = row[RecursosBDModulo16.PARAMETRO_MARCA].ToString();
                    elImplemento.Color_Implemento = row[RecursosBDModulo16.PARAMETRO_COLOR].ToString();
                    elImplemento.Talla_Implemento = row[RecursosBDModulo16.PARAMETRO_TALLA].ToString();
                    elImplemento.Estatus_Implemento = row[RecursosBDModulo16.PARAMETRO_ESTATUS].ToString();
                    elImplemento.Precio_Implemento = int.Parse(row[RecursosBDModulo16.PARAMETRO_PRECIO].ToString());
                    elImplemento.Descripcion_Implemento = row[RecursosBDModulo16.PARAMETRO_DESCRIPCION].ToString();

                }
                return elImplemento;

            }
            catch (Exception e)
            {
                throw e;
            }
        }
示例#19
0
        public static bool AgregarRol(string idUsuario, string idRol)
        {
            BDConexion       laConexion;
            List <Parametro> parametros;
            Parametro        elParametro = new Parametro();

            try
            {
                laConexion  = new BDConexion();
                parametros  = new List <Parametro>();
                elParametro = new Parametro(RecursosBDModulo2.AliasIdRol, SqlDbType.VarChar, idRol, false);
                parametros.Add(elParametro);
                elParametro = new Parametro(RecursosBDModulo2.aliasIdUsuario, SqlDbType.VarChar, idUsuario, false);
                parametros.Add(elParametro);
                laConexion.EjecutarStoredProcedureTuplas(RecursosBDModulo2.AgregarRolProcedure, parametros);
                return(true);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
示例#20
0
        /// <summary>
        /// Procedimiento para obtener todos los usuarios registrados en el sistema
        /// </summary>
        /// <returns>Returna una lista con todos los usuarios que hay en el sistema</returns>
        public List <Usuario> ObtenerListaUsuario()
        {
            SqlDataReader  resultadoConsulta;
            List <Usuario> listUsuario = new List <Usuario>();
            BDConexion     conexionBd  = new BDConexion();

            resultadoConsulta = conexionBd.EjecutarQuery(RecursosBaseDeDatosModulo7.QueryListarUsuario);
            while (resultadoConsulta.Read())
            {
                listUsuario.Add(new Usuario(resultadoConsulta.GetInt32(0),
                                            resultadoConsulta.GetValue(1).ToString(),
                                            resultadoConsulta.GetValue(2).ToString(),
                                            resultadoConsulta.GetValue(3).ToString(),
                                            resultadoConsulta.GetValue(4).ToString(),
                                            resultadoConsulta.GetValue(5).ToString(),
                                            resultadoConsulta.GetValue(6).ToString(),
                                            resultadoConsulta.GetValue(7).ToString(),
                                            resultadoConsulta.GetValue(8).ToString(),
                                            resultadoConsulta.GetValue(9).ToString()));
            }
            return(listUsuario);
        }
示例#21
0
        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;
            }
        }
示例#22
0
        public static bool EliminarRol(string idUsuario, string idRol)
        {
            BDConexion laConexion;
               List<Parametro> parametros;
               Parametro elParametro = new Parametro();

               try
               {
               laConexion = new BDConexion();
               parametros = new List<Parametro>();
               elParametro = new Parametro(RecursosBDModulo2.AliasIdRol, SqlDbType.VarChar, idRol, false);
               parametros.Add(elParametro);
               elParametro = new Parametro(RecursosBDModulo2.aliasIdUsuario, SqlDbType.VarChar, idUsuario, false);
               parametros.Add(elParametro);
               laConexion.EjecutarStoredProcedureTuplas( RecursosBDModulo2.EliminarRolProcedure, parametros);
               return true;

               }
               catch (Exception e)
               {
               throw e;
               }
        }
示例#23
0
        public int Actualizar(Vehiculo v)
        {
            int           resultado = -1;
            SqlConnection cn        = new BDConexion().ObtenerConexion();

            try
            {
                SqlCommand cmd = new SqlCommand("SP_ACTUALIZAR_VEHICULO", cn);
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.Parameters.AddWithValue("@placa", v.Placa);
                cmd.Parameters.AddWithValue("@marca", v.Marca);
                cmd.Parameters.AddWithValue("@modelo", v.Modelo);
                cmd.Parameters.AddWithValue("@anioFabricacion", v.AnioFabricacion);
                cmd.Parameters.AddWithValue("@certificado", v.Certificado);
                cmd.Parameters.AddWithValue("@pesoMaximo", v.PesoMaximo);
                cmd.Parameters.AddWithValue("@volumenMaximo", v.VolumenMaximo);
                cmd.Parameters.AddWithValue("@id", v.IdVehiculo);
                cn.Open();
                resultado = cmd.ExecuteNonQuery();
            }
            catch (Exception) { throw; }
            finally { cn.Close(); }
            return(resultado);
        }
示例#24
0
        /// <summary>
        /// Permite consultar la informacion de un usuario, segun su nombre, apellido y cargo
        /// </summary>
        /// <param name="nombre">El nombre del usuario que se desea consultar</param>
        /// <param name="apellido">El apellido del usuario que se desea consultar </param>
        /// <param name="cargo">El cargo del usuario que se desea consultar</param>
        /// <returns>Returna el usuario que a consultar</returns>
        public Usuario ConsultarDatosUsuario(String nombre, String apellido, String cargo)
        {
            SqlDataReader resultadoConsulta;
            Usuario       usuario    = new Usuario();
            BDConexion    conexionBd = new BDConexion();

            conexionBd.Conectar();
            resultadoConsulta = conexionBd.EjecutarQuery("SELECT * FROM USUARIO WHERE usu_nombre =" + nombre + "AND usu_apellido=" + apellido + " CARGO_car_id=(SELECT car_id FROM CARGO WHERE car_nombre=" + cargo + ")");
            conexionBd.Desconectar();
            if (resultadoConsulta.Read())
            {
                usuario = new Usuario(resultadoConsulta.GetInt32(0),
                                      resultadoConsulta.GetString(1),
                                      resultadoConsulta.GetString(2),
                                      resultadoConsulta.GetString(3),
                                      resultadoConsulta.GetString(4),
                                      resultadoConsulta.GetString(5),
                                      resultadoConsulta.GetString(6),
                                      resultadoConsulta.GetString(7),
                                      resultadoConsulta.GetString(8),
                                      resultadoConsulta.GetString(9));
            }
            return(usuario);
        }
示例#25
0
        public void PruebaParametroInvalidoException()
        {
            try
            {
                List <Parametro> parametros = new List <Parametro>();
                Parametro        parametro  = null;
                parametros.Add(parametro);

                BDConexion con = new BDConexion();
                con.AsignarParametros(parametros);
                Assert.Fail("Una excepcion se ha debido de lanzar");
            }
            catch (ParametroInvalidoException parametroInvalidoException)
            {
                Assert.AreEqual("Error en un parametro del stored procedure", parametroInvalidoException.Mensaje);
            }
            catch (Exception e)
            {
                Assert.Fail(
                    string.Format("Unexpected exception of type {0} caught: {1}",
                                  e.GetType(), e.Message)
                    );
            }
        }
示例#26
0
        /// <summary>
        /// Método para Eliminar un proyecto en la bd(solo para pruebas unitarias)
        /// </summary>
        /// <param name="codigo">codigo del proyecto a Eliminar</param>
        /// <returns>Retrorna True si se modifica, False si no </returns>
        public static bool EliminarProyecto(String codigo)
        {
            List <Parametro> parametros = new List <Parametro>();
            Parametro        parametro  = new Parametro(RecursosBDModulo4.ParametroCodigoProyecto, SqlDbType.VarChar, codigo, false);

            parametros.Add(parametro);
            try
            {
                BDConexion       con        = new BDConexion();
                List <Resultado> resultados = con.EjecutarStoredProcedure(RecursosBDModulo4.ProcedimientoEliminarProyecto, parametros);
                if (resultados != null)
                {
                    return(true);
                }
                else
                {
                    throw new NotImplementedException();
                }
            }
            catch (NotImplementedException e)
            {
                throw e;
            }
        }
示例#27
0
        public static List <Competencia> ListarCompetencias()
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            BDConexion         laConexion;
            List <Competencia> laListaDeCompetencias = new List <Competencia>();
            List <Parametro>   parametros;

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


                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                    RecursosBDModulo12.ConsultarCompetencias, parametros);

                foreach (DataRow row in dt.Rows)
                {
                    Competencia laCompetencia = new Competencia();

                    laCompetencia.Id_competencia  = int.Parse(row[RecursosBDModulo12.AliasIdCompetencia].ToString());
                    laCompetencia.Nombre          = row[RecursosBDModulo12.AliasNombreCompetencia].ToString();
                    laCompetencia.TipoCompetencia = row[RecursosBDModulo12.AliasTipoCompetencia].ToString();

                    if (laCompetencia.TipoCompetencia == "1")
                    {
                        laCompetencia.TipoCompetencia = RecursosBDModulo12.TipoCompetenciaKata;
                    }
                    else
                    {
                        laCompetencia.TipoCompetencia = RecursosBDModulo12.TipoCompetenciaKumite;
                    }

                    laCompetencia.Status            = row[RecursosBDModulo12.AliasStatusCompetencia].ToString();
                    laCompetencia.OrganizacionTodas = Convert.ToBoolean(row[RecursosBDModulo12.AliasTodasOrganizaciones].ToString());

                    if (laCompetencia.OrganizacionTodas == false)
                    {
                        laCompetencia.Organizacion = new Organizacion(int.Parse(row[RecursosBDModulo12.AliasIdOrganizacion].ToString())
                                                                      , row[RecursosBDModulo12.AliasNombreOrganizacion].ToString());
                    }
                    else
                    {
                        laCompetencia.Organizacion = new Organizacion(RecursosBDModulo12.TodasLasOrganizaciones);
                    }
                    laCompetencia.Ubicacion = new Ubicacion(int.Parse(row[RecursosBDModulo12.AliasIdUbicacion].ToString()),
                                                            row[RecursosBDModulo12.AliasNombreCiudad].ToString(),
                                                            row[RecursosBDModulo12.AliasNombreEstado].ToString());

                    laListaDeCompetencias.Add(laCompetencia);
                }
            }
            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.Modulo12.FormatoIncorrectoException(RecursosBDModulo12.Codigo_Error_Formato,
                                                                             RecursosBDModulo12.Mensaje_Error_Formato, 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);
            }

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return(laListaDeCompetencias);
        }
示例#28
0
        public static Competencia DetallarCompetencia(int idCompetencia)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);
            BDConexion       laConexion;
            List <Parametro> parametros;
            Parametro        elParametro   = new Parametro();
            Competencia      laCompetencia = new Competencia();

            laCompetencia.Id_competencia = idCompetencia;
            int    diaFecha;
            int    mesFecha;
            int    anoFecha;
            string fechaInicio;
            string fechaFin;

            try
            {
                if (BuscarIDCompetencia(laCompetencia))
                {
                    laConexion = new BDConexion();
                    parametros = new List <Parametro>();


                    elParametro = new Parametro(RecursosBDModulo12.ParamIdCompetencia, SqlDbType.Int, idCompetencia.ToString(),
                                                false);
                    parametros.Add(elParametro);

                    DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                        RecursosBDModulo12.ConsultarCompetenciasXId, parametros);

                    foreach (DataRow row in dt.Rows)
                    {
                        laCompetencia.Id_competencia  = int.Parse(row[RecursosBDModulo12.AliasIdCompetencia].ToString());
                        laCompetencia.Nombre          = row[RecursosBDModulo12.AliasNombreCompetencia].ToString();
                        laCompetencia.TipoCompetencia = row[RecursosBDModulo12.AliasTipoCompetencia].ToString();

                        if (laCompetencia.TipoCompetencia == "1")
                        {
                            laCompetencia.TipoCompetencia = RecursosBDModulo12.TipoCompetenciaKata;
                        }
                        else
                        {
                            laCompetencia.TipoCompetencia = RecursosBDModulo12.TipoCompetenciaKumite;
                        }

                        laCompetencia.Status            = row[RecursosBDModulo12.AliasStatusCompetencia].ToString();
                        laCompetencia.OrganizacionTodas = Convert.ToBoolean(row[RecursosBDModulo12.AliasTodasOrganizaciones].ToString());

                        diaFecha    = Convert.ToDateTime(row[RecursosBDModulo12.AliasFechaInicio]).Day;
                        mesFecha    = Convert.ToDateTime(row[RecursosBDModulo12.AliasFechaInicio]).Month;
                        anoFecha    = Convert.ToDateTime(row[RecursosBDModulo12.AliasFechaInicio]).Year;
                        fechaInicio = mesFecha.ToString() + "/" + diaFecha.ToString() + "/" + anoFecha.ToString();
                        //laCompetencia.FechaInicio = Convert.ToDateTime(fechaInicio);

                        laCompetencia.FechaInicio = DateTime.ParseExact(fechaInicio, "mm/dd/yyyy",
                                                                        CultureInfo.InvariantCulture);

                        diaFecha = Convert.ToDateTime(row[RecursosBDModulo12.AliasFechaFin]).Day;
                        mesFecha = Convert.ToDateTime(row[RecursosBDModulo12.AliasFechaFin]).Month;
                        anoFecha = Convert.ToDateTime(row[RecursosBDModulo12.AliasFechaFin]).Year;
                        fechaFin = mesFecha.ToString() + "/" + diaFecha.ToString() + "/" + anoFecha.ToString();
                        //laCompetencia.FechaFin = Convert.ToDateTime(fechaFin);

                        laCompetencia.FechaFin = DateTime.ParseExact(fechaFin, "mm/dd/yyyy",
                                                                     CultureInfo.InvariantCulture);

                        laCompetencia.Costo = float.Parse(row[RecursosBDModulo12.AliasCostoCompetencia].ToString());

                        if (laCompetencia.OrganizacionTodas == false)
                        {
                            laCompetencia.Organizacion = new Organizacion(int.Parse(row[RecursosBDModulo12.AliasIdOrganizacion].ToString())
                                                                          , row[RecursosBDModulo12.AliasNombreOrganizacion].ToString());
                        }
                        else
                        {
                            laCompetencia.Organizacion = new Organizacion(RecursosBDModulo12.TodasLasOrganizaciones);
                        }
                        laCompetencia.Ubicacion = new Ubicacion(int.Parse(row[RecursosBDModulo12.AliasIdUbicacion].ToString()),
                                                                row[RecursosBDModulo12.AliasLatitudDireccion].ToString(),
                                                                row[RecursosBDModulo12.AliasLongitudDireccion].ToString(),
                                                                row[RecursosBDModulo12.AliasNombreCiudad].ToString(),
                                                                row[RecursosBDModulo12.AliasNombreEstado].ToString(),
                                                                row[RecursosBDModulo12.AliasNombreDireccion].ToString());

                        laCompetencia.Categoria = new Categoria(int.Parse(row[RecursosBDModulo12.AliasIdCategoria].ToString()),
                                                                int.Parse(row[RecursosBDModulo12.AliasEdadInicio].ToString()),
                                                                int.Parse(row[RecursosBDModulo12.AliasEdadFin].ToString()),
                                                                row[RecursosBDModulo12.AliasCintaInicio].ToString(),
                                                                row[RecursosBDModulo12.AliasCintaFin].ToString(),
                                                                row[RecursosBDModulo12.AliasSexo].ToString());
                    }

                    Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

                    return(laCompetencia);
                }
                else
                {
                    Logger.EscribirWarning(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.Mensaje_Competencia_Inexistente, System.Reflection.MethodBase.GetCurrentMethod().Name);

                    throw new ExcepcionesSKD.Modulo12.CompetenciaInexistenteException(RecursosBDModulo12.Codigo_Competencia_Inexistente,
                                                                                      RecursosBDModulo12.Mensaje_Competencia_Inexistente, new Exception());
                }
            }
            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.Modulo12.FormatoIncorrectoException(RecursosBDModulo12.Codigo_Error_Formato,
                                                                             RecursosBDModulo12.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesSKD.Modulo12.CompetenciaInexistenteException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw 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);
            }
        }
示例#29
0
        public static List<Organizacion> M12ListarOrganizaciones()
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            BDConexion laConexion;
            List<Organizacion> laListaOrganizaciones = new List<Organizacion>();
            List<Parametro> parametros;

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

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosBDModulo12.ConsultarOrganizaciones, parametros);

                foreach (DataRow row in dt.Rows)
                {
                    Organizacion laOrganizacion = new Organizacion();

                    laOrganizacion.Id_organizacion = int.Parse(row[RecursosBDModulo12.AliasIdOrganizacion].ToString());
                    laOrganizacion.Nombre = row[RecursosBDModulo12.AliasNombreOrganizacion].ToString();

                    laListaOrganizaciones.Add(laOrganizacion);

                }

            }
            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.Modulo12.FormatoIncorrectoException(RecursosBDModulo12.Codigo_Error_Formato,
                     RecursosBDModulo12.Mensaje_Error_Formato, 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);
            }

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return laListaOrganizaciones;
        }
示例#30
0
        public List<Cuenta> ListarUsuarios()
        {
            BDConexion laConexion;//COnsultar la persona
            BDConexion laConexion2;//Consultar los roles de la persona
            BDConexion laConexion3;//Crea el objeto PERSONA
            List<Parametro> parametros;
            List<Parametro> parametros2;
            Parametro elParametro = new Parametro();

            try
            {

                parametros = new List<Parametro>();
                laConexion = new BDConexion();
                List<Cuenta> lasCuentas = new List<Cuenta>();

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                                RecursosBDM1.listarUsuarios, parametros);

                foreach (DataRow row in dt.Rows)
                {
                    laConexion2 = new BDConexion();
                    laConexion3 = new BDConexion();
                    parametros2 = new List<Parametro>();
                    parametros = new List<Parametro>();
                    string idUsuario = RecursosBDM1.idInicial;
                    Cuenta laCuenta = new Cuenta();
                    laCuenta.Nombre_usuario = row[RecursosBDM1.AliasNombreUsuario].ToString();
                    laCuenta.Imagen = row[RecursosBDM1.AliasImagen].ToString();
                    idUsuario = row[RecursosBDM1.AliasIdUsuario].ToString();
                    elParametro =
                        new Parametro(RecursosBDM1.AliasNombreUsuario, SqlDbType.VarChar, laCuenta.Nombre_usuario, false);
                    parametros.Add(elParametro);
                    DataTable dt1 = laConexion2.EjecutarStoredProcedureTuplas(
                RecursosBDM1.ConsultarRolesUsuario, parametros);
                    List<Rol> listaRol = new List<Rol>();
                    foreach (DataRow row2 in dt1.Rows)
                    {

                        Rol elRol = new Rol();
                        elRol.Id_rol = int.Parse(row2[RecursosBDM1.AliasIdRol].ToString());
                        elRol.Nombre = row2[RecursosBDM1.AliasNombreRol].ToString();
                        elRol.Descripcion = row2[RecursosBDM1.AliasDescripcionRol].ToString();
                        elRol.Fecha_creacion = (DateTime)row2[RecursosBDM1.AliasFechaCreacion];
                        listaRol.Add(elRol);
                    }
                    laCuenta.Roles = listaRol;

                    elParametro = new Parametro(RecursosBDM1.AliasIdUsuario, SqlDbType.Int, idUsuario, false);
                    parametros2.Add(elParametro);
                    DataTable dt2 = laConexion3.EjecutarStoredProcedureTuplas(
                                    RecursosBDM1.consultarPersona, parametros2);

                    PersonaM1 laPersona = new PersonaM1();
                    foreach (DataRow row3 in dt2.Rows)
                    {

                        laPersona._Id = int.Parse(row3[RecursosBDM1.AliasIdUsuario].ToString());
                        laPersona._Nombre = row3[RecursosBDM1.AliasNombreUsuario].ToString();
                        laPersona._Apellido = row3[RecursosBDM1.aliasApellidoUsuario].ToString();
                        laPersona._DocumentoID = row3[RecursosBDM1.AliasDocumento].ToString();
                    }
                    laCuenta.PersonaUsuario = laPersona;

                    lasCuentas.Add(laCuenta);
                }

                //Llenar el usuario

                return lasCuentas;

            }
            catch (SqlException e)
            {
                throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
                    RecursoGeneralBD.Mensaje, e);
            }
            catch (FormatException e)
            {
                throw new ExcepcionesSKD.Modulo12.FormatoIncorrectoException(RecursosBDM1.Codigo_Error_Formato,
                     RecursosBDM1.Mensaje_Error_Formato, e);
            }
            catch (ExcepcionesSKD.ExceptionSKDConexionBD e)
            {
                throw e;
            }
            catch (Exception e)
            {
                throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, e);
            }
        }
        /// <summary>
        /// Metodo para modificar a un cliente potencial dentro de la base de datos
        /// </summary>
        /// <param name="parametro"></param>
        /// <returns></returns>
        public bool Modificar(Entidad parametro)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceClientePotencial.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);
            ClientePotencial elClientePotencial = (ClientePotencial)parametro;
            List <Parametro> parameters         = new List <Parametro>();
            BDConexion       theConnection      = new BDConexion();
            Parametro        theParam           = new Parametro();

            try
            {
                theParam = new Parametro(ResourceClientePotencial.AidClientePotencial, SqlDbType.Int,
                                         elClientePotencial.IdClientePotencial.ToString(), false);
                parameters.Add(theParam);

                theParam = new Parametro(ResourceClientePotencial.AnombreClientePotencial, SqlDbType.VarChar,
                                         elClientePotencial.NombreClientePotencial, false);
                parameters.Add(theParam);

                theParam = new Parametro(ResourceClientePotencial.ArifClientePotencial, SqlDbType.VarChar,
                                         elClientePotencial.RifClientePotencial, false);
                parameters.Add(theParam);

                theParam = new Parametro(ResourceClientePotencial.AemailClientePotencial, SqlDbType.VarChar,
                                         elClientePotencial.EmailClientePotencial, false);
                parameters.Add(theParam);

                theParam = new Parametro(ResourceClientePotencial.ApresupuestoAnualInversion, SqlDbType.Decimal,
                                         elClientePotencial.PresupuestoAnual_inversion.ToString(), false);
                parameters.Add(theParam);

                theParam = new Parametro(ResourceClientePotencial.AnumLlamadas, SqlDbType.Int,
                                         elClientePotencial.NumeroLlamadas.ToString(), false);
                parameters.Add(theParam);

                theParam = new Parametro(ResourceClientePotencial.AnumVisitas, SqlDbType.Int,
                                         elClientePotencial.NumeroVisitas.ToString(), false);
                parameters.Add(theParam);

                List <Resultado> results =
                    theConnection.EjecutarStoredProcedure(ResourceClientePotencial.SP_modificarClientePotencial, parameters);
            }
            catch (ArgumentNullException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.M3.NullArgumentExceptionLeads(RecursoGeneralBD.Codigo,
                                                                             RecursoGeneralBD.Mensaje, ex);
            }
            catch (SqlException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.ExceptionTGConBD(RecursoGeneralBD.Codigo,
                                                                RecursoGeneralBD.Mensaje, ex);
            }
            catch (FormatException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExcepcionesTangerine.M3.WrongFormatExceptionLeads(ResourceClientePotencial.Codigo_Error_Formato,
                                                                            ResourceClientePotencial.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesTangerine.ExceptionTGConBD 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 ExcepcionesTangerine.ExceptionsTangerine(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceClientePotencial.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return(true);
        }
示例#32
0
        /// <summary>
        /// Verifica si existe o no un registro de rif de un dojo en la base de datos
        /// debido a que un rif debe ser único para cada dojo/
        /// </summary>
        /// <param name="parametro">rif a consultar</param>
        /// <returns>True si el rif existe y False en caso contrario</returns>
        public bool BuscarRifDojo(Entidad parametro)
        {
            bool retorno = false;
            BDConexion laConexion;
            List<Parametro> parametros;

            try
            {
                DojoM4 elDojo = (DojoM4)FabricaEntidades.ObtenerDojo_M4();
                elDojo = (DojoM4)parametro;

                laConexion = new BDConexion();
                parametros = new List<Parametro>();

                Parametro elParametro = new Parametro(RecursosDAOModulo4.ParamRifDojo, SqlDbType.VarChar, elDojo.Rif_dojo.ToString(),
                                               false);
                parametros.Add(elParametro);
                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(RecursosDAOModulo4.BuscarRifDojo, parametros);

                if (dt != null)
                {
                    foreach (DataRow row in dt.Rows)
                    {
                        string data = row[RecursosDAOModulo4.ParametroRifDojo].ToString();
                        if (String.Equals(elDojo.Rif_dojo, data))
                        {
                            retorno = true;
                            break;
                        }
                        else retorno = false;
                    }
                }
                else return false;
            }
            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.Modulo12.FormatoIncorrectoException(RecursosDAOModulo4.Codigo_Error_Formato,
                     RecursosDAOModulo4.Mensaje_Error_Formato, 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);
            }

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo4.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return retorno;
        }
示例#33
0
        public static List<Dojo> ListarDojos()
        {
            BDConexion laConexion;
            List<Dojo> laListaDeDojos = new List<Dojo>();
            List<Parametro> parametros;

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

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosBDModulo4.ConsultarDojos, parametros);
                foreach (DataRow row in dt.Rows)
                {

                    Dojo elDojo = new Dojo();

                    elDojo.Id_dojo= int.Parse(row[RecursosBDModulo4.AliasIdDojo].ToString());
                    elDojo.OrgNombre_dojo = row[RecursosBDModulo4.AliasRifDojo].ToString();
                    elDojo.Nombre_dojo = row[RecursosBDModulo4.AliasNombreDojo].ToString();
                    elDojo.Telefono_dojo = int.Parse(row[RecursosBDModulo4.AliasTelefonoDojo].ToString());
                    elDojo.Email_dojo = row[RecursosBDModulo4.AliasEmailDojo].ToString();
                    elDojo.Logo_dojo = row[RecursosBDModulo4.AliasLogoDojo].ToString();
                    elDojo.Status_dojo = row[RecursosBDModulo4.AliasStatusDojo].ToString();
                    elDojo.OrgNombre_dojo = row[RecursosBDModulo4.AliasNombreOrganizacion].ToString();
                    elDojo.Registro_dojo = DateTime.Parse(row[RecursosBDModulo4.AliasFechaDojo].ToString());
                    elDojo.Organizacion_dojo = int.Parse(row[RecursosBDModulo4.AliasIdOrganizacion].ToString());
                    elDojo.Ubicacion = new Ubicacion(int.Parse(row[RecursosBDModulo4.AliasIdUbicacion].ToString()),
                                                            row[RecursosBDModulo4.AliasNombreCiudad].ToString(),
                                                            row[RecursosBDModulo4.AliasNombreEstado].ToString());

                    laListaDeDojos.Add(elDojo);

                }

            }
              catch (SqlException ex)
              {
                  throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
                      RecursoGeneralBD.Mensaje, ex);
              }
              catch (FormatException ex)
              {
                  throw new ExcepcionesSKD.Modulo4.FormatoIncorrectoException(RecursosBDModulo4.Codigo_Error_Formato,
                       RecursosBDModulo4.Mensaje_Error_Formato, ex);
              }
              catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
              {
                  throw ex;
              }
              catch (Exception ex)
              {
                  throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
              }

              return laListaDeDojos;
        }
示例#34
0
        /// <summary>
        /// Metodo que elimina un objeto que haya en el carrito del usuario en la Base de Datos
        /// </summary>
        /// <param name="tipoObjeto">Especifica si se borrara una matricula, un inventario o evento</param>
        /// <param name="objetoBorrar">El objeto en especifico a borrar</param>
        /// <param name="idUsuario">El usuario al que se alterara su carrito</param>
        /// <returns>Si la operacion fue exitosa o fallida</returns>
        public bool eliminarItem(int tipoObjeto, int objetoBorrar, Entidad parametro)
        {
            Persona laPersona;

            try
            {
                laPersona = (Persona)FabricaEntidades.ObtenerPersona();
                //Escribo en el logger la entrada a este metodo
                Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                     RecursosBDModulo16.MENSAJE_ENTRADA_LOGGER, System.Reflection.MethodBase.GetCurrentMethod().Name);

                //Creo la lista de los parametros para el stored procedure y los anexo
                List<Parametro> parametros = new List<Parametro>();
                Parametro elParametro = new Parametro(RecursosBDModulo16.PARAMETRO_USUARIO, SqlDbType.Int,
                    laPersona.ID.ToString(), false);
                parametros.Add(elParametro);
                elParametro = new Parametro(RecursosBDModulo16.PARAMETRO_ITEM, SqlDbType.Int,
                    objetoBorrar.ToString(), false);
                parametros.Add(elParametro);
                elParametro = new Parametro(RecursosBDModulo16.PARAMETRO_TIPO_ITEM, SqlDbType.Int,
                    tipoObjeto.ToString(), false);
                parametros.Add(elParametro);


                //Procedo a intentar eliminar el item en BD ejecutando el stored procedure
                BDConexion conexion = new BDConexion();
                conexion.EjecutarStoredProcedure(RecursosBDModulo16.PROCEDIMIENTO_ELIMINAR_ITEM, parametros);

                //Escribo en el logger la salida a este metodo
                Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                    RecursosBDModulo16.MENSAJE_SALIDA_LOGGER, System.Reflection.MethodBase.GetCurrentMethod().Name);

                return true;
            }
            catch (LoggerException e)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, e);
                throw e;
            }
            catch (ArgumentNullException e)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, e);
                throw new ParseoVacioException(RecursosBDModulo16.CODIGO_EXCEPCION_ARGUMENTO_NULO,
                    RecursosBDModulo16.MENSAJE_EXCEPCION_ARGUMENTO_NULO, e);
            }
            catch (FormatException e)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, e);
                throw new ParseoFormatoInvalidoException(RecursosBDModulo16.CODIGO_EXCEPCION_FORMATO_INVALIDO,
                    RecursosBDModulo16.MENSAJE_EXCEPCION_FORMATO_INVALIDO, e);
            }
            catch (OverflowException e)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, e);
                throw new ParseoEnSobrecargaException(RecursosBDModulo16.CODIGO_EXCEPCION_SOBRECARGA,
                    RecursosBDModulo16.MENSAJE_EXCEPCION_SOBRECARGA, e);
            }
            catch (ParametroInvalidoException e)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, e);
                throw e;
            }
            catch (ExceptionSKDConexionBD e)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, e);
                throw e;
            }
            catch (ExceptionSKD e)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, e);
                throw e;
            }
            catch (Exception e)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, e);
                throw new ExceptionSKD(RecursosBDModulo16.CODIGO_EXCEPCION_GENERICO,
                    RecursosBDModulo16.MENSAJE_EXCEPCION_GENERICO, e);
            }
        }
        /// <summary>
        /// Metodo para consultar todos los clientes potenciales
        /// </summary>
        /// <returns>Una lista que contiene clientes potenciales</returns>
        public List <Entidad> ConsultarTodos()
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceClientePotencial.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            List <Entidad> objetolistaClientePotencial = new List <Entidad>();

            BDConexion theConnection = new BDConexion();
            Parametro  theParam      = new Parametro();

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

            DataTable data = new DataTable();

            data = theConnection.EjecutarStoredProcedureTuplas(ResourceClientePotencial.SP_listarClientePotencial, parametros);
            try
            {
                foreach (DataRow row in data.Rows)
                {
                    Entidad clientePotencial = DominioTangerine.Fabrica.FabricaEntidades.ObtenerClientePotencial();

                    ((ClientePotencial)clientePotencial).IdClientePotencial =
                        Int32.Parse(row[ResourceClientePotencial.idClientePotencial].ToString());

                    ((ClientePotencial)clientePotencial).NombreClientePotencial =
                        row[ResourceClientePotencial.nombreClientePotencial].ToString();

                    ((ClientePotencial)clientePotencial).RifClientePotencial =
                        row[ResourceClientePotencial.rifClientePotencial].ToString();

                    ((ClientePotencial)clientePotencial).EmailClientePotencial =
                        row[ResourceClientePotencial.emailClientePotencial].ToString();

                    ((ClientePotencial)clientePotencial).PresupuestoAnual_inversion =
                        float.Parse(row[ResourceClientePotencial.presupuestoAnual_inversion].ToString());

                    ((ClientePotencial)clientePotencial).Status =
                        Int32.Parse(row[ResourceClientePotencial.status].ToString());


                    objetolistaClientePotencial.Add(clientePotencial);
                }
            }
            catch (ArgumentNullException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.M3.NullArgumentExceptionLeads(RecursoGeneralBD.Codigo,
                                                                             RecursoGeneralBD.Mensaje, ex);
            }
            catch (SqlException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.ExceptionTGConBD(RecursoGeneralBD.Codigo,
                                                                RecursoGeneralBD.Mensaje, ex);
            }

            catch (FormatException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExcepcionesTangerine.M3.WrongFormatExceptionLeads(ResourceClientePotencial.Codigo_Error_Formato,
                                                                            ResourceClientePotencial.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesTangerine.ExceptionTGConBD 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 ExcepcionesTangerine.ExceptionsTangerine(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceClientePotencial.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return(objetolistaClientePotencial);
        }
示例#36
0
        public static bool BuscarNombreCompetencia(Competencia laCompetencia)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            bool retorno = false;
            BDConexion laConexion;
            List<Parametro> parametros;

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

                Parametro elParametro = new Parametro(RecursosBDModulo12.ParamNombreCompetencia, SqlDbType.VarChar
                                                      , laCompetencia.Nombre, false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosBDModulo12.ParamSalidaNumCompetencia, SqlDbType.Int, true);
                parametros.Add(elParametro);

                List<Resultado> resultados = laConexion.EjecutarStoredProcedure(RecursosBDModulo12.BuscarNombreCompetencia
                                             , parametros);

                foreach (Resultado elResultado in resultados)
                {
                    if (elResultado.etiqueta == RecursosBDModulo12.ParamSalidaNumCompetencia)
                        if (int.Parse(elResultado.valor) == 1)
                            retorno = true;
                        else
                            retorno = false;
                }
            }
            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.Modulo12.FormatoIncorrectoException(RecursosBDModulo12.Codigo_Error_Formato,
                     RecursosBDModulo12.Mensaje_Error_Formato, 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);
            }

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return retorno;
        }
示例#37
0
        /// <summary>
        /// Consulta el id de una organizacion a la que pertenece la persona que se encuentra en sesión
        /// </summary>
        /// <param name="parametro">id de la persona que esta en sesión</param>
        /// <returns>id de la orgnización a la cual pertenece dicha persona</returns>
        public int BuscarIdOrganizacion(Entidad parametro)
        {
            BDConexion laConexion;
            List<Parametro> parametros;

            try
            {

                laConexion = new BDConexion();
                parametros = new List<Parametro>();

                Parametro elParametro = new Parametro(RecursosDAOModulo4.ParamIdOrganizacion, SqlDbType.Int, parametro.Id.ToString(),
                                               false);
                parametros.Add(elParametro);
                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(RecursosDAOModulo4.BuscarIdOrganizacion, parametros);

                if (dt != null)
                {
                    foreach (DataRow row in dt.Rows)
                    {
                        int id = int.Parse(row[RecursosDAOModulo4.AliasIdOrganizacion].ToString());
                        return id;
                    }
                }
                else return 0;
            }
            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.Modulo12.FormatoIncorrectoException(RecursosDAOModulo4.Codigo_Error_Formato,
                     RecursosDAOModulo4.Mensaje_Error_Formato, 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);
            }

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo4.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return 0;
        }
示例#38
0
        public static Competencia DetallarCompetencia(int idCompetencia)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);
            BDConexion laConexion;
            List<Parametro> parametros;
            Parametro elParametro = new Parametro();
            Competencia laCompetencia = new Competencia();
            laCompetencia.Id_competencia = idCompetencia;
            int diaFecha;
            int mesFecha;
            int anoFecha;
            string fechaInicio;
            string fechaFin;

            try
            {
                if (BuscarIDCompetencia(laCompetencia))
                {
                    laConexion = new BDConexion();
                    parametros = new List<Parametro>();

                    elParametro = new Parametro(RecursosBDModulo12.ParamIdCompetencia, SqlDbType.Int, idCompetencia.ToString(),
                                                false);
                    parametros.Add(elParametro);

                    DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                                   RecursosBDModulo12.ConsultarCompetenciasXId, parametros);

                    foreach (DataRow row in dt.Rows)
                    {

                        laCompetencia.Id_competencia = int.Parse(row[RecursosBDModulo12.AliasIdCompetencia].ToString());
                        laCompetencia.Nombre = row[RecursosBDModulo12.AliasNombreCompetencia].ToString();
                        laCompetencia.TipoCompetencia = row[RecursosBDModulo12.AliasTipoCompetencia].ToString();

                        if (laCompetencia.TipoCompetencia == "1")
                            laCompetencia.TipoCompetencia = RecursosBDModulo12.TipoCompetenciaKata;
                        else
                            laCompetencia.TipoCompetencia = RecursosBDModulo12.TipoCompetenciaKumite;

                        laCompetencia.Status = row[RecursosBDModulo12.AliasStatusCompetencia].ToString();
                        laCompetencia.OrganizacionTodas = Convert.ToBoolean(row[RecursosBDModulo12.AliasTodasOrganizaciones].ToString());

                        diaFecha = Convert.ToDateTime(row[RecursosBDModulo12.AliasFechaInicio]).Day;
                        mesFecha = Convert.ToDateTime(row[RecursosBDModulo12.AliasFechaInicio]).Month;
                        anoFecha = Convert.ToDateTime(row[RecursosBDModulo12.AliasFechaInicio]).Year;
                        fechaInicio = mesFecha.ToString() + "/" + diaFecha.ToString() + "/" + anoFecha.ToString();
                        //laCompetencia.FechaInicio = Convert.ToDateTime(fechaInicio);

                        laCompetencia.FechaInicio = DateTime.ParseExact(fechaInicio, "mm/dd/yyyy",
                            CultureInfo.InvariantCulture);

                        diaFecha = Convert.ToDateTime(row[RecursosBDModulo12.AliasFechaFin]).Day;
                        mesFecha = Convert.ToDateTime(row[RecursosBDModulo12.AliasFechaFin]).Month;
                        anoFecha = Convert.ToDateTime(row[RecursosBDModulo12.AliasFechaFin]).Year;
                        fechaFin = mesFecha.ToString() + "/" + diaFecha.ToString() + "/" + anoFecha.ToString();
                        //laCompetencia.FechaFin = Convert.ToDateTime(fechaFin);

                        laCompetencia.FechaFin = DateTime.ParseExact(fechaFin, "mm/dd/yyyy",
                            CultureInfo.InvariantCulture);

                        laCompetencia.Costo = float.Parse(row[RecursosBDModulo12.AliasCostoCompetencia].ToString());

                        if (laCompetencia.OrganizacionTodas == false)
                            laCompetencia.Organizacion = new Organizacion(int.Parse(row[RecursosBDModulo12.AliasIdOrganizacion].ToString())
                                                                            , row[RecursosBDModulo12.AliasNombreOrganizacion].ToString());
                        else
                        {
                            laCompetencia.Organizacion = new Organizacion(RecursosBDModulo12.TodasLasOrganizaciones);
                        }
                        laCompetencia.Ubicacion = new Ubicacion(int.Parse(row[RecursosBDModulo12.AliasIdUbicacion].ToString()),
                                                                row[RecursosBDModulo12.AliasLatitudDireccion].ToString(),
                                                                row[RecursosBDModulo12.AliasLongitudDireccion].ToString(),
                                                                row[RecursosBDModulo12.AliasNombreCiudad].ToString(),
                                                                row[RecursosBDModulo12.AliasNombreEstado].ToString(),
                                                                row[RecursosBDModulo12.AliasNombreDireccion].ToString());

                        laCompetencia.Categoria = new Categoria(int.Parse(row[RecursosBDModulo12.AliasIdCategoria].ToString()),
                                                                 int.Parse(row[RecursosBDModulo12.AliasEdadInicio].ToString()),
                                                                 int.Parse(row[RecursosBDModulo12.AliasEdadFin].ToString()),
                                                                 row[RecursosBDModulo12.AliasCintaInicio].ToString(),
                                                                 row[RecursosBDModulo12.AliasCintaFin].ToString(),
                                                                 row[RecursosBDModulo12.AliasSexo].ToString());

                    }

                    Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

                    return laCompetencia;
                }
                else
                {

                    Logger.EscribirWarning(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.Mensaje_Competencia_Inexistente, System.Reflection.MethodBase.GetCurrentMethod().Name);

                    throw new ExcepcionesSKD.Modulo12.CompetenciaInexistenteException(RecursosBDModulo12.Codigo_Competencia_Inexistente,
                                RecursosBDModulo12.Mensaje_Competencia_Inexistente, new Exception());
                }
            }
            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.Modulo12.FormatoIncorrectoException(RecursosBDModulo12.Codigo_Error_Formato,
                     RecursosBDModulo12.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesSKD.Modulo12.CompetenciaInexistenteException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw 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);
            }
        }
示例#39
0
        public static bool BuscarIDCompetencia(Competencia laCompetencia)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            bool             retorno = false;
            BDConexion       laConexion;
            List <Parametro> parametros;

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

                Parametro elParametro = new Parametro(RecursosBDModulo12.ParamIdCompetencia, SqlDbType.Int
                                                      , laCompetencia.Id_competencia.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosBDModulo12.ParamSalidaNumCompetencia, SqlDbType.Int, true);
                parametros.Add(elParametro);

                List <Resultado> resultados = laConexion.EjecutarStoredProcedure(RecursosBDModulo12.BuscarIDCompetencia
                                                                                 , parametros);

                foreach (Resultado elResultado in resultados)
                {
                    if (elResultado.etiqueta == RecursosBDModulo12.ParamSalidaNumCompetencia)
                    {
                        if (int.Parse(elResultado.valor) == 1)
                        {
                            retorno = true;
                        }
                        else
                        {
                            Logger.EscribirWarning(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.Mensaje_Competencia_Inexistente, System.Reflection.MethodBase.GetCurrentMethod().Name);

                            throw new ExcepcionesSKD.Modulo12.CompetenciaInexistenteException(RecursosBDModulo12.Codigo_Competencia_Inexistente,
                                                                                              RecursosBDModulo12.Mensaje_Competencia_Inexistente, new Exception());
                        }
                    }
                }
            }
            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.Modulo12.FormatoIncorrectoException(RecursosBDModulo12.Codigo_Error_Formato,
                                                                             RecursosBDModulo12.Mensaje_Error_Formato, 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);
            }

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return(retorno);
        }
示例#40
0
        public static Dojo DetallarDojo(int idDojo)
        {
            BDConexion laConexion;
            List<Parametro> parametros;
            Parametro elParametro = new Parametro();
            Dojo elDojo = new Dojo();
            elDojo.Id_dojo = idDojo;

            try
            {

                    laConexion = new BDConexion();
                    parametros = new List<Parametro>();

                    elParametro = new Parametro(RecursosBDModulo4.ParamIdDojo, SqlDbType.Int, idDojo.ToString(),
                                                false);
                    parametros.Add(elParametro);

                    DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                                   RecursosBDModulo4.ConsultarDojoXId, parametros);

                    foreach (DataRow row in dt.Rows)
                    {

                        elDojo.Id_dojo = int.Parse(row[RecursosBDModulo4.AliasIdDojo].ToString());
                        elDojo.OrgNombre_dojo = row[RecursosBDModulo4.AliasRifDojo].ToString();
                        elDojo.Nombre_dojo = row[RecursosBDModulo4.AliasNombreDojo].ToString();
                        elDojo.Telefono_dojo = int.Parse(row[RecursosBDModulo4.AliasTelefonoDojo].ToString());
                        elDojo.Email_dojo = row[RecursosBDModulo4.AliasEmailDojo].ToString();
                        elDojo.Logo_dojo = row[RecursosBDModulo4.AliasLogoDojo].ToString();
                        elDojo.Status_dojo = row[RecursosBDModulo4.AliasStatusDojo].ToString();
                        elDojo.Registro_dojo = DateTime.Parse(row[RecursosBDModulo4.AliasFechaDojo].ToString());
                        elDojo.Organizacion_dojo = int.Parse(row[RecursosBDModulo4.AliasIdOrganizacion].ToString());
                        elDojo.OrgNombre_dojo = row[RecursosBDModulo4.AliasNombreOrganizacion].ToString();
                        elDojo.Ubicacion = new Ubicacion(int.Parse(row[RecursosBDModulo4.AliasIdUbicacion].ToString()),
                                                                row[RecursosBDModulo4.AliasNombreCiudad].ToString(),
                                                                row[RecursosBDModulo4.AliasNombreEstado].ToString());
                        //elDojo.Matricula_dojo = (BuscarMatriculaVigente(elDojo));

                    }
                    return elDojo;

            }
            catch (SqlException ex)
            {
                throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
                    RecursoGeneralBD.Mensaje, ex);
            }
            catch (FormatException ex)
            {
                throw new ExcepcionesSKD.Modulo12.FormatoIncorrectoException(RecursosBDModulo4.Codigo_Error_Formato,
                     RecursosBDModulo4.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesSKD.Modulo12.CompetenciaInexistenteException ex)
            {
                throw ex;
            }
            catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }
        }
示例#41
0
        public static bool ModificarCompetencia(Competencia laCompetencia)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            try
            {
                if (!BuscarNombreCompetencia(laCompetencia))
                {
                    List <Parametro> parametros  = new List <Parametro>();
                    Parametro        elParametro = new Parametro(RecursosBDModulo12.ParamIdCompetencia, SqlDbType.Int,
                                                                 laCompetencia.Id_competencia.ToString(), false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamNombreCompetencia, SqlDbType.VarChar,
                                                laCompetencia.Nombre, false);
                    parametros.Add(elParametro);
                    if (laCompetencia.TipoCompetencia == RecursosBDModulo12.TipoCompetenciaKata)
                    {
                        laCompetencia.TipoCompetencia = "1";
                    }
                    else
                    if (laCompetencia.TipoCompetencia == RecursosBDModulo12.TipoCompetenciaKumite)
                    {
                        laCompetencia.TipoCompetencia = "2";
                    }

                    elParametro = new Parametro(RecursosBDModulo12.ParamTipoCompetencia, SqlDbType.VarChar,
                                                laCompetencia.TipoCompetencia, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamOrganizacionTodas, SqlDbType.Bit,
                                                laCompetencia.OrganizacionTodas.ToString(), false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamStatusCompetencia, SqlDbType.VarChar,
                                                laCompetencia.Status, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamFechaInicio, SqlDbType.DateTime,
                                                laCompetencia.FechaInicio.ToString(), false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamFechaFin, SqlDbType.DateTime,
                                                laCompetencia.FechaFin.ToString(), false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamNombreOrganizacion, SqlDbType.VarChar,
                                                laCompetencia.Organizacion.Nombre, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamNombreCiudad, SqlDbType.VarChar,
                                                laCompetencia.Ubicacion.Ciudad, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamNombreEstado, SqlDbType.VarChar,
                                                laCompetencia.Ubicacion.Estado, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamNombreDireccion, SqlDbType.VarChar,
                                                laCompetencia.Ubicacion.Direccion, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamLatitudDireccion, SqlDbType.VarChar,
                                                laCompetencia.Ubicacion.Latitud, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamLongitudDireccion, SqlDbType.VarChar,
                                                laCompetencia.Ubicacion.Longitud, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamEdadInicio, SqlDbType.Int,
                                                laCompetencia.Categoria.Edad_inicial.ToString(), false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamEdadFin, SqlDbType.Int,
                                                laCompetencia.Categoria.Edad_final.ToString(), false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamCintaInicio, SqlDbType.VarChar,
                                                laCompetencia.Categoria.Cinta_inicial, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamCintaFin, SqlDbType.VarChar,
                                                laCompetencia.Categoria.Cinta_final, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamSexo, SqlDbType.Char,
                                                laCompetencia.Categoria.Sexo, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamCostoCompetencia, SqlDbType.Float,
                                                laCompetencia.Costo.ToString(), false);
                    parametros.Add(elParametro);

                    BDConexion laConexion = new BDConexion();
                    laConexion.EjecutarStoredProcedure(RecursosBDModulo12.ModificarCompetencia, parametros);
                }
                else
                {
                    Logger.EscribirWarning(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.Mensaje_Competencia_Existente, System.Reflection.MethodBase.GetCurrentMethod().Name);

                    throw new ExcepcionesSKD.Modulo12.CompetenciaExistenteException(RecursosBDModulo12.Codigo_Competencia_Existente,
                                                                                    RecursosBDModulo12.Mensaje_Competencia_Existente, new Exception());
                }
            }
            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.Modulo12.FormatoIncorrectoException(RecursosBDModulo12.Codigo_Error_Formato,
                                                                             RecursosBDModulo12.Mensaje_Error_Formato, 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);
            }

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return(true);
        }
示例#42
0
        public bool Modificar(Entidad parametro)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                RecursosDAOModulo4.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            try
            {
                HistorialM elHistMat = (HistorialM)FabricaEntidades.ObtenerHistorialMatricula();
                elHistMat = (HistorialM)parametro;

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

                Parametro elParametro = new Parametro(RecursosDAOModulo4.ParamIdMatricula, SqlDbType.Int,
                    elHistMat.Id_historial_matricula.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroFechaVigenteHistorial, SqlDbType.DateTime,
                    elHistMat.Fecha_historial_matricula.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroModalidad, SqlDbType.VarChar,
                    elHistMat.Modalidad_historial_matricula.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroMontoMatricula, SqlDbType.Float,
                    elHistMat.Monto_historial_matricula.ToString(), false);
                parametros.Add(elParametro);

                BDConexion laConexion = new BDConexion();
                laConexion.EjecutarStoredProcedure(RecursosDAOModulo4.ModificarHistorialMatricula, parametros);
                Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo4.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

                return true;

            }
            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.Modulo4.FormatoIncorrectoException(RecursosDAOModulo4.Codigo_Error_Formato,
                     RecursosDAOModulo4.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesSKD.Modulo4.HistorialMatriculaInexistenteException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw 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);
            }

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo4.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return false;
        }
示例#43
0
        public static Competencia DetallarCompetencia(int idCompetencia)
        {
            BDConexion laConexion;
            List<Parametro> parametros;
            Parametro elParametro = new Parametro();

            try
            {
                laConexion = new BDConexion();
                parametros = new List<Parametro>();
                Competencia laCompetencia = new Competencia();

                elParametro = new Parametro(RecursosBDModulo12.AliasIdCompetencia,SqlDbType.Int,idCompetencia.ToString(),
                                            false);
                parametros.Add(elParametro);

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosBDModulo12.ConsultarCompetenciasXId, parametros);

                foreach (DataRow row in dt.Rows)
                {

                    laCompetencia.Id_competencia = int.Parse(row[RecursosBDModulo12.AliasIdCompetencia].ToString());
                    laCompetencia.Nombre = row[RecursosBDModulo12.AliasNombreCompetencia].ToString();
                    laCompetencia.TipoCompetencia = int.Parse(row[RecursosBDModulo12.AliasTipoCompetencia].ToString());
                    laCompetencia.Status = row[RecursosBDModulo12.AliasStatusCompetencia].ToString();
                    laCompetencia.OrganizacionTodas = Convert.ToBoolean(row[RecursosBDModulo12.AliasTodasOrganizaciones].ToString());
                    laCompetencia.FechaInicio = Convert.ToDateTime(row[RecursosBDModulo12.AliasEdadInicio].ToString());
                    laCompetencia.FechaFin = Convert.ToDateTime(row[RecursosBDModulo12.AliasFechaFin].ToString());
                    laCompetencia.Costo = float.Parse(row[RecursosBDModulo12.AliasCostoCompetencia].ToString());

                    if (laCompetencia.OrganizacionTodas == false)
                        laCompetencia.Organizacion = new Organizacion(int.Parse(row[RecursosBDModulo12.AliasIdOrganizacion].ToString())
                                                                        , row[RecursosBDModulo12.AliasNombreOrganizacion].ToString());
                    else
                    {
                        laCompetencia.Organizacion = new Organizacion(RecursosBDModulo12.TodasLasOrganizaciones);
                    }
                    laCompetencia.Ubicacion = new Ubicacion(int.Parse(row[RecursosBDModulo12.AliasIdUbicacion].ToString()),
                                                            row[RecursosBDModulo12.AliasLatitudDireccion].ToString(),
                                                            row[RecursosBDModulo12.AliasLongitudDireccion].ToString(),
                                                            row[RecursosBDModulo12.AliasNombreCiudad].ToString(),
                                                            row[RecursosBDModulo12.AliasNombreEstado].ToString(),
                                                            row[RecursosBDModulo12.AliasNombreDireccion].ToString());

                    laCompetencia.Categoria = new Categoria(int.Parse(row[RecursosBDModulo12.AliasIdCategoria].ToString()),
                                                             int.Parse(row[RecursosBDModulo12.AliasEdadInicio].ToString()),
                                                             int.Parse(row[RecursosBDModulo12.AliasFechaFin].ToString()),
                                                             row[RecursosBDModulo12.AliasCintaInicio].ToString(),
                                                             row[RecursosBDModulo12.AliasCintaFin].ToString(),
                                                             row[RecursosBDModulo12.AliasSexo].ToString());

                }
                return laCompetencia;

            }
            catch (Exception e)
            {
                throw e;
            }
        }
示例#44
0
        public static bool ModificarCompetencia(Competencia laCompetencia)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            try
            {
                if (!BuscarNombreCompetencia(laCompetencia))
                {
                    List<Parametro> parametros = new List<Parametro>();
                    Parametro elParametro = new Parametro(RecursosBDModulo12.ParamIdCompetencia, SqlDbType.Int,
                        laCompetencia.Id_competencia.ToString(), false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamNombreCompetencia, SqlDbType.VarChar,
                        laCompetencia.Nombre, false);
                    parametros.Add(elParametro);
                    if (laCompetencia.TipoCompetencia == RecursosBDModulo12.TipoCompetenciaKata)
                        laCompetencia.TipoCompetencia = "1";
                    else
                        if (laCompetencia.TipoCompetencia == RecursosBDModulo12.TipoCompetenciaKumite)
                            laCompetencia.TipoCompetencia = "2";

                    elParametro = new Parametro(RecursosBDModulo12.ParamTipoCompetencia, SqlDbType.VarChar,
                        laCompetencia.TipoCompetencia, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamOrganizacionTodas, SqlDbType.Bit,
                        laCompetencia.OrganizacionTodas.ToString(), false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamStatusCompetencia, SqlDbType.VarChar,
                        laCompetencia.Status, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamFechaInicio, SqlDbType.DateTime,
                        laCompetencia.FechaInicio.ToString(), false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamFechaFin, SqlDbType.DateTime,
                        laCompetencia.FechaFin.ToString(), false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamNombreOrganizacion, SqlDbType.VarChar,
                        laCompetencia.Organizacion.Nombre, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamNombreCiudad, SqlDbType.VarChar,
                        laCompetencia.Ubicacion.Ciudad, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamNombreEstado, SqlDbType.VarChar,
                        laCompetencia.Ubicacion.Estado, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamNombreDireccion, SqlDbType.VarChar,
                        laCompetencia.Ubicacion.Direccion, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamLatitudDireccion, SqlDbType.VarChar,
                        laCompetencia.Ubicacion.Latitud, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamLongitudDireccion, SqlDbType.VarChar,
                        laCompetencia.Ubicacion.Longitud, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamEdadInicio, SqlDbType.Int,
                        laCompetencia.Categoria.Edad_inicial.ToString(), false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamEdadFin, SqlDbType.Int,
                        laCompetencia.Categoria.Edad_final.ToString(), false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamCintaInicio, SqlDbType.VarChar,
                        laCompetencia.Categoria.Cinta_inicial, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamCintaFin, SqlDbType.VarChar,
                        laCompetencia.Categoria.Cinta_final, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamSexo, SqlDbType.Char,
                        laCompetencia.Categoria.Sexo, false);
                    parametros.Add(elParametro);
                    elParametro = new Parametro(RecursosBDModulo12.ParamCostoCompetencia, SqlDbType.Float,
                        laCompetencia.Costo.ToString(), false);
                    parametros.Add(elParametro);

                    BDConexion laConexion = new BDConexion();
                    laConexion.EjecutarStoredProcedure(RecursosBDModulo12.ModificarCompetencia, parametros);
                }
                else
                {
                    Logger.EscribirWarning(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.Mensaje_Competencia_Existente, System.Reflection.MethodBase.GetCurrentMethod().Name);

                    throw new ExcepcionesSKD.Modulo12.CompetenciaExistenteException(RecursosBDModulo12.Codigo_Competencia_Existente,
                                RecursosBDModulo12.Mensaje_Competencia_Existente, new Exception());
                }
            }
            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.Modulo12.FormatoIncorrectoException(RecursosBDModulo12.Codigo_Error_Formato,
                     RecursosBDModulo12.Mensaje_Error_Formato, 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);
            }

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return true;
        }
示例#45
0
        public Entidad ConsultarXId(Entidad parametro)
        {
            BDConexion laConexion;
            List<Parametro> parametros;
            Parametro elParametro = new Parametro();

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo4.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            HistorialM elHistMat = (HistorialM)FabricaEntidades.ObtenerHistorialMatricula();
            elHistMat = (HistorialM)parametro;

            try
            {

                laConexion = new BDConexion();

                parametros = new List<Parametro>();

                elParametro = new Parametro(RecursosDAOModulo4.ParamIdMatricula, SqlDbType.VarChar,
                    elHistMat.Id.ToString(), false);
                parametros.Add(elParametro);

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosDAOModulo4.ConsultarMatriculasXId, parametros);

                foreach (DataRow row in dt.Rows)
                {

                    elHistMat.Id = int.Parse(row[RecursosDAOModulo4.AliasIdMatricula].ToString());
                    elHistMat.Fecha_historial_matricula = DateTime.Parse(row[RecursosDAOModulo4.AliasFechaMatricula].ToString());
                    elHistMat.Modalidad_historial_matricula = row[RecursosDAOModulo4.AliasModalidad].ToString();
                    elHistMat.Monto_historial_matricula = int.Parse(row[RecursosDAOModulo4.AliasMonto].ToString());

                }

            }
            catch (SqlException ex)
            {
                throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
                    RecursoGeneralBD.Mensaje, ex);
            }
            catch (FormatException ex)
            {
                throw new ExcepcionesSKD.Modulo4.FormatoIncorrectoException(RecursosDAOModulo4.Codigo_Error_Formato,
                     RecursosDAOModulo4.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesSKD.Modulo4.DojoInexistenteException ex)
            {
                throw ex;
            }
            catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }

            return elHistMat;
        }
        /// <summary>
        /// Metodo para promover a un cliente dentro de la base de datos
        /// </summary>
        /// <param name="parametro"></param>
        /// <returns>Un cliente potencial</returns>
        public Entidad ConsultarXId(Entidad parametro)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceClientePotencial.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            ClientePotencial cliente       = (ClientePotencial)parametro;
            List <Parametro> parameters    = new List <Parametro>();
            BDConexion       theConnection = new BDConexion();
            Parametro        theParam      = new Parametro();

            List <ClientePotencial> listClientePotencial = new List <ClientePotencial>();
            ClientePotencial        elClientePotencial   = null;

            try
            {
                theConnection.Conectar();

                theParam = new Parametro(ResourceClientePotencial.AidClientePotencial, SqlDbType.Int,
                                         cliente.Id.ToString(), false);
                parameters.Add(theParam);

                DataTable dt =
                    theConnection.EjecutarStoredProcedureTuplas(ResourceClientePotencial.SP_consultarClientePotencial, parameters);

                //Por cada fila de la tabla voy a guardar los datos
                foreach (DataRow row in dt.Rows)
                {
                    int    IdClientePotencial         = int.Parse(row[ResourceClientePotencial.idClientePotencial].ToString());
                    String NombreClientePotencial     = row[ResourceClientePotencial.nombreClientePotencial].ToString();
                    String RifClientePotencial        = row[ResourceClientePotencial.rifClientePotencial].ToString();
                    String EmailClientePotencial      = row[ResourceClientePotencial.emailClientePotencial].ToString();
                    float  PresupuestoAnual_inversion = float.Parse(row[ResourceClientePotencial.presupuestoAnual_inversion].ToString());
                    int    NumeroLlamadas             = int.Parse(row[ResourceClientePotencial.numeroLlamadas].ToString());
                    int    NumeroVisitas = int.Parse(row[ResourceClientePotencial.numeroVisitas].ToString());
                    int    Status        = int.Parse(row[ResourceClientePotencial.status].ToString());

                    elClientePotencial = new DominioTangerine.Entidades.M3.ClientePotencial(IdClientePotencial, NombreClientePotencial, RifClientePotencial,
                                                                                            EmailClientePotencial, PresupuestoAnual_inversion, NumeroLlamadas, NumeroVisitas, Status);
                }
            }
            catch (ArgumentNullException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.M3.NullArgumentExceptionLeads(RecursoGeneralBD.Codigo,
                                                                             RecursoGeneralBD.Mensaje, ex);
            }
            catch (SqlException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.ExceptionTGConBD(RecursoGeneralBD.Codigo,
                                                                RecursoGeneralBD.Mensaje, ex);
            }
            catch (FormatException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExcepcionesTangerine.M3.WrongFormatExceptionLeads(ResourceClientePotencial.Codigo_Error_Formato,
                                                                            ResourceClientePotencial.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesTangerine.ExceptionTGConBD 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 ExcepcionesTangerine.ExceptionsTangerine(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceClientePotencial.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return(elClientePotencial);
        }
示例#47
0
        public List<Entidad> ConsultarTodos()
        {
            BDConexion laConexion;
            List<Entidad> laListaDeMatriculas = FabricaEntidades.ObtenerListaEntidad_M4();
            List<Parametro> parametros;

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

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosDAOModulo4.ConsultarMatriculas, parametros);

                foreach (DataRow row in dt.Rows)
                {
                    DojoM4 elDojo = (DojoM4)FabricaEntidades.ObtenerDojo_M4();
                    HistorialM elHistMat = (HistorialM)FabricaEntidades.ObtenerHistorialMatricula();

                    elHistMat.Id_historial_matricula = int.Parse(row[RecursosDAOModulo4.AliasIdMatricula].ToString());
                    elHistMat.Fecha_historial_matricula = DateTime.Parse(row[RecursosDAOModulo4.AliasFechaMatricula].ToString());
                    elHistMat.Modalidad_historial_matricula = row[RecursosDAOModulo4.AliasModalidad].ToString();
                    elHistMat.Monto_historial_matricula = int.Parse(row[RecursosDAOModulo4.AliasMonto].ToString());
                    elDojo.Id = int.Parse(row[RecursosDAOModulo4.AliasIdDojo].ToString());
                    elDojo.Nombre_dojo = row[RecursosDAOModulo4.AliasNombreDojo].ToString();
                    elHistMat.Dojo_historial_matricula = elDojo;

                    laListaDeMatriculas.Add(elHistMat);

                }

            }
            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.Modulo4.FormatoIncorrectoException(RecursosDAOModulo4.Codigo_Error_Formato,
                     RecursosDAOModulo4.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesSKD.Modulo4.HistorialMatriculaInexistenteException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw 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);
            }

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo4.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return laListaDeMatriculas;
        }
示例#48
0
        /// <summary>
        /// Metodo para consultar todos los empleados
        /// </summary>
        /// <returns></returns>
        public List <DominioTangerine.Entidad> ConsultarTodos()
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceEmpleado.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            List <Parametro> parameters    = new List <Parametro>();
            BDConexion       theConnection = new BDConexion();
            Parametro        theParam      = new Parametro();

            List <DominioTangerine.Entidad> listEmpleado = new List <DominioTangerine.Entidad>();

            try
            {
                theConnection.Conectar();

                theParam = new Parametro("@param", SqlDbType.Int, "1", false);
                parameters.Add(theParam);

                //Guardo la tabla que me regresa el procedimiento de consultar contactos
                DataTable dt = theConnection.EjecutarStoredProcedureTuplas(ResourceEmpleado.ConsultarEmpleado,
                                                                           parameters);

                //Por cada fila de la tabla voy a guardar los datos
                foreach (DataRow row in dt.Rows)
                {
                    int      empId        = int.Parse(row[ResourceEmpleado.EmpIdEmpleado].ToString());
                    String   empPNombre   = row[ResourceEmpleado.EmpPNombre].ToString();
                    String   empSNombre   = row[ResourceEmpleado.EmpSNombre].ToString();
                    String   empPApellido = row[ResourceEmpleado.EmpPApellido].ToString();
                    String   empSApellido = row[ResourceEmpleado.EmpSApellido].ToString();
                    int      empCedula    = int.Parse(row[ResourceEmpleado.EmpCedula].ToString());
                    DateTime empFecha     = DateTime.Parse(row[ResourceEmpleado.EmpFecha].ToString());
                    String   empActivo    = row[ResourceEmpleado.EmpActivo].ToString();
                    String   empEmail     = row[ResourceEmpleado.EmpEmail].ToString();
                    String   empGenero    = row[ResourceEmpleado.EmpGenero].ToString();
                    String   empEstudio   = row[ResourceEmpleado.EmpEstudio].ToString();

                    String   empCargo            = row[ResourceEmpleado.EmpCargo].ToString();
                    String   empCargoDescripcion = row[ResourceEmpleado.EmpCargoDescripcion].ToString();
                    DateTime empContratacion     = DateTime.Parse(row[ResourceEmpleado.EmpFechaInicio].ToString());
                    String   empModalidad        = row[ResourceEmpleado.EmpModalidad].ToString();
                    double   empSalario          = double.Parse(row[ResourceEmpleado.EmpSueldo].ToString());


                    //Creo un objeto de tipo Entidad con los datos de la fila

                    Entidad cargoEmpleado = DominioTangerine.Fabrica.FabricaEntidades.ObtenerCargo3(empCargo,
                                                                                                    empCargoDescripcion, empContratacion);


                    Entidad empleado = DominioTangerine.Fabrica.FabricaEntidades.ConsultarEmpleados
                                           (empId, empPNombre, empSNombre,
                                           empPApellido, empSApellido, empCedula, empFecha, empActivo, empEmail, empGenero, empEstudio,
                                           empModalidad, empSalario, cargoEmpleado);


                    listEmpleado.Add(empleado);
                }
            }
            catch (ArgumentNullException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ConsultarEmpleadoException("DS-101", "Ingreso de un argumento con valor invalido", ex);
            }
            catch (SqlException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new BaseDatosException("DS-101", "Error con la base de datos", ex);
            }
            catch (FormatException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.M10.WrongFormatException(ResourceEmpleado.Codigo_Error_Formato,
                                                                        ResourceEmpleado.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesTangerine.ExceptionTGConBD 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 ExcepcionesTangerine.ExceptionsTangerine(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceEmpleado.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return(listEmpleado);
        }
示例#49
0
        /// <summary>
        /// Método que consulta dojos
        /// </summary>
        /// <param name="parametro">id del dojo a consultar</param>
        /// <returns>dojo según el id de parametro</returns>
        public Entidad ConsultarXId(Entidad parametro)
        {
            BDConexion laConexion;
            List<Parametro> parametros;
            Parametro elParametro = new Parametro();

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo4.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            DojoM4 elDojo = (DojoM4)FabricaEntidades.ObtenerDojo_M4();
            elDojo = (DojoM4)parametro;

            try
            {

                laConexion = new BDConexion();
                parametros = new List<Parametro>();

                elParametro = new Parametro(RecursosDAOModulo4.ParamIdDojo, SqlDbType.Int, elDojo.Id.ToString(),
                                            false);
                parametros.Add(elParametro);

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosDAOModulo4.ConsultarDojoXId, parametros);

                foreach (DataRow row in dt.Rows)
                {

                    Organizacion org = (Organizacion)FabricaEntidades.ObtenerOrganizacion_M4();
                    Ubicacion ubi = (Ubicacion)FabricaEntidades.ObtenerUbicacion_M4();

                    elDojo.Id_dojo = int.Parse(row[RecursosDAOModulo4.AliasIdDojo].ToString());
                    elDojo.Rif_dojo = row[RecursosDAOModulo4.AliasRifDojo].ToString();
                    elDojo.Nombre_dojo = row[RecursosDAOModulo4.AliasNombreDojo].ToString();
                    elDojo.Telefono_dojo = int.Parse(row[RecursosDAOModulo4.AliasTelefonoDojo].ToString());
                    elDojo.Email_dojo = row[RecursosDAOModulo4.AliasEmailDojo].ToString();
                    elDojo.Logo_dojo = row[RecursosDAOModulo4.AliasLogoDojo].ToString();
                    elDojo.Status_dojo = bool.Parse(row[RecursosDAOModulo4.AliasStatusDojo].ToString());
                    elDojo.Estilo_dojo = row[RecursosDAOModulo4.AliasEstiloDojo].ToString();
                    elDojo.Registro_dojo = DateTime.Parse(row[RecursosDAOModulo4.AliasFechaDojo].ToString());
                    org.Id = int.Parse(row[RecursosDAOModulo4.AliasIdOrganizacion].ToString());
                    org.Nombre = row[RecursosDAOModulo4.AliasNombreOrganizacion].ToString();
                    elDojo.Organizacion = org;
                    ubi.Id = int.Parse(row[RecursosDAOModulo4.AliasIdUbicacion].ToString());
                    ubi.Ciudad = row[RecursosDAOModulo4.AliasNombreCiudad].ToString();
                    ubi.Estado = row[RecursosDAOModulo4.AliasNombreEstado].ToString();
                    ubi.Direccion = row[RecursosDAOModulo4.AliasNombreDireccion].ToString();
                    elDojo.Ubicacion = ubi;

                }

            }
            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.Modulo4.FormatoIncorrectoException(RecursosDAOModulo4.Codigo_Error_Formato,
                     RecursosDAOModulo4.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesSKD.Modulo4.DojoInexistenteException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw 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);
            }
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo4.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return elDojo;
        }
示例#50
0
        /// <summary>
        /// Método que modifica un dojo base de datos
        /// </summary>
        /// <param name="parametro">El dojo con sus cambios</param>
        /// <returns>True si modificó y false en caso contrario</returns>
        public bool Modificar(Entidad parametro)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                RecursosDAOModulo4.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            try
            {
                DojoM4 elDojo = (DojoM4)FabricaEntidades.ObtenerDojo_M4();
                elDojo = (DojoM4)parametro;

                ///Se listan todos los parametros para crear el nuevo dojo
                List<Parametro> parametros = new List<Parametro>();
                Parametro elParametro = new Parametro(RecursosDAOModulo4.ParamIdDojo, SqlDbType.Int, elDojo.Id.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroRifDojo, SqlDbType.VarChar, elDojo.Rif_dojo, false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroNombreDojo, SqlDbType.VarChar, elDojo.Nombre_dojo, false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroTelefonoDojo, SqlDbType.Int,
                    elDojo.Telefono_dojo.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroEmailDojo, SqlDbType.VarChar,
                    elDojo.Email_dojo, false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroLogoDojo, SqlDbType.VarChar,
                    elDojo.Logo_dojo, false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroStatusDojo, SqlDbType.Bit,
                    elDojo.Status_dojo.ToString(), false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroNombreEstado, SqlDbType.VarChar,
                    elDojo.Ubicacion.Estado, false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroNombreCiudad, SqlDbType.VarChar,
                    elDojo.Ubicacion.Ciudad, false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroLatitud, SqlDbType.VarChar,
                    elDojo.Ubicacion.Latitud, false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroLongitud, SqlDbType.VarChar,
                    elDojo.Ubicacion.Longitud, false);
                parametros.Add(elParametro);

                elParametro = new Parametro(RecursosDAOModulo4.ParametroDireccion, SqlDbType.VarChar,
                    elDojo.Ubicacion.Direccion, false);
                parametros.Add(elParametro);

                BDConexion laConexion = new BDConexion();
                laConexion.EjecutarStoredProcedure(RecursosDAOModulo4.ModificarDojo, parametros);
                Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo4.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

                return true;

            }
            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.Modulo4.FormatoIncorrectoException(RecursosDAOModulo4.Codigo_Error_Formato,
                     RecursosDAOModulo4.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesSKD.Modulo4.DojoInexistenteException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw 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);
            }

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo4.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return false;
        }
示例#51
0
        /// <summary>
        /// Metodo que agrega la lista de contactos involucrados a un proyecto
        /// </summary>
        /// <param name="lista">lista de contactos a insertar</param>
        /// <returns>Valor booleano que refleja el exito de la operacion</returns>
        public static bool agregarContactosInvolucrados(ListaInvolucradoContacto listaContactos)
        {
            int      filasA, filasD;
            Proyecto elProyecto;

            if (listaContactos.Proyecto != null)
            {
                elProyecto = listaContactos.Proyecto;
            }
            else
            {
                throw new ExcepcionesTotem.Modulo3.ListaSinProyectoException(RecursosBDModulo3.Codigo_ListaSinProy,
                                                                             RecursosBDModulo3.Mensaje_ListaSinProy, new Exception());
            }
            List <Parametro> parametros, parametrosContar;

            Parametro  paramProyectoCod, paramContactoID, paramFilas;
            BDConexion laConexion = new BDConexion();

            parametrosContar = new List <Parametro>();
            paramFilas       = new Parametro(RecursosBDModulo3.ParamFilas, SqlDbType.Int, true);
            parametrosContar.Add(paramFilas);

            List <Resultado> resultado = laConexion.EjecutarStoredProcedure(RecursosBDModulo3.StoredContarCliente,
                                                                            parametrosContar);

            filasA = int.Parse(resultado[0].valor);

            if (listaContactos.Lista.ToArray().Length == 0 || listaContactos.Lista == null)
            {
                throw new ExcepcionesTotem.Modulo3.ListaSinInvolucradosException(RecursosBDModulo3.Codigo_ListaSinInv,
                                                                                 RecursosBDModulo3.Mensaje_ListaSinInv, new Exception());
            }
            try
            {
                foreach (Contacto elContacto in listaContactos.Lista)
                {
                    laConexion = new BDConexion();
                    parametros = new List <Parametro>();

                    paramProyectoCod = new Parametro(RecursosBDModulo3.ParamCodProy, SqlDbType.VarChar,
                                                     elProyecto.Codigo, false);
                    parametros.Add(paramProyectoCod);
                    if (elContacto.Con_Id != null)
                    {
                        paramContactoID = new Parametro(RecursosBDModulo3.ParamContID, SqlDbType.Int,
                                                        elContacto.Con_Id.ToString(), false);
                        parametros.Add(paramContactoID);
                    }
                    else
                    {
                        throw new ExcepcionesTotem.Modulo3.ContactoSinIDException(
                                  RecursosBDModulo3.Codigo_ContactoSinID, RecursosBDModulo3.Mensaje_ContactoSinID,
                                  new Exception());
                    }
                    laConexion.EjecutarStoredProcedure(RecursosBDModulo3.StoredInsertarCliente, parametros);
                }

                laConexion = new BDConexion();
                resultado  = null;

                resultado = laConexion.EjecutarStoredProcedure(RecursosBDModulo3.StoredContarCliente, parametrosContar);
                System.Diagnostics.Debug.WriteLine(resultado[0]);
                filasD = int.Parse(resultado[0].valor);

                if (filasD > filasA)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            catch (SqlException ex)
            {
                if (ex.Number == 2627)
                {
                    throw new ExcepcionesTotem.Modulo3.InvolucradoRepetidoException(
                              RecursosBDModulo3.Codigo_Involucrado_Repetido,
                              RecursosBDModulo3.Mensaje_Involucrado_Repetido, new Exception());
                }
                else
                {
                    throw new ExcepcionesTotem.ExceptionTotemConexionBD(RecursoGeneralBD.Codigo,
                                                                        RecursoGeneralBD.Mensaje, new Exception());
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionesTotem.ExceptionTotem("No se pudo completar la operacion", new Exception());
            }
        }
示例#52
0
        public static List<Competencia> ListarCompetencias()
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            BDConexion laConexion;
            List<Competencia> laListaDeCompetencias = new List<Competencia>();
            List<Parametro> parametros;

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

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosBDModulo12.ConsultarCompetencias, parametros);

                foreach (DataRow row in dt.Rows)
                {
                    Competencia laCompetencia = new Competencia();

                    laCompetencia.Id_competencia = int.Parse(row[RecursosBDModulo12.AliasIdCompetencia].ToString());
                    laCompetencia.Nombre = row[RecursosBDModulo12.AliasNombreCompetencia].ToString();
                    laCompetencia.TipoCompetencia = row[RecursosBDModulo12.AliasTipoCompetencia].ToString();

                    if (laCompetencia.TipoCompetencia == "1")
                        laCompetencia.TipoCompetencia = RecursosBDModulo12.TipoCompetenciaKata;
                    else
                        laCompetencia.TipoCompetencia = RecursosBDModulo12.TipoCompetenciaKumite;

                    laCompetencia.Status = row[RecursosBDModulo12.AliasStatusCompetencia].ToString();
                    laCompetencia.OrganizacionTodas = Convert.ToBoolean(row[RecursosBDModulo12.AliasTodasOrganizaciones].ToString());

                    if (laCompetencia.OrganizacionTodas == false)
                        laCompetencia.Organizacion = new Organizacion(int.Parse(row[RecursosBDModulo12.AliasIdOrganizacion].ToString())
                                                                        , row[RecursosBDModulo12.AliasNombreOrganizacion].ToString());
                    else
                    {
                        laCompetencia.Organizacion = new Organizacion(RecursosBDModulo12.TodasLasOrganizaciones);
                    }
                    laCompetencia.Ubicacion = new Ubicacion(int.Parse(row[RecursosBDModulo12.AliasIdUbicacion].ToString()),
                                                            row[RecursosBDModulo12.AliasNombreCiudad].ToString(),
                                                            row[RecursosBDModulo12.AliasNombreEstado].ToString());

                    laListaDeCompetencias.Add(laCompetencia);

                }

            }
            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.Modulo12.FormatoIncorrectoException(RecursosBDModulo12.Codigo_Error_Formato,
                     RecursosBDModulo12.Mensaje_Error_Formato, 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);
            }

            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo12.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return laListaDeCompetencias;
        }
示例#53
0
        public static List<Competencia> ListarCompetencias()
        {
            BDConexion laConexion;
            List<Competencia> laListaDeCompetencias = new List<Competencia>();
            List<Parametro> parametros;

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

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
                               RecursosBDModulo12.ConsultarCompetencias, parametros);

                foreach (DataRow row in dt.Rows)
                {
                    Competencia laCompetencia = new Competencia();

                    laCompetencia.Id_competencia = int.Parse(row[RecursosBDModulo12.AliasIdCompetencia].ToString());
                    laCompetencia.Nombre = row[RecursosBDModulo12.AliasNombreCompetencia].ToString();
                    laCompetencia.TipoCompetencia = int.Parse(row[RecursosBDModulo12.AliasTipoCompetencia].ToString());
                    laCompetencia.Status = row[RecursosBDModulo12.AliasStatusCompetencia].ToString();
                    laCompetencia.OrganizacionTodas = Convert.ToBoolean(row[RecursosBDModulo12.AliasTodasOrganizaciones].ToString());

                    if (laCompetencia.OrganizacionTodas == false)
                        laCompetencia.Organizacion = new Organizacion(int.Parse(row[RecursosBDModulo12.AliasIdOrganizacion].ToString())
                                                                        , row[RecursosBDModulo12.AliasNombreOrganizacion].ToString());
                    else
                    {
                        laCompetencia.Organizacion = new Organizacion(RecursosBDModulo12.TodasLasOrganizaciones);
                    }
                    laCompetencia.Ubicacion = new Ubicacion(int.Parse(row[RecursosBDModulo12.AliasIdUbicacion].ToString()),
                                                            row[RecursosBDModulo12.AliasNombreCiudad].ToString(),
                                                            row[RecursosBDModulo12.AliasNombreEstado].ToString());

                    laListaDeCompetencias.Add(laCompetencia);

                }

            }
            catch (Exception e)
            {
                throw e;
            }

            return laListaDeCompetencias;
        }
示例#54
0
        /// <summary>
        /// Metodo que agrega la lista de usuarios involucrados a un proyecto
        /// </summary>
        /// <param name="lista">lista de usuarios a insertar</param>
        /// <returns>Valor booleano que refleja el exito de la operacion</returns>
        public static bool agregarUsuariosInvolucrados(ListaInvolucradoUsuario listaUsuarios)
        {
            int      filasA, filasD;
            Proyecto elProyecto;

            if (listaUsuarios.Proyecto != null)
            {
                elProyecto = listaUsuarios.Proyecto;
            }
            else
            {
                throw new ExcepcionesTotem.Modulo3.ListaSinProyectoException(RecursosBDModulo3.Codigo_ListaSinProy,
                                                                             RecursosBDModulo3.Mensaje_ListaSinProy, new Exception());
            }

            List <Parametro> parametros, parametrosContar;
            Parametro        paramProyectoCod, paramUsername, paramFilas;
            BDConexion       laConexion = new BDConexion();

            parametrosContar = new List <Parametro>();
            paramFilas       = new Parametro(RecursosBDModulo3.ParamFilas, SqlDbType.Int, true);
            parametrosContar.Add(paramFilas);

            if (listaUsuarios.Lista.ToArray().Length == 0 || listaUsuarios.Lista == null)
            {
                throw new ExcepcionesTotem.Modulo3.ListaSinInvolucradosException(RecursosBDModulo3.Codigo_ListaSinInv,
                                                                                 RecursosBDModulo3.Mensaje_ListaSinInv, new Exception());
            }
            try
            {
                List <Resultado> resultado = laConexion.EjecutarStoredProcedure(RecursosBDModulo3.StoredContarUsuario,
                                                                                parametrosContar);
                filasA = int.Parse(resultado[0].valor);

                foreach (Usuario elUsuario in listaUsuarios.Lista)
                {
                    laConexion = new BDConexion();
                    parametros = new List <Parametro>();
                    if (elProyecto.Codigo != null)
                    {
                        paramProyectoCod = new Parametro(RecursosBDModulo3.ParamCodProy, SqlDbType.VarChar,
                                                         elProyecto.Codigo, false);
                        parametros.Add(paramProyectoCod);
                    }
                    else
                    {
                        throw new ExcepcionesTotem.Modulo3.ProyectoSinCodigoException(
                                  RecursosBDModulo3.Codigo_ProyectoSinCod, RecursosBDModulo3.Mensaje_ProyectoSinCod,
                                  new Exception());
                    }
                    if (elUsuario.username != null)
                    {
                        paramUsername = new Parametro(RecursosBDModulo3.ParamUsername, SqlDbType.VarChar,
                                                      elUsuario.username, false);
                        parametros.Add(paramUsername);
                    }
                    else
                    {
                        throw new ExcepcionesTotem.Modulo3.UsuarioSinUsernameException(RecursosBDModulo3.Codigo_UsuarioSinUsername,
                                                                                       RecursosBDModulo3.Mensaje_UsuarioSinUsername, new Exception());
                    }

                    laConexion.EjecutarStoredProcedure(RecursosBDModulo3.StoredInsertarUsuario, parametros);
                }
                laConexion = new BDConexion();
                resultado  = laConexion.EjecutarStoredProcedure(RecursosBDModulo3.StoredContarUsuario, parametrosContar);
                filasD     = int.Parse(resultado[0].valor);

                if (filasD == filasA + listaUsuarios.Lista.ToArray().Length)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            catch (SqlException ex)
            {
                if (ex.Number == 2627)
                {
                    throw new ExcepcionesTotem.Modulo3.InvolucradoRepetidoException(
                              RecursosBDModulo3.Codigo_Involucrado_Repetido,
                              RecursosBDModulo3.Mensaje_Involucrado_Repetido, new Exception());
                }
                else
                {
                    throw new ExcepcionesTotem.ExceptionTotemConexionBD(RecursoGeneralBD.Codigo,
                                                                        RecursoGeneralBD.Mensaje, new Exception());
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionesTotem.ExceptionTotem("No se pudo completar la operacion", new Exception());
            }
        }
示例#55
0
        /// <summary>
        /// Metodo que consulta los contactos involucrados a un proyecto dado
        /// </summary>
        /// <param name="p">proyecto del que se desean saber los involucrados</param>
        /// <returns>lista de contactos involucrados al proyecto que recibe como parametro</returns>
        public static ListaInvolucradoContacto consultarContactosInvolucradosPorProyecto(Proyecto p)
        {
            BDConexion laConexion;
            ListaInvolucradoContacto laListaDeContactos = new ListaInvolucradoContacto();
            List <Parametro>         parametros;
            Parametro codigoProyecto;

            List <Contacto> lContactos = new List <Contacto>();

            try
            {
                laConexion = new BDConexion();
                parametros = new List <Parametro>();
                if (p.Codigo != null)
                {
                    codigoProyecto = new Parametro(RecursosBDModulo3.ParamCodProy, SqlDbType.VarChar, p.Codigo, false);
                    parametros.Add(codigoProyecto);
                }
                else
                {
                    throw new ExcepcionesTotem.Modulo3.ProyectoSinCodigoException(
                              RecursosBDModulo3.Codigo_ProyectoSinCod, RecursosBDModulo3.Mensaje_ProyectoSinCod,
                              new Exception());
                }

                DataTable dt = laConexion.EjecutarStoredProcedureTuplas(RecursosBDModulo3.StoredConsultarContacto,
                                                                        parametros);
                foreach (DataRow row in dt.Rows)
                {
                    Contacto c = new Contacto();
                    c.Con_Id       = int.Parse(row[RecursosBDModulo3.aliasContactoID].ToString());
                    c.Con_Nombre   = row[RecursosBDModulo3.aliasContactoNombre].ToString();
                    c.Con_Apellido = row[RecursosBDModulo3.aliasContactoApellido].ToString();
                    c.ConCargo     = row[RecursosBDModulo3.aliasCargoNombre].ToString();
                    System.Console.WriteLine(row[RecursosBDModulo3.aliasValor].ToString());
                    if (row[RecursosBDModulo3.aliasValor].ToString().Equals("1"))
                    {
                        c.ConClienteJurid            = new ClienteJuridico();
                        c.ConClienteJurid.Jur_Id     = row[RecursosBDModulo3.aliasClienteID].ToString();
                        c.ConClienteJurid.Jur_Nombre = row[RecursosBDModulo3.aliasClienteNombre].ToString();
                    }
                    else
                    {
                        c.ConClienteNat              = new ClienteNatural();
                        c.ConClienteNat.Nat_Id       = row[RecursosBDModulo3.aliasClienteID].ToString();
                        c.ConClienteJurid.Jur_Nombre = row[RecursosBDModulo3.aliasClienteNombre].ToString();
                    }

                    lContactos.Add(c);
                }
                laListaDeContactos = new ListaInvolucradoContacto(lContactos, p);
            }
            catch (SqlException ex)
            {
                throw new ExcepcionesTotem.ExceptionTotemConexionBD(RecursoGeneralBD.Codigo,
                                                                    RecursoGeneralBD.Mensaje, new Exception());
            }
            catch (Exception ex)
            {
                throw new ExcepcionesTotem.ExceptionTotem("No se pudo completar la operacion", new Exception());
            }


            return(laListaDeContactos);
        }
示例#56
0
        /// <summary>
        /// Metodo que elimina un usuario involucrado a un proyecto
        /// </summary>
        /// <param name="c">usuario a eliminar</param>
        /// <param name="p">proyecto al que esta asociado</param>
        /// <returns>Valor booleano que refleja el exito de la operacion</returns>
        public static bool eliminarUsuariosDeIvolucradosEnProyecto(Usuario u, ListaInvolucradoUsuario l)
        {
            int filasA, filasD;

            Parametro        paramProyectoCod, paramFilas, paramUsuario;
            BDConexion       laConexion = new BDConexion();
            List <Parametro> listaParametros, parametrosContar;

            parametrosContar = new List <Parametro>();
            paramFilas       = new Parametro(RecursosBDModulo3.ParamFilas, SqlDbType.Int, true);
            parametrosContar.Add(paramFilas);
            try
            {
                List <Resultado> resultado = laConexion.EjecutarStoredProcedure(RecursosBDModulo3.StoredContarUsuario,
                                                                                parametrosContar);
                filasA = int.Parse(resultado[0].valor);

                laConexion      = new BDConexion();
                listaParametros = new List <Parametro>();
                if (l.Proyecto != null)
                {
                    if (l.Proyecto.Codigo != null)
                    {
                        paramProyectoCod = new Parametro(DatosTotem.Modulo3.RecursosBDModulo3.ParamCodProy,
                                                         SqlDbType.VarChar, l.Proyecto.Codigo, false);
                        listaParametros.Add(paramProyectoCod);
                    }
                    else
                    {
                        throw new ExcepcionesTotem.Modulo3.ProyectoSinCodigoException(
                                  RecursosBDModulo3.Codigo_ProyectoSinCod, RecursosBDModulo3.Mensaje_ProyectoSinCod,
                                  new Exception());
                    }
                }
                else
                {
                    throw new ExcepcionesTotem.Modulo3.ListaSinProyectoException(RecursosBDModulo3.Codigo_ListaSinProy,
                                                                                 RecursosBDModulo3.Mensaje_ListaSinProy, new Exception());
                }
                if (u.username != null)
                {
                    paramUsuario = new Parametro(DatosTotem.Modulo3.RecursosBDModulo3.ParamUsername,
                                                 SqlDbType.VarChar, u.username, false);
                    listaParametros.Add(paramUsuario);
                }
                else
                {
                    throw new ExcepcionesTotem.Modulo3.ContactoSinIDException(
                              RecursosBDModulo3.Codigo_ContactoSinID, RecursosBDModulo3.Mensaje_ContactoSinID,
                              new Exception());
                }

                laConexion.EjecutarStoredProcedure(RecursosBDModulo3.StoredEliminarUsuario, listaParametros);
                laConexion = new BDConexion();
                resultado  = laConexion.EjecutarStoredProcedure(RecursosBDModulo3.StoredContarUsuario, parametrosContar);
                filasD     = int.Parse(resultado[0].valor);

                if ((filasA - 1) == filasD)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            catch (SqlException ex)
            {
                throw new ExcepcionesTotem.ExceptionTotemConexionBD(RecursoGeneralBD.Codigo,
                                                                    RecursoGeneralBD.Mensaje, ex);
            }
            catch (Exception ex)
            {
                return(false);
                //lanza otra
            }
        }
示例#57
0
        /// <summary>
        /// Metodo para consultar empleados por Id
        /// </summary>
        /// <param name="parametro"></param>
        /// <returns></returns>
        public Entidad ConsultarXId(Entidad empleado)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceEmpleado.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);



            List <Parametro> parameters = new List <Parametro>();
            BDConexion       Connection = new BDConexion();
            Parametro        param      = new Parametro();
            Entidad          empleadoFinal;

            try
            {
                param = new Parametro("@id", SqlDbType.Int,
                                      ((DominioTangerine.Entidades.M10.EmpleadoM10)empleado).emp_id.ToString(), false);
                parameters.Add(param);

                DataTable dataTable = EjecutarStoredProcedureTuplas(ResourceEmpleado.DetallarEmpleado, parameters);

                DataRow row = dataTable.Rows[0];

                int      empId            = int.Parse(row[ResourceEmpleado.EmpIdEmpleado].ToString());
                String   empPNombre       = row[ResourceEmpleado.EmpPNombre].ToString();
                String   empSNombre       = row[ResourceEmpleado.EmpSNombre].ToString();
                String   empPApellido     = row[ResourceEmpleado.EmpPApellido].ToString();
                String   empSApellido     = row[ResourceEmpleado.EmpSApellido].ToString();
                String   empGenero        = row[ResourceEmpleado.EmpGenero].ToString();
                int      empCedula        = int.Parse(row[ResourceEmpleado.EmpCedula].ToString());
                DateTime empFecha         = DateTime.Parse(row[ResourceEmpleado.EmpFecha].ToString());
                String   empActivo        = row[ResourceEmpleado.EmpActivo].ToString();
                int      empLugId         = int.Parse(row[ResourceEmpleado.EmpLugId].ToString());
                String   empNivelEstudio  = row[ResourceEmpleado.EmpEstudio].ToString();
                String   empEmailEmployee = row[ResourceEmpleado.EmpEmail].ToString();

                //Variables que son de la entidad Cargo
                String empCargo       = row[ResourceEmpleado.EmpCargo].ToString();
                double empSalario     = double.Parse(row[ResourceEmpleado.EmpSueldo].ToString());
                String empFechaInicio = row[ResourceEmpleado.EmpFechaInicio].ToString();
                String empFechaFin    = row[ResourceEmpleado.EmpFechaFin].ToString();
                String empDireccion   = row[ResourceEmpleado.EmpDireccion].ToString();

                Entidad cargoEmpleado = DominioTangerine.Fabrica.FabricaEntidades.ObtenerCargoXid(empCargo,
                                                                                                  empSalario, empFechaInicio, empFechaFin);

                empleadoFinal = DominioTangerine.Fabrica.FabricaEntidades.ListarEmpleadoId(empId, empPNombre,
                                                                                           empSNombre, empPApellido, empSApellido,
                                                                                           empGenero, empCedula, empFecha, empActivo, empNivelEstudio,
                                                                                           empEmailEmployee, empLugId, cargoEmpleado, empSalario,
                                                                                           empFechaInicio, empFechaFin, empDireccion);
            }
            catch (ArgumentNullException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ConsultarEmpleadoException("DS-101", "Ingreso de un argumento con valor invalido", ex);
            }
            catch (SqlException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new BaseDatosException("DS-101", "Error con la base de datos", ex);
            }
            catch (FormatException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.M10.WrongFormatException(ResourceEmpleado.Codigo_Error_Formato,
                                                                        ResourceEmpleado.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesTangerine.ExceptionTGConBD 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 ExcepcionesTangerine.ExceptionsTangerine(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceEmpleado.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return(empleadoFinal);
        }
示例#58
0
        /// <summary>
        /// Metodo para consultar todos los puntos tratados en una Minuta
        /// </summary>
        /// <param name="idMinuta">Es el id de la Minuta de los puntos a consultar</param>
        /// <returns>Retorna una Lista de todos los punto de la Minuta</returns>
        public List <Punto> ConsultarPuntoBD(int idMinuta)
        {
            con = new BDConexion();
            List <Punto>  listaPunto = new List <Punto>();
            SqlConnection conect     = con.Conectar();

            SqlCommand sqlcom = new SqlCommand(RecursosBDModulo8.ProcedimientoConsultarPuntos, conect);

            try
            {
                sqlcom.CommandType = CommandType.StoredProcedure;
                sqlcom.Parameters.Add(new SqlParameter(RecursosBDModulo8.ParametroIDMinuta, idMinuta));

                SqlDataReader leer;
                conect.Open();

                leer = sqlcom.ExecuteReader();

                while (leer.Read())
                {
                    listaPunto.Add(ObtenerObjetoPuntoBD(leer));
                }
                return(listaPunto);
            }

            catch (NullReferenceException ex)
            {
                throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionNullReference,
                                            RecursosBDModulo8.Mensaje_ExcepcionNullReference, ex);
            }
            catch (ExceptionTotemConexionBD ex)
            {
                throw new ExceptionTotemConexionBD(RecursoGeneralBD.Codigo,
                                                   RecursoGeneralBD.Mensaje, ex);
            }
            catch (SqlException ex)
            {
                throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionSql,
                                            RecursosBDModulo8.Mensaje_ExcepcionSql, ex);
            }
            catch (ParametroIncorrectoException ex)
            {
                throw new ParametroIncorrectoException(RecursosBDModulo8.Codigo_ExcepcionParametro,
                                                       RecursosBDModulo8.Mensaje__ExcepcionParametro, ex);
            }
            catch (AtributoIncorrectoException ex)
            {
                throw new AtributoIncorrectoException(RecursosBDModulo8.Codigo_ExcepcionAtributo,
                                                      RecursosBDModulo8.Mensaje_ExcepcionAtributo, ex);
            }
            catch (Exception ex)
            {
                throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionGeneral,
                                            RecursosBDModulo8.Mensaje_ExcepcionGeneral, ex);
            }

            finally
            {
                con.Desconectar(conect);
            }
        }
示例#59
0
        /// <summary>
        /// Metodo obtener si un usuario esta activo
        /// </summary>
        /// <returns>Usuario</returns>
        public Entidad ObtenerUsuarioCorreo(Entidad usuario)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceEmpleado.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);



            List <Parametro> parameters = new List <Parametro>();
            BDConexion       Connection = new BDConexion();
            Parametro        param      = new Parametro();


            try
            {
                param = new Parametro("@usuario", SqlDbType.VarChar, ((DominioTangerine.Entidades.M2.UsuarioM2)usuario)
                                      .nombreUsuario.ToString(), false);
                parameters.Add(param);

                param = new Parametro("@correo", SqlDbType.VarChar, ((DominioTangerine.Entidades.M2.UsuarioM2)usuario)
                                      .contrasena.ToString(), false);

                parameters.Add(param);


                DataTable dataTable = EjecutarStoredProcedureTuplas(ResourceEmpleado.ObtenerCorreoUsuario, parameters);

                foreach (DataRow row in dataTable.Rows)
                {
                    string usuAct = row[ResourceEmpleado.UsuActivo].ToString();

                    ((DominioTangerine.Entidades.M2.UsuarioM2)usuario).activo = usuAct;
                }
            }
            catch (ArgumentNullException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.M10.NullArgumentException(RecursoGeneralBD.Codigo,
                                                                         RecursoGeneralBD.Mensaje, ex);
            }
            catch (SqlException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.ExceptionTGConBD(RecursoGeneralBD.Codigo,
                                                                RecursoGeneralBD.Mensaje, ex);
            }
            catch (FormatException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw new ExcepcionesTangerine.M10.WrongFormatException(ResourceEmpleado.Codigo_Error_Formato,
                                                                        ResourceEmpleado.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesTangerine.ExceptionTGConBD 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 ExcepcionesTangerine.ExceptionsTangerine(RecursoGeneralBD.Mensaje_Generico_Error, ex);
            }
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
                                ResourceEmpleado.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return(usuario);
        }
示例#60
0
        /// <summary>
        /// Método que elimina un dojo de la base de datos
        /// </summary>
        /// <param name="parametro">id del dojo a eliminar</param>
        /// <returns>True si elimina  dicho dojo y Flase en caso contrario</returns>
        public bool EliminarDojo(Entidad parametro)
        {
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo4.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            BDConexion laConexion;
            List<Parametro> parametros;
            Parametro elParametro = new Parametro();

            try
            {
                DojoM4 elDojo = (DojoM4)FabricaEntidades.ObtenerDojo_M4();
                elDojo = (DojoM4)parametro;

                laConexion = new BDConexion();
                parametros = new List<Parametro>();
                elParametro = new Parametro(RecursosDAOModulo4.ParamIdDojo, SqlDbType.Int, elDojo.Id.ToString(),
                                               false);
                parametros.Add(elParametro);

                laConexion.EjecutarStoredProcedure(RecursosDAOModulo4.EliminarDojo, parametros);

                return true;

            }
            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.Modulo4.FormatoIncorrectoException(RecursosDAOModulo4.Codigo_Error_Formato,
                     RecursosDAOModulo4.Mensaje_Error_Formato, ex);
            }
            catch (ExcepcionesSKD.Modulo4.DojoInexistenteException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);

                throw 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);
            }
            Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo4.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);

            return false;
        }