dateorganizer.java

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

/**
 *   Copyright 2004 Carlos Silva A.
 * 
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License. 
 *   You may obtain a copy of the License at  
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 * 
 */
package jgantt.model;

import java.io.IOException;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;

import jgantt.Messages;

/**
 * DateOrganizer controla la vigencia de fechas.
 * 
 * TODO: Soporte a tareas con duracion menor a un dia 
 * <p>$Date: 2005/06/12 09:52:48 $</p> 
 * @version $Revision: 1.12 $
 * @author {user}
 */
public class DateOrganizer {
	/**
	 * Hora de Inicio de la jornada
	 */
	byte startHH = 9;

	/**
	 * Minutos de Inicio de la jornada
	 */
	byte startMM = 0;

	/**
	 * Dias habiles en la semana
	 * Comenzando desde lunes
	 */
	boolean laborDays[] = { true, true, true, true, true, false, false };

	/**
	 * Horas de trabajo diario
	 */
	int workHours = 8;
	/**
	 * Minutos de trabajo diario
	 */
	int workMinutes = 00;

	/**
	 * Asigna las horas trabajables cada dia.
	 * 
	 * @param hh horas trabajables
	 * @param mm minutos trabajables, puede ser mayor a 60.
	 */
	public void setWorktime(int hh, int mm) {
		workHours = hh + (mm / 60);
		workMinutes = mm % 60;
	}

	/**
	 * Retorna los minutos trabajables cada dia
	 *
	 */
	public int getWorktime() {
		return workHours * 60 + workMinutes;
	}

	/**
	 * Dias feriados en la forma de un Set con objetos de tipo java.util.Date.
	 * Cada objeto de este set debe contener una fecha (sin hora, minutos, segundos ni milesimas)
	 */
	Set holidays = new HashSet();
	
	/**
	 * extraWorkDays, feriados en la forma de un Set con objetos de tipo java.util.Date.
	 * Cada objeto de este set debe contener una fecha (sin hora, minutos, segundos ni milesimas)
	 */
	Set extraWorkDays= new HashSet();	

	// transient
	/**
	 * Calendario para calculos internos
	 */
	transient java.util.Calendar cal = new java.util.GregorianCalendar();
	
	/**
	 * Constructor para DateOrganizer
	 */
	public DateOrganizer() {
		super();
	}

	/**
	 * Asigna el arreglo con los dias habiles 
	 * arr[0]=lunes.
	 */
	public void setLaborDays(boolean arr[]) throws GanttException {
		laborDays = arr;
		int laborDaysCount=0;
		for (int i = 0; i < 7; i++)
			if (laborDays[i])
				laborDaysCount++;
		if (laborDaysCount == 0) {
			throw new GanttException(Messages.getString("dateorg.error.noLaborDays")); //$NON-NLS-1$
		}
	}	

	/**
	 * Retorna la misma fecha con horas,minutos y segundos vacios.
	 * @param d
	 * @return
	 */
	private Date truncDate(Date d) {
		cal.setTime(d);
		cal.set(java.util.Calendar.HOUR_OF_DAY, 0);
		cal.set(java.util.Calendar.MINUTE, 0);
		cal.set(java.util.Calendar.SECOND, 0);
		cal.set(java.util.Calendar.MILLISECOND, 0);
		return cal.getTime();
	}
	/**
	 * Retorna la primera hora del dia indicado que sea trabajable, i.e., 
	 * cambia la hora de inicio de la jornada.
	 * Actualmente normaliza a 00:00:00.000 horas
	 * pero debe normalizar a las 00:00 horas del dia
	 * del milisegundo siguiente	 
	 */
	public Date getNormalizedStartDate(Date d) {
		return truncDate(d);
	}

	/**
	 * Retorna el d韆 habil siguiente considerando feriados
	 */
	public Date nextLaborDay(Date d) {
		cal.setTime(d);
		boolean tryNextDay = false;
		do {
			tryNextDay = isLaborable();
			if (tryNextDay) {
				cal.add(java.util.Calendar.DATE, 1);
			}
		} while (tryNextDay);

		return cal.getTime();
	}
	
	
	/**
	 * Nueva fecha luego del termino de la anterior mas un delay en dias
	 */
	public Date getNextLaborableDate(Date d, int delay) {
		// normalizar a las 00:00 horas del dia del milisegundo siguiente
		cal.setTime(d);
		cal.add(java.util.Calendar.MILLISECOND, 1);
		 
		int direction = (delay<0 ? -1 : 1);
		int skiped = 0;
		if (direction < 0) {
			cal.add(java.util.Calendar.DATE, -1);
			skiped = -1;
		}
		boolean laborable = isLaborable();
		while ((skiped != delay) || (!laborable)) {
			if (laborable)
				skiped += direction;
			cal.add(java.util.Calendar.DATE, direction);
			laborable = isLaborable();
		}
		return cal.getTime();
	}
	
