コード例 #1
0
        public string agrega(string Nombre, double MontoMinimo, string Descripcion)
        {
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        insert         = "insert into Tipo_Cuenta (Nombre, MontoMinimo, Descripcion) " +
                                           "values (@Nombre, @MontoMinimo, @Descripcion)";

            SqlCommand cmd = new SqlCommand(insert, conexion);

            cmd.Parameters.Add("@Nombre", Nombre);
            cmd.Parameters.Add("@MontoMinimo", MontoMinimo);
            cmd.Parameters.Add("@Descripcion", Descripcion);

            try
            {
                cmd.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                conexion.Close();
                return(ex.Message);
            }
            conexion.Close();

            return("Tipo de cuenta agregada exitosamente");
        }
コード例 #2
0
        public Movimiento ObtenerMovimiento(int Folio)
        {
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select Monto, Tipo, convert(varchar, Fecha, 1), convert(varchar, Hora, 8), Clave_Cuenta, NombreDepositante from Movimiento Where Folio = @Folio";
            SqlCommand    cmd            = new SqlCommand(consulta, conexion);

            cmd.Parameters.Add("@Folio", Folio);
            SqlDataReader lector = Rutinas.ObtenerLector(consulta, conexion);
            Movimiento    temp   = null;

            if (lector.HasRows)
            {
                while (lector.Read())
                {
                    double Monto       = lector.GetDouble(0);
                    char   Tipo        = Convert.ToChar(lector.GetValue(1));
                    string Fecha       = lector.GetString(2);
                    string Hora        = lector.GetString(3);
                    int    ClaveCuenta = lector.GetInt32(4);
                    string Nombre      = lector.GetString(5);
                    temp = new Movimiento(Monto, Tipo, Fecha, Hora, ClaveCuenta, Nombre);
                }
            }
            conexion.Close();

            return(temp);
        }
コード例 #3
0
        public bool ValidaMovimientos(int claveCuenta)
        {
            bool          flag           = true;
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            SqlCommand    cmd            = new SqlCommand("SP_ValidaCuentaMovimientos", conexion);

            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.Add("@claveCuenta", claveCuenta);
            cmd.Parameters.Add("@result", SqlDbType.Bit).Direction = ParameterDirection.ReturnValue;

            try
            {
                cmd.ExecuteNonQuery();
                int resultTemp = Convert.ToInt32(cmd.Parameters["@result"].Value);
                flag = resultTemp == 0 ? false : true;
            }
            catch (SqlException ex)
            {
                conexion.Close();
                return(false);
            }
            conexion.Close();
            return(flag);
        }
コード例 #4
0
        public Cuenta BuscarCuenta(int claveC)
        {
            Cuenta temp = null;

            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select c.Saldo, t.Nombre, cl.ID_Cliente from Cuenta c inner join Tipo_Cuenta t on t.ID = c.ID_TipoCuenta  ";

            consulta += "inner join Cuenta_Cliente cl on cl.Clave_Cuenta = c.Clave where c.Clave =@clave";
            SqlCommand cmd = new SqlCommand(consulta, conexion);

            cmd.Parameters.Add("@clave", claveC);

            SqlDataReader lector = cmd.ExecuteReader();

            if (lector.HasRows)
            {
                while (lector.Read())
                {
                    double saldo = Convert.ToDouble(lector.GetValue(0));
                    string tipo  = lector.GetString(1);
                    int    idCli = lector.GetInt32(2);
                    temp = new Cuenta(claveC, saldo, tipo, idCli);
                }
            }
            conexion.Close();

            return(temp);
        }
コード例 #5
0
        public Cliente ObtenerCliente(int key)
        {
            Cliente       temp           = null;
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select Nombre, Domicilio, Ciudad, Telefono from Cliente where @ID=ID";
            SqlCommand    cmd            = new SqlCommand(consulta, conexion);

            cmd.Parameters.Add("@ID", key);

            try
            {
                SqlDataReader lector = cmd.ExecuteReader();
                if (lector.HasRows)
                {
                    while (lector.Read())
                    {
                        string nom    = lector.GetString(0);
                        string dom    = lector.GetString(1);
                        string ciudad = lector.GetString(2);
                        string tel    = lector.GetString(3);
                        temp = new Cliente(key, nom, dom, ciudad, tel);
                    }
                }
                conexion.Close();
            }
            catch (SqlException)
            {
                conexion.Close();
                return(null);
            }

            return(temp);
        }
