public void Actualizar(ArticuloXLocal articuloXLocal)
{
new ArticuloXLocalDA().SaveOrUpdate(articuloXLocal);
if (articuloXLocal.Cantidad < 0)
{
Movimiento mov = new Movimiento();
mov.Fecha = DateTime.Today;
mov.Local = articuloXLocal.Local;
new MovimientoBL().Grabar(mov);
Incidencia incidencia = new Incidencia();
incidencia.NroMovimiento = mov;
incidencia.DescripcionAdicional = articuloXLocal.Id.ToString() + articuloXLocal.Cantidad.ToString() +" FUERA DE RANGO DE STOCK";
incidencia.Estado = "Creada";
incidencia.Fecha = DateTime.Today;
incidencia.Local = articuloXLocal.Local;
incidencia.TipoIncidencia = "Ajuste";
new IncidenciaBL().Grabar(incidencia);
IncidenciaLinea linea = new IncidenciaLinea();
linea.Cantidad = 1;
linea.NroIncidencia = incidencia;
new IncidenciaLineaBL().Grabar(linea);
}
}
void instancear()
{
if(PhotonNetwork.room.playerCount <=1)
{
//instancear jugador
PhotonNetwork.Instantiate(this.playerPrefab1.name, new Vector3(7.785223f, 0.5f, -7.0f), Quaternion.identity, 0);
PhotonNetwork.InstantiateSceneObject("Terreno",new Vector3(0,0,0), Quaternion.identity, 0, null);
Debug.Log("isntanceo primero");
}
else
{
PhotonNetwork.Instantiate(this.playerPrefab2.name, new Vector3(-7.88836f, 0.5f, -7.247649f), Quaternion.identity, 0);
Debug.Log("isntanceo segundo");
mo = playerPrefab1.GetComponent<Movimiento>();
mo.enabled = false;
}
}
public IHttpActionResult CierreTbk()
{
Movimiento movimiento = null;
string msg = string.Empty;
movimiento = new Movimiento();
msg = movimiento.ValidarTbk(ServicioPago.Comandos.CierreTbk, oConfig.IdKiosko);
PipeService pipe = new PipeService();
var algo = msg.Split('~');
var respuesta = pipe.ComponentPipePrintVoutcher("", algo[2]);
Log.Write("Usabilidad", msg, Evento.Response, ServicioPago.Comandos.PagoTbk);
return(Ok(new ApiResponse()
{
Code = 0, Message = "OK".ToString()
}));
}
public List <Movimiento> ListarMovimientoTarjeta(int IdTarjeta)
{
List <Movimiento> lstMovimiento = new List <Movimiento>();
using (SqlConnection sqlCn = new SqlConnection(Conexion.cnMetroCard))
{
sqlCn.Open();
using (SqlCommand sqlCmd = new SqlCommand("Movimiento_Listar", sqlCn))
{
sqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
sqlCmd.Parameters.Add("@IdTarjeta", SqlDbType.Int).Value = IdTarjeta;
SqlDataReader sqlDr = sqlCmd.ExecuteReader(CommandBehavior.SingleResult);
if (sqlDr != null)
{
if (sqlDr.HasRows)
{
Movimiento objMovimiento;
while (sqlDr.Read())
{
objMovimiento = new Movimiento();
objMovimiento.IdTarjeta = sqlDr.GetInt32(sqlDr.GetOrdinal("IdTarjeta"));
objMovimiento.NroTarjeta = sqlDr.GetString(sqlDr.GetOrdinal("NroTarjeta"));
objMovimiento.Saldo = sqlDr.GetDecimal(sqlDr.GetOrdinal("Saldo"));
objMovimiento.FechaSaldo = sqlDr.GetDateTime(sqlDr.GetOrdinal("FechaSaldo"));
objMovimiento.SaldoAnterior = sqlDr.GetDecimal(sqlDr.GetOrdinal("SaldoAnterior"));
objMovimiento.FechaMovimiento = sqlDr.GetDateTime(sqlDr.GetOrdinal("FechaSaldoAnterior"));
lstMovimiento.Add(objMovimiento);
}
sqlDr.Close();
}
}
}
}
return(lstMovimiento);
}
public void ActualizarParaCierreFacuracion(Movimiento movimiento)
{
_servicioRepositorio.Update(new Servicio
{
Id = movimiento.Servicio.Id,
Radicado = movimiento.Servicio.Radicado,
AseguradoraId = movimiento.Servicio.Aseguradora.Id
}, s => s.Radicado, s => s.AseguradoraId);
_movimientoRepositorio.Update(new Movimiento
{
Id = movimiento.Id,
Valor = movimiento.Valor,
ClienteId = movimiento.Servicio.Aseguradora.Id,
Aprobado = true
}, m => m.Valor, m => m.Aprobado, m => m.ClienteId);
_unitOfWork.Commit();
}
/// <summary>
/// Registramos Movimiento en Vacio
/// </summary>
/// <returns></returns>
public RetornoOperacion RegistraMovimientoVacioSinOrden()
{
//Declaramos objeto Resultante
RetornoOperacion resultado = new RetornoOperacion();
//Validamos que los Remolque sean Diferentes
if (ddlRemolque1.SelectedValue != ddlRemolque2.SelectedValue || (ddlRemolque1.SelectedValue == "0" && ddlRemolque2.SelectedValue == "0"))
{
//Creando Lista de unidades de arrastre
List <int> arrastre = new List <int>();
arrastre.Add(Convert.ToInt32(ddlRemolque1.SelectedValue));
arrastre.Add(Convert.ToInt32(ddlRemolque2.SelectedValue));
arrastre.Add(Convert.ToInt32(ddlDolly.SelectedValue));
arrastre.RemoveAll(item => item == 0);
//Insertamos movimiento en Vacio
resultado = Movimiento.InsertaMovimientoVacio(this._id_ubicacion_origen, Convert.ToInt32(Cadena.RegresaCadenaSeparada(txtUbicacion.Text, ':', 1)), this._id_compania_emisor,
Convert.ToInt32(Cadena.RegresaCadenaSeparada(txtOperador.Text, ':', 1)), Convert.ToInt32(ddlUnidad.SelectedValue),
Convert.ToInt32(Cadena.VerificaCadenaVacia(Cadena.RegresaCadenaSeparada(txtNombreTercero.Text, ':', 1), "0")), arrastre,
Convert.ToDateTime(txtFechaSalidaUnidades.Text), this._id_tipo_actualizacion_fin, txtRemolque13ero.Text, txtRemolque23ero.Text,
((Usuario)Session["usuario"]).id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Inicializamos Controles
InicializaControl(this._id_recurso, this._id_compania_emisor, Parada.TipoActualizacionLlegada.Manual, Parada.TipoActualizacionSalida.Manual, EstanciaUnidad.TipoActualizacionInicio.Manual, this._id_tipo_actualizacion_fin);
}
else
{
//Mostrando Mensaje Error
lblError.Text = resultado.Mensaje;
}
}
else
{
//Mostramos Mensaje Error
lblError.Text = "No puedes seleccionar remolques iguales.";
}
return(resultado);
}
public bool Guardar(Boolean ShowMessage)
{
try
{
MView.GetItem();
if (!setNroCheque(Item.CUBA_Codigo, Item.TIPO_Movimiento.TIPO_Desc2, Item.TIPO_Movimiento.TIPO_Num1.Value))
{
if (Infrastructure.WinForms.Controls.Dialogos.MostrarMensajePregunta(Title,
"No tiene definido para la cuenta bancaria una chequera, ¿desea continuar?.", Infrastructure.WinForms.Controls.Dialogos.LabelBoton.Si_No) == System.Windows.Forms.DialogResult.No)
{
return(false);
}
}
Item.TipoInterfazMovimiento = Entities.Movimiento.TInterfazMovimiento.ChequeEnBlanco;
if (Item.Validar())
{
Movimiento _item = Item;
if (Client.SaveMovimiento(ref _item, Movimiento.TInterfazMovimiento.ChequeEnBlanco))
{
Item = _item;
if (ShowMessage)
{
Infrastructure.WinForms.Controls.Dialogos.MostrarMensajeSatisfactorio(Title, "Se ha guardado satisfactoriamente");
}
return(true);
}
return(false);
}
else
{
MView.ShowValidation();
return(false);
}
return(false);
}
catch (Exception ex)
{
Infrastructure.WinForms.Controls.Dialogos.MostrarMensajeError(Title, Infrastructure.Aspect.Constants.Mensajes.SavePresenter, ex);
return(false);
}
}
public Boolean Save(ref Movimiento Item, Entities.Movimiento.TInterfazMovimiento x_opcion)
{
try
{
Boolean m_isCorrect = true;
switch (x_opcion)
{
case Movimiento.TInterfazMovimiento.ChequeEnBlanco:
m_isCorrect = SaveChequeEnBlanco(ref Item);
break;
case Movimiento.TInterfazMovimiento.Transferencia:
m_isCorrect = SaveTransferencia(ref Item);
break;
case Movimiento.TInterfazMovimiento.EjecutarDiferido:
m_isCorrect = SaveDiferido(ref Item);
break;
case Movimiento.TInterfazMovimiento.RegistroPlanilla:
m_isCorrect = SavePlanilla(ref Item);
break;
case Movimiento.TInterfazMovimiento.RediferirMovimiento:
m_isCorrect = SaveRediferirMovimiento(ref Item);
break;
case Movimiento.TInterfazMovimiento.Anular:
m_isCorrect = SaveAnular(ref Item);
break;
case Movimiento.TInterfazMovimiento.Extornar:
m_isCorrect = SaveExtornar(ref Item);
break;
}
return(m_isCorrect);
}
catch (Exception)
{ throw; }
}
public static void MovimientosAlta(Movimiento pMovimiento)
{
SqlConnection _cnn = new SqlConnection(Conexion.Cnn);
SqlCommand _comando = new SqlCommand("MovimientosAlta", _cnn);
_comando.CommandType = System.Data.CommandType.StoredProcedure;
_comando.Parameters.AddWithValue("@NumCta", pMovimiento.UnaCuenta.NumCta);
_comando.Parameters.AddWithValue("@MontoMov", pMovimiento.MontoMov);
_comando.Parameters.AddWithValue("@TipoMov", pMovimiento.TipoMov);
_comando.Parameters.AddWithValue("@SaldoCta", pMovimiento.UnaCuenta.SaldoCuenta);
SqlParameter _retorno = new SqlParameter("@Retorno", System.Data.SqlDbType.Int);
_retorno.Direction = System.Data.ParameterDirection.ReturnValue;
_comando.Parameters.Add(_retorno);
try
{
_cnn.Open();
_comando.ExecuteNonQuery();
if ((int)_retorno.Value == -1)
{
throw new Exception("No existe la cuenta");
}
else if ((int)_retorno.Value == -2)
{
throw new Exception("Error en Alta Movimiento");
}
else if ((int)_retorno.Value == -3)
{
throw new Exception("Error en Modificacion de saldo");
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
_cnn.Close();
}
}
public List <Movimiento> ListarxFechasxProducto(DateTime FirstDate, DateTime LastDate, string Producto)
{
List <Movimiento> List = new List <Movimiento>();
try
{
SQLParameter[] parameters = new SQLParameter[3];
parameters[0] = new SQLParameter("@FirstDate", FirstDate, SqlDbType.Date);
parameters[1] = new SQLParameter("@LastDate", LastDate, SqlDbType.Date);
parameters[2] = new SQLParameter("@Producto", Producto, SqlDbType.VarChar);
DataTable data = new DataTable();
data = Conexion.ExecuteProcedureD("USP_S_SeleccionarMovimientoFechasProducto", parameters).Tables[0];
foreach (DataRow row in data.Rows)
{
Movimiento be = new Movimiento
{
ID = Convert.ToInt32(row[0]),
Fecha = Convert.ToDateTime(row[1]),
TipoComprobante = row[2].ToString(),
Serie = row[3].ToString(),
Numero = row[4].ToString(),
TipoOperacion = row[5].ToString(),
Producto = row[6].ToString(),
CantidadEntrada = Convert.ToInt32(row[7]),
CostoUnitarioEntrada = Convert.ToDouble(row[8]),
CostoTotalEntrada = Convert.ToDouble(row[9]),
CantidadSalida = Convert.ToInt32(row[10]),
CostoUnitarioSalida = Convert.ToDouble(row[11]),
CostoTotalSalida = Convert.ToDouble(row[12]),
CantidadFinal = Convert.ToInt32(row[13]),
CostoUnitarioFinal = Convert.ToDouble(row[14]),
CostoTotalFinal = Convert.ToDouble(row[15])
};
List.Add(be);
}
}
catch
{
Console.WriteLine("No se encontro Procedimiento Almacenado");
}
return(List);
}
protected void btnAgregarNewCuenta_Click(object sender, EventArgs e)
{
if (cvTxtNewMontoInicial.IsValid && cvTxtNewNumCuenta.IsValid)
{
this.divNewCuenta.Visible = false;
this.btnNewCuenta.Visible = true;
String numCuentaTxt = this.txtNewNumCuenta.Text;
int numCuenta = Convert.ToInt32(numCuentaTxt);
String montoTxt = this.txtNewMontoInicial.Text;
int monto = Convert.ToInt32(montoTxt);
List <Cliente> clientes = clienteDAL.Obtener();
for (int i = 0; i < clientes.Count(); i++)
{
foreach (GridViewRow row in gvClientes.Rows)
{
String run = row.Cells[0].Text;
if (run == clientes[i].Run)
{
String clave = clientes[i].Run.Substring(0, 4);
Cuenta cuenta = new Cuenta();
cuenta.Num_cuenta = numCuenta;
cuenta.Saldo = monto;
cuenta.CuentaHabiente = clientes[i];
cuenta.Clave = clave;
if (monto != 0)
{
Movimiento m = new Movimiento((cuenta.Movimientos.Count() + 100), cuenta, "Depósito", monto);
}
clientes[i].Cuentas.Add(cuenta);
cuentaDal.Agregar(cuenta);
gvCuentas.DataBind();
}
}
}
}
}
public async Task <IActionResult> DeleteConfirmed(int id, [Bind("IdRazonMovimiento, FechaMovimiento")] Movimiento datos)
{
var ganado = await _context.Ganado.FindAsync(id);
ganado.Estado = (int)Ganado.Estados.Baja;
Movimiento movimiento = new Movimiento();
movimiento.IdRazonMovimiento = datos.IdRazonMovimiento;
movimiento.FechaMovimiento = datos.FechaMovimiento;
movimiento.IdGanado = ganado.IdGanado;
movimiento.Estado = 1;
_context.Movimiento.Add(movimiento);
_context.Ganado.Update(ganado);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public List <Movimiento> SelectMovimiento()
{
List <Movimiento> movimiento_list = new List <Movimiento>();
Database database = new Database();
System.Data.OleDb.OleDbDataReader reader = database.ReadDB("SELECT * FROM Movimientos ORDER BY id_movimientos ASC");
while (reader.Read())
{
Movimiento movimiento = new Movimiento();
movimiento.Id_movimientos = Convert.ToInt32(reader["id_movimientos"].ToString());
movimiento.Factura = Convert.ToInt32(reader["factura"].ToString());
movimiento.Fecha = Convert.ToDateTime(reader["fecha"].ToString());
movimiento.Dinero = Convert.ToSingle(reader["dinero"].ToString());
movimiento.Id_personas = Convert.ToInt32(reader["id_personas"].ToString());
movimiento_list.Add(movimiento);
}
database.Close_Database();
return(movimiento_list);
}
public void BorrarMovimiento(Movimiento movimiento)
{
Console.WriteLine("Borrando movimiento" + movimiento.Id);
using (var ts = new TransactionScope(TransactionScopeOption.Required))
{
try
{
DeleteMovimiento(movimiento);
ts.Complete();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}
Console.WriteLine("Movimiento Borrado");
}
public bool anularSaldoEgreso(Movimiento movimiento, ModelStateDictionary ModelState, int montoOrginal)
{
SAG2DB db = new SAG2DB();
Saldo Saldo = null;
try
{
Saldo = db.Saldo.Where(s => s.CuentaCorrienteID == movimiento.CuentaCorrienteID).Where(s => s.Periodo == movimiento.Periodo).Where(s => s.Mes == movimiento.Mes).Single();
Saldo.SaldoFinal = Saldo.SaldoFinal + montoOrginal;
db.Entry(Saldo).State = EntityState.Modified;
db.SaveChanges();
}
catch (Exception)
{
return(false);
}
actualizarSaldos(Saldo);
return(true);
}
/// <summary>
/// Reversa Movimiento
/// </summary>
private void reversaMovimiento()
{
//Declaramos Mensaje
RetornoOperacion resultado = new RetornoOperacion();
//Instanciamos Movimiento
using (Movimiento objMovimiento = new Movimiento(Convert.ToInt32(gvMovimientos.SelectedValue)))
{
//Terminamos Movimiento
resultado = objMovimiento.ReversaTerminaMovimientoVacio(((Usuario)Session["usuario"]).id_usuario);
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Cargamos Movimientos
cargaMovimientosVacio();
}
//Mostrando resultado
ScriptServer.MuestraNotificacion(gvMovimientos, resultado, ScriptServer.PosicionNotificacion.AbajoDerecha);
}
public void EmitirMovimiento(long?clienteId, decimal monto, TipoMovimiento tipoMovimiento, long?facturaId, long?proveedorId)
{
using (var context = new ModeloGastronomiaContainer())
{
var MovimientoNuevo = new Movimiento
{
ClienteId = clienteId,
Numero = ObtenerSiguienteNumero(),
Fecha = DateTime.Now,
Tipo = tipoMovimiento,
Monto = monto,
FacturaId = facturaId,
ProveedorId = proveedorId
};
context.Movimientos.Add(MovimientoNuevo);
context.SaveChanges();
}
}
// OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks
override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
if (playerScript == null)
{
playerScript = animator.GetComponent <Movimiento> ();
}
//Debug.Log("Inicio:"+startTime+" end: "+endTime+ "tiempo normalizado: "+stateInfo.normalizedTime);
if (stateInfo.normalizedTime > startTime && stateInfo.normalizedTime < endTime)
{
playerScript._weapon1.enabled = true;
playerScript._weapon2.enabled = true;
}
else
{
playerScript._weapon1.enabled = false;
playerScript._weapon2.enabled = false;
}
playerScript.FaceTarget();
}
public Movimiento Add(Movimiento movimiento)
{
Movimiento result = default(Movimiento);
try
{
var request = new MovimientoRequest()
{
Movimiento = movimiento
};
var response = HttpPost <MovimientoResponse, MovimientoRequest>("api/Movimiento/Agregar", request, MediaType.Json);
result = response.Result;
}
catch (FaultException fex)
{
throw new ApplicationException(fex.Message);
}
return(result);
}
public void ObtenerJugada(List <int> posiciones)
{
Queue <int> pasos = new Queue <int>();
foreach (int pos in posiciones)
{
pasos.Enqueue(pos);
}
Movimiento m = new Movimiento();
m.Origen = pasos.Dequeue();
m.Destino = pasos.Dequeue();
jugada.AddLos_movs(m);
while (pasos.Count != 0)
{
m.Origen = m.Destino;
m.Destino = pasos.Dequeue();
jugada.AddLos_movs(m);
}
}
public static string Usermove(string strMov, Partida ptd)
{
Movimiento usermove = new Movimiento(strMov);
ptd.Tab.MoverPieza(usermove, false);
ptd.CambiarTurno();
if (ptd.ColorMaquina != 2)
{
Movimiento respuesta = ptd.Alejo.ElegirMovimiento(ptd);
ptd.Tab.MoverPieza(respuesta, false);
ptd.CambiarTurno();
return("move " + respuesta.ToString());
}
else
{
return("no respuesta");
}
}
public static void Add(Movimiento movimiento)
{
// Actulizo el Archivo
var archivo = new StreamWriter(nombreArchivo, true);
string tipo = movimiento.TipoMovimiento == TipoMovimiento.Ingreso
? " 1"
: "-1";
var crearLinea = $"{movimiento.Identificacion.PadLeft(8, '0')}" +
$"{movimiento.Descripcion.PadRight(68, ' ')}" +
$"{movimiento.Monto.ToString().PadLeft(14, ' ')}" +
$"{tipo}";
archivo.WriteLine(crearLinea);
archivo.Close();
// Actualizo la Lista
Movimientos.Add(movimiento);
}
public long InsertarMovimiento(Movimiento movimiento)
{
long insertado = -1;
try
{
Object objeto = mapper.Insert("InsertarMovimiento", movimiento);
if (objeto != null)
{
insertado = (long)objeto;
objeto = null;
}
}
catch (Exception e)
{
log.Error("ERROR --------- " + e.StackTrace);
}
return(insertado);
}
public ActionResult Reintegro(int id)
{
Movimiento movimiento = db.Movimiento.Find(id);
Persona Persona = (Persona)Session["Persona"];
@ViewBag.Ejecutor = Persona.NombreCompleto;
DetalleEgreso detalle = db.DetalleEgreso.Find(movimiento.DetalleEgresoID);
@ViewBag.detalle = detalle;
try
{
@ViewBag.Director = db.Rol.Include(r => r.TipoRol).Include(r => r.Persona).Where(r => r.TipoRolID == 1).Where(r => r.ProyectoID == movimiento.ProyectoID).Single().Persona.NombreCompleto;
@ViewBag.Apoderado = db.Rol.Include(r => r.TipoRol).Include(r => r.Persona).Where(r => r.TipoRolID == 6).Where(r => r.ProyectoID == movimiento.ProyectoID).Single().Persona.NombreCompleto;
}
catch
{ }
return(View(movimiento));
}
public void Insertar(string concepto, string tipo, string subtipo, string fecha, decimal monto, string mes)
{
mov = new Movimiento();
_doMovimiento = new MovimientoDo();
try
{
mov.Concepto = concepto.Trim();
//mov.Descripcion = descripcion.Trim();
mov.Fecha = fecha.Trim();
mov.Monto = monto;
mov.Tipo = tipo.Trim();
mov.SubTipo = subtipo.Trim();
mov.Mes = mes.Trim();
_doMovimiento.Insertar(mov);
}
catch (Exception ex)
{
throw ex;
}
}
protected void lnk_nuevo_Click(object sender, EventArgs e)
{
Movimiento m = new Movimiento();
DataSet ds = new DataSet();
m.id_empresa = sessionEmp;
m.apellidos = txtFilApellido.Text;
m.tipo = Convert.ToInt16(ddlFilTipo.SelectedValue);
ds = MovimientoBS.ObtieneRepMovimiento(m);
String filename = "Reporte movimientos ";
HttpResponse response = HttpContext.Current.Response;
// first let's clean up the response.object
response.Clear();
response.Charset = "";
// set the response mime type for excel
response.ContentType = "application/vnd.ms-excel";
response.AddHeader("Content-Disposition", "attachment;filename=\"" + filename + "\"");
Response.ContentEncoding = System.Text.Encoding.Unicode;
Response.BinaryWrite(System.Text.Encoding.Unicode.GetPreamble());
// create a string writer
using (System.IO.StringWriter sw = new StringWriter())
{
using (HtmlTextWriter htw = new HtmlTextWriter(sw))
{
// instantiate a datagrid
DataGrid dg = new DataGrid();
dg.DataSource = ds.Tables[0];
dg.DataBind();
dg.RenderControl(htw);
response.Write(sw.ToString());
response.End();
}
}
}
public ActionResult Create(Movimiento movimiento)
{
if (ModelState.IsValid)
{
var userProp = UserManager.FindByEmail(User.Identity.GetUserName());
var IdUser = userProp.IdUsuario;
movimiento.IdUsuario = IdUser;
db.Movimientos.Add(movimiento);
if (movimiento.Operacion == "Depósito")
{
// obtengo el saldo actual del usuario y lo actualizo
userProp.SaldoActual = userProp.SaldoActual + movimiento.Monto;
TempData["Success"] = "El movimiento ha sido generado correctamente.";
UserManager.Update(userProp);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
// si hay saldo suficiente, se hace la extracción
if (userProp.SaldoActual >= movimiento.Monto)
{
userProp.SaldoActual = userProp.SaldoActual - movimiento.Monto;
TempData["Success"] = "El movimiento ha sido generado correctamente.";
UserManager.Update(userProp);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
// no se puede realizar la extracción
ViewData["Error"] = "El saldo en la billetera es insuficiente para realizar la extracción solicitada";
return(View("Create"));
}
}
// UserManager.Update(userProp);
// db.SaveChanges();
}
return(View(movimiento));
}
public void DeshacerMovimiento(Movimiento mov, bool reinsertarCapturadas)
{
byte color = this[mov.Destino].Tipo.Color;
if (mov.Destino == this.EsqRey[0] || mov.Destino == this.EsqRey[1]) //esqrey[color]??
{
this.EsqRey[color] = mov.Origen;
if (mov.Origen == mov.Destino - 2)
{
this[mov.Destino - 1].Tipo = this[mov.Destino - 3].Tipo;
this[mov.Destino - 3].Tipo = null;
}
else if (mov.Origen == mov.Destino + 2)
{
this[mov.Destino + 1].Tipo = this[mov.Destino + 4].Tipo;
this[mov.Destino + 4].Tipo = null;
}
}
this[mov.Destino].Tipo.EliminarMovimientos(mov.Destino, this);
this[mov.Origen].Tipo = this[mov.Destino].Tipo;
this[mov.Destino].Tipo = null;
if (esqPiezasCapturadas.Count > 0 && reinsertarCapturadas)
{
int destinoComido = (int)esqPiezasCapturadas.Peek();
Pieza piezaComida;
if (destinoComido == mov.Destino)
{
this.esqPiezasCapturadas.Pop();
piezaComida = (Pieza)this.piezasCapturadas.Pop();
this[mov.Destino].Tipo = piezaComida;
this[mov.Destino].Tipo.GenerarMovLegales(mov.Destino, this);
}
}
Movimiento invertido = new Movimiento(mov.Destino, mov.Origen);
this.ActualizarTablero(invertido);
this[mov.Origen].Tipo.GenerarMovLegales(mov.Origen, this);
}
public Juego1Stub()
{
juego = new Juego(4);
Viajero1 = new ViajeroComun("123", "Juan");
Viajero2 = new ViajeroComun("124", "Ana");
Viajero3 = new ViajeroComun("125", "Pedro");
Viajero4 = new ViajeroComun("126", "Antonio");
List <Viajero> viajeros = new List <Viajero>();
viajeros.Add(Viajero1);
viajeros.Add(Viajero2);
viajeros.Add(Viajero3);
viajeros.Add(Viajero4);
Experiencia granja1 = new Granja(3);
Experiencia granja2 = new Granja(1);
Experiencia aguaTermal1 = new AguaTermal(1);
Experiencia aguaTermal2 = new AguaTermal(4);
Experiencia oceano1 = new Oceano(4);
Experiencia oceano2 = new Oceano(2);
Experiencia montania1 = new Montania(3);
Experiencia montania2 = new Montania(1);
List <Experiencia> experiencias = new List <Experiencia>();
experiencias.Add(granja1);
experiencias.Add(aguaTermal1);
experiencias.Add(oceano1);
experiencias.Add(granja2);
experiencias.Add(montania1);
experiencias.Add(oceano2);
experiencias.Add(montania2);
experiencias.Add(aguaTermal2);
juego.CargarViajeros(viajeros);
juego.CargarExperiencias(experiencias);
Mover = new Movimiento(juego.Camino, juego.Viajeros);
}
private Guid RegistrarMovimientoEgreso(Guid Id, double Kilos, Guid DepositoId)
{
Movimiento movimiento;
movimiento = new Movimiento();
movimiento.Id = Guid.NewGuid();
movimiento.Fecha = DateTime.Now.Date;
movimiento.TransaccionId = Id;
movimiento.Documento = DevConstantes.Transferencia;
movimiento.Unidad = DevConstantes.Kg;
movimiento.Ingreso = 0;
movimiento.Egreso = Kilos;
movimiento.DepositoId = DepositoId;
movimiento.Actual = false;
movimiento.Anulado = false;
Context.Movimiento.Add(movimiento);
Context.SaveChanges();
return(movimiento.Id);
}
public async Task <IActionResult> DeleteConfirmed(int id)
{
try
{
Movimiento movimiento = new Movimiento()
{
IdMovimiento = id
};
_context.Entry(movimiento).State = EntityState.Deleted;
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.)
return(RedirectToAction(nameof(Delete), new { id = id, saveChangesError = true }));
}
}
public async Task <IActionResult> Create([Bind("Fecha,Tipo,Estado")] Movimiento movimiento)
{
try
{
if (ModelState.IsValid)
{
_context.Add(movimiento);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.
ModelState.AddModelError("", "No se pueden guardar los cambios. " +
"Inténtalo de nuevo y si el problema persiste" +
"consulte al administrador de su sistema.");
}
return(View(movimiento));
}
public void Devolver(Documento documento,NotaCredito notaCredito, IList<DocumentoLinea> lineasDocumento,List<NotaIngresoSalidaLinea> lineasIngresosSalidas)
{
new DocumentoBL().Grabar(documento);
foreach (DocumentoLinea documentoLinea in lineasDocumento)
{
documentoLinea.Documento = documento;
new DocumentoLineaBL().Grabar(documentoLinea);
}
//MOVIMIENTO
Movimiento movimiento=new Movimiento();
movimiento.Local=documento.Caja.Local;
movimiento.Fecha=DateTime.Today;
new MovimientoBL().Grabar(movimiento);
//GRABAMOS LA NOTA DE CREDITO
notaCredito.Documento = documento;
notaCredito.NroMovimiento = movimiento;
Grabar(notaCredito);
//CREAMOS LA NOTA DE INGRESOSALIDA
NotaIngresoSalida notaIngSal=new NotaIngresoSalida();
notaIngSal.Local=documento.Caja.Local;
notaIngSal.Fecha=DateTime.Today;
notaIngSal.NroMovimiento=movimiento;
new NotaIngresoSalidaBL().Grabar(notaIngSal);
foreach (NotaIngresoSalidaLinea linea in lineasIngresosSalidas) linea.CodNota = notaIngSal;
new NotaIngresoSalidaLineaBL().Grabar(lineasIngresosSalidas);
}
public ActionResult ViewAttachment(int id, String option, String carga)
{
if (carga != null)
{
Asegurado asegurado = db.Asegurados.Find(id);
var movtosTemp = db.Movimientos.Where(x => x.aseguradoId == id
&& x.tipo.Equals(option)).OrderByDescending(x => x.fechaTransaccion).ToList();
Movimiento movto = new Movimiento();
if (movtosTemp != null && movtosTemp.Count > 0)
{
foreach (var movtosItem in movtosTemp)
{
movto = movtosItem;
break;
}//Definimos los valores para la plaza
var fileName = "C:\\SUA\\Asegurados\\" + asegurado.numeroAfiliacion + "\\" + option + "\\" + movto.nombreArchivo.Trim();
if (System.IO.File.Exists(fileName))
{
FileStream fs = new FileStream(fileName, FileMode.Open);
return File(fs, "application/pdf");
}
else
{
return RedirectToAction("Index");
}
}
else
{
return RedirectToAction("Index");
}
}
else
{
return RedirectToAction("Index");
}
}
void iniciaPuntos()
{
orden=new List<List<Movimiento>>();
//Movimiento1
List<Movimiento> movsUno=new List<Movimiento>();
Movimiento mv1=new Movimiento();
mv1.distancia=30f;
mv1.eje=EJE_X;
movsUno.Add(mv1);
orden.Add(movsUno);
//movimiento2
List<Movimiento> movsDos=new List<Movimiento>();
Movimiento mv2=new Movimiento();
mv2.ejeRotacion=EJE_Y;
mv2.rotacion=90f;
movsDos.Add(mv2);
//
Movimiento mv2Uno=new Movimiento();
mv2Uno.eje=EJE_Z;
mv2Uno.distancia=-7f;
movsDos.Add(mv2Uno);
//
Movimiento mv2Dos=new Movimiento();
mv2Dos.ejeRotacion=EJE_Y;
mv2Dos.rotacion=-90f;
movsDos.Add(mv2Dos);
Movimiento mv2Tres=new Movimiento();
mv2Tres.distancia=20f;
mv2Tres.eje=EJE_X;
movsDos.Add(mv2Tres);
Movimiento mv2Cuatro=new Movimiento();
mv2Cuatro.ejeRotacion=EJE_Y;
mv2Cuatro.rotacion=-90f;
movsDos.Add(mv2Cuatro);
Movimiento mv2Cinco=new Movimiento();
mv2Cinco.eje=EJE_Z;
mv2Cinco.distancia=7f;
movsDos.Add(mv2Cinco);
Movimiento mv2Seis=new Movimiento();
mv2Seis.ejeRotacion=EJE_Y;
mv2Seis.rotacion=90f;
movsDos.Add(mv2Seis);
orden.Add(movsDos);
//
List<Movimiento> movsTres=new List<Movimiento>();
Movimiento mv3Uno=new Movimiento();
mv3Uno.ejeRotacion=EJE_Y;
mv3Uno.rotacion=90f;
movsTres.Add(mv3Uno);
Movimiento mv3Dos=new Movimiento();
mv3Dos.eje=EJE_Z;
mv3Dos.distancia=-5f;
movsTres.Add(mv3Dos);
Movimiento mv3Tres=new Movimiento();
mv3Tres.ejeRotacion=EJE_Y;
mv3Tres.rotacion=-90f;
movsTres.Add(mv3Tres);
Movimiento mv3Cuatro=new Movimiento();
mv3Cuatro.eje=EJE_X;
mv3Cuatro.distancia=15f;
movsTres.Add(mv3Cuatro);
Movimiento mv3Cinco=new Movimiento();
mv3Cinco.ejeRotacion=EJE_Y;
mv3Cinco.rotacion=-90f;
movsTres.Add(mv3Cinco);
Movimiento mv3Seis=new Movimiento();
mv3Seis.eje=EJE_Z;
mv3Seis.distancia=5f;
movsTres.Add(mv3Seis);
Movimiento mv3Siete=new Movimiento();
mv3Siete.ejeRotacion=EJE_Y;
mv3Siete.rotacion=90f;
movsTres.Add(mv3Siete);
Movimiento mv3Ocho=new Movimiento();
mv3Ocho.eje=EJE_X;
mv3Ocho.distancia=5f;
movsTres.Add(mv3Ocho);
Movimiento mv3Nueve=new Movimiento();
mv3Nueve.eje=EJE_X;
mv3Nueve.distancia=10f;
movsTres.Add(mv3Nueve);
orden.Add(movsTres);
//
List<Movimiento> movsCuatro=new List<Movimiento>();
Movimiento mv4Uno=new Movimiento();
mv4Uno.ejeRotacion=EJE_Y;
mv4Uno.rotacion=90f;
movsCuatro.Add(mv4Uno);
Movimiento mv4Dos=new Movimiento();
mv4Dos.eje=EJE_Z;
mv4Dos.distancia=2f;
movsCuatro.Add(mv4Dos);
orden.Add(movsCuatro);
//
List<Movimiento> movsCinco=new List<Movimiento>();
Movimiento mv5Uno=new Movimiento();
mv5Uno.ejeRotacion=EJE_Y;
mv5Uno.rotacion=180f;
movsCinco.Add(mv5Uno);
Movimiento mv5Dos=new Movimiento();
mv5Dos.eje=EJE_Z;
mv5Dos.distancia=-2f;
movsCinco.Add(mv5Dos);
orden.Add(movsCinco);
//
List<Movimiento> movsSeis=new List<Movimiento>();
Movimiento mv6Uno=new Movimiento();
mv6Uno.ejeRotacion=EJE_Y;
mv6Uno.rotacion=90f;
movsSeis.Add(mv6Uno);
Movimiento mv6Dos=new Movimiento();
mv6Dos.eje=EJE_X;
mv6Dos.distancia=10f;
movsSeis.Add(mv6Dos);
orden.Add(movsSeis);
}
IEnumerator ejecutaVariosMovimientosRegresar(int posAc)
{
//Debug.Log(posAc+" ** "+orden.Count);
if(posAc>(orden.Count-1)){
//Debug.Log("Es el ultimo");
posAc=posAc-1;
posicionActual=posicionActual-1;
}
List<Movimiento> movs=orden[posAc];
Movimiento voltea=new Movimiento();
voltea.ejeRotacion=EJE_Y;
voltea.rotacion=180f;
StartCoroutine(ejecutaMovimiento(voltea));
int i=movs.Count-1;
while(i>=0){
if(!estaCorriendo){
Movimiento m=movs[i];
//Debug.Log(m.eje+" ** "+m.distancia);
//Debug.Log(m.ejeRotacion+" ** "+m.rotacion);
if(m.ejeRotacion.Equals("")){
m.distancia=(m.distancia*-1.0f);
}else {
m.rotacion=(m.rotacion*-1.0f);
}
//Debug.Log(m.eje+" ++ "+m.distancia);
//Debug.Log(m.ejeRotacion+" ++ "+m.rotacion);
StartCoroutine(ejecutaMovimiento(m));
i--;
}else{
yield return new WaitForSeconds(0.0001f);
}
}
StartCoroutine(ejecutaMovimiento(voltea));
}
IEnumerator ejecutaMovimiento(Movimiento movimiento)
{
estaCorriendo=true;
float x,y,z;
x=player.transform.position.x;
y=player.transform.position.y;
z=player.transform.position.z;
if(movimiento.ejeRotacion.Equals("")){
//Debug.Log("Mover");
if(movimiento.eje==EJE_X){
x+=movimiento.distancia;
}else if(movimiento.eje==EJE_Y){
y+=movimiento.distancia;
}else if(movimiento.eje==EJE_Z){
z+=movimiento.distancia;
}
float i=100f;
float avance=movimiento.distancia/i;
float tmp=0;
while(tmp<i){
player.transform.position=Vector3.Lerp(player.transform.position,new Vector3(x,y,z),tmp*0.01f);
tmp++;
yield return null;
}
}else{
//Debug.Log("Rotar");
float xR,yR,zR;
xR=0f;
yR=0f;
zR=0f;
float i=100f;
float avance=movimiento.rotacion/i;
float tmp=0;
while(tmp<i){
//Debug.Log("Esta rotando");
if(movimiento.ejeRotacion==EJE_X){
xR=avance;
}else if(movimiento.ejeRotacion==EJE_Y){
yR=avance;
}else if(movimiento.ejeRotacion==EJE_Z){
zR=avance;
}
tmp++;
player.transform.Rotate(Vector3.Slerp(player.transform.eulerAngles,new Vector3(xR,yR,zR),1));
yield return null;
}
}
estaCorriendo=false;
}
public ActionResult UploadFileAcre(int id)
{
if (id == 0)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Acreditado acreditado = db.Acreditados.Find(id);
if (acreditado == null)
{
return HttpNotFound();
}
Movimiento movimiento = new Movimiento();
DateTime date = DateTime.Now;
movimiento.Acreditado = acreditado;
movimiento.acreditadoId = id;
movimiento.fechaTransaccion = date;
movimiento.tipo = "A";
ViewBag.Acreditado = acreditado;
return View(movimiento);
}
static void Main(string[] args)
{
AppaLiteModelContainer context = new AppaLiteModelContainer();
Marca mrc1 = new Marca
{
Nombre = "Adidas",
Icono = "Adidas.jpg"
};
context.Marcas.Add(mrc1);
//context.SaveChanges();
Articulo art1 = new Articulo
{
Referencia = "A12345",
Descripcion = "Maraton 6",
Talla = "6",
Marca = mrc1
// Prestamo =
};
context.Articulos.Add(art1);
//context.SaveChanges();
Local lcl1 = new Local
{
Nombre = "Cca 126",
Icono = "126.jpg",
Telefono = "3021234"
};
context.Locales.Add(lcl1);
//context.SaveChanges();
Local lcl2 = new Local
{
Nombre = "Cca 124",
Icono = "124.jpg",
Telefono = "3011235"
};
context.Locales.Add(lcl2);
//context.SaveChanges();
Empleado emp1 = new Empleado
{
Nombre = "Elbert Toledo",
Cedula = "1234",
Telefono = "3001236",
Foto = "emp1.jpg",
};
context.Empleados.Add(emp1);
//context.SaveChanges();
Movimiento mvt1 = new Movimiento
{
Estado = "Prestado",
Fecha = "10/08/2015",
Hora = "2:30 Pm",
Destino = lcl1,
//Prestamo =ptm1 ,
};
emp1.Movimiento.Add(mvt1);
context.Movimientos.Add(mvt1);
//context.SaveChanges();
Prestamo ptm1 = new Prestamo
{
Articulo = art1,
Origen = lcl1,
// Movimientos
};
// mvt1.Prestamo = ptm1;
ptm1.Articulo = art1;
context.Prestamos.Add(ptm1);
//context.SaveChanges();
try
{
// doing here my logic
context.SaveChanges();
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
Console.WriteLine("Property: {0} Error: {1}", validationError.
PropertyName, validationError.ErrorMessage);
}
}
}
//context.SaveChanges();
}
private void btnGuardar_Click(object sender, EventArgs e)
{
if (!puedeGuardar)
{
Utils.Utils.Mensaje("Datos incompletos o incorrectos", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
if (txtRazonSocial.Text.Length == 0)
{
Utils.Utils.Mensaje("Por favor, ingrese la Razón Social", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
if (txtRUC.Text.Length == 0)
{
Utils.Utils.Mensaje("Por favor, ingrese la RUC", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
if (cboEstado.Text.Length == 0)
{
Utils.Utils.Mensaje("Por favor, seleccione el Estado", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
if (dtpFecDevolucion.Value.Date <= dtpFecEntrega.Value.Date)
{
Utils.Utils.Mensaje("La fecha de Devolución debe ser posterior a la de Entrega", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
if (consignacionLineas.Count == 0)
{
Utils.Utils.Mensaje("Por favor, agregue artículos a la consignación", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
if (!Utils.Utils.ContinuarOperacion("Una vez ingresados los datos no podrán cambiarse. ¿Está totalmente seguro?"))
{
return;
}
consignacion.FechaEntrega = dtpFecEntrega.Value.Date;
consignacion.FechaDevolucion = dtpFecDevolucion.Value.Date;
consignacion.Estado = cboEstado.Text;
consignacion.TipoCambio = tipoCambio;
consignacion.Empleado = empleado;
consignacion.FechaRegistro = DateTime.Now;
Movimiento movConsignacion = new Movimiento();
movConsignacion.Local = empleado.Local;
movConsignacion.Fecha = System.DateTime.Now;
new MovimientoBL().Grabar(movConsignacion);
consignacion.NroMovimiento = movConsignacion;
if (new DocumentoConsignacionBL().Grabar(consignacion) && new DocumentoConsignacionBL().Grabar(consignacionLineas))
{
Utils.Utils.OK(Utils.Utils.REGISTRO_OK);
btnGuardar.Visible = true;
btnCancelar.Text = "Aceptar";
}
else
Utils.Utils.Error(null, "Error al guardar la información");
}
private void btnAceptar_Click(object sender, EventArgs e)
{
int nLineas = articulos.Count;
bool ok = true;
string msjError = "";
//LIMPIRAR CELDAS
for (int i = 0; i < nLineas; i++)
{
dgvIncidencias.Rows[i].DefaultCellStyle.BackColor = Color.White;
}
//CANTIDADES LLENAS
for (int i = 0; i < nLineas; i++)
{
//verificar todo lleno
string sCantAceptada = dgvIncidencias.Rows[i].Cells[4].FormattedValue.ToString();
if (String.IsNullOrEmpty(sCantAceptada))
{
dgvIncidencias.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
ok = false;
msjError = "No especificó ninguna cantidad asociada.\n";
}
else
{
int cantidadAceptada;
//verificar numero valido
if ((!int.TryParse(sCantAceptada, out cantidadAceptada)))
if (cantidadAceptada < 0)
{
ok = false;
dgvIncidencias.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
msjError = "No especificó un número de cantidad válido.\n";
}
else
//verificar cantidaad menor a la permitida
if (cantidadAceptada <= Convert.ToInt32(dgvIncidencias.Rows[i].Cells[4].Value))
{
ok = false;
dgvIncidencias.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
msjError = "Cantidad Mayor a la permitida.\n";
}
else
{
articulos[i].Cantidad = cantidadAceptada;
}
}
//NO ARTICULOS
if (nLineas <= 0)
{
ok = false;
msjError += "No especificó ningun artículo involucrado.\n";
}
}
if (ok)
{
//crear objeto movimiento
Movimiento mov = new Movimiento();
mov.Local = (Local)cmbLocal.SelectedItem;
mov.Fecha = dtpFecha.Value.Date;
//Crear objeto ajuste
Ajuste ajuste = new Ajuste();
ajuste.FechaAjuste = DateTime.Today;
ajuste.Local = (Local)cmbLocal.SelectedItem;
ajuste.NroMovimiento = mov;
//creacion de objetos ajustelinea
List<AjusteLinea> lineas = new List<AjusteLinea>();
foreach (ArticuloXLocal art in articulos)
{
new ArticuloXLocalBL().Actualizar(art);
AjusteLinea linea = new AjusteLinea();
linea.ArticuloXLocal = art;
linea.Cantidad = art.Cantidad;
lineas.Add(linea);
}
//GRABAR MOVIMIENTO E INCIDENCIA
new MovimientoBL().Grabar(mov);
new AjusteBL().Grabar(ajuste);
new AjusteLineaBL().AsignarSolicitudesLineas(lineas, ajuste);
Utils.Utils.OK(IND_MENSAJE);
this.Dispose();
}
else
Utils.Utils.Error(this, msjError);
}
public LuzRenderizada(TgcMesh me, LightData l , Movimiento m)
{
this.mesh = me;
this.luz = l;
this.movimiento = m;
}
private void btnAceptar_Click(object sender, EventArgs e)
{
int nLineas = lineas.Count;
bool ok = true;
string msjError = "";
//LIMPIRAR CELDAS
for (int i = 0; i < nLineas; i++)
{
dgvArticulos.Rows[i].DefaultCellStyle.BackColor = Color.White;
}
rtbMotivo.BackColor = Color.White;
txbNroDoc.BackColor = Color.White;
//CANTIDADES LLENAS
for (int i = 0; i < nLineas; i++)
{
//verificar todo lleno
string sCantAceptada = dgvArticulos.Rows[i].Cells[2].FormattedValue.ToString();
if (String.IsNullOrEmpty(sCantAceptada))
{
dgvArticulos.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
ok = false;
msjError = "No especificó ninguna cantidad asociada.\n";
}
else
{
int cantidadAceptada;
//verificar numero valido
if ((!int.TryParse(sCantAceptada, out cantidadAceptada)))
if(cantidadAceptada<0)
{
ok = false;
dgvArticulos.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
msjError = "No especificó un número de cantidad válido.\n";
}
else
//verificar cantidaad menor a la permitida
if (!validaCantidad(cantidadAceptada, i))
{
ok = false;
dgvArticulos.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
msjError = "Cantidad Mayor a la permitida.\n";
}
else
{
String cant = cantidadAceptada.ToString();
cantidades.Add(cant);
}
}
//NO ARTICULOS
if (nLineas <= 0)
{
ok = false;
msjError += "No especificó ningun artículo involucrado.\n";
}
//DEVOLUCION Y NRODOC
if (cmbTipoIncidencia.Text == "DEVOLUCION" && txbNroDoc.Text == "")
{
ok = false;
txbNroDoc.BackColor = Color.RosyBrown;
msjError += "No especificó Nro de Orden de Compra.\n";
}
//MOTIVO LLENO
if (rtbMotivo.Text == "")
{
ok = false;
rtbMotivo.BackColor = Color.RosyBrown;
msjError += "No especificó Motivo.\n";
}
}
if (ok)
{
//crear objeto movimiento
Movimiento mov = new Movimiento();
if (cmbTipoIncidencia.Text == "DEVOLUCION")
mov = new MovimientoBL().GetByOC(Convert.ToInt32(txbNroDoc.Text));
else
{
mov.Local = (Local)cmbLocal.SelectedItem;
mov.Fecha = dtpFecha.Value.Date;
}
//Crear objeto incidencia
Incidencia incid = new Incidencia();
String descAd = "";
int cantTotal = 0;
for (int i = 0; i < lineas.Count; i++)
{
descAd += lineas[i];
descAd += " ";
descAd += cantidades[i];
descAd += " ";
cantTotal += Convert.ToInt32(cantidades[i]);
}
descAd += rtbMotivo.Text;
incid.DescripcionAdicional = descAd;
incid.Estado = "Creada";
incid.Fecha = dtpFecha.Value.Date;
incid.Local = (Local)cmbLocal.SelectedItem;
incid.TipoIncidencia = cmbTipoIncidencia.Text;
incid.NroMovimiento = mov;
//creacion de objetos incidencialinea
IncidenciaLinea incidlinea1 = new IncidenciaLinea();
IncidenciaLinea incidlinea2 = new IncidenciaLinea();
//Cantidad de articulos diferentes
incidlinea1.Cantidad = lineas.Count;
incidlinea1.NroIncidencia = incid;
//cantidad total de arituclos dañados
incidlinea2.Cantidad = cantTotal;
incidlinea2.NroIncidencia = incid;
//GRABAR MOVIMIENTO E INCIDENCIA
new MovimientoBL().Grabar(mov);
new IncidenciaBL().Grabar(incid);
new IncidenciaLineaBL().Grabar(incidlinea1);
new IncidenciaLineaBL().Grabar(incidlinea2);
Utils.Utils.OK(IND_MENSAJE);
this.Dispose();
}
else
Utils.Utils.Error(this, msjError);
}
public static global::System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(global::System.Xml.Schema.XmlSchemaSet xs) {
global::System.Xml.Schema.XmlSchemaComplexType type = new global::System.Xml.Schema.XmlSchemaComplexType();
global::System.Xml.Schema.XmlSchemaSequence sequence = new global::System.Xml.Schema.XmlSchemaSequence();
Movimiento ds = new Movimiento();
global::System.Xml.Schema.XmlSchemaAny any1 = new global::System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = global::System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
global::System.Xml.Schema.XmlSchemaAny any2 = new global::System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = global::System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
global::System.Xml.Schema.XmlSchemaAttribute attribute1 = new global::System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
global::System.Xml.Schema.XmlSchemaAttribute attribute2 = new global::System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "ReporteDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
global::System.Xml.Schema.XmlSchema dsSchema = ds.GetSchemaSerializable();
if (xs.Contains(dsSchema.TargetNamespace)) {
global::System.IO.MemoryStream s1 = new global::System.IO.MemoryStream();
global::System.IO.MemoryStream s2 = new global::System.IO.MemoryStream();
try {
global::System.Xml.Schema.XmlSchema schema = null;
dsSchema.Write(s1);
for (global::System.Collections.IEnumerator schemas = xs.Schemas(dsSchema.TargetNamespace).GetEnumerator(); schemas.MoveNext(); ) {
schema = ((global::System.Xml.Schema.XmlSchema)(schemas.Current));
s2.SetLength(0);
schema.Write(s2);
if ((s1.Length == s2.Length)) {
s1.Position = 0;
s2.Position = 0;
for (; ((s1.Position != s1.Length)
&& (s1.ReadByte() == s2.ReadByte())); ) {
;
}
if ((s1.Position == s1.Length)) {
return type;
}
}
}
}
finally {
if ((s1 != null)) {
s1.Close();
}
if ((s2 != null)) {
s2.Close();
}
}
}
xs.Add(dsSchema);
return type;
}
public static global::System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(global::System.Xml.Schema.XmlSchemaSet xs) {
Movimiento ds = new Movimiento();
global::System.Xml.Schema.XmlSchemaComplexType type = new global::System.Xml.Schema.XmlSchemaComplexType();
global::System.Xml.Schema.XmlSchemaSequence sequence = new global::System.Xml.Schema.XmlSchemaSequence();
global::System.Xml.Schema.XmlSchemaAny any = new global::System.Xml.Schema.XmlSchemaAny();
any.Namespace = ds.Namespace;
sequence.Items.Add(any);
type.Particle = sequence;
global::System.Xml.Schema.XmlSchema dsSchema = ds.GetSchemaSerializable();
if (xs.Contains(dsSchema.TargetNamespace)) {
global::System.IO.MemoryStream s1 = new global::System.IO.MemoryStream();
global::System.IO.MemoryStream s2 = new global::System.IO.MemoryStream();
try {
global::System.Xml.Schema.XmlSchema schema = null;
dsSchema.Write(s1);
for (global::System.Collections.IEnumerator schemas = xs.Schemas(dsSchema.TargetNamespace).GetEnumerator(); schemas.MoveNext(); ) {
schema = ((global::System.Xml.Schema.XmlSchema)(schemas.Current));
s2.SetLength(0);
schema.Write(s2);
if ((s1.Length == s2.Length)) {
s1.Position = 0;
s2.Position = 0;
for (; ((s1.Position != s1.Length)
&& (s1.ReadByte() == s2.ReadByte())); ) {
;
}
if ((s1.Position == s1.Length)) {
return type;
}
}
}
}
finally {
if ((s1 != null)) {
s1.Close();
}
if ((s2 != null)) {
s2.Close();
}
}
}
xs.Add(dsSchema);
return type;
}
private void btnAceptar_Click(object sender, EventArgs e)
{
int nLineas = lineas.Count;
bool ok = true;
int nError = 0;//0=vacio
for (int i = 0; i < nLineas; i++)
{
dgvArticulos.Rows[i].DefaultCellStyle.BackColor = Color.White;
}
rtbMotivo.BackColor = Color.White;
txbNroDoc.BackColor = Color.White;
if (cmbTipoIncidencia.Text == "DEVOLUCION" && txbNroDoc.Text == "")
{
ok = false;
txbNroDoc.BackColor = Color.RosyBrown;
nError = 2;//NO ESCRIBIO NROOC
}
else
if (rtbMotivo.Text == "")
{
ok = false;
rtbMotivo.BackColor = Color.RosyBrown;
nError = 4;//NO ESCRIBIO RAZON
}
else
for (int i = 0; i < nLineas; i++)
{
//verificar todo lleno
string sCantAceptada = dgvArticulos.Rows[i].Cells[2].FormattedValue.ToString();
if (String.IsNullOrEmpty(sCantAceptada))
{
dgvArticulos.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
ok = false;
nError = 0;//VACIO
}
else
{
int cantidadAceptada;
//verificar numero valido
if (!int.TryParse(sCantAceptada, out cantidadAceptada))
{
ok = false;
dgvArticulos.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
nError = 1;//NUMERO NO VALIDO
}
else
if (!validaCantidad(cantidadAceptada, i))
{
ok = false;
dgvArticulos.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
nError = 3;//NUMERO MAYOR A STOCK
}
else
{
String cant = cantidadAceptada.ToString();
cantidades.Add(cant);
}
}
}
if (ok)
{
//crear objeto movimiento
Movimiento mov = new Movimiento();
if (cmbTipoIncidencia.Text == "DEVOLUCION")
mov = new MovimientoBL().GetByOC(Convert.ToInt32(txbNroDoc.Text));
else
{
mov.Local = (Local)cmbLocal.SelectedItem;
mov.Fecha = dtpFecha.Value.Date;
new MovimientoBL().Grabar(mov);
}
//Crear objeto incidencia
Incidencia incid = new Incidencia();
String descAd="";
for (int i=0;i<lineas.Count;i++)
{
descAd += lineas[i];
descAd += " ";
descAd += cantidades[i];
descAd += " ";
}
descAd += rtbMotivo.Text;
incid.DescripcionAdicional = descAd;
incid.Estado = "CREADA";
incid.Fecha = dtpFecha.Value.Date;
incid.Local = (Local)cmbLocal.SelectedItem;
incid.TipoIncidencia = cmbTipoIncidencia.Text;
incid.NroMovimiento = mov;
new IncidenciaBL().Grabar(incid);
//creacion de objetos incidencialinea
IncidenciaLinea incidlinea1 = new IncidenciaLinea();
IncidenciaLinea incidlinea2 = new IncidenciaLinea();
//Cantidad de articulos diferentes
incidlinea1.Cantidad = lineas.Count;
incidlinea1.NroIncidencia = incid;
//cantidad total de arituclos dañados
incidlinea2.Cantidad = Convert.ToInt32(txbCantidadTotal.Text);
incidlinea2.NroIncidencia = incid;
new IncidenciaLineaBL().Grabar(incidlinea1);
new IncidenciaLineaBL().Grabar(incidlinea2);
Utils.Utils.OK(IND_MENSAJE);
this.Dispose();
}
else
switch (nError)
{
case 0: { Utils.Utils.Error(this, "Cantidad se encuentra vacia"); break; }
case 1: { Utils.Utils.Error(this, "Cantidad no es un número válido"); break; }
case 2: { Utils.Utils.Error(this, "No ha indicado el Nro de Orden de Compra para la Devolucion"); break; }
case 3: { Utils.Utils.Error(this, "Cantidad mayor a la permitida"); break; }
case 4: { Utils.Utils.Error(this, "Motivo no especificado"); break; }
}
}
//-------------------------------------------------------------
// Metodos
//-------------------------------------------------------------
void Start()
{
//Inicializa los componentes necesarios
mov = (Movimiento)GetComponent(typeof(Movimiento));
poderesEnCool = (Cooldown)GetComponent(typeof(Cooldown));
poderActual = new GameObject();
poderActual.name = "";
if (!photonView.isMine)
{
//MINE: local player, simply enable the local scripts
this.enabled = false;
}
}
private void btnAceptar_Click(object sender, EventArgs e)
{
int nLineas = dgvSolRecep.Rows.Count;
bool ok = true;
int nError = 0;//0=vacio
int nMod=0;//CantidadModificada
List<TransferenciaLinea> lineas = new List<TransferenciaLinea>();
for (int i = 0; i < nLineas; i++)
{
dgvSolRecep.Rows[i].DefaultCellStyle.BackColor = Color.White;
}
for (int i = 0; i < nLineas; i++)
{
//verificar todo lleno
string sCantAceptada = dgvSolRecep.Rows[i].Cells[5].FormattedValue.ToString();
string sIdSolicitudLinea = dgvSolRecep.Rows[i].Cells[0].FormattedValue.ToString();
string sCantSolicitada = dgvSolRecep.Rows[i].Cells[4].FormattedValue.ToString();
if (String.IsNullOrEmpty(sCantAceptada))
{
dgvSolRecep.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
ok = false;
nError = 0;//VACIO
}
else
{
int cantidadAceptada;
//verificar numero valido
if (!int.TryParse(sCantAceptada, out cantidadAceptada))
{
ok = false;
dgvSolRecep.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
nError = 1;//NUMERO NO VALIDO
}
else
{
int cantSolicitada; int.TryParse(sCantSolicitada, out cantSolicitada);
if (cantSolicitada < cantidadAceptada) //VALIDAR CANTIDAD ACEPTADA MENOR A SOLICITADA
{
ok = false;
dgvSolRecep.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
nError = 2;//CANTIDAD MAYOR
}
else
{
SolicitudTransferenciaLinea auxSol = new SolicitudTransferenciaLinea();
TransferenciaLinea aux = new TransferenciaLinea();
int id; int.TryParse(sIdSolicitudLinea, out id);
auxSol = new SolicitudTransferenciaLineaBL().findSolicitudTransferenciaLineaxId(id);
aux.ArticuloXLocal = auxSol.ArticuloXLocal;
aux.CantidadArticulosAprob = cantidadAceptada;
if (cantSolicitada != cantidadAceptada) { nMod++; }
lineas.Add(aux);
}
}
}
}
if (ok)
{
Movimiento mov = new Movimiento();
mov.Local = solicitud.LocalOrigen;
mov.Fecha = DateTime.Now.Date;
Transferencia Trans = new Transferencia();
Trans.LocalOrigen = solicitud.LocalOrigen;
Trans.LocalDestino =solicitud.LocalDestino;
Trans.Movimiento=solicitud.Movimiento;
Trans.NroMovimiento = mov;
Trans.NroSolicitudTransferencia=solicitud;
Trans.Estado="Emitido";
Trans.FechaConfirmacion=DateTime.Now.Date;
new MovimientoBL().Grabar(mov);
new TransferenciaBL().Grabar(Trans);
new TransferenciaLineaBL().AsignarSolicitudesLineas(lineas, Trans);
if (nMod > 0)
solicitud.Estado = "Parcialmente Aceptado";
else
solicitud.Estado = "Aceptado";
new SolicitudTransferenciaBL().Grabar(solicitud);
Utils.Utils.OK(IND_MENSAJE);
this.Dispose();
}
else
switch (nError)
{
case 0: { Utils.Utils.Error(this,"Cantidad Aceptada se encuentra vacia"); break; }
case 1: { Utils.Utils.Error(this, "Cantidad Aceptada no es un número válido"); break; }
case 2: { Utils.Utils.Error(this, "Cantidad Aceptada es mayor a la Cantidad Solicitada"); break; }
}
}
public void Grabar(Movimiento movimiento)
{
new MovimientoDA().Save(movimiento);
}
private void btnAceptar_Click(object sender, EventArgs e)
{
int nLineas = dgvSolRecep.Rows.Count;
bool ok = true;
string msjError = "";
int nMod=0;//CantidadModificada
List<TransferenciaLinea> lineas = new List<TransferenciaLinea>();
//LIMPIAR CELDAS
for (int i = 0; i < nLineas; i++)
{
dgvSolRecep.Rows[i].DefaultCellStyle.BackColor = Color.White;
}
for (int i = 0; i < nLineas; i++)
{
//verificar todo lleno
string sCantAceptada = dgvSolRecep.Rows[i].Cells[5].FormattedValue.ToString();
string sIdSolicitudLinea = dgvSolRecep.Rows[i].Cells[0].FormattedValue.ToString();
string sCantSolicitada = dgvSolRecep.Rows[i].Cells[4].FormattedValue.ToString();
if (String.IsNullOrEmpty(sCantAceptada))
{
dgvSolRecep.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
ok = false;
msjError = "Cantidad vacía.\n";
}
else
{
int cantidadAceptada;
//verificar numero valido
if (!int.TryParse(sCantAceptada, out cantidadAceptada))
if(cantidadAceptada<0)
{
ok = false;
dgvSolRecep.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
msjError = "Número de cantidad no válido.\n";
}
else
{
int cantSolicitada; int.TryParse(sCantSolicitada, out cantSolicitada);
if (cantSolicitada < cantidadAceptada) //VALIDAR CANTIDAD ACEPTADA MENOR A SOLICITADA
{
ok = false;
dgvSolRecep.Rows[i].DefaultCellStyle.BackColor = Color.RosyBrown;
msjError = "Cantidad mayor a la cantidad Solicitada.\n";
}
else
{
SolicitudTransferenciaLinea auxSol = new SolicitudTransferenciaLinea();
TransferenciaLinea aux = new TransferenciaLinea();
int id; int.TryParse(sIdSolicitudLinea, out id);
auxSol = new SolicitudTransferenciaLineaBL().findSolicitudTransferenciaLineaxId(id);
aux.ArticuloXLocal = auxSol.ArticuloXLocal;
aux.CantidadArticulosAprob = cantidadAceptada;
if (cantSolicitada != cantidadAceptada) { nMod++; }
lineas.Add(aux);
}
}
}
}
if (ok)
{
//CREAR MOVIMIENTO
Movimiento mov = new Movimiento();
mov.Local = solicitud.LocalOrigen;
mov.Fecha = DateTime.Now.Date;
//CREAR TRANSFERENCIA
Transferencia Trans = new Transferencia();
Trans.LocalOrigen = solicitud.LocalOrigen;
Trans.LocalDestino = solicitud.LocalDestino;
Trans.Movimiento = solicitud.Movimiento;
Trans.NroMovimiento = mov;
Trans.NroSolicitudTransferencia = solicitud;
Trans.Estado = "Emitido";
Trans.FechaConfirmacion = DateTime.Now.Date;
//GRABAR MOVIMIENTO Y TRANSFERENCIA
new MovimientoBL().Grabar(mov);
new TransferenciaBL().Grabar(Trans);
new TransferenciaLineaBL().AsignarSolicitudesLineas(lineas, Trans);
//MODIFICAR SOLICITUD
if (nMod > 0)
solicitud.Estado = "Parcialmente Aceptado";
else
solicitud.Estado = "Aceptado";
new SolicitudTransferenciaBL().Grabar(solicitud);
Utils.Utils.OK(IND_MENSAJE);
this.Dispose();
}
else
Utils.Utils.Error(this, msjError);
}
private void btnAceptar_Click(object sender, EventArgs e)
{
bool ok= true;
/* Grabo movimiento */
Movimiento movEntrada = new Movimiento();
movEntrada.Local = this.local;
movEntrada.Fecha = System.DateTime.Now;
new MovimientoBL().Grabar(movEntrada);
/* Grabo nota de ingreso */
NotaIngresoSalida notaIngreso = new NotaIngresoSalida();
notaIngreso.Fecha = System.DateTime.Now;
notaIngreso.Local = this.local;
notaIngreso.NroMovimiento = movEntrada;
new NotaIngresoSalidaBL().Grabar(notaIngreso);
/* Grabo el detalle de la nota de ingreso y verifico incidencias */
List<NotaIngresoSalidaLinea> notaLineas = new List<NotaIngresoSalidaLinea>();
foreach (DataGridViewRow fila in dgvProductos.Rows)
{
NotaIngresoSalidaLinea notaIngresoLinea = new NotaIngresoSalidaLinea();
notaIngresoLinea.CodNota = notaIngreso;
int cantIngresada = 0;
if ((fila.Cells["cantIngresada"].Value!= null)&&(int.TryParse(fila.Cells["cantIngresada"].Value.ToString(), out cantIngresada)))
notaIngresoLinea.Cantidad = cantIngresada;
else
{
ok = false;
fila.Cells["cantIngresada"].Style.BackColor = Color.RosyBrown;
}
if ((notaIngresoLinea.CodAnaquel = (Anaquel)fila.Cells["cboAnaquel"].Value) == null)
{
ok = false;
fila.Cells["cboAnaquel"].Style.BackColor = Color.RosyBrown;
}
if (ok)
{
notaLineas.Add(notaIngresoLinea);
if (int.Parse(fila.Cells["cantPedida"].Value.ToString()) != int.Parse(fila.Cells["cantIngresada"].Value.ToString()))
{
//Ingresar incidencia
Incidencia incidencia = new Incidencia();
incidencia.DescripcionAdicional = "AUTO - Ingreso de articulos por "+ cboTipoMovimiento.Text + " inconsistente con documento nro. " + txtNroDocumento.Text;
incidencia.Estado = "CREADA";
incidencia.Fecha = DateTime.Today;
incidencia.Local = this.local;
incidencia.TipoIncidencia = "RECEPCION";
incidencia.NroMovimiento = movEntrada;
new IncidenciaBL().Grabar(incidencia);
}
}
}
if (ok)
{
/* Agregar el articulo por local a la lista */
int i = 0;
foreach (OrdenCompraLinea auxOCL in ordenCompra.OrdenCompraOrdenCompraLineafk)
{
ArticuloXLocal axl = new ArticuloXLocalBL().findArticuloXLocal(auxOCL.ArticuloXProveedor.Articulo.Id, local.Id);
if (axl != null) axl.Cantidad += notaLineas[i].Cantidad;
else
{
axl = new ArticuloXLocal();
axl.Local = this.local;
axl.Cantidad = notaLineas[i].Cantidad;
axl.Articulo = auxOCL.ArticuloXProveedor.Articulo;
}
new ArticuloXLocalBL().Actualizar(axl);
notaLineas[i].ArticuloXLocal = axl;
i++;
}
new NotaIngresoSalidaLineaBL().Grabar(notaLineas);
Utils.Utils.Mensaje("Se han registrado los productos ingresados", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.Dispose();
}
else Utils.Utils.Error(this, "Ha ocurrido un error en la grabación");
}
public ActionResult UploadFileInc(int id)
{
if (id == 0)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Incapacidade asegurado = db.Incapacidades.Find(id);
if (asegurado == null)
{
return HttpNotFound();
}
Movimiento movimiento = new Movimiento();
DateTime date = DateTime.Now;
movimiento.Asegurado = asegurado.Asegurado;
movimiento.aseguradoId = asegurado.Asegurado.id;
movimiento.acreditadoId = asegurado.id;
movimiento.fechaTransaccion = date;
movimiento.tipo = "I";
ViewBag.Asegurado = asegurado;
return View(movimiento);
}