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);
}
/// <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);
}
/// <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"));
}
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"));
}
/// <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"));
}
/// <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"));
}
/// <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);
}
/// <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"));
}
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"));
}
/// <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"));
}
/// <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"));
}
/// <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"));
}
/// <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"));
}
/// <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);
}
/// <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));
}
}
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);
}
/// <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"));
}
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"));
}
/// <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);
}
/// <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"));
}
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"));
}
/// <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);
}
/// <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"));
}