code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public ProjectCalendarException getException(Date date)
{
ProjectCalendarException exception = null;
// We're working with expanded exceptions, which includes any recurring exceptions
// expanded into individual entries.
populateExpandedExceptions();
if (!m_expandedExceptions.isEmpty())
{
sortExceptions();
int low = 0;
int high = m_expandedExceptions.size() - 1;
long targetDate = date.getTime();
while (low <= high)
{
int mid = (low + high) >>> 1;
ProjectCalendarException midVal = m_expandedExceptions.get(mid);
int cmp = 0 - DateHelper.compare(midVal.getFromDate(), midVal.getToDate(), targetDate);
if (cmp < 0)
{
low = mid + 1;
}
else
{
if (cmp > 0)
{
high = mid - 1;
}
else
{
exception = midVal;
break;
}
}
}
}
if (exception == null && getParent() != null)
{
// Check base calendar as well for an exception.
exception = getParent().getException(date);
}
return (exception);
} | java |
public ProjectCalendarWeek getWorkWeek(Date date)
{
ProjectCalendarWeek week = null;
if (!m_workWeeks.isEmpty())
{
sortWorkWeeks();
int low = 0;
int high = m_workWeeks.size() - 1;
long targetDate = date.getTime();
while (low <= high)
{
int mid = (low + high) >>> 1;
ProjectCalendarWeek midVal = m_workWeeks.get(mid);
int cmp = 0 - DateHelper.compare(midVal.getDateRange().getStart(), midVal.getDateRange().getEnd(), targetDate);
if (cmp < 0)
{
low = mid + 1;
}
else
{
if (cmp > 0)
{
high = mid - 1;
}
else
{
week = midVal;
break;
}
}
}
}
if (week == null && getParent() != null)
{
// Check base calendar as well for a work week.
week = getParent().getWorkWeek(date);
}
return (week);
} | java |
public Duration getWork(Date date, TimeUnit format)
{
ProjectCalendarDateRanges ranges = getRanges(date, null, null);
long time = getTotalTime(ranges);
return convertFormat(time, format);
} | java |
public Duration getWork(Date startDate, Date endDate, TimeUnit format)
{
DateRange range = new DateRange(startDate, endDate);
Long cachedResult = m_workingDateCache.get(range);
long totalTime = 0;
if (cachedResult == null)
{
//
// We want the start date to be the earliest date, and the end date
// to be the latest date. Set a flag here to indicate if we have swapped
// the order of the supplied date.
//
boolean invert = false;
if (startDate.getTime() > endDate.getTime())
{
invert = true;
Date temp = startDate;
startDate = endDate;
endDate = temp;
}
Date canonicalStartDate = DateHelper.getDayStartDate(startDate);
Date canonicalEndDate = DateHelper.getDayStartDate(endDate);
if (canonicalStartDate.getTime() == canonicalEndDate.getTime())
{
ProjectCalendarDateRanges ranges = getRanges(startDate, null, null);
if (ranges.getRangeCount() != 0)
{
totalTime = getTotalTime(ranges, startDate, endDate);
}
}
else
{
//
// Find the first working day in the range
//
Date currentDate = startDate;
Calendar cal = Calendar.getInstance();
cal.setTime(startDate);
Day day = Day.getInstance(cal.get(Calendar.DAY_OF_WEEK));
while (isWorkingDate(currentDate, day) == false && currentDate.getTime() < canonicalEndDate.getTime())
{
cal.add(Calendar.DAY_OF_YEAR, 1);
currentDate = cal.getTime();
day = day.getNextDay();
}
if (currentDate.getTime() < canonicalEndDate.getTime())
{
//
// Calculate the amount of working time for this day
//
totalTime += getTotalTime(getRanges(currentDate, null, day), currentDate, true);
//
// Process each working day until we reach the last day
//
while (true)
{
cal.add(Calendar.DAY_OF_YEAR, 1);
currentDate = cal.getTime();
day = day.getNextDay();
//
// We have reached the last day
//
if (currentDate.getTime() >= canonicalEndDate.getTime())
{
break;
}
//
// Skip this day if it has no working time
//
ProjectCalendarDateRanges ranges = getRanges(currentDate, null, day);
if (ranges.getRangeCount() == 0)
{
continue;
}
//
// Add the working time for the whole day
//
totalTime += getTotalTime(ranges);
}
}
//
// We are now at the last day
//
ProjectCalendarDateRanges ranges = getRanges(endDate, null, day);
if (ranges.getRangeCount() != 0)
{
totalTime += getTotalTime(ranges, DateHelper.getDayStartDate(endDate), endDate);
}
}
if (invert)
{
totalTime = -totalTime;
}
m_workingDateCache.put(range, Long.valueOf(totalTime));
}
else
{
totalTime = cachedResult.longValue();
}
return convertFormat(totalTime, format);
} | java |
private Duration convertFormat(long totalTime, TimeUnit format)
{
double duration = totalTime;
switch (format)
{
case MINUTES:
case ELAPSED_MINUTES:
{
duration /= (60 * 1000);
break;
}
case HOURS:
case ELAPSED_HOURS:
{
duration /= (60 * 60 * 1000);
break;
}
case DAYS:
{
double minutesPerDay = getMinutesPerDay();
if (minutesPerDay != 0)
{
duration /= (minutesPerDay * 60 * 1000);
}
else
{
duration = 0;
}
break;
}
case WEEKS:
{
double minutesPerWeek = getMinutesPerWeek();
if (minutesPerWeek != 0)
{
duration /= (minutesPerWeek * 60 * 1000);
}
else
{
duration = 0;
}
break;
}
case MONTHS:
{
double daysPerMonth = getParentFile().getProjectProperties().getDaysPerMonth().doubleValue();
double minutesPerDay = getMinutesPerDay();
if (daysPerMonth != 0 && minutesPerDay != 0)
{
duration /= (daysPerMonth * minutesPerDay * 60 * 1000);
}
else
{
duration = 0;
}
break;
}
case ELAPSED_DAYS:
{
duration /= (24 * 60 * 60 * 1000);
break;
}
case ELAPSED_WEEKS:
{
duration /= (7 * 24 * 60 * 60 * 1000);
break;
}
case ELAPSED_MONTHS:
{
duration /= (30 * 24 * 60 * 60 * 1000);
break;
}
default:
{
throw new IllegalArgumentException("TimeUnit " + format + " not supported");
}
}
return (Duration.getInstance(duration, format));
} | java |
private long getTotalTime(ProjectCalendarDateRanges exception, Date date, boolean after)
{
long currentTime = DateHelper.getCanonicalTime(date).getTime();
long total = 0;
for (DateRange range : exception)
{
total += getTime(range.getStart(), range.getEnd(), currentTime, after);
}
return (total);
} | java |
private long getTotalTime(ProjectCalendarDateRanges exception)
{
long total = 0;
for (DateRange range : exception)
{
total += getTime(range.getStart(), range.getEnd());
}
return (total);
} | java |
private long getTotalTime(ProjectCalendarDateRanges hours, Date startDate, Date endDate)
{
long total = 0;
if (startDate.getTime() != endDate.getTime())
{
Date start = DateHelper.getCanonicalTime(startDate);
Date end = DateHelper.getCanonicalTime(endDate);
for (DateRange range : hours)
{
Date rangeStart = range.getStart();
Date rangeEnd = range.getEnd();
if (rangeStart != null && rangeEnd != null)
{
Date canoncialRangeStart = DateHelper.getCanonicalTime(rangeStart);
Date canonicalRangeEnd = DateHelper.getCanonicalTime(rangeEnd);
Date startDay = DateHelper.getDayStartDate(rangeStart);
Date finishDay = DateHelper.getDayStartDate(rangeEnd);
//
// Handle the case where the end of the range is at midnight -
// this will show up as the start and end days not matching
//
if (startDay.getTime() != finishDay.getTime())
{
canonicalRangeEnd = DateHelper.addDays(canonicalRangeEnd, 1);
}
if (canoncialRangeStart.getTime() == canonicalRangeEnd.getTime() && rangeEnd.getTime() > rangeStart.getTime())
{
total += (24 * 60 * 60 * 1000);
}
else
{
total += getTime(start, end, canoncialRangeStart, canonicalRangeEnd);
}
}
}
}
return (total);
} | java |
private long getTime(Date start, Date end, long target, boolean after)
{
long total = 0;
if (start != null && end != null)
{
Date startTime = DateHelper.getCanonicalTime(start);
Date endTime = DateHelper.getCanonicalTime(end);
Date startDay = DateHelper.getDayStartDate(start);
Date finishDay = DateHelper.getDayStartDate(end);
//
// Handle the case where the end of the range is at midnight -
// this will show up as the start and end days not matching
//
if (startDay.getTime() != finishDay.getTime())
{
endTime = DateHelper.addDays(endTime, 1);
}
int diff = DateHelper.compare(startTime, endTime, target);
if (diff == 0)
{
if (after == true)
{
total = (endTime.getTime() - target);
}
else
{
total = (target - startTime.getTime());
}
}
else
{
if ((after == true && diff < 0) || (after == false && diff > 0))
{
total = (endTime.getTime() - startTime.getTime());
}
}
}
return (total);
} | java |
private long getTime(Date start, Date end)
{
long total = 0;
if (start != null && end != null)
{
Date startTime = DateHelper.getCanonicalTime(start);
Date endTime = DateHelper.getCanonicalTime(end);
Date startDay = DateHelper.getDayStartDate(start);
Date finishDay = DateHelper.getDayStartDate(end);
//
// Handle the case where the end of the range is at midnight -
// this will show up as the start and end days not matching
//
if (startDay.getTime() != finishDay.getTime())
{
endTime = DateHelper.addDays(endTime, 1);
}
total = (endTime.getTime() - startTime.getTime());
}
return (total);
} | java |
private long getTime(Date start1, Date end1, Date start2, Date end2)
{
long total = 0;
if (start1 != null && end1 != null && start2 != null && end2 != null)
{
long start;
long end;
if (start1.getTime() < start2.getTime())
{
start = start2.getTime();
}
else
{
start = start1.getTime();
}
if (end1.getTime() < end2.getTime())
{
end = end1.getTime();
}
else
{
end = end2.getTime();
}
if (start < end)
{
total = end - start;
}
}
return (total);
} | java |
public void copy(ProjectCalendar cal)
{
setName(cal.getName());
setParent(cal.getParent());
System.arraycopy(cal.getDays(), 0, getDays(), 0, getDays().length);
for (ProjectCalendarException ex : cal.m_exceptions)
{
addCalendarException(ex.getFromDate(), ex.getToDate());
for (DateRange range : ex)
{
ex.addRange(new DateRange(range.getStart(), range.getEnd()));
}
}
for (ProjectCalendarHours hours : getHours())
{
if (hours != null)
{
ProjectCalendarHours copyHours = cal.addCalendarHours(hours.getDay());
for (DateRange range : hours)
{
copyHours.addRange(new DateRange(range.getStart(), range.getEnd()));
}
}
}
} | java |
private void clearWorkingDateCache()
{
m_workingDateCache.clear();
m_startTimeCache.clear();
m_getDateLastResult = null;
for (ProjectCalendar calendar : m_derivedCalendars)
{
calendar.clearWorkingDateCache();
}
} | java |
private ProjectCalendarDateRanges getRanges(Date date, Calendar cal, Day day)
{
ProjectCalendarDateRanges ranges = getException(date);
if (ranges == null)
{
ProjectCalendarWeek week = getWorkWeek(date);
if (week == null)
{
week = this;
}
if (day == null)
{
if (cal == null)
{
cal = Calendar.getInstance();
cal.setTime(date);
}
day = Day.getInstance(cal.get(Calendar.DAY_OF_WEEK));
}
ranges = week.getHours(day);
}
return ranges;
} | java |
private void populateExpandedExceptions()
{
if (!m_exceptions.isEmpty() && m_expandedExceptions.isEmpty())
{
for (ProjectCalendarException exception : m_exceptions)
{
RecurringData recurring = exception.getRecurring();
if (recurring == null)
{
m_expandedExceptions.add(exception);
}
else
{
for (Date date : recurring.getDates())
{
Date startDate = DateHelper.getDayStartDate(date);
Date endDate = DateHelper.getDayEndDate(date);
ProjectCalendarException newException = new ProjectCalendarException(startDate, endDate);
int rangeCount = exception.getRangeCount();
for (int rangeIndex = 0; rangeIndex < rangeCount; rangeIndex++)
{
newException.addRange(exception.getRange(rangeIndex));
}
m_expandedExceptions.add(newException);
}
}
}
Collections.sort(m_expandedExceptions);
}
} | java |
private Map<String, Table> getIndex(Table table)
{
Map<String, Table> result;
if (!table.getResourceFlag())
{
result = m_taskTablesByName;
}
else
{
result = m_resourceTablesByName;
}
return result;
} | java |
public void saveFile(File file, String type)
{
if (file != null)
{
m_treeController.saveFile(file, type);
}
} | java |
public void addFilter(Filter filter)
{
if (filter.isTaskFilter())
{
m_taskFilters.add(filter);
}
if (filter.isResourceFilter())
{
m_resourceFilters.add(filter);
}
m_filtersByName.put(filter.getName(), filter);
m_filtersByID.put(filter.getID(), filter);
} | java |
public void removeFilter(String filterName)
{
Filter filter = getFilterByName(filterName);
if (filter != null)
{
if (filter.isTaskFilter())
{
m_taskFilters.remove(filter);
}
if (filter.isResourceFilter())
{
m_resourceFilters.remove(filter);
}
m_filtersByName.remove(filterName);
m_filtersByID.remove(filter.getID());
}
} | java |
private void writeProjectProperties()
{
ProjectProperties properties = m_projectFile.getProjectProperties();
m_plannerProject.setCompany(properties.getCompany());
m_plannerProject.setManager(properties.getManager());
m_plannerProject.setName(getString(properties.getName()));
m_plannerProject.setProjectStart(getDateTime(properties.getStartDate()));
m_plannerProject.setCalendar(getIntegerString(m_projectFile.getDefaultCalendar().getUniqueID()));
m_plannerProject.setMrprojectVersion("2");
} | java |
private void writeCalendars() throws JAXBException
{
//
// Create the new Planner calendar list
//
Calendars calendars = m_factory.createCalendars();
m_plannerProject.setCalendars(calendars);
writeDayTypes(calendars);
List<net.sf.mpxj.planner.schema.Calendar> calendar = calendars.getCalendar();
//
// Process each calendar in turn
//
for (ProjectCalendar mpxjCalendar : m_projectFile.getCalendars())
{
net.sf.mpxj.planner.schema.Calendar plannerCalendar = m_factory.createCalendar();
calendar.add(plannerCalendar);
writeCalendar(mpxjCalendar, plannerCalendar);
}
} | java |
private void writeDayTypes(Calendars calendars)
{
DayTypes dayTypes = m_factory.createDayTypes();
calendars.setDayTypes(dayTypes);
List<DayType> typeList = dayTypes.getDayType();
DayType dayType = m_factory.createDayType();
typeList.add(dayType);
dayType.setId("0");
dayType.setName("Working");
dayType.setDescription("A default working day");
dayType = m_factory.createDayType();
typeList.add(dayType);
dayType.setId("1");
dayType.setName("Nonworking");
dayType.setDescription("A default non working day");
dayType = m_factory.createDayType();
typeList.add(dayType);
dayType.setId("2");
dayType.setName("Use base");
dayType.setDescription("Use day from base calendar");
} | java |
private void writeCalendar(ProjectCalendar mpxjCalendar, net.sf.mpxj.planner.schema.Calendar plannerCalendar) throws JAXBException
{
//
// Populate basic details
//
plannerCalendar.setId(getIntegerString(mpxjCalendar.getUniqueID()));
plannerCalendar.setName(getString(mpxjCalendar.getName()));
//
// Set working and non working days
//
DefaultWeek dw = m_factory.createDefaultWeek();
plannerCalendar.setDefaultWeek(dw);
dw.setMon(getWorkingDayString(mpxjCalendar, Day.MONDAY));
dw.setTue(getWorkingDayString(mpxjCalendar, Day.TUESDAY));
dw.setWed(getWorkingDayString(mpxjCalendar, Day.WEDNESDAY));
dw.setThu(getWorkingDayString(mpxjCalendar, Day.THURSDAY));
dw.setFri(getWorkingDayString(mpxjCalendar, Day.FRIDAY));
dw.setSat(getWorkingDayString(mpxjCalendar, Day.SATURDAY));
dw.setSun(getWorkingDayString(mpxjCalendar, Day.SUNDAY));
//
// Set working hours
//
OverriddenDayTypes odt = m_factory.createOverriddenDayTypes();
plannerCalendar.setOverriddenDayTypes(odt);
List<OverriddenDayType> typeList = odt.getOverriddenDayType();
Sequence uniqueID = new Sequence(0);
//
// This is a bit arbitrary, so not ideal, however...
// The idea here is that MS Project allows us to specify working hours
// for each day of the week individually. Planner doesn't do this,
// but instead allows us to specify working hours for each day type.
// What we are doing here is stepping through the days of the week to
// find the first working day, then using the hours for that day
// as the hours for the working day type in Planner.
//
for (int dayLoop = 1; dayLoop < 8; dayLoop++)
{
Day day = Day.getInstance(dayLoop);
if (mpxjCalendar.isWorkingDay(day))
{
processWorkingHours(mpxjCalendar, uniqueID, day, typeList);
break;
}
}
//
// Process exception days
//
Days plannerDays = m_factory.createDays();
plannerCalendar.setDays(plannerDays);
List<net.sf.mpxj.planner.schema.Day> dayList = plannerDays.getDay();
processExceptionDays(mpxjCalendar, dayList);
m_eventManager.fireCalendarWrittenEvent(mpxjCalendar);
//
// Process any derived calendars
//
List<net.sf.mpxj.planner.schema.Calendar> calendarList = plannerCalendar.getCalendar();
for (ProjectCalendar mpxjDerivedCalendar : mpxjCalendar.getDerivedCalendars())
{
net.sf.mpxj.planner.schema.Calendar plannerDerivedCalendar = m_factory.createCalendar();
calendarList.add(plannerDerivedCalendar);
writeCalendar(mpxjDerivedCalendar, plannerDerivedCalendar);
}
} | java |
private void processWorkingHours(ProjectCalendar mpxjCalendar, Sequence uniqueID, Day day, List<OverriddenDayType> typeList)
{
if (isWorkingDay(mpxjCalendar, day))
{
ProjectCalendarHours mpxjHours = mpxjCalendar.getCalendarHours(day);
if (mpxjHours != null)
{
OverriddenDayType odt = m_factory.createOverriddenDayType();
typeList.add(odt);
odt.setId(getIntegerString(uniqueID.next()));
List<Interval> intervalList = odt.getInterval();
for (DateRange mpxjRange : mpxjHours)
{
Date rangeStart = mpxjRange.getStart();
Date rangeEnd = mpxjRange.getEnd();
if (rangeStart != null && rangeEnd != null)
{
Interval interval = m_factory.createInterval();
intervalList.add(interval);
interval.setStart(getTimeString(rangeStart));
interval.setEnd(getTimeString(rangeEnd));
}
}
}
}
} | java |
private void writeResources()
{
Resources resources = m_factory.createResources();
m_plannerProject.setResources(resources);
List<net.sf.mpxj.planner.schema.Resource> resourceList = resources.getResource();
for (Resource mpxjResource : m_projectFile.getResources())
{
net.sf.mpxj.planner.schema.Resource plannerResource = m_factory.createResource();
resourceList.add(plannerResource);
writeResource(mpxjResource, plannerResource);
}
} | java |
private void writeResource(Resource mpxjResource, net.sf.mpxj.planner.schema.Resource plannerResource)
{
ProjectCalendar resourceCalendar = mpxjResource.getResourceCalendar();
if (resourceCalendar != null)
{
plannerResource.setCalendar(getIntegerString(resourceCalendar.getUniqueID()));
}
plannerResource.setEmail(mpxjResource.getEmailAddress());
plannerResource.setId(getIntegerString(mpxjResource.getUniqueID()));
plannerResource.setName(getString(mpxjResource.getName()));
plannerResource.setNote(mpxjResource.getNotes());
plannerResource.setShortName(mpxjResource.getInitials());
plannerResource.setType(mpxjResource.getType() == ResourceType.MATERIAL ? "2" : "1");
//plannerResource.setStdRate();
//plannerResource.setOvtRate();
plannerResource.setUnits("0");
//plannerResource.setProperties();
m_eventManager.fireResourceWrittenEvent(mpxjResource);
} | java |
private void writeTasks() throws JAXBException
{
Tasks tasks = m_factory.createTasks();
m_plannerProject.setTasks(tasks);
List<net.sf.mpxj.planner.schema.Task> taskList = tasks.getTask();
for (Task task : m_projectFile.getChildTasks())
{
writeTask(task, taskList);
}
} | java |
private void writeTask(Task mpxjTask, List<net.sf.mpxj.planner.schema.Task> taskList) throws JAXBException
{
net.sf.mpxj.planner.schema.Task plannerTask = m_factory.createTask();
taskList.add(plannerTask);
plannerTask.setEnd(getDateTimeString(mpxjTask.getFinish()));
plannerTask.setId(getIntegerString(mpxjTask.getUniqueID()));
plannerTask.setName(getString(mpxjTask.getName()));
plannerTask.setNote(mpxjTask.getNotes());
plannerTask.setPercentComplete(getIntegerString(mpxjTask.getPercentageWorkComplete()));
plannerTask.setPriority(mpxjTask.getPriority() == null ? null : getIntegerString(mpxjTask.getPriority().getValue() * 10));
plannerTask.setScheduling(getScheduling(mpxjTask.getType()));
plannerTask.setStart(getDateTimeString(DateHelper.getDayStartDate(mpxjTask.getStart())));
if (mpxjTask.getMilestone())
{
plannerTask.setType("milestone");
}
else
{
plannerTask.setType("normal");
}
plannerTask.setWork(getDurationString(mpxjTask.getWork()));
plannerTask.setWorkStart(getDateTimeString(mpxjTask.getStart()));
ConstraintType mpxjConstraintType = mpxjTask.getConstraintType();
if (mpxjConstraintType != ConstraintType.AS_SOON_AS_POSSIBLE)
{
Constraint plannerConstraint = m_factory.createConstraint();
plannerTask.setConstraint(plannerConstraint);
if (mpxjConstraintType == ConstraintType.START_NO_EARLIER_THAN)
{
plannerConstraint.setType("start-no-earlier-than");
}
else
{
if (mpxjConstraintType == ConstraintType.MUST_START_ON)
{
plannerConstraint.setType("must-start-on");
}
}
plannerConstraint.setTime(getDateTimeString(mpxjTask.getConstraintDate()));
}
//
// Write predecessors
//
writePredecessors(mpxjTask, plannerTask);
m_eventManager.fireTaskWrittenEvent(mpxjTask);
//
// Write child tasks
//
List<net.sf.mpxj.planner.schema.Task> childTaskList = plannerTask.getTask();
for (Task task : mpxjTask.getChildTasks())
{
writeTask(task, childTaskList);
}
} | java |
private void writePredecessors(Task mpxjTask, net.sf.mpxj.planner.schema.Task plannerTask)
{
Predecessors plannerPredecessors = m_factory.createPredecessors();
plannerTask.setPredecessors(plannerPredecessors);
List<Predecessor> predecessorList = plannerPredecessors.getPredecessor();
int id = 0;
List<Relation> predecessors = mpxjTask.getPredecessors();
for (Relation rel : predecessors)
{
Integer taskUniqueID = rel.getTargetTask().getUniqueID();
Predecessor plannerPredecessor = m_factory.createPredecessor();
plannerPredecessor.setId(getIntegerString(++id));
plannerPredecessor.setPredecessorId(getIntegerString(taskUniqueID));
plannerPredecessor.setLag(getDurationString(rel.getLag()));
plannerPredecessor.setType(RELATIONSHIP_TYPES.get(rel.getType()));
predecessorList.add(plannerPredecessor);
m_eventManager.fireRelationWrittenEvent(rel);
}
} | java |
private void writeAssignments()
{
Allocations allocations = m_factory.createAllocations();
m_plannerProject.setAllocations(allocations);
List<Allocation> allocationList = allocations.getAllocation();
for (ResourceAssignment mpxjAssignment : m_projectFile.getResourceAssignments())
{
Allocation plannerAllocation = m_factory.createAllocation();
allocationList.add(plannerAllocation);
plannerAllocation.setTaskId(getIntegerString(mpxjAssignment.getTask().getUniqueID()));
plannerAllocation.setResourceId(getIntegerString(mpxjAssignment.getResourceUniqueID()));
plannerAllocation.setUnits(getIntegerString(mpxjAssignment.getUnits()));
m_eventManager.fireAssignmentWrittenEvent(mpxjAssignment);
}
} | java |
private String getIntegerString(Number value)
{
return (value == null ? null : Integer.toString(value.intValue()));
} | java |
private boolean isWorkingDay(ProjectCalendar mpxjCalendar, Day day)
{
boolean result = false;
net.sf.mpxj.DayType type = mpxjCalendar.getWorkingDay(day);
if (type == null)
{
type = net.sf.mpxj.DayType.DEFAULT;
}
switch (type)
{
case WORKING:
{
result = true;
break;
}
case NON_WORKING:
{
result = false;
break;
}
case DEFAULT:
{
if (mpxjCalendar.getParent() == null)
{
result = false;
}
else
{
result = isWorkingDay(mpxjCalendar.getParent(), day);
}
break;
}
}
return (result);
} | java |
private String getWorkingDayString(ProjectCalendar mpxjCalendar, Day day)
{
String result = null;
net.sf.mpxj.DayType type = mpxjCalendar.getWorkingDay(day);
if (type == null)
{
type = net.sf.mpxj.DayType.DEFAULT;
}
switch (type)
{
case WORKING:
{
result = "0";
break;
}
case NON_WORKING:
{
result = "1";
break;
}
case DEFAULT:
{
result = "2";
break;
}
}
return (result);
} | java |
private String getTimeString(Date value)
{
Calendar cal = DateHelper.popCalendar(value);
int hours = cal.get(Calendar.HOUR_OF_DAY);
int minutes = cal.get(Calendar.MINUTE);
DateHelper.pushCalendar(cal);
StringBuilder sb = new StringBuilder(4);
sb.append(m_twoDigitFormat.format(hours));
sb.append(m_twoDigitFormat.format(minutes));
return (sb.toString());
} | java |
private String getDateString(Date value)
{
Calendar cal = DateHelper.popCalendar(value);
int year = cal.get(Calendar.YEAR);
int month = cal.get(Calendar.MONTH) + 1;
int day = cal.get(Calendar.DAY_OF_MONTH);
DateHelper.pushCalendar(cal);
StringBuilder sb = new StringBuilder(8);
sb.append(m_fourDigitFormat.format(year));
sb.append(m_twoDigitFormat.format(month));
sb.append(m_twoDigitFormat.format(day));
return (sb.toString());
} | java |
private String getDateTimeString(Date value)
{
String result = null;
if (value != null)
{
Calendar cal = DateHelper.popCalendar(value);
StringBuilder sb = new StringBuilder(16);
sb.append(m_fourDigitFormat.format(cal.get(Calendar.YEAR)));
sb.append(m_twoDigitFormat.format(cal.get(Calendar.MONTH) + 1));
sb.append(m_twoDigitFormat.format(cal.get(Calendar.DAY_OF_MONTH)));
sb.append('T');
sb.append(m_twoDigitFormat.format(cal.get(Calendar.HOUR_OF_DAY)));
sb.append(m_twoDigitFormat.format(cal.get(Calendar.MINUTE)));
sb.append(m_twoDigitFormat.format(cal.get(Calendar.SECOND)));
sb.append('Z');
result = sb.toString();
DateHelper.pushCalendar(cal);
}
return result;
} | java |
private String getDurationString(Duration value)
{
String result = null;
if (value != null)
{
double seconds = 0;
switch (value.getUnits())
{
case MINUTES:
case ELAPSED_MINUTES:
{
seconds = value.getDuration() * 60;
break;
}
case HOURS:
case ELAPSED_HOURS:
{
seconds = value.getDuration() * (60 * 60);
break;
}
case DAYS:
{
double minutesPerDay = m_projectFile.getProjectProperties().getMinutesPerDay().doubleValue();
seconds = value.getDuration() * (minutesPerDay * 60);
break;
}
case ELAPSED_DAYS:
{
seconds = value.getDuration() * (24 * 60 * 60);
break;
}
case WEEKS:
{
double minutesPerWeek = m_projectFile.getProjectProperties().getMinutesPerWeek().doubleValue();
seconds = value.getDuration() * (minutesPerWeek * 60);
break;
}
case ELAPSED_WEEKS:
{
seconds = value.getDuration() * (7 * 24 * 60 * 60);
break;
}
case MONTHS:
{
double minutesPerDay = m_projectFile.getProjectProperties().getMinutesPerDay().doubleValue();
double daysPerMonth = m_projectFile.getProjectProperties().getDaysPerMonth().doubleValue();
seconds = value.getDuration() * (daysPerMonth * minutesPerDay * 60);
break;
}
case ELAPSED_MONTHS:
{
seconds = value.getDuration() * (30 * 24 * 60 * 60);
break;
}
case YEARS:
{
double minutesPerDay = m_projectFile.getProjectProperties().getMinutesPerDay().doubleValue();
double daysPerMonth = m_projectFile.getProjectProperties().getDaysPerMonth().doubleValue();
seconds = value.getDuration() * (12 * daysPerMonth * minutesPerDay * 60);
break;
}
case ELAPSED_YEARS:
{
seconds = value.getDuration() * (365 * 24 * 60 * 60);
break;
}
default:
{
break;
}
}
result = Long.toString((long) seconds);
}
return (result);
} | java |
private void readProjectProperties(Project project) throws MPXJException
{
ProjectProperties properties = m_projectFile.getProjectProperties();
properties.setCompany(project.getCompany());
properties.setManager(project.getManager());
properties.setName(project.getName());
properties.setStartDate(getDateTime(project.getProjectStart()));
} | java |
private void readCalendars(Project project) throws MPXJException
{
Calendars calendars = project.getCalendars();
if (calendars != null)
{
for (net.sf.mpxj.planner.schema.Calendar cal : calendars.getCalendar())
{
readCalendar(cal, null);
}
Integer defaultCalendarID = getInteger(project.getCalendar());
m_defaultCalendar = m_projectFile.getCalendarByUniqueID(defaultCalendarID);
if (m_defaultCalendar != null)
{
m_projectFile.getProjectProperties().setDefaultCalendarName(m_defaultCalendar.getName());
}
}
} | java |
private void readCalendar(net.sf.mpxj.planner.schema.Calendar plannerCalendar, ProjectCalendar parentMpxjCalendar) throws MPXJException
{
//
// Create a calendar instance
//
ProjectCalendar mpxjCalendar = m_projectFile.addCalendar();
//
// Populate basic details
//
mpxjCalendar.setUniqueID(getInteger(plannerCalendar.getId()));
mpxjCalendar.setName(plannerCalendar.getName());
mpxjCalendar.setParent(parentMpxjCalendar);
//
// Set working and non working days
//
DefaultWeek dw = plannerCalendar.getDefaultWeek();
setWorkingDay(mpxjCalendar, Day.MONDAY, dw.getMon());
setWorkingDay(mpxjCalendar, Day.TUESDAY, dw.getTue());
setWorkingDay(mpxjCalendar, Day.WEDNESDAY, dw.getWed());
setWorkingDay(mpxjCalendar, Day.THURSDAY, dw.getThu());
setWorkingDay(mpxjCalendar, Day.FRIDAY, dw.getFri());
setWorkingDay(mpxjCalendar, Day.SATURDAY, dw.getSat());
setWorkingDay(mpxjCalendar, Day.SUNDAY, dw.getSun());
//
// Set working hours
//
processWorkingHours(mpxjCalendar, plannerCalendar);
//
// Process exception days
//
processExceptionDays(mpxjCalendar, plannerCalendar);
m_eventManager.fireCalendarReadEvent(mpxjCalendar);
//
// Process any derived calendars
//
List<net.sf.mpxj.planner.schema.Calendar> calendarList = plannerCalendar.getCalendar();
for (net.sf.mpxj.planner.schema.Calendar cal : calendarList)
{
readCalendar(cal, mpxjCalendar);
}
} | java |
private void readResources(Project plannerProject) throws MPXJException
{
Resources resources = plannerProject.getResources();
if (resources != null)
{
for (net.sf.mpxj.planner.schema.Resource res : resources.getResource())
{
readResource(res);
}
}
} | java |
private void readResource(net.sf.mpxj.planner.schema.Resource plannerResource) throws MPXJException
{
Resource mpxjResource = m_projectFile.addResource();
//mpxjResource.setResourceCalendar(m_projectFile.getBaseCalendarByUniqueID(getInteger(plannerResource.getCalendar())));
mpxjResource.setEmailAddress(plannerResource.getEmail());
mpxjResource.setUniqueID(getInteger(plannerResource.getId()));
mpxjResource.setName(plannerResource.getName());
mpxjResource.setNotes(plannerResource.getNote());
mpxjResource.setInitials(plannerResource.getShortName());
mpxjResource.setType(getInt(plannerResource.getType()) == 2 ? ResourceType.MATERIAL : ResourceType.WORK);
//plannerResource.getStdRate();
//plannerResource.getOvtRate();
//plannerResource.getUnits();
//plannerResource.getProperties();
ProjectCalendar calendar = mpxjResource.addResourceCalendar();
calendar.setWorkingDay(Day.SUNDAY, DayType.DEFAULT);
calendar.setWorkingDay(Day.MONDAY, DayType.DEFAULT);
calendar.setWorkingDay(Day.TUESDAY, DayType.DEFAULT);
calendar.setWorkingDay(Day.WEDNESDAY, DayType.DEFAULT);
calendar.setWorkingDay(Day.THURSDAY, DayType.DEFAULT);
calendar.setWorkingDay(Day.FRIDAY, DayType.DEFAULT);
calendar.setWorkingDay(Day.SATURDAY, DayType.DEFAULT);
ProjectCalendar baseCalendar = m_projectFile.getCalendarByUniqueID(getInteger(plannerResource.getCalendar()));
if (baseCalendar == null)
{
baseCalendar = m_defaultCalendar;
}
calendar.setParent(baseCalendar);
m_eventManager.fireResourceReadEvent(mpxjResource);
} | java |
private void readTasks(Project plannerProject) throws MPXJException
{
Tasks tasks = plannerProject.getTasks();
if (tasks != null)
{
for (net.sf.mpxj.planner.schema.Task task : tasks.getTask())
{
readTask(null, task);
}
for (net.sf.mpxj.planner.schema.Task task : tasks.getTask())
{
readPredecessors(task);
}
}
m_projectFile.updateStructure();
} | java |
private void readPredecessors(net.sf.mpxj.planner.schema.Task plannerTask)
{
Task mpxjTask = m_projectFile.getTaskByUniqueID(getInteger(plannerTask.getId()));
Predecessors predecessors = plannerTask.getPredecessors();
if (predecessors != null)
{
List<Predecessor> predecessorList = predecessors.getPredecessor();
for (Predecessor predecessor : predecessorList)
{
Integer predecessorID = getInteger(predecessor.getPredecessorId());
Task predecessorTask = m_projectFile.getTaskByUniqueID(predecessorID);
if (predecessorTask != null)
{
Duration lag = getDuration(predecessor.getLag());
if (lag == null)
{
lag = Duration.getInstance(0, TimeUnit.HOURS);
}
Relation relation = mpxjTask.addPredecessor(predecessorTask, RELATIONSHIP_TYPES.get(predecessor.getType()), lag);
m_eventManager.fireRelationReadEvent(relation);
}
}
}
//
// Process child tasks
//
List<net.sf.mpxj.planner.schema.Task> childTasks = plannerTask.getTask();
for (net.sf.mpxj.planner.schema.Task childTask : childTasks)
{
readPredecessors(childTask);
}
} | java |
private void readAssignments(Project plannerProject)
{
Allocations allocations = plannerProject.getAllocations();
List<Allocation> allocationList = allocations.getAllocation();
Set<Task> tasksWithAssignments = new HashSet<Task>();
for (Allocation allocation : allocationList)
{
Integer taskID = getInteger(allocation.getTaskId());
Integer resourceID = getInteger(allocation.getResourceId());
Integer units = getInteger(allocation.getUnits());
Task task = m_projectFile.getTaskByUniqueID(taskID);
Resource resource = m_projectFile.getResourceByUniqueID(resourceID);
if (task != null && resource != null)
{
Duration work = task.getWork();
int percentComplete = NumberHelper.getInt(task.getPercentageComplete());
ResourceAssignment assignment = task.addResourceAssignment(resource);
assignment.setUnits(units);
assignment.setWork(work);
if (percentComplete != 0)
{
Duration actualWork = Duration.getInstance((work.getDuration() * percentComplete) / 100, work.getUnits());
assignment.setActualWork(actualWork);
assignment.setRemainingWork(Duration.getInstance(work.getDuration() - actualWork.getDuration(), work.getUnits()));
}
else
{
assignment.setRemainingWork(work);
}
assignment.setStart(task.getStart());
assignment.setFinish(task.getFinish());
tasksWithAssignments.add(task);
m_eventManager.fireAssignmentReadEvent(assignment);
}
}
//
// Adjust work per assignment for tasks with multiple assignments
//
for (Task task : tasksWithAssignments)
{
List<ResourceAssignment> assignments = task.getResourceAssignments();
if (assignments.size() > 1)
{
double maxUnits = 0;
for (ResourceAssignment assignment : assignments)
{
maxUnits += assignment.getUnits().doubleValue();
}
for (ResourceAssignment assignment : assignments)
{
Duration work = assignment.getWork();
double factor = assignment.getUnits().doubleValue() / maxUnits;
work = Duration.getInstance(work.getDuration() * factor, work.getUnits());
assignment.setWork(work);
Duration actualWork = assignment.getActualWork();
if (actualWork != null)
{
actualWork = Duration.getInstance(actualWork.getDuration() * factor, actualWork.getUnits());
assignment.setActualWork(actualWork);
}
Duration remainingWork = assignment.getRemainingWork();
if (remainingWork != null)
{
remainingWork = Duration.getInstance(remainingWork.getDuration() * factor, remainingWork.getUnits());
assignment.setRemainingWork(remainingWork);
}
}
}
}
} | java |
private Date getDateTime(String value) throws MPXJException
{
try
{
Number year = m_fourDigitFormat.parse(value.substring(0, 4));
Number month = m_twoDigitFormat.parse(value.substring(4, 6));
Number day = m_twoDigitFormat.parse(value.substring(6, 8));
Number hours = m_twoDigitFormat.parse(value.substring(9, 11));
Number minutes = m_twoDigitFormat.parse(value.substring(11, 13));
Calendar cal = DateHelper.popCalendar();
cal.set(Calendar.YEAR, year.intValue());
cal.set(Calendar.MONTH, month.intValue() - 1);
cal.set(Calendar.DAY_OF_MONTH, day.intValue());
cal.set(Calendar.HOUR_OF_DAY, hours.intValue());
cal.set(Calendar.MINUTE, minutes.intValue());
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
Date result = cal.getTime();
DateHelper.pushCalendar(cal);
return result;
}
catch (ParseException ex)
{
throw new MPXJException("Failed to parse date-time " + value, ex);
}
} | java |
private Date getTime(String value) throws MPXJException
{
try
{
Number hours = m_twoDigitFormat.parse(value.substring(0, 2));
Number minutes = m_twoDigitFormat.parse(value.substring(2, 4));
Calendar cal = DateHelper.popCalendar();
cal.set(Calendar.HOUR_OF_DAY, hours.intValue());
cal.set(Calendar.MINUTE, minutes.intValue());
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
Date result = cal.getTime();
DateHelper.pushCalendar(cal);
return result;
}
catch (ParseException ex)
{
throw new MPXJException("Failed to parse time " + value, ex);
}
} | java |
private Duration getDuration(String value)
{
Duration result = null;
if (value != null && value.length() != 0)
{
double seconds = getLong(value);
double hours = seconds / (60 * 60);
double days = hours / 8;
if (days < 1)
{
result = Duration.getInstance(hours, TimeUnit.HOURS);
}
else
{
double durationDays = hours / 8;
result = Duration.getInstance(durationDays, TimeUnit.DAYS);
}
}
return (result);
} | java |
public ArrayList<Duration> segmentWork(ProjectCalendar projectCalendar, List<TimephasedWork> work, TimescaleUnits rangeUnits, List<DateRange> dateList)
{
ArrayList<Duration> result = new ArrayList<Duration>(dateList.size());
int lastStartIndex = 0;
//
// Iterate through the list of dates range we are interested in.
// Each date range in this list corresponds to a column
// shown on the "timescale" view by MS Project
//
for (DateRange range : dateList)
{
//
// If the current date range does not intersect with any of the
// assignment date ranges in the list, then we show a zero
// duration for this date range.
//
int startIndex = lastStartIndex == -1 ? -1 : getStartIndex(range, work, lastStartIndex);
if (startIndex == -1)
{
result.add(Duration.getInstance(0, TimeUnit.HOURS));
}
else
{
//
// We have found an assignment which intersects with the current
// date range, call the method below to determine how
// much time from this resource assignment can be allocated
// to the current date range.
//
result.add(getRangeDuration(projectCalendar, rangeUnits, range, work, startIndex));
lastStartIndex = startIndex;
}
}
return result;
} | java |
public ArrayList<Duration> segmentBaselineWork(ProjectFile file, List<TimephasedWork> work, TimescaleUnits rangeUnits, ArrayList<DateRange> dateList)
{
return segmentWork(file.getBaselineCalendar(), work, rangeUnits, dateList);
} | java |
public ArrayList<Double> segmentCost(ProjectCalendar projectCalendar, List<TimephasedCost> cost, TimescaleUnits rangeUnits, ArrayList<DateRange> dateList)
{
ArrayList<Double> result = new ArrayList<Double>(dateList.size());
int lastStartIndex = 0;
//
// Iterate through the list of dates range we are interested in.
// Each date range in this list corresponds to a column
// shown on the "timescale" view by MS Project
//
for (DateRange range : dateList)
{
//
// If the current date range does not intersect with any of the
// assignment date ranges in the list, then we show a zero
// duration for this date range.
//
int startIndex = lastStartIndex == -1 ? -1 : getStartIndex(range, cost, lastStartIndex);
if (startIndex == -1)
{
result.add(NumberHelper.DOUBLE_ZERO);
}
else
{
//
// We have found an assignment which intersects with the current
// date range, call the method below to determine how
// much time from this resource assignment can be allocated
// to the current date range.
//
result.add(getRangeCost(projectCalendar, rangeUnits, range, cost, startIndex));
lastStartIndex = startIndex;
}
}
return result;
} | java |
public ArrayList<Double> segmentBaselineCost(ProjectFile file, List<TimephasedCost> cost, TimescaleUnits rangeUnits, ArrayList<DateRange> dateList)
{
return segmentCost(file.getBaselineCalendar(), cost, rangeUnits, dateList);
} | java |
private <T extends TimephasedItem<?>> int getStartIndex(DateRange range, List<T> assignments, int startIndex)
{
int result = -1;
if (assignments != null)
{
long rangeStart = range.getStart().getTime();
long rangeEnd = range.getEnd().getTime();
for (int loop = startIndex; loop < assignments.size(); loop++)
{
T assignment = assignments.get(loop);
int compareResult = DateHelper.compare(assignment.getStart(), assignment.getFinish(), rangeStart);
//
// The start of the target range falls after the assignment end -
// move on to test the next assignment.
//
if (compareResult > 0)
{
continue;
}
//
// The start of the target range falls within the assignment -
// return the index of this assignment to the caller.
//
if (compareResult == 0)
{
result = loop;
break;
}
//
// At this point, we know that the start of the target range is before
// the assignment start. We need to determine if the end of the
// target range overlaps the assignment.
//
compareResult = DateHelper.compare(assignment.getStart(), assignment.getFinish(), rangeEnd);
if (compareResult >= 0)
{
result = loop;
break;
}
}
}
return result;
} | java |
private void processCalendarHours(byte[] data, ProjectCalendar defaultCalendar, ProjectCalendar cal, boolean isBaseCalendar)
{
// Dump out the calendar related data and fields.
//MPPUtility.dataDump(data, true, false, false, false, true, false, true);
int offset;
ProjectCalendarHours hours;
int periodIndex;
int index;
int defaultFlag;
int periodCount;
Date start;
long duration;
Day day;
List<DateRange> dateRanges = new ArrayList<DateRange>(5);
for (index = 0; index < 7; index++)
{
offset = getCalendarHoursOffset() + (60 * index);
defaultFlag = data == null ? 1 : MPPUtility.getShort(data, offset);
day = Day.getInstance(index + 1);
if (defaultFlag == 1)
{
if (isBaseCalendar)
{
if (defaultCalendar == null)
{
cal.setWorkingDay(day, DEFAULT_WORKING_WEEK[index]);
if (cal.isWorkingDay(day))
{
hours = cal.addCalendarHours(Day.getInstance(index + 1));
hours.addRange(ProjectCalendarWeek.DEFAULT_WORKING_MORNING);
hours.addRange(ProjectCalendarWeek.DEFAULT_WORKING_AFTERNOON);
}
}
else
{
boolean workingDay = defaultCalendar.isWorkingDay(day);
cal.setWorkingDay(day, workingDay);
if (workingDay)
{
hours = cal.addCalendarHours(Day.getInstance(index + 1));
for (DateRange range : defaultCalendar.getHours(day))
{
hours.addRange(range);
}
}
}
}
else
{
cal.setWorkingDay(day, DayType.DEFAULT);
}
}
else
{
dateRanges.clear();
periodIndex = 0;
periodCount = MPPUtility.getShort(data, offset + 2);
while (periodIndex < periodCount)
{
int startOffset = offset + 8 + (periodIndex * 2);
start = MPPUtility.getTime(data, startOffset);
int durationOffset = offset + 20 + (periodIndex * 4);
duration = MPPUtility.getDuration(data, durationOffset);
Date end = new Date(start.getTime() + duration);
dateRanges.add(new DateRange(start, end));
++periodIndex;
}
if (dateRanges.isEmpty())
{
cal.setWorkingDay(day, false);
}
else
{
cal.setWorkingDay(day, true);
hours = cal.addCalendarHours(Day.getInstance(index + 1));
for (DateRange range : dateRanges)
{
hours.addRange(range);
}
}
}
}
} | java |
private void updateBaseCalendarNames(List<Pair<ProjectCalendar, Integer>> baseCalendars, HashMap<Integer, ProjectCalendar> map)
{
for (Pair<ProjectCalendar, Integer> pair : baseCalendars)
{
ProjectCalendar cal = pair.getFirst();
Integer baseCalendarID = pair.getSecond();
ProjectCalendar baseCal = map.get(baseCalendarID);
if (baseCal != null && baseCal.getName() != null)
{
cal.setParent(baseCal);
}
else
{
// Remove invalid calendar to avoid serious problems later.
m_file.removeCalendar(cal);
}
}
} | java |
public void fireTaskReadEvent(Task task)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.taskRead(task);
}
}
} | java |
public void fireTaskWrittenEvent(Task task)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.taskWritten(task);
}
}
} | java |
public void fireResourceReadEvent(Resource resource)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.resourceRead(resource);
}
}
} | java |
public void fireResourceWrittenEvent(Resource resource)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.resourceWritten(resource);
}
}
} | java |
public void fireCalendarReadEvent(ProjectCalendar calendar)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.calendarRead(calendar);
}
}
} | java |
public void fireAssignmentReadEvent(ResourceAssignment resourceAssignment)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.assignmentRead(resourceAssignment);
}
}
} | java |
public void fireAssignmentWrittenEvent(ResourceAssignment resourceAssignment)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.assignmentWritten(resourceAssignment);
}
}
} | java |
public void fireRelationReadEvent(Relation relation)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.relationRead(relation);
}
}
} | java |
public void fireRelationWrittenEvent(Relation relation)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.relationWritten(relation);
}
}
} | java |
public void fireCalendarWrittenEvent(ProjectCalendar calendar)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.calendarWritten(calendar);
}
}
} | java |
public void addProjectListeners(List<ProjectListener> listeners)
{
if (listeners != null)
{
for (ProjectListener listener : listeners)
{
addProjectListener(listener);
}
}
} | java |
public <E extends Enum<E> & FieldType> E nextField(Class<E> clazz, UserFieldDataType type)
{
for (String name : m_names[type.ordinal()])
{
int i = NumberHelper.getInt(m_counters.get(name)) + 1;
try
{
E e = Enum.valueOf(clazz, name + i);
m_counters.put(name, Integer.valueOf(i));
return e;
}
catch (IllegalArgumentException ex)
{
// try the next name
}
}
// no more fields available
throw new IllegalArgumentException("No fields for type " + type + " available");
} | java |
private ProjectFile read() throws Exception
{
m_project = new ProjectFile();
m_eventManager = m_project.getEventManager();
ProjectConfig config = m_project.getProjectConfig();
config.setAutoCalendarUniqueID(false);
config.setAutoTaskID(false);
config.setAutoTaskUniqueID(false);
config.setAutoResourceUniqueID(false);
config.setAutoWBS(false);
config.setAutoOutlineNumber(false);
m_project.getProjectProperties().setFileApplication("FastTrack");
m_project.getProjectProperties().setFileType("FTS");
m_eventManager.addProjectListeners(m_projectListeners);
// processProject();
// processCalendars();
processResources();
processTasks();
processDependencies();
processAssignments();
return m_project;
} | java |
private void processDependencies()
{
Set<Task> tasksWithBars = new HashSet<Task>();
FastTrackTable table = m_data.getTable(FastTrackTableType.ACTBARS);
for (MapRow row : table)
{
Task task = m_project.getTaskByUniqueID(row.getInteger(ActBarField._ACTIVITY));
if (task == null || tasksWithBars.contains(task))
{
continue;
}
tasksWithBars.add(task);
String predecessors = row.getString(ActBarField.PREDECESSORS);
if (predecessors == null || predecessors.isEmpty())
{
continue;
}
for (String predecessor : predecessors.split(", "))
{
Matcher matcher = RELATION_REGEX.matcher(predecessor);
matcher.matches();
Integer id = Integer.valueOf(matcher.group(1));
RelationType type = RELATION_TYPE_MAP.get(matcher.group(3));
if (type == null)
{
type = RelationType.FINISH_START;
}
String sign = matcher.group(4);
double lag = NumberHelper.getDouble(matcher.group(5));
if ("-".equals(sign))
{
lag = -lag;
}
Task targetTask = m_project.getTaskByID(id);
if (targetTask != null)
{
Duration lagDuration = Duration.getInstance(lag, m_data.getDurationTimeUnit());
Relation relation = task.addPredecessor(targetTask, type, lagDuration);
m_eventManager.fireRelationReadEvent(relation);
}
}
}
} | java |
private Integer getOutlineLevel(Task task)
{
String value = task.getWBS();
Integer result = Integer.valueOf(1);
if (value != null && value.length() > 0)
{
String[] path = WBS_SPLIT_REGEX.split(value);
result = Integer.valueOf(path.length);
}
return result;
} | java |
public void setWeeklyDay(Day day, boolean value)
{
if (value)
{
m_days.add(day);
}
else
{
m_days.remove(day);
}
} | java |
public void setWeeklyDaysFromBitmap(Integer days, int[] masks)
{
if (days != null)
{
int value = days.intValue();
for (Day day : Day.values())
{
setWeeklyDay(day, ((value & masks[day.getValue()]) != 0));
}
}
} | java |
public Day getDayOfWeek()
{
Day result = null;
if (!m_days.isEmpty())
{
result = m_days.iterator().next();
}
return result;
} | java |
public Date[] getDates()
{
int frequency = NumberHelper.getInt(m_frequency);
if (frequency < 1)
{
frequency = 1;
}
Calendar calendar = DateHelper.popCalendar(m_startDate);
List<Date> dates = new ArrayList<Date>();
switch (m_recurrenceType)
{
case DAILY:
{
getDailyDates(calendar, frequency, dates);
break;
}
case WEEKLY:
{
getWeeklyDates(calendar, frequency, dates);
break;
}
case MONTHLY:
{
getMonthlyDates(calendar, frequency, dates);
break;
}
case YEARLY:
{
getYearlyDates(calendar, dates);
break;
}
}
DateHelper.pushCalendar(calendar);
return dates.toArray(new Date[dates.size()]);
} | java |
private boolean moreDates(Calendar calendar, List<Date> dates)
{
boolean result;
if (m_finishDate == null)
{
int occurrences = NumberHelper.getInt(m_occurrences);
if (occurrences < 1)
{
occurrences = 1;
}
result = dates.size() < occurrences;
}
else
{
result = calendar.getTimeInMillis() <= m_finishDate.getTime();
}
return result;
} | java |
private void getDailyDates(Calendar calendar, int frequency, List<Date> dates)
{
while (moreDates(calendar, dates))
{
dates.add(calendar.getTime());
calendar.add(Calendar.DAY_OF_YEAR, frequency);
}
} | java |
private void getWeeklyDates(Calendar calendar, int frequency, List<Date> dates)
{
int currentDay = calendar.get(Calendar.DAY_OF_WEEK);
while (moreDates(calendar, dates))
{
int offset = 0;
for (int dayIndex = 0; dayIndex < 7; dayIndex++)
{
if (getWeeklyDay(Day.getInstance(currentDay)))
{
if (offset != 0)
{
calendar.add(Calendar.DAY_OF_YEAR, offset);
offset = 0;
}
if (!moreDates(calendar, dates))
{
break;
}
dates.add(calendar.getTime());
}
++offset;
++currentDay;
if (currentDay > 7)
{
currentDay = 1;
}
}
if (frequency > 1)
{
offset += (7 * (frequency - 1));
}
calendar.add(Calendar.DAY_OF_YEAR, offset);
}
} | java |
private void getMonthlyDates(Calendar calendar, int frequency, List<Date> dates)
{
if (m_relative)
{
getMonthlyRelativeDates(calendar, frequency, dates);
}
else
{
getMonthlyAbsoluteDates(calendar, frequency, dates);
}
} | java |
private void getMonthlyRelativeDates(Calendar calendar, int frequency, List<Date> dates)
{
long startDate = calendar.getTimeInMillis();
calendar.set(Calendar.DAY_OF_MONTH, 1);
int dayNumber = NumberHelper.getInt(m_dayNumber);
while (moreDates(calendar, dates))
{
if (dayNumber > 4)
{
setCalendarToLastRelativeDay(calendar);
}
else
{
setCalendarToOrdinalRelativeDay(calendar, dayNumber);
}
if (calendar.getTimeInMillis() > startDate)
{
dates.add(calendar.getTime());
if (!moreDates(calendar, dates))
{
break;
}
}
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.MONTH, frequency);
}
} | java |
private void getMonthlyAbsoluteDates(Calendar calendar, int frequency, List<Date> dates)
{
int currentDayNumber = calendar.get(Calendar.DAY_OF_MONTH);
calendar.set(Calendar.DAY_OF_MONTH, 1);
int requiredDayNumber = NumberHelper.getInt(m_dayNumber);
if (requiredDayNumber < currentDayNumber)
{
calendar.add(Calendar.MONTH, 1);
}
while (moreDates(calendar, dates))
{
int useDayNumber = requiredDayNumber;
int maxDayNumber = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
if (useDayNumber > maxDayNumber)
{
useDayNumber = maxDayNumber;
}
calendar.set(Calendar.DAY_OF_MONTH, useDayNumber);
dates.add(calendar.getTime());
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.MONTH, frequency);
}
} | java |
private void getYearlyDates(Calendar calendar, List<Date> dates)
{
if (m_relative)
{
getYearlyRelativeDates(calendar, dates);
}
else
{
getYearlyAbsoluteDates(calendar, dates);
}
} | java |
private void getYearlyRelativeDates(Calendar calendar, List<Date> dates)
{
long startDate = calendar.getTimeInMillis();
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.set(Calendar.MONTH, NumberHelper.getInt(m_monthNumber) - 1);
int dayNumber = NumberHelper.getInt(m_dayNumber);
while (moreDates(calendar, dates))
{
if (dayNumber > 4)
{
setCalendarToLastRelativeDay(calendar);
}
else
{
setCalendarToOrdinalRelativeDay(calendar, dayNumber);
}
if (calendar.getTimeInMillis() > startDate)
{
dates.add(calendar.getTime());
if (!moreDates(calendar, dates))
{
break;
}
}
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.YEAR, 1);
}
} | java |
private void getYearlyAbsoluteDates(Calendar calendar, List<Date> dates)
{
long startDate = calendar.getTimeInMillis();
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.set(Calendar.MONTH, NumberHelper.getInt(m_monthNumber) - 1);
int requiredDayNumber = NumberHelper.getInt(m_dayNumber);
while (moreDates(calendar, dates))
{
int useDayNumber = requiredDayNumber;
int maxDayNumber = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
if (useDayNumber > maxDayNumber)
{
useDayNumber = maxDayNumber;
}
calendar.set(Calendar.DAY_OF_MONTH, useDayNumber);
if (calendar.getTimeInMillis() < startDate)
{
calendar.add(Calendar.YEAR, 1);
}
dates.add(calendar.getTime());
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.YEAR, 1);
}
} | java |
private void setCalendarToOrdinalRelativeDay(Calendar calendar, int dayNumber)
{
int currentDayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
int requiredDayOfWeek = getDayOfWeek().getValue();
int dayOfWeekOffset = 0;
if (requiredDayOfWeek > currentDayOfWeek)
{
dayOfWeekOffset = requiredDayOfWeek - currentDayOfWeek;
}
else
{
if (requiredDayOfWeek < currentDayOfWeek)
{
dayOfWeekOffset = 7 - (currentDayOfWeek - requiredDayOfWeek);
}
}
if (dayOfWeekOffset != 0)
{
calendar.add(Calendar.DAY_OF_YEAR, dayOfWeekOffset);
}
if (dayNumber > 1)
{
calendar.add(Calendar.DAY_OF_YEAR, (7 * (dayNumber - 1)));
}
} | java |
private void setCalendarToLastRelativeDay(Calendar calendar)
{
calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
int currentDayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
int requiredDayOfWeek = getDayOfWeek().getValue();
int dayOfWeekOffset = 0;
if (currentDayOfWeek > requiredDayOfWeek)
{
dayOfWeekOffset = requiredDayOfWeek - currentDayOfWeek;
}
else
{
if (currentDayOfWeek < requiredDayOfWeek)
{
dayOfWeekOffset = -7 + (requiredDayOfWeek - currentDayOfWeek);
}
}
if (dayOfWeekOffset != 0)
{
calendar.add(Calendar.DAY_OF_YEAR, dayOfWeekOffset);
}
} | java |
public void setYearlyAbsoluteFromDate(Date date)
{
if (date != null)
{
Calendar cal = DateHelper.popCalendar(date);
m_dayNumber = Integer.valueOf(cal.get(Calendar.DAY_OF_MONTH));
m_monthNumber = Integer.valueOf(cal.get(Calendar.MONTH) + 1);
DateHelper.pushCalendar(cal);
}
} | java |
private String getOrdinal(Integer value)
{
String result;
int index = value.intValue();
if (index >= ORDINAL.length)
{
result = "every " + index + "th";
}
else
{
result = ORDINAL[index];
}
return result;
} | java |
public static Priority getInstance(Locale locale, String priority)
{
int index = DEFAULT_PRIORITY_INDEX;
if (priority != null)
{
String[] priorityTypes = LocaleData.getStringArray(locale, LocaleData.PRIORITY_TYPES);
for (int loop = 0; loop < priorityTypes.length; loop++)
{
if (priorityTypes[loop].equalsIgnoreCase(priority) == true)
{
index = loop;
break;
}
}
}
return (Priority.getInstance((index + 1) * 100));
} | java |
public static Duration add(Duration a, Duration b, ProjectProperties defaults)
{
if (a == null && b == null)
{
return null;
}
if (a == null)
{
return b;
}
if (b == null)
{
return a;
}
TimeUnit unit = a.getUnits();
if (b.getUnits() != unit)
{
b = b.convertUnits(unit, defaults);
}
return Duration.getInstance(a.getDuration() + b.getDuration(), unit);
} | java |
public static ProjectReader getProjectReader(String name) throws MPXJException
{
int index = name.lastIndexOf('.');
if (index == -1)
{
throw new IllegalArgumentException("Filename has no extension: " + name);
}
String extension = name.substring(index + 1).toUpperCase();
Class<? extends ProjectReader> fileClass = READER_MAP.get(extension);
if (fileClass == null)
{
throw new IllegalArgumentException("Cannot read files of type: " + extension);
}
try
{
ProjectReader file = fileClass.newInstance();
return (file);
}
catch (Exception ex)
{
throw new MPXJException("Failed to load project reader", ex);
}
} | java |
private void processCalendars() throws SQLException
{
for (ResultSetRow row : getRows("SELECT * FROM MSP_CALENDARS WHERE PROJ_ID=?", m_projectID))
{
processCalendar(row);
}
updateBaseCalendarNames();
processCalendarData(m_project.getCalendars());
} | java |
private void processCalendarData(List<ProjectCalendar> calendars) throws SQLException
{
for (ProjectCalendar calendar : calendars)
{
processCalendarData(calendar, getRows("SELECT * FROM MSP_CALENDAR_DATA WHERE PROJ_ID=? AND CAL_UID=?", m_projectID, calendar.getUniqueID()));
}
} | java |
private void processCalendarData(ProjectCalendar calendar, List<ResultSetRow> calendarData)
{
for (ResultSetRow row : calendarData)
{
processCalendarData(calendar, row);
}
} | java |
private void processSubProjects()
{
int subprojectIndex = 1;
for (Task task : m_project.getTasks())
{
String subProjectFileName = task.getSubprojectName();
if (subProjectFileName != null)
{
String fileName = subProjectFileName;
int offset = 0x01000000 + (subprojectIndex * 0x00400000);
int index = subProjectFileName.lastIndexOf('\\');
if (index != -1)
{
fileName = subProjectFileName.substring(index + 1);
}
SubProject sp = new SubProject();
sp.setFileName(fileName);
sp.setFullPath(subProjectFileName);
sp.setUniqueIDOffset(Integer.valueOf(offset));
sp.setTaskUniqueID(task.getUniqueID());
task.setSubProject(sp);
++subprojectIndex;
}
}
} | java |
private void processOutlineCodeFields(Row parentRow) throws SQLException
{
Integer entityID = parentRow.getInteger("CODE_REF_UID");
Integer outlineCodeEntityID = parentRow.getInteger("CODE_UID");
for (ResultSetRow row : getRows("SELECT * FROM MSP_OUTLINE_CODES WHERE CODE_UID=?", outlineCodeEntityID))
{
processOutlineCodeField(entityID, row);
}
} | java |
private void allocateConnection() throws SQLException
{
if (m_connection == null)
{
m_connection = m_dataSource.getConnection();
m_allocatedConnection = true;
queryDatabaseMetaData();
}
} | java |
private void queryDatabaseMetaData()
{
ResultSet rs = null;
try
{
Set<String> tables = new HashSet<String>();
DatabaseMetaData dmd = m_connection.getMetaData();
rs = dmd.getTables(null, null, null, null);
while (rs.next())
{
tables.add(rs.getString("TABLE_NAME"));
}
m_hasResourceBaselines = tables.contains("MSP_RESOURCE_BASELINES");
m_hasTaskBaselines = tables.contains("MSP_TASK_BASELINES");
m_hasAssignmentBaselines = tables.contains("MSP_ASSIGNMENT_BASELINES");
}
catch (Exception ex)
{
// Ignore errors when reading meta data
}
finally
{
if (rs != null)
{
try
{
rs.close();
}
catch (SQLException ex)
{
// Ignore errors when closing result set
}
rs = null;
}
}
} | java |
public static final UUID parseUUID(String value)
{
UUID result = null;
if (value != null && !value.isEmpty())
{
if (value.charAt(0) == '{')
{
// PMXML representation: <GUID>{0AB9133E-A09A-9648-B98A-B2384894AC44}</GUID>
result = UUID.fromString(value.substring(1, value.length() - 1));
}
else
{
// XER representation: CrkTPqCalki5irI4SJSsRA
byte[] data = javax.xml.bind.DatatypeConverter.parseBase64Binary(value + "==");
long msb = 0;
long lsb = 0;
for (int i = 0; i < 8; i++)
{
msb = (msb << 8) | (data[i] & 0xff);
}
for (int i = 8; i < 16; i++)
{
lsb = (lsb << 8) | (data[i] & 0xff);
}
result = new UUID(msb, lsb);
}
}
return result;
} | java |
public static String printUUID(UUID guid)
{
return guid == null ? null : "{" + guid.toString().toUpperCase() + "}";
} | java |
public static final String printTime(Date value)
{
return (value == null ? null : TIME_FORMAT.get().format(value));
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.