コード例 #6
0
        public Cliente[] ObtenerClientes()
        {
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select ID, Nombre, Domicilio, Ciudad, Telefono from Cliente";
            SqlDataReader lector         = Rutinas.ObtenerLector(consulta, conexion);

            Cliente[] temp = new Cliente[this.Count()];

            if (lector.HasRows)
            {
                int con = 0;
                while (lector.Read())
                {
                    int    ID     = lector.GetInt32(0);
                    string nom    = lector.GetString(1);
                    string dom    = lector.GetString(2);
                    string ciudad = lector.GetString(3);
                    string tel    = lector.GetString(4);
                    temp[con] = new Cliente(ID, nom, dom, ciudad, tel);
                    con++;
                }
            }
            conexion.Close();
            return(temp);
        }
コード例 #7
0
        public List <Cuenta> ObtenerPorCliente(int claveCliente)
        {
            List <Cuenta> temp = new List <Cuenta>();

            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select c.Clave from Cuenta c ";

            consulta += "inner join Cuenta_Cliente cl on cl.Clave_Cuenta = c.Clave where cl.ID_Cliente = @idCliente";
            SqlCommand cmd = new SqlCommand(consulta, conexion);

            cmd.Parameters.Add("@idCliente", claveCliente);
            SqlDataReader lector = cmd.ExecuteReader();

            if (lector.HasRows)
            {
                while (lector.Read())
                {
                    int claveCuenta = lector.GetInt32(0);
                    temp.Add(BuscarCuenta(claveCuenta));
                }
            }
            conexion.Close();


            return(temp);
        }
コード例 #8
0
        public Movimiento[] obtieneMovimientos()
        {
            Movimiento[]  movimientos    = new Movimiento[this.Count()];
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select Monto, Tipo, convert(varchar, Fecha, 1), convert(varchar, Hora, 8), Clave_Cuenta, NombreDepositante from Movimiento";
            SqlCommand    cmd            = new SqlCommand(consulta, conexion);
            SqlDataReader lector         = Rutinas.ObtenerLector(consulta, conexion);
            int           cont           = 0;

            if (lector.HasRows)
            {
                while (lector.Read())
                {
                    double Monto       = Convert.ToDouble(lector.GetValue(0));
                    char   Tipo        = Convert.ToChar(lector.GetValue(1));
                    string Fecha       = lector.GetString(2);
                    string Hora        = lector.GetString(3);
                    int    ClaveCuenta = lector.GetInt32(4);
                    string Nombre      = lector.GetString(5);
                    movimientos[cont] = new Movimiento(Monto, Tipo, Fecha, Hora, ClaveCuenta, Nombre);
                    cont++;
                }
            }
            conexion.Close();

            return(movimientos);
        }
コード例 #9
0
        public string Agrega(string Nombre, string Domicilio, string Ciudad, string Telefono)
        {
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        insercion      = "insert into Cliente(Nombre,Domicilio,Ciudad,Telefono)";

            insercion += "values(@nom,@dom,@ciudad,@tel)";
            SqlCommand cmd = new SqlCommand(insercion, conexion);

            cmd.Parameters.Add("@nom", Nombre);
            cmd.Parameters.Add("@dom", Domicilio);
            cmd.Parameters.Add("@ciudad", Ciudad);
            cmd.Parameters.Add("@tel", Telefono);

            try
            {
                cmd.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                conexion.Close();
                return(ex.Message);
            }

            return("Cliente agregado exitosamente");
        }
コード例 #10
0
        public string Agrega(double Monto, char Tipo, DateTime Fecha, DateTime Hora, int Clave_Cuenta, string NombreDepositante)
        {
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        insertA        = "insert into Movimiento (Monto, Tipo, Fecha, Hora, Clave_Cuenta, NombreDepositante) " +
                                           "values (@Monto, @Tipo, @Fecha, @Hora, @Clave_Cuenta, @NombreDepositante)";

            SqlCommand cmd = new SqlCommand(insertA, conexion);

            cmd.Parameters.Add("@Monto", Monto);
            cmd.Parameters.Add("@Tipo", Tipo);
            cmd.Parameters.Add("@Fecha", Fecha);
            cmd.Parameters.Add("@Hora", Hora);
            cmd.Parameters.Add("@Clave_Cuenta", Clave_Cuenta);
            cmd.Parameters.Add("@NombreDepositante", NombreDepositante);

            try
            {
                cmd.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                conexion.Close();
                return(ex.Message);
            }
            conexion.Close();

            return("Movimiento realizado exitosamente");
        }
