task.java

Owing to the applet Gantt chart source yard, already Chinese melt, Gantt chart can demonstrate a Chi

	public String getIndentedName() {
		StringBuffer spaces = new StringBuffer();
		Task p = parentTask;
		while (p != null) {
			spaces.append("  ");
			p = p.parentTask;
		}
		return spaces.toString() + name;
	}

	/**
	 * Agrega una restriccion de la cual esta tarea depende
	 * Si ya existe un constraint entre estas tareas se genera una excepcion.
	 * @param c
	 */
	void addConstraint(Constraint c) throws GanttException {
		c.getMasterTask().checkConstrained(c.getSlaveTask());

		for (Iterator it = c.getMasterTask().childConstraints.iterator();
			it.hasNext();
			) {
			Constraint ct = (Constraint) it.next();
			if (ct.getSlaveTask() == this)
				throw new GanttException(Messages.getString("task.error.dupConstraint")); //$NON-NLS-1$
		}

		c.getMasterTask().childConstraints.addElement(c);
		constraints.addElement(c);
		setDirty();

		project.sendChange(new ProjectChange(this));
	}

	/**
	 * Retorna el largo de la tarea en minutos habiles.
	 * Esta funcion no debe llamar a recalc ya que no se apoya en ella.
	 */
	public int getLength() {
		return length;
	}

	/**
	 * Asigna el largo de la tarea en minutos habiles.
	 */
	public void setLength(int newLength) throws GanttException {
		if (isResume()) {
			throw new GanttException(Messages.getString("task.error.chgLength")); //$NON-NLS-1$
		}
		Command cmd = new SetCommand(this, "setLength", newLength, length);
		length = newLength;
		setDirty();
		project.registerCommand(cmd);
		project.sendChange(new ProjectChange(this));
	}

	/**
	 * Asigna el nombre.
	 */
	public void setName(String newName) {
		Command cmd = new SetCommand(this, "setName", newName, name);
		if (newName == null)
			name = "";
		else
			name = newName;
		project.registerCommand(cmd);
		project.sendChange(new ProjectChange(this));
	}
	/**
	 * Retorna la fecha minima en que la tarea puede comenzar
	 */
	public Date getNotBeforeDate() {
		return notBeforeDate;
	}
	/**
	 * Asigna la fecha minima en que la tarea puede comenzar
	 */
	public void setNotBeforeDate(Date newNotBeforeDate) throws GanttException {
		if (childTasks.size() > 0) {
			throw new GanttException(Messages.getString("task.error.chgNotBeforeDate")); //$NON-NLS-1$
		}

		Command cmd =
			new SetCommand(
				this,
				"setNotBeforeDate",
				newNotBeforeDate,
				notBeforeDate);
		notBeforeDate = newNotBeforeDate;
		setDirty();
		project.registerCommand(cmd);
		project.sendChange(new ProjectChange(this));
	}

	/**
	 * retorna los comentarios asociados a la tarea
	 */
	public String getComments() {
		return comments;
	}
	/**
	 * Asigna los comentarios de la tarea
	 */
	public void setComments(String newComments) {
		Command cmd =
			new SetCommand(this, "setComments", newComments, comments);
		comments = newComments;
		project.registerCommand(cmd);
		project.sendChange(new ProjectChange(this));
	}
	/**
	 * Retorna la fecha calculada de inicio de la tarea
	 * de acuerdo al calendario del proyecto
	 */
	public Date getStartDate() {
		recalc();
		return startDate;
	}

	/**
	 * Retorna la fecha de termino de la tarea en dias reales
	 * Asume que una tarea de un dia se terminan a ultima hora del mismo dia
	 * Todas las tareas comienzan a primera hora del dia.
	 * Solo cuentan los campos de dia (no los de hh,mm,ss y ms)
	 */
	public Date getFinishDate() {
		recalc();
		return finishDate;
	}

	public Vector getChildTasks() {
		return childTasks;
	}

	// Metodos protegidos

	/**
     * Marca la tarea para ser recalculada...
     * Originalmente recalculaba recursivamente:
     * <ul> 
     * <li>los hijos: si depende de otras tareas (incluso indirectamente) 
     * <li>los dependientes
     * <li>La tarea padre
     * </ul>
     * 
	 * Hoy llama a {@link Project#allDirty()} y asigna todas las tareas
     * como sucias, esto elimino muchos errores en el recalculo y no
     * toma tanto tiempo como para ser un problema.
	 * Recursiva sobre las tareas resumen
	 */
	protected void setDirty() {
        project.allDirty();
	}

	/**
	 * Obtiene la fecha de inicio basado solo en contraints y en las restricciones
	 * heredadas de la tarea padre.
	 * <p>Si no hay constraints, se parte desde la fecha de inicio del proyecto.</p>
	 * <p>no afecta el estado de dirty.</p>
	 * 
	 * @returns la fecha de inicio de la tarea
	 */
	protected Date getConstrainedStart() {
		Date cStart = notBeforeDate;
		if (cStart == null)
			cStart = project.getStartDate();
		for (Enumeration e = constraints.elements(); e.hasMoreElements();) {
			Constraint c = (Constraint) e.nextElement();
			Date test = c.getStartDate();
			if ((cStart == null) || (test.after(cStart))) {
				cStart = test;
			}
		}

		//		Si el resumen padre tiene restricciones, se heredan
		if (parentTask != null) {
			Date cDate = parentTask.getConstrainedStart();
			if (cStart.before(cDate)) {
				cStart = cDate;
			}
		} else { // es la tarea principal. ya tiene un startDate
		}

		return cStart;
	}

	/**
	 * Calculo de restricciones
	 * revisar restricciones.
	 * deja el estado limpio (not dirty)
	 */
	protected void recalc() {
		if (!dirty)
			return;

		startDate = getConstrainedStart();
		if (childTasks.size() > 0) { // es tarea resumen? tiene tareas hijas
			// inicio=min({child startdates})			
			Date minChild = null;
			Date maxChild = null;
			for (Enumeration e = childTasks.elements(); e.hasMoreElements();) {
				Task t = (Task) e.nextElement();
				Date cDate = t.getStartDate();
				if ((minChild == null) || (minChild.after(cDate))) {
					minChild = cDate;
				}
				cDate = t.getFinishDate();
				if ((maxChild == null) || (maxChild.before(cDate))) {
					maxChild = cDate;
				}
			}
			if (minChild != null)
				startDate = minChild;
			finishDate = maxChild;

			length =
				project.getDateOrganizer().daysBetween(startDate, finishDate);

			double a = 0, b = 0;
			for (Enumeration e = childTasks.elements(); e.hasMoreElements();) {
				Task t = (Task) e.nextElement();
				a += (t.getLength() * t.getCompleted()) / 100.0;
				b += t.getLength();
			}
			completed = (int) (100.0 * (a / b));
		} else { // es una hoja!			
			finishDate =
				project.getDateOrganizer().getFinishDate(startDate, length);
		}
		dirty = false;
	}
	public Vector getChildConstraints() {
		return childConstraints;
	}
	/**
	 * Retorna los minutos totales asociados a un recurso.
	 * @param r recurso
	 * @return
	 */
	public int getTotalResourceUnits(Resource r) {
		int childUnits = 0;
		if (childTasks.size() != 0) { // es tarea resumen?
			for (Enumeration e = childTasks.elements(); e.hasMoreElements();) {
				Task t = (Task) e.nextElement();
				childUnits += t.getTotalResourceUnits(r);
			}
		}
		return getLocalTotalResourceUnits(r) + childUnits;
	}

	/**
	 * Retorna los minutos totales asociados a un recurso solo en esta tarea.
	 * @param r recurso
	 * @return
	 */
	public int getLocalTotalResourceUnits(Resource r) {
		int units = 0;
		int minutes =
			getLength() * project.getDateOrganizer().workHours * 60
				+ project.getDateOrganizer().workMinutes;
		for (Iterator i = getAsignations().iterator(); i.hasNext();) {
			Asignation a = (Asignation) i.next();
			if (a.getResource().equals(r)) {
				units = (int) (a.getUnits() * minutes / 100.0);
				break;
			}
		}
		return units;
	}

	/**
	 * Retorna los minutos trabajados asociados a un recurso.
	 * @param r recurso
	 * @return
	 */
	public int getWorkedResourceUnits(Resource r) {
		int childUnits = 0;
		if (childTasks.size() != 0) { // es tarea resumen?
			for (Enumeration e = childTasks.elements(); e.hasMoreElements();) {
				Task t = (Task) e.nextElement();
				childUnits += t.getWorkedResourceUnits(r);
			}
		}
		return getLocalWorkedResourceUnits(r) + childUnits;
	}

	/**
	 * Retorna los minutos trabajados asociados a un recurso solo en esta tarea.
	 * @param r recurso
	 * @return
	 */
	public int getLocalWorkedResourceUnits(Resource r) {
		int units = 0;
		int minutes =
			getLength() * project.getDateOrganizer().workHours * 60
				+ project.getDateOrganizer().workMinutes;
		for (Iterator i = getAsignations().iterator(); i.hasNext();) {
			Asignation a = (Asignation) i.next();
			if (a.getResource().equals(r)) {
				units = (int) (a.getUnits() * minutes / 100.0);
				units = (int) (units * getCompleted() / 100.0);
				break;
			}
		}
		return units;
	}

	/**
	 * Asigna el nivel de completitud de la tarea.
	 * @param c completitud en un porcentaje en el rango 0..100
	 */
	public void setCompleted(int newCompleted) {
		if (childTasks.size() != 0) { // es tarea resumen?
			throw new RuntimeException(Messages.getString("task.error.chgCompleted")); //$NON-NLS-1$
		}
		Command cmd =
			new SetCommand(this, "setCompleted", newCompleted, completed);
		completed = newCompleted;
		setDirty();
		project.registerCommand(cmd);
		project.sendChange(new ProjectChange(this));
	}

	/**
	 * Obtiene el porcentaje terminado de una tarea.
	 * En el caso de las tareas resumen, el total se calcula en
	 * la funcion recalc
	 * @return
	 */
	public int getCompleted() {
		return completed;
	}

	/**
	 * Reasigna al recurso con una cantidad de unidades
	 * Si ya esta asignado, lo reasigna.
	 * Si las unidades son cero, se elimina la asignacion
	 * existente (o no se agrega).
	 * @param r
	 * @param u
	 */
	public void addResource(Resource r, int u) {
		removeResource(r);
		if (u == 0) {
			project.sendChange(new ProjectChange(this));
			return;
		}
		Asignation a = new Asignation();
		a.setResource(r);
		a.setUnits(u);
		resources.addElement(a);
		project.sendChange(new ProjectChange(this));
	}

	/**
	 * Remueve un recurso de la lista de recursos
	 * 
	 */
	public void removeResource(Resource r) {
		for (int i = 0; i < resources.size(); i++) {
			Asignation a = (Asignation) resources.elementAt(i);
			if (a.getResource().equals(r)) {
				resources.remove(i);
				return;
			}
		}
		project.sendChange(new ProjectChange(this));
	}

	public Vector getAsignations() {
		return resources;
	}
	/**
	 *  
	 * @param r
	 * @return
	 */
	public int getAsignationUnits(Resource r) {
		for (Iterator i = resources.iterator(); i.hasNext();) {
			Asignation a = (Asignation) i.next();
			if (a.getResource() == r)
				return a.getUnits();
		}
		return 0;
	}
	public Task getParentTask() {
		return parentTask;
	}
	public boolean isChildOf(Task p) {
		Task t = this;
		while ((t.parentTask != null) && (t.parentTask != p)) {
			t = t.parentTask;
		}
		return (p == t.parentTask);
	}

	// serializacion
	private void readObject(java.io.ObjectInputStream in)
		throws IOException, ClassNotFoundException {
		in.defaultReadObject();
		// reiniciar variables transientes...
		dirty = true;

	}

	/**
	 * Retorna un string con las asignaciones de personas
	 * @return
	 */
	public String getCompletionDescription() {
		Vector a = getAsignations();
		StringBuffer toPrint = new StringBuffer(30);
		for (int j = 0; j < a.size(); j++) {
			Asignation asign = (Asignation) a.elementAt(j);
			toPrint.append(" ");
			toPrint.append(asign.getResource().getInitials());
			toPrint.append("[");
			toPrint.append(asign.getUnits());
			toPrint.append("%]");
		}
		//toPrint.append(" - ");
		//toPrint.append(getCompleted());
		//toPrint.append("%");
		return toPrint.toString();
	}

	/**
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		return "Task(" + name + ")";
	}

	int visibleIndex = 0;

	/**
	 * indice visible
	 * @return indice 1..
	 */
	public int getVisibleIndex() {
		return visibleIndex;
	}

	boolean childsVisible = true;
	public boolean getChildsVisible() {
		if (!isResume())
			return true;
		return childsVisible;

	}
	public void setChildsVisible(boolean b) {
		childsVisible = b;
		// reorganizar los ids visibles
		project.rebuildVIds();

		project.registerCommand(
			new SetCommand(this, "setChildsVisible", b, !b));
		project.sendChange(new ProjectChange(this));
	}

	public boolean isVisible() {
		Task p = parentTask;
		while (p != null) {
			if (!p.childsVisible)
				return false;
			p = p.parentTask;
		}
		return true;
	}
	/**
	 * Retorna una referencia al objeto que administra los colores de esta tarea
	 *
	 */
	public TaskColors getTaskColors() {
		if (isResume())
			return project.getGraphColors().defaultResumeColors;
		return project.getGraphColors().defaultTaskColors;
	}

	Vector snapshots = new Vector();

	/**
	 * Almacena el estado de la tarea en un snapshot
	 * @param date
	 * @param name
	 */
	public void takeSnapshot(Date date) {
		snapshots.add(new SnapShot(date, this));
	}
	/**
	 * Quita un snapshot de la lista
	 * @param date
	 */
	public void removeSnapshot(Date date) {
		for (int i = 0; i < snapshots.size(); i++) {
			SnapShot ss = (SnapShot) snapshots.get(i);
			if (ss.date.equals(date)) {
				snapshots.remove(ss);
			}
		}
	}

	public SnapShot getSnapshot(Date d) {
		for (int i = 0; i < snapshots.size(); i++) {
			SnapShot ss = (SnapShot) snapshots.get(i);
			if (ss.date.equals(d))
				return ss;
		}
		return null;
	}

	public static class SnapShot {
		public Date date;
		public Date start, end;
		int completed;
		public SnapShot(Date d, Task t) {
			date = d;
			start = t.getStartDate();
			end = t.getFinishDate();
			completed = t.getCompleted();
		}
		/** 
		 * Constructor para cuando se lee desde un XML.
		 * @param d
		 * @param t
		 */
		public SnapShot(Date d, Date s, Date e, int c) {
			date = d;
			start = s;
			end = e;
			completed = c;
		}
	}
	public int getPriority() {
		return priority;
	}
	public void setPriority(int p) {
		Command cmd = new SetCommand(this, "setPriority", p, priority);
		priority = p;
		project.registerCommand(cmd);
		project.sendChange(new ProjectChange(this));
	}
	public int getMinLength() {
		return minLength;
	}
	public int getMaxLength() {
		return maxLength;
	}
	public void setMinLength(int newLength) {
		Command cmd =
			new SetCommand(this, "setMinLength", newLength, minLength);
		minLength = newLength;
		project.registerCommand(cmd);
		project.sendChange(new ProjectChange(this));

	}
	public void setMaxLength(int l) {
		Command cmd = new SetCommand(this, "setMaxLength", l, maxLength);
		maxLength = l;
		project.registerCommand(cmd);
		project.sendChange(new ProjectChange(this));
	}

	public String getNotes() {
		return notes;
	}

	public void setNotes(String newNotes) {
		Command cmd = new SetCommand(this, "setNotes", newNotes, notes);
		notes = newNotes;
		project.registerCommand(cmd);
		project.sendChange(new ProjectChange(this));
	}

}