Esempio n. 1
0
        public static User ObtenerIdUsuario(string nombreUsuario)
        {
            User          res   = new User();
            SqlCommand    cmd   = null;
            SqlDataReader dr    = null;
            string        query = @"SELECT idUsuario
                             FROM Usuario 
                             WHERE nombre = @nombre and eliminado = 1";

            try
            {
                cmd = OperationsSql.CreateBasicCommand(query);
                cmd.Parameters.AddWithValue("@nombre", nombreUsuario);
                dr = OperationsSql.ExecuteDataReaderCommand(cmd);
                while (dr.Read())
                {
                    res = new User()
                    {
                        IdUser = dr.GetGuid(0)
                    };
                }
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("UsuarioDal", "ObtenerIdUsuario(Get)", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            finally
            {
                cmd.Connection.Close();
            }
            return(res);
        }
Esempio n. 2
0
        /// <summary>
        /// Obtiene un Persona de la base de datos
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public static Guid ObtenerIdUsuario(Guid idPersona)
        {
            Guid       idUsuario = Guid.Empty;
            SqlCommand cmd       = null;
            string     query     = @"SELECT idUsuario 
                             FROM Persona 
                             WHERE idPersona=@id and eliminado=1";

            try
            {
                cmd = OperationsSql.CreateBasicCommand(query);
                cmd.Parameters.AddWithValue("@id", idPersona);
                idUsuario = new Guid(OperationsSql.ExcecuteScalarCommand(cmd));
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("PersonaDal", "ObtenerIdUsuario(Get)", string.Format("{0} Error: {1}", DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            finally
            {
                cmd.Connection.Close();
            }
            return(idUsuario);
        }
Esempio n. 3
0
        /// <summary>
        /// Método para actulizar a un empleado
        /// </summary>
        /// <param name="client"></param>
        public static void Actualizar(Client client)
        {
            OperationsLogs.WriteLogsDebug("EmpleadoDal", "Actualizar", string.Format("{0} Info: {1}", DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para eliminar un Persona"));

            SqlCommand command = null;

            // Proporcionar la cadena de consulta
            string queryString = @"UPDATE Cliente
                                    WHERE idPersona=@idPersona";

            try
            {
                command = OperationsSql.CreateBasicCommand(queryString);
                command.Parameters.AddWithValue("@idPersona", client.IdPerson);

                //Actualizo a la persona
                PersonDal.Actualizar(client as Person);

                OperationsSql.ExecuteBasicCommand(command);
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("EmpleadoDal", "Actualizar", string.Format("{0} Error: {1}", DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("EmpleadoDal", "Actualizar", string.Format("{0} Error: {1}", DateTime.Now.ToString(), ex.Message));
                throw ex;
            }

            OperationsLogs.WriteLogsDebug("EmpleadoDal", "Actualizar", string.Format("{0}  Info: {1}", DateTime.Now.ToString(), "Termino de ejecutar  el metodo acceso a datos para Eliminar un Cliente"));
        }
Esempio n. 4
0
        public static void Eliminar(Guid id)
        {
            OperationsLogs.WriteLogsDebug("VentaDal", "Eliminar", string.Format("{0} Info: {1}", DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para eliminar un Venta"));

            SqlCommand command = null;

            // Proporcionar la cadena de consulta
            string queryString = @"UPDATE Pedido SET eliminado = 0
                                    WHERE idPedido = @idPedido";

            try
            {
                command = OperationsSql.CreateBasicCommand(queryString);
                command.Parameters.AddWithValue("@idPedido", id);
                OperationsSql.ExecuteBasicCommand(command);
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("VentaDal", "Eliminar", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("VentaDal", "Eliminar", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }

            OperationsLogs.WriteLogsDebug("VentaDal", "Eliminar", string.Format("{0} {1} Info: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), "Termino de ejecutar  el metodo acceso a datos para Eliminar un Cliente"));
        }
Esempio n. 5
0
        /// <summary>
        /// Elimina Persona de la base de datos
        /// </summary>
        /// <param name="idPerson"></param>
        public static void EliminarConTransaccion(Guid idPerson, SqlTransaction transaction, SqlConnection connection)
        {
            OperationsLogs.WriteLogsDebug("PersonaDal", "Eliminar", string.Format("{0} Info: {1}", DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para eliminar un Persona"));

            SqlCommand command = null;

            // Proporcionar la cadena de consulta
            string queryString = @"UPDATE Persona SET eliminado=0
                                    WHERE idPersona = @idPersona";

            try
            {
                command = OperationsSql.CreateBasicCommandWithTransaction(queryString, transaction, connection);
                command.Parameters.AddWithValue("@idPersona", idPerson);
                OperationsSql.ExecuteBasicCommandWithTransaction(command);

                //elimina al usuario
                UserDal.EliminarPorIdPersonaConTransaccion(idPerson, transaction, connection);

                ////Eliminar telefonos
                //TelefonoDal.EliminarPorIdPersonaConTransaccion(idPersona, transaccion, conexion);
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("PersonaDal", "Eliminar", string.Format("{0} Error: {1}", DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("PersonaDal", "Eliminar", string.Format("{0} Error: {1}", DateTime.Now.ToString(), ex.Message));
                throw ex;
            }

            OperationsLogs.WriteLogsDebug("PersonaDal", "Eliminar", string.Format("{0} Info: {1}", DateTime.Now.ToString(), "Termino de ejecutar  el metodo acceso a datos para Eliminar un Cliente"));
        }
Esempio n. 6
0
        /// <summary>
        /// Método para actulizar la ubicacion de un cliente
        /// </summary>
        /// <param name="Cliente"></param>
        public static void ActualizarUbicacionCliente(Location location)
        {
            OperationsLogs.WriteLogsDebug("ClienteDal", "ActualizarUbicacionCliente", string.Format("{0} Info: {1}", DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para eliminar un Persona"));

            SqlCommand command = null;

            // Proporcionar la cadena de consulta
            string queryString = @"UPDATE Ubicacion SET latitud = @latitud, longitud = @longitud
                                    WHERE idUbicacion=@idUbicacion";

            try
            {
                command = OperationsSql.CreateBasicCommand(queryString);
                command.Parameters.AddWithValue("@latitud", location.Latitude);
                command.Parameters.AddWithValue("@longitud", location.Length);

                OperationsSql.ExecuteBasicCommand(command);
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("ClienteDal", "ActualizarUbicacionCliente", string.Format("{0} Error: {1}", DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("ClienteDal", "ActualizarUbicacionCliente", string.Format("{0} Error: {1}", DateTime.Now.ToString(), ex.Message));
                throw ex;
            }

            OperationsLogs.WriteLogsDebug("ClienteDal", "ActualActualizarUbicacionClienteizar", string.Format("{0}  Info: {1}", DateTime.Now.ToString(), "Termino de ejecutar  el metodo acceso a datos para Eliminar un Cliente"));
        }
Esempio n. 7
0
        /// <summary>
        /// Obtiene la ubicacion de la base de datos
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public static Location Obtener(Guid id)
        {
            Location      res   = new Location();
            SqlCommand    cmd   = null;
            SqlDataReader dr    = null;
            string        query = @"SELECT idUbicacion, latitud, longitud,  
                             FROM Ubicacion 
                             WHERE idUbicacion = @id";

            try
            {
                cmd = OperationsSql.CreateBasicCommand(query);
                cmd.Parameters.AddWithValue("@id", id);
                dr = OperationsSql.ExecuteDataReaderCommand(cmd);
                while (dr.Read())
                {
                    res = new Location()
                    {
                        IdLocation = dr.GetGuid(0),
                        Latitude   = dr.GetInt32(1),
                        Length     = dr.GetInt32(2)
                    };
                }
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("LocationDal", "Obtener(Get)", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            finally
            {
                cmd.Connection.Close();
            }
            return(res);
        }
Esempio n. 8
0
        /// <summary>
        /// Actualiza Usuario de la base de datos
        /// </summary>
        /// <param name="Usuario"></param>
        public static void Actualizar(User user)
        {
            OperationsLogs.WriteLogsDebug("UsuarioDal", "Actualizar", string.Format("{0} Info: {1}", DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para eliminar un Usuario"));

            SqlCommand command = null;

            // Proporcionar la cadena de consulta
            string queryString = @"UPDATE Usuario SET nombre = @nombre, password = @password
                                    WHERE idUsuario = @idUsuario";

            try
            {
                command = OperationsSql.CreateBasicCommand(queryString);
                command.Parameters.AddWithValue("@nombre", user.UserName);
                command.Parameters.AddWithValue("@password", user.Password);
                command.Parameters.AddWithValue("@idUsuario", user.IdUser);
                OperationsSql.ExecuteBasicCommand(command);
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("UsuarioDal", "Actualizar", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("UsuarioDal", "Actualizar", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }

            OperationsLogs.WriteLogsDebug("UsuarioDal", "Actualizar", string.Format("{0} {1} Info: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), "Termino de ejecutar  el metodo acceso a datos para Eliminar un Cliente"));
        }
Esempio n. 9
0
        public static void Insert(Order order)
        {
            OperationsLogs.WriteLogsDebug("VentaDal", "Insertar", string.Format("{0} Info: {1}",
                                                                                DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para crear una Venta"));

            SqlCommand command = null;

            string query = @"INSERT INTO Pedido(idPedido, idCliente, idEmpleado, precioTotal, estadoPedido, fechaInicio, fechaEntrega, eliminado)
                            VALUES(@idPedido, @idCliente, @idEmpleado, @precioTotal, @estadoPedido, @fechaInicio, @fechaEntrega, @eliminado)";

            //Declaro e inicio la conexion
            SqlConnection conexion = OperationsSql.ObtenerConexion();

            //Declaro la transaccion
            SqlTransaction transaccion = null;

            try
            {
                conexion.Open();

                transaccion = conexion.BeginTransaction();
                command     = OperationsSql.CreateBasicCommand(query);
                command.Parameters.AddWithValue("@idPedido", order.IdPedido);
                command.Parameters.AddWithValue("@idCliente", order.IdCliente);
                command.Parameters.AddWithValue("@idEmpleado", order.IdEmpleado);
                command.Parameters.AddWithValue("@precioTotal", order.PrecioTotal);
                command.Parameters.AddWithValue("@estadoPedido", order.EstadoPedido);
                command.Parameters.AddWithValue("@fechaInicio", order.FechaInicio);
                command.Parameters.AddWithValue("@fechaEntrega", order.FechaEntrega);
                command.Parameters.AddWithValue("@eliminado", order.Eliminado);
                OperationsSql.ExecuteBasicCommand(command);

                foreach (Product_Order detalle in order.ProductOrder)
                {
                    Product_OrderDal.InsertTransaction(detalle, transaccion, conexion);
                }

                transaccion.Commit();
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("VentaDal", "Insertar", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("VentaDal", "Insertar", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            finally
            {
                conexion.Close();
            }

            OperationsLogs.WriteLogsDebug("VentaDal", "Insertar", string.Format("{0} {1} Info: {1}",
                                                                                DateTime.Now.ToString(), DateTime.Now.ToString(),
                                                                                "Termino de ejecutar  el metodo acceso a datos para insertar venta"));
        }
Esempio n. 10
0
        /// <summary>
        /// Inserta una Cliente a la base de datos
        /// </summary>
        /// <param name="Cliente"></param>
        public static void Insertar(Client client)
        {
            OperationsLogs.WriteLogsDebug("ClienteDal", "Insertar", string.Format("{0} Info: {1}",
                                                                                  DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para crear un Cliente"));

            SqlCommand command = null;

            //Consulta para insertar Clientes
            string queryString = @"INSERT INTO Cliente(idPersona) 
                                   VALUES(@idCliente)";
            //Declaro e inicio la conexion
            SqlConnection conexion = OperationsSql.ObtenerConexion();

            //Declaro la transaccion
            SqlTransaction transaccion = null;

            try
            {
                //Abro la conexion a la base de datos
                conexion.Open();

                //Inicio la transaccion
                transaccion = conexion.BeginTransaction();

                //Inserto a la persona
                PersonDal.InsertarConTransaccion(client as Person, transaccion, conexion);

                //Inserto al Cliente
                command = OperationsSql.CreateBasicCommandWithTransaction(queryString, transaccion, conexion);
                command.Parameters.AddWithValue("@idCliente", client.IdPerson);

                OperationsSql.ExecuteBasicCommandWithTransaction(command);

                transaccion.Commit();
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("ClienteDal", "Insertar", string.Format("{0} Error: {1} ",
                                                                                        DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("ClienteDal", "Insertar", string.Format("{0} Error: {1}",
                                                                                        DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            finally
            {
                conexion.Close();
            }
            OperationsLogs.WriteLogsDebug("ClienteDal", "Insertar", string.Format("{0} Info: {1}",
                                                                                  DateTime.Now.ToString(),
                                                                                  "Termino de ejecutar  el metodo acceso a datos para insertar Cliente"));
        }
Esempio n. 11
0
        /// <summary>
        /// Actualiza Persona de la base de datos
        /// </summary>
        /// <param name="Persona"></param>
        public static void Actualizar(Person person)
        {
            OperationsLogs.WriteLogsDebug("PersonaDal", "ToUpdate", string.Format("{0} Info: {1}", DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para eliminar un Persona"));

            SqlCommand command = null;

            // Proporcionar la cadena de consulta
            string queryString = @"UPDATE Personas SET cedulaDeIdentidad = @cedulaDeIdentidad, nombres = @nombres, primerApellido = @primerApellido, segundoApellido = @segundoApellido, correoElectronico = @correoElectronico, direccion = @direccion, telefono = @telefono
                                   WHERE idPersona=@idPersona";

            try
            {
                command = OperationsSql.CreateBasicCommand(queryString);
                command.Parameters.AddWithValue("@idPersona", person.IdPerson);
                command.Parameters.AddWithValue("@cedulaDeIdentidad", person.IdentityCard);
                command.Parameters.AddWithValue("@nombres", person.Names);
                command.Parameters.AddWithValue("@primerApellido", person.FirstSurname);
                command.Parameters.AddWithValue("@segundoApellido", person.SecondSurname);
                command.Parameters.AddWithValue("@correoElectronico", person.Email);
                command.Parameters.AddWithValue("@direccion", person.Address);
                command.Parameters.AddWithValue("@telefono", person.Phone);

                //Actualizo al usuario
                if (person.User != null)
                {
                    command.Parameters.AddWithValue("@idUsuario", person.User.IdUser);
                    UserDal.Actualizar(person.User);
                }
                else
                {
                    command.Parameters.AddWithValue("@idUsuario", DBNull.Value);
                }

                ////Actualizo los telefonos
                //foreach (var telefono in persona.Telefonos)
                //{
                //    TelefonoDal.Actualizar(telefono);
                //}

                OperationsSql.ExecuteBasicCommand(command);
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("PersonaDal", "ToUpdate", string.Format("{0} Error: {1}", DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("PersonaDal", "ToUpdate", string.Format("{0} Error: {1}", DateTime.Now.ToString(), ex.Message));
                throw ex;
            }

            OperationsLogs.WriteLogsDebug("PersonaDal", "ToUpdate", string.Format("{0} Info: {1}", DateTime.Now.ToString(), "Termino de ejecutar  el metodo acceso a datos para Eliminar un Cliente"));
        }
Esempio n. 12
0
        /// <summary>
        /// Inserta una Persona a la base de datos
        /// </summary>
        /// <param name="person"></param>
        public static void InsertarConTransaccion(Person person, SqlTransaction transaction, SqlConnection connection)
        {
            OperationsLogs.WriteLogsDebug("PersonaDal", "Insertar", string.Format("{0} Info: {1}",
                                                                                  DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para crear un persona"));

            SqlCommand command = null;

            //Consulta para insertar personas
            string queryString = @"INSERT INTO Persona(idPersona, idUsuario, cedulaDeIdentidad, nombres, primerApellido, segundoApellido, correoElectronico, direccion, telefono, eliminado) 
                                   VALUES(@idPersona, @idUsuario, @cedulaDeIdentidad, @nombres, @primerApellido, @segundoApellido, @correoElectronico, @direccion, @telefono, @eliminado)";

            try
            {
                command = OperationsSql.CreateBasicCommandWithTransaction(queryString, transaction, connection);
                if (person.User != null)
                {
                    UserDal.InsertarTransaccion(person.User, transaction, connection);
                    command.Parameters.AddWithValue("@idUsuario", person.User.IdUser);
                }
                else
                {
                    command.Parameters.AddWithValue("@idUsuario", null);
                }

                command.Parameters.AddWithValue("@idPersona", person.IdPerson);
                command.Parameters.AddWithValue("@cedulaDeIdentidad", person.IdentityCard);
                command.Parameters.AddWithValue("@nombres", person.Names);
                command.Parameters.AddWithValue("@primerApellido", person.FirstSurname);
                command.Parameters.AddWithValue("@segundoApellido", person.SecondSurname);
                command.Parameters.AddWithValue("@correoElectronico", person.Email);
                command.Parameters.AddWithValue("@direccion", person.Address);
                command.Parameters.AddWithValue("@telefono", person.Phone);
                command.Parameters.AddWithValue("@eliminado", (byte)1);

                OperationsSql.ExecuteBasicCommandWithTransaction(command);
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("PersonaDal", "Insertar", string.Format("{0} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("PersonaDal", "Insertar", string.Format("{0} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }

            OperationsLogs.WriteLogsDebug("PersonaDal", "Insertar", string.Format("{0} Info: {1}",
                                                                                  DateTime.Now.ToString(), DateTime.Now.ToString(),
                                                                                  "Termino de ejecutar  el metodo acceso a datos para insertar persona"));
        }
Esempio n. 13
0
        /// <summary>
        /// Método para eliminar a un Cliente
        /// </summary>
        /// <param name="Cliente"></param>
        public static void Eliminar(Guid idCliente)
        {
            OperationsLogs.WriteLogsDebug("ClienteDal", "Eliminar", string.Format("{0} Info: {1}", DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para eliminar un Persona"));

            SqlCommand command = null;

            // Proporcionar la cadena de consulta
            string queryString = @"UPDATE Cliente SET idPersona = @id
                                    WHERE idPersona=@id";
            //Declaro e inicio la conexion
            SqlConnection conexion = OperationsSql.ObtenerConexion();

            //Declaro la transaccion
            SqlTransaction transaccion = null;

            try
            {
                //Abro la conexion a la base de datos
                conexion.Open();

                //Inicio la transaccion
                transaccion = conexion.BeginTransaction();

                command = OperationsSql.CreateBasicCommandWithTransaction(queryString, transaccion, conexion);
                command.Parameters.AddWithValue("@id", idCliente);

                //Elimino a la persona
                PersonDal.EliminarConTransaccion(idCliente, transaccion, conexion);

                OperationsSql.ExecuteBasicCommandWithTransaction(command);

                transaccion.Commit();
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("ClienteDal", "Eliminar", string.Format("{0} Error: {1}", DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("ClienteDal", "Eliminar", string.Format("{0} Error: {1}", DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            OperationsLogs.WriteLogsDebug("ClienteDal", "Eliminar", string.Format("{0}  Info: {1}", DateTime.Now.ToString(), "Termino de ejecutar  el metodo acceso a datos para Eliminar un Cliente"));
        }
Esempio n. 14
0
        /// <summary>
        /// Obtiene un Persona de la base de datos
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public static Client ObtenerCliente(Guid id)
        {
            Client        persona = new Client();
            SqlCommand    cmd     = null;
            SqlDataReader dr      = null;
            string        query   = @"SELECT idPersona, idUsuario cedulaDeIdentidad, nombres, primerApellido, segundoApellido, correoElectronico, direccion, telefono, eliminado 
                             FROM Persona 
                             WHERE idPersona = @id and eliminado = 1";

            try
            {
                cmd = OperationsSql.CreateBasicCommand(query);
                cmd.Parameters.AddWithValue("@id", id);
                dr = OperationsSql.ExecuteDataReaderCommand(cmd);
                while (dr.Read())
                {
                    persona = new Client()
                    {
                        IdPerson      = dr.GetGuid(0),
                        User          = UserDal.Obtener(dr.GetGuid(1)),
                        IdentityCard  = dr.GetString(2),
                        Names         = dr.GetString(3),
                        FirstSurname  = dr.GetString(4),
                        SecondSurname = dr.GetString(5),
                        Email         = dr.GetString(6),
                        Address       = dr.GetString(7),
                        Phone         = dr.GetInt32(8),
                        State         = dr.GetByte(9)
                    };
                }
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("PersonaDal", "ObtenerCliente(Get)", string.Format("{0} Error: {1}", DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            finally
            {
                cmd.Connection.Close();
            }
            return(persona);
        }
Esempio n. 15
0
        /// <summary>
        /// Metodo que ejecuta una consulta UPDATE en la tabla Usuario para cambiar contraseña
        /// </summary>
        public static void CambiarPassword(User user)
        {
            string query = @"UPDATE Usuario 
                             set password = @password, estadoPassword = 1
                             WHERE idUsuario = @idUsuario";

            try
            {
                System.Diagnostics.Debug.WriteLine(string.Format("{0} Info: Inicio del Metodo de Cambiar Contraseña de Empleado Usuario", DateTime.Now));
                SqlCommand cmd = OperationsSql.CreateBasicCommand(query);
                cmd.Parameters.AddWithValue("@password", user.Password).SqlDbType = SqlDbType.VarChar;
                cmd.Parameters.AddWithValue("@idUsuario", user.IdUser);

                OperationsSql.ExecuteBasicCommand(cmd);
                System.Diagnostics.Debug.WriteLine(string.Format("{0} Info: Contraseña Cambiada, Nombre Empleado: {1}", DateTime.Now, Session.userSession));
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(string.Format("{0} Info: Error al Cambiar Contraseña:  {1} Usuario: {2}", DateTime.Now, ex.Message, Session.userSession));
            }
        }
Esempio n. 16
0
        public static Product Get(Guid id)
        {
            Product       product = new Product();
            SqlCommand    cmd     = null;
            SqlDataReader dr      = null;
            string        query   = @"SELECT idProducto, imagen, nombre, ingredientes, descripcion, oferta, eliminado
                           FROM Producto 
                           WHERE idProducto = @id AND eliminado = 1";

            try
            {
                cmd = OperationsSql.CreateBasicCommand(query);
                cmd.Parameters.AddWithValue("@id", id);
                dr = OperationsSql.ExecuteDataReaderCommand(cmd);
                while (dr.Read())
                {
                    product = new Product
                    {
                        IdProduct   = dr.GetGuid(0),
                        Image       = dr.GetString(1),
                        Name        = dr.GetString(2),
                        Ingredients = dr.GetString(3),
                        Description = dr.GetString(4),
                        Offer       = dr.GetByte(5),
                        Price       = dr.GetSqlMoney(6)
                    };
                }
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("ProductoDal", "Obtenet(Get)", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            finally
            {
                cmd.Connection.Close();
            }
            return(product);
        }
Esempio n. 17
0
        /// <summary>
        /// Inserta un Usuario a la base de datos
        /// </summary>
        /// <param name="Producto"></param>
        public static void Insert(Product product)
        {
            OperationsLogs.WriteLogsDebug("ProductoDal", "Insertar", string.Format("{0} Info: {1}",
                                                                                   DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para crear un Producto"));

            SqlCommand command = null;

            //Consulta para insertar Productos
            string queryString = @"INSERT INTO Producto(imagen, nombre, ingredientes, descripcion, oferta, eliminado)
                             VALUES(@imagen, @nombre, @ingredientes, @descripcion, @oferta, @eliminado)";

            try
            {
                command = OperationsSql.CreateBasicCommand(queryString);

                command.Parameters.AddWithValue("@imagen", product.Image);
                command.Parameters.AddWithValue("@nombre", product.Name);
                command.Parameters.AddWithValue("@ingredientes", product.Ingredients);
                command.Parameters.AddWithValue("@descripcion", product.Description);
                command.Parameters.AddWithValue("@oferta", product.Offer);
                command.Parameters.AddWithValue("@eliminado", 1);

                OperationsSql.ExecuteBasicCommand(command);
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("ProductoDal", "Insertar", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("ProductoDal", "Insertar", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }

            OperationsLogs.WriteLogsDebug("ProductoDal", "Insertar", string.Format("{0} {1} Info: {1}",
                                                                                   DateTime.Now.ToString(), DateTime.Now.ToString(),
                                                                                   "Termino de ejecutar  el metodo acceso a datos para insertar Producto"));
        }
Esempio n. 18
0
        public static void Insert(Restaurant restaurant)
        {
            OperationsLogs.WriteLogsDebug("RestaurantDal", "Insertar", string.Format("{0} Info: {1}",
                                                                                     DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para crear un Producto"));

            SqlCommand command = null;

            //Consulta para insertar Productos
            string queryString = @"INSERT INTO Restaurante(idRestaurante, idCliente, idUbicacion, nombre, direccion, eliminado)
                                   VALUES(@idRestaurante, @idCliente, @idUbicacion, @nombre, @direccion, @eliminado)";

            try
            {
                command = OperationsSql.CreateBasicCommand(queryString);

                command.Parameters.AddWithValue("@idRestaurante", restaurant.IdRestaurante);
                command.Parameters.AddWithValue("@idCliente", restaurant.IdCliente);
                command.Parameters.AddWithValue("@idUbicacion", restaurant.IdUbicacion);
                command.Parameters.AddWithValue("@nombre", restaurant.NombreRestaurante);
                command.Parameters.AddWithValue("@direccion", restaurant.Direccion);
                command.Parameters.AddWithValue("@eliminado", 1);

                OperationsSql.ExecuteBasicCommand(command);
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("RestaurantDal", "Insertar", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("RestaurantDal", "Insertar", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }

            OperationsLogs.WriteLogsDebug("RestaurantDal", "Insertar", string.Format("{0} {1} Info: {1}",
                                                                                     DateTime.Now.ToString(), DateTime.Now.ToString(),
                                                                                     "Termino de ejecutar  el metodo acceso a datos para insertar Producto"));
        }
Esempio n. 19
0
        /// <summary>
        /// Metodo para obtener  un Cliente
        /// </summary>
        /// <param name="id">Identificado del Cliente </param>
        /// <returns>Cliente</returns>
        public static Client Obtener(Guid id)
        {
            Client        cliente = null;
            SqlCommand    cmd     = null;
            SqlDataReader dr      = null;
            string        query   = @"SELECT c.idPersona, c.idUbicacion
                             FROM Cliente c
                             INNER JOIN Persona p ON p.idPersona = c.idPersona
                             WHERE c.idPersona = @id and p.eliminado = 1";

            try
            {
                cmd = OperationsSql.CreateBasicCommand(query);
                cmd.Parameters.AddWithValue("@id", id);
                dr      = OperationsSql.ExecuteDataReaderCommand(cmd);
                cliente = PersonDal.ObtenerCliente(id);
                while (dr.Read())
                {
                    cliente.IdPerson = dr.GetGuid(0);
                    cliente.Location = LocationDal.Obtener(dr.GetGuid(1));
                }
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("ClienteDal", "Obtenet", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("ClienteDal", "Obtenet", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            finally
            {
                cmd.Connection.Close();
            }
            return(cliente);
        }
Esempio n. 20
0
        /// <summary>
        /// Inserta un usaurio a la base de datos con transaccion
        /// </summary>
        /// <param name="usuario">Objeto usuario </param>
        /// <param name="transaccion">Objeto transaccion</param>
        /// <param name="conexion">Objeto conexion</param>
        public static void InsertarTransaccion(User usuario, SqlTransaction transaccion, SqlConnection conexion)
        {
            OperationsLogs.WriteLogsDebug("UsuarioDal", "InsertarTransaccion", string.Format("{0} Info: {1}",
                                                                                             DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para crear un usuario"));

            SqlCommand command = null;

            //Consulta para insertar usuarios
            string queryString = @"INSERT INTO Usuario(idUsuario, nombre, password, rol, eliminado, estadoPassword) 
                                    VALUES(@idUsuario, @nombre, @password, @rol, @eliminado, @estadoPassword)";

            try
            {
                command = OperationsSql.CreateBasicCommandWithTransaction(queryString, transaccion, conexion);
                command.Parameters.AddWithValue("@idUsuario", usuario.IdUser);
                command.Parameters.AddWithValue("@nombre", usuario.UserName);
                command.Parameters.AddWithValue("@password", usuario.Password);
                command.Parameters.AddWithValue("@rol", "cliente");
                command.Parameters.AddWithValue("@eliminado", (byte)1);
                command.Parameters.AddWithValue("@estadoPassword", (byte)1);

                OperationsSql.ExecuteBasicCommandWithTransaction(command);
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("UsuarioDal", "InsertarTransaccion", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("UsuarioDal", "InsertarTransaccion", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }

            OperationsLogs.WriteLogsDebug("UsuarioDal", "InsertarTransaccion", string.Format("{0} {1} Info: {1}",
                                                                                             DateTime.Now.ToString(), DateTime.Now.ToString(),
                                                                                             "Termino de ejecutar  el metodo acceso a datos para insertar usuario"));
        }
Esempio n. 21
0
        public static void InsertTransaction(Product_Order product_Order, SqlTransaction transaction, SqlConnection connection)
        {
            OperationsLogs.WriteLogsDebug("DetalleVentaDal", "Insertar", string.Format("{0} Info: {1}",
                                                                                       DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para crear un DetalleVenta"));

            SqlCommand command = null;

            //Consulta para insertar DetalleVentas
            string queryString = @"INSERT INTO DetalleVenta(idProducto, idPedido, cantidad, precioUnitario) 
                                    VALUES(@idProducto, @idPedido, @cantidad, @precioUnitario)";

            try
            {
                command = OperationsSql.CreateBasicCommandWithTransaction(queryString, transaction, connection);

                command.Parameters.AddWithValue("@idProducto", product_Order.IdProducto);
                command.Parameters.AddWithValue("@idPedido", product_Order.IdPedido);
                command.Parameters.AddWithValue("@cantidad", product_Order.Cantidad);
                command.Parameters.AddWithValue("@precioUnitario", product_Order.PrecioUnitario);

                OperationsSql.ExecuteBasicCommandWithTransaction(command);
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("DetalleVentaDal", "Insertar", string.Format("{0} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("DetalleVentaDal", "Insertar", string.Format("{0} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }

            OperationsLogs.WriteLogsDebug("DetalleVentaDal", "Insertar", string.Format("{0} Info: {1}",
                                                                                       DateTime.Now.ToString(), DateTime.Now.ToString(),
                                                                                       "Termino de ejecutar  el metodo acceso a datos para insertar DetalleVenta"));
        }
Esempio n. 22
0
        /// <summary>
        /// Obtiene un Usuario de la base de datos
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public static User Obtener(Guid id)
        {
            User          res   = new User();
            SqlCommand    cmd   = null;
            SqlDataReader dr    = null;
            string        query = @"SELECT idUsuario, nombre, password, rol, eliminado 
                             FROM Usuarios 
                             WHERE idUsuario = @id and eliminado = 1";

            try
            {
                cmd = OperationsSql.CreateBasicCommand(query);
                cmd.Parameters.AddWithValue("@id", id);
                dr = OperationsSql.ExecuteDataReaderCommand(cmd);
                while (dr.Read())
                {
                    res = new User()
                    {
                        IdUser   = dr.GetGuid(0),
                        UserName = dr.GetString(1),
                        Password = dr.GetString(2),
                        Role     = dr.GetString(3),
                        State    = dr.GetByte(4)
                    };
                }
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("UsuarioDal", "Obtenet(Get)", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            finally
            {
                cmd.Connection.Close();
            }
            return(res);
        }
Esempio n. 23
0
        /// <summary>
        /// Actualiza Usuario de la base de datos
        /// </summary>
        /// <param name="Producto"></param>
        public static void Update(Product product)
        {
            OperationsLogs.WriteLogsDebug("ProductoDal", "Actualizar", string.Format("{0} Info: {1}", DateTime.Now.ToString(), "Empezando a ejecutar el metodo acceso a datos para eliminar un Producto"));

            SqlCommand command = null;

            // Proporcionar la cadena de consulta
            string queryString = @"UPDATE Producto SET imagen = @imagen, nombre = @nombre, ingredientes = @ingredientes, descripcion = @descripcion, oferta = @oferta, eliminado = @eliminado
                                   WHERE idProducto = @idProducto";

            try
            {
                command = OperationsSql.CreateBasicCommand(queryString);

                command.Parameters.AddWithValue("@idProducto", product.IdProduct);
                command.Parameters.AddWithValue("@imagen", product.Image);
                command.Parameters.AddWithValue("@nombre", product.Name);
                command.Parameters.AddWithValue("@ingredientes", product.Ingredients);
                command.Parameters.AddWithValue("@descripcion", product.Description);
                command.Parameters.AddWithValue("@oferta", product.Offer);

                OperationsSql.ExecuteBasicCommand(command);
            }
            catch (SqlException ex)
            {
                OperationsLogs.WriteLogsRelease("ProductoDal", "Actualizar", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }
            catch (Exception ex)
            {
                OperationsLogs.WriteLogsRelease("ProductoDal", "Actualizar", string.Format("{0} {1} Error: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
                throw ex;
            }

            OperationsLogs.WriteLogsDebug("ProductoDal", "Actualizar", string.Format("{0} {1} Info: {1}", DateTime.Now.ToString(), DateTime.Now.ToString(), "Termino de ejecutar  el metodo acceso a datos para Eliminar un Cliente"));
        }