public ActionResult AddEditDetalleIngreso(AddEditDetalleIngresoViewModel ViewModel)
{
if (!ModelState.IsValid)
{
ViewModel.Fill(CargarDatosContext());
TryUpdateModel(ViewModel);
return(View(ViewModel));
}
try
{
if (ViewModel.DetalleIngresoId.HasValue)
{
DetalleIngreso _detalleingreso = context.DetalleIngreso.FirstOrDefault(x => x.DetalleIngresoId == ViewModel.DetalleIngresoId.Value);
_detalleingreso.Concepto = ViewModel.Concepto;
_detalleingreso.Monto = ViewModel.Monto.ToDecimal() + ViewModel.MontoAdicional.ToDecimal();
_detalleingreso.Pagado = ViewModel.Pagado;
context.Entry(_detalleingreso).State = System.Data.Entity.EntityState.Modified;
}
else
{
DetalleIngreso _detalleingreso = new DetalleIngreso();
_detalleingreso.Concepto = ViewModel.Concepto;
_detalleingreso.Monto = ViewModel.Monto.ToDecimal() + ViewModel.MontoAdicional.ToDecimal(); //RENZO agregado
_detalleingreso.IngresoId = ViewModel.IngresoId;
_detalleingreso.Estado = ConstantHelpers.EstadoActivo;
_detalleingreso.FechaRegistro = DateTime.Now;
_detalleingreso.Pagado = ViewModel.Pagado;
context.DetalleIngreso.Add(_detalleingreso);
}
context.SaveChanges();
PostMessage(MessageType.Success);
}
catch { PostMessage(MessageType.Error); }
return(RedirectToAction("LstDetalleIngresoAdmin", new { IngresoId = ViewModel.IngresoId, EdificioId = ViewModel.EdificioId }));
}
public static List <DetalleIngreso> ObtenerTodos(int pIdIngreso)
{
string consulta = string.Concat("SELECT TOP(500) di.Id, di.IdIngreso, di.IdProducto, pr.Nombre Producto, pr.Descripcion, ",
"di.Cantidad, di.PrecioUnitario, di.SubTotal from DetalleIngreso di JOIN Producto pr on di.IdProducto = pr.Id where di.IdIngreso = @IdIngreso");
SqlCommand comando = ComunDB.ObtenerComando();
comando.CommandText = consulta;
comando.Parameters.AddWithValue("@IdIngreso", pIdIngreso);
SqlDataReader reader = ComunDB.EjecutarComandoReader(comando);
List <DetalleIngreso> listaDetallesIngreso = new List <DetalleIngreso>();
while (reader.Read())
{
DetalleIngreso detalleIngreso = new DetalleIngreso();
detalleIngreso.Id = reader.GetInt32(0);
detalleIngreso.IdIngreso = reader.GetInt32(1);
detalleIngreso.IdProducto = reader.GetInt32(2);
detalleIngreso.Producto = reader.GetString(3);
detalleIngreso.Descripcion = reader.GetString(4);
detalleIngreso.Cantidad = reader.GetInt32(5);
detalleIngreso.PrecioUnitario = (double)reader.GetDecimal(6);
detalleIngreso.SubTotal = (double)reader.GetDecimal(7);
listaDetallesIngreso.Add(detalleIngreso);
}
return(listaDetallesIngreso);
}
//InsertaDetalleIngreso
public string InsertaDetalleIngreso(DetalleIngreso objDetalleIngresos)
{
string resultado = "";
string create = "Execute InsertaDetalleIngreso '" + objDetalleIngresos.FolioIngreso + "','" + objDetalleIngresos.RutMiembro + "','" + objDetalleIngresos.IdEvento + "','" + objDetalleIngresos.ObservacionesIngreso + "','" + objDetalleIngresos.MontoIngreso + "','" + objDetalleIngresos.IdUsuario + "'";
try
{
comando = new SqlCommand(create, objConexionDB.getCon());
objConexionDB.getCon().Open();
//RECUPERAR EL CODIGO AUTOGENERADO
SqlDataReader reader = comando.ExecuteReader();
if (reader.Read())
{
resultado = reader[0].ToString();
}
}
catch (Exception e)
{
resultado = "1";
}
finally
{
objConexionDB.getCon().Close();
objConexionDB.closeDB();
}
return(resultado);
}
//llena detalleingresoproducto
private void AgregarDetalle(DetalleIngreso prod)
{
try
{
//conectionstring cadena de instrucciones para conectarse a la base de datos
using (SqlConnection conn = new SqlConnection())
{
conn.ConnectionString = Conectar.cnn;
conn.Open();
//sql stuctured querly
//insert into *NOMBRE DE LA TABLA* values(pasan los parametros y se manda la conexión)
SqlCommand insertCommand = new SqlCommand("INSERT INTO DetallesIngreso VALUES (@IdIngreso,@IdBodega,@IdProducto,@Precio_Compra,@Stock_Inicial,@Stock_Actual,@Fecha_Caducidad,@Fecha_Ingreso)", conn);
insertCommand.Parameters.Add(new SqlParameter("IdBodega", prod.IdBodega));
insertCommand.Parameters.Add(new SqlParameter("IdProducto", prod.IdProducto));
insertCommand.Parameters.Add(new SqlParameter("Precio_Compra", prod.Precio_Compra));
insertCommand.Parameters.Add(new SqlParameter("IdIngreso", prod.IdIngreso));
insertCommand.Parameters.Add(new SqlParameter("Stock_Inicial", prod.Stock_Inicial));
insertCommand.Parameters.Add(new SqlParameter("Stock_Actual", prod.Stock_Actual));
insertCommand.Parameters.Add(new SqlParameter("Fecha_Caducidad", prod.Fecha_Caducidad));
insertCommand.Parameters.Add(new SqlParameter("Fecha_Ingreso", prod.Fecha_Ingreso));
insertCommand.ExecuteScalar();
MessageBox.Show("ACTUALIZADO EXITOSAMENTE");
}
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> PutDetalleIngreso(int id, DetalleIngreso detalleIngreso)
{
if (id != detalleIngreso.idDetalleIngreso)
{
return(BadRequest());
}
_context.Entry(detalleIngreso).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DetalleIngresoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutDetalleIngreso(int id, DetalleIngreso detalleingreso)
{
//valido que el id sea diferente
if (id != detalleingreso.idDetalleIngreso)
{
return(BadRequest());
}
_context.Entry(detalleingreso).State = EntityState.Modified;
//a revisar que lo que subamos por medio de la api no sea basura
try
{
await _context.SaveChangesAsync();
}
//ESTO PORQUE REVIERTE LA OPERACION SI EN CASO HAY ERROR
//POR EJEMPLO QUE EL ID YA EXISTE.
catch (DbUpdateConcurrencyException)
{
if (DetalleIngresoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <DetalleIngreso> > PostDetalleIngreso(DetalleIngreso detalleIngreso)
{
_context.DetalleIngresos.Add(detalleIngreso);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetDetalleIngreso", new { id = detalleIngreso.idDetalleIngreso }, detalleIngreso));
}
public async Task <IActionResult> PutDetalleIngreso(int id, DetalleIngreso detIngreso)
{
if (id != detIngreso.idDetalleIngreso)
{
return(BadRequest()); // si es diferente no da un badrequest
}
_context.Entry(detIngreso).State = EntityState.Modified; /*indicar al dbcontexr con el entity que lo que hay en detalle ingreso
* vamos a realizar una modificacion , las entidad ya tiene las propiedades
* o informacion que vamos a guardar*/
/*el manejo de erro try nos evitará tener problemas a evitar que si hay error que la api no falle*/
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)//esto lo que hara un rollback a la operacion que se esta realizando
{
if (!DetalleIngresoExists(id))
{
return(NotFound());
}
else
{
throw;// por si desconocemos el error
}
}
return(NoContent());
}
private void btnEliminar_Click(object sender, EventArgs e)
{
DetalleIngreso di = (DetalleIngreso)dgtbDetalleIngreso.CurrentRow.DataBoundItem;
ingreso.detalleIngreso.Remove(di);
ActualizarDataGrid();
}
//actualiza tabla detalleingresoproducto si existe
private void ActualizarDetallesdeIngresoporcantidad()
{
try
{
//conectionstring cadena de instrucciones para conectarse a la base de datos
using (SqlConnection conn = new SqlConnection())
{
conn.ConnectionString = Conectar.cnn;
conn.Open();
//sql stuctured querly
//insert into *NOMBRE DE LA TABLA* values(pasan los parametros y se manda la conexión)
SqlCommand insertCommand = new SqlCommand("" +
"UPDATE DetallesIngreso SET " +// IdIngreso= @IdIngreso," +
"IdBodega = @IdBodega," +
"Precio_Compra = @Precio_Compra," +
"Stock_Inicial = @Stock_Inicial," +
"Stock_Actual = @Stock_Actual," +
"Fecha_Caducidad = @Fecha_Caducidad," +
"Fecha_Ingreso=@Fecha_Ingreso" +
" WHERE IdProducto = @IdProducto", conn);
var Idbodega = Convert.ToInt32(comboBox4.SelectedValue);
var detingreso = new DetalleIngreso
{
IdBodega = Idbodega,
IdProducto = int.Parse(txtidprod.Text),
// IdIngreso=int.Parse(txtid.Text),
Precio_Compra = Convert.ToInt32(txtpreciocompra.Text),
Stock_Actual = int.Parse(txtactual.Text),
Stock_Inicial = int.Parse(txtinicial.Text),
Fecha_Caducidad = Convert.ToDateTime(txtfechacaducidad.Text),
Fecha_Ingreso = textBox1.Text
};
// insertCommand.Parameters.Add(new SqlParameter("IdIngreso", detingreso.IdIngreso));
insertCommand.Parameters.Add(new SqlParameter("IdBodega", detingreso.IdBodega));
insertCommand.Parameters.Add(new SqlParameter("Precio_Compra", detingreso.Precio_Compra));
insertCommand.Parameters.Add(new SqlParameter("Stock_Inicial", detingreso.Stock_Inicial));
insertCommand.Parameters.Add(new SqlParameter("Stock_Actual", detingreso.Stock_Actual));
insertCommand.Parameters.Add(new SqlParameter("Fecha_Caducidad", detingreso.Fecha_Caducidad));
insertCommand.Parameters.Add(new SqlParameter("Fecha_Ingreso", detingreso.Fecha_Ingreso));
insertCommand.Parameters.Add(new SqlParameter("IdProducto", detingreso.IdProducto));
insertCommand.ExecuteScalar();
MessageBox.Show("Datos Guardados con exito");
}
}
catch (Exception)
{
throw;
}
}
public override async Task <IActionResult> Create(IngresoDto dto)
{
if (!await _context.Usuarios.AnyAsync(u => u.Id == dto.IdUsuario))
{
return(BadRequest("No existe el usuario"));
}
if (!await _context.Proveedores.AnyAsync(u => u.Id == dto.IdProveedor))
{
return(BadRequest("No existe el proveedor"));
}
if (dto.Detalles.Count == 0)
{
return(BadRequest(new { detallesError = "Debe agregar artículos al detalle" }));
}
Ingreso ingreso = new Ingreso
{
IdProveedor = (long)dto.IdProveedor,
IdUsuario = dto.IdUsuario,
TipoComprobante = dto.TipoComprobante,
NroComprobante = dto.NroComprobante,
FechaHora = DateTime.Now,
Impuesto = (decimal)dto.Impuesto,
Total = (decimal)dto.Total,
Estado = "Aceptado",
FechaCreacion = DateTime.Now
};
_context.Ingresos.Add(ingreso);
await _context.SaveChangesAsync();
foreach (var detalleDto in dto.Detalles)
{
//se registra el detalle
DetalleIngreso detalle = new DetalleIngreso
{
IdIngreso = ingreso.Id,
IdArticulo = (long)detalleDto.IdArticulo,
Cantidad = (int)detalleDto.Cantidad,
Precio = (decimal)detalleDto.Precio,
FechaCreacion = DateTime.Now
};
_context.DetallesIngresos.Add(detalle);
//se actualiza el stock
var articulo = await _context.Articulos.FindAsync(detalleDto.IdArticulo);
articulo.Stock += (int)detalleDto.Cantidad;
_context.Articulos.Update(articulo);
await _context.SaveChangesAsync();
}
await _context.SaveChangesAsync();
return(Ok(new { id = ingreso.Id }));
}
public ActionResult InsertaDetalleIngreso(Int64 folioIngreso, string pagadorIngreso, Int64 idFormaPago, DateTime fechaPago, string observacionesIngreso, Int64 idEstadoIngreso, string idUsuario, string rutMiembro, long idEvento, string observacionesDetalle, long montoDetalle)
{
string mensaje = "";
if (folioIngreso == 0 || idUsuario == "")
{
//if (idDetalleIngreso == 0) mensaje = "SELECCIONE ACCION GESTIÓN";
if (folioIngreso == 0)
{
mensaje = "SELECCIONE RESULTADO";
}
if (idUsuario == "")
{
mensaje = "ERROR EN IDENTIFICADOR DE HABILITADO";
}
}
else
{
try
{
DetalleIngreso objDetalleIngreso = new DetalleIngreso(folioIngreso, rutMiembro, idEvento, observacionesDetalle, montoDetalle, idUsuario);
string resultadoDetalle = objDetalleIngresoNeg.InsertaDetalleIngreso(objDetalleIngreso);
if (resultadoDetalle == "1" || resultadoDetalle == null)
{
mensaje = "ERROR AL REGISTRAR DETALLE DEL PAGO";
}
else
{
mensaje = "0";
}
Ingreso objIngreso = new Ingreso(folioIngreso, pagadorIngreso, idFormaPago, Convert.ToDateTime(fechaPago), observacionesIngreso, idEstadoIngreso, idUsuario);
//objDetalleIngresoNeg.EliminaDetalleIngreso(objDetalleIngreso);
string resultado = objIngresoNeg.ActualizaEncabezado(objIngreso);
//resultado = objIngresoNeg.Resultado.ToString();
if (resultado == "1" || resultado == null)
{
mensaje = "ERROR AL REGISTRAR EL PAGO";
}
else
{
mensaje = "0";
}
}
catch (Exception)
{
mensaje = "ERROR, REVISAR DATOS INGRESADOS";
}
}
return(Json(mensaje));
}
private void btnAgregar_Click(object sender, EventArgs e)
{
DetalleIngreso di = new DetalleIngreso();
di.TipoComprobante = cmbTipoComprobante.Text;
di.Igv = txtIgv.Text;
di.Estado = txtEstado.Text;
di.Correlativo = txtCorrelativo.Text;
ingreso.detalleIngreso.Add(di);
ActualizarDataGrid();
Limpiar();
}
void AgregarDetalle()
{
if (idDetalleIngresoAEditar != null)
{
foreach (DetalleIngreso detalle in listadoDetallesIngreso.Where(x => x.Id == idDetalleIngresoAEditar))
{
detalle.IdProducto = producto.Id;
detalle.Producto = producto.Nombre;
detalle.Descripcion = producto.Descripcion;
detalle.Cantidad = (int)nudCantidad.Value;
detalle.PrecioUnitario = producto.PrecioVenta;
detalle.SubTotal = (int)nudCantidad.Value * producto.PrecioVenta;
}
ActualizarDatagridView();
LimpiarDetalles();
btnAgregarDetalle.Text = "Agregar detalle";
}
else
{
DetalleIngreso detalleIngresoAAgregar = new DetalleIngreso();
detalleIngresoAAgregar.IdProducto = producto.Id;
detalleIngresoAAgregar.Producto = producto.Nombre;
detalleIngresoAAgregar.Descripcion = producto.Descripcion;
detalleIngresoAAgregar.Cantidad = (int)nudCantidad.Value;
detalleIngresoAAgregar.PrecioUnitario = producto.PrecioVenta;
detalleIngresoAAgregar.SubTotal = (int)nudCantidad.Value * producto.PrecioVenta;
int idUltimoDetalle;
if (listadoDetallesIngreso.Count >= 1)
{
idUltimoDetalle = listadoDetallesIngreso[listadoDetallesIngreso.Count - 1].Id;
}
else
{
idUltimoDetalle = 0;
}
detalleIngresoAAgregar.Id = idUltimoDetalle + 1;
if (listadoDetallesIngreso.Exists(x => x.IdProducto == detalleIngresoAAgregar.IdProducto))
{
MetroMessageBox.Show(this, "Ya agregó este producto a la lista.", "¡Aviso!", MessageBoxButtons.OK, MessageBoxIcon.Warning,
MessageBoxDefaultButton.Button1);
nudCantidad.ResetText();
nudCantidad.Focus();
}
else
{
listadoDetallesIngreso.Add(detalleIngresoAAgregar);
CargarListadoDetalles();
LimpiarDetalles();
}
}
}
public static int Modificar(DetalleIngreso pDetalleIngreso)
{
string consulta = @"UPDATE DetalleIngreso SET IdIngreso = @IdIngreso, IdProducto = @IdProducto, Cantidad = @Cantidad, PrecioUnitario = @PrecioUnitario WHERE Id = @Id";
SqlCommand comando = ComunDB.ObtenerComando();
comando.CommandText = consulta;
comando.Parameters.AddWithValue("@IdIngreso", pDetalleIngreso.IdIngreso);
comando.Parameters.AddWithValue("@IdProducto", pDetalleIngreso.IdProducto);
comando.Parameters.AddWithValue("@Cantidad", pDetalleIngreso.Cantidad);
comando.Parameters.AddWithValue("@PrecioUnitario", (decimal)pDetalleIngreso.PrecioUnitario);
comando.Parameters.AddWithValue("@Id", pDetalleIngreso.Id);
return(ComunDB.EjecutarComando(comando));
}
void CargarDetallesAEditar()
{
DetalleIngreso detalleAEditar = listadoDetallesIngreso.Find(x => x.Id == idDetalleIngresoAEditar);
producto = ProductoBL.BuscarPorId(detalleAEditar.IdProducto);
lblNombreProducto.Text = producto.Nombre;
lblPrecioUnitario.Text = string.Concat("$ ", producto.PrecioVenta.ToString("N"));
lblDescripcion.Text = producto.Descripcion;
lblStock.Text = producto.Stock.ToString();
nudCantidad.Text = detalleAEditar.Cantidad.ToString();
lblSubTotal.Text = string.Concat("$ ", detalleAEditar.SubTotal.ToString("N"));
HabilitarBotonAgregarDetalle();
}
public static int Guardar(DetalleIngreso pDetalleIngreso)
{
string consulta = string.Concat("INSERT INTO DetalleIngreso (IdIngreso, IdProducto, Cantidad, PrecioUnitario) ",
"VALUES (@IdIngreso, @IdProducto, @Cantidad, @PrecioUnitario)");
SqlCommand comando = ComunDB.ObtenerComando();
comando.CommandText = consulta;
comando.Parameters.AddWithValue("@IdIngreso", pDetalleIngreso.IdIngreso);
comando.Parameters.AddWithValue("@IdProducto", pDetalleIngreso.IdProducto);
comando.Parameters.AddWithValue("@Cantidad", pDetalleIngreso.Cantidad);
comando.Parameters.AddWithValue("@PrecioUnitario", (decimal)pDetalleIngreso.PrecioUnitario);
return(ComunDB.EjecutarComando(comando));
}
public async Task <IActionResult> Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest((ModelState)));
}
var fechaHora = DateTime.Now;
Ingreso ingreso = new Ingreso
{
idproveedor = model.idproveedor,
idusuario = model.idusuario,
tipo_comprobante = model.tipo_comprobante,
serie_comprobante = model.serie_comprobante,
num_comprobante = model.num_comprobante,
fecha_hora = fechaHora,
impuesto = model.impuesto,
total = model.total,
estado = "Aceptado"
};
try
{
_context.Ingresos.Add(ingreso);
await _context.SaveChangesAsync();
var id = ingreso.idingreso;
foreach (var det in model.detalles)
{
DetalleIngreso detalle = new DetalleIngreso
{
idingreso = id,
idarticulo = det.idarticulo,
cantidad = det.cantidad,
precio = det.precio
};
_context.DetallesIngresos.Add(detalle);
}
await _context.SaveChangesAsync();
}
catch (Exception e)
{
Console.WriteLine(e);
return(BadRequest());
}
return(Ok());
}
public ActionResult DeleteDetalleIngreso(Int32 DetalleIngresoId, Int32 IngresoId, Int32 EdificioId)
{
try
{
DetalleIngreso _detalleingreso = context.DetalleIngreso.FirstOrDefault(x => x.DetalleIngresoId == DetalleIngresoId);
_detalleingreso.Estado = ConstantHelpers.EstadoInactivo;
context.Entry(_detalleingreso).State = System.Data.Entity.EntityState.Modified;
context.DetalleIngreso.Remove(_detalleingreso);
context.SaveChanges();
PostMessage(MessageType.Success);
}
catch { }
return(RedirectToAction("LstDetalleIngresoAdmin", new { IngresoId = IngresoId, EdificioId = EdificioId }));
}
private List <DetalleIngreso> ConstruirListaDetalleIngresos()
{
List <DetalleIngreso> listaDetalle = new List <DetalleIngreso>();
int contadorFilas = -1;
foreach (var p in lista)
{
contadorFilas++;
DetalleIngreso detalleIngreso = new DetalleIngreso();
detalleIngreso.Producto = p;
detalleIngreso.Cantidad = (decimal)(double)dgvDatos.Rows[contadorFilas].Cells[2].Value;
listaDetalle.Add(detalleIngreso);
}
return(listaDetalle);
}
public async Task <ActionResult <Ingreso> > Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid) // si los data anotation no se cumplen esto valida que se cumplan sino el request sera detenido
{
return(BadRequest(ModelState));
}
var fechaHora = DateTime.Now;
Ingreso ingreso = new Ingreso
{
idproveedor = model.idproveedor,
idusuario = model.idusuario,
tipo_comprobante = model.tipo_comprobante,
serie_comprobante = model.serie_comprobante,
num_comprobante = model.num_comprobante,
fecha_hora = fechaHora,
impuesto = model.impuesto,
total = model.total,
estado = "Aceptado"
};
try
{
_context.Ingresos.Add(ingreso);
await _context.SaveChangesAsync();
var id = ingreso.idingreso;
foreach (var det in model.detalles)
{
DetalleIngreso detalle = new DetalleIngreso
{
idingreso = id,
idarticulo = det.idarticulo,
cantidad = det.cantidad,
precio = det.precio
};
_context.DetalleIngresos.Add(detalle);
}
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok());
}
public void Guardar(DetalleIngreso detalle)
{
try
{
var cadenaDeComando = "INSERT INTO DetalleIngresos (IngresoId,ProductoId,Cantidad,KardexId)" +
"VALUES (@ingreso,@producto,@cantidad,@kardex)";
var comando = new SqlCommand(cadenaDeComando, conexion, transaction);
comando.Parameters.AddWithValue("@ingreso", detalle.Ingreso.IngresoId);
comando.Parameters.AddWithValue("@producto", detalle.Producto.ProductoId);
comando.Parameters.AddWithValue("@cantidad", detalle.Cantidad);
comando.Parameters.AddWithValue("@kardex", detalle.Kardex.KardexId);
comando.ExecuteNonQuery();
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public void Guardar(DetalleIngreso detalleIngreso)
{
try
{
string cadenaComando = "INSERT INTO DetalleIngresos (IngresoId, ProductoId, Cantidad, KardexId) " +
"VALUES (@ingreso, @prod, @cant, @kardex)";
var comando = new SqlCommand(cadenaComando, _sqlConnection, _sqlTransactiontran);
comando.Parameters.AddWithValue("@ingreso", detalleIngreso.Ingreso.IngresoId);
comando.Parameters.AddWithValue("@prod", detalleIngreso.Producto.ProductoId);
comando.Parameters.AddWithValue("@cant", detalleIngreso.Cantidad);
comando.Parameters.AddWithValue("@kardex", detalleIngreso.Kardex.KardexId);
comando.ExecuteNonQuery();
}
catch (Exception e)
{
throw new Exception("Error al intentar guardar un detalle de ingreso");
}
}
private List <DetalleIngreso> ConstruirListaDetalleIngresos()
{
List <DetalleIngreso> lista = new List <DetalleIngreso>();
int contadorFilas = -1;
foreach (var producto in _listaProducto)
{
contadorFilas++;
DetalleIngreso detalle = new DetalleIngreso
{
Producto = producto,
Cantidad = (decimal)(double)StockInProductosDataGridView.Rows[contadorFilas].Cells[2].Value
};
lista.Add(detalle);
}
return(lista);
}
private void GuardaDetalleprod()
{
var Idbodega = Convert.ToInt32(comboBox4.SelectedValue);
var detingre = new DetalleIngreso()
{
IdBodega = Idbodega,
IdProducto = int.Parse(txtidprod.Text),
IdIngreso = int.Parse(txtid.Text),
Precio_Compra = Convert.ToInt32(txtpreciocompra.Text),
Stock_Actual = int.Parse(txtactual.Text),
Stock_Inicial = int.Parse(txtinicial.Text),
Fecha_Caducidad = Convert.ToDateTime(txtfechacaducidad.Text),
Fecha_Ingreso = textBox1.Text
};
AgregarDetalle(detingre);
}
public ActionResult EliminaDetalleIngreso(Int64 idDetalleIngreso, Int64 folioIngreso, string idUsuario)
{
string mensaje = "";
if (idDetalleIngreso == 0 || folioIngreso == 0 || idUsuario == "")
{
if (idDetalleIngreso == 0)
{
mensaje = "SELECCIONE ACCION GESTIÓN";
}
if (folioIngreso == 0)
{
mensaje = "SELECCIONE RESULTADO";
}
if (idUsuario == "")
{
mensaje = "ERROR EN IDENTIFICADOR DE HABILITADO";
}
}
else
{
try
{
DetalleIngreso objDetalleIngreso = new DetalleIngreso(idDetalleIngreso, folioIngreso, idUsuario);
//objDetalleIngresoNeg.EliminaDetalleIngreso(objDetalleIngreso);
string resultado = objDetalleIngresoNeg.EliminaDetalleIngreso(objDetalleIngreso);
//resultado = objIngresoNeg.Resultado.ToString();
if (resultado == "1" || resultado == null)
{
mensaje = "ERROR AL REGISTRAR EL PAGO";
}
else
{
mensaje = "0";
}
}
catch (Exception)
{
mensaje = "ERROR, REVISAR DATOS INGRESADOS";
}
}
return(Json(mensaje));
}
public ActionResult NuevoIngreso(Int64 folio)
{
var datosEncabezadoIngreso = new Ingreso();
var datosDetalleIngreso = new DetalleIngreso();
Ingreso objIngreso = new Ingreso();
//DetalleIngreso objDetalleIngreso = new DetalleIngreso();
if (folio.Equals(0))
{
objIngresoNeg.GenerarFolioIngreso(objIngreso);
datosEncabezadoIngreso = objIngreso;
}
else
{
Ingreso objEncabezadoIngreso = new Ingreso(folio);
objIngresoNeg.TraeEncabezadoIngreso(objEncabezadoIngreso);
datosEncabezadoIngreso = objEncabezadoIngreso;
}
DetalleIngreso objDetalleIngreso = new DetalleIngreso(folio);
List <DetalleIngreso> ListaDetalleIngreso = objDetalleIngresoNeg.TraeDetalleIngreso(objDetalleIngreso);
//SelectList ListaHistoricoGestion = new SelectList(dataHistoricoGestion, "idResultadoGestion", "nombreResultadoGestion");
ViewBag.ListaDetalleIngresos = ListaDetalleIngreso;
List <Unidad> dataUnidad = objUnidadNeg.GetUnidad();
SelectList ListaUnidad = new SelectList(dataUnidad, "idUnidad", "nombreUnidad");
ViewBag.ListaUnidades = ListaUnidad;
List <Evento> dataEvento = objEventoNeg.GetEvento();
SelectList ListaEvento = new SelectList(dataEvento, "idEvento", "nombreEvento");
ViewBag.ListaEventos = ListaEvento;
List <FormaPago> dataFormaPago = objFormaPagoNeg.GetFormaPago();
SelectList ListaFormaPago = new SelectList(dataFormaPago, "idFormaPago", "nombreFormaPago");
ViewBag.ListaFormaPagos = ListaFormaPago;
return(View(Tuple.Create(datosEncabezadoIngreso)));//(Tuple.Create(datosHabilitado, datosGestion, datosTipoGestion, datosHistoricoGestion));
}
public List <DetalleIngreso> TraeDetalleIngreso(DetalleIngreso objDetalleIngresos)
{
List <DetalleIngreso> listaDetalleIngreso = new List <DetalleIngreso>();
//Ingreso objDetalleIngreso = new Ingreso();
string find = "EXECUTE TraeDetalleIngreso " + objDetalleIngresos.FolioIngreso;
try
{
comando = new SqlCommand(find, objConexionDB.getCon());
objConexionDB.getCon().Open();
reader = comando.ExecuteReader();
while (reader.Read())
{
DetalleIngreso objDetalleIngreso = new DetalleIngreso();
objDetalleIngreso.IdDetalleIngreso = Convert.ToInt64(reader[0].ToString());
objDetalleIngreso.FolioIngreso = Convert.ToInt64(reader[1].ToString());
objDetalleIngreso.RutMiembro = (reader[2].ToString());
objDetalleIngreso.NombreCompletoMiembro = (reader[3].ToString());
objDetalleIngreso.IdUnidad = Convert.ToInt64(reader[4].ToString());
objDetalleIngreso.NombreUnidad = (reader[5].ToString());
objDetalleIngreso.IdEvento = Convert.ToInt64(reader[6].ToString());
objDetalleIngreso.NombreEvento = (reader[7].ToString());
objDetalleIngreso.ObservacionesIngreso = (reader[8].ToString());
objDetalleIngreso.MontoIngreso = Convert.ToInt64(reader[9].ToString());
listaDetalleIngreso.Add(objDetalleIngreso);
}
}
catch (Exception)
{
throw;
}
finally
{
objConexionDB.getCon().Close();
objConexionDB.closeDB();
}
return(listaDetalleIngreso);
}
private void GuardaDetalleprod()
{
int nombog = 0;
//validar combobox de acuerdo a la bodega
if (comboBox3.Text == "Express Home")
{
nombog = 11;
}
if (comboBox3.Text == "Super Casa")
{
nombog = 12;
}
if (comboBox3.Text == "Super Ecomax")
{
nombog = 13;
}
if (comboBox3.Text == "Todo en Casa")
{
nombog = 14;
}
if (comboBox3.Text == "Rapishop")
{
nombog = 15;
}
var detingre = new DetalleIngreso()
{
IdBodega = nombog,
IdProducto = int.Parse(textBox6.Text),
IdIngreso = int.Parse(textBox1.Text),
Precio_Compra = Convert.ToInt32(textBox5.Text),
Stock_Actual = int.Parse(textBox4.Text),
Stock_Inicial = int.Parse(textBox3.Text),
Fecha_Caducidad = Convert.ToDateTime(textBox2.Text),
Fecha_Ingreso = textBox8.Text
};
AgregarDetalle(detingre);
}
public void Fill(CargarDatosContext datacontext)
{
baseFill(datacontext);
Edificio = datacontext.context.Edificio.FirstOrDefault(x => x.EdificioId == EdificioId);
DescripcionUnidadMedida = datacontext.context.Ingreso.FirstOrDefault(x => x.IngresoId == IngresoId).UnidadTiempo.Descripcion.ToUpper();
if (DetalleIngresoId.HasValue)
{
DetalleIngreso detalleingreso = datacontext.context.DetalleIngreso.FirstOrDefault(x => x.DetalleIngresoId == DetalleIngresoId.Value);
if (detalleingreso != null)
{
this.Concepto = detalleingreso.Concepto;
this.DetalleIngresoId = detalleingreso.DetalleIngresoId;
this.Monto = detalleingreso.Monto;
this.Estado = detalleingreso.Estado;
this.IngresoId = detalleingreso.IngresoId;
this.Pagado = detalleingreso.Pagado;
}
}
else
{
this.Pagado = true;
}
}