/// <summary>
/// método lógica de negocio para insertar un persona
/// </summary>
/// <param name="persona"></param>
public static void Insert(Person persona)
{
OperationsLogs.WriteLogsDebug("PersonaBrl", "Insertar", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Empezando a ejecutar el método lógica de negocio para crear un persona"));
try
{
PersonDal.Insertar(persona);
}
catch (SqlException ex)
{
OperationsLogs.WriteLogsRelease("PersonaBrl", "Insertar", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
throw ex;
}
catch (Exception ex)
{
OperationsLogs.WriteLogsRelease("PersonaBrl", "Insertar", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
throw ex;
}
OperationsLogs.WriteLogsDebug("PersonaBrl", "Insertar", string.Format("{0} Info: {1}",
DateTime.Now.ToString(), DateTime.Now.ToString(),
"Termino de ejecutar el método lógica de negocio para insertar persona"));
}
/// <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"));
}
/// <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>
/// 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"));
}
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>
/// Método para obtener un Cliente
/// </summary>
/// <param name="id">Identificado del Cliente </param>
/// <returns>Cliente</returns>
public static Client Get(Guid id)
{
OperationsLogs.WriteLogsDebug("ClienteBrl", "Insertar", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Empezando a ejecutar el método lógica de negocio para obtener un Cliente"));
Client Cliente = null;
try
{
Cliente = ClientDal.Obtener(id);
}
catch (SqlException ex)
{
OperationsLogs.WriteLogsRelease("ClienteBrl", "obtener", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), ex.Message));
throw ex;
}
catch (Exception ex)
{
OperationsLogs.WriteLogsRelease("ClienteBrl", "obtener", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), ex.Message));
throw ex;
}
OperationsLogs.WriteLogsDebug("ClienteBrl", "obtener", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Termino de ejecutar el método lógica de negocio para obtener Cliente"));
return(Cliente);
}
/// <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>
/// 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 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"));
}
/// <summary>
/// Método lógica de negocio para insertar un Cliente
/// </summary>
/// <param name="employee"></param>
public static void Insert(Employee employee)
{
OperationsLogs.WriteLogsDebug("ClienteBrl", "Insertar", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Empezando a ejecutar el método lógica de negocio para crear un Cliente"));
try
{
EmployeeDal.Insertar(employee);
}
catch (SqlException ex)
{
OperationsLogs.WriteLogsRelease("ClienteBrl", "Insertar", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), ex.Message));
throw ex;
}
catch (Exception ex)
{
OperationsLogs.WriteLogsRelease("ClienteBrl", "Insertar", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), ex.Message));
throw ex;
}
OperationsLogs.WriteLogsDebug("ClienteBrl", "Insertar", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Termino de ejecutar el método lógica de negocio para insertar Cliente"));
}
/// <summary>
/// método lógica de negocio para actulizar un Producto
/// </summary>
/// <param name="Producto"></param>
public static void Update(Product product)
{
OperationsLogs.WriteLogsDebug("ProductoBrl", "Actualizar", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Empezando a ejecutar el método lógica de negocio para crear un Producto"));
try
{
ProductDal.Update(product);
}
catch (SqlException ex)
{
OperationsLogs.WriteLogsRelease("ProductoBrl", "Actualizar", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
throw ex;
}
catch (Exception ex)
{
OperationsLogs.WriteLogsRelease("ProductoBrl", "Actualizar", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
throw ex;
}
OperationsLogs.WriteLogsDebug("ProductoBrl", "Actualizar", string.Format("{0} Info: {1}",
DateTime.Now.ToString(), DateTime.Now.ToString(),
"Termino de ejecutar el método lógica de negocio para actualizar Producto"));
}
/// <summary>
/// método lógica de negocio para eliminar un usuario
/// </summary>
/// <param name="usuario"></param>
public static void Eliminar(Guid id)
{
OperationsLogs.WriteLogsDebug("UsuarioBrl", "Eliminar", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Empezando a ejecutar el método lógica de negocio para Eliminar un usuario"));
try
{
UserDal.Eliminar(id);
}
catch (SqlException ex)
{
OperationsLogs.WriteLogsRelease("UsuarioBrl", "Eliminar", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
throw ex;
}
catch (Exception ex)
{
OperationsLogs.WriteLogsRelease("UsuarioBrl", "Eliminar", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
throw ex;
}
OperationsLogs.WriteLogsDebug("UsuarioBrl", "Eliminar", string.Format("{0} Info: {1}",
DateTime.Now.ToString(), DateTime.Now.ToString(),
"Termino de ejecutar el método lógica de negocio para Eliminar usuario"));
}
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>
/// Método lógica de negocio para crear un Cliente en la lógica de negocio
/// </summary>
/// <param name="Cliente"></param>
public static void Update(Client cliente)
{
OperationsLogs.WriteLogsDebug("ClienteBrl", "Actualizar", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Empezando a ejecutar el método lógica de negocio para Actualizar un Cliente"));
try
{
ClientDal.Actualizar(cliente);
}
catch (SqlException ex)
{
OperationsLogs.WriteLogsRelease("ClienteBrl", "Actualizar", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), ex.Message));
throw ex;
}
catch (Exception ex)
{
OperationsLogs.WriteLogsRelease("ClienteBrl", "Actualizar", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), ex.Message));
throw ex;
}
OperationsLogs.WriteLogsDebug("ClienteBrl", "Actualizar", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Termino de ejecutar el método lógica de negocio para Actualizar 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"));
}
private void BtnInsertarCliente_Click(object sender, RoutedEventArgs e)
{
OperationsLogs.WriteLogsDebug("ClienteInsert", "BtnInsertarCliente_Click", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Empezando a ejecutar el metodo de la capa de presentacion para crear un empleado"));
try
{
Client client = new Client();
client.IdPerson = Guid.NewGuid();
client.IdentityCard = txtCedulaDeIdentidad.Text.Trim();
client.Names = txtNombres.Text.Trim();
client.FirstSurname = txtPrimerApellido.Text.Trim();
client.SecondSurname = txtSegundoApellido.Text.Trim();
client.Email = txtCorreoElectronico.Text.Trim();
client.Address = txtdireccion.Text.Trim();
client.Phone = int.Parse(txtTelefono.Text.Trim());
client.User = new User();
client.User.IdUser = Guid.NewGuid();
client.User.UserName = txtNombreUsuario.Text.Trim();
client.User.Password = txtPasswordUsuario.Text.Trim();
ClientBrl.Insert(client);
MessageBox.Show("Empleado Agregado Exitosamente");
this.Close();
}
catch (Exception ex)
{
MessageBox.Show("error" + ex);
OperationsLogs.WriteLogsRelease("InsertarEmpleado", "BtnInsertarCliente_Click", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), ex.Message));
MessageBoxResult result = MessageBox.Show("Existe un problema, por favor contactese con su administrador",
"Confirmation",
MessageBoxButton.OK,
MessageBoxImage.Error);
if (result == MessageBoxResult.OK)
{
Application.Current.Shutdown();
}
}
OperationsLogs.WriteLogsDebug("InsertarEmpleado", "BtnInsertarCliente_Click", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Termino a ejecutar el metodo de la capa de presentacion para crear un empleado"));
}
/// <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);
}
private void BtnInsertar_Click(object sender, RoutedEventArgs e)
{
OperationsLogs.WriteLogsDebug("RestauranteInsert_Update", "BtnInsertarCliente_Click", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Empezando a ejecutar el metodo de la capa de presentacion para crear un empleado"));
try
{
Restaurant restaurant = new Restaurant();
restaurant.IdRestaurante = Guid.NewGuid();
restaurant.IdCliente = id;
restaurant.NombreRestaurante = txtNombreRestaurante.Text.Trim();
restaurant.Direccion = txtDireccion.Text.Trim();
RestauranteBrl.Insert(restaurant);
MessageBox.Show("Restaurante Agregado Exitosamente");
this.Close();
}
catch (Exception ex)
{
MessageBox.Show("error" + ex);
OperationsLogs.WriteLogsRelease("RestauranteInsert_Update", "BtnInsertarCliente_Click", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), ex.Message));
MessageBoxResult result = MessageBox.Show("Existe un problema, por favor contactese con su administrador",
"Confirmation",
MessageBoxButton.OK,
MessageBoxImage.Error);
if (result == MessageBoxResult.OK)
{
Application.Current.Shutdown();
}
}
OperationsLogs.WriteLogsDebug("RestauranteInsert_Update", "BtnInsertarCliente_Click", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Termino a ejecutar el metodo de la capa de presentacion para crear un empleado"));
}
/// <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"));
}
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>
/// 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"));
}
/// <summary>
/// método lógica de negocio para eliminar un Producto
/// </summary>
/// <param name="Producto"></param>
public static Product Get(Guid id)
{
OperationsLogs.WriteLogsDebug("ProductoBrl", "Obtener", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Empezando a ejecutar el método lógica de negocio para Obtener un Producto"));
try
{
return(ProductDal.Get(id));
}
catch (SqlException ex)
{
OperationsLogs.WriteLogsRelease("ProductoBrl", "Obtener", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
throw ex;
}
catch (Exception ex)
{
OperationsLogs.WriteLogsRelease("ProductoBrl", "Obtener", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
throw ex;
}
}
/// <summary>
/// Metodo que realiza una llamada al metodo LOGIN de la clase UsuarioDAl para iniciar una sesion
/// </summary>
/// <param name="usuario"></param>
/// <param name="password"></param>
/// <returns></returns>
public static User ObtenerIdUsuario(string nombreUsuario)
{
OperationsLogs.WriteLogsDebug("UsuarioBrl", "Obtener", string.Format("{0} Info: {1}",
DateTime.Now.ToString(),
"Empezando a ejecutar el método lógica de negocio para Obtener un usuario"));
try
{
return(UserDal.ObtenerIdUsuario(nombreUsuario));
}
catch (SqlException ex)
{
OperationsLogs.WriteLogsRelease("UsuarioBrl", "Obtener", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
throw ex;
}
catch (Exception ex)
{
OperationsLogs.WriteLogsRelease("UsuarioBrl", "Obtener", string.Format("{0} Error: {1}",
DateTime.Now.ToString(), DateTime.Now.ToString(), ex.Message));
throw ex;
}
}
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"));
}
