/// <summary>
/// Cuidado con esto!!.. Va a verificar que todos los proyectos y usuarios tengan asignados el calendario
/// Descar, y para los usuarios, crea un calendario propio.
/// </summary>
public static void ActualizarCalendariosUsuariosYProyectos()
{
List <USUARIO> usuarios = ControladorUsuarios.ObtenerTodosUsuarios();
foreach (var item in usuarios)
{
if (item.id_calendario_laboral == 1 || item.id_calendario_laboral == null)
{
Calendario_Laboral calendario = new Calendario_Laboral()
{
es_calendario_base = false,
id_calendario_padre = 1,
nombre_calendario = item.FullName
};
calendario = ControladorCalendario.Insertar(calendario);
item.id_calendario_laboral = calendario.id_calendario_laboral;
ControladorUsuarios.Actualizar(item);
}
}
List <Proyecto> proyectos = ControladorProyecto.ObtenerProyectos();
foreach (var item in proyectos)
{
if (item.id_calendario_laboral_base == null)
{
item.id_calendario_laboral_base = 1;
ControladorProyecto.Update(item);
}
}
}
public static Calendario_Laboral InsertarCalendario(Calendario_Laboral calendario)
{
using (var bd = new DescarEntity())
{
bd.Calendario_Laboral.Add(calendario);
bd.SaveChanges();
}
return(calendario);
}
/// <summary>
/// Inserta un nuevo usuario en la base de datos, y crea el calendario para el mismo,
/// con calendario base indicado. Éste calendario se actualiza con el nuevo id.
/// </summary>
/// <param name="usuario"></param>
/// <returns></returns>
public static USUARIO InsertarYcreaCalendario(USUARIO usuario)
{
Calendario_Laboral calendario = new Calendario_Laboral()
{
es_calendario_base = false,
id_calendario_padre = usuario.id_calendario_laboral,
nombre_calendario = usuario.FullName
};
calendario = ControladorCalendario.Insertar(calendario);
usuario.id_calendario_laboral = calendario.id_calendario_laboral;
return(UsuariosBD.Insertar(usuario));
}
public static List <Definicion_Calendario_Laboral> ObtenerDefiniciones(Calendario_Laboral calendario)
{
if (calendario == null)
{
return(new List <Definicion_Calendario_Laboral>());
}
using (var bd = new DescarEntity())
{
var sub = (from s in bd.Definicion_Calendario_Laboral
where s.id_calendario_laboral == calendario.id_calendario_laboral
select s);
return(sub.ToList());
}
}
public static Calendario_Laboral ActualizarCalendario(Calendario_Laboral calendario)
{
using (var bd = new DescarEntity())
{
var sub = (from s in bd.Calendario_Laboral
select s).Single();
sub.nombre_calendario = calendario.nombre_calendario;
sub.id_calendario_padre = calendario.id_calendario_padre;
sub.es_calendario_base = calendario.es_calendario_base;
bd.SaveChanges();
return(sub);
}
}
public static List <Tuple <DateTime, Tuple <TimeSpan, TimeSpan> > > PruebaObtenerFechas(USUARIO usuario, DateTime fecha_inicio, DateTime fecha_fin)
{
Calendario_Laboral calendario = ObtenerCalendarioLaboraldeMiembro(usuario);
List <Tuple <DateTime, Tuple <TimeSpan, TimeSpan> > > lista = new List <Tuple <DateTime, Tuple <TimeSpan, TimeSpan> > >();
for (DateTime i = fecha_inicio; i < fecha_fin; i = i.AddDays(1))
{
var listaHoraDia = ObtenerHorasLaboralesDia(calendario, i);
foreach (var item in listaHoraDia)
{
lista.Add(new Tuple <DateTime, Tuple <TimeSpan, TimeSpan> >(i, item));
}
}
return(lista);
}
public static List <Excepcion_Calendario> ObtenerExcepcionesTotales(Calendario_Laboral calendario)
{
if (!calendario.es_calendario_base)
{
//Si no es calendario base, y tiene excepciones, solo toma esas, sino las de la base
using (var bd = new DescarEntity())
{
var sub = (from s in bd.Excepcion_Calendario
where calendario.id_calendario_laboral == s.id_calendario_laboral
select s);
if (sub.ToList().Count > 0)
{
return(sub.ToList());
}
else
{
//Devuelve las excepciones del padre
sub = (from s in bd.Excepcion_Calendario
join cb in bd.Calendario_Laboral on calendario.id_calendario_padre equals cb.id_calendario_laboral
where cb.id_calendario_laboral == s.id_calendario_laboral
select s);
return(sub.ToList());
}
}
}
//Si el calendario ya es base, devuelve sus excepciones
using (var bd = new DescarEntity())
{
var sub = (from s in bd.Excepcion_Calendario
where calendario.id_calendario_laboral == s.id_calendario_laboral
select s);
return(sub.ToList());
}
}
private static List <Excepcion_Calendario> ObtenerExcepcionesTotales(Calendario_Laboral calendario)
{
return(CalendarioDB.ObtenerExcepcionesTotales(calendario));
}
public static List <Definicion_Calendario_Laboral> ObtenerDefinicionesTotales(Calendario_Laboral calendario)
{
if (!calendario.es_calendario_base)
{
using (var bd = new DescarEntity())
{
var sub = (from s in bd.Definicion_Calendario_Laboral
join c in bd.Calendario_Laboral on calendario.id_calendario_padre equals c.id_calendario_laboral
where calendario.id_calendario_laboral == s.id_calendario_laboral ||
s.id_calendario_laboral == c.id_calendario_laboral
select s);
return(sub.ToList());
}
}
else
{
using (var bd = new DescarEntity())
{
var sub = (from s in bd.Definicion_Calendario_Laboral
where calendario.id_calendario_laboral == s.id_calendario_laboral
select s);
return(sub.ToList());
}
}
}
public static DateTime?CalcularFechaFin(Actividad_proyecto actividad, USUARIO usuario, DateTime fecha_inicio, double?horas)
{
Calendario_Laboral calendario = ObtenerCalendarioLaboraldeMiembro(usuario);
Calendario_Laboral padre = ObtenerCalendario(calendario.id_calendario_padre.Value);
List <Definicion_Calendario_Laboral> definiciones_padre = ObtenerDefiniciones(padre).OrderByDescending(x => x.fecha_hasta).ToList();
List <Excepcion_Calendario> excepciones = ObtenerExcepciones(padre);
List <Definicion_Calendario_Laboral> definiciones_hijo = ObtenerDefiniciones(calendario).OrderByDescending(x => x.fecha_hasta).ToList();
List <Excepcion_Calendario> excepciones_hijo = ObtenerExcepciones(calendario);
List <DateTime> fechasIncluidas = new List <DateTime>();
fechasIncluidas.AddRange(definiciones_padre.Select(x => x.fecha_hasta));
fechasIncluidas.AddRange(excepciones.Select(x => x.fecha_fin.Value).ToList());
fechasIncluidas.AddRange(definiciones_hijo.Select(x => x.fecha_hasta));
fechasIncluidas.AddRange(excepciones_hijo.Select(x => x.fecha_fin.Value).ToList());
fechasIncluidas.Sort((a, b) => b.CompareTo(a));
double horasActividad = horas.HasValue ? horas.Value : ControladorActividades.ObtenerHorasTotalesActividad(actividad);
double restante = horasActividad * 60;
TimeSpan hora = fecha_inicio.TimeOfDay;
DateTime fecha_fin;
if (fechasIncluidas.Count > 0)
{
for (DateTime i = fecha_inicio; i <= fechasIncluidas.First(); i = i.AddDays(1))
{
//Agregar si la expcecion no base no define un dia pero la base si,
//dentro de un período
var aux = ObtenerHorasLaboralesDia(calendario, i);
double tiempoDia = 0;
foreach (var item in aux)
{
if (fecha_inicio.Date == i.Date)
{
//Hay que tener en cuenta la hora, sino no
if (hora.Ticks > item.Item1.Ticks && hora.Ticks < item.Item2.Ticks)
{
tiempoDia += (item.Item2.Ticks - hora.Ticks) / TimeSpan.TicksPerMinute;
}
else if (hora.Ticks <= item.Item1.Ticks)
{
tiempoDia += (item.Item2.Ticks - item.Item1.Ticks) / TimeSpan.TicksPerMinute;
}
}
else
{
tiempoDia += (item.Item2.Ticks - item.Item1.Ticks) / TimeSpan.TicksPerMinute;
}
if (restante - tiempoDia == 0)
{
fecha_fin = i;
TimeSpan hora_fin = TimeSpan.FromTicks(item.Item2.Ticks);
DateTime nuevo = new DateTime(i.Year, i.Month, i.Day, hora_fin.Hours, hora_fin.Minutes, hora_fin.Seconds);
return(nuevo);
}
else if (restante - tiempoDia < 0)
{
TimeSpan hora_fin;
if (fecha_inicio.Date == i.Date && (hora.Ticks > item.Item1.Ticks && hora.Ticks < item.Item2.Ticks))
{
hora_fin = TimeSpan.FromTicks((long)(hora.Ticks + (restante * TimeSpan.TicksPerMinute)));
}
else
{
hora_fin = TimeSpan.FromTicks((long)(item.Item1.Ticks + (restante * TimeSpan.TicksPerMinute)));
}
fecha_fin = i;
DateTime nuevo = new DateTime(i.Year, i.Month, i.Day, hora_fin.Hours, hora_fin.Minutes, hora_fin.Seconds);
return(nuevo);
}
else
{
restante = restante - tiempoDia;
tiempoDia = 0;
}
}
}
}
return(null);
}
public static DateTime?ObtenerFechaFinMinima(Actividad_proyecto actividad, DateTime fecha_inicio)
{
Proyecto proyecto = ControladorProyecto.ObtenerPorID(actividad.id_proyecto.Value);
Calendario_Laboral padre = ObtenerCalendario(proyecto.id_calendario_laboral_base.Value);
List <Definicion_Calendario_Laboral> definiciones_padre = ObtenerDefiniciones(padre).OrderByDescending(x => x.fecha_hasta).ToList();
List <Excepcion_Calendario> excepciones = ObtenerExcepciones(padre);
List <DateTime> fechasIncluidas = ObtenerDefiniciones(padre).OrderByDescending(x => x.fecha_hasta).Select(x => x.fecha_hasta).ToList();
fechasIncluidas.AddRange(excepciones.Select(x => x.fecha_fin.Value).ToList());
fechasIncluidas.Sort((a, b) => b.CompareTo(a));
double horasActividad = ControladorActividades.ObtenerHorasTotalesActividad(actividad);
double restante = horasActividad * 60;
TimeSpan hora = fecha_inicio.TimeOfDay;
DateTime fecha_fin;
if (fechasIncluidas.Count > 0)
{
for (DateTime i = fecha_inicio; i <= fechasIncluidas.First(); i = i.AddDays(1))
{
var aux = ObtenerHorasLaboralesDia(padre, i);
double tiempoDia = 0;
foreach (var item in aux)
{
if (fecha_inicio.Date == i.Date)
{
//Hay que tener en cuenta la hora, sino no
if (hora.Ticks > item.Item1.Ticks && hora.Ticks < item.Item2.Ticks)
{
tiempoDia += (item.Item2.Ticks - hora.Ticks) / TimeSpan.TicksPerMinute;
}
else if (hora.Ticks <= item.Item1.Ticks)
{
tiempoDia += (item.Item2.Ticks - item.Item1.Ticks) / TimeSpan.TicksPerMinute;
}
}
else
{
tiempoDia += (item.Item2.Ticks - item.Item1.Ticks) / TimeSpan.TicksPerMinute;
}
//restante = restante - tiempoDia;
if (restante - tiempoDia == 0)
{
fecha_fin = i;
TimeSpan hora_fin = TimeSpan.FromTicks(item.Item2.Ticks);
DateTime nuevo = new DateTime(i.Year, i.Month, i.Day, hora_fin.Hours, hora_fin.Minutes, hora_fin.Seconds);
return(nuevo);
}
else if (restante - tiempoDia < 0)
{
var hora_fin = TimeSpan.FromTicks((long)(item.Item1.Ticks + (restante * TimeSpan.TicksPerMinute)));
fecha_fin = i;
DateTime nuevo = new DateTime(i.Year, i.Month, i.Day, hora_fin.Hours, hora_fin.Minutes, hora_fin.Seconds);
return(nuevo);
}
else
{
restante = restante - tiempoDia;
tiempoDia = 0;
}
}
}
}
return(null);
}
public static List <Definicion_Calendario_Laboral> ObtenerDefinicionesTotalesDentroDelRango(Calendario_Laboral calendario, DateTime fecha)
{
return(CalendarioDB.ObtenerDefinicionesTotales(calendario).Where(x => x.fecha_desde.Date <= fecha.Date && x.fecha_hasta.Date >= fecha.Date).ToList());
}
private static List <Excepcion_Calendario> ObtenerExcepcionesTotalesDentroDelRango(Calendario_Laboral calendario, DateTime fecha)
{
return(CalendarioDB.ObtenerExcepcionesTotales(calendario).Where(x => x.fecha_comienzo.Value.Date <= fecha.Date && x.fecha_fin.Value.Date >= fecha.Date).ToList());
}
public static List <Excepcion_Calendario> ObtenerExcepciones(Calendario_Laboral calendario)
{
return(CalendarioDB.ObtenerExcepciones(calendario));
}
/// <summary>
/// Obtiene las horas laborales de ese calendario para la fecha indicada. Ignora los días no
/// laborables. (Si se trabaja ese dia, entonces va a retornar algo).
/// TODO: Periodos nulos, o del padre.
/// </summary>
/// <param name="calendario"></param>
/// <param name="fecha"></param>
/// <returns></returns>
public static List <Tuple <TimeSpan, TimeSpan> > ObtenerHorasLaboralesDia(Calendario_Laboral calendario, DateTime fecha)
{
List <Excepcion_Calendario> excepciones = ObtenerExcepcionesTotalesDentroDelRango(calendario, fecha);
//Este no considera si llama de la base, tenerlo en cuenta para futuro.
List <Definicion_Calendario_Laboral> definiciones = ObtenerDefinicionesTotalesDentroDelRango(calendario, fecha);
List <Excepcion_Calendario> excepcionesBase = new List <Excepcion_Calendario>();
List <Definicion_Calendario_Laboral> definicionesBase = new List <Definicion_Calendario_Laboral>();
if (!calendario.es_calendario_base && calendario.id_calendario_padre.HasValue)
{
excepcionesBase = ObtenerExcepcionesTotalesDentroDelRango(ObtenerCalendario(calendario.id_calendario_padre.Value), fecha);
definicionesBase = ObtenerDefinicionesTotalesDentroDelRango(ObtenerCalendario(calendario.id_calendario_padre.Value), fecha);
}
List <Detalle_Calendario_Laboral> detalles;
List <Tuple <TimeSpan, TimeSpan> > listaHoras = new List <Tuple <TimeSpan, TimeSpan> >();
bool laborable = true;
//Si tiene excepciones, tienen prioridad y se ignoran las deciniciones
if (excepciones.Count > 0 || excepcionesBase.Count > 0)
{
List <Tuple <TimeSpan, TimeSpan> > aux = ObtenerHorasDeExcepciones(excepciones, fecha, out laborable);
if (laborable)
{
//El dia no tiene definiciones de que no sea laborable. Si viene vacío, entonces
// hay que usar el calendario base, sino tomar los datos de este.
if (aux.Count == 0 && !calendario.es_calendario_base &&
calendario.id_calendario_padre.HasValue)
{
listaHoras.AddRange(ObtenerHorasDeExcepciones(excepcionesBase, fecha, out laborable));
}
else
{
//Si tiene datos, entonces solo se cuenta el del calendario del usuario/proyecto.
listaHoras.AddRange(aux);
}
}
else
{
return(new List <Tuple <TimeSpan, TimeSpan> >());
}
}
if (laborable == false)
{
//En este caso, habia excepciones del original, pero no para ese dia en particular,
//sin embargo el calendario base si tiene definicion para ese dia, e indica que no es laboral
return(new List <Tuple <TimeSpan, TimeSpan> >());
}
//Sino no tiene excepciones o no hay excepciones para ese dia en particular,
//se toman las definiciones
if ((laborable = true && listaHoras.Count == 0 &&
(excepciones.Count > 0 || excepcionesBase.Count > 0)) ||
(excepciones.Count == 0 || excepcionesBase.Count == 0))
{
laborable = true;
List <Tuple <TimeSpan, TimeSpan> > auxDef = ObtenerHorasDeDefiniciones(definiciones, fecha, out laborable);
if (laborable)
{
//El dia no tiene definiciones de que no sea laborable. Si viene vacío, entonces
// hay que usar el calendario base, sino tomar los datos de este.
if (auxDef.Count == 0 && !calendario.es_calendario_base &&
calendario.id_calendario_padre.HasValue)
{
listaHoras.AddRange(ObtenerHorasDeDefiniciones(definicionesBase, fecha, out laborable));
}
else
{
//Si tiene datos, entonces solo se cuenta el del calendario del usuario/proyecto.
listaHoras.AddRange(auxDef);
}
}
else
{
return(new List <Tuple <TimeSpan, TimeSpan> >());
}
}
return(listaHoras);
}
public static Calendario_Laboral ActualizarCalendario(Calendario_Laboral calendario)
{
return(CalendarioDB.ActualizarCalendario(calendario));
}
/// <summary>
/// Calcula la cantidad de minutos disponibles para ese usuario entre las fecha indicadas, en base a su calendario
/// </summary>
/// <param name="usuario"></param>
/// <param name="fecha_fin"></param>
/// <param name="fecha_inicio"></param>
/// <returns></returns>
public static double CalcularTiempoEntreFechas(Calendario_Laboral calendario, DateTime fecha_fin, DateTime fecha_inicio)
{
if (fecha_inicio > fecha_fin)
{
return(-1);
}
List <Definicion_Calendario_Laboral> definiciones_padre = ObtenerDefiniciones(calendario).OrderByDescending(x => x.fecha_hasta).ToList();
List <Excepcion_Calendario> excepciones = ObtenerExcepciones(calendario);
List <DateTime> fechasIncluidas = ObtenerDefiniciones(calendario).OrderByDescending(x => x.fecha_hasta).Select(x => x.fecha_hasta).ToList();
fechasIncluidas.AddRange(excepciones.Select(x => x.fecha_fin.Value).ToList());
if (!calendario.es_calendario_base && calendario.id_calendario_padre.HasValue)
{
Calendario_Laboral calBase = ObtenerCalendario(calendario.id_calendario_padre.Value);
List <Definicion_Calendario_Laboral> definiciones_base = ObtenerDefiniciones(calBase).OrderByDescending(x => x.fecha_hasta).ToList();
List <Excepcion_Calendario> excepcionesBase = ObtenerExcepciones(calBase);
fechasIncluidas.AddRange(definiciones_base.Select(x => x.fecha_hasta).ToList());
fechasIncluidas.AddRange(excepcionesBase.Select(x => x.fecha_fin.Value).ToList());
}
fechasIncluidas.Sort((a, b) => b.CompareTo(a));
TimeSpan hora = fecha_inicio.TimeOfDay;
double tiempo = 0;
if (fechasIncluidas.Count > 0)
{
for (DateTime i = fecha_inicio; i < fecha_fin; i = i.AddDays(1))
{
var aux = ObtenerHorasLaboralesDia(calendario, i);
foreach (var item in aux)
{
if (fecha_inicio.Date == i.Date)
{
//Hay que tener en cuenta la hora, sino no
if (hora.Ticks > item.Item1.Ticks && hora.Ticks < item.Item2.Ticks)
{
if (fecha_fin.Date == fecha_inicio.Date)
{
if (fecha_fin.TimeOfDay.Ticks < item.Item2.Ticks)
{
tiempo += (fecha_fin.TimeOfDay.Ticks - hora.Ticks) / TimeSpan.TicksPerMinute;
return(tiempo);
}
else
{
tiempo += (item.Item2.Ticks - hora.Ticks) / TimeSpan.TicksPerMinute;
return(tiempo);
}
}
else
{
tiempo += (item.Item2.Ticks - hora.Ticks) / TimeSpan.TicksPerMinute;
}
}
else if (hora.Ticks <= item.Item1.Ticks)
{
tiempo += (item.Item2.Ticks - item.Item1.Ticks) / TimeSpan.TicksPerMinute;
}
}
else
{
tiempo += (item.Item2.Ticks - item.Item1.Ticks) / TimeSpan.TicksPerMinute;
}
}
}
}
return(tiempo);
}
private static List <Definicion_Calendario_Laboral> ObtenerDefinicionesTotales(Calendario_Laboral calendario)
{
return(CalendarioDB.ObtenerDefinicionesTotales(calendario));
}
public static Calendario_Laboral Insertar(Calendario_Laboral calendario)
{
return(CalendarioDB.InsertarCalendario(calendario));
}