コード例 #11
0
        public int Size()
        {
            int           count          = 0;
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select count(Clave) from Cuenta";
            SqlDataReader lector         = Rutinas.ObtenerLector(consulta, conexion);

            if (lector.HasRows)
            {
                while (lector.Read())
                {
                    count = lector.GetInt32(0);
                }
            }
            conexion.Close();
            return(count);
        }
コード例 #12
0
        public int Count()
        {
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select count(Folio) from Movimiento";
            SqlDataReader lector         = Rutinas.ObtenerLector(consulta, conexion);

            int cont = 0;

            if (lector.HasRows)
            {
                while (lector.Read())
                {
                    cont = lector.GetInt32(0);
                }
            }
            conexion.Close();
            return(cont);
        }
コード例 #13
0
        /*
         *
         *  CONSULTAR SI ES NECESARIO
         *
         * public void elimina(string Nombre)
         * {
         *  for (int i = 0; i < pos; i++)
         *  {
         *      if (catalogo[i] != null)
         *      {
         *          if (catalogo[i].pNombre.Equals(Nombre.ToUpper()))
         *          {
         *              catalogo[i] = null;
         *          }
         *      }
         *  }
         * }
         */

        public string[] obtieneNombres()
        {
            String[]      nombres        = new String[this.Count()];
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select Nombre from Tipo_Cuenta";
            SqlDataReader lector         = Rutinas.ObtenerLector(consulta, conexion);

            if (lector.HasRows)
            {
                int cont = 0;
                while (lector.Read())
                {
                    nombres[cont] = lector.GetString(0);
                    cont++;
                }
            }
            conexion.Close();
            return(nombres);
        }
コード例 #14
0
        public bool Existe(int key)
        {
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select ID from Cliente where @ID=ID";
            SqlCommand    cmd            = new SqlCommand(consulta, conexion);

            cmd.Parameters.Add("@ID", key);

            SqlDataReader lector = cmd.ExecuteReader();

            if (lector.HasRows)
            {
                conexion.Close();
                return(true);
            }
            conexion.Close();

            return(false);
        }
コード例 #15
0
        public string EliminarCuenta(int claveC)
        {
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        eliminacion    = "Delete Cuenta where Clave=@claveC";
            SqlCommand    cmd            = new SqlCommand(eliminacion, conexion);

            cmd.Parameters.Add("@claveC", claveC);

            try
            {
                cmd.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                conexion.Close();
                return(ex.Message);
            }
            conexion.Close();
            return("Cuenta eliminada exitosamente");
        }
コード例 #16
0
        public string ActualizaDireccíon(string direccion, int idCliente)
        {
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        actualizacion  = "Update Cliente set Domicilio=@newDom where id=@idCliente";
            SqlCommand    cmd            = new SqlCommand(actualizacion, conexion);

            cmd.Parameters.Add("@newDom", direccion);
            cmd.Parameters.Add("@idCliente", idCliente);

            try
            {
                cmd.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                conexion.Close();
                return(ex.Message);
            }
            conexion.Close();
            return("Dirección del cliente actualizada exitosamente");
        }
コード例 #17
0
        public string ActualizaTelefono(string tel, int idCliente)
        {
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        actualizacion  = "Update Cliente set telefono=@newTel where id=@idCliente";
            SqlCommand    cmd            = new SqlCommand(actualizacion, conexion);

            cmd.Parameters.Add("@newTel", tel);
            cmd.Parameters.Add("@idCliente", idCliente);

            try
            {
                cmd.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                conexion.Close();
                return(ex.Message);
            }
            conexion.Close();
            return("Teléfono del cliente actualizada exitosamente");
        }