	/**
	 * Para fechas de termino, resta un milisegundo (para llegar al dia anterior) y
	 * si el dia anterior no es habil, continua devolviendose.
	 * 
	 * @param d fecha de termino calculada
	 * @return nueva fecha de termino normalizada
	 */
	public Date getMaximumFinishDate(Date d) {
		// restar un milisegundo
		cal.setTime(d);
		cal.add(java.util.Calendar.MILLISECOND, -1);
		// si no es trabajable, retroceder hasta que lo sea.
		boolean laborable = isLaborable();
		while (!laborable) {
			cal.add(java.util.Calendar.DATE, -1);
			laborable = isLaborable();
		}
		return cal.getTime();
	}

	/**
	 * Calcula una cantidad de dias en el futuro de dias sin 
	 * incluir feriados ni festivos.
	 */
	public Date getFinishDate(Date start, int workDays) {
		cal.setTime(start);
		int added = 0;
		boolean laborable = isLaborable();
		while ((added < workDays) || (!laborable)) {
			//while (added < workDays)  {  // nuevo
			if (laborable)
				added++;
			cal.add(java.util.Calendar.DATE, 1);
			laborable = isLaborable();
		}
		return getMaximumFinishDate(cal.getTime());
	}

	/**
	 * Calcula el numero de dias habiles entre dos fechas
	 * las fecha from comienza de 00:00:00.000 y la fecha to 
	 * termina en 23:59:59.999 del ultimo dia trabajado.
	 */
	public int daysBetween(Date from, Date to) {
		cal.setTime(from);
		int added = 0;
		boolean laborable = isLaborable();
		while (cal.getTime().before(to)) {
			if (isLaborable())
				added++;
			cal.add(java.util.Calendar.DATE, 1);
		}
		return added;
	}

	// protegidas
	/**
	 * Transforma desde DOW de la clase Calendar a numeros basados
	 * en lunes=0.
	 */
	public int DOW(int dow) {
		switch (dow) {
			case java.util.Calendar.SUNDAY :
				return 6;
			case java.util.Calendar.MONDAY :
				return 0;
			case java.util.Calendar.TUESDAY :
				return 1;
			case java.util.Calendar.WEDNESDAY :
				return 2;
			case java.util.Calendar.THURSDAY :
				return 3;
			case java.util.Calendar.FRIDAY :
				return 4;
			case java.util.Calendar.SATURDAY :
				return 5;
		}
		throw new RuntimeException(Messages.getString("dateorg.error.badDOW")); //$NON-NLS-1$
	}

	/**
	 * Determina si una fecha en particular es laborable, para esto
	 * considera dias de la semana, feriados y dias extra.
	 * 
	 * Usa la fecha definida en el el calendario interno (cal)
	 * normalizandola y luego retornandola.
	 * 
	 * @return true si es un dia laborable
	 */
	private boolean isLaborable() {		
		boolean result;
		Date d = cal.getTime();		
		cal.set(java.util.Calendar.HOUR_OF_DAY, 0);
		cal.set(java.util.Calendar.MINUTE, 0);
		cal.set(java.util.Calendar.SECOND, 0);
		cal.set(java.util.Calendar.MILLISECOND, 0);
		if(laborDays[DOW(cal.get(java.util.Calendar.DAY_OF_WEEK))])
			result = !holidays.contains(cal.getTime());				
		else
			result = extraWorkDays.contains(cal.getTime());
		cal.setTime(d);
		return result;		
	}

	/**
	 * Determina si una fecha en particular es laborable, se 
	 * implemente a traves de {@link #isLaborDay}.
	 *  
	 * @param d fecha
	 * @return true si es un dia laborable
	 */
	public boolean isLaborable(Date d) {
		cal.setTime(d);		
		return isLaborable();
	}

