_id
stringlengths 2
7
| title
stringlengths 3
140
| partition
stringclasses 3
values | text
stringlengths 73
34.1k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q700
|
TableContainer.getIndex
|
train
|
private Map<String, Table> getIndex(Table table)
{
Map<String, Table> result;
if (!table.getResourceFlag())
{
result = m_taskTablesByName;
}
else
{
result = m_resourceTablesByName;
}
return result;
}
|
java
|
{
"resource": ""
}
|
q701
|
ProjectFilePanel.saveFile
|
train
|
public void saveFile(File file, String type)
{
if (file != null)
{
m_treeController.saveFile(file, type);
}
}
|
java
|
{
"resource": ""
}
|
q702
|
FilterContainer.addFilter
|
train
|
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
|
{
"resource": ""
}
|
q703
|
FilterContainer.removeFilter
|
train
|
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
|
{
"resource": ""
}
|
q704
|
PlannerWriter.writeProjectProperties
|
train
|
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
|
{
"resource": ""
}
|
q705
|
PlannerWriter.writeCalendars
|
train
|
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
|
{
"resource": ""
}
|
q706
|
PlannerWriter.writeDayTypes
|
train
|
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
|
{
"resource": ""
}
|
q707
|
PlannerWriter.writeCalendar
|
train
|
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
|
{
"resource": ""
}
|
q708
|
PlannerWriter.processWorkingHours
|
train
|
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
|
{
"resource": ""
}
|
q709
|
PlannerWriter.writeResources
|
train
|
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
|
{
"resource": ""
}
|
q710
|
PlannerWriter.writeResource
|
train
|
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
|
{
"resource": ""
}
|
q711
|
PlannerWriter.writeTasks
|
train
|
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
|
{
"resource": ""
}
|
q712
|
PlannerWriter.writeTask
|
train
|
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
|
{
"resource": ""
}
|
q713
|
PlannerWriter.writePredecessors
|
train
|
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
|
{
"resource": ""
}
|
q714
|
PlannerWriter.writeAssignments
|
train
|
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
|
{
"resource": ""
}
|
q715
|
PlannerWriter.getIntegerString
|
train
|
private String getIntegerString(Number value)
{
return (value == null ? null : Integer.toString(value.intValue()));
}
|
java
|
{
"resource": ""
}
|
q716
|
PlannerWriter.isWorkingDay
|
train
|
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
|
{
"resource": ""
}
|
q717
|
PlannerWriter.getWorkingDayString
|
train
|
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
|
{
"resource": ""
}
|
q718
|
PlannerWriter.getTimeString
|
train
|
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
|
{
"resource": ""
}
|
q719
|
PlannerWriter.getDateString
|
train
|
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
|
{
"resource": ""
}
|
q720
|
PlannerWriter.getDateTimeString
|
train
|
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
|
{
"resource": ""
}
|
q721
|
PlannerWriter.getDurationString
|
train
|
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
|
{
"resource": ""
}
|
q722
|
PlannerReader.readProjectProperties
|
train
|
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
|
{
"resource": ""
}
|
q723
|
PlannerReader.readCalendars
|
train
|
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
|
{
"resource": ""
}
|
q724
|
PlannerReader.readCalendar
|
train
|
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
|
{
"resource": ""
}
|
q725
|
PlannerReader.readResources
|
train
|
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
|
{
"resource": ""
}
|
q726
|
PlannerReader.readResource
|
train
|
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
|
{
"resource": ""
}
|
q727
|
PlannerReader.readTasks
|
train
|
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
|
{
"resource": ""
}
|
q728
|
PlannerReader.readPredecessors
|
train
|
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
|
{
"resource": ""
}
|
q729
|
PlannerReader.readAssignments
|
train
|
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
|
{
"resource": ""
}
|
q730
|
PlannerReader.getDateTime
|
train
|
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
|
{
"resource": ""
}
|
q731
|
PlannerReader.getTime
|
train
|
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
|
{
"resource": ""
}
|
q732
|
PlannerReader.getDuration
|
train
|
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
|
{
"resource": ""
}
|
q733
|
TimephasedUtility.segmentWork
|
train
|
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
|
{
"resource": ""
}
|
q734
|
TimephasedUtility.segmentBaselineWork
|
train
|
public ArrayList<Duration> segmentBaselineWork(ProjectFile file, List<TimephasedWork> work, TimescaleUnits rangeUnits, ArrayList<DateRange> dateList)
{
return segmentWork(file.getBaselineCalendar(), work, rangeUnits, dateList);
}
|
java
|
{
"resource": ""
}
|
q735
|
TimephasedUtility.segmentCost
|
train
|
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
|
{
"resource": ""
}
|
q736
|
TimephasedUtility.segmentBaselineCost
|
train
|
public ArrayList<Double> segmentBaselineCost(ProjectFile file, List<TimephasedCost> cost, TimescaleUnits rangeUnits, ArrayList<DateRange> dateList)
{
return segmentCost(file.getBaselineCalendar(), cost, rangeUnits, dateList);
}
|
java
|
{
"resource": ""
}
|
q737
|
TimephasedUtility.getStartIndex
|
train
|
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
|
{
"resource": ""
}
|
q738
|
AbstractCalendarFactory.processCalendarHours
|
train
|
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
|
{
"resource": ""
}
|
q739
|
AbstractCalendarFactory.updateBaseCalendarNames
|
train
|
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
|
{
"resource": ""
}
|
q740
|
EventManager.fireTaskReadEvent
|
train
|
public void fireTaskReadEvent(Task task)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.taskRead(task);
}
}
}
|
java
|
{
"resource": ""
}
|
q741
|
EventManager.fireTaskWrittenEvent
|
train
|
public void fireTaskWrittenEvent(Task task)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.taskWritten(task);
}
}
}
|
java
|
{
"resource": ""
}
|
q742
|
EventManager.fireResourceReadEvent
|
train
|
public void fireResourceReadEvent(Resource resource)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.resourceRead(resource);
}
}
}
|
java
|
{
"resource": ""
}
|
q743
|
EventManager.fireResourceWrittenEvent
|
train
|
public void fireResourceWrittenEvent(Resource resource)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.resourceWritten(resource);
}
}
}
|
java
|
{
"resource": ""
}
|
q744
|
EventManager.fireCalendarReadEvent
|
train
|
public void fireCalendarReadEvent(ProjectCalendar calendar)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.calendarRead(calendar);
}
}
}
|
java
|
{
"resource": ""
}
|
q745
|
EventManager.fireAssignmentReadEvent
|
train
|
public void fireAssignmentReadEvent(ResourceAssignment resourceAssignment)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.assignmentRead(resourceAssignment);
}
}
}
|
java
|
{
"resource": ""
}
|
q746
|
EventManager.fireAssignmentWrittenEvent
|
train
|
public void fireAssignmentWrittenEvent(ResourceAssignment resourceAssignment)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.assignmentWritten(resourceAssignment);
}
}
}
|
java
|
{
"resource": ""
}
|
q747
|
EventManager.fireRelationReadEvent
|
train
|
public void fireRelationReadEvent(Relation relation)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.relationRead(relation);
}
}
}
|
java
|
{
"resource": ""
}
|
q748
|
EventManager.fireRelationWrittenEvent
|
train
|
public void fireRelationWrittenEvent(Relation relation)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.relationWritten(relation);
}
}
}
|
java
|
{
"resource": ""
}
|
q749
|
EventManager.fireCalendarWrittenEvent
|
train
|
public void fireCalendarWrittenEvent(ProjectCalendar calendar)
{
if (m_projectListeners != null)
{
for (ProjectListener listener : m_projectListeners)
{
listener.calendarWritten(calendar);
}
}
}
|
java
|
{
"resource": ""
}
|
q750
|
EventManager.addProjectListeners
|
train
|
public void addProjectListeners(List<ProjectListener> listeners)
{
if (listeners != null)
{
for (ProjectListener listener : listeners)
{
addProjectListener(listener);
}
}
}
|
java
|
{
"resource": ""
}
|
q751
|
UserFieldCounters.nextField
|
train
|
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
|
{
"resource": ""
}
|
q752
|
FastTrackReader.read
|
train
|
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
|
{
"resource": ""
}
|
q753
|
FastTrackReader.processDependencies
|
train
|
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
|
{
"resource": ""
}
|
q754
|
FastTrackReader.getOutlineLevel
|
train
|
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
|
{
"resource": ""
}
|
q755
|
RecurringData.setWeeklyDay
|
train
|
public void setWeeklyDay(Day day, boolean value)
{
if (value)
{
m_days.add(day);
}
else
{
m_days.remove(day);
}
}
|
java
|
{
"resource": ""
}
|
q756
|
RecurringData.setWeeklyDaysFromBitmap
|
train
|
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
|
{
"resource": ""
}
|
q757
|
RecurringData.getDayOfWeek
|
train
|
public Day getDayOfWeek()
{
Day result = null;
if (!m_days.isEmpty())
{
result = m_days.iterator().next();
}
return result;
}
|
java
|
{
"resource": ""
}
|
q758
|
RecurringData.getDates
|
train
|
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
|
{
"resource": ""
}
|
q759
|
RecurringData.moreDates
|
train
|
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
|
{
"resource": ""
}
|
q760
|
RecurringData.getDailyDates
|
train
|
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
|
{
"resource": ""
}
|
q761
|
RecurringData.getWeeklyDates
|
train
|
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
|
{
"resource": ""
}
|
q762
|
RecurringData.getMonthlyDates
|
train
|
private void getMonthlyDates(Calendar calendar, int frequency, List<Date> dates)
{
if (m_relative)
{
getMonthlyRelativeDates(calendar, frequency, dates);
}
else
{
getMonthlyAbsoluteDates(calendar, frequency, dates);
}
}
|
java
|
{
"resource": ""
}
|
q763
|
RecurringData.getMonthlyRelativeDates
|
train
|
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
|
{
"resource": ""
}
|
q764
|
RecurringData.getMonthlyAbsoluteDates
|
train
|
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
|
{
"resource": ""
}
|
q765
|
RecurringData.getYearlyDates
|
train
|
private void getYearlyDates(Calendar calendar, List<Date> dates)
{
if (m_relative)
{
getYearlyRelativeDates(calendar, dates);
}
else
{
getYearlyAbsoluteDates(calendar, dates);
}
}
|
java
|
{
"resource": ""
}
|
q766
|
RecurringData.getYearlyRelativeDates
|
train
|
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
|
{
"resource": ""
}
|
q767
|
RecurringData.getYearlyAbsoluteDates
|
train
|
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
|
{
"resource": ""
}
|
q768
|
RecurringData.setCalendarToOrdinalRelativeDay
|
train
|
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
|
{
"resource": ""
}
|
q769
|
RecurringData.setCalendarToLastRelativeDay
|
train
|
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
|
{
"resource": ""
}
|
q770
|
RecurringData.setYearlyAbsoluteFromDate
|
train
|
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
|
{
"resource": ""
}
|
q771
|
RecurringData.getOrdinal
|
train
|
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
|
{
"resource": ""
}
|
q772
|
PriorityUtility.getInstance
|
train
|
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
|
{
"resource": ""
}
|
q773
|
Duration.add
|
train
|
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
|
{
"resource": ""
}
|
q774
|
ProjectReaderUtility.getProjectReader
|
train
|
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
|
{
"resource": ""
}
|
q775
|
MPD9DatabaseReader.processCalendars
|
train
|
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
|
{
"resource": ""
}
|
q776
|
MPD9DatabaseReader.processCalendarData
|
train
|
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
|
{
"resource": ""
}
|
q777
|
MPD9DatabaseReader.processCalendarData
|
train
|
private void processCalendarData(ProjectCalendar calendar, List<ResultSetRow> calendarData)
{
for (ResultSetRow row : calendarData)
{
processCalendarData(calendar, row);
}
}
|
java
|
{
"resource": ""
}
|
q778
|
MPD9DatabaseReader.processSubProjects
|
train
|
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
|
{
"resource": ""
}
|
q779
|
MPD9DatabaseReader.processOutlineCodeFields
|
train
|
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
|
{
"resource": ""
}
|
q780
|
MPD9DatabaseReader.allocateConnection
|
train
|
private void allocateConnection() throws SQLException
{
if (m_connection == null)
{
m_connection = m_dataSource.getConnection();
m_allocatedConnection = true;
queryDatabaseMetaData();
}
}
|
java
|
{
"resource": ""
}
|
q781
|
MPD9DatabaseReader.queryDatabaseMetaData
|
train
|
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
|
{
"resource": ""
}
|
q782
|
DatatypeConverter.parseUUID
|
train
|
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
|
{
"resource": ""
}
|
q783
|
DatatypeConverter.printUUID
|
train
|
public static String printUUID(UUID guid)
{
return guid == null ? null : "{" + guid.toString().toUpperCase() + "}";
}
|
java
|
{
"resource": ""
}
|
q784
|
DatatypeConverter.printTime
|
train
|
public static final String printTime(Date value)
{
return (value == null ? null : TIME_FORMAT.get().format(value));
}
|
java
|
{
"resource": ""
}
|
q785
|
ProjectEntityContainer.renumberUniqueIDs
|
train
|
public void renumberUniqueIDs()
{
int uid = firstUniqueID();
for (T entity : this)
{
entity.setUniqueID(Integer.valueOf(uid++));
}
}
|
java
|
{
"resource": ""
}
|
q786
|
ProjectEntityContainer.validateUniqueIDsForMicrosoftProject
|
train
|
public void validateUniqueIDsForMicrosoftProject()
{
if (!isEmpty())
{
for (T entity : this)
{
if (NumberHelper.getInt(entity.getUniqueID()) > MS_PROJECT_MAX_UNIQUE_ID)
{
renumberUniqueIDs();
break;
}
}
}
}
|
java
|
{
"resource": ""
}
|
q787
|
SureTrakDatabaseReader.readDefinitions
|
train
|
private void readDefinitions()
{
for (MapRow row : m_tables.get("TTL"))
{
Integer id = row.getInteger("DEFINITION_ID");
List<MapRow> list = m_definitions.get(id);
if (list == null)
{
list = new ArrayList<MapRow>();
m_definitions.put(id, list);
}
list.add(row);
}
List<MapRow> rows = m_definitions.get(WBS_FORMAT_ID);
if (rows != null)
{
m_wbsFormat = new SureTrakWbsFormat(rows.get(0));
}
}
|
java
|
{
"resource": ""
}
|
q788
|
SureTrakDatabaseReader.readCalendars
|
train
|
private void readCalendars()
{
Table cal = m_tables.get("CAL");
for (MapRow row : cal)
{
ProjectCalendar calendar = m_projectFile.addCalendar();
m_calendarMap.put(row.getInteger("CALENDAR_ID"), calendar);
Integer[] days =
{
row.getInteger("SUNDAY_HOURS"),
row.getInteger("MONDAY_HOURS"),
row.getInteger("TUESDAY_HOURS"),
row.getInteger("WEDNESDAY_HOURS"),
row.getInteger("THURSDAY_HOURS"),
row.getInteger("FRIDAY_HOURS"),
row.getInteger("SATURDAY_HOURS")
};
calendar.setName(row.getString("NAME"));
readHours(calendar, Day.SUNDAY, days[0]);
readHours(calendar, Day.MONDAY, days[1]);
readHours(calendar, Day.TUESDAY, days[2]);
readHours(calendar, Day.WEDNESDAY, days[3]);
readHours(calendar, Day.THURSDAY, days[4]);
readHours(calendar, Day.FRIDAY, days[5]);
readHours(calendar, Day.SATURDAY, days[6]);
int workingDaysPerWeek = 0;
for (Day day : Day.values())
{
if (calendar.isWorkingDay(day))
{
++workingDaysPerWeek;
}
}
Integer workingHours = null;
for (int index = 0; index < 7; index++)
{
if (days[index].intValue() != 0)
{
workingHours = days[index];
break;
}
}
if (workingHours != null)
{
int workingHoursPerDay = countHours(workingHours);
int minutesPerDay = workingHoursPerDay * 60;
int minutesPerWeek = minutesPerDay * workingDaysPerWeek;
int minutesPerMonth = 4 * minutesPerWeek;
int minutesPerYear = 52 * minutesPerWeek;
calendar.setMinutesPerDay(Integer.valueOf(minutesPerDay));
calendar.setMinutesPerWeek(Integer.valueOf(minutesPerWeek));
calendar.setMinutesPerMonth(Integer.valueOf(minutesPerMonth));
calendar.setMinutesPerYear(Integer.valueOf(minutesPerYear));
}
}
}
|
java
|
{
"resource": ""
}
|
q789
|
SureTrakDatabaseReader.readHours
|
train
|
private void readHours(ProjectCalendar calendar, Day day, Integer hours)
{
int value = hours.intValue();
int startHour = 0;
ProjectCalendarHours calendarHours = null;
Calendar cal = DateHelper.popCalendar();
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
calendar.setWorkingDay(day, false);
while (value != 0)
{
// Move forward until we find a working hour
while (startHour < 24 && (value & 0x1) == 0)
{
value = value >> 1;
++startHour;
}
// No more working hours, bail out
if (startHour >= 24)
{
break;
}
// Move forward until we find the end of the working hours
int endHour = startHour;
while (endHour < 24 && (value & 0x1) != 0)
{
value = value >> 1;
++endHour;
}
cal.set(Calendar.HOUR_OF_DAY, startHour);
Date startDate = cal.getTime();
cal.set(Calendar.HOUR_OF_DAY, endHour);
Date endDate = cal.getTime();
if (calendarHours == null)
{
calendarHours = calendar.addCalendarHours(day);
calendar.setWorkingDay(day, true);
}
calendarHours.addRange(new DateRange(startDate, endDate));
startHour = endHour;
}
DateHelper.pushCalendar(cal);
}
|
java
|
{
"resource": ""
}
|
q790
|
SureTrakDatabaseReader.countHours
|
train
|
private int countHours(Integer hours)
{
int value = hours.intValue();
int hoursPerDay = 0;
int hour = 0;
while (value > 0)
{
// Move forward until we find a working hour
while (hour < 24)
{
if ((value & 0x1) != 0)
{
++hoursPerDay;
}
value = value >> 1;
++hour;
}
}
return hoursPerDay;
}
|
java
|
{
"resource": ""
}
|
q791
|
SureTrakDatabaseReader.readHolidays
|
train
|
private void readHolidays()
{
for (MapRow row : m_tables.get("HOL"))
{
ProjectCalendar calendar = m_calendarMap.get(row.getInteger("CALENDAR_ID"));
if (calendar != null)
{
Date date = row.getDate("DATE");
ProjectCalendarException exception = calendar.addCalendarException(date, date);
if (row.getBoolean("ANNUAL"))
{
RecurringData recurring = new RecurringData();
recurring.setRecurrenceType(RecurrenceType.YEARLY);
recurring.setYearlyAbsoluteFromDate(date);
recurring.setStartDate(date);
exception.setRecurring(recurring);
// TODO set end date based on project end date
}
}
}
}
|
java
|
{
"resource": ""
}
|
q792
|
SureTrakDatabaseReader.readActivities
|
train
|
private void readActivities()
{
List<MapRow> items = new ArrayList<MapRow>();
for (MapRow row : m_tables.get("ACT"))
{
items.add(row);
}
final AlphanumComparator comparator = new AlphanumComparator();
Collections.sort(items, new Comparator<MapRow>()
{
@Override public int compare(MapRow o1, MapRow o2)
{
return comparator.compare(o1.getString("ACTIVITY_ID"), o2.getString("ACTIVITY_ID"));
}
});
for (MapRow row : items)
{
String activityID = row.getString("ACTIVITY_ID");
String wbs;
if (m_wbsFormat == null)
{
wbs = null;
}
else
{
m_wbsFormat.parseRawValue(row.getString("WBS"));
wbs = m_wbsFormat.getFormattedValue();
}
ChildTaskContainer parent = m_wbsMap.get(wbs);
if (parent == null)
{
parent = m_projectFile;
}
Task task = parent.addTask();
setFields(TASK_FIELDS, row, task);
task.setStart(task.getEarlyStart());
task.setFinish(task.getEarlyFinish());
task.setMilestone(task.getDuration().getDuration() == 0);
task.setWBS(wbs);
Duration duration = task.getDuration();
Duration remainingDuration = task.getRemainingDuration();
task.setActualDuration(Duration.getInstance(duration.getDuration() - remainingDuration.getDuration(), TimeUnit.HOURS));
m_activityMap.put(activityID, task);
}
}
|
java
|
{
"resource": ""
}
|
q793
|
CostRateTableFactory.process
|
train
|
public void process(Resource resource, int index, byte[] data)
{
CostRateTable result = new CostRateTable();
if (data != null)
{
for (int i = 16; i + 44 <= data.length; i += 44)
{
Rate standardRate = new Rate(MPPUtility.getDouble(data, i), TimeUnit.HOURS);
TimeUnit standardRateFormat = getFormat(MPPUtility.getShort(data, i + 8));
Rate overtimeRate = new Rate(MPPUtility.getDouble(data, i + 16), TimeUnit.HOURS);
TimeUnit overtimeRateFormat = getFormat(MPPUtility.getShort(data, i + 24));
Double costPerUse = NumberHelper.getDouble(MPPUtility.getDouble(data, i + 32) / 100.0);
Date endDate = MPPUtility.getTimestampFromTenths(data, i + 40);
CostRateTableEntry entry = new CostRateTableEntry(standardRate, standardRateFormat, overtimeRate, overtimeRateFormat, costPerUse, endDate);
result.add(entry);
}
Collections.sort(result);
}
else
{
//
// MS Project economises by not actually storing the first cost rate
// table if it doesn't need to, so we take this into account here.
//
if (index == 0)
{
Rate standardRate = resource.getStandardRate();
Rate overtimeRate = resource.getOvertimeRate();
Number costPerUse = resource.getCostPerUse();
CostRateTableEntry entry = new CostRateTableEntry(standardRate, standardRate.getUnits(), overtimeRate, overtimeRate.getUnits(), costPerUse, CostRateTableEntry.DEFAULT_ENTRY.getEndDate());
result.add(entry);
}
else
{
result.add(CostRateTableEntry.DEFAULT_ENTRY);
}
}
resource.setCostRateTable(index, result);
}
|
java
|
{
"resource": ""
}
|
q794
|
CostRateTableFactory.getFormat
|
train
|
private TimeUnit getFormat(int format)
{
TimeUnit result;
if (format == 0xFFFF)
{
result = TimeUnit.HOURS;
}
else
{
result = MPPUtility.getWorkTimeUnits(format);
}
return result;
}
|
java
|
{
"resource": ""
}
|
q795
|
ConstraintTypeUtility.getInstance
|
train
|
public static ConstraintType getInstance(Locale locale, String type)
{
int index = 0;
String[] constraintTypes = LocaleData.getStringArray(locale, LocaleData.CONSTRAINT_TYPES);
for (int loop = 0; loop < constraintTypes.length; loop++)
{
if (constraintTypes[loop].equalsIgnoreCase(type) == true)
{
index = loop;
break;
}
}
return (ConstraintType.getInstance(index));
}
|
java
|
{
"resource": ""
}
|
q796
|
MpxjQuery.query
|
train
|
private static void query(String filename) throws Exception
{
ProjectFile mpx = new UniversalProjectReader().read(filename);
listProjectProperties(mpx);
listResources(mpx);
listTasks(mpx);
listAssignments(mpx);
listAssignmentsByTask(mpx);
listAssignmentsByResource(mpx);
listHierarchy(mpx);
listTaskNotes(mpx);
listResourceNotes(mpx);
listRelationships(mpx);
listSlack(mpx);
listCalendars(mpx);
}
|
java
|
{
"resource": ""
}
|
q797
|
MpxjQuery.listProjectProperties
|
train
|
private static void listProjectProperties(ProjectFile file)
{
SimpleDateFormat df = new SimpleDateFormat("dd/MM/yyyy HH:mm z");
ProjectProperties properties = file.getProjectProperties();
Date startDate = properties.getStartDate();
Date finishDate = properties.getFinishDate();
String formattedStartDate = startDate == null ? "(none)" : df.format(startDate);
String formattedFinishDate = finishDate == null ? "(none)" : df.format(finishDate);
System.out.println("MPP file type: " + properties.getMppFileType());
System.out.println("Project Properties: StartDate=" + formattedStartDate + " FinishDate=" + formattedFinishDate);
System.out.println();
}
|
java
|
{
"resource": ""
}
|
q798
|
MpxjQuery.listResources
|
train
|
private static void listResources(ProjectFile file)
{
for (Resource resource : file.getResources())
{
System.out.println("Resource: " + resource.getName() + " (Unique ID=" + resource.getUniqueID() + ") Start=" + resource.getStart() + " Finish=" + resource.getFinish());
}
System.out.println();
}
|
java
|
{
"resource": ""
}
|
q799
|
MpxjQuery.listTasks
|
train
|
private static void listTasks(ProjectFile file)
{
SimpleDateFormat df = new SimpleDateFormat("dd/MM/yyyy HH:mm z");
for (Task task : file.getTasks())
{
Date date = task.getStart();
String text = task.getStartText();
String startDate = text != null ? text : (date != null ? df.format(date) : "(no start date supplied)");
date = task.getFinish();
text = task.getFinishText();
String finishDate = text != null ? text : (date != null ? df.format(date) : "(no finish date supplied)");
Duration dur = task.getDuration();
text = task.getDurationText();
String duration = text != null ? text : (dur != null ? dur.toString() : "(no duration supplied)");
dur = task.getActualDuration();
String actualDuration = dur != null ? dur.toString() : "(no actual duration supplied)";
String baselineDuration = task.getBaselineDurationText();
if (baselineDuration == null)
{
dur = task.getBaselineDuration();
if (dur != null)
{
baselineDuration = dur.toString();
}
else
{
baselineDuration = "(no duration supplied)";
}
}
System.out.println("Task: " + task.getName() + " ID=" + task.getID() + " Unique ID=" + task.getUniqueID() + " (Start Date=" + startDate + " Finish Date=" + finishDate + " Duration=" + duration + " Actual Duration" + actualDuration + " Baseline Duration=" + baselineDuration + " Outline Level=" + task.getOutlineLevel() + " Outline Number=" + task.getOutlineNumber() + " Recurring=" + task.getRecurring() + ")");
}
System.out.println();
}
|
java
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.