Java Code Examples for net.sf.mpxj.ProjectCalendar#setName()

/**
 * Populates a calendar instance.
 *
 * @param record MPX record
 * @param calendar calendar instance
 * @param isBaseCalendar true if this is a base calendar
 */
private void populateCalendar(Record record, ProjectCalendar calendar, boolean isBaseCalendar)
{
   if (isBaseCalendar == true)
   {
      calendar.setName(record.getString(0));
   }
   else
   {
      calendar.setParent(m_projectFile.getCalendarByName(record.getString(0)));
   }

   calendar.setWorkingDay(Day.SUNDAY, record.getDayType(1));
   calendar.setWorkingDay(Day.MONDAY, record.getDayType(2));
   calendar.setWorkingDay(Day.TUESDAY, record.getDayType(3));
   calendar.setWorkingDay(Day.WEDNESDAY, record.getDayType(4));
   calendar.setWorkingDay(Day.THURSDAY, record.getDayType(5));
   calendar.setWorkingDay(Day.FRIDAY, record.getDayType(6));
   calendar.setWorkingDay(Day.SATURDAY, record.getDayType(7));

   m_eventManager.fireCalendarReadEvent(calendar);
}
 

/**
 * Read a calendar.
 *
 * @param row calendar data
 */
protected void processCalendar(Row row)
{
   Integer uniqueID = row.getInteger("CAL_UID");
   if (NumberHelper.getInt(uniqueID) > 0)
   {
      boolean baseCalendar = row.getBoolean("CAL_IS_BASE_CAL");
      ProjectCalendar cal;
      if (baseCalendar == true)
      {
         cal = m_project.addCalendar();
         cal.setName(row.getString("CAL_NAME"));
      }
      else
      {
         Integer resourceID = row.getInteger("RES_UID");
         cal = m_project.addCalendar();
         m_baseCalendarReferences.add(new Pair<>(cal, row.getInteger("CAL_BASE_UID")));
         m_resourceMap.put(resourceID, cal);
      }

      cal.setUniqueID(uniqueID);
      m_calendarMap.put(uniqueID, cal);
      m_eventManager.fireCalendarReadEvent(cal);
   }
}
 

/**
 * Extract data for a single calendar.
 *
 * @param row calendar data
 */
private void processCalendar(MapRow row)
{
   ProjectCalendar calendar = m_project.addCalendar();

   Map<UUID, List<DateRange>> dayTypeMap = processDayTypes(row.getRows("DAY_TYPES"));

   calendar.setName(row.getString("NAME"));

   processRanges(dayTypeMap.get(row.getUUID("SUNDAY_DAY_TYPE")), calendar.addCalendarHours(Day.SUNDAY));
   processRanges(dayTypeMap.get(row.getUUID("MONDAY_DAY_TYPE")), calendar.addCalendarHours(Day.MONDAY));
   processRanges(dayTypeMap.get(row.getUUID("TUESDAY_DAY_TYPE")), calendar.addCalendarHours(Day.TUESDAY));
   processRanges(dayTypeMap.get(row.getUUID("WEDNESDAY_DAY_TYPE")), calendar.addCalendarHours(Day.WEDNESDAY));
   processRanges(dayTypeMap.get(row.getUUID("THURSDAY_DAY_TYPE")), calendar.addCalendarHours(Day.THURSDAY));
   processRanges(dayTypeMap.get(row.getUUID("FRIDAY_DAY_TYPE")), calendar.addCalendarHours(Day.FRIDAY));
   processRanges(dayTypeMap.get(row.getUUID("SATURDAY_DAY_TYPE")), calendar.addCalendarHours(Day.SATURDAY));

   for (MapRow assignment : row.getRows("DAY_TYPE_ASSIGNMENTS"))
   {
      Date date = assignment.getDate("DATE");
      processRanges(dayTypeMap.get(assignment.getUUID("DAY_TYPE_UUID")), calendar.addCalendarException(date, date));
   }

   m_calendarMap.put(row.getUUID("UUID"), calendar);
}
 

/**
 * This method extracts data for a single calendar from an MSPDI file.
 *
 * @param calendar Calendar data
 * @param map Map of calendar UIDs to names
 * @param baseCalendars list of base calendars
 */
private void readCalendar(Project.Calendars.Calendar calendar, HashMap<BigInteger, ProjectCalendar> map, List<Pair<ProjectCalendar, BigInteger>> baseCalendars)
{
   ProjectCalendar bc = m_projectFile.addCalendar();
   bc.setUniqueID(NumberHelper.getInteger(calendar.getUID()));
   bc.setName(calendar.getName());
   BigInteger baseCalendarID = calendar.getBaseCalendarUID();
   if (baseCalendarID != null)
   {
      baseCalendars.add(new Pair<>(bc, baseCalendarID));
   }

   readExceptions(calendar, bc);
   boolean readExceptionsFromDays = bc.getCalendarExceptions().isEmpty();

   Project.Calendars.Calendar.WeekDays days = calendar.getWeekDays();
   if (days != null)
   {
      for (Project.Calendars.Calendar.WeekDays.WeekDay weekDay : days.getWeekDay())
      {
         readDay(bc, weekDay, readExceptionsFromDays);
      }
   }
   else
   {
      bc.setWorkingDay(Day.SUNDAY, DayType.DEFAULT);
      bc.setWorkingDay(Day.MONDAY, DayType.DEFAULT);
      bc.setWorkingDay(Day.TUESDAY, DayType.DEFAULT);
      bc.setWorkingDay(Day.WEDNESDAY, DayType.DEFAULT);
      bc.setWorkingDay(Day.THURSDAY, DayType.DEFAULT);
      bc.setWorkingDay(Day.FRIDAY, DayType.DEFAULT);
      bc.setWorkingDay(Day.SATURDAY, DayType.DEFAULT);
   }

   readWorkWeeks(calendar, bc);

   map.put(calendar.getUID(), bc);

   m_eventManager.fireCalendarReadEvent(bc);
}
 

