/// <summary>
/// Actualiza la hora del subproyecto para que la suma sea igual a las horas de las actividades
/// incluyendo los subproyectos hijos.
/// </summary>
/// <param name="subproyecto">Subproyecto a actualizar, incluyendo sus hijos</param>
/// <returns></returns>
public static decimal ActualizarHorasSubproyecto(SUBPROYECTO subproyecto)
{
List <SUBPROYECTO> subproyectos = ObtenerSubproyectosHijos(subproyecto);
List <Actividad_proyecto> actividades = ControladorActividades.ObtenerActividadesProyectoDeSubproyecto(subproyecto);
List <SUBPROYECTO> hijos;
decimal total = 0;
//Función recursiva para calcular las horas de los subproyectos hijos
foreach (var subpro in subproyectos)
{
total += ActualizarHorasSubproyecto(subpro);
}
//Recorre las actividades y suma sus horas
foreach (var item in actividades)
{
item.cantidad_hora = (decimal)ControladorActividades.ObtenerHorasTotalesActividad(item);
ControladorActividades.ActualizarActividadProyecto(item);
total += (decimal)ControladorActividades.ObtenerHorasTotalesActividad(item);
}
subproyecto.horas_estimadas = total;
ActualizarSubproyecto(subproyecto);
return(total);
}
/// <summary>
/// Agrega una tarea en la base de datos para el usuario seleccionado.
/// Se asigna con estado Pendiente.
/// Si el usuaro ya tiene ese
/// </summary>
/// <param name="idActividadProyectoSolicitar"></param>
/// <param name="idUsuario"></param>
/// <returns></returns>
public static Detalle_recurso RequerirTarea(int idActividadProyectoSolicitar, int idUsuario)
{
Detalle_recurso tarea = new Detalle_recurso();
tarea.id_actividad_proyecto = idActividadProyectoSolicitar;
tarea.forzada = false;
tarea.id_usuario = idUsuario;
tarea.motivo = "solicitud";
tarea.tipo = "";
tarea.porcentaje_avance = 0;
tarea.realizada = false;
tarea.cantidad_hora = Convert.ToDecimal(ControladorActividades.ObtenerHorasTotalesActividad(ControladorActividades.ObtenerActividadProyecto(idActividadProyectoSolicitar)));
tarea.id_estado = ObtenerEstadoPorNombre("Pendiente").IdEstadoTarea;
tarea.fecha_inicio = DateTime.Now;
tarea.fecha_fin = ControladorCalendario.CalcularFechaFin(ControladorActividades.ObtenerActividadProyecto(idActividadProyectoSolicitar), ControladorUsuarios.ObtenerUsuario(idUsuario), tarea.fecha_inicio.Value, ControladorActividades.ObtenerHorasTotalesActividad(ControladorActividades.ObtenerActividadProyecto(idActividadProyectoSolicitar)));
tarea.duracion_cadista = (decimal)ControladorActividades.ObtenerHorasOrdenCompraParaCadista(ControladorActividades.ObtenerActividadProyecto(idActividadProyectoSolicitar));
tarea.fecha_inicio_cadista = tarea.fecha_inicio;
tarea.fecha_fin_cadista = tarea.fecha_fin;
if (ControladorTareas.EstaAsignadaAUsuario(idActividadProyectoSolicitar, idUsuario) == null)
{
return(Insertar(tarea));
}
return(null);
}
/// <summary>
/// Completar
/// </summary>
/// <param name="actividad"></param>
/// <returns></returns>
public static bool AsignarActividadProyecto(Actividad_proyecto actividad, double cantidad_horas_solapamiento)
{
List <Tuple <USUARIO, decimal> > miembros_habilitados = ControladorSubproyecto.ObtenerMiemrosHabilitadosParaAsignar(actividad);
DateTime fecha_inicio;
DateTime fecha_fin;
double tiempo_trabajado, tiempo_total;
tiempo_total = ControladorActividades.ObtenerHorasTotalesActividad(actividad);
tiempo_trabajado = 0;//ControladorActividades.ObtenerHorasConsumidas(actividad);
//Modificar este metodo para que verifique fecha inicio mayor a la actual.
fecha_inicio = ControladorActividades.ObtenerFechaInicioMinima(actividad);
//Devuelve la fecha fin ideal
fecha_fin = ControladorCalendario.ObtenerFechaFinMinima(actividad, fecha_inicio).Value;
List <Tuple <Tuple <USUARIO, decimal>, Tuple <DateTime, DateTime> > > listaPorFechaFin;
List <Tuple <Tuple <USUARIO, decimal>, Tuple <DateTime, DateTime> > > listaPorCalifi;
List <Tuple <Tuple <USUARIO, decimal>, Tuple <DateTime, DateTime> > > listaOrdenada = new List <Tuple <Tuple <USUARIO, decimal>, Tuple <DateTime, DateTime> > >();
if (!ControladorActividades.EstaCompletada(actividad))
{
foreach (var miem in miembros_habilitados)
{
DateTime fecha = ObtenerFechaInicioMinimaUsuario(miem.Item1, fecha_inicio, tiempo_total - tiempo_trabajado, actividad, fecha_fin);
DateTime?fecha_fin_usuario = ControladorCalendario.CalcularFechaFin(actividad, miem.Item1, fecha, null);
listaOrdenada.Add(new Tuple <Tuple <USUARIO, decimal>, Tuple <DateTime, DateTime> >(miem, new Tuple <DateTime, DateTime>(fecha, fecha_fin_usuario.Value)));
}
if (listaOrdenada.Count > 0)
{
//Ordena la lista primero por fecha de fin, luego por calificaciones, el que tiene mas primero.
listaOrdenada = listaOrdenada.OrderBy(x => x.Item2.Item2).ThenByDescending(x => x.Item1.Item2).ToList();
listaPorFechaFin = listaOrdenada.OrderBy(x => x.Item2.Item2).ToList();
listaPorCalifi = listaOrdenada.OrderByDescending(x => x.Item1.Item2).ToList();
if (listaOrdenada.ElementAt(0).Item2.Item2.Subtract(listaPorCalifi.ElementAt(0).Item2.Item2).TotalHours <= cantidad_horas_solapamiento)
{
AsignarActividad(actividad, listaPorCalifi.ElementAt(0).Item1.Item1, listaPorCalifi.ElementAt(0).Item2.Item1, listaPorCalifi.ElementAt(0).Item2.Item2);
}
else
{
AsignarActividad(actividad, listaOrdenada.ElementAt(0).Item1.Item1, listaOrdenada.ElementAt(0).Item2.Item1, listaOrdenada.ElementAt(0).Item2.Item2);
}
return(true);
}
return(false);
}
return(false);
}
internal static void ActualizarHorasProyectosActivos()
{
List <Proyecto> proyectos_activos = ObtenerProyectosActivos();
decimal totalProy = 0;
decimal totalSub = 0;
foreach (var proyecto in proyectos_activos)
{
totalProy = 0;
List <SUBPROYECTO> subproyectos = ObtenerSubproyectosHijos(proyecto);
foreach (var subpro in subproyectos)
{
List <SUBPROYECTO> subproyectosHijos = ControladorSubproyecto.ObtenerSubproyectosHijos(subpro);
List <Actividad_proyecto> actividades = ControladorActividades.ObtenerActividadesProyectoDeSubproyecto(subpro);
List <SUBPROYECTO> hijos;
totalSub = 0;
//Función recursiva para calcular las horas de los subproyectos hijos
foreach (var sub in subproyectosHijos)
{
totalSub += ControladorSubproyecto.ActualizarHorasSubproyecto(sub);
}
//Recorre las actividades y suma sus horas
foreach (var item in actividades)
{
item.cantidad_hora = (decimal)ControladorActividades.ObtenerHorasTotalesActividad(item);
ControladorActividades.ActualizarActividadProyecto(item);
totalSub += (decimal)ControladorActividades.ObtenerHorasTotalesActividad(item);
}
totalProy += totalSub;
subpro.horas_estimadas = totalSub;
ControladorSubproyecto.ActualizarSubproyecto(subpro);
}
proyecto.total_hora = totalProy;
Update(proyecto);
}
}
/// <summary>
/// Asigna la actividad al usuario - VER TEMA DE FECHAS
/// </summary>
/// <param name="actividad"></param>
/// <param name="usuario"></param>
public static Detalle_recurso AsignarActividad(Actividad_proyecto actividad, USUARIO usuario, DateTime fecha_inicio, DateTime fecha_fin)
{
Detalle_recurso tarea = new Detalle_recurso();
tarea.cantidad_hora = (decimal)(ControladorActividades.ObtenerHorasTotalesActividad(actividad));
tarea.fecha_fin = fecha_fin;
tarea.fecha_inicio = fecha_inicio;
tarea.forzada = false;
tarea.id_actividad_proyecto = actividad.id_actividad_proyecto;
tarea.id_estado = ObtenerEstadoPorNombre("Asignado") != null?ObtenerEstadoPorNombre("Asignado").IdEstadoTarea : 0;
tarea.id_usuario = usuario.id_usuario;
tarea.motivo = "asignada por algoritmo";
tarea.porcentaje_avance = 0;
tarea.realizada = false;
tarea.tipo = "asignada por algoritmo";
tarea.fecha_inicio_cadista = fecha_inicio;
tarea.fecha_fin_cadista = fecha_fin;
tarea.duracion_cadista = (decimal)(ControladorActividades.ObtenerHorasOrdenCompraParaCadista(actividad));
return(TareaDB.AsignarActividad(tarea));
}
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 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);
}