Java tutorial
/* * This file is part of LibrePlan * * Copyright (C) 2012 Igalia, S.L. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ package org.libreplan.importers; import java.util.ArrayList; import java.util.Calendar; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.UUID; import net.sf.mpxj.DateRange; import net.sf.mpxj.DayType; import net.sf.mpxj.Duration; import net.sf.mpxj.ProjectCalendar; import net.sf.mpxj.ProjectCalendarDateRanges; import net.sf.mpxj.ProjectCalendarException; import net.sf.mpxj.ProjectCalendarWeek; import net.sf.mpxj.ProjectFile; import net.sf.mpxj.ProjectProperties; import net.sf.mpxj.Relation; import net.sf.mpxj.RelationType; import net.sf.mpxj.Task; import net.sf.mpxj.TimeUnit; import org.apache.commons.io.FilenameUtils; import org.apache.commons.lang3.StringUtils; import org.joda.time.DateTime; import org.joda.time.Period; import org.libreplan.importers.CalendarDayHoursDTO.CalendarDayDTO; import org.libreplan.importers.CalendarDayHoursDTO.CalendarTypeDayDTO; import org.libreplan.importers.DependencyDTO.TypeOfDependencyDTO; /** * Class that is a converter from the MPXJ format File to {@link OrderDTO}. * * @author Alba Carro Prez <alba.carro@gmail.com> * @author Vova Perebykivskyi <vova@libreplan-enterprise.com> * * @todo It last relationships. resources, calendars, hours, etc. */ public class MPXJProjectFileConverter { private static ProjectProperties properties; /** * Map between the MPXJ Task and the OrderElemenDTO or MilestoneDTO that represent it. */ private static Map<Task, IHasTaskAssociated> mapTask; /** * Converts a ProjectFile into a {@link OrderDTO}. * * This method contains a switch that is going to select the method to call for each format. * At this time it only differences between planner and project. * * @param file * ProjectFile to extract data from. * @return ImportData with the data that we want to import. */ public static OrderDTO convert(ProjectFile file, String filename) { OrderDTO importData = null; if (FilenameUtils.getExtension(filename).equals("planner")) importData = getImportDataFromPlanner(file, filename); else if (FilenameUtils.getExtension(filename).equals("mpp")) importData = getImportDataFromMPP(file, filename); return importData; } /** * Get a list of {@link CalendarDTO} from a ProjectFile. * * @param file * ProjectFile to extract data from. * @return List<CalendarDTO> List with the calendars that we want to import. */ public static List<CalendarDTO> convertCalendars(ProjectFile file) { List<CalendarDTO> calendarDTOs = new ArrayList<>(); for (ProjectCalendar projectCalendar : file.getCalendars()) { if (StringUtils.isBlank(projectCalendar.getName())) { String name = "calendar-" + UUID.randomUUID(); projectCalendar.setName(name); } calendarDTOs.add(toCalendarDTO(projectCalendar)); calendarDTOs.addAll(getDerivedCalendars(projectCalendar.getDerivedCalendars())); } return calendarDTOs; } /** * Get a list of {@link CalendarDTO} from a ProjectFile. * * @param derivedProjectCalendars * ProjectCalendar to extract data from. * @return List<CalendarDTO> List with the calendars that we want to import. */ public static List<CalendarDTO> getDerivedCalendars(List<ProjectCalendar> derivedProjectCalendars) { List<CalendarDTO> calendarDTOs = new ArrayList<>(); for (ProjectCalendar projectCalendar : derivedProjectCalendars) { if (projectCalendar.getResource() == null && projectCalendar.getName() != null && projectCalendar.getName().length() != 0) { calendarDTOs.add(toCalendarDTO(projectCalendar)); calendarDTOs.addAll(getDerivedCalendars(projectCalendar.getDerivedCalendars())); } } return calendarDTOs; } /** * Get {@link CalendarDTO} from a ProjectCalendar. * * @param projectCalendar * ProjectCalendar to extract data from. * @return List<CalendarDTO> List with the calendars that we want to import. */ private static CalendarDTO toCalendarDTO(ProjectCalendar projectCalendar) { CalendarDTO calendarDTO = new CalendarDTO(); calendarDTO.name = projectCalendar.getName(); if (projectCalendar.getParent() != null) { calendarDTO.parent = projectCalendar.getParent().getName(); } calendarDTO.calendarExceptions = getCalendarExceptionDTOs(projectCalendar.getCalendarExceptions()); List<ProjectCalendarWeek> workWeeks = projectCalendar.getWorkWeeks(); Collections.sort(workWeeks, new CompareMPXJProjectCalendarWeeks()); calendarDTO.calendarWeeks = getCalendarWeekDTOs(projectCalendar, workWeeks); return calendarDTO; } /** * Get a list of {@link CalendarExceptionDTO} from a list of CalendarExceptions. * * @param calendarExceptions * List of CalendarException to extract data from. * @return List<CalendarExceptionDTO> List with the CalendarExcepitions that we want to import. */ private static List<CalendarExceptionDTO> getCalendarExceptionDTOs( List<ProjectCalendarException> calendarExceptions) { List<CalendarExceptionDTO> calendarExceptionDTOs = new ArrayList<>(); for (ProjectCalendarException projectCalendarException : calendarExceptions) { calendarExceptionDTOs.addAll(toCalendarExceptionDTOs(projectCalendarException)); } return calendarExceptionDTOs; } /** * Get {@link CalendarExceptionDTO} from a ProjectCalendarException. * * @param projectCalendarException * ProjectCalendarException to extract data from. * @return List<CalendarExceptionDTO> with the calendar exceptions that we want to import. */ private static List<CalendarExceptionDTO> toCalendarExceptionDTOs( ProjectCalendarException projectCalendarException) { List<CalendarExceptionDTO> calendarExceptionDTOs = new ArrayList<>(); Date fromDate = projectCalendarException.getFromDate(); Date toDate = projectCalendarException.getToDate(); Period period = new Period(new DateTime(fromDate), new DateTime(toDate)); boolean working = projectCalendarException.getWorking(); int day = period.getDays(); Calendar cal = Calendar.getInstance(); cal.setTime(fromDate); List<Integer> duration = toHours(projectCalendarException); int hours; int minutes; if (duration != null) { hours = duration.get(0); minutes = duration.get(1); } else { if (working) { hours = 8; } else { hours = 0; } minutes = 0; } while (day > -1) { if (day == 0) { calendarExceptionDTOs.add(toCalendarExceptionDTO(cal.getTime(), hours, minutes, working)); } else { calendarExceptionDTOs.add(toCalendarExceptionDTO(cal.getTime(), hours, minutes, working)); cal.add(Calendar.DAY_OF_MONTH, +1); } day--; } return calendarExceptionDTOs; } /** * Get {@link CalendarExceptionDTO} from a ProjectCalendarException. * * @param fromDate * Date with the day of the exception. * @param hours * int with the hours. * @param minutes * int with the minutes. * @param working * boolean to express it is a working exception or not * @return CalendarExceptionDTO with the calendar exceptions that we want to import. */ private static CalendarExceptionDTO toCalendarExceptionDTO(Date fromDate, int hours, int minutes, boolean working) { CalendarExceptionDTO calendarExceptionDTO = new CalendarExceptionDTO(); calendarExceptionDTO.date = fromDate; calendarExceptionDTO.hours = hours; calendarExceptionDTO.minutes = minutes; calendarExceptionDTO.working = working; return calendarExceptionDTO; } /** * Get a list of {@link CalendarWeekDTO} from a list of ProjectCalendarWeek. * * @param projectCalendar * ProjectCalendarWeek with the default data * @param workWeeks * List of ProjectCalendarWeek to extract data from.Assume that is ordered * for its DataRange start date. * @return List<CalendarDataDTO> List with the CalendarData that we want to import. */ private static List<CalendarWeekDTO> getCalendarWeekDTOs(ProjectCalendar projectCalendar, List<ProjectCalendarWeek> workWeeks) { List<CalendarWeekDTO> calendarDataDTOs = new ArrayList<>(); Date startCalendarDate; Date endCalendarDate; if (projectCalendar.getDateRange() == null) { startCalendarDate = projectCalendar.getParentFile().getProjectProperties().getStartDate(); endCalendarDate = projectCalendar.getParentFile().getProjectProperties().getFinishDate(); } else { startCalendarDate = projectCalendar.getDateRange().getStart(); endCalendarDate = projectCalendar.getDateRange().getEnd(); } if (workWeeks.isEmpty()) { calendarDataDTOs.add(toCalendarWeekDTO(projectCalendar)); } else { /* * TODO * This utility is not currently implemented in MPXJ. * This one is going to represent all the work weeks. * Including the ones with the default value that are in the middle of two. */ Date firsWorkWeekCalendarDate = workWeeks.get(0).getDateRange().getStart(); Calendar calendar1 = Calendar.getInstance(); Calendar calendar2 = Calendar.getInstance(); // If the star of the first work week is after the start of the default we have to fill the hole if (startCalendarDate.compareTo(firsWorkWeekCalendarDate) < 0) { calendar1.setTime(firsWorkWeekCalendarDate); calendar1.set(Calendar.DAY_OF_MONTH, -1); calendarDataDTOs.add(toCalendarWeekDTO(projectCalendar)); } Date endDate; Date nextStartDate; int j; for (int i = 0; i < workWeeks.size(); i++) { endDate = workWeeks.get(i).getDateRange().getEnd(); calendarDataDTOs.add(toCalendarWeekDTO(workWeeks.get(i))); j = i + 1; // If is not the last one if (j < workWeeks.size()) { nextStartDate = workWeeks.get(i + 1).getDateRange().getStart(); calendar1.setTime(endDate); calendar1.set(Calendar.DAY_OF_MONTH, +1); // If the end of the current work week is more than one day before the beginning of the next if (calendar1.getTime().compareTo(nextStartDate) < 0) { calendar2.setTime(nextStartDate); calendar1.set(Calendar.DAY_OF_MONTH, -1); // Adds a new default calendar week in the hole calendarDataDTOs.add(toCalendarWeekDTO(projectCalendar)); } } } Date endWorkWeekCalendarDate = workWeeks.get(workWeeks.size()).getDateRange().getEnd(); // If the end of the last work week is earlier than the end of the default we have to fill the hole if (endCalendarDate.compareTo(endWorkWeekCalendarDate) > 0) { calendar1.setTime(endWorkWeekCalendarDate); calendar1.set(Calendar.DAY_OF_MONTH, +1); calendarDataDTOs.add(toCalendarWeekDTO(projectCalendar)); } } return calendarDataDTOs; } /** * Get {@link CalendarWeekDTO} from a ProjectCalendarWeek. * * @param projectCalendarWeek * ProjectCalendarWeek to extract data from. * @return CalendarDataDTO with the calendar data that we want to import. */ private static CalendarWeekDTO toCalendarWeekDTO(ProjectCalendarWeek projectCalendarWeek) { CalendarWeekDTO calendarDataDTO = new CalendarWeekDTO(); if (projectCalendarWeek.getDateRange() != null) { calendarDataDTO.startDate = projectCalendarWeek.getDateRange().getStart(); calendarDataDTO.endDate = projectCalendarWeek.getDateRange().getEnd(); } else { calendarDataDTO.startDate = null; calendarDataDTO.endDate = null; } List<CalendarDayHoursDTO> calendarDaysHourDTOs = new ArrayList<>(); CalendarDayHoursDTO calendarDayHoursDTO; for (int i = 0; i < 7; i++) { calendarDayHoursDTO = new CalendarDayHoursDTO(); calendarDayHoursDTO.type = toCalendarTypeDayDTO(projectCalendarWeek.getDays()[i]); calendarDayHoursDTO.day = CalendarDayDTO.values()[i]; List<Integer> duration = toHours(projectCalendarWeek.getHours()[i]); if (duration != null) { calendarDayHoursDTO.hours = duration.get(0); calendarDayHoursDTO.minutes = duration.get(1); } else { if (calendarDayHoursDTO.type == CalendarTypeDayDTO.WORKING) { calendarDayHoursDTO.hours = 8; } else if (calendarDayHoursDTO.type == CalendarTypeDayDTO.NOT_WORKING) { calendarDayHoursDTO.hours = 0; } else if (calendarDayHoursDTO.type == CalendarTypeDayDTO.DEFAULT) { // TODO Grab the ones form default calendarDayHoursDTO.hours = 0; } calendarDayHoursDTO.minutes = 0; } calendarDaysHourDTOs.add(calendarDayHoursDTO); } calendarDataDTO.hoursPerDays = calendarDaysHourDTOs; return calendarDataDTO; } private static CalendarTypeDayDTO toCalendarTypeDayDTO(DayType dayType) { switch (dayType) { case DEFAULT: return CalendarTypeDayDTO.DEFAULT; case NON_WORKING: return CalendarTypeDayDTO.NOT_WORKING; case WORKING: return CalendarTypeDayDTO.WORKING; default: return null; } } /** * Get the number of hours of a ProjectCalendarHours. * * @param projectCalendarDateRanges * ProjectCalendarDateRanges to extract data from. * @return Integer with the total number of hours or null if the projectCalendarHours is null. */ private static List<Integer> toHours(ProjectCalendarDateRanges projectCalendarDateRanges) { if (projectCalendarDateRanges != null) { List<Integer> duration = new ArrayList<>(); int hours = 0; int minutes = 0; for (DateRange dateRange : projectCalendarDateRanges) { DateTime start = new DateTime(dateRange.getStart()); DateTime end = new DateTime(dateRange.getEnd()); Period period = new Period(start, end); int days = period.getDays(); if (period.getDays() != 0) { hours += 24 * days; } hours += period.getHours(); minutes += period.getMinutes(); } duration.add(hours); duration.add(minutes); return duration; } else { return null; } } /** * Converts a ProjectFile into a {@link OrderDTO}. * Assumes that the ProjectFile comes for a .planner file. * * @param file * ProjectFile to extract data from. * @return ImportData with the data that we want to import. */ private static OrderDTO getImportDataFromPlanner(ProjectFile file, String filename) { OrderDTO importData = new OrderDTO(); mapTask = new HashMap<>(); importData.name = filename.substring(0, filename.length() - 8/* ".planner" */); properties = file.getProjectProperties(); importData.startDate = properties.getStartDate(); importData.tasks = getImportTasks(file.getChildTasks()); importData.milestones = getImportMilestones(file.getChildTasks()); // MPXJ don't provide a deadline for the project so we take the finish date importData.deadline = properties.getFinishDate(); importData.dependencies = createDependencies(); importData.calendarName = file.getBaselineCalendar().getName(); return importData; } /** * Uses the map mapTask to create the list of {@link DependencyDTO}. * * @return List<DependencyDTO> * List with all the dependencies */ private static List<DependencyDTO> createDependencies() { List<DependencyDTO> dependencies = new ArrayList<>(); List<Relation> successors; Task task; DependencyDTO dependencyDTO; for (Map.Entry<Task, IHasTaskAssociated> mapEntry : mapTask.entrySet()) { task = mapEntry.getKey(); successors = task.getSuccessors(); if (successors != null) { for (Relation successor : successors) { dependencyDTO = new DependencyDTO(); dependencyDTO.origin = mapEntry.getValue(); dependencyDTO.destination = mapTask.get(successor.getTargetTask()); dependencyDTO.type = toDependencyDTOType(successor.getType()); dependencies.add(dependencyDTO); } } } return dependencies; } /** * Mapping between LP and MPXJ relationships. * * @param type * MPXJ RelationType to map. * @return TypeOfDependencyDTO * Type of the dependency for DependencyDTO */ private static TypeOfDependencyDTO toDependencyDTOType(RelationType type) { switch (type) { case FINISH_FINISH: return TypeOfDependencyDTO.END_END; case FINISH_START: return TypeOfDependencyDTO.END_START; case START_FINISH: return TypeOfDependencyDTO.START_END; case START_START: return TypeOfDependencyDTO.START_START; default: return null; } } /** * Converts a ProjectFile into a {@link OrderDTO}. * Assumes that the ProjectFile comes for a .mpp file. * * @param file * ProjectFile to extract data from. * @return ImportData with the data that we want to import. */ private static OrderDTO getImportDataFromMPP(ProjectFile file, String filename) { OrderDTO importData = new OrderDTO(); mapTask = new HashMap<>(); properties = file.getProjectProperties(); importData.startDate = properties.getStartDate(); // MPXJ doesn't provide a deadline for the project so we take the finish date importData.deadline = properties.getFinishDate(); for (Task task : file.getChildTasks()) { // Projects are represented as a level 0 task with all real task as its children. // Ignore all other top level tasks. // See http://mpxj.sourceforge.net/faq.html#extra-tasks-and-resources if (!task.getChildTasks().isEmpty()) { String name = task.getName(); if (name != null) { importData.name = name; } else { // Take the filename if the project name is not set importData.name = filename.substring(0, filename.length() - 4 /* ".mpp" */ ); } importData.tasks = getImportTasks(task.getChildTasks()); importData.milestones = getImportMilestones(task.getChildTasks()); importData.calendarName = file.getDefaultCalendar().getName(); break; } } importData.dependencies = createDependencies(); return importData; } /** * Converts a List of MPXJ Tasks into a List of {@link MilestoneDTO}. * * @param childTasks * List of MPXJ Tasks to extract data from. * @return List<MilestoneDTO> List of MilestoneDTO with the data that we want to * import. */ private static List<MilestoneDTO> getImportMilestones(List<Task> childTasks) { List<MilestoneDTO> milestones = new ArrayList<>(); for (Task task : childTasks) { if (task.getMilestone()) { MilestoneDTO milestone = getMilestoneData(task); mapTask.put(task, milestone); milestones.add(milestone); } } return milestones; } /** * Converts a MPXJ Task into a {@link MilestoneDTO}. * * @param task * MPXJ Task to extract data from. * @return MilestoneDTO MilestoneDTO with the data that we want to import. */ private static MilestoneDTO getMilestoneData(Task task) { MilestoneDTO milestone = new MilestoneDTO(); milestone.name = task.getName(); milestone.startDate = task.getStart(); toLibreplanConstraint(task); milestone.constraint = constraint; milestone.constraintDate = constraintDate; return milestone; } /** * Converts the Duration into an integer that represent hours. * * @param duration * Duration to convert. * @param properties * ProjectProperties needed to convert * @return int Integer with the rounded duration in hours */ private static int durationToIntHours(Duration duration, ProjectProperties properties) { Duration durationInHours = duration.convertUnits(TimeUnit.HOURS, properties); return (int) Math.floor(durationInHours.getDuration()); } /** * Converts a List of MPXJ Tasks into a List of {@link OrderElementDTO}. * * @param tasks * List of MPXJ Tasks to extract data from. * @return List<OrderElementDTO> List of ImportTask with the data that we want to import. */ private static List<OrderElementDTO> getImportTasks(List<Task> tasks) { List<OrderElementDTO> importTasks = new ArrayList<>(); for (Task task : tasks) { if (!task.getMilestone()) { OrderElementDTO importTask = getTaskData(task); importTask.children = getImportTasks(task.getChildTasks()); importTask.milestones = getImportMilestones(task.getChildTasks()); // This is because in MPXJ only MPP9 files have this attribute if (task.getCalendar() != null) { importTask.calendarName = task.getCalendar().getName(); } else { importTask.calendarName = null; } mapTask.put(task, importTask); importTasks.add(importTask); } } return importTasks; } /** * Converts a MPXJ Task into a {@link OrderElementDTO}. * * @param task * MPXJ Task to extract data from. * @return OrderElementDTO OrderElementDTO with the data that we want to import. */ private static OrderElementDTO getTaskData(Task task) { OrderElementDTO importTask = new OrderElementDTO(); importTask.name = task.getName(); importTask.startDate = task.getStart(); importTask.endDate = task.getFinish(); importTask.totalHours = durationToIntHours(task.getDuration(), properties); importTask.deadline = task.getDeadline(); toLibreplanConstraint(task); importTask.constraint = constraint; importTask.constraintDate = constraintDate; return importTask; } private static ConstraintDTO constraint; private static Date constraintDate; /** * Set the attributes constraint y constraintDate with the correct value. * * Because MPXJ has more types of constraints than Libreplan we had * choose to convert some of them. * * @param task * MPXJ Task to extract data from. */ private static void toLibreplanConstraint(Task task) { switch (task.getConstraintType()) { case AS_SOON_AS_POSSIBLE: constraint = ConstraintDTO.AS_SOON_AS_POSSIBLE; constraintDate = task.getConstraintDate(); return; case AS_LATE_AS_POSSIBLE: constraint = ConstraintDTO.AS_LATE_AS_POSSIBLE; constraintDate = task.getConstraintDate(); return; case MUST_START_ON: constraint = ConstraintDTO.START_IN_FIXED_DATE; constraintDate = task.getConstraintDate(); return; case MUST_FINISH_ON: constraint = ConstraintDTO.START_IN_FIXED_DATE; constraintDate = recalculateConstraintDateMin(task); return; case START_NO_EARLIER_THAN: constraint = ConstraintDTO.START_NOT_EARLIER_THAN; constraintDate = task.getConstraintDate(); return; case START_NO_LATER_THAN: constraint = ConstraintDTO.FINISH_NOT_LATER_THAN; constraintDate = recalculateConstraintDateSum(task); return; case FINISH_NO_EARLIER_THAN: constraint = ConstraintDTO.START_NOT_EARLIER_THAN; constraintDate = recalculateConstraintDateMin(task); return; case FINISH_NO_LATER_THAN: constraint = ConstraintDTO.FINISH_NOT_LATER_THAN; constraintDate = task.getConstraintDate(); return; default: break; } } /** * Get the new date based on the task date adding duration. * * @param task * MPXJ Task to extract data from. * @return Date new recalculated date */ private static Date recalculateConstraintDateSum(Task task) { return new Date(task.getConstraintDate().getTime() + (durationToIntHours(task.getDuration(), properties) * 60 * 60 * 1000)); } /** * Get the new date based on the task date and substracting duration. * * @param task * MPXJ Task to extract data from. * @return Date new recalculated date */ private static Date recalculateConstraintDateMin(Task task) { return new Date(task.getConstraintDate().getTime() - (durationToIntHours(task.getDuration(), properties) * 60 * 60 * 1000)); } }