	/**
	 * Consulta si una fecha esta en la lista de feriados		 
	 * @return true si es feriado
	 */
	private boolean isHoliday() {
		Date d = cal.getTime();
		cal.set(java.util.Calendar.HOUR_OF_DAY, 0);
		cal.set(java.util.Calendar.MINUTE, 0);
		cal.set(java.util.Calendar.SECOND, 0);
		cal.set(java.util.Calendar.MILLISECOND, 0);
		boolean ih = holidays.contains(cal.getTime());
		cal.setTime(d);
		return ih;
	}
	
	/**
	 * Consulta si una fecha esta en la lista de fechas
	 * extraordinarias.
	 * @return true si es un dia extra de trabajo
	 */
	private boolean isExtraWorkDay() {
		Date d = cal.getTime();
		cal.set(java.util.Calendar.HOUR_OF_DAY, 0);
		cal.set(java.util.Calendar.MINUTE, 0);
		cal.set(java.util.Calendar.SECOND, 0);
		cal.set(java.util.Calendar.MILLISECOND, 0);
		boolean result = extraWorkDays.contains(cal.getTime());
		cal.setTime(d);
		return result;
	}
	
	

	/**
	 * Consulta si una fecha es feriado (no no fin de semana).
	 * 
	 * @param d fecha a consultar
	 * @return true si es feriado
	 */
	public boolean isHoliday(Date d) {
		cal.setTime(d);
		return isHoliday();
	}

	/**
	 * Determina si un dia de la semana es un dia laborable.
	 * No considera feriados ni dias extra.
	 * 
	 * @param d dia de la semana en escala 0=lunes, 6=domingo
	 * @return true si es un dia laborable
	 */
	public boolean isLaborDay(int d) {
		return laborDays[d];
	}
	
	/**
	 * Genera una indicacion del dia de la semana en la escala 0=lunes, 6=domingo.
	 * @param d fecha
	 * @return dia de la semana
	 */
	public int dow(Date d) {
		cal.setTime(d);
		return DOW(cal.get(java.util.Calendar.DAY_OF_WEEK));
	}

	// serializacion
	private void readObject(java.io.ObjectInputStream in)
		throws IOException, ClassNotFoundException {
		in.defaultReadObject();
		// reiniciar variables transientes...
		cal = new java.util.GregorianCalendar();
	}

	/**
	 *Asigna los dias feriados en la forma de un Set con objetos de tipo java.util.Date.
	 * Cada objeto de este set debe contener una fecha (sin hora, minutos, segundos ni milesimas) 
	 */
	public void setHolidays(Set s) {
		holidays.clear();
		holidays.addAll(s);
	}
	/**
	 * Retorna la lista de feriados existente
	 * Esta lista puede ser modificada por la aplicacion
	 * pero debera forzarse un recalculo completo
	 * @return Set con los feriados
	 */
	public Set getHolidays() {
		return holidays;
	}

	/**
	 * Agrega un dia feriado a la lista.
	 */
	public void addHoliday(Date d) {
		holidays.add(truncDate(d));
	}

	/**
	 * Agrega un dia feriado a la lista.
	 */
	public void removeHoliday(Date d) {
		holidays.remove(truncDate(d));
	}

	
	/**
	 * Retorna la lista de dias extra existentes.
	 * Esta lista puede ser modificada por la aplicacion
	 * pero debera forzarse un recalculo completo
	 * @return Set con los feriados
	 */
	public Set getExtraWorkDays() {
		return extraWorkDays;
	}

	/**
	 * Agrega un dia extra a la lista.
	 */
	public void addExtraWorkDays(Date d) {
		extraWorkDays.add(truncDate(d));
	}

	/**
	 * Agrega un dia extra a la lista.
	 */
	public void removeExtraWorkDays(Date d) {
		extraWorkDays.remove(truncDate(d));
	}

	/**
	 * Permite asignar automaticamente un feriado o un dia extra.
	 * @param date Fecha 
	 * @param set true si la fecha debe ser laborable
	 */
	public void setLaborable(Date date, boolean set){
		date = truncDate(date);
		if (laborDays[dow(date)])
			if (set)
				holidays.remove(date);
			else				
				holidays.add(date);
		else
			if (set)
				extraWorkDays.add(date);
			else
				extraWorkDays.remove(date);		
	}
}