/// <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);
}
}
}
/// <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);
}
/// <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 DateTime ObtenerFechaInicioMinimaUsuario(USUARIO usuario, DateTime fecha, double tiempo, Actividad_proyecto actividad, DateTime fecha_fin)
{
//Obtener una lista de los miembros, y ver todas las asignaciones que tiene,
//buscar los detalles con fechas de inicio mayor a la fecha de parametro
//y hacer una simulación para ver donde ese usuario tendría a esa tarea
//Para cada miembro hacer lo mismo, y dársela al que inicia lo mas temprano posible
List <Detalle_recurso> listaTareasUsuario = ObtenerTareasPorUsuario(usuario.id_usuario).Where(x => x.fecha_fin >= fecha).OrderBy(x => x.fecha_inicio).ToList();
List <Detalle_recurso> listaFinal = new List <Detalle_recurso>();
//listaFinal.AddRange(tareasArrancaAntesYTerminaDespues);
listaFinal.AddRange(listaTareasUsuario);
//listaFinal.AddRange(tareasArrancaAntesyTerminaEnMedio);
listaFinal = listaFinal.OrderBy(x => x.fecha_fin.Value).ToList();
//Para calcular la fecha inicio
List <Detalle_recurso> listaFechaInicio = listaFinal.OrderBy(x => x.fecha_inicio.Value).ToList();
double horas_disponibles = 0;
if (listaFinal.Count > 0)
{
//Puede ser que la primer fecha asignada al usuario sea mas tarde,
//permitiendo que entre la fecha de parametro y la primera fecha asignada pueda asignarse una
// tarea
if (listaFechaInicio.ElementAt(0).fecha_inicio > fecha)
{
horas_disponibles = ControladorCalendario.CalcularTiempoEntreFechas(ControladorCalendario.ObtenerCalendario(usuario.id_calendario_laboral.Value), listaFechaInicio.ElementAt(0).fecha_inicio.Value, fecha) / 60;
if (horas_disponibles >= tiempo)
{
return(fecha);
}
}
listaFinal = listaFinal.OrderBy(x => x.fecha_fin.Value).ToList();
for (int i = 1; i < listaFinal.Count; i++)
{
horas_disponibles = ControladorCalendario.CalcularTiempoEntreFechas(ControladorCalendario.ObtenerCalendario(usuario.id_calendario_laboral.Value), listaFinal.ElementAt(i - 1).fecha_fin.Value, listaFinal.ElementAt(i).fecha_inicio.Value) / 60;
if (horas_disponibles >= tiempo)
{
return(listaFinal.ElementAt(i - 1).fecha_fin.Value);
}
}
return(listaFinal.ElementAt(listaFinal.Count - 1).fecha_fin.Value);
}
return(fecha);
}
public static DateTime ObtenerFechaInicioMinima(Actividad_proyecto actividad)
{
//Si la actividad es Concepto, le fecha minima de inicio es la fecha del proyecto
//Si la actividad es Preparacion, la fecha minima de inicio es la fecha del proyecto
//mas el tiempo de concepto, pero si el concepto ya esta asignado, que la fecha minima de inicio sea la fecha
//fin de concepto.. Lo mismo para preparacion.
String tipo_actividad = ControladorActividades.ObtenerTipoActividad(actividad).descripcion.ToLower();
SUBPROYECTO sub = ControladorSubproyecto.BuscarPorId(actividad.id_subproyecto.Value);
List <Detalle_recurso> tareas = new List <Detalle_recurso>();
DateTime fecha;
Actividad_proyecto act_anterior = ControladorActividades.ObtenerActividadAnterior(actividad);
if (act_anterior != null)
{
double tiempo_actividad;
//Suma los tiempos del
var act_anterior_aux = act_anterior;
tiempo_actividad = 0;
do
{
tiempo_actividad = ObtenerHorasTotalesActividad(act_anterior_aux);
act_anterior_aux = ControladorActividades.ObtenerActividadAnterior(act_anterior_aux);
} while (act_anterior_aux != null);
tareas = obtenerTareasDeActividad(act_anterior);
if (tareas.Count == 0)
{
//No esta asignada, se asigna a la fecha de proyecto + tiempo_actividad
fecha = ControladorCalendario.CalcularFechaFinDesdeProyecto(actividad, tiempo_actividad).Value;
}
else
{
//Está asignada, se asigna a la fecha fin de la asignacion de actividad anterior.
tareas = tareas.OrderByDescending(x => x.fecha_fin).ToList();
fecha = tareas.First().fecha_fin.Value;
}
}
else
{
fecha = ControladorProyecto.ObtenerPorID(actividad.id_proyecto.Value).fecha_inicio.Value;
}
//if (tipo_actividad.Contains("prep") || (tipo_actividad.Contains("deta")))
//{
// List<AvanceSubproyecto> avance;
// double tiempo_actividad;
// if (tipo_actividad.Contains("deta"))
// {
// tiempo_actividad = ObtenerHorasTotalesActividad(ObtenerActividadPorTipoActividad(sub,acti_concepto)) + ObtenerHorasTotalesActividad(ObtenerActividadPorTipoActividad(sub, acti_prepa));
// tareas = obtenerTareasDeActividad(ObtenerActividadPorTipoActividad(sub, acti_prepa));
// }
// else
// {
// tiempo_actividad = ObtenerHorasTotalesActividad(ObtenerActividadPorTipoActividad(sub, acti_concepto));
// tareas = obtenerTareasDeActividad(ObtenerActividadPorTipoActividad(sub, acti_concepto));
// }
// if (tareas.Count == 0)
// {
// //No esta asignada, se asigna a la fecha de proyecto + tiempo_actividad
// fecha = ControladorCalendario.CalcularFechaFinDesdeProyecto(actividad, tiempo_actividad).Value;
// }else
// {
// //Está asignada, se asigna a la fecha fin de la asignacion de actividad anterior.
// tareas = tareas.OrderByDescending(x => x.fecha_fin).ToList();
// fecha = tareas.First().fecha_fin.Value;
// }
//}
//else //Es concepto, o cualquier otro tipo de actividad, inicia cuando lo hace el proyecto.
//{
// fecha = ControladorProyecto.ObtenerPorID(actividad.id_proyecto.Value).fecha_inicio.Value;
//}
return(fecha < DateTime.Now ? DateTime.Now : fecha);
}