private void BtnGuardar_Click(object sender, EventArgs e)
{
if (ValidarGrilla())
{
try
{
foreach (DataGridViewRow row in dgvViajes.Rows)
{
GridItem gridItem = row.DataBoundItem as GridItem;
ViajeBE viaje = gridItem.Viaje;
viaje.Completado = row.Cells["colCompletado"].Value != null && (bool)row.Cells["colCompletado"].Value;
if (row.Cells["colHoraRealLlegada"].Value != null)
{
viaje.HoraRealLlegada = new DateTime() + TimeSpan.Parse(row.Cells["colHoraRealLlegada"].Value.ToString());
}
if (row.Cells["colDensidadPasajeros"].Value != null)
{
viaje.Completitud = completitudes.FirstOrDefault(c => c.Value == row.Cells["colDensidadPasajeros"].Value.ToString()).Key;
}
}
PlanillaHoraria.GuardarViajes(planillaHoraria);
MessageBox.Show(ObtenerLeyenda("msgPlanillaActualizada"));
}
catch
{
MostrarError();
}
}
}
private static void Actualizar(ViajeBE viaje)
{
string query = "UPDATE viaje SET hora_real_llegada = @horaRealLlegada, completado = @completado, " +
"completitud_id = @idCompletitud WHERE id = @id";
SqlParameter[] parameters = new SqlParameter[]
{
new SqlParameter("@horaRealLlegada", viaje.HoraRealLlegada.HasValue ? (object)viaje.HoraRealLlegada.Value.TimeOfDay : DBNull.Value),
new SqlParameter("@completado", (object)viaje.Completado ?? DBNull.Value),
new SqlParameter("@idCompletitud", viaje.Completitud > 0 ? (object)(int)viaje.Completitud : DBNull.Value),
new SqlParameter("@id", viaje.Id)
};
SqlHelper.Ejecutar(query, parameters);
}
private static void Insertar(ViajeBE viaje, int planillaHorariaId)
{
string query = "INSERT INTO viaje (planilla_horaria_id, es_ida, hora_salida, hora_estimada_llegada, dvh) " +
"OUTPUT INSERTED.id VALUES (@planillaHorariaId, @esIda, @horaSalida, @horaEstimadaLlegada, 0)";
SqlParameter[] parameters = new SqlParameter[]
{
new SqlParameter("@planillaHorariaId", planillaHorariaId),
new SqlParameter("@esIda", viaje.EsIda),
new SqlParameter("@horaSalida", viaje.HoraSalida.TimeOfDay),
new SqlParameter("@horaEstimadaLlegada", viaje.HoraEstimadaLlegada.TimeOfDay)
};
viaje.Id = SqlHelper.Insertar(query, parameters);
}
public static void Guardar(ViajeBE viaje, int planillaHorariaId)
{
if (viaje.Id > 0)
{
Actualizar(viaje);
}
else
{
Insertar(viaje, planillaHorariaId);
}
int dvh = DigitoVerificadorDAL.CalcularDV(ObtenerRegistroDVH(viaje, planillaHorariaId));
DigitoVerificadorDAL.ActualizarDVH("viaje", dvh, viaje.Id);
}
private static string ObtenerRegistroDVH(ViajeBE viaje, int planillaHorariaId)
{
return(string.Format("{0}{1}{2}{3}{4}{5}{6}{7}", viaje.Id, planillaHorariaId, viaje.EsIda,
viaje.HoraSalida.TimeOfDay.ToString(), viaje.HoraEstimadaLlegada.TimeOfDay.ToString(),
viaje.HoraRealLlegada?.TimeOfDay.ToString(), viaje.Completado, (int)viaje.Completitud));
}
public static void Guardar(ViajeBE viaje, PlanillaHorariaBE planillaHoraria)
{
ViajeDAL.Guardar(viaje, planillaHoraria.Id);
}
private void GenerarViajesYPlanillas(CalculoDeRecorrido calcRecorrido)
{
// Una vez que termino con el cálculo de cada intervalo genero viajes
// El primer viaje del día es a las 4 AM
DateTime inicioProximoViaje = new DateTime(1, 1, 1, 4, 0, 0);
RecorridoBE recorrido = calcRecorrido.Recorrido;
int descansoChoferes = int.Parse(ConfigurationManager.AppSettings["descansoChoferes"]);
foreach (int intervalo in calcRecorrido.FrecuenciaPorIntervalo.Keys)
{
while (inicioProximoViaje.Hour - inicioProximoViaje.Hour % 2 == intervalo)
{
ViajeBE viajeIda = new ViajeBE
{
HoraSalida = inicioProximoViaje,
HoraEstimadaLlegada = inicioProximoViaje.Add(calcRecorrido.DuracionPorIntervalo[intervalo]),
EsIda = true,
TerminalOrigen = recorrido.TerminalInicio,
TerminalDestino = recorrido.TerminalFin
};
// Busco la planilla cuyo último viaje termine en la terminal de salida antes de que
// salga este micro (más el descanso de los choferes)
PlanillaHorariaBE planillaIda = _planillasGeneradas.Where(p =>
p.Recorrido == recorrido &&
p.Viajes.Last().TerminalDestino == recorrido.TerminalInicio &&
p.Viajes.Last().HoraEstimadaLlegada.AddMinutes(descansoChoferes) < inicioProximoViaje).FirstOrDefault();
if (planillaIda == null)
{
planillaIda = new PlanillaHorariaBE
{
Fecha = _fechaAGenerar,
Recorrido = recorrido,
Viajes = new List <ViajeBE>()
};
_planillasGeneradas.Add(planillaIda);
}
planillaIda.Viajes.Add(viajeIda);
// Hago lo mismo con el viaje de vuelta
ViajeBE viajeVuelta = new ViajeBE
{
HoraSalida = inicioProximoViaje,
HoraEstimadaLlegada = inicioProximoViaje.Add(calcRecorrido.DuracionPorIntervalo[intervalo]),
EsIda = false,
TerminalOrigen = recorrido.TerminalFin,
TerminalDestino = recorrido.TerminalInicio,
};
PlanillaHorariaBE planillaVuelta = _planillasGeneradas.Where(p =>
p.Recorrido == recorrido &&
p.Viajes.Last().TerminalDestino == recorrido.TerminalFin &&
p.Viajes.Last().HoraEstimadaLlegada.AddMinutes(descansoChoferes) < inicioProximoViaje).FirstOrDefault();
if (planillaVuelta == null)
{
planillaVuelta = new PlanillaHorariaBE
{
Fecha = _fechaAGenerar,
Recorrido = recorrido,
Viajes = new List <ViajeBE>()
};
_planillasGeneradas.Add(planillaVuelta);
}
planillaVuelta.Viajes.Add(viajeVuelta);
inicioProximoViaje = inicioProximoViaje.AddMinutes(calcRecorrido.FrecuenciaPorIntervalo[intervalo]);
}
}
}
private void CalcularIntervalos(CalculoDeRecorrido calcRecorrido, List <DateTime> dias)
{
List <PlanillaHorariaBE> planillas = PlanillaHoraria.ObtenerPlanilas(calcRecorrido.Recorrido, dias);
calcRecorrido.FrecuenciaPorIntervalo = new Dictionary <int, int>();
calcRecorrido.DuracionPorIntervalo = new Dictionary <int, TimeSpan>();
// Agrupo las planillas por día
var planillasPorDia = planillas.GroupBy(p => p.Fecha).Select(g => new
{
Fecha = g.Key,
Planillas = g.ToList()
}).OrderBy(x => x.Fecha).ToList();
int diasDeCalculo = planillasPorDia.Count;
// Un intervalo representa un período de 2 hs. El intervalo 4 es el período de 4 a 6 hs por ej.
// Empieza en 4 porque el primer viaje del día siempre es a las 4 AM
for (int intervalo = 4; intervalo <= 22; intervalo += 2)
{
decimal sumaDeIndices = 0;
TimeSpan sumaDuracion = new TimeSpan();
int frecuenciaDiaAnterior = -1;
int cantidadViajes = 0;
for (int dia = 0; dia < diasDeCalculo; dia++)
{
// Viajes de este intervalo de cada planilla
List <ViajeBE> viajesDeIntervalo = planillasPorDia[dia].Planillas.SelectMany(p => p.Viajes)
.Where(v => v.HoraSalida.Hour - v.HoraSalida.Hour % 2 == intervalo).OrderBy(v => v.HoraSalida).ToList();
cantidadViajes += viajesDeIntervalo.Count;
decimal sumaCompletitud = 0;
for (int iViaje = 0; iViaje < viajesDeIntervalo.Count; iViaje++)
{
ViajeBE viaje = viajesDeIntervalo[iViaje];
// Completitud del viaje
if (viaje.Completitud == CompletitudViaje.Vacio)
{
sumaCompletitud += 0.5M;
}
else if (viaje.Completitud == CompletitudViaje.Moderado || viaje.Completitud == CompletitudViaje.Nulo)
{
sumaCompletitud += 1;
}
else if (viaje.Completitud == CompletitudViaje.Lleno)
{
sumaCompletitud += 1.5M;
}
// Duración del viaje
if (viaje.HoraRealLlegada.HasValue && viaje.HoraRealLlegada.Value < viaje.HoraSalida)
{
// Este es el caso cuando llega al día siguiente
viaje.HoraRealLlegada = viaje.HoraRealLlegada.Value.AddDays(1);
}
DateTime horaLlegada = viaje.HoraRealLlegada ?? viaje.HoraEstimadaLlegada;
sumaDuracion = sumaDuracion.Add(horaLlegada - viaje.HoraSalida);
// Frecuencia del día anterior
if (dia == 0 && frecuenciaDiaAnterior < 0)
{
DateTime horaProximoViaje = viajesDeIntervalo.Where(v => v.HoraSalida > viaje.HoraSalida)
.OrderBy(v => v.HoraSalida).Select(v => v.HoraSalida).FirstOrDefault();
if (horaProximoViaje != default)
{
frecuenciaDiaAnterior = (int)(horaProximoViaje - viaje.HoraSalida).TotalMinutes;
}
else if (intervalo <= 20)
{
// No hay proximo viaje en este intervalo, busco en el siguiente
horaProximoViaje = planillasPorDia[dia].Planillas.SelectMany(p => p.Viajes)
.Where(v => v.HoraSalida.Hour - v.HoraSalida.Hour % 2 == (intervalo + 2))
.OrderBy(v => v.HoraSalida).Select(v => v.HoraSalida).FirstOrDefault();
frecuenciaDiaAnterior = (int)(horaProximoViaje - viaje.HoraSalida).TotalMinutes;
}
else
{
// No hay siguiente intervalo, tomo la frecuencia respecto al anterior.
DateTime horaViajeAnterior = planillasPorDia[dia].Planillas
.SelectMany(p => p.Viajes)
.Where(v => v.HoraSalida.Hour - v.HoraSalida.Hour % 2 == (intervalo - 2))
.OrderBy(v => v.HoraSalida).Select(v => v.HoraSalida).LastOrDefault();
frecuenciaDiaAnterior = (int)(viaje.HoraSalida - horaViajeAnterior).TotalMinutes;
}
}
}
decimal promedioCompletitudIntervalo = sumaCompletitud / viajesDeIntervalo.Count;
decimal indiceDeAjuste = promedioCompletitudIntervalo * (diasDeCalculo - dia) / diasDeCalculo;
sumaDeIndices += indiceDeAjuste;
}
int nuevaFrecuencia;
TimeSpan nuevaDuracion;
if (diasDeCalculo > 0 && cantidadViajes > 0)
{
decimal divisorDeFrecuencia = sumaDeIndices / diasDeCalculo;
nuevaFrecuencia = (int)Math.Round(frecuenciaDiaAnterior / divisorDeFrecuencia);
nuevaFrecuencia = Math.Min(nuevaFrecuencia, 60); // No puede haber una frecuencia mayor a 60 minutos
nuevaDuracion = new TimeSpan(sumaDuracion.Ticks / cantidadViajes);
// Redondeo al minuto más cercano
nuevaDuracion = TimeSpan.FromMinutes(Math.Round(nuevaDuracion.TotalMinutes));
}
else
{
// Si no hay datos, tomo la frecuencia y duración por defecto
nuevaFrecuencia = int.Parse(ConfigurationManager.AppSettings["frecuenciaDefault"]);
nuevaDuracion = new TimeSpan(0, int.Parse(ConfigurationManager.AppSettings["duracionDefault"]), 0);
}
calcRecorrido.FrecuenciaPorIntervalo.Add(intervalo, nuevaFrecuencia);
calcRecorrido.DuracionPorIntervalo.Add(intervalo, nuevaDuracion);
}
}
