private void eliminarAntecesoras(ITarea tarea)
{
for (int i = tarea.Antecesoras.Count - 1; i >= 0; i--)
{
EliminarTarea(tarea.Antecesoras[i].TareaID);
}
}
private void eliminarPersonasEnTarea(ITarea tarea)
{
for (int i = tarea.Personas.Count - 1; i >= 0; i--)
{
EliminarPersona(tarea.Personas[i].PersonaID);
}
}
private void editarTareaVentana(ITarea tarea, bool esNuevaTarea)
{
VentanaDetallesTarea ventanaDetalles = new VentanaDetallesTarea(tarea, esNuevaTarea, contexto);
ventanaDetalles.ShowDialog(this);
refrescarVentanaAlCerrarseDialogo();
}
private void agregarElementoListaAntecesoras(ITarea tarea)
{
ListViewItem elementoLista = generarElementoListView(tarea);
elementoLista.ImageIndex = iconoTarea(tarea);
listViewAntecesoras.Items.Add(elementoLista);
}
/// <summary>
/// Programa una tarea
/// </summary>
/// <param name="id"></param>
/// <param name="tarea"></param>
/// <param name="tarea"></param>
/// <param name="tipoTarea"></param>
/// <param name="procesosIncompatibles">Coleccion de IDs de tareas incompatibles</param>
void ProgramaTarea(string id, ITarea tarea, Type tipoTarea, IProgramador programacion, IEnumerable <string> procesosIncompatibles = null)
{
if ((tarea == null && tipoTarea == null) || programacion == null)
{
throw new ArgumentException("La tarea y la programación deben especificarse");
}
if (tarea != null && tipoTarea != null)
{
throw new ArgumentException("Solo se puede especificar la tarea o su tipo");
}
if (tipoTarea != null && container == null)
{
throw new ArgumentException($"El contenedor es nulo y la tarea tipo {tipoTarea.Name} lo necesita");
}
if (tipoTarea != null && container.GetRegistration(tipoTarea) == null)
{
throw new ArgumentException($"El contenedor no conoce a {tipoTarea.Name}");
}
if (string.IsNullOrWhiteSpace(id))
{
throw new ArgumentException($"La tarea debe tener un Id unico");
}
log.Info($"Programando tarea {id} con el programador {programacion.GetType()}");
DateTime primeraEjecucion = programacion.PrimeraEjecucion(DateTime.Now);
if (primeraEjecucion < DateTime.Now.AddSeconds(-5))
{
log.Warn($"La tarea {id} ha caducado antes de iniciarse");
return;
}
log.Info($"Servicio periodico registrado {id} en fecha {primeraEjecucion:g}");
TareaProgramada prog = new TareaProgramada();
prog.ID = id;
prog.Programacion = programacion;
prog.Tarea = tarea;
prog.TipoTarea = tipoTarea;
prog.SiguienteInicio = primeraEjecucion;
if (procesosIncompatibles != null)
{
prog.ProcesosIncompatibles.AddRange(procesosIncompatibles);
}
lock (bloqueo)
{
if (tareasProgramadas.Where(x => x.ID == id).FirstOrDefault() != null)
{
log.Warn($"La tarea {id} está duplicada");
return;
}
tareasProgramadas.Add(prog);
}
EscaneaTareas();
}
private TreeNode GenerarNodoArbolTareaSimple(ITarea tarea)
{
TreeNode nodoArbol = new TreeNode(GenerarTextoAMostrar(tarea));
nodoArbol.Tag = tarea;
AsignarIconosTareaSimple(nodoArbol);
return(nodoArbol);
}
private TreeNode generarNodoArbolTareaSimple(ITarea tarea)
{
TreeNode nodoRetorno = new TreeNode(generarTextoAMostrar(tarea));
nodoRetorno.Tag = tarea;
asignarIconosTareaSimple(nodoRetorno);
return(nodoRetorno);
}
private void AgregarSubArbolTareaSimple(TreeNode[] arbolNodos, int posicion, ITarea tarea)
{
TreeNode hojaArbol = GenerarNodoArbolTareaSimple(tarea);
hojaArbol.Tag = tarea;
AsignarIconosTareaSimple(hojaArbol);
arbolNodos[posicion] = hojaArbol;
}
public VentanaAsignarAntecesoraVentanaDetallesEtapa(IEtapa etapa, ITarea tarea, IContextoGestorProyectos contexto)
{
this.contexto = contexto;
InitializeComponent();
this.etapa = etapa;
this.tarea = tarea;
inicializarComboBoxTareas();
}
private void borrarAntecesora()
{
ITarea seleccionada = antecesoraSeleccionada();
agregarAntecesorasAntesElminacion(seleccionada);
tarea.Antecesoras.Remove(antecesoraSeleccionada());
tarea.AgregarModificacion("Eliminada antecesora " + seleccionada.ToString());
contexto.ModificarTarea(tarea);
}
public VentanaDetallesTarea(ITarea tarea, bool esNueva, IContextoGestorProyectos contexto)
{
InitializeComponent();
this.contexto = contexto;
this.tarea = contexto.ObtenerTarea(tarea.TareaID);
this.tarea.Contexto = contexto;
this.esNuevaTarea = esNueva;
InicializarComponentes();
}
private void agregarAntecesorasAntesElminacion(ITarea seleccionada)
{
foreach (Tarea antecesora in seleccionada.Antecesoras)
{
if (!tarea.Antecesoras.Contains(antecesora))
{
tarea.Antecesoras.Add(antecesora);
}
}
}
private void eliminarSubtareasSiTiene(ITarea tarea)
{
if (esTareaCompuesta(tarea))
{
for (int i = (((TareaCompuesta)tarea).Subtareas).Count - 1; i >= 0; i--)
{
EliminarTarea((((TareaCompuesta)tarea).Subtareas)[i].TareaID);
}
}
}
private int iconoTarea(ITarea tarea)
{
if (esCompuesta(tarea))
{
return(0);
}
else
{
return(1);
}
}
public void ClonarPrueba(string nombre, int duracionPendiente, string fechaInicio, string fechaFin)
{
TareaCompuesta tarea = new TareaCompuesta(new ContextoGestorProyectos())
{
Nombre = nombre,
FechaInicio = DateTime.Parse(fechaInicio)
};
ITarea tareaClonada = tarea.Clonar();
Assert.Equal(tarea, tareaClonada);
}
public void EliminarTarea(int id)
{
ITarea tarea = ObtenerTarea(id);
eliminarPersonasEnTarea(tarea);
eliminarAntecesoras(tarea);
eliminarSubtareasSiTiene(tarea);
Tareas.Remove(Tareas.Find(id));
SaveChanges();
}
private string crearMensajeElminacion(ITarea tarea)
{
if (esCompuesta(tarea))
{
return("¿Seguro desea eliminar esta subtarea compuesta?\n" +
"Esto eliminará todas las subtareas que la componen.");
}
else
{
return("¿Seguro desea eliminar esta subtarea?");
}
}
public ITarea ObtenerTarea(int id)
{
ITarea t = null;
var tareas = from r in Tareas.Include(ENTIDAD_PERSONA)//.Include("Antecesoras").Include("Subtareas")
where r.TareaID == id
select r;
foreach (Tarea ta in tareas)
{
t = ta;
}
return(t);
}
private void editarTareaVentana(ITarea tarea, bool esNuevaTarea)
{
VentanaDetallesTarea ventanaDetalles = new VentanaDetallesTarea(tarea, esNuevaTarea, contexto);
ventanaDetalles.ShowDialog(this);
foreach (Form formulario in Application.OpenForms)
{
if (estaCerradaVentanaDetallesTarea(formulario))
{
inicializarComponentes();
break;
}
}
}
private TreeNode generarNodoArbol(ITarea tarea)
{
TreeNode nodoRetorno = new TreeNode();
if (esCompuesta(tarea))
{
nodoRetorno = generarNodoArbolTareaCompuesta((TareaCompuesta)tarea);
}
else
{
nodoRetorno = generarNodoArbolTareaSimple(tarea);
}
return(nodoRetorno);
}
public void CloneadoTareaSimple(string nombre,
string fechaInicio, string fechaFinalizacion)
{
Tarea tarea = new TareaSimple(new ContextoGestorProyectos())
{
Nombre = nombre,
FechaInicio = DateTime.Parse(fechaInicio),
FechaFinalizacion = DateTime.Parse(fechaFinalizacion)
};
ITarea tareaCloneada = tarea.Clonar();
Assert.Equal(tarea, tareaCloneada);
}
private void cambiarATareaSimpleSimple(TareaCompuesta tareaCompuesta, DateTime fechaFinalizacion, int duracionPendiente)
{
if (tareaCompuesta.Subtareas.Count == 0)
{
tarea = new TareaSimple(contexto)
{
Nombre = tarea.Nombre,
FechaInicio = tareaCompuesta.FechaInicio,
FechaFinalizacion = fechaFinalizacion,
DuracionPendiente = duracionPendiente,
Prioridad = tareaCompuesta.Prioridad,
Antecesoras = tareaCompuesta.Antecesoras,
Descripcion = tareaCompuesta.Descripcion,
Objetivo = tareaCompuesta.Objetivo,
Personas = tareaCompuesta.Personas
};
}
}
private void buttonGuardar_Click(object sender, EventArgs e)
{
ITarea tareaAnterior = tarea.Clonar();
bool confirmacion = AyudanteVisual.CartelConfirmacion(crearMensaje(), "Impacto en la duracion del proyecto");
if (!confirmacion && esNuevaTarea)
{
eliminarTareaActual();
this.Close();
}
else if (!(confirmacion || esNuevaTarea))
{
InicializarComponentes();
}
else if (confirmacion)
{
asignarValoresTarea();
}
Close();
}
public void ModificarTarea(ITarea tarea)
{
var t = Tareas.Find(tarea.TareaID);
t.Nombre = tarea.Nombre;
t.Objetivo = tarea.Objetivo;
t.Descripcion = tarea.Descripcion;
t.DuracionEstimada = tarea.DuracionEstimada;
t.Personas = tarea.Personas;
t.Antecesoras = tarea.Antecesoras;
t.FechaInicio = tarea.FechaInicio;
t.Prioridad = tarea.Prioridad;
if (esTareaCompuesta(tarea))
{
((TareaCompuesta)t).Subtareas = ((TareaCompuesta)tarea).Subtareas;
}
else
{
((TareaSimple)t).FechaFinalizacion = ((TareaSimple)tarea).FechaFinalizacion;
}
SaveChanges();
}
public bool AdicionaTarea(ITarea tarea)
{
Tarea t = tarea as Tarea;
if (arbol == null)
{
arbol = new IntervalTree <Tarea, DateTime>(t, Color.Black);
}
foreach (Tarea item in arbol.Overlap(t))
{
if (!item.Equals(t) && CompartenRecursos(t, item))
{
return(false);
}
}
IntervalTree <Tarea, DateTime> .InsertKey(t, arbol);
foreach (Tarea item in t.Subtareas)
{
IntervalTree <Tarea, DateTime> .InsertKey(item, arbol);
}
return(true);
}
private void asignarValoresTarea()
{
cambiarNombreTarea();
cambiarObjetivoTarea();
cambiarPrioridadTarea();
cambiarDescripcionTarea();
cambiarFechaDeInicio();
IProyecto padre = tarea.ObtenerProyectoPadre();
String modificacion = "La duración pendiente se modificó de " + padre.CalcularDuracionPendiente();
if (!esCompuesta(tarea))
{
TareaSimple tareaSimple = (TareaSimple)tarea;
cambiarDuracionPendiente(tareaSimple);
cambiarFechaFinalizacion(tareaSimple);
tarea = tareaSimple;
}
tarea.DuracionEstimada = Int32.Parse(textBoxDuracionEstimada.Text);
contexto.ModificarTarea(tarea);
padre = tarea.ObtenerProyectoPadre();
modificacion += " a " + padre.CalcularDuracionPendiente();
padre.AgregarModificacion(modificacion);
contexto.ModificarProyecto(padre);
}
public bool ModificarTareaUsuarioComun(ITarea tarea)
{
throw new NotImplementedException();
}
private static bool EsUnaTareaSimple(ITarea tarea)
{
return(tarea.GetType() == typeof(TareaSimple) || tarea.GetType().BaseType == typeof(TareaSimple));
}
private static String GenerarTextoAMostrar(ITarea tarea)
{
return(tarea.ToString());
}
private static bool esTareaCompuesta(ITarea tarea)
{
return(tarea.GetType() == typeof(TareaCompuesta) || tarea.GetType().BaseType == typeof(TareaCompuesta));
}
