NEW - bug 202181: Make TaskActivityManager thread safe

https://bugs.eclipse.org/bugs/show_bug.cgi?id=202181

1 files changed, 238 insertions, 6 deletions

diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskActivityManager.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskActivityManager.java
index 58ddbfe73..94d629eac 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskActivityManager.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/TaskActivityManager.java
@@ -8,8 +8,10 @@
 
 package org.eclipse.mylyn.internal.tasks.core;
 
+import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Date;
+import java.util.GregorianCalendar;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -31,16 +33,34 @@ import org.eclipse.mylyn.tasks.core.TaskList;
 import org.eclipse.mylyn.tasks.core.TaskRepositoryManager;
 
 /**
- * Manager for Task timing and scheduling including due dates
+ * Manager for Task timing, scheduling, due dates, and activation history
+ * 
+ * TODO: Consider extracting a TaskPlanningManager to hold scheduling and calendar ranges
  * 
  * @since 2.1
  * @author Rob Elves
  */
 public class TaskActivityManager {
 
-	private int startHour = 9;
+	private static final int NUM_WEEKS_PREVIOUS_START = -1;
 
-	private int endHour = 17;
+	private static final int NUM_WEEKS_PREVIOUS_END = -1;
+
+	private static final int NUM_WEEKS_NEXT = 1;
+
+	private static final int NUM_WEEKS_FUTURE_START = 2;
+
+	private static final int NUM_WEEKS_PAST_END = -2;
+
+	private static final String DESCRIPTION_THIS_WEEK = "This Week";
+
+	private static final String DESCRIPTION_PREVIOUS_WEEK = "Previous Week";
+
+	private static final String DESCRIPTION_NEXT_WEEK = "Next Week";
+
+	private static final String DESCRIPTION_FUTURE = "Future";
+
+	private static final String DESCRIPTION_PAST = "Past";
 
 	private SortedMap<Calendar, Set<AbstractTask>> scheduledTasks = new TreeMap<Calendar, Set<AbstractTask>>();
 
@@ -50,8 +70,26 @@ public class TaskActivityManager {
 
 	private Map<AbstractTask, SortedMap<Calendar, Long>> taskElapsedTimeMap = new ConcurrentHashMap<AbstractTask, SortedMap<Calendar, Long>>();
 
+	private List<ScheduledTaskContainer> scheduleWeekDays = new ArrayList<ScheduledTaskContainer>();
+
+	private ArrayList<ScheduledTaskContainer> scheduleContainers = new ArrayList<ScheduledTaskContainer>();
+
+	private ScheduledTaskContainer scheduledThisWeek;
+
+	private ScheduledTaskContainer scheduledNextWeek;
+
+	private ScheduledTaskContainer scheduledFuture;
+
+	private ScheduledTaskContainer scheduledPast;
+
+	private ScheduledTaskContainer scheduledPrevious;
+
 	private int timeTicks;
 
+	private int startHour = 9;
+
+	private int endHour = 17;
+
 	private boolean taskActivityHistoryInitialized = false;
 
 	private TaskList taskList;
@@ -62,6 +100,8 @@ public class TaskActivityManager {
 
 	private int endDay = Calendar.SUNDAY;
 
+	private Date startTime = new Date();
+
 	private static TaskActivityManager INSTANCE;
 
 	private TaskActivityManager() {
@@ -127,7 +167,8 @@ public class TaskActivityManager {
 		taskElapsedTimeMap.clear();
 	}
 
-	public void reloadTimingData() {
+	public void reloadTimingData(Date date) {
+		startTime = date;
 		taskActivityHistoryInitialized = false;
 		clear();
 		List<InteractionEvent> events = ContextCorePlugin.getContextManager()
@@ -136,9 +177,8 @@ public class TaskActivityManager {
 		for (InteractionEvent event : events) {
 			parseInteractionEvent(event);
 		}
-
 		reloadScheduledData();
-
+		setupCalendarRanges();
 		taskActivityHistoryInitialized = true;
 	}
 
@@ -492,4 +532,196 @@ public class TaskActivityManager {
 		return false;
 	}
 
+	/**
+	 * TODO: move to activity manager
+	 */
+	private void setupCalendarRanges() {
+
+		scheduleContainers.clear();
+		scheduleWeekDays.clear();
+
+		int startDay = TaskActivityManager.getInstance().getStartDay();
+		//int endDay = TaskActivityManager.getInstance().getEndDay();
+		// scheduledStartHour =
+		// TasksUiPlugin.getDefault().getPreferenceStore().getInt(
+		// TaskListPreferenceConstants.PLANNING_STARTHOUR);
+
+//		scheduledEndHour = TasksUiPlugin.getDefault().getPreferenceStore().getInt(
+//				TasksUiPreferenceConstants.PLANNING_ENDHOUR);
+
+		Calendar pastStart = GregorianCalendar.getInstance();
+		pastStart.setTimeInMillis(0);
+//		pastStart.setFirstDayOfWeek(startDay);
+//		pastStart.setTime(startTime);
+//		pastStart.add(Calendar.WEEK_OF_YEAR, NUM_WEEKS_PAST_START);
+//		snapToStartOfWeek(pastStart);
+		GregorianCalendar pastEnd = new GregorianCalendar();
+		pastEnd.setFirstDayOfWeek(startDay);
+		pastEnd.setTime(startTime);
+		pastEnd.add(Calendar.WEEK_OF_YEAR, NUM_WEEKS_PAST_END);
+		TaskActivityUtil.snapEndOfWeek(pastEnd);
+		scheduledPast = new ScheduledTaskContainer(this, pastStart.getTime(), pastEnd.getTime(), DESCRIPTION_PAST);
+		scheduleContainers.add(scheduledPast);
+
+		scheduleWeekDays.clear();
+		for (int x = startDay; x < (startDay + 7); x++) {
+			GregorianCalendar dayStart = new GregorianCalendar();
+			GregorianCalendar dayEnd = new GregorianCalendar();
+			dayStart.setFirstDayOfWeek(startDay);
+			dayEnd.setFirstDayOfWeek(startDay);
+			if (x > 7) {
+				dayStart.set(Calendar.DAY_OF_WEEK, x % 7);
+				dayEnd.set(Calendar.DAY_OF_WEEK, x % 7);
+			} else {
+				dayStart.set(Calendar.DAY_OF_WEEK, x);
+				dayEnd.set(Calendar.DAY_OF_WEEK, x);
+			}
+
+			dayStart.set(Calendar.HOUR_OF_DAY, 0);
+			dayStart.set(Calendar.MINUTE, 0);
+			dayStart.set(Calendar.SECOND, 0);
+			dayStart.set(Calendar.MILLISECOND, 0);
+			dayStart.getTime();
+
+			dayEnd.set(Calendar.HOUR_OF_DAY, dayEnd.getMaximum(Calendar.HOUR_OF_DAY));
+			dayEnd.set(Calendar.MINUTE, dayEnd.getMaximum(Calendar.MINUTE));
+			dayEnd.set(Calendar.SECOND, dayEnd.getMaximum(Calendar.SECOND));
+			dayEnd.set(Calendar.MILLISECOND, dayEnd.getMaximum(Calendar.MILLISECOND));
+			dayEnd.getTime();
+
+			String summary = "<unknown>";
+			switch (dayStart.get(Calendar.DAY_OF_WEEK)) {
+			case Calendar.MONDAY:
+				summary = "Monday";
+				break;
+			case Calendar.TUESDAY:
+				summary = "Tuesday";
+				break;
+			case Calendar.WEDNESDAY:
+				summary = "Wednesday";
+				break;
+			case Calendar.THURSDAY:
+				summary = "Thursday";
+				break;
+			case Calendar.FRIDAY:
+				summary = "Friday";
+				break;
+			case Calendar.SATURDAY:
+				summary = "Saturday";
+				break;
+			case Calendar.SUNDAY:
+				summary = "Sunday";
+				break;
+			}
+			ScheduledTaskContainer day = new ScheduledTaskContainer(this, dayStart, dayEnd, summary);
+			scheduleWeekDays.add(day);
+			scheduleContainers.add(day);
+		}
+
+		GregorianCalendar currentBegin = new GregorianCalendar();
+		currentBegin.setFirstDayOfWeek(startDay);
+		currentBegin.setTime(startTime);
+		TaskActivityUtil.snapStartOfWorkWeek(currentBegin);
+		GregorianCalendar currentEnd = new GregorianCalendar();
+		currentEnd.setFirstDayOfWeek(startDay);
+		currentEnd.setTime(startTime);
+		TaskActivityUtil.snapEndOfWeek(currentEnd);
+		scheduledThisWeek = new ScheduledTaskContainer(this, currentBegin, currentEnd, DESCRIPTION_THIS_WEEK);
+		// dateRangeContainers.add(activityThisWeek);
+
+		GregorianCalendar nextStart = new GregorianCalendar();
+		nextStart.setFirstDayOfWeek(startDay);
+		nextStart.setTime(startTime);
+		nextStart.add(Calendar.WEEK_OF_YEAR, NUM_WEEKS_NEXT);
+		TaskActivityUtil.snapStartOfWorkWeek(nextStart);
+		GregorianCalendar nextEnd = new GregorianCalendar();
+		nextEnd.setFirstDayOfWeek(startDay);
+		nextEnd.setTime(startTime);
+		nextEnd.add(Calendar.WEEK_OF_YEAR, NUM_WEEKS_NEXT);
+		TaskActivityUtil.snapEndOfWeek(nextEnd);
+		scheduledNextWeek = new ScheduledTaskContainer(this, nextStart.getTime(), nextEnd.getTime(),
+				DESCRIPTION_NEXT_WEEK);
+		scheduleContainers.add(scheduledNextWeek);
+
+		GregorianCalendar futureStart = new GregorianCalendar();
+		futureStart.setFirstDayOfWeek(startDay);
+		futureStart.setTime(startTime);
+		futureStart.add(Calendar.WEEK_OF_YEAR, NUM_WEEKS_FUTURE_START);
+		TaskActivityUtil.snapStartOfWorkWeek(futureStart);
+		GregorianCalendar futureEnd = new GregorianCalendar();
+		futureEnd.setFirstDayOfWeek(startDay);
+		futureEnd.setTime(startTime);
+		futureEnd.add(Calendar.YEAR, 1);
+		TaskActivityUtil.snapEndOfWeek(futureEnd);
+		scheduledFuture = new ScheduledTaskContainer(this, futureStart.getTime(), futureEnd.getTime(),
+				DESCRIPTION_FUTURE);
+		scheduleContainers.add(scheduledFuture);
+
+		GregorianCalendar previousStart = new GregorianCalendar();
+		previousStart.setFirstDayOfWeek(startDay);
+		previousStart.setTime(startTime);
+		previousStart.add(Calendar.WEEK_OF_YEAR, NUM_WEEKS_PREVIOUS_START);
+		TaskActivityUtil.snapStartOfWorkWeek(previousStart);
+		GregorianCalendar previousEnd = new GregorianCalendar();
+		previousEnd.setFirstDayOfWeek(startDay);
+		previousEnd.setTime(startTime);
+		previousEnd.add(Calendar.WEEK_OF_YEAR, NUM_WEEKS_PREVIOUS_END);
+		TaskActivityUtil.snapEndOfWeek(previousEnd);
+		scheduledPrevious = new ScheduledTaskContainer(this, previousStart.getTime(), previousEnd.getTime(),
+				DESCRIPTION_PREVIOUS_WEEK);
+		scheduleContainers.add(scheduledPrevious);
+	}
+
+	public List<ScheduledTaskContainer> getDateRanges() {
+		return scheduleContainers;
+	}
+
+	public List<ScheduledTaskContainer> getActivityWeekDays() {
+		return scheduleWeekDays;
+	}
+
+	public boolean isWeekDay(ScheduledTaskContainer dateRangeTaskContainer) {
+		return scheduleWeekDays.contains(dateRangeTaskContainer);
+	}
+
+	/** public for testing */
+	public ScheduledTaskContainer getActivityThisWeek() {
+		return scheduledThisWeek;
+	}
+
+	/** public for testing * */
+	public ScheduledTaskContainer getActivityPast() {
+		return scheduledPast;
+	}
+
+	/** public for testing */
+	public ScheduledTaskContainer getActivityFuture() {
+		return scheduledFuture;
+	}
+
+	/** public for testing */
+	public ScheduledTaskContainer getActivityNextWeek() {
+		return scheduledNextWeek;
+	}
+
+	/** public for testing */
+	public ScheduledTaskContainer getActivityPrevious() {
+		return scheduledPrevious;
+	}
+
+	public Date getStartTime() {
+		return startTime;
+	}
+
+	public void scheduleNewTask(AbstractTask newTask) {
+		newTask.setCreationDate(new Date());
+		Calendar newTaskSchedule = Calendar.getInstance();
+		// If past scheduledEndHour set for following day
+		if (newTaskSchedule.get(Calendar.HOUR_OF_DAY) >= getEndHour()) {
+			TaskActivityUtil.snapForwardNumDays(newTaskSchedule, 1);
+		} else {
+			TaskActivityUtil.snapEndOfWorkDay(newTaskSchedule);
+		}
+		setScheduledFor(newTask, newTaskSchedule.getTime());
+	}
 }