public async Task <ActionResult <Movimientos> > PostMovimientos(Movimientos movimientos)
{
_context.Movimientos.Add(movimientos);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMovimientos", new { id = movimientos.Id }, movimientos));
}
public ActionResult Operaciones(int id)
{
Movimientos movimiento = new Movimientos();
movimiento.cue_id = id;
IEnumerable <Cuenta> cuenta = null;
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(url);
var ResponseTask = client.GetAsync("CuentaAhorro/" + id.ToString());
ResponseTask.Wait();
var result = ResponseTask.Result;
if (result.IsSuccessStatusCode)
{
var readJob = result.Content.ReadAsAsync <IList <Cuenta> >();
readJob.Wait();
cuenta = readJob.Result;
}
else
{
cuenta = Enumerable.Empty <Cuenta>();
ModelState.AddModelError(string.Empty, "Error al consumir");
return(View("Index"));
}
}
movimiento.cli_id = cuenta.FirstOrDefault().cli_id;
return(View(movimiento));
}
public async Task <ActionResult <Movimientos> > SalidaParcial(int columna, int nivel, Movimientos mvt)
{
Movimientos salida = new Movimientos();
salida.Columna = columna;
salida.Nivel = nivel;
salida.UsuariosId = mvt.UsuariosId;
//Movimientos actual = await _context.Movimientos.FindAsync(Id);
Object[] rs = _bodega4.salidaParcial(salida, (int)mvt.Paquetes.Bultos);
if (rs[0] is string)
{
return(NotFound(rs));
}
else
{
Movimientos mSalida = (Movimientos)rs[0];
Movimientos mEntrada = (Movimientos)rs[1];
_context.Movimientos.Add(mSalida);
_context.Paquetes.Add(mEntrada.Paquetes);
_context.Movimientos.Add(mEntrada);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMovimientos", "Movimientos", new { id = mSalida.Id }, salida));
}
}
public async Task <ActionResult <Movimientos> > DeleteMultiple(dataSalidaMultiple data)
{
Movimientos salida = new Movimientos();
salida.Columna = data.columna;
salida.Nivel = data.nivel;
Object rs = _bodega4.salidaMultiple(salida, data.cantidad);
if (rs is string)
{
return(StatusCode(400, rs));
}
else
{
List <Movimientos> lista = (List <Movimientos>)rs;
lista.ForEach(async salida =>
{
salida.UsuariosId = data.UsuariosId;
await _context.Movimientos.AddAsync(salida);
});
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMovimientos", "Movimientos", new { id = 0 }, lista));
}
}
public ActionResult Create([Bind(Include = "IdMovimiento,IdCuenta,Fecha,ValorRetiro,ValorGmf,SaldoMov,CuentaDestino,TipoTransaccion")] Movimientos movimientos)
{
string connectionString = GetConnectionString();
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
SqlCommand cmd = connection.CreateCommand();
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "calculoSaldo";
cmd.Parameters.Add("@IdCta", System.Data.SqlDbType.Int).Value = movimientos.IdCuenta;
cmd.Parameters.Add("@valorRetiro", System.Data.SqlDbType.Decimal).Value = movimientos.ValorRetiro;
cmd.Parameters.Add("@cuentaDestino", System.Data.SqlDbType.VarChar, 50).Value = movimientos.CuentaDestino + "_sp";
cmd.Parameters.Add("@tipoTransaccion", System.Data.SqlDbType.VarChar, 1).Value = movimientos.TipoTransaccion;
cmd.ExecuteNonQuery();
connection.Close();
}
Movimientos movimientos1 = db.Movimientos.Find(movimientos.IdCuenta);
// if (ModelState.IsValid)
//{
//db.Movimientos.Add(movimientos);
//db.SaveChanges();
ViewBag.IdCuenta = new SelectList(db.Cuentas, "IdCuenta", "NombreCta", movimientos.IdCuenta);
return(RedirectToAction("Index"));
//}
//Movimientos movimientos1 = db.Movimientos.Find(movimientos.IdCuenta);
//if (movimientos1 == null)
//{
// return HttpNotFound();
//}
//return View(movimientos1);
}
protected void LBConsultar_Click(object sender, EventArgs e)
{
if (HttpContext.Current.Session["Tarjeta"] == null)
{
Page.Response.Redirect("~/LogIn.aspx", false);
return;
}
ActivarConsulta(true);
MultiView1.SetActiveView(ViewConsultar);
if (HttpContext.Current.Session["TablaMovimientos"] == null)
{
Estructuras.Tarjeta Tarjeta1 = (Estructuras.Tarjeta)HttpContext.Current.Session["Tarjeta"];
Tarjeta1.TipoConsulta = Constantes.TipoConsulta.Masiva;
Estructuras.Movimientos Movimiento1 = new Estructuras.Movimientos {
IdEstaActivo = true
};
DateTime FechaInicio = DateTime.Parse("01/01/1900"), FechaFin = new DateTime(2099, 1, 1, 23, 59, 59);
using (Movimientos ObjMovimientos = new Movimientos()) ObjMovimientos.ConsultarCatalogoMovimientos(ref Tarjeta1, ref Movimiento1, FechaInicio, FechaFin, true, true);
HttpContext.Current.Session["TablaMovimientos"] = Tarjeta1.TablaConsulta;
HttpContext.Current.Session["ConteoMovimientos"] = Tarjeta1.TablaConsulta?.Rows.Count.ToString();
GVMovimientos.DataSource = Tarjeta1.TablaConsulta;
GVMovimientos.DataBind();
}
else
{
DataTable Tabla = (DataTable)HttpContext.Current.Session["TablaMovimientos"];
HttpContext.Current.Session["ConteoMovimientos"] = Tabla?.Rows.Count.ToString();
GVMovimientos.DataSource = Tabla;
GVMovimientos.DataBind();
}
}
private void BtnDelete_Click(object sender, EventArgs e)
{
DialogResult dialogResult = MessageBox.Show("Va a eliminar datos de manera permanente. " +
"¿Está seguro que quieres eliminarlos permanentemente?",
"ADVERTENCIA", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
if (dialogResult == DialogResult.Yes)
{
if (RbPeriodo.Checked)
{
FechaDesde = DtDesde.Value;
FechaHasta = DtHasta.Value;
_movimientos = _negMovimientos.DeletePeriodo(FechaDesde, FechaHasta, _movimientos);
}
else
{
if (vacio)
{
_movimientos = _negMovimientos.DeleteAll(accion, _movimientos);
}
else
{
MessageBox.Show("No se ha seleccionado ningún item. Seleccione lo que quiera borrar.", "Seleccionar dato a borrar", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
MostrarSaldos();
vacio = false;
ActualizacionDeSaldos();
}
}
/// <summary>
/// Metodo que recibe como parametro la fecha, y segun lo indicado vacia los datos en una tabla.
/// </summary>
/// <param name="Mov"></param>
/// <param name="Mes"></param>
/// <param name="Año"></param>
/// <param name="Tabla"></param>
public static void Obtener_Mov_Fecha(string Mov, string Mes, string Año, ListView Tabla)
{
EMovimientos.Movimiento = Mov;
EMovimientos.Mes = Mes;
EMovimientos.Año = Año;
Movimientos.Obtener_Mov_Fecha(Tabla);
}
private void LlenarObjetoMovimientos(ref Movimientos mov)
{
try
{
mov.Id_TAc = int.Parse(this.HdId_TAc.Value);
mov.Id_Tm = int.Parse(this.TxtId_TmAc.Text);
mov.TAc_Cuenta = this.TxtTAc_Cuenta.Text;
mov.TAc_Subcuenta = this.TxtAc_Subcuenta.Text;
mov.TAc_Subsubcuenta = this.TxtAc_Subsubcuenta.Text;
mov.TAc_CuentaA = this.TxtTAc_CuentaA.Text;
mov.TAc_SubcuentaA = this.TxtAc_SubcuentaA.Text;
mov.TAc_SubsubcuentaA = this.TxtAc_SubsubcuentaA.Text;
mov.TAc_CuentaB = this.TxtTAc_CuentaB.Text;
mov.TAc_SubcuentaB = this.TxtTAc_SubCuentaB.Text;
mov.TAc_SubsubcuentaB = this.TxtTAc_SubsubCuentaB.Text;
mov.TAc_CC = this.ChckApCC.Checked;
mov.TAc_Naturaleza = Convert.ToBoolean(int.Parse(this.CmbAc_Naturaleza.SelectedValue));
if (this.RbtnTAc_NatMov0.Checked == false)
{
mov.TAc_NatMov = true;
}
else
{
mov.TAc_NatMov = false;
}
}
catch (Exception ex)
{
throw ex;
}
}
public void CrearMovimiento(Movimientos Movimiento)
{
SqlConnection conString = new SqlConnection(@"Data Source=DESKTOP-6DRGPE6;Initial Catalog=ParcialSAP;Integrated Security=True");
try
{
conString.Open();
SqlTransaction transaction;
transaction = conString.BeginTransaction();
SqlCommand command = new SqlCommand();
command.Connection = conString;
command.Parameters.AddWithValue("Saldo", Movimiento.Saldo);
command.Parameters.AddWithValue("CuentaBancariaDestino", Movimiento.CuentaBancariaDestino);
command.Parameters.AddWithValue("CuentaBancariaOrigen", Movimiento.CuentaBancariaOrigen);
command.Parameters.AddWithValue("Tipo", Movimiento.Tipo);
command.CommandText = "insert into Movimientos (Saldo, CuentaBancariaDestino, CuentaBancariaOrigen, Tipo) values (@Saldo, @CuentaBancariaDestino, @CuentaBancariaOrigen, @Tipo)";
command.CommandType = System.Data.CommandType.Text;
command.Transaction = transaction;
command.ExecuteNonQuery();
transaction.Commit();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
conString.Close();
}
}
/// <summary>
/// Metodo que registra los movimientos segun los parametros rebidos de la interfaz.
/// </summary>
/// <param name="Mov"></param>
/// <param name="Cod"></param>
/// <param name="Mat"></param>
/// <param name="Doc"></param>
/// <param name="Des"></param>
/// <param name="Can"></param>
/// <param name="Fe"></param>
/// <param name="Usu"></param>
/// <param name="Mes"></param>
/// <param name="Año"></param>
public static void Registrar_Movimiento(string Mov, string Cod, string Mat, string Doc, string Des, string Can, string Fe, string Usu, string Mes, string Año)
{
if (Des == "")
{
EMensaje.Informacion("Indique el texto breve", "Informacion");
}
if (Can == "")
{
EMensaje.Informacion("Indique la cantidad", "Informacion");
}
{
EMovimientos.Movimiento = Mov;
EMovimientos.Codigo = Cod;
EMovimientos.Material = Mat;
EMovimientos.Documento = Doc;
EMovimientos.Descripcion = Des;
EMovimientos.Cantidad = Can;
EMovimientos.Fecha = Fe;
EMovimientos.Usuario = Usu;
EMovimientos.Mes = Mes;
EMovimientos.Año = Año;
Movimientos.Registrar_Movimiento();
EMensaje.Informacion("Proceso Completado", "Informacion");
}
}
public virtual void Agregar(Movimiento movimiento)
{
movimiento.NoEsNull(nameof(movimiento));
movimiento.Almacen = this;
Movimientos.Agregar(movimiento);
}
private DataTable ObtenerSucursalRegistrosProcesados(DataTable poMovimientos)
{
Movimientos loSucursal = new Movimientos();
DataTable loResultadoSinSucursal = poMovimientos.Clone();
for (int lnFila = 0; lnFila < poMovimientos.Rows.Count; lnFila++)
{
DataTable loResultado = loSucursal.ObtenerSucursalBanamex(((InicioSesion)this.MdiParent.Owner).Sesion, poMovimientos.Rows[lnFila]["Ref_Numerica"].ToString());
if (loResultado.Rows.Count > 0)
{
poMovimientos.Rows[lnFila]["Cliente"] = loResultado.Rows[0][0].ToString();
poMovimientos.Rows[lnFila]["Suc_Clave"] = loResultado.Rows[0][2].ToString();
poMovimientos.Rows[lnFila]["Sucursal"] = loResultado.Rows[0][3].ToString();
}
}
int lnLugar = 1;
foreach (DataRow loFila in poMovimientos.Rows)
{
loFila["#"] = lnLugar++;
}
return(obtenerFormaDePago(poMovimientos));
}
public async Task <IActionResult> PutMovimientos(int id, Movimientos movimientos)
{
if (id != movimientos.Id)
{
return(BadRequest());
}
_context.Entry(movimientos).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovimientosExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public List <Movimientos> ListarMovimientos()
{
SqlConnection conString = new SqlConnection(@"Data Source=DESKTOP-6DRGPE6;Initial Catalog=ParcialSAP;Integrated Security=True");
List <Movimientos> Movimiento = new List <Movimientos>();
try
{
conString.Open();
SqlCommand command = new SqlCommand();
command.Connection = conString;
command.CommandText = "select * from Movimientos";
command.CommandType = System.Data.CommandType.Text;
var reader = command.ExecuteReader();
while (reader.Read())
{
Movimientos c = new Movimientos();
c.CuentaBancariaDestino = Int32.Parse(reader["CuentaBancariaDestino"].ToString());
c.CuentaBancariaOrigen = Int32.Parse(reader["CuentaBancariaOrigen"].ToString());
c.Saldo = float.Parse(reader["Saldo"].ToString());
c.Tipo = string.Format(reader["Tipo"].ToString());
Movimiento.Add(c);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
conString.Close();
}
return(Movimiento);
}
public FormMovimientos()
{
InitializeComponent();
_objMovimientos = new Movimientos();
_objNegMovimientos = new NegMovimientos();
EnlistadoDTGV();
}
protected void gvMovimientos_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName.Equals("AGREGAR"))
{
Movimientos m = new Movimientos();
int idActo = int.Parse(ddlActos.SelectedValue.ToString());
TextBox txtNombreMov = (TextBox)gvMovimientos.FooterRow.FindControl("txNombreMovimiento");
DropDownList ddlTipo = (DropDownList)gvMovimientos.FooterRow.FindControl("ddlEditTiposF");
String Resultado = m.GuardarNuevo(idActo, txtNombreMov.Text.ToUpper(), int.Parse(ddlTipo.SelectedValue));
gvMovimientos.DataSource = main.Movimientos.Catalogo(idActo);
gvMovimientos.DataBind();
if (gvMovimientos.Rows.Count == 0)
{
gvMovimientos.DataSource = new[]
{
new{
Clave = string.Empty,
Nombre = string.Empty,
Folio = string.Empty,
//mas cosas
}
};
gvMovimientos.DataBind();
}
if (Resultado.Equals("OK"))
{
ScriptManager.RegisterClientScriptBlock(this, this.GetType(), "alertMessage", "alert('Datos agregados Correctamente')", true);
}
}
}
public int SaveMovement(Movimientos movimientos)
{
SaldosEstablecidos saldosEstablecidos = new SaldosEstablecidos();
int resultado = -1;
string orden = @"Insert into Movimientos (Importe,
TipoMovimiento,
FechaRealizada,
NumCuotaPaga,
CantCuotas,
Observaciones,
PagoFinalizado,
SeId
)
values (@Importe,
@TipoMovimiento,
@FechaRealizada,
@NumCuotaPaga,
@CantCuotas,
@Observaciones,
@PagoFinalizado,
@SeId)"
;
SqlParameter seId = new SqlParameter("@SeId", movimientos.SeId);
SqlParameter importe = new SqlParameter("@Importe", movimientos.Importe);
SqlParameter tipoMovimiento = new SqlParameter("@TipoMovimiento", movimientos.TipoMovimiento);
SqlParameter fechaRealizada = new SqlParameter("@FechaRealizada", movimientos.FechaRealizada);
SqlParameter numCuotaPaga = new SqlParameter("@NumCuotaPaga", movimientos.NumCuotaPaga);
SqlParameter cantCuotas = new SqlParameter("@CantCuotas", movimientos.CantCuotas);
SqlParameter observaciones = new SqlParameter("@Observaciones", movimientos.Observaciones);
SqlParameter pagoFinalizado = new SqlParameter("@PagoFinalizado", movimientos.PagoFinalizado);
SqlCommand cmd = new SqlCommand(orden, conexion);
cmd.Parameters.Add(seId);
cmd.Parameters.Add(importe);
cmd.Parameters.Add(tipoMovimiento);
cmd.Parameters.Add(fechaRealizada);
cmd.Parameters.Add(numCuotaPaga);
cmd.Parameters.Add(cantCuotas);
cmd.Parameters.Add(observaciones);
cmd.Parameters.Add(pagoFinalizado);
try
{
Abrirconexion();
resultado = cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw new Exception("Error al tratar de guardar Movimientos", e);
}
finally
{
Cerrarconexion();
cmd.Dispose();
}
return(resultado);
}
public void GetSaldoActual()
{
_objMovimientos = _objNegMovimientos.ConsultarSaldo(_objMovimientos);
GetSaldos();
SaldoActual = _objMovimientos.SaldoActual - _objSaldosEstablecidos.GastoPermitido;
PermitidoActual = _objMovimientos.GastoPermitido;
}
public ActionResult DeleteConfirmed(int id)
{
Movimientos movimientos = db.Movimientos.Find(id);
db.Movimientos.Remove(movimientos);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Metodo que registra los movimientos total segun el movimiento que reciba, el codigo y la cantidad.
/// </summary>
/// <param name="Procedimiento"></param>
/// <param name="pCodigo"></param>
/// <param name="pCantidad"></param>
public static void Registrar_Mov_Total(string Procedimiento, string pCodigo, string pCantidad)
{
EMovimientos.Codigo = pCodigo;
EMovimientos.Movimiento = pCantidad;
Movimientos.Registrar_Mov_Total(Procedimiento);
Movimientos.Actualizar_Mov_Total();
Inventario.Actualizar_Inventario_Total();
}
public MovimientoPlantilla(Movimientos movimientos)
{
Documentoid = movimientos.Documentoid;
NumeroMovimiento = movimientos.NumeroMovimiento;
CodAlmacen = movimientos.CodAlmacen;
CodProducto = movimientos.CodProducto;
Precio = movimientos.Precio;
Unidades = movimientos.Unidades;
}
public virtual void Consignar(double valor)
{
MovimientoFinanciero movimiento = new MovimientoFinanciero();
movimiento.ValorConsignacion = valor;
movimiento.FechaMovimiento = DateTime.Now;
Saldo += valor;
Movimientos.Add(movimiento);
}
public void Consignar(double valor)
{
MovimientoFinanciero consignacion = new MovimientoFinanciero();
consignacion.ValorConsignacion = valor;
consignacion.FechaMovimiento = DateTime.Now;
Saldo -= valor;
Movimientos.Add(consignacion);
}
public void ConsultaListMovApContable(ref List <Movimientos> List, bool Tm_NatMov, Sesion sesion)
{
try
{
CD_Datos cd_datos = new CD_Datos(sesion.Emp_Cnx);
SqlDataReader dr = null;
String[] Parametros = { "@Tm_NatMov" };
Object[] Valores = { Tm_NatMov };
SqlCommand sqlcmd = cd_datos.GenerarSqlCommand("spCatTMovimiento_ApContableConsultar", ref dr, Parametros, Valores);
Movimientos m;
while (dr.Read())
{
m = new Movimientos();
m.Id_TAc = Convert.ToInt32(dr["Id_TAc"]);
m.Id_Tm = Convert.ToInt32(dr["Id_Tm"]);
m.Nombre = dr["Tm_Nombre"].ToString();
m.TAc_CuentaStr = dr["TAc_Cuenta"].ToString();
m.TAc_SubcuentaStr = dr["TAc_Subcuenta"].ToString();
m.TAc_Subsubcuenta = dr["TAc_Subsubcuenta"].ToString();
if (dr["TAc_Naturaleza"].ToString() == "0")
{
m.TAc_Naturalezastr = "Cargo";
}
else if (dr["TAc_Naturaleza"].ToString() == "1")
{
m.TAc_Naturalezastr = "Crédito";
}
else
{
m.TAc_Naturalezastr = string.Empty;
}
if (dr["Tm_Naturaleza"].ToString() == "0")
{
m.TAc_TipoStr = "Entrada";
}
else if (dr["Tm_Naturaleza"].ToString() == "1")
{
m.TAc_TipoStr = "Salida";
}
List.Add(m);
}
dr.Close();
cd_datos.LimpiarSqlcommand(ref sqlcmd);
}
catch (Exception ex)
{
throw ex;
}
}
protected void CrearMovimientoDeIngreso(double valor)
{
MovimientoFinanciero movimiento = new MovimientoFinanciero();
movimiento.ValorConsignacion = valor;
movimiento.FechaMovimiento = DateTime.Now;
Saldo += valor;
Movimientos.Add(movimiento);
}
private Movimientos MapearMovimiento()
{
movimientos = new Movimientos();
movimientos.Motivo = cmboMotivo.Text;
movimientos.Codigo = txtCodigo.Text;
movimientos.Cantidad = int.Parse(txtCantidad.Text);
movimientos.Fecha = DateTime.Parse(LbelFecha.Text);
movimientos.Descripcion = txtObservacion.Text;
return(movimientos);
}
public ActionResult Edit([Bind(Include = "id,IdCuenta,Fecha,ValorRetiro,ValorGmf,SaldoMov,CuentaDestino")] Movimientos movimientos)
{
if (ModelState.IsValid)
{
db.Entry(movimientos).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(movimientos));
}
private void RegistroMoviento(decimal valor, string tipo)
{
Movimiento movimiento = new Movimiento();
movimiento.Fecha = DateTime.Now;
movimiento.Tipo = tipo;
movimiento.Saldo = Saldo;
movimiento.Valor = valor;
Movimientos.Add(movimiento);
}
public void ConsultarMovsNotaCredito(Movimientos mov, ref List <Movimientos> listaMovimientos, string Conexion)
{
try
{
new CD_CapNotaCredito().ConsultarMovsNotaCredito(mov, ref listaMovimientos, Conexion);
}
catch (Exception ex)
{
throw ex;
}
}
public void Mover(Movimientos mov)
{
switch (mov)
{
case Movimientos.Izquierda:
break;
case Movimientos.Arriba:
break;
case Movimientos.Derecha:
break;
case Movimientos.Abajo:
break;
default:
throw new ArgumentOutOfRangeException("mov");
}
}