コード例 #18
0
        public int KeyCliente(string Nombre)
        {
            int           keyC           = -1;
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select ID from Cliente where @nombre=Nombre";
            SqlCommand    cmd            = new SqlCommand(consulta, conexion);

            cmd.Parameters.Add("@nombre", Nombre);
            SqlDataReader lector = cmd.ExecuteReader();

            if (lector.HasRows)
            {
                while (lector.Read())
                {
                    keyC = lector.GetInt32(0);
                }
            }

            conexion.Close();
            return(keyC);
        }
コード例 #19
0
        public string Agrega(int claveCuenta, int claveCliente, double saldoInicial, string tipoCuenta)
        {
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexionA      = Rutinas.ConectaBD(cadenaConexion);
            SqlConnection conexionB      = Rutinas.ConectaBD(cadenaConexion);
            string        insercionA     = "insert into Cuenta(Clave,Saldo,ID_TipoCuenta)";

            insercionA += "values(@claveCu,@saldo,@idTipo)";

            SqlCommand cmdA = new SqlCommand(insercionA, conexionA);
            SqlCommand cmdB = new SqlCommand("SP_AñadirCuentaCliente", conexionB);

            int idTipo = manejaCatalogo.BuscarIDTipo(tipoCuenta);

            //Inserción en Cuentas:
            cmdA.Parameters.Add("@claveCu", claveCuenta);
            cmdA.Parameters.Add("@saldo", saldoInicial);
            cmdA.Parameters.Add("@idTipo", idTipo);

            //Inserción en Cuentas-Clientes:
            cmdB.CommandType = CommandType.StoredProcedure;
            cmdB.Parameters.Add("@idCliente", claveCliente);
            cmdB.Parameters.Add("@claveCuenta", claveCuenta);

            try
            {
                cmdA.ExecuteNonQuery();
                cmdB.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                conexionA.Close();
                conexionB.Close();
                return(ex.Message);
            }

            return("Cuenta agregada exitosamente.");
        }
コード例 #20
0
        public int NumCuentasCliente(int claveCliente)
        {
            int           count          = 0;
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select count(Clave) from Cuenta c ";

            consulta += "inner join Cuenta_Cliente cl on cl.Clave_Cuenta = c.Clave where cl.ID_Cliente = @idCliente";
            SqlCommand cmd = new SqlCommand(consulta, conexion);

            cmd.Parameters.Add("@idCliente", claveCliente);
            SqlDataReader lector = cmd.ExecuteReader();

            if (lector.HasRows)
            {
                while (lector.Read())
                {
                    count = lector.GetInt32(0);
                }
            }
            conexion.Close();

            return(count);
        }
コード例 #21
0
        public double obtenerSaldoTotalPorCliente(int claveCliente)
        {
            double saldoTotal = 0;

            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select  case when sum(c.Saldo) is null then 0 else sum(c.Saldo) end as [Saldo Actual] from Cuenta c ";

            consulta += "inner join Cuenta_Cliente cl on cl.Clave_Cuenta = c.Clave where cl.ID_Cliente = @idCliente";
            SqlCommand cmd = new SqlCommand(consulta, conexion);

            cmd.Parameters.Add("@idCliente", claveCliente);
            SqlDataReader lector = cmd.ExecuteReader();

            if (lector.HasRows)
            {
                while (lector.Read())
                {
                    saldoTotal = Convert.ToDouble(lector.GetValue(0));
                }
            }

            return(saldoTotal);
        }
コード例 #22
0
        public TipoCuenta consulta(string Nombre)
        {
            string        cadenaConexion = Rutinas.ObtenerStringConexion();
            SqlConnection conexion       = Rutinas.ConectaBD(cadenaConexion);
            string        consulta       = "select * from Tipo_Cuenta where Nombre = '" + Nombre + "'";
            SqlDataReader lector         = Rutinas.ObtenerLector(consulta, conexion);

            TipoCuenta cuenta = null;

            if (lector.HasRows)
            {
                while (lector.Read())
                {
                    int    ID          = lector.GetInt32(0);
                    string NombreTC    = lector.GetString(1);
                    double MontoMinimo = Convert.ToDouble(lector.GetValue(2));
                    string Descripcion = lector.GetString(3);
                    cuenta = new TipoCuenta(NombreTC, MontoMinimo, Descripcion);
                }
            }
            conexion.Close();

            return(cuenta);
        }