/**
 * Read calendar data.
 */
private void processCalendars() throws Exception
{
   List<Row> rows = getRows("select * from zcalendar where zproject=?", m_projectID);
   for (Row row : rows)
   {
      ProjectCalendar calendar = m_project.addCalendar();
      calendar.setUniqueID(row.getInteger("Z_PK"));
      calendar.setName(row.getString("ZTITLE"));
      processDays(calendar);
      processExceptions(calendar);
      m_eventManager.fireCalendarReadEvent(calendar);
   }
}
 

/**
 * Read resource data.
 */
private void processResources() throws SQLException
{
   List<Row> rows = getRows("select * from zresource where zproject=? order by zorderinproject", m_projectID);
   for (Row row : rows)
   {
      Resource resource = m_project.addResource();
      resource.setUniqueID(row.getInteger("Z_PK"));
      resource.setEmailAddress(row.getString("ZEMAIL"));
      resource.setInitials(row.getString("ZINITIALS"));
      resource.setName(row.getString("ZTITLE_"));
      resource.setGUID(row.getUUID("ZUNIQUEID"));
      resource.setType(row.getResourceType("ZTYPE"));
      resource.setMaterialLabel(row.getString("ZMATERIALUNIT"));

      if (resource.getType() == ResourceType.WORK)
      {
         resource.setMaxUnits(Double.valueOf(NumberHelper.getDouble(row.getDouble("ZAVAILABLEUNITS_")) * 100.0));
      }

      Integer calendarID = row.getInteger("ZRESOURCECALENDAR");
      if (calendarID != null)
      {
         ProjectCalendar calendar = m_project.getCalendarByUniqueID(calendarID);
         if (calendar != null)
         {
            calendar.setName(resource.getName());
            resource.setResourceCalendar(calendar);
         }
      }

      m_eventManager.fireResourceReadEvent(resource);
   }
}
 

@Override public void process(Context context)
{
   ProjectCalendar calendar = context.addCalendar(getString(0));
   calendar.setName(getString(2));

   String flags = getString(1);
   for (Day day : Day.values())
   {
      calendar.setWorkingDay(day, flags.charAt(day.getValue() - 1) == 'Y');
   }
   context.getEventManager().fireCalendarReadEvent(calendar);
}
 

/**
 * Read the calendar data from a Gantt Designer file.
 *
 * @param gantt Gantt Designer file.
 */
private void readCalendar(Gantt gantt)
{
   Gantt.Calendar ganttCalendar = gantt.getCalendar();
   m_projectFile.getProjectProperties().setWeekStartDay(ganttCalendar.getWeekStart());

   ProjectCalendar calendar = m_projectFile.addCalendar();
   calendar.setName("Standard");
   m_projectFile.setDefaultCalendar(calendar);

   String workingDays = ganttCalendar.getWorkDays();
   calendar.setWorkingDay(Day.SUNDAY, workingDays.charAt(0) == '1');
   calendar.setWorkingDay(Day.MONDAY, workingDays.charAt(1) == '1');
   calendar.setWorkingDay(Day.TUESDAY, workingDays.charAt(2) == '1');
   calendar.setWorkingDay(Day.WEDNESDAY, workingDays.charAt(3) == '1');
   calendar.setWorkingDay(Day.THURSDAY, workingDays.charAt(4) == '1');
   calendar.setWorkingDay(Day.FRIDAY, workingDays.charAt(5) == '1');
   calendar.setWorkingDay(Day.SATURDAY, workingDays.charAt(6) == '1');

   for (int i = 1; i <= 7; i++)
   {
      Day day = Day.getInstance(i);
      ProjectCalendarHours hours = calendar.addCalendarHours(day);
      if (calendar.isWorkingDay(day))
      {
         hours.addRange(ProjectCalendarWeek.DEFAULT_WORKING_MORNING);
         hours.addRange(ProjectCalendarWeek.DEFAULT_WORKING_AFTERNOON);
      }
   }

   for (Gantt.Holidays.Holiday holiday : gantt.getHolidays().getHoliday())
   {
      ProjectCalendarException exception = calendar.addCalendarException(holiday.getDate(), holiday.getDate());
      exception.setName(holiday.getContent());
   }
}
 

