Example #1
0
        public void Actualizar(UsuarioEntity usuario)
        {
            try
            {
                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("ActualizarUsuario", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@UsuarioNombre"].Value    = usuario.nombre.Trim();
                        comando.Parameters["@UsuarioApellido"].Value  = usuario.apellido.Trim();
                        comando.Parameters["@UsuarioEmail"].Value     = usuario.mail.Trim();
                        comando.Parameters["@UsuarioPassword"].Value  = usuario.password.Trim();
                        comando.Parameters["@UsuarioTelefono"].Value  = usuario.telefono.Trim();
                        comando.Parameters["@UsuarioIDPermiso"].Value = usuario.idPermiso;
                        comando.Parameters["@UsuarioDomicilio"].Value = usuario.domicilio.Trim();

                        comando.ExecuteNonQuery();
                    }
                    conexion.Close();
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al actualizar el usuario.", ex);
            }
        }
Example #2
0
        public void Insertar(UsuarioEntity usuario)
        {
            try
            {
                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("CrearUsuario", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@UsuarioNombre"].Value   = usuario.nombre.Trim();
                        comando.Parameters["@UsuarioApellido"].Value = usuario.apellido.Trim();
                        comando.Parameters["@UsuarioEmail"].Value    = usuario.mail.Trim();
                        comando.Parameters["@UsuarioPassword"].Value = usuario.password.Trim();
                        comando.Parameters["@UsuarioTelefono"].Value = usuario.telefono.Trim();
                        /*comando.Parameters["@UsuarioIDPermiso"].Value = usuario.idPermiso;*/
                        comando.Parameters["@UsuarioDomicilio"].Value = usuario.domicilio.Trim();


                        //comando.Parameters["@UsuarioFechaRegistracion"].Value = usuario.FechaRegistracion;
                        comando.ExecuteNonQuery();

                        /*usuario.idUsuario = Convert.ToInt32(comando.Parameters["@RETURN_VALUE"].Value);*/
                    }
                    conexion.Close();
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al insertar el usuario.", ex);
            }
        }
Example #3
0
        public bool ExisteEmail(string mail)
        {
            try
            {
                bool existeEmail;

                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("UsuarioBuscarEmail", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@mail"].Value = mail.Trim();
                        existeEmail = Convert.ToBoolean(comando.ExecuteScalar());
                    }

                    conexion.Close();
                }

                return(existeEmail);
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al buscar por id de usuario.", ex);
            }
        }
Example #4
0
        public void Confirmar(int idCarrito)
        {
            try
            {
                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("ConfirmarCarrito", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@UserID"].Value = idCarrito;
                        comando.ExecuteNonQuery();
                    }
                    conexion.Close();
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al eliminar el Carrito.", ex);
            }
        }
Example #5
0
        public void Eliminar(int idTipoTag)
        {
            try
            {
                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("EliminarTipoTag", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@TipoTagID"].Value = idTipoTag;
                        comando.ExecuteNonQuery();
                    }
                    conexion.Close();
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al eliminar el Tipo de Tag.", ex);
            }
        }
Example #6
0
        public List <ArticuloEntity> Buscar(string descripcion, string Marca, string Codigo)
        {
            // Lista de objetos con datos de empleados.
            List <ArticuloEntity> Articulos = null;

            try
            {
                ArticuloEntity articulo = null;

                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("BuscarArticuloCarrito", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@ArticuloDescripcion"].Value = descripcion.Trim();
                        comando.Parameters["@ArticuloMarca"].Value       = Marca.Trim();
                        comando.Parameters["@ArticuloCodigo"].Value      = Codigo.Trim();

                        using (SqlDataReader cursor = comando.ExecuteReader())
                        {
                            Articulos = new List <ArticuloEntity>();
                            while (cursor.Read())
                            {
                                Articulos.Add(CrearArticulo(cursor));
                            }
                            cursor.Close();
                        }
                    }
                    conexion.Close();
                }
                return(Articulos);
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al buscar por email y contraseña.", ex);
            }
        }
Example #7
0
        public List <UsuarioEntity> Buscar(string email, string nombre, string apellido)
        {
            // Lista de objetos con datos de empleados.
            List <UsuarioEntity> usuarios = null;

            try
            {
                UsuarioEntity usuario = null;

                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("UsuarioBuscar", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@UsuarioEmail"].Value    = email.Trim();
                        comando.Parameters["@UsuarioNombre"].Value   = nombre.Trim();
                        comando.Parameters["@UsuarioApellido"].Value = apellido.Trim();

                        using (SqlDataReader cursor = comando.ExecuteReader())
                        {
                            usuarios = new List <UsuarioEntity>();
                            while (cursor.Read())
                            {
                                usuarios.Add(CrearUsuario(cursor));
                            }
                            cursor.Close();
                        }
                    }
                    conexion.Close();
                }
                return(usuarios);
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al buscar por email y contraseña.", ex);
            }
        }
