public async Task <IActionResult> PutParada(int id, Parada parada)
{
if (id != parada.Id)
{
return(BadRequest());
}
_context.Entry(parada).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ParadaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Agrega una nueva parada en la BD
/// </summary>
/// <param name="idParada">Id de la parada</param>
/// <param name="nombre">Nombre de la parada</param>
/// <param name="lat">Latutud de la parada</param>
/// <param name="lon">Longitud</param>
/// <returns></returns>
public EParada addParada(string nombre, double lat, double lon)
{
try
{
using (uybusEntities db = new uybusEntities())
{
//Chequea si existe la parada. Sí ya existe no la crea
var paradas = db.Parada;
foreach (var p in paradas)
{
if (p.Nombre == nombre)
{
return(null);
}
}
Parada parada = new Parada();
parada.Nombre = nombre;
parada.Lat = lat;
parada.Long = lon;
db.Parada.Add(parada);
db.SaveChanges();
return(Converter.paradaAEParada(parada));
}
}
catch (Exception e)
{
Console.WriteLine("Error en DAL_Parada. Método: addParada " + e.Message);
throw e;
}
}
public async Task <IActionResult> Edit(int id, [Bind("IdParada,NombreParada,Borrado")] Parada parada)
{
if (id != parada.IdParada)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
parada.NombreNormalizado = parada.NombreParada.ToUpper();
_context.Update(parada);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ParadaExists(parada.IdParada))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(parada));
}
public Parada ModificarParada(Parada p)
{
try
{
if (p == null)
{
throw new Exception("La parada no puede ser NULL");
}
if (p.id <= 0)
{
throw new Exception("El ID de la parada no es valido");
}
if (p.nombre == null || p.nombre.Equals(""))
{
throw new Exception("El nombre no puede ser NULL ni vacio");
}
return(dal.ModificarParada(p));
}
catch (Exception e)
{
throw new Exception("Ocurrio un error al intentar registrar la parada. " + e.Message);
}
}
/*================================================================================
* GET PARADAS
*================================================================================*/
public static ObservableCollection <Parada> GetParadas(long IdItinerario)
{
// Creamos la lista y el comando que extrae los gráficos.
ObservableCollection <Parada> lista = new ObservableCollection <Parada>();
using (OleDbConnection conexion = new OleDbConnection(App.Global.CadenaConexionLineas))
{
string comandoSQL = "SELECT * FROM Paradas WHERE IdItinerario=? ORDER BY Orden";
OleDbCommand Comando = new OleDbCommand(comandoSQL, conexion);
Comando.Parameters.AddWithValue("iditinerario", IdItinerario);
OleDbDataReader lector = null;
// Ejecutamos el comando y extraemos los gráficos del lector a la lista.
try {
conexion.Open();
lector = Comando.ExecuteReader();
while (lector.Read())
{
Parada parada = new Parada(lector);
lista.Add(parada);
parada.Nuevo = false;
parada.Modificado = false;
}
} catch (Exception ex) {
Utils.VerError("BdParadas.GetParadas", ex);
} finally {
lector.Close();
}
}
return(lista);
}
public async Task <IActionResult> UpdateParada(int id, [FromBody] Parada body)
{
// Open a db connection
await Db.Connection.OpenAsync();
// Create a new parada
var query = new Parada(Db);
// Find the parada with the passed id and asign it to result
var result = await query.FindOne(id);
if (result is null)
{
return(new NotFoundResult());
}
// Update the properties
result.nombre = body.nombre;
result.descripcion = body.descripcion;
result.latitud = body.latitud;
result.longitud = body.longitud;
// Update the parada
await result.UpdateAsync();
// Return 200 ok with the updated object
return(new ObjectResult(result));
}
/// <summary>
/// Inicializamos Controles Movimiento en Vacio
/// </summary>
/// <param name="idCompania">Id Compania del Servicio</param>
/// <param name="idParadaActual">Id Parada Actual</param>
/// <param name="tipoActualizaionFin">Tipo de Actualización Fin de la Estancia (Manual, GPS, APP)</param>
public void InicializaControl(int idCompania, int idParadaActual, Parada.TipoActualizacionLlegada tipoActualizacionLlegada, Parada.TipoActualizacionSalida tipoActualizacionSalida, EstanciaUnidad.TipoActualizacionInicio tipoActuailizacionInicio,
EstanciaUnidad.TipoActualizacionFin tipoActualizaionFin)
{
//Asignamo Atributos
this._id_compania_emisor = idCompania;
this._id_tipo_actualizacion_fin = tipoActualizaionFin;
this._id_parada = idParadaActual;
this._id_ubicacion_origen = 0; //Se actualiza con el Id de Ubicación de la unidad principal del movimiento
//Instanciamos Parada
using (Parada objParada = new Parada(idParadaActual))
{
//Declaramos Variables para la Unidad por modificar ubicación
int id_unidad = 0;
//Asignando Atributos
this._id_servicio = objParada.id_servicio;
//Cargamos la Unidade que se asignarón a la Parada pero se encuentran en una ubicación distinta
MovimientoAsignacionRecurso.CargaRecursoAsignadoAParadaDifUbicacion(idParadaActual, objParada.id_ubicacion, out id_unidad, out this._id_ubicacion_origen);
//Instanciamos Unidad
using (SAT_CL.Global.Unidad objUnidad = new SAT_CL.Global.Unidad(id_unidad))
{
//Si existe unidad a mover
if (objUnidad.id_unidad > 0)
{
//Instanciamos Tipo de Unidad
using (SAT_CL.Global.UnidadTipo objUnidadTipo = new SAT_CL.Global.UnidadTipo(objUnidad.id_tipo_unidad))
{
//Cargamos Catalogos
cargaCatalogos(this._id_ubicacion_origen);
//Validamos Tipo de Unidad para Inicializar y habilitar Controles
if (objUnidadTipo.bit_motriz == true)
{
//Inicializamos Controles
inicializaValoresUnidad(objUnidad.id_unidad);
//Habilitamos Controles
habilitarControlesUnidad();
}
else
{
//Inicializamos Controles
inicializaValoresRemolque(objUnidad.id_unidad);
//Habilitamos Controles
habilitaControlesRemolque();
}
}
}
else
{
//Inicializamos Controles
inicializaValores();
//Habilitamos Controles
habilitarControles();
}
}
}
}
/// <summary>
/// Método Público encargado de Insertar nuevos Registros
/// </summary>
/// <param name="id_servicio_control_evidencia">Id Servicio Control Evidencia</param>
/// <param name="id_segmento">Id de segmento</param>
/// <param name="id_hoja_instruccion">Hoja Instrucción</param>
/// <param name="id_usuario">Id de Usuario</param>
/// <returns></returns>
public static RetornoOperacion InsertaSegmentoControlEvidencia(int id_servicio_control_evidencia, int id_segmento, int id_hoja_instruccion, int id_usuario)
{ //Declarando Objeto de Retorno
RetornoOperacion result = new RetornoOperacion();
//Si cuenta con una Hoja de Instruccón
if (id_hoja_instruccion != 0)
{
//Insertamos Segmento Control Evidencia
//Declarando Arreglo de Parametros del SP
object[] param = { 1, 0, id_servicio_control_evidencia, id_segmento, EstatusSegmentoControlEvidencias.No_Recibidos, id_hoja_instruccion,
id_usuario, true, "", "" };
//Obteniendo Resultado del SP
result = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(_nom_sp, param);
}
//Si no existe HI
else
{
//Instanciamos Segmento
using (SegmentoCarga objSegmento = new SegmentoCarga(id_segmento))
{
//Instanciamos Parada Inicio y Parada Fin
using (Parada objParadaInicio = new Parada(objSegmento.id_parada_inicio), objParadaFin = new Parada(objSegmento.id_parada_fin))
{
result = new RetornoOperacion("No se encontró la HI para el siguiente segmento: " + "(Remitente " + objParadaInicio.descripcion + " / Destinatario " + objParadaFin.descripcion + ")");
}
}
}
//Devolviendo resultado Obtenido
return(result);
}
/// <summary>
/// Realiza la inserción de un nuevo evento con el tipo predeterminado para una secuencia de paradas
/// </summary>
/// <returns></returns>
public RetornoOperacion NuevoEvento()
{
//Declaramos Mensaje
RetornoOperacion resultado = new RetornoOperacion();
//Validando que exista una parada para asociar evento
if (this._id_parada > 0)
{
//Instanciando parada
using (Parada parada = new Parada(this._id_parada))
//Editamos Parada
resultado = ParadaEvento.InsertaParadaEventoEnDespacho(parada.id_servicio, parada.id_parada, this._mit_eventos != null ? this._mit_eventos.Rows.Count : 0, ((Usuario)Session["usuario"]).id_usuario);
}
//Si no hay parada
else
{
resultado = new RetornoOperacion("No hay una parada a la cual asignar un nuevo evento.");
}
//Validamos Resultado final
if (resultado.OperacionExitosa)
{
//Borrando Id de Evento
this._id_evento = resultado.IdRegistro;
//Cargamos Eventos
cargaEventosParada();
//Cambiando vista a resumen
mtvEventosParada.SetActiveView(vwResumenEventos);
}
//Devolviendo resultado
return(resultado);
}
public async Task <ActionResult <Parada> > PostParada(Parada parada)
{
_context.Paradas.Add(parada);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetParada", new { id = parada.Id }, parada));
}
public static void asociarPasajesDestino(Parada p, ICollection <Pasaje> pd)
{
foreach (var item in pd)
{
item.parada_destino = p;
p.pasajes_destino.Add(item);
}
}
public static void asociarTramos(Parada p, ICollection <Tramo> t)
{
foreach (var item in t)
{
item.parada = p;
p.tramos.Add(item);
}
}
/** Vinculacion de colecciones ****************************************/
public static void asociarPasajesOrigen(Parada p, ICollection <Pasaje> po)
{
foreach (var item in po)
{
item.parada_origen = p;
p.pasajes_origen.Add(item);
}
}
public ActionResult DeleteConfirmed(int id)
{
Parada parada = db.Paradas.Find(id);
db.Paradas.Remove(parada);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void ValidacaoParada_CamposObrigatoriosNaoPreenchidos_Invalido()
{
var parada = new Parada {
};
var resultadoValidacao = validadorParada.Validate(parada);
Assert.False(resultadoValidacao.IsValid);
Assert.Equal(4, resultadoValidacao.Errors.Count);
}
/// <summary>
/// Terminamos Movimiento
/// </summary>
private void terminarMovimiento()
{
//Declarando objeto de resultado
RetornoOperacion resultado = new RetornoOperacion();
//inicializando transacción
using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Instanciando movimiento vacío
using (SAT_CL.Despacho.Movimiento mov = new Movimiento(Convert.ToInt32(gvMovimientos.SelectedDataKey["IdMovimiento"])))
{
//Si el movimiento se recuperó
if (mov.id_movimiento > 0)
{
//Instanciando parada de origen
using (SAT_CL.Despacho.Parada origen = new Parada(mov.id_parada_origen))
{
//Validamos fecha de salida de origen vs fecha llegada a destino
if (Convert.ToDateTime(txtFechaTerminar.Text).CompareTo(origen.fecha_salida) > 0)
{
//Terminamos Movimiento
resultado = mov.TerminaMovimientoVacio(chkFechaActual.Checked ? TSDK.Base.Fecha.ObtieneFechaEstandarMexicoCentro() : Convert.ToDateTime(txtFechaTerminar.Text), EstanciaUnidad.TipoActualizacionInicio.Manual, ((Usuario)Session["usuario"]).id_usuario);
}
else
{
resultado = new RetornoOperacion(string.Format("La Llegada al Destino '{0:dd/MM/yyyy HH:mm}' debe ser Mayor a la Salida del Origen '{1:dd/MM/yyyy HH:mm}'", Convert.ToDateTime(txtFechaTerminar.Text), origen.fecha_salida));
}
}
}
//Si no hay movimiento
else
{
resultado = new RetornoOperacion(string.Format("Movimiento '{0}' no encontrado.", gvMovimientos.SelectedDataKey["IdMovimiento"]));
}
}
//Finalizando transacción
if (resultado.OperacionExitosa)
{
scope.Complete();
}
}
//Validamos Resultado final
if (resultado.OperacionExitosa)
{
//Cargamos Movimientos
cargaMovimientosVacio();
//Registrando el script sólo para los paneles que producirán actualización del mismo
ScriptServer.AlternarVentana(btnAceptarTerminarMovimiento, btnAceptarTerminarMovimiento.GetType(), "CierreVentanaModal", "contenidoFechaTerminarMovimiento", "confirmacionFechaTerminarMovimiento");
}
//Mostrando resultado
ScriptServer.MuestraNotificacion(btnAceptarTerminarMovimiento, resultado, ScriptServer.PosicionNotificacion.AbajoDerecha);
}
//
// GET: /Paradas/Details/5
public ActionResult Details(int id = 0)
{
Parada parada = db.Paradas.Find(id);
if (parada == null)
{
return(HttpNotFound());
}
return(View(parada));
}
public Parada RegistrarParada([FromBody] Parada p)
{
try
{
return(bla.RegistrarParada(p));
}
catch (Exception e)
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e.Message));
}
}
public ActionResult Create([Bind(Include = "CodigoIdentificador,ExpectativaId,Data,MateriaPrima," +
"MPLote,MPConsumo,ProdIncio,ProdFim,Maquina,Produto,ProdutoCor,MasterLote,Fornecedor,TempAgua," +
"NivelOleo,Galho,OffSpec,RefugoKg,UnidadesProduzidas,ContadorInicial,ContadorFinal")] OrdemProducaoPeca ordemProducaoPeca)
{
var a = Request.Form["Parada.HoraParada"];
var b = Request.Form["Parada.HoraRetorno"];
var c = Request.Form["Parada.Motivo"];
var d = Request.Form["Parada.Observacoes"];
if (ModelState.IsValid)
{
string[] hrP = a.Split(',').ToArray();
string[] hrR = b.Split(',').ToArray();
string[] mot = c.Split(',').ToArray();
string[] obs = d.Split(',').ToArray();
List <Parada> parada = new List <Parada>();
for (int x = 0; x < hrP.Count(); x++)
{
Parada p = new Parada();
p.HoraParada = hrP[x];
p.HoraRetorno = hrR[x];
p.Motivo = mot[x];
p.Observacoes = obs[x];
parada.Add(p);
}
ordemProducaoPeca.Paradas = parada;
var qtdOp = 0;
var mesAnterior = 0;
if (db.OrdemProducaoPecas.ToList().Count() > 0)
{
qtdOp = db.OrdemProducaoPecas.ToList().Last().OPnoMes;
mesAnterior = db.OrdemProducaoPecas.ToList().Last().Data.Month;
}
if (mesAnterior != ordemProducaoPeca.Data.Month)
{
ordemProducaoPeca.OPnoMes = 1;
}
else
{
ordemProducaoPeca.OPnoMes = qtdOp + 1;
}
ordemProducaoPeca.Expectativa = db.Expectativas.Find(ordemProducaoPeca.ExpectativaId);
//db.Entry(ordemProducaoPeca).Reference(f => f.Expectativa).Load();
ordemProducaoPeca.ConfiguracaoInicial();
db.OrdemProducaoPecas.Add(ordemProducaoPeca);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ExpectativaId = new SelectList(db.Expectativas, "ExpectativaId", "Produto", ordemProducaoPeca.ExpectativaId);
return(View(ordemProducaoPeca));
}
public ActionResult Edit(Parada parada)
{
if (ModelState.IsValid)
{
db.Entry(parada).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Id_Ruta = new SelectList(db.Rutas, "Id", "Nombre", parada.Id_Ruta);
return(View(parada));
}
//
// GET: /Paradas/Edit/5
public ActionResult Edit(int id = 0)
{
Parada parada = db.Paradas.Find(id);
if (parada == null)
{
return(HttpNotFound());
}
ViewBag.Id_Ruta = new SelectList(db.Rutas, "Id", "Nombre", parada.Id_Ruta);
return(View(parada));
}
public ActionResult Edit([Bind(Include = "ParadaId,HoraParada,HoraRetorno,Motivo,Observacoes,OrdemProducaoPecaId")] Parada parada)
{
if (ModelState.IsValid)
{
db.Entry(parada).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.OrdemProducaoPecaId = new SelectList(db.OrdemProducaoPecas, "CodigoIdentificador", "MateriaPrima", parada.OrdemProducaoPecaId);
return(View(parada));
}
public ActionResult Create(Parada parada)
{
if (ModelState.IsValid)
{
db.Paradas.Add(parada);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Id_Ruta = new SelectList(db.Rutas, "Id", "Nombre", parada.Id_Ruta);
return(View(parada));
}
public async Task <IActionResult> Create([Bind("IdParada,NombreParada,Borrado")] Parada parada)
{
if (ModelState.IsValid)
{
parada.NombreNormalizado = parada.NombreParada.ToUpper();
_context.Add(parada);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(parada));
}
public static Viagem converterParaViagem(ColetaDTO coleta)
{
Viagem viagemColeta = new Viagem()
{
TipoViagem = "Coleta",
Veiculo = new Veiculo()
{
Placa = coleta.Placa
},
Paradas = new List <Parada>(),
DataHoraPartida = DateTime.Parse(coleta.DataPartida + " " + coleta.HoraPartida, CultureInfo.CreateSpecificCulture("pt-BR")),
DataHoraRetornoPrevisto = DateTime.Parse(coleta.DataRetornoEstimada + " " + coleta.HoraRetornoEstimada, CultureInfo.CreateSpecificCulture("pt-BR")),
DistanciaTotal = coleta.Roteiro.Distancia
};
int ordem = 1;
foreach (var paradaColeta in coleta.Roteiro.Paradas)
{
Parada paradaViagem = new Parada()
{
Endereco = paradaColeta.Endereco,
Cep = paradaColeta.Cep,
Municipio = new Municipio()
{
Codigo = paradaColeta.CodigoMunicipio
},
DataHoraChegadaPrevista = DateTime.Parse(paradaColeta.HorarioChegada, CultureInfo.CreateSpecificCulture("pt-BR")),
DistanciaTrecho = paradaColeta.Distancia,
Ordem = ordem,
Itens = new List <ItemTransporte>()
};
foreach (var item in coleta.Itens)
{
if (item.Endereco == paradaViagem.Endereco)
{
paradaViagem.Itens.Add(new ItemTransporte()
{
Codigo = item.Codigo
});
}
}
viagemColeta.Paradas.Add(paradaViagem);
ordem++;
}
return(viagemColeta);
}
/// <summary>
/// Realizando carga de paradas del servicio solicitado
/// </summary>
private void cargaParadasServicio()
{
//Inicializando indices
Controles.InicializaIndices(gvParadasServicio);
//Cargando conjunto de paradas asociadas al servicio indicado
using (DataTable mit = Parada.CargaParadasParaVisualizacion(this._id_servicio))
{
//Cargando gridview
Controles.CargaGridView(gvParadasServicio, mit, "Id", "", true, 2);
//Guardando origen de datos
this._mitParadasServicio = mit;
}
}
public async Task <IActionResult> CreateParada([FromBody] Parada body)
{
// Open a database connection
await Db.Connection.OpenAsync();
// Pass in the database instance
body.Db = Db;
// Call the Insert method async
await body.InsertAsync();
// Return 200 Ok with the created object
return(new OkObjectResult(body));
// Look into populating the relationship table from here
}
/// <summary>
/// Método encargado de Deshabilitar un Movimiento Vacio Iniciado
/// </summary>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion DeshabilitaMovimientoVacioIniciado(int id_usuario)
{
//Declaramos objeto Resultado
RetornoOperacion resultado = new RetornoOperacion();
//Iniciando transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Validamos que el estatus actual del movimiento sea Iniciado
if (this.EstatusMovimiento == Estatus.Iniciado)
{
//Validamos que no existan pagos ligados al movimeinto
resultado = validaPagos();
//Validamos que no existan Pagos
if (resultado.OperacionExitosa)
{
//Cargamos Estancias ligadas a un Id Movimiento en Estatus Iniciado
using (DataTable mitEstanciasOrigen = EstanciaUnidad.CargaEstanciasTerminadasParada(this._id_parada_origen))
{
//Reversa Inicio de Moimiento
resultado = ReversaInicioMovimietoVacio(mitEstanciasOrigen, MovimientoAsignacionRecurso.Estatus.Iniciado, id_usuario);
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Instanciamos Parada Destino
using (Parada objParadaDestino = new Parada(this._id_parada_destino))
{
//Deshabilitamos Parada Destino
resultado = objParadaDestino.DeshabilitaParada(id_usuario);
}
}
}
}
else
{
//Establecemos Mensaje
resultado = new RetornoOperacion("El estatus del movimiento no permite su edición.");
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
scope.Complete();
}
}
//Devolvemos Valor Retorno
return(resultado);
}
// GET: Paradas/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Parada parada = db.Paradas.Find(id);
if (parada == null)
{
return(HttpNotFound());
}
return(View(parada));
}
public void ValidacaoParada_CamposObrigatoriosPreenchidos_Valido()
{
var parada = new Parada
{
Data = DateTime.Now,
IdentificadorProcesso = Guid.NewGuid(),
Descricao = "Parada de teste",
Turno = Turno.Manha
};
var resultadoValidacao = validadorParada.Validate(parada);
Assert.True(resultadoValidacao.IsValid);
}
public void agregarParada(Estaciones nodo, bool para)
{
Parada parada = new Parada();
parada.nodo = nodo;
parada.para = para;
_paradas.Add(parada);
}