/**
 * This method extracts data for a single calendar from a Planner file.
 *
 * @param plannerCalendar Calendar data
 * @param parentMpxjCalendar parent of derived calendar
 */
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);
   }
}
 

/**
 * Process data for an individual calendar.
 *
 * @param row calendar data
 * @return ProjectCalendar instance
 */
public ProjectCalendar processCalendar(Row row)
{
   ProjectCalendar calendar = m_project.addCalendar();

   Integer id = row.getInteger("clndr_id");
   calendar.setUniqueID(id);
   calendar.setName(row.getString("clndr_name"));

   try
   {
      calendar.setMinutesPerDay(Integer.valueOf((int) NumberHelper.getDouble(row.getDouble("day_hr_cnt")) * 60));
      calendar.setMinutesPerWeek(Integer.valueOf((int) (NumberHelper.getDouble(row.getDouble("week_hr_cnt")) * 60)));
      calendar.setMinutesPerMonth(Integer.valueOf((int) (NumberHelper.getDouble(row.getDouble("month_hr_cnt")) * 60)));
      calendar.setMinutesPerYear(Integer.valueOf((int) (NumberHelper.getDouble(row.getDouble("year_hr_cnt")) * 60)));
   }
   catch (ClassCastException ex)
   {
      // We have seen examples of malformed calendar data where fields have been missing
      // from the record. We'll typically get a class cast exception here as we're trying
      // to process something which isn't a double.
      // We'll just return at this point as it's not clear that we can salvage anything
      // sensible from this record.
      return calendar;
   }

   // Process data
   String calendarData = row.getString("clndr_data");
   if (calendarData != null && !calendarData.isEmpty())
   {
      Record root = Record.getRecord(calendarData);
      if (root != null)
      {
         processCalendarDays(calendar, root);
         processCalendarExceptions(calendar, root);
      }
   }
   else
   {
      // if there is not DaysOfWeek data, Primavera seems to default to Mon-Fri, 8:00-16:00
      DateRange defaultHourRange = new DateRange(DateHelper.getTime(8, 0), DateHelper.getTime(16, 0));
      for (Day day : Day.values())
      {
         if (day != Day.SATURDAY && day != Day.SUNDAY)
         {
            calendar.setWorkingDay(day, true);
            ProjectCalendarHours hours = calendar.addCalendarHours(day);
            hours.addRange(defaultHourRange);
         }
         else
         {
            calendar.setWorkingDay(day, false);
         }
      }
   }

   m_eventManager.fireCalendarReadEvent(calendar);

   return calendar;
}
 

/**
 * Read project calendars.
 */
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));
      }
   }
}
 

/**
 * Read an individual calendar from the file.
 *
 * @param block CCalendar block
 * @return ProjectCalendar instance
 */
private ProjectCalendar readCalendar(Block block)
{
   ProjectCalendar calendar;

   byte[] data = block.getData();
   String name = DatatypeConverter.getString(data, 0, null);

   if (name == null || name.trim().isEmpty())
   {
      calendar = null;
   }
   else
   {
      int offset = 1 + name.length();

      calendar = m_projectFile.addCalendar();
      calendar.setName(name);

      // This is guesswork - need some samples with more variation
      int workingDays = DatatypeConverter.getByte(data, offset);
      calendar.setWorkingDay(Day.SATURDAY, (workingDays & 0x40) != 0);
      calendar.setWorkingDay(Day.SUNDAY, (workingDays & 0x20) != 0);
      calendar.setWorkingDay(Day.MONDAY, (workingDays & 0x10) != 0);
      calendar.setWorkingDay(Day.TUESDAY, (workingDays & 0x08) != 0);
      calendar.setWorkingDay(Day.WEDNESDAY, (workingDays & 0x04) != 0);
      calendar.setWorkingDay(Day.THURSDAY, (workingDays & 0x02) != 0);
      calendar.setWorkingDay(Day.FRIDAY, (workingDays & 0x01) != 0);
      offset += 28;

      Map<Day, List<DateRange>> ranges = new HashMap<>();
      ranges.put(Day.SATURDAY, readCalendarHours(data, offset + 0));
      ranges.put(Day.SUNDAY, readCalendarHours(data, offset + 16));
      ranges.put(Day.MONDAY, readCalendarHours(data, offset + 32));
      ranges.put(Day.TUESDAY, readCalendarHours(data, offset + 48));
      ranges.put(Day.WEDNESDAY, readCalendarHours(data, offset + 64));
      ranges.put(Day.THURSDAY, readCalendarHours(data, offset + 80));
      ranges.put(Day.FRIDAY, readCalendarHours(data, offset + 96));

      for (Day day : DAYS)
      {
         if (calendar.isWorkingDay(day))
         {
            ProjectCalendarHours hours = calendar.addCalendarHours(day);
            ranges.get(day).stream().forEach(range -> hours.addRange(range));
         }
      }

      block.getChildBlocks().stream().filter(x -> "CDayFlag".equals(x.getName())).forEach(x -> readCalendarException(calendar, ranges, x.getData()));

      m_eventManager.fireCalendarReadEvent(calendar);
   }

   return calendar;
}