Example #8
0
        public int Eliminar(int idCarrito)
        {
            try
            {
                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("EliminarCarrito", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@CarritoID"].Value = idCarrito;
                        comando.ExecuteNonQuery();
                    }
                    conexion.Close();
                    return(1);
                }
            }
            catch (Exception ex)
            {
                return(0);
            }
        }
Example #9
0
        public void Actualizar(CarritoEntity Carrito)
        {
            try
            {
                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("ActualizarCarrito", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@CarritoID"].Value        = Carrito.idCarrito;
                        comando.Parameters["@CarritoIdCliente"].Value = Carrito.idCliente;
                        comando.ExecuteNonQuery();
                    }
                    conexion.Close();
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al actualizar el Carrito.", ex);
            }
        }
Example #10
0
        public void Actualizar(TipoTagEntity TipoTag)
        {
            try
            {
                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("ActualizarTipoTag", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@TipoTagID"].Value          = TipoTag.idTipo;
                        comando.Parameters["@TipoTagDescripcion"].Value = TipoTag.descripcion.Trim();
                        comando.ExecuteNonQuery();
                    }
                    conexion.Close();
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al actualizar el TipoTag.", ex);
            }
        }
Example #11
0
        public void AgregarTag(ArticuloEntity articulo, int idTag)
        {
            try
            {
                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("AgregarArticuloTag", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@ArticuloID"].Value  = articulo.idProducto;
                        comando.Parameters["@ArticuloTag"].Value = idTag;
                        comando.ExecuteNonQuery();
                    }
                    conexion.Close();
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al insertar la combinacion articulo-tag.", ex);
            }
        }
Example #12
0
        public List <TipoTagEntity> BuscarTipoAsociado(int idTag)
        {
            // Lista de objetos con datos de empleados.
            List <TipoTagEntity> TipoTags = null;

            try
            {
                TipoTagEntity TipoTag = null;

                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("BuscarTagEdit", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@TagID"].Value = idTag;

                        using (SqlDataReader cursor = comando.ExecuteReader())
                        {
                            TipoTags = new List <TipoTagEntity>();
                            while (cursor.Read())
                            {
                                TipoTags.Add(CrearTipoTag(cursor));
                            }
                            cursor.Close();
                        }
                    }
                    conexion.Close();
                }
                return(TipoTags);
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al buscar por descripcion.", ex);
            }
        }
Example #13
0
        public ArticuloEntity BuscarPorClavePrimaria(int idProducto)
        {
            // Lista de objetos con datos de empleados.
            List <ArticuloEntity> Articulos = null;

            try
            {
                ArticuloEntity Articulo = null;

                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("BuscarArticuloPorClave", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@ArticuloID"].Value = idProducto;

                        using (SqlDataReader cursor = comando.ExecuteReader())
                        {
                            Articulo = new ArticuloEntity();
                            while (cursor.Read())
                            {
                                Articulo = CrearArticulo(cursor);
                            }
                            cursor.Close();
                        }
                    }
                    conexion.Close();
                }
                return(Articulo);
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al buscar el Articulo.", ex);
            }
        }
Example #14
0
        public UsuarioEntity BuscarUsuario(string email, string password)
        {
            try
            {
                UsuarioEntity usuario = null;

                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("UsuarioBuscarPorEmailPassword", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@UsuarioEmail"].Value    = email.Trim();
                        comando.Parameters["@UsuarioPassword"].Value = password.Trim();

                        using (SqlDataReader cursor = comando.ExecuteReader())
                        {
                            if (cursor.Read())
                            {
                                usuario = CrearUsuario(cursor);
                            }

                            cursor.Close();
                        }
                    }

                    conexion.Close();
                }

                return(usuario);
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al buscar por email y contraseña.", ex);
            }
        }
Example #15
0
        public TipoTagEntity BuscarTipoTag(int idTipo)
        {
            try
            {
                TipoTagEntity TipoTag = null;

                using (SqlConnection conexion = ConexionDA.ObtenerConexion())
                {
                    using (SqlCommand comando = new SqlCommand("TipoTagBuscarPorID", conexion))
                    {
                        comando.CommandType = CommandType.StoredProcedure;
                        SqlCommandBuilder.DeriveParameters(comando);

                        comando.Parameters["@TipoTagID"].Value = TipoTag.idTipo;

                        using (SqlDataReader cursor = comando.ExecuteReader())
                        {
                            if (cursor.Read())
                            {
                                TipoTag = CrearTipoTag(cursor);
                            }

                            cursor.Close();
                        }
                    }

                    conexion.Close();
                }

                return(TipoTag);
            }
            catch (Exception ex)
            {
                throw new ExcepcionDA("Se produjo un error al buscar por email y contraseña.", ex);
            }
        }