/*================================================================================
* GET ITINERARIOS
*================================================================================*/
public static ObservableCollection <Itinerario> GetItinerarios(long IdLinea)
{
// Creamos la lista.
ObservableCollection <Itinerario> lista = new ObservableCollection <Itinerario>();
using (OleDbConnection conexion = new OleDbConnection(App.Global.CadenaConexionLineas))
{
string comandoSQL = "SELECT * FROM Itinerarios WHERE IdLinea=? ORDER BY Nombre";
OleDbCommand Comando = new OleDbCommand(comandoSQL, conexion);
Comando.Parameters.AddWithValue("idlinea", IdLinea);
OleDbDataReader lector = null;
try {
conexion.Open();
// Ejecutamos el comando y extraemos los gráficos del lector a la lista.
lector = Comando.ExecuteReader();
while (lector.Read())
{
Itinerario itinerario = new Itinerario(lector);
itinerario.ListaParadas = BdParadas.GetParadas(itinerario.Id);
lista.Add(itinerario);
itinerario.Nuevo = false;
itinerario.Modificado = false;
}
} catch (Exception ex) {
Utils.VerError("BdItinerarios.GetItinerarios", ex);
} finally {
lector.Close();
}
}
return(lista);
}
/*================================================================================
* GET ITINERARIO BY NOMBRE
*================================================================================*/
public static Itinerario GetItinerarioByNombre(decimal nombre)
{
Itinerario itinerario = null;
using (OleDbConnection conexion = new OleDbConnection(App.Global.CadenaConexionLineas))
{
// Creamos el comando que extrae el itinerario
string comandoSQL = "SELECT * FROM Itinerarios WHERE Nombre = ?";
OleDbCommand Comando = new OleDbCommand(comandoSQL, conexion);
Comando.Parameters.AddWithValue("nombre", nombre.ToString());
OleDbDataReader lector = null;
try {
conexion.Open();
lector = Comando.ExecuteReader();
if (lector.Read())
{
itinerario = new Itinerario(lector);
itinerario.ListaParadas = BdParadas.GetParadas(itinerario.Id);
}
} catch (Exception ex) {
Utils.VerError("BdItinerarios.GetItinerarioByNombre", ex);
} finally {
lector.Close();
}
}
return(itinerario);
}
private Pais CurrentPaisItinerario(Itinerario itinerario, IEnumerable <Visa> visas_usuario)
{
bool change = false;
foreach (var viaje in itinerario.Viajes)
{
change = false;
var visas = GetVisasPais(viaje.Pais);
if (visas.Count() != 0)
{
foreach (var visa in visas)
{
if (visas_usuario.Contains(visa))
{
change = true;
break;
}
}
if (change)
{
continue;
}
return(viaje.Pais);
}
else
{
continue;
}
}
return(null);
}
public async Task <CommandResult> Handle(AdicionarItinerarioCommand request, CancellationToken cancellationToken)
{
var motorista = await _motoristaRepository.ObterPorId(request.MotoristaId);
if (motorista == null)
{
AddNotification("Motorista", "Motorista não encontrado.");
}
var veiculo = await _veiculoRepository.ObterPorId(request.VeiculoId);
if (veiculo == null)
{
AddNotification("Veículo", "Veículo não encontrado.");
}
var itinerario = new Itinerario(motorista, veiculo);
await _itinerarioRepository.AddAsync(itinerario);
GerarEntregasNoItinerario(request.Entregas, itinerario);
HandleEntity(itinerario);
if (!IsSuccess())
{
return(new CommandResult(false, "Existem notificações"));
}
await CommitAsync();
return(new CommandResult(true, "Executado sem notificações", new { }));
}
public void QuandoAtualizoUmaCotacaoDeFreteAsPropriedadesSaoAlteradas()
{
ProcessoDeCotacaoDeFrete processo = DefaultObjects.ObtemProcessoDeCotacaoDeFrete();
Produto produto = DefaultObjects.ObtemProdutoPadrao();
UnidadeDeMedida unidadeDeMedida = DefaultObjects.ObtemUnidadeDeMedidaPadrao();
Itinerario itinerario = DefaultObjects.ObtemItinerarioPadrao();
var dataLimiteDeRetorno = DateTime.Today.AddDays(15);
var dataValidadeInicial = DateTime.Today.AddMonths(2);
var dataValidadeFinal = DateTime.Today.AddMonths(3);
processo.Atualizar("requisitos alterados", "1500", dataLimiteDeRetorno,
dataValidadeInicial, dataValidadeFinal, itinerario);
processo.AtualizarItem(produto, 1500, unidadeDeMedida);
var item = processo.Itens.First();
//Assert.AreSame(produto, processo.Produto);
//Assert.AreEqual(1500, processo.Quantidade);
//Assert.AreSame(unidadeDeMedida, processo.UnidadeDeMedida);
Assert.AreSame(produto, item.Produto);
Assert.AreEqual(1500, item.Quantidade);
Assert.AreSame(unidadeDeMedida, item.UnidadeDeMedida);
Assert.AreEqual("requisitos alterados", processo.Requisitos);
Assert.AreEqual("1500", processo.NumeroDoContrato);
Assert.AreEqual(dataLimiteDeRetorno, processo.DataLimiteDeRetorno);
Assert.AreEqual(dataValidadeInicial, processo.DataDeValidadeInicial);
Assert.AreEqual(dataValidadeFinal, processo.DataDeValidadeFinal);
Assert.AreSame(itinerario, processo.Itinerario);
}
public async Task <IActionResult> PutItinerario(int id, Itinerario itinerario)
{
if (id != itinerario.Id)
{
return(BadRequest());
}
_context.Entry(itinerario).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ItinerarioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <Itinerario> > PostItinerario(Itinerario itinerario)
{
_context.Itinerarios.Add(itinerario);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetItinerario", new { id = itinerario.Id }, itinerario));
}
public async Task <IHttpActionResult> PostItinerario(Itinerario itinerario)
{
if (itinerario == null)
{
return(BadRequest("El modelo esta vacio"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
DetalleItinerario detalles = new DetalleItinerario();
try
{
detalles.Salida = DateTime.Now;
db.DetallesItinerarios.Add(detalles);
await db.SaveChangesAsync();
}
catch (Exception e) {
var a = e.Message;
}
itinerario.DetalleItinerarioId = detalles.Id;
db.Itinerarios.Add(itinerario);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = itinerario.Id }, itinerario));
}
public List <Entidad> ConsultarItinerarios(int id_usuario)
{
try
{
comando = FabricaComando.CrearComandoConsultarItinerarios(id_usuario);
comando.Ejecutar();
List <Itinerario> listaItinerarios = new List <Itinerario>();
foreach (Entidad item in comando.RetornarLista())
{
Itinerario itinerarioNew = (Itinerario)item;
listaItinerarios.Add(itinerarioNew);
}
return(comando.RetornarLista());
}
catch (NpgsqlException)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
catch (ArgumentException)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
catch (InvalidCastException)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.Ambiguous);
}
}
public async Task <ActionResult> AddorEdit(int id = 0)
{
IEnumerable <Repartidor> repartidores;
repartidores = await repartidoresService.obtenerRepartidores();
IEnumerable <Zona> zonas;
zonas = await zonasService.obtenerZonas();
//IEnumerable<DetalleItinerario> detalles;
//detalles = await detallesService.obtenerDetalleItinerarios();
ViewBag.RepartidoresListItems = repartidores.ToList();
ViewBag.ZonasListItems = zonas.ToList();
if (id == 0)
{
return(View(new Itinerario()));
}
else
{
Itinerario itinerario = await itinerariosService.obtenerItinerario(id);
return(View(itinerario));
}
}
/// <summary>
/// Metodo encargado de actualizar los datos de un itinerario
/// </summary>
/// <param name="objeto">Metodo que contiene el id del itinerario y los datos nuevos</param>
public override void Actualizar(Entidad objeto)
{
try
{
Itinerario itinerario = (Itinerario)objeto;
base.Conectar();
comando = new NpgsqlCommand("mod_itinerario", base.SqlConexion);
comando.CommandType = CommandType.StoredProcedure;
comando.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Integer, itinerario.Id);
comando.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Varchar, itinerario.Nombre);
comando.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Date, itinerario.FechaInicio);
comando.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Date, itinerario.FechaFin);
comando.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Integer, itinerario.IdUsuario);
respuesta = comando.ExecuteReader();
respuesta.Read();
base.Desconectar();
}
catch (NpgsqlException e)
{
base.Desconectar();
throw e;
}
catch (InvalidCastException e)
{
base.Desconectar();
throw e;
}
catch (Exception e)
{
base.Desconectar();
throw e;
}
}
private void agregarAsignacionRecorrido(Itinerario itinerario)
{
objControladorItinerario = new ControladorItinerario();
List <Itinerario> itinerariosRegistrados = objControladorItinerario.traerItinerario();
Boolean validarDiaChofer = objControladorItinerario.validarDiadelViajeChofer(itinerariosRegistrados, itinerario);
Boolean validarDiaOmnibus = objControladorItinerario.validarDiadeReservaOmnibus(itinerariosRegistrados, itinerario);
if (validarDiaChofer == true && validarDiaOmnibus == true)
{
objControladorItinerario.agregarItinerario(itinerario);
Console.WriteLine("La Asignacion del Recorrido fue Dado de Alta Correctamente.");
}
else if (validarDiaChofer == false && validarDiaOmnibus == true)
{
Console.WriteLine("El Chofer ya Realiza un Viaje ese Dia.");
}
else if (validarDiaChofer == true && validarDiaOmnibus == false)
{
Console.WriteLine("El Omnibus ya esta Reservado ese Dia.");
}
else
{
Console.WriteLine("El Chofer y el Omnibus no estan Disponible para ese Dia.");
}
presioneTeclaParaContinuar();
}
private void GerarEntregasNoItinerario(List <EntregaCommand> entregas, Itinerario itinerario)
{
foreach (var item in entregas)
{
itinerario.AdicionarEntrega(item.Destinatario.Nome, item.Destinatario.Endereco, DateTime.Now);
}
}
public Itinerario UpdateItinerario(Itinerario entity, Itinerario toUpd)
{
var itinerario = _itinerarioDbAccess.Update(entity, toUpd);
_context.Commit();
return(itinerario);
}
public async Task <IActionResult> Edit(DateTime id, [Bind("HuespedId,FechaRecogida,CantidasDeDias,Jefe,Recorrido,Resumen")] Itinerario itinerario)
{
if (id != itinerario.FechaRecogida)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(itinerario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ItinerarioExists(itinerario.FechaRecogida))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["HuespedId"] = new SelectList(_context.Huesped, "HuespedId", "Nombre", itinerario.HuespedId);
return(View(itinerario));
}
public List <Itinerario> traerItinerario()
{
SqlConnection objConexion = new SqlConnection(ConexionSQLServer.getConexion());
DataTable objTablaDatos = new DataTable();
List <Itinerario> recorridosAsignados = new List <Itinerario>();
SqlCommand objComando = new SqlCommand();
objComando.Connection = objConexion;
objComando.CommandText = "SELECT * FROM ITINERARIO";
objComando.CommandType = CommandType.Text;
objConexion.Open();
SqlDataReader objReader = objComando.ExecuteReader();
objTablaDatos.Load(objReader);
objConexion.Close();
foreach (DataRow recorridoAsignado in objTablaDatos.Rows)
{
Itinerario objRecorridoAsignado = new Itinerario();
objRecorridoAsignado.IdItinerario = Convert.ToInt32(recorridoAsignado["ID"]);
objRecorridoAsignado.IdChofer = Convert.ToInt32(recorridoAsignado["ID_CHOFER"]);
objRecorridoAsignado.IdOmnibus = Convert.ToInt32(recorridoAsignado["ID_OMNIBUS"]);
objRecorridoAsignado.IdRecorrido = Convert.ToInt32(recorridoAsignado["ID_RECORRIDO"]);
objRecorridoAsignado.IdDia = Convert.ToInt32(recorridoAsignado["ID_DIA"]);
recorridosAsignados.Add(objRecorridoAsignado);
}
return(recorridosAsignados);
}
public ActionResult RegistrarItinerario(HttpPostedFileBase fileUpload, HttpPostedFileBase fileUpload2, HttpPostedFileBase fileUpload3, string dia, string desayuno, string almuerzo, string cena)
{
try
{
string path = Server.MapPath("~/Content/img/");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
fileUpload.SaveAs(path + Path.GetFileName(fileUpload.FileName));
fileUpload2.SaveAs(path + Path.GetFileName(fileUpload2.FileName));
fileUpload3.SaveAs(path + Path.GetFileName(fileUpload3.FileName));
ENTIDAD.Itinerario galeria = new Itinerario();
galeria.dia = dia;
galeria.desayuno = desayuno;
galeria.almuerzo = almuerzo;
galeria.cena = cena;
galeria.imgUrlDesayuno = "\\Content\\img\\" + fileUpload.FileName;
galeria.imgUrlAlmuerzo = "\\Content\\img\\" + fileUpload2.FileName;
galeria.imgUrlCena = "\\Content\\img\\" + fileUpload3.FileName;
itinerario.registrarItinerario(galeria);
return(View("ItinerarioAdm", itinerario.listadoItinerario2()));
}
catch (Exception e)
{
return(Json(new { Value = false, Message = "Error" + e.Message }, JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// Elimina el itinerario con el id
/// </summary>
/// <param name="objeto">objeto con el id del itinerario</param>
public override void Eliminar(Entidad objeto)
{
try
{
Itinerario itinerario = (Itinerario)objeto;
base.Conectar();
comando = new NpgsqlCommand("del_itinerario", base.SqlConexion);
comando.CommandType = CommandType.StoredProcedure;
comando.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Integer, itinerario.Id);
respuesta = comando.ExecuteReader();
respuesta.Read();
Boolean resp = respuesta.GetBoolean(0);
base.Desconectar();
//return resp;
}
catch (NpgsqlException e)
{
base.Desconectar();
throw e;
}
catch (Exception e)
{
base.Desconectar();
throw e;
}
}
public Itinerario AgregarItinerario(Itinerario it)
{
try
{
comando = FabricaComando.CrearComandoAgregarItinerario(it.IdUsuario, it.Nombre);
comando.Ejecutar();
Itinerario itNew = (Itinerario)comando.Retornar();
return(itNew);
}
catch (NpgsqlException e)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
catch (InvalidCastException)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
catch (NullReferenceException)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.Ambiguous);
}
}
public ActionResult CargarIti(Itinerario itiner)
{
if (Session["listitinerarios"] != null)
{
listitinerarios = (List <Itinerario>)Session["listitinerarios"];
}
else
{
listitinerarios = new List <Itinerario>();
}
Itinerario itiadd = new Itinerario();
// iter.itinerarios= new List<Itinerario>();
itiadd = new Itinerario {
origen = itiner.origen, destino = itiner.destino, fechaServicio = itiner.fechaServicio, horaSalida = itiner.horaSalida, tipoAccion = itiner.tipoAccion, cantidad = itiner.cantidad
};
listitinerarios.Add(itiadd);
//return RedirectToAction("Index", "SolicitudProgramacion");
ViewData["listitinerarios"] = listitinerarios;
Session["listitinerarios"] = listitinerarios;
// if (Request.IsAjaxRequest())
return(PartialView());
// else return View();
}
public void QuandoCrioUmProcessoDeCotacaoDeFreteAsPropriedadesFicamCorretas()
{
Produto produto = DefaultObjects.ObtemProdutoPadrao();
UnidadeDeMedida unidadeDeMedida = DefaultObjects.ObtemUnidadeDeMedidaPadrao();
Itinerario itinerario = DefaultObjects.ObtemItinerarioPadrao();
var dataLimiteDeRetorno = DateTime.Today.AddDays(10);
var dataValidadeInicial = DateTime.Today.AddMonths(1);
var dataValidadeFinal = DateTime.Today.AddMonths(2);
var processo = new ProcessoDeCotacaoDeFrete("Requisitos do Processo de Cotação de Fretes",
"10001", dataLimiteDeRetorno, dataValidadeInicial, dataValidadeFinal, itinerario);
processo.AdicionarItem(produto, 100, unidadeDeMedida);
var item = processo.Itens.First();
//Assert.AreSame(produto, processo.Produto);
//Assert.AreEqual(100, processo.Quantidade);
//Assert.AreSame(unidadeDeMedida, processo.UnidadeDeMedida);
Assert.AreSame(produto, item.Produto);
Assert.AreEqual(100, item.Quantidade);
Assert.AreSame(unidadeDeMedida, item.UnidadeDeMedida);
Assert.AreEqual("Requisitos do Processo de Cotação de Fretes", processo.Requisitos);
Assert.AreEqual("10001", processo.NumeroDoContrato);
Assert.AreEqual(dataLimiteDeRetorno, processo.DataLimiteDeRetorno);
Assert.AreEqual(dataValidadeInicial, processo.DataDeValidadeInicial);
Assert.AreEqual(dataValidadeFinal, processo.DataDeValidadeFinal);
Assert.AreSame(itinerario, processo.Itinerario);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Codigo,Duracion,Visitantes,Longitud")] Itinerario itinerario)
{
if (id != itinerario.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(itinerario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ItinerarioExists(itinerario.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(itinerario));
}
private void cmd_Buscar_Click(object sender, EventArgs e)
{
List <Escala> escalas = new List <Escala>();
if (this.cmb_itinerarios.SelectedIndex != -1 && !this.chk_todos.Checked)
{
List <Itinerario> itinerarios = new List <Itinerario>();
int id = Convert.ToInt32(this.cmb_itinerarios.SelectedValue);
Itinerario itinerario = itinerarioService.GetById(id);
escalas = escalaService.getAllEscalasDeUnItinerario(id);
itinerarios.Add(itinerario);
cargar_grillaItinerarios(itinerarios);
cargar_grillaEscalas(escalas);
}
else
{
if (this.chk_todos.Checked)
{
int id = Convert.ToInt32(this.cmb_itinerarios.SelectedValue);
List <Itinerario> itinerariosList = itinerarioService.GetAll();
cargar_grillaItinerarios(itinerariosList);
}
else
{
MessageBox.Show("No ha ingresado ningún dato para realizar la búsqueda", "Mensaje", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
}
/// <summary>
/// Metodo utilizados para casos borde(excepciones) de AgregarItinerario
/// </summary>
public void Excepcion_Agregar2()
{
itinerario = new Itinerario("Michel", 0);
Comando comando = FabricaComando.CrearComandoAgregarItinerario(itinerario.Id, itinerario.Nombre);
comando.Ejecutar();
}
public Itinerario mapeoItinerario(DataRow row)
{
Itinerario oItinerario = new Itinerario();
oItinerario.Codigo = Convert.ToInt32(row["cod_intinerarios"].ToString());
oItinerario.Descripcion = row["descripcion"].ToString();
return(oItinerario);
}
public Boolean SetVisible(int idusuario, int iditinerario, Boolean visible)
{
comando = FabricaComando.CrearComandoSetVisibleItinerario(visible, idusuario, iditinerario);
comando.Ejecutar();
Itinerario itinerario = (Itinerario)comando.Retornar();
return(itinerario.Visible);
}
internal Itinerario GenerarNuevoItinerarioConCambios(int semilla)
{
Itinerario clonadoBase = ItinerarioBase.Clonar(semilla);
clonadoBase.AplicarCambiosEnTiemposProgramados(_tramos_por_avion);
return(clonadoBase);
}
public ComandoSetVisibleItinerario(int idItinerario, int idUsuario,
Boolean visible)
{
itinerario = FabricaEntidad.CrearEntidadItinerario();
itinerario.Id = idItinerario;
itinerario.IdUsuario = idUsuario;
this.visible = visible;
}
/// <summary>
/// Constructor de objeto controlador de información
/// </summary>
/// <param name="itin"> Itinerario analizado</param>
/// <param name="parametros">Objeto de parámetros de la simulación</param>
/// <param name="disrupciones">Objeto de modelo de disrupciones</param>
public ControladorInformacion(Itinerario itin, ParametrosSimuLAN parametros, ModeloDisrupciones disrupciones)
{
this._itinerario = itin;
this._parametros = parametros;
this._modelo_disrupciones = disrupciones;
this._faltas = new Dictionary <TipoFaltaInformacion, List <Falta> >();
CargarTiposFalta();
}
/// <summary>
/// Constructr de la clase
/// </summary>
/// <param name="idUsuario">id del usuario</param>
/// <param name="nombreItinerario">Nombre del nuevo itinerario</param>
public ComandoAgregarItinerario(int idUsuario, string nombreItinerario)
{
itinerario = FabricaEntidad.CrearEntidadItinerario();
usuario = FabricaEntidad.CrearEntidadUsuario();
usuario.Id = idUsuario;
itinerario.Nombre = nombreItinerario;
itinerario.IdUsuario = idUsuario;
}
