public ResultadoEntidad ActualizarTemporalAccesorioIndividual(TemporalAccesorioEntidad TemporalAccesorioObjetoEntidad)
{
string CadenaConexion = string.Empty;
ResultadoEntidad Resultado = new ResultadoEntidad();
SqlTransaction Transaccion;
SqlConnection Conexion;
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Activos);
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
Resultado = ActualizarTemporalAccesorio(Conexion, Transaccion, TemporalAccesorioObjetoEntidad);
// Si se edito el accesorio temporal exitosamente termina la transaccion
if (Resultado.ErrorId == (int)ConstantePrograma.TemporalAccesorio.TemporalAccesorioEditadoCorrectamente)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
return(Resultado);
}
public ResultadoEntidad GuardarSubFamiliaPuesto(SubFamiliaPuestoEntidad SubFamiliaPuestoObjetoEntidad)
{
string CadenaConexion = string.Empty;
SqlTransaction Transaccion;
SqlConnection Conexion;
ResultadoEntidad Resultado = new ResultadoEntidad();
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Activos);
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
Resultado = InsertarSubFamiliaPuesto(Conexion, Transaccion, SubFamiliaPuestoObjetoEntidad);
if (Resultado.ErrorId == (int)ConstantePrograma.SubFamilia.SubFamiliaGuardadoCorrectamente)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
return(Resultado);
}
public void BorrarOrdenSalidaDetalleTemp()
{
SqlConnection Conexion = new SqlConnection(SeleccionarConexion(ConstantePrograma.DefensoriaDB_Almacen));
SqlTransaction Transaccion;
OrdenSalidaAcceso OrdenSalidaAcceso = new OrdenSalidaAcceso();
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
try
{
// Borrar detalle temporal
OrdenSalidaAcceso.BorrarOrdenSalidaDetalleTemp(Conexion, Transaccion, _OrdenSalidaDetalleEntidad);
if (_ErrorId == 0)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
}
catch
{
if (Conexion.State == ConnectionState.Open)
{
Transaccion.Rollback();
Conexion.Close();
}
}
}
private void btnGrabar_Click(object sender, EventArgs e)
{
if (fun.ValidarFecha(txtFecha.Text) == false)
{
Mensaje("Debe ingresar una fecha correcta para continuar");
return;
}
SqlTransaction Transaccion;
SqlConnection con = new SqlConnection(cConexion.GetConexion());
con.Open();
Transaccion = con.BeginTransaction();
try
{
Int32 CodCompra = GrabarCompra(con, Transaccion);
GrabarDetalleCompra(con, Transaccion, CodCompra);
Transaccion.Commit();
con.Close();
Mensaje("Datos grabados Correctamente");
LimpiarGrilla();
}
catch (Exception exa)
{
Transaccion.Rollback();
con.Close();
Mensaje("Hubo un error en el proceso de grabacion");
Mensaje(exa.Message);
}
}
private void btnGuardar_Click(object sender, EventArgs e)
{
if (txtMonto.Text == "")
{
Mensaje("Debe ingresar un monto para continuar");
return;
}
if (txtApellido.Text == "")
{
Mensaje("Debe ingresar un apellido ");
return;
}
if (txtNombre.Text == "")
{
Mensaje("Debe ingresar un nombre ");
return;
}
if (fun.ValidarFecha(txtFecha.Text) == false)
{
Mensaje("La fecha ingresada es incorrecta");
return;
}
DateTime Fecha = Convert.ToDateTime(txtFecha.Text);
double Importe = fun.ToDouble(txtMonto.Text);
string Nombre = txtNombre.Text;
string Apellido = txtApellido.Text;
string Descripcion = txtDescripcion.Text;
SqlConnection con = new SqlConnection();
con.ConnectionString = Clases.cConexion.Cadenacon();
con.Open();
SqlTransaction Transaccion;
Transaccion = con.BeginTransaction();
string Descrip = "";
cVale vale = new cVale();
cMovimiento mov = new cMovimiento();
try
{
vale.Registrar(con, Transaccion, Fecha, Importe, Nombre, Apellido, Descripcion);
Descrip = "ADELANTO DE DINERO " + txtNombre.Text + " " + txtApellido.Text;
mov.GrabarMovimientoTransaccion(con, Transaccion, -1 * Importe, Descrip, Fecha, 1, null);
Mensaje("Datos grabados correctamente");
Transaccion.Commit();
con.Close();
Limpiar();
}
catch (Exception ex)
{
Transaccion.Rollback();
con.Close();
Mensaje("Hubo un error en el proceso de grabación");
}
}
public ResultadoEntidad AgregarTemporalRequisicion(RequisicionEntidad RequisicionObjetoEntidad)
{
RequisicionAcceso RequisicionAccesoObjeto = new RequisicionAcceso();
string CadenaConexion = string.Empty;
ResultadoEntidad Resultado = new ResultadoEntidad();
ResultadoEntidad ResultadoRequisicionDuplicado = new ResultadoEntidad();
SqlTransaction Transaccion;
SqlConnection Conexion;
if (!ValidarProductoRequisicion(RequisicionObjetoEntidad))
{
return(Resultado);
}
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Almacen);
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
try
{
Resultado = RequisicionAccesoObjeto.SeleccionarRequisicionDetalleTemp(Conexion, Transaccion, RequisicionObjetoEntidad);
if (Resultado.ResultadoDatos.Tables[0].Rows.Count > 0)
{
Resultado.ErrorId = ((int)ConstantePrograma.Requisicion.RequisicionTieneRegistroDuplicado);
}
else
{
Resultado = RequisicionAccesoObjeto.InsertarRequisicionDetalleTemp(Conexion, Transaccion, RequisicionObjetoEntidad);
}
if (Resultado.ErrorId == (int)ConstantePrograma.Requisicion.RequisicionGuardadoCorrectamente)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
return(Resultado);
}
catch (Exception EX)
{
Transaccion.Rollback();
if (Conexion.State == ConnectionState.Open)
{
Conexion.Close();
}
Resultado.DescripcionError = EX.Message;
return(Resultado);
}
}
/// <summary>
/// Guarda la información de una orden temporal.
/// </summary>
public void GuardarProductoOrdenTemp()
{
string CadenaConexion = string.Empty;
SqlTransaction Transaccion;
SqlConnection Conexion = new SqlConnection(SeleccionarConexion(ConstantePrograma.DefensoriaDB_Almacen));
// Validar información
if (!ValidarOrdenTemp())
{
return;
}
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
try
{
// Guardar encabezado temporal
if (_OrdenDetalleEntidad.OrdenId == "")
{
_OrdenDetalleEntidad.OrdenId = Guid.NewGuid().ToString();
GuardarProductoOrdenEncabezadoTemp(Conexion, Transaccion, _OrdenDetalleEntidad);
}
if (_ErrorId != 0)
{
Transaccion.Rollback();
Conexion.Close();
return;
}
// Si todo salió bien, guardar el detalle temporal
GuardaProductoOrdenDetalleTemp(Conexion, Transaccion, _OrdenDetalleEntidad);
if (_ErrorId == 0)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
}
catch (Exception Exception)
{
_ErrorId = (int)TextoError.Error.Generico;
_DescripcionError = Exception.Message;
if (Conexion.State == ConnectionState.Open)
{
Transaccion.Rollback();
Conexion.Close();
}
}
}
private void button2_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(txtNombre.Text))
{
MessageBox.Show("Se debe ingresar un nombre");
return;
}
List <string> columnas = new List <string>();
columnas.Add("Nombre");
List <Filtro> filtrosNom = new List <Filtro>();
filtrosNom.Add(FiltroFactory.Exacto("Nombre", txtNombre.Text));
if (!conexion.ExisteRegistro(Tabla.Rol, columnas, filtrosNom))
{
List <Funcion> funciones = new List <Funcion>();
for (int i = 0; i < checkedListBoxFuncion.Items.Count; i++)
{
if (checkedListBoxFuncion.GetItemChecked(i))
{
funciones.Add((Funcion)i + 1);
}
}
if (funciones.Count == 0)
{
MessageBox.Show("Se debe seleccionar al menos una funcion");
return;
}
Dictionary <string, object> datos = new Dictionary <string, object>();
datos["nombre"] = txtNombre.Text;
Transaccion tr = conexion.IniciarTransaccion();
int idinsertada = tr.Insertar(Tabla.Rol, datos);
if (idinsertada == -1)
{
DialogResult = DialogResult.Abort;
return;
}
foreach (int f in funciones)
{
tr.InsertarTablaIntermedia(Tabla.RolXFuncion, "id_rol", "id_funcion", idinsertada, f);
}
tr.Commit();
MessageBox.Show("Rol creado exitosamente");
}
else
{
MessageBox.Show("Ese rol ya existe.");
txtNombre.Text = string.Empty;
}
DialogResult = DialogResult.OK;
}
public ResultadoEntidad GuardarMantenimiento(MantenimientoEntidad MantenimientoEntidadObjeto)
{
ResultadoEntidad Resultado = new ResultadoEntidad();
string CadenaConexion = string.Empty;
SqlTransaction Transaccion;
SqlConnection Conexion;
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Activos);
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
if (MantenimientoEntidadObjeto.MantenimientoId == 0)
{
Resultado = InsertarMantenimiento(Conexion, Transaccion, MantenimientoEntidadObjeto);
MantenimientoEntidadObjeto.MantenimientoId = Resultado.NuevoRegistroId;
}
else
{
Resultado = EliminarMantenimientoEmpleado(Conexion, Transaccion, MantenimientoEntidadObjeto.MantenimientoId);
}
if (Resultado.ErrorId == (int)ConstantePrograma.Mantenimiento.GuardadoCorrectamente ||
Resultado.ErrorId == (int)ConstantePrograma.MantenimientoEmpleado.EliminadoCorrectamente)
{
Resultado = InsertarMantenimientoActivo(Conexion, Transaccion, MantenimientoEntidadObjeto);
if (Resultado.ErrorId == (int)ConstantePrograma.MantenimientoActivo.GuardadoCorrectamente)
{
Resultado = InsertarMantenimientoEmpleado(Conexion, Transaccion, MantenimientoEntidadObjeto);
if (Resultado.ErrorId == (int)ConstantePrograma.MantenimientoEmpleado.GuardadoCorrectamente)
{
Transaccion.Commit();
Resultado.NuevoRegistroId = MantenimientoEntidadObjeto.MantenimientoId;
}
else
{
Transaccion.Rollback();
}
}
else
{
Transaccion.Rollback();
}
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
return(Resultado);
}
public bool introducirUsuarioEnBBDD(string usuario, string email, string pass, string nombre, string apellidos)
{
lock (bloqueo)
{
conectar();
MySqlTransaction Transaccion;
Transaccion = conexion.BeginTransaction();
ConsolaDebug.escribirEnConsola("INFO", "Comenzando transacción en BD");
MySqlCommand cmd = new MySqlCommand();
cmd.Connection = conexion;
cmd.Transaction = Transaccion;
try
{
// Primer insert de la transacción
string sql = "INSERT INTO usuarios VALUES( null, @user, @email, @pass, @name, @apell )";
cmd.Parameters.AddWithValue("@user", usuario);
cmd.Parameters.AddWithValue("@email", email);
cmd.Parameters.AddWithValue("@pass", pass);
cmd.Parameters.AddWithValue("@name", nombre);
cmd.Parameters.AddWithValue("@apell", apellidos);
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
ConsolaDebug.escribirEnConsola("INFO", "Insert en usuarios ejecutado satisfactoriamente");
// Segundo insert de la transacción
sql = "INSERT INTO credenciales VALUES( (SELECT Id FROM usuarios WHERE usuario = @user), 'token', 'normal' )";
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
Transaccion.Commit();
ConsolaDebug.escribirEnConsola("INFO", "Insert en credenciales ejecutado satisfactoriamente");
return(true);
}
catch (Exception e)
{
try
{
ConsolaDebug.escribirEnConsola("WARNING", "Problema en transacción, comenzando ROLLBACK");
Transaccion.Rollback();
ConsolaDebug.escribirEnConsola("INFO", "ROLLBACK ejecutado satisfactoriamente");
}
catch (MySqlException ex)
{
ConsolaDebug.escribirEnConsola("WARNING", "Problema en ROLLBACK");
if (Transaccion.Connection != null)
{
ConsolaDebug.escribirEnConsola("ERROR", "Excepción lanzada: {0}", ex.Message);
}
}
ConsolaDebug.escribirEnConsola("WARNING", "No se ha insertado nada en la BD");
ConsolaDebug.escribirEnConsola("ERROR", "Excepción lanzada: {0}", e.Message);
return(false);
}
finally
{
conexion.Close();
}
}
}
public ResultadoEntidad GuardarTransferenciaAccesorio(AccesorioEntidad AccesorioObjetoEntidad, int CantidadAccesorios)
{
string CadenaConexion = string.Empty;
ResultadoEntidad Resultado = new ResultadoEntidad();
SqlTransaction Transaccion;
SqlConnection Conexion;
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Activos);
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
//Primero se pasan los accesorios seleccionados al historial
Resultado = InsertarHistorialAccesorioPorTransferencia(Conexion, Transaccion, AccesorioObjetoEntidad);
//Si se guardo el historial correctamente y solo la cantidad de registros igual a la cantidad de accesorios seleccionados
if (Resultado.ErrorId == (int)ConstantePrograma.Accesorio.HistorialAccesorioGuardadoCorrectamente)
{
if (Resultado.NuevoRegistroId == CantidadAccesorios)
{
//Ahora se editan los accesorios para transferirlos al nuevo activo destino (padre)
Resultado = ActualizarAccesorioPorTransferencia(Conexion, Transaccion, AccesorioObjetoEntidad);
if (Resultado.ErrorId == (int)ConstantePrograma.Accesorio.AccesorioGuardadoCorrectamente)
{ //Si no hubo errores y se editaron la misma cantidad de registros que la cantidad de accesorios seleccionados
if (Resultado.NuevoRegistroId == CantidadAccesorios)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
Resultado.DescripcionError = "Ocurrió un error inesperado.";
}
}
else
{
Transaccion.Rollback();
}
}
else
{
Transaccion.Rollback();
Resultado.DescripcionError = "Ocurrió un error inesperado.";
}
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
return(Resultado);
}
public ResultadoEntidad AgregarActivo(TemporalAsignacionEntidad TemporalAsignacionObjetoEntidad)
{
string CadenaConexion = string.Empty;
TemporalAsignacionProceso TemporalAsignacionProcesoNegocio = new TemporalAsignacionProceso();
ResultadoEntidad Resultado = new ResultadoEntidad();
SqlTransaction Transaccion;
SqlConnection Conexion;
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Activos);
// Primero se valida si no se ha agregado al activo a la asignacion temporal
if (ExisteActivoEnAsignacion(TemporalAsignacionObjetoEntidad) == false)
{
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
// Luego se verifica si ya se creeo la asignacion temporal, si no es asi, pues se crea
if (TemporalAsignacionObjetoEntidad.TemporalAsignacionId == 0)
{
Resultado = TemporalAsignacionProcesoNegocio.InsertarTemporalAsignacion(Conexion, Transaccion, TemporalAsignacionObjetoEntidad);
TemporalAsignacionObjetoEntidad.TemporalAsignacionId = Resultado.NuevoRegistroId;
}
// Si la asignacion temporal se creo exitosamente o ya existia, se agrega el activo a la asignacion detalle temporal
if (Resultado.ErrorId == (int)ConstantePrograma.TemporalAsignacion.TemporalAsignacionGuardadoCorrectamente || Resultado.ErrorId == 0)
{
Resultado = GuardarTemporalAsignacionDetalle(Conexion, Transaccion, TemporalAsignacionObjetoEntidad);
// Si se inserto/actualizó el activo en el detalle de la asignacion exitosamente termina la transaccion
if (Resultado.ErrorId == (int)ConstantePrograma.TemporalAsignacion.TemporalAsignacionDetalleGuardadoCorrectamente)
{
Transaccion.Commit();
Resultado.NuevoRegistroId = TemporalAsignacionObjetoEntidad.TemporalAsignacionId;
}
else
{
Transaccion.Rollback();
}
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
}
else
{
// Ya se agregó el activo a la actual asignacion temporal
Resultado.DescripcionError = TextoError.ActivoRepetido;
}
return(Resultado);
}
/// <summary>
/// Guarda un registro nuevo en la tabla temporal de orden de salida.
/// </summary>
public string GuardarOrdenSalida()
{
SqlConnection Conexion = new SqlConnection(SeleccionarConexion(ConstantePrograma.DefensoriaDB_Almacen));
SqlTransaction Transaccion;
string OrdenSalidaClave = String.Empty;
if (!ValidarOrdenSalidaTemp())
{
return(OrdenSalidaClave);
}
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
try
{
//// Guardar encabezado
//if (_OrdenSalidaDetalleEntidad.OrdenSalidaId == "")
//{
//_OrdenSalidaDetalleEntidad.OrdenSalidaId = Guid.NewGuid().ToString();
OrdenSalidaClave = GuardarOrdenSalidaEncabezado(Conexion, Transaccion, _OrdenSalidaDetalleEntidad);
//}
if (_ErrorId != 0)
{
Transaccion.Rollback();
Conexion.Close();
return(OrdenSalidaClave);
}
// Si todo salió bien, guardar el detalle
GuardaOrdenSalidaDetalle(Conexion, Transaccion, _OrdenSalidaDetalleEntidad);
if (_ErrorId == 0)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
return(OrdenSalidaClave);
}
catch (SqlException Ex)
{
if (Conexion.State == ConnectionState.Open)
{
Transaccion.Rollback();
Conexion.Close();
}
return(OrdenSalidaClave);
}
}
public ResultadoEntidad GuardarPreOrdenCompra(PreOrdenEntidad PreOrdenObjetoEntidad)
{
string CadenaConexion = string.Empty;
ResultadoEntidad Resultado = new ResultadoEntidad();
PreOrdenAcceso PreOrdenAccesoObjeto = new PreOrdenAcceso();
SqlTransaction Transaccion;
SqlConnection Conexion;
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Almacen);
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
try
{
if (PreOrdenObjetoEntidad.PreOrdenId == "")
{
Conexion.Close();
//mesnaje de error
return(Resultado);
}
Resultado = PreOrdenAccesoObjeto.InsertarPreOrdenEncabezado(Conexion, Transaccion, PreOrdenObjetoEntidad);
if (Resultado.ErrorId != (int)ConstantePrograma.PreOrden.PreOrdenGuardadoCorrectamente)
{
Transaccion.Rollback();
//devolver msg de errp
return(Resultado);
}
Resultado = GuardarPreOrdenDetalle(Conexion, Transaccion, PreOrdenObjetoEntidad);
if (Resultado.ErrorId == (int)ConstantePrograma.PreOrden.PreOrdenGuardadoCorrectamente)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
return(Resultado);
}
catch (Exception EX)
{
Transaccion.Rollback();
if (Conexion.State == ConnectionState.Open)
{
Conexion.Close();
}
Resultado.DescripcionError = EX.Message;
return(Resultado);
}
}
private void btnCobrar_Click(object sender, EventArgs e)
{
if (tbCuotas.Rows.Count < 1)
{
Mensaje("Debe tener cuotas a cancelar");
return;
}
cCuota objCuota = new cCuota();
Int32 CodVenta = 0;
Double TotalCobrado = 0;
Int32 Cuota = 0;
Double Importe = 0;
DateTime FechaPago = Convert.ToDateTime(txtFecha.Text);
int Saldo = 0;
SqlConnection con = new SqlConnection();
con.ConnectionString = Clases.cConexion.Cadenacon();
con.Open();
SqlTransaction Transaccion;
Transaccion = con.BeginTransaction();
try
{
for (int i = 0; i < GrillaCuotas.Rows.Count - 1; i++)
{
Cuota = Convert.ToInt32(GrillaCuotas.Rows[i].Cells[1].Value.ToString());
CodVenta = Convert.ToInt32(GrillaCuotas.Rows[i].Cells[0].Value.ToString());
Importe = Convert.ToDouble(GrillaCuotas.Rows[i].Cells[2].Value.ToString());
objCuota.GrabarCuotaTransaccion(con, Transaccion, CodVenta, Cuota, FechaPago, Importe, Saldo);
}
TotalCobrado = fun.ToDouble(txtTotal.Text);
string Descrip = "COBRO DE DOCUMENTO, PATENTE: " + txtPatente.Text;
cMovimiento mov = new cMovimiento();
DateTime Fecha = Convert.ToDateTime(txtFecha.Text);
mov.RegistrarMovimientoDescripcionTransaccion(con, Transaccion, CodVenta,
Principal.CodUsuarioLogueado, TotalCobrado, 0, 0, 0, 0, Fecha,
Descrip, -1);
Transaccion.Commit();
con.Close();
Mensaje("Datos Grabados Correctamente");
}
catch (Exception ex)
{
Transaccion.Rollback();
con.Close();
Mensaje("Hubo un error en el proceso de grabación");
}
tbCuotas.Clear();
GrillaCuotas.DataSource = tbCuotas;
if (Principal.CodigoPrincipalAbm != null)
{
Int32 CodigoVenta = Convert.ToInt32(Principal.CodigoPrincipalAbm);
BuscarCuotas(CodigoVenta);
}
}
public bool borrarUsuario(int id, int newUploader)
{
lock (bloqueo)
{
conectar();
MySqlTransaction Transaccion;
Transaccion = conexion.BeginTransaction();
ConsolaDebug.escribirEnConsola("INFO", "Comenzando transacción de borrado en BD enlaces...");
MySqlCommand cmd = new MySqlCommand();
cmd.Connection = conexion;
cmd.Transaction = Transaccion;
try
{
// Primer update de la transacción
string sql = "UPDATE enlaces SET uploader = @newUploader WHERE uploader = @id";
cmd.Parameters.AddWithValue("@newUploader", newUploader);
cmd.Parameters.AddWithValue("@id", id);
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
ConsolaDebug.escribirEnConsola("INFO", "Update en BD ENLACES tabla enlaces se ha cambiado el uploader al usuario admin satisfactoriamente");
// Segundo delete de la transacción
sql = "DELETE FROM usuarios WHERE id = @id";
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
Transaccion.Commit();
ConsolaDebug.escribirEnConsola("INFO", "Delete en BD ENLACES tabla ususarios ejecutado satisfactoriamente");
return(true);
}
catch (Exception e)
{
try
{
ConsolaDebug.escribirEnConsola("WARNING", "Problema en transacción, comenzando ROLLBACK");
Transaccion.Rollback();
ConsolaDebug.escribirEnConsola("INFO", "ROLLBACK ejecutado satisfactoriamente");
}
catch (MySqlException ex)
{
ConsolaDebug.escribirEnConsola("WARNING", "Problema en ROLLBACK");
if (Transaccion.Connection != null)
{
ConsolaDebug.escribirEnConsola("ERROR", "Excepción lanzada: {0}", ex.Message);
}
}
ConsolaDebug.escribirEnConsola("WARNING", "No se ha borrado nada en la BD");
ConsolaDebug.escribirEnConsola("ERROR", "Excepción lanzada: {0}", e.Message);
return(false);
}
finally
{
conexion.Close();
}
}
}
public void GuardarOrdenSalidaTemp()
{
SqlConnection Conexion = new SqlConnection(SeleccionarConexion(ConstantePrograma.DefensoriaDB_Almacen));
SqlTransaction Transaccion;
if (!ValidarOrdenSalidaTemp())
{
return;
}
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
try
{
// Guardar encabezado en la tabla principal
if (_OrdenSalidaDetalleEntidad.OrdenSalidaId == "")
{
_OrdenSalidaDetalleEntidad.OrdenSalidaId = Guid.NewGuid().ToString();
GuardarOrdenSalidaEncabezadoTemp(Conexion, Transaccion, _OrdenSalidaDetalleEntidad);
}
if (_ErrorId != 0)
{
Transaccion.Rollback();
Conexion.Close();
return;
}
// Si todo salió bien, guardar el detalle
GuardaOrdenSalidaDetalleTemp(Conexion, Transaccion, _OrdenSalidaDetalleEntidad);
if (_ErrorId == 0)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
}
catch
{
if (Conexion.State == ConnectionState.Open)
{
Transaccion.Rollback();
Conexion.Close();
}
}
}
public ResultadoEntidad CancelarNuevoPreOrden(TemporalPreOrdenEntidad TemporalPreOrdenObjetoEntidad)
{
string CadenaConexion = string.Empty;
ResultadoEntidad Resultado = new ResultadoEntidad();
TemporalPreOrdenAcceso TemporalPreOrdenAccesoObjeto = new TemporalPreOrdenAcceso();
SqlTransaction Transaccion;
SqlConnection Conexion;
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Almacen);
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
try
{
//Se elimina la PreOrden temporal
if (TemporalPreOrdenObjetoEntidad.ProductoId != "")
{
Resultado = TemporalPreOrdenAccesoObjeto.EliminarPreOrdenDetalleTemp(Conexion, Transaccion, TemporalPreOrdenObjetoEntidad);
if (Resultado.ErrorId == (int)ConstantePrograma.TemporalPreOrden.TemporalPreOrdenEliminadoCorrectamente)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
return(Resultado);
}
catch (Exception EX)
{
Transaccion.Rollback();
if (Conexion.State == ConnectionState.Open)
{
Conexion.Close();
}
Resultado.DescripcionError = EX.Message;
return(Resultado);
}
}
/// <summary>
/// Elimina la información de los productos enviados como parámetro.
/// </summary>
/// <param name="CadenaProductoId">Cadena de caracteres con los identificadores de los productos separados por comas.</param>
public void EliminarProducto(string CadenaProductoId)
{
SqlConnection Conexion = new SqlConnection(SeleccionarConexion(ConstantePrograma.DefensoriaDB_Almacen));
SqlTransaction Transaccion;
// Validar que las marcas no contengan información relacionada con otras tablas
if (TieneRelacionesElProducto(CadenaProductoId))
{
_ErrorId = (int)ConstantePrograma.Producto.TieneInformacionRelacionada;
_DescripcionError = TextoError.ProductoTieneRegistrosRelacionados.Replace("{0}", _OrigenError);
return;
}
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
try
{
// Si se pasaron las validaciones, hay que borrar la existencia del producto
EliminarExistenciaProducto(Conexion, Transaccion, CadenaProductoId);
if (_ErrorId != 0)
{
Transaccion.Rollback();
Conexion.Close();
return;
}
// Ahora se deben borrar los Productos seleccionadas
EliminarProducto(Conexion, Transaccion, CadenaProductoId);
if (_ErrorId == 0)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
}
catch
{
if (Conexion.State == ConnectionState.Open)
{
Transaccion.Rollback();
Conexion.Close();
}
}
}
public ResultadoEntidad CancelarNuevoRequisicion(RequisicionEntidad RequisicionObjetoEntidad)
{
string CadenaConexion = string.Empty;
ResultadoEntidad Resultado = new ResultadoEntidad();
RequisicionAcceso RequisicionAccesoObjeto = new RequisicionAcceso();
SqlTransaction Transaccion;
SqlConnection Conexion;
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Almacen);
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
try
{
//Se elimina la RecepcionDetalle del producto
if (RequisicionObjetoEntidad.ProductoId != "")
{
Resultado = RequisicionAccesoObjeto.EliminarRequisicionDetalle(Conexion, Transaccion, RequisicionObjetoEntidad);
if (Resultado.ErrorId == (int)ConstantePrograma.Requisicion.EliminadoExitosamente)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
return(Resultado);
}
catch (Exception EX)
{
Transaccion.Rollback();
if (Conexion.State == ConnectionState.Open)
{
Conexion.Close();
}
Resultado.DescripcionError = EX.Message;
return(Resultado);
}
}
private void btnReintegrar_Click(object sender, EventArgs e)
{
if (fun.ValidarFecha(txtFechaRintegro.Text) == false)
{
Mensaje("La fecha de reintegro es incorrecta");
return;
}
double Saldo = fun.ToDouble(Grilla.CurrentRow.Cells[5].Value.ToString());
if (Saldo == 0)
{
Mensaje("Ya se ha reintegrado el movimiento");
return;
}
double Importe = fun.ToDouble(Grilla.CurrentRow.Cells[3].Value.ToString());
DateTime Fecha = Convert.ToDateTime(txtFechaRintegro.Text);
Int32 CodVale = Convert.ToInt32(Grilla.CurrentRow.Cells[0].Value.ToString());
string Nombre = Grilla.CurrentRow.Cells[1].Value.ToString();
string Apellido = Grilla.CurrentRow.Cells[2].Value.ToString();
string Descripcion = "";
cVale objVale = new cVale();
cMovimiento mov = new cMovimiento();
SqlConnection con = new SqlConnection();
con.ConnectionString = Clases.cConexion.Cadenacon();
con.Open();
SqlTransaction Transaccion;
Transaccion = con.BeginTransaction();
try
{
objVale.GrabarDevolucion(con, Transaccion, CodVale, Fecha);
Descripcion = "REINTEGRO VALE " + Nombre + " " + Apellido;
mov.GrabarMovimientoTransaccion(con, Transaccion, Importe, Descripcion, Fecha, 1, null);
Mensaje("Datos grabados correctamente");
Transaccion.Commit();
con.Close();
Buscar();
}
catch (Exception ex)
{
Mensaje("Hubo un error en el proceso de grabación");
Transaccion.Rollback();
con.Close();
}
}
public ResultadoEntidad CancelarActualizarActivo(TemporalActivoEntidad TemporalActivoObjetoEntidad)
{
string CadenaConexion = string.Empty;
TemporalAccesorioEntidad TemporalAccesorioObjetoEntidad = new TemporalAccesorioEntidad();
TemporalAccesorioProceso TemporalAccesorioProcesoNegocio = new TemporalAccesorioProceso();
ResultadoEntidad Resultado = new ResultadoEntidad();
SqlTransaction Transaccion;
SqlConnection Conexion;
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Activos);
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
//Se eliminan fisicamente todos los accesorios nuevos de ese activo temporal
TemporalAccesorioObjetoEntidad.GrupoEstatus = "," + ((int)ConstantePrograma.EstatusTemporalAccesorio.Nuevo).ToString() + ",";
TemporalAccesorioObjetoEntidad.TemporalActivoId = TemporalActivoObjetoEntidad.TemporalActivoId;
Resultado = TemporalAccesorioProcesoNegocio.EliminarTemporalAccesorio(Conexion, Transaccion, TemporalAccesorioObjetoEntidad);
if (Resultado.ErrorId == (int)ConstantePrograma.TemporalAccesorio.TemporalAccesorioEliminadoCorrectamente)
{
//Se editan los accesorios con estatus Eliminado a estatus Activo de ese activo temporal
TemporalAccesorioObjetoEntidad.GrupoEstatus = "," + ((int)ConstantePrograma.EstatusTemporalAccesorio.Eliminado).ToString() + ",";
TemporalAccesorioObjetoEntidad.Estatus = (Int16)ConstantePrograma.EstatusTemporalAccesorio.Activo;
TemporalAccesorioObjetoEntidad.TemporalActivoId = TemporalActivoObjetoEntidad.TemporalActivoId;
Resultado = TemporalAccesorioProcesoNegocio.ActualizarTemporalAccesorio(Conexion, Transaccion, TemporalAccesorioObjetoEntidad);
//Si se actualizaron correctamente los accesorios, se termina la transaccion
if (Resultado.ErrorId == (int)ConstantePrograma.TemporalAccesorio.TemporalAccesorioEditadoCorrectamente)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
return(Resultado);
}
private void button2_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(txtNombre.Text))
{
MessageBox.Show("Se debe ingresar un nombre");
return;
}
List <Funcion> aBorrar = new List <Funcion>();
List <Funcion> aInsertar = new List <Funcion>();
for (int i = 0; i < checkedListBoxFuncion.Items.Count; i++)
{
if (checkedListBoxFuncion.GetItemChecked(i) && !funcionesOriginales.Contains((Funcion)i + 1))
{
aInsertar.Add((Funcion)i + 1);
}
if (!checkedListBoxFuncion.GetItemChecked(i) && funcionesOriginales.Contains((Funcion)i + 1))
{
aBorrar.Add((Funcion)i + 1);
}
}
Transaccion tr = conexion.IniciarTransaccion();
Dictionary <string, object> datos = new Dictionary <string, object>();
datos["nombre"] = txtNombre.Text;
tr.Modificar(idRol, Tabla.Rol, datos);
foreach (int v in aInsertar)
{
if (!tr.InsertarTablaIntermedia(Tabla.RolXFuncion, "id_rol", "id_funcion", idRol, v))
{
DialogResult = DialogResult.Abort;
return;
}
}
foreach (int v in aBorrar)
{
if (!tr.eliminarTablaIntermedia(Tabla.RolXFuncion, "id_rol", "id_funcion", idRol, v))
{
DialogResult = DialogResult.Abort;
return;
}
}
tr.Commit();
DialogResult = DialogResult.OK;
}
public ResultadoEntidad GuardarLevantamiento(LevantamientoActivoEntidad LevantamientoActivoObjetoEntidad)
{
string CadenaConexion = string.Empty;
SqlTransaction Transaccion;
SqlConnection Conexion;
ResultadoEntidad Resultado = new ResultadoEntidad();
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Activos);
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
//Primero se guarda el encabezado del levantamiento
Resultado = InsertarLevantamientoEncabezado(Conexion, Transaccion, LevantamientoActivoObjetoEntidad);
// Si el levantamiento fue guardado correctamente, se obtiene su ID
if (Resultado.ErrorId == (int)ConstantePrograma.LevantamientoActivo.LevantamientoActivoGuardadoCorrectamente)
{
LevantamientoActivoObjetoEntidad.LevantamientoID = Resultado.NuevoRegistroId;
//Ahora se guarda el detalle del levantamiento (sus activos y estatus)
Resultado = InsertarLevantamiento(Conexion, Transaccion, LevantamientoActivoObjetoEntidad);
// Si el detalle del levantamiento fue guardado correctamente finaliza la transaccion
if (Resultado.ErrorId == (int)ConstantePrograma.LevantamientoActivo.LevantamientoActivoGuardadoCorrectamente)
{
Resultado.NuevoRegistroId = LevantamientoActivoObjetoEntidad.LevantamientoID;
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
return(Resultado);
}
public ResultadoEntidad EliminarUsuario(string CadenaUsuarioId)
{
string CadenaConexion = string.Empty;
string[] ArrayUsuario;
SqlTransaction Transaccion;
SqlConnection Conexion;
ResultadoEntidad ResultadoEntidadObjeto = new ResultadoEntidad();
UsuarioAcceso UsuarioAccesoObjeto = new UsuarioAcceso();
if (CadenaUsuarioId != "")
{
ArrayUsuario = CadenaUsuarioId.Split(',');
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Seguridad);
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
foreach (string UsuarioId in ArrayUsuario)
{
if (UsuarioId != "")
{
ResultadoEntidadObjeto = EliminarUsuario(Conexion, Transaccion, Int16.Parse(UsuarioId));
if (ResultadoEntidadObjeto.ErrorId != (int)ConstantePrograma.Usuario.EliminacionExitosa)
{
Transaccion.Rollback();
break;
}
}
}
if (ResultadoEntidadObjeto.ErrorId == (int)ConstantePrograma.Usuario.EliminacionExitosa)
{
Transaccion.Commit();
}
}
return(ResultadoEntidadObjeto);
}
public ResultadoEntidad SeleccionarMovimientoBaja(ActivoEntidad ActivoObjetoEntidad)
{
string CadenaConexion = string.Empty;
SqlTransaction Transaccion;
SqlConnection Conexion;
ResultadoEntidad Resultado = new ResultadoEntidad();
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Activos);
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
Resultado = SeleccionarMovimientoBaja(Conexion, Transaccion, ActivoObjetoEntidad);
Transaccion.Commit();
Conexion.Close();
return(Resultado);
}
public ResultadoEntidad CancelarNuevoActivo(TemporalAccesorioEntidad TemporalAccesorioObjetoEntidad, TemporalActivoEntidad TemporalActivoObjetoEntidad)
{
string CadenaConexion = string.Empty;
TemporalAccesorioProceso TemporalAccesorioProcesoNegocio = new TemporalAccesorioProceso();
ResultadoEntidad Resultado = new ResultadoEntidad();
SqlTransaction Transaccion;
SqlConnection Conexion;
CadenaConexion = SeleccionarConexion(ConstantePrograma.DefensoriaDB_Activos);
Conexion = new SqlConnection(CadenaConexion);
Conexion.Open();
Transaccion = Conexion.BeginTransaction();
Resultado = TemporalAccesorioProcesoNegocio.EliminarTemporalAccesorio(Conexion, Transaccion, TemporalAccesorioObjetoEntidad);
// Si se eliminaron los accesorios temporales exitosamente
if (Resultado.ErrorId == (int)ConstantePrograma.TemporalAccesorio.TemporalAccesorioEliminadoCorrectamente)
{
//Se elimina el activo temporal
Resultado = EliminarTemporalActivo(Conexion, Transaccion, TemporalActivoObjetoEntidad);
if (Resultado.ErrorId == (int)ConstantePrograma.TemporalActivo.TemporalActivoEliminadoCorrectamente)
{
Transaccion.Commit();
}
else
{
Transaccion.Rollback();
}
}
else
{
Transaccion.Rollback();
}
Conexion.Close();
return(Resultado);
}
public void ejecutarSQLTransaccion(String pSql)
{
// Definicion de Command
SqlCommand cmd = null;
SqlTransaction Transaccion;
IsError = false;
// Inicio de la transaccion
Transaccion = conexion.BeginTransaction();
try
{
cmd = new SqlCommand(pSql.ToString(), conexion);
cmd.Transaction = Transaccion;
cmd.Connection = conexion;
cmd.ExecuteNonQuery();
Transaccion.Commit();
}
catch (SqlException errorSql)
{
IsError = true;
ErrorDescripcion = "Error en ejecutarSQL \n";
ErrorDescripcion += errorSql.Message;
Transaccion.Rollback();
}
catch (Exception error)
{
IsError = true;
ErrorDescripcion = "Error en ejecutarSQL \n";
ErrorDescripcion += error.Message;
Transaccion.Rollback();
}
cmd.Dispose();
Transaccion.Dispose();
}
private void ButtonExit_Click(object sender, EventArgs e)
{
string puertoHasta = lbResultado.Items[lbResultado.Items.Count - 1].ToString();
int longDesde = puertoHasta.LastIndexOf("HASTA: ") + 7;
int longHasta = puertoHasta.Length - longDesde;
List <Filtro> filtros = new List <Filtro>();
filtros.Add(FiltroFactory.Exacto("descripcion", puertoHasta.Substring(longDesde, longHasta)));
Dictionary <string, List <object> > resul = conexion.ConsultaPlana(Tabla.Puerto, new List <string>(new string[] { "ID" }), filtros);
int IdPuertoDest = Convert.ToInt32(resul["ID"][0]);
Dictionary <string, object> data = new Dictionary <string, object>();
data["puerto_destino_id"] = IdPuertoDest;
if (IDsOG.Count == 0)
{
string puertoDesde = lbResultado.Items[0].ToString();
longDesde = 7;
longHasta = puertoDesde.LastIndexOf(';') - longDesde;
filtros[0] = FiltroFactory.Exacto("descripcion", puertoDesde.Substring(longDesde, longHasta));
resul = conexion.ConsultaPlana(Tabla.Puerto, new List <string>(new string[] { "ID" }), filtros);
data["puerto_origen_id"] = resul["ID"][0];
}
Transaccion tr = conexion.IniciarTransaccion();
tr.Modificar(PkRecorrido, Tabla.Recorrido, data);
foreach (int cod in IDsInsert)
{
tr.InsertarTablaIntermedia(Tabla.Tramo_X_Recorrido, "id_recorrido", "id_tramo", PkRecorrido, cod);
}
foreach (int cod in IDsDelete)
{
tr.eliminarTablaIntermedia(Tabla.Tramo_X_Recorrido, "id_recorrido", "id_tramo", PkRecorrido, cod);
}
tr.Commit();
DialogResult = DialogResult.OK;
}
private void btnGrabar_Click(object sender, EventArgs e)
{
SqlTransaction Transaccion;
SqlConnection con = new SqlConnection(cConexion.GetConexion());
con.Open();
Transaccion = con.BeginTransaction();
try
{
Int32 CodCompra = GrabarCompra(con, Transaccion);
GrabarDetalleCompra(con, Transaccion, CodCompra);
Transaccion.Commit();
con.Close();
Mensaje("Datos grabados Correctamente");
LimpiarGrilla();
}
catch (Exception exa)
{
Transaccion.Rollback();
con.Close();
Mensaje("Hubo un error en el proceso de grabacion");
Mensaje(exa.Message);
}
}