/*
    * To change this template, choose Tools | Templates
    * and open the template in the editor.
    */
   package org.kuali.student.enrollment.class2.courseoffering.service.impl;
   
   import org.kuali.rice.core.api.criteria.EqualPredicate;
   import org.kuali.rice.core.api.criteria.QueryByCriteria;
   import org.kuali.student.common.mock.MockService;
  import org.kuali.student.common.util.UUIDHelper;
  import org.kuali.student.r2.common.dto.ContextInfo;
  import org.kuali.student.r2.common.dto.MetaInfo;
  import org.kuali.student.r2.common.dto.StatusInfo;
  import org.kuali.student.r2.common.dto.ValidationResultInfo;
  import org.kuali.student.r2.common.exceptions.AlreadyExistsException;
  import org.kuali.student.r2.common.exceptions.DataValidationErrorException;
  import org.kuali.student.r2.common.exceptions.DoesNotExistException;
  import org.kuali.student.r2.common.exceptions.InvalidParameterException;
  import org.kuali.student.r2.common.exceptions.MissingParameterException;
  import org.kuali.student.r2.common.exceptions.OperationFailedException;
  import org.kuali.student.r2.common.exceptions.PermissionDeniedException;
  import org.kuali.student.r2.common.exceptions.ReadOnlyException;
  import org.kuali.student.r2.common.exceptions.VersionMismatchException;
  import org.kuali.student.r2.core.acal.dto.AcademicCalendarInfo;
  import org.kuali.student.r2.core.acal.dto.AcalEventInfo;
  import org.kuali.student.r2.core.acal.dto.ExamPeriodInfo;
  import org.kuali.student.r2.core.acal.dto.HolidayCalendarInfo;
  import org.kuali.student.r2.core.acal.dto.HolidayInfo;
  import org.kuali.student.r2.core.acal.dto.KeyDateInfo;
  import org.kuali.student.r2.core.acal.dto.TermInfo;
  import org.kuali.student.r2.core.acal.service.AcademicCalendarService;
  import org.kuali.student.r2.core.class1.state.dto.StateInfo;
  import org.kuali.student.r2.core.class1.type.dto.TypeInfo;
  import org.kuali.student.r2.core.constants.AtpServiceConstants;
  
  import javax.jws.WebParam;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.HashSet;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  /**
   *
   * @author nwright
   */
  public class AcademicCalendarServiceMockImpl implements AcademicCalendarService, MockService {
  
      // Map of IDs to AcalInfos
      private Map<String, AcademicCalendarInfo> acals = new LinkedHashMap<String, AcademicCalendarInfo>();
      // Maps of IDs to TermInfos
      private Map<String, TermInfo> terms = new LinkedHashMap<String, TermInfo>();
      // Map of term ID to a set of Acal Ids (KSENROLL-7444)
      private Map<String, Set<String>> term2calSet = new LinkedHashMap<String, Set<String>>();
      // Map of term ID to a set of term Ids representing the "parents".  A child, in theory, can
      // have multiple parent terms. (KSENROLL-7444)
      private Map<String, Set<String>> subterm2termSet = new LinkedHashMap<String, Set<String>>();
      // Keydates
      private Map<String, KeyDateInfo> keydates = new LinkedHashMap<String, KeyDateInfo>();
      // Term to keydate set
      private Map<String, Set<String>> term2KeydateSet = new LinkedHashMap<String, Set<String>>();
      // ExamPeriod
      private Map<String, ExamPeriodInfo> examPeriodMap = new LinkedHashMap<String, ExamPeriodInfo>();
      // Term to exam period set
      private Map<String, Set<String>> term2examPeriodSet = new LinkedHashMap<String, Set<String>>();
  
      @Override
  	public void clear() {
      	this.acals.clear();
      	this.terms.clear();
      	this.term2calSet.clear();
      	this.subterm2termSet.clear();
          this.keydates.clear();
          this.term2KeydateSet.clear();
          this.examPeriodMap.clear();
          this.term2examPeriodSet.clear();
  	}
  
      @Override
      public List<String> getKeyDateIdsForTerm(@WebParam(name = "termId") String termId, @WebParam(name = "contextInfo") ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
          List<KeyDateInfo> keyDates = getKeyDatesForTerm(termId, contextInfo);
          List<String> keyDateIds = new ArrayList<String>();
          for (KeyDateInfo keyDate: keyDates) {
              keyDateIds.add(keyDate.getId());
          }
          return keyDateIds;
      }
  
  	@Override
      public StatusInfo addTermToAcademicCalendar(String academicCalendarId, String termId, ContextInfo contextInfo) throws AlreadyExistsException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
          // KSENROLL-7444
          if (!terms.containsKey(termId)) {
              throw new DoesNotExistException("termId=" + termId + " does not exist");
          }
          if (!acals.containsKey(academicCalendarId)) {
              throw new DoesNotExistException("academicCalendarId=" + academicCalendarId + " does not exist");
          }
         if (!term2calSet.containsKey(termId)) {
             term2calSet.put(termId, new HashSet<String>());
         }
         this.term2calSet.get(termId).add(academicCalendarId);
         return _successStatus();
     }
 
     @Override
     public StatusInfo addTermToTerm(String parentTermId, String childTermId, ContextInfo contextInfo) throws AlreadyExistsException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         // KSENROLL-7444
         if (!terms.containsKey(childTermId)) {
             throw new DoesNotExistException("childTermId=" + childTermId + " does not exist");
         }
         if (!terms.containsKey(parentTermId)) {
             throw new DoesNotExistException("parentTermId=" + childTermId + " does not exist");
         }
         if (!this.subterm2termSet.containsKey(childTermId)) {
             this.subterm2termSet.put(childTermId, new HashSet<String>());
         }
         Set<String> parentTermIds = this.subterm2termSet.get(childTermId);
         if (parentTermIds.contains(parentTermId)) {
             throw new AlreadyExistsException("parentTermId=" + parentTermId + " already exists");
         }
         parentTermIds.add(parentTermId);
         return _successStatus();
     }
 
     @Override
     public AcalEventInfo calculateAcalEvent(String acalEventId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public HolidayInfo calculateHoliday(String holidayId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public KeyDateInfo calculateKeyDate(String keyDateId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public AcademicCalendarInfo copyAcademicCalendar(String academicCalendarId, Date startDate, Date endDate, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public HolidayCalendarInfo copyHolidayCalendar(String holidayCalendarId, Date startDate, Date endDate, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public AcademicCalendarInfo createAcademicCalendar(String academicCalendarTypeKey, AcademicCalendarInfo academicCalendarInfo, ContextInfo contextInfo) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, ReadOnlyException {
         AcademicCalendarInfo copy = new AcademicCalendarInfo(academicCalendarInfo);
         if (copy.getId() == null) {
             copy.setId(UUIDHelper.genStringUUID());
         }
         this.acals.put(copy.getId(), copy);
         return new AcademicCalendarInfo(copy);
     }
 
     @Override
     public AcalEventInfo createAcalEvent(String academicCalendarId, String acalEventTypeKey, AcalEventInfo acalEventInfo, ContextInfo contextInfo) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, ReadOnlyException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public HolidayInfo createHoliday(String holidayCalendarId, String holidayTypeKey, HolidayInfo holidayInfo, ContextInfo contextInfo) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, ReadOnlyException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public HolidayCalendarInfo createHolidayCalendar(String holidayCalendarTypeKey, HolidayCalendarInfo holidayCalendarInfo, ContextInfo contextInfo) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, ReadOnlyException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public KeyDateInfo createKeyDate(String termId, String keyDateTypeKey, KeyDateInfo keyDateInfo, ContextInfo contextInfo) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, ReadOnlyException {
         if (!terms.containsKey(termId)) {
             throw new DoesNotExistException("termId=" + termId + "does not exist");
         }
         KeyDateInfo copy = new KeyDateInfo(keyDateInfo);
         if (copy.getId() == null) {
             copy.setId(UUIDHelper.genStringUUID());
         }
         keydates.put(copy.getId(), copy);
         if (!term2KeydateSet.containsKey(termId)) {
             term2KeydateSet.put(termId, new HashSet<String>());
         }
         // Note: this doens't check if the keydate already exists for this term
         term2KeydateSet.get(termId).add(copy.getId());
         return new KeyDateInfo(copy);
     }
 
     @Override
     public TermInfo createTerm(String termTypeKey, TermInfo termInfo, ContextInfo contextInfo) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, ReadOnlyException {
         TermInfo copy = new TermInfo(termInfo);
         if (copy.getId() == null) {
             copy.setId(UUIDHelper.genStringUUID());
         }
         terms.put(copy.getId(), copy);
         return new TermInfo(copy);
     }
 
     @Override
     public StatusInfo deleteAcademicCalendar(String academicCalendarId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         this.getAcademicCalendar(academicCalendarId, contextInfo);
         acals.remove(academicCalendarId);
         StatusInfo status = new StatusInfo();
         status.setSuccess(Boolean.TRUE);
         return status;
     }
 
     @Override
     public StatusInfo deleteAcalEvent(String acalEventId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StatusInfo deleteHoliday(String holidayId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StatusInfo deleteHolidayCalendar(String holidayCalendarId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StatusInfo deleteKeyDate(String keyDateId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StatusInfo deleteTerm(String termId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException,
             MissingParameterException, OperationFailedException, PermissionDeniedException {
         // Note: milestones not yet handled
         // Will only permit a delete if the term has no subterms.  Will also remove from calendar if there are any calendars
         // associated with it
         if (!terms.containsKey(termId)) {
             throw new DoesNotExistException("termId=" + termId + " does not exist");
         }
         TermInfo term = getTerm(termId, contextInfo);
         if (term.getStateKey().equals(AtpServiceConstants.ATP_OFFICIAL_STATE_KEY)) {
             throw new OperationFailedException("Can't delete term that is official");
         }
         List<TermInfo> childTerms = getIncludedTermsInTerm(termId, contextInfo);
         // For each of the child terms, remove its link to termId (which may make it "stranded")
         for (TermInfo child: childTerms) {
             subterm2termSet.get(child.getId()).remove(termId);
         }
         // Remove term from any parent terms
         if (subterm2termSet.containsKey(termId)) {
             subterm2termSet.remove(termId);
         }
         // Check if it's attached to a calendar, and remove if so.
         if (term2calSet.containsKey(termId)) {
             term2calSet.remove(termId);
         }
         // Finally, remove the term itself
         this.getTerm(termId, contextInfo);
         terms.remove(termId);
         StatusInfo status = new StatusInfo();
         status.setSuccess(Boolean.TRUE);
         return status;
     }
 
     @Override
     public AcademicCalendarInfo getAcademicCalendar(String academicCalendarId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         if (!acals.containsKey(academicCalendarId)) {
             throw new DoesNotExistException(academicCalendarId);
         }
         return acals.get(academicCalendarId);
     }
 
     @Override
     public String getAcademicCalendarData(String academicCalendarId, String calendarDataFormatTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<String> getAcademicCalendarIdsByType(String academicCalendarTypeKey, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StateInfo getAcademicCalendarState(String academicCalendarStateKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<StateInfo> getAcademicCalendarStates(ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public TypeInfo getAcademicCalendarType(String academicCalendarTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TypeInfo> getAcademicCalendarTypes(ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<AcademicCalendarInfo> getAcademicCalendarsByIds(List<String> academicCalendarIds, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<AcademicCalendarInfo> getAcademicCalendarsByStartYear(Integer year, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<AcademicCalendarInfo> getAcademicCalendarsForTerm(String termId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         // KSENROLL-7444
         if (!terms.containsKey(termId)) {
             throw new DoesNotExistException("termId=" + termId + " does not exist");
         }
         if (!term2calSet.containsKey(termId)) {
             // Term exists, but it's not mapped to any academic calendars.
             return new ArrayList<AcademicCalendarInfo>();
         }
         TermInfo termInfo = terms.get(termId);
         Set<String> acalIds = term2calSet.get(termId);
         List<AcademicCalendarInfo> acalInfos = new ArrayList<AcademicCalendarInfo>();
         for (String id: acalIds) {
             if (!acals.containsKey(id)) {
                 throw new DoesNotExistException("acalId=" + id + " does not exist");
             }
             AcademicCalendarInfo acalInfo = getAcademicCalendar(id, contextInfo);
             acalInfos.add(acalInfo);
         }
         return acalInfos;
     }
 
     @Override
     public AcalEventInfo getAcalEvent(String acalEventId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<String> getAcalEventIdsByType(String acalEventTypeKey, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StateInfo getAcalEventState(String acalEventStateKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<StateInfo> getAcalEventStates(ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public TypeInfo getAcalEventType(String acalEventTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TypeInfo> getAcalEventTypes(ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TypeInfo> getAcalEventTypesForAcademicCalendarType(String academicCalendarTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<AcalEventInfo> getAcalEventsByIds(List<String> acalEventIds, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<AcalEventInfo> getAcalEventsForAcademicCalendar(String academicCalendarId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<AcalEventInfo> getAcalEventsForAcademicCalendarByDate(String academicCalendarId, Date startDate, Date endDate, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TermInfo> getContainingTerms(String childTermId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         // KSENROLL-7444
         if (!this.terms.containsKey(childTermId)) {
             throw new DoesNotExistException("childTermId=" + childTermId + " does not exists");
         }
         if (!this.subterm2termSet.containsKey(childTermId)) {
             return new ArrayList<TermInfo>(); // subterm exists, but no linkage yet
         }
         Set<String> parentTermIds = this.subterm2termSet.get(childTermId);
         List<TermInfo> parentTermInfos = new ArrayList<TermInfo>();
         for (String termId: parentTermIds) {
             if (!this.terms.containsKey(termId)) {
                 throw new DoesNotExistException("parentTermId=" + termId + " does not exist");
             }
             parentTermInfos.add(this.terms.get(termId));
         }
         return parentTermInfos;
     }
 
     @Override
     public List<TermInfo> getCurrentTerms(String usageKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public HolidayInfo getHoliday(String holidayId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public HolidayCalendarInfo getHolidayCalendar(String holidayCalendarId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<String> getHolidayCalendarIdsByType(String holidayCalendarTypeKey, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StateInfo getHolidayCalendarState(String holidayCalendarStateKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<StateInfo> getHolidayCalendarStates(ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public TypeInfo getHolidayCalendarType(String holidayCalendarTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TypeInfo> getHolidayCalendarTypes(ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<HolidayCalendarInfo> getHolidayCalendarsByIds(List<String> holidayCalendarIds, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<HolidayCalendarInfo> getHolidayCalendarsByStartYear(Integer year, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<String> getHolidayIdsByType(String holidayTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StateInfo getHolidayState(String holidayStateKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<StateInfo> getHolidayStates(ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public TypeInfo getHolidayType(String holidayTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TypeInfo> getHolidayTypes(ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TypeInfo> getHolidayTypesForHolidayCalendarType(String holidayCalendarTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<HolidayInfo> getHolidaysByDateForAcademicCalendar(String academicCalendarId, Date startDate, Date endDate, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<HolidayInfo> getHolidaysByIds(List<String> holidayIds, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<HolidayInfo> getHolidaysForHolidayCalendar(String holidayCalendarId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<HolidayInfo> getHolidaysForHolidayCalendarByDate(String holidayCalendarId, Date startDate, Date endDate, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<AcalEventInfo> getImpactedAcalEvents(String acalEventId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<HolidayInfo> getImpactedHolidays(String holidayId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<KeyDateInfo> getImpactedKeyDates(String keyDateId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TermInfo> getIncludedTermsInTerm(String parentTermId, ContextInfo contextInfo)
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
                    OperationFailedException, PermissionDeniedException {
         Set<String> childIds = new HashSet<String>();
         for (Map.Entry<String, Set<String>> entry: subterm2termSet.entrySet()) {
             Set<String> parentTerms = entry.getValue();
             String childId = entry.getKey();
             if (parentTerms.contains(parentTermId)) {
                 childIds.add(childId);
             }
         }
         List<TermInfo> result = new ArrayList<TermInfo>();
         for (String childId: childIds) {
             if (!terms.containsKey(childId)) {
                 throw new DoesNotExistException("termId=" + childId + "does not exist");
             }
             result.add(terms.get(childId));
         }
         return result;
     }
 
     @Override
     public Integer getInstructionalDaysForTerm(String termId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public KeyDateInfo getKeyDate(String keyDateId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<String> getKeyDateIdsByType(String keyDateTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<String> getKeyDateIdsByTypeForTerm(String keyDateTypeKey, String termId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StateInfo getKeyDateState(String keyDateStateKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<StateInfo> getKeyDateStates(ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public TypeInfo getKeyDateType(String keyDateTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TypeInfo> getKeyDateTypes(ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TypeInfo> getKeyDateTypesForTermType(String termTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<KeyDateInfo> getKeyDatesByIds(List<String> keyDateIds, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<KeyDateInfo> getKeyDatesForTerm(String termId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         Set<String> keydateSet = term2KeydateSet.get(termId);
         if (keydateSet == null) {
             return new ArrayList<KeyDateInfo>();
         }
         List<KeyDateInfo> keyDateInfos = new ArrayList<KeyDateInfo>();
         for (String keydateId: keydateSet) {
             if (!keydates.containsKey(keydateId)) {
                 throw new DoesNotExistException("keydate=" + keydateId + "does not exist");
             }
             keyDateInfos.add(keydates.get(keydateId));
         }
         return keyDateInfos;
     }
 
     @Override
     public List<KeyDateInfo> getKeyDatesForTermByDate(String termId, Date startDate, Date endDate, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public TermInfo getTerm(String termId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         if (!terms.containsKey(termId)) {
             throw new DoesNotExistException(termId);
         }
         return new TermInfo(terms.get(termId));
     }
 
     @Override
     public List<String> getTermIdsByType(String termTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StateInfo getTermState(String termStateKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<StateInfo> getTermStates(ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public TypeInfo getTermType(String termTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TypeInfo> getTermTypes(ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TypeInfo> getTermTypesForAcademicCalendarType(String academicCalendarTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TypeInfo> getTermTypesForTermType(String termTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TermInfo> getTermsByCode(String code, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TermInfo> getTermsByIds(List<String> termIds, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TermInfo> getTermsForAcademicCalendar(String academicCalendarId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         if (!acals.containsKey(academicCalendarId)) {
             throw new OperationFailedException("acalId=" + academicCalendarId + " does not exist");
         }
         Set<String> resultSet = new HashSet<String>();
         for (String termId: term2calSet.keySet()) {
             if (term2calSet.get(termId).contains(academicCalendarId)) {
                 resultSet.add(termId);
             }
         }
         List<TermInfo> termInfos = new ArrayList<TermInfo>();
         for (String termId: resultSet) {
             termInfos.add(terms.get(termId));
         }
         return termInfos;
     }
 
     @Override
     public StatusInfo removeTermFromAcademicCalendar(String academicCalendarId, String termId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StatusInfo removeTermFromTerm(String termId, String includedTermId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<String> searchForAcademicCalendarIds(QueryByCriteria criteria, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<AcademicCalendarInfo> searchForAcademicCalendars(QueryByCriteria criteria, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<String> searchForAcalEventIds(QueryByCriteria criteria, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<AcalEventInfo> searchForAcalEvents(QueryByCriteria criteria, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<String> searchForHolidayCalendarIds(QueryByCriteria criteria, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<HolidayCalendarInfo> searchForHolidayCalendars(QueryByCriteria criteria, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<String> searchForHolidayIds(QueryByCriteria criteria, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<HolidayInfo> searchForHolidays(QueryByCriteria criteria, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<String> searchForKeyDateIds(QueryByCriteria criteria, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<KeyDateInfo> searchForKeyDates(QueryByCriteria criteria, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<String> searchForTermIds(QueryByCriteria criteria, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<TermInfo> searchForTerms(QueryByCriteria criteria, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         List<TermInfo> list = new ArrayList<TermInfo>();
         if(criteria.getPredicate() instanceof EqualPredicate){
             EqualPredicate p = (EqualPredicate) criteria.getPredicate();
             if("atpCode".equals(p.getPropertyPath())){
                 list.add(this.terms.get(p.getValue().getValue()));
             }
         }
         return list;
     }
 
     @Override
     public AcademicCalendarInfo updateAcademicCalendar(String academicCalendarId, AcademicCalendarInfo academicCalendarInfo, ContextInfo contextInfo) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, ReadOnlyException, VersionMismatchException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StatusInfo changeAcademicCalendarState(String academicCalendarId, @WebParam(name = "nextStateKey") String nextStateKey, @WebParam(name = "contextInfo") ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         // Does not do state propagation
         try {
             AcademicCalendarInfo acal = this.acals.get(academicCalendarId);
             if (acal == null) {
                 throw new DoesNotExistException("No academic calendar for id = " + academicCalendarId);
             }
             acal.setStateKey(nextStateKey);
             return _successStatus();
 
         } catch (Exception e) {
             throw new OperationFailedException("changeAcademicCalendarState (id=" + academicCalendarId + ", nextStateKey=" + nextStateKey, e);
         }
     }
 
     private StatusInfo _successStatus() {
         StatusInfo status = new StatusInfo();
         status.setSuccess(Boolean.TRUE);
         return status;
     }
 
     @Override
     public AcalEventInfo updateAcalEvent(String acalEventId, AcalEventInfo acalEventInfo, ContextInfo contextInfo) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, ReadOnlyException, VersionMismatchException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StatusInfo changeAcalEventState(@WebParam(name = "acalEventId") String acalEventId, @WebParam(name = "nextStateKey") String nextStateKey, @WebParam(name = "contextInfo") ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("changeAcalEventState");
     }
 
     @Override
     public HolidayInfo updateHoliday(String holidayId, HolidayInfo holidayInfo, ContextInfo contextInfo) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, ReadOnlyException, VersionMismatchException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StatusInfo changeHolidayState(@WebParam(name = "holidayId") String holidayId, @WebParam(name = "nextStateKey") String nextStateKey, @WebParam(name = "contextInfo") ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("changeHolidayState");
     }
 
     @Override
     public HolidayCalendarInfo updateHolidayCalendar(String holidayCalendarId, HolidayCalendarInfo holidayCalendarInfo, ContextInfo contextInfo) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, ReadOnlyException, VersionMismatchException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StatusInfo changeHolidayCalendarState(@WebParam(name = "holidayCalendarId") String holidayCalendarId, @WebParam(name = "nextStateKey") String nextStateKey, @WebParam(name = "contextInfo") ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("changeHolidayCalendarState");
     }
 
     @Override
     public KeyDateInfo updateKeyDate(String keyDateId, KeyDateInfo keyDateInfo, ContextInfo contextInfo) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, ReadOnlyException, VersionMismatchException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StatusInfo changeKeyDateState(@WebParam(name = "keyDateId") String keyDateId, @WebParam(name = "nextStateKey") String nextStateKey, @WebParam(name = "contextInfo") ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("changeKeyDateState");
     }
 
     @Override
     public TermInfo updateTerm(String termId, TermInfo termInfo, ContextInfo contextInfo) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, ReadOnlyException, VersionMismatchException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public StatusInfo changeTermState(String termId, String nextStateKey, ContextInfo contextInfo)
             throws DoesNotExistException, InvalidParameterException, MissingParameterException,
                    OperationFailedException, PermissionDeniedException {
         // Does not do state propagation
         try {
             TermInfo termInfo = this.terms.get(termId);
             if (termInfo == null) {
                 throw new DoesNotExistException("No term for id = " + termId);
             }
             termInfo.setStateKey(nextStateKey);
             return _successStatus();
 
         } catch (Exception e) {
             throw new OperationFailedException("changeTermState (id=" + termId + ", nextStateKey=" + nextStateKey, e);
         }
     }
 
     @Override
     public List<ValidationResultInfo> validateAcademicCalendar(String validationTypeKey, String academicCalendarTypeKey, AcademicCalendarInfo academicCalendarInfo, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<ValidationResultInfo> validateAcalEvent(String validationTypeKey, String termId, String acalEventTypeKey, AcalEventInfo acalEventInfo, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<ValidationResultInfo> validateHoliday(String validationTypeKey, String holidayCalendarId, String holidayTypeKey, HolidayInfo holidayInfo, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<ValidationResultInfo> validateHolidayCalendar(String validationTypeKey, String holidayCalendarTypeKey, HolidayCalendarInfo holidayCalendarInfo, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<ValidationResultInfo> validateKeyDate(String validationTypeKey, String termId, String keyDateTypeKey, KeyDateInfo keyDateInfo, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public List<ValidationResultInfo> validateTerm(String validationTypeKey, String termTypeKey, TermInfo termInfo, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public TypeInfo getExamPeriodType(String examPeriodTypeKey, ContextInfo contextInfo)
             throws DoesNotExistException
             ,InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         throw new UnsupportedOperationException("getExamPeriodType not implemented yet.");
     }
 
     @Override
     public List<TypeInfo> getExamPeriodTypes(ContextInfo contextInfo)
             throws InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         throw new UnsupportedOperationException("getExamPeriodTypes not implemented yet.");
     }
 
     @Override
     public List<TypeInfo> getExamPeriodTypesForTermType(String termTypeKey, ContextInfo contextInfo)
             throws DoesNotExistException
             ,InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         throw new UnsupportedOperationException("getExamPeriodTypesForTermType not implemented yet.");
     }
 
     @Override
     public StateInfo getExamPeriodState(String examPeriodStateKey, ContextInfo contextInfo)
             throws DoesNotExistException
             ,InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         throw new OperationFailedException ("getExamPeriodState has not been implemented");
     }
 
     @Override
     public List<StateInfo> getExamPeriodStates(ContextInfo contextInfo)
             throws InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         throw new OperationFailedException ("getExamPeriodStates has not been implemented");
     }
 
     @Override
     public ExamPeriodInfo getExamPeriod(String examPeriodId, ContextInfo contextInfo)
             throws DoesNotExistException
             ,InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         if (!this.examPeriodMap.containsKey(examPeriodId)) {
             throw new DoesNotExistException(examPeriodId);
         }
         return new ExamPeriodInfo(this.examPeriodMap.get (examPeriodId));
     }
 
     @Override
     public List<ExamPeriodInfo> getExamPeriodsByIds(List<String> examPeriodIds, ContextInfo contextInfo)
             throws DoesNotExistException
             ,InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         List<ExamPeriodInfo> list = new ArrayList<ExamPeriodInfo> ();
         for (String id: examPeriodIds) {
             list.add (this.getExamPeriod(id, contextInfo));
         }
         return list;
     }
 
     @Override
     public List<String> getExamPeriodIdsByType(String examPeriodTypeKey, ContextInfo contextInfo)
             throws DoesNotExistException
             ,InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         List<String> list = new ArrayList<String> ();
         for (ExamPeriodInfo info: examPeriodMap.values ()) {
             if (examPeriodTypeKey.equals(info.getTypeKey())) {
                 list.add (info.getId ());
             }
         }
         return list;
     }
 
     @Override
     public List<ExamPeriodInfo> getExamPeriodsByCode(String code, ContextInfo contextInfo)
             throws InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         List<ExamPeriodInfo> list = new ArrayList<ExamPeriodInfo> ();
         for (ExamPeriodInfo info: examPeriodMap.values ()) {
             if (code.equals(info.getCode())) {
                 list.add (info);
             }
         }
         return list;
     }
 
     @Override
     public List<String> searchForExamPeriodIds(QueryByCriteria criteria, ContextInfo contextInfo)
             throws InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         throw new OperationFailedException ("searchForExamPeriodIds has not been implemented");
     }
 
     @Override
     public List<ExamPeriodInfo> searchForExamPeriods(QueryByCriteria criteria, ContextInfo contextInfo)
             throws InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         throw new OperationFailedException ("searchForExamPeriods has not been implemented");
     }
 
     @Override
     public List<ValidationResultInfo> validateExamPeriod(String validationTypeKey, String examPeriodTypeKey, ExamPeriodInfo examPeriodInfo, ContextInfo contextInfo)
             throws DoesNotExistException
             ,InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         // validate
         return new ArrayList<ValidationResultInfo> ();
     }
 
     @Override
     public ExamPeriodInfo createExamPeriod(String examPeriodTypeKey, ExamPeriodInfo examPeriodInfo, ContextInfo contextInfo)
             throws DataValidationErrorException
             ,DoesNotExistException
             ,InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
             ,ReadOnlyException
     {
         // create
         if (!examPeriodTypeKey.equals (examPeriodInfo.getTypeKey())) {
             throw new InvalidParameterException ("The type parameter does not match the type on the info object");
         }
         ExamPeriodInfo copy = new ExamPeriodInfo(examPeriodInfo);
         if (copy.getId() == null) {
             copy.setId(UUIDHelper.genStringUUID());
         }
         copy.setMeta(newMeta(contextInfo));
         examPeriodMap.put(copy.getId(), copy);
         return new ExamPeriodInfo(copy);
     }
 
     @Override
     public ExamPeriodInfo updateExamPeriod(String examPeriodId, ExamPeriodInfo examPeriodInfo, ContextInfo contextInfo)
             throws DataValidationErrorException
             ,DoesNotExistException
             ,InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
             ,ReadOnlyException
             ,VersionMismatchException
     {
         // update
         if (!examPeriodId.equals (examPeriodInfo.getId())) {
             throw new InvalidParameterException ("The id parameter does not match the id on the info object");
         }
         ExamPeriodInfo copy = new ExamPeriodInfo(examPeriodInfo);
         ExamPeriodInfo old = this.getExamPeriod(examPeriodInfo.getId(), contextInfo);
         if (!old.getMeta().getVersionInd().equals(copy.getMeta().getVersionInd())) {
             throw new VersionMismatchException(old.getMeta().getVersionInd());
         }
         copy.setMeta(updateMeta(copy.getMeta(), contextInfo));
         this.examPeriodMap .put(examPeriodInfo.getId(), copy);
         return new ExamPeriodInfo(copy);
     }
 
     @Override
     public StatusInfo changeExamPeriodState(String examPeriodId, String nextStateKey, ContextInfo contextInfo)
             throws DoesNotExistException
             ,InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         try {
             ExamPeriodInfo examPeriodInfo = this.examPeriodMap.get(examPeriodId);
             if (examPeriodInfo == null) {
                 throw new DoesNotExistException("No examperiod for id = " + examPeriodId);
             }
             examPeriodInfo.setStateKey(nextStateKey);
             return _successStatus();
 
         } catch (Exception e) {
             throw new OperationFailedException("changeExamPeriodState (id=" + examPeriodId + ", nextStateKey=" + nextStateKey, e);
         }
     }
 
     @Override
     public StatusInfo deleteExamPeriod(String examPeriodId, ContextInfo contextInfo)
             throws DoesNotExistException
             ,InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         if (this.examPeriodMap.remove(examPeriodId) == null) {
             throw new DoesNotExistException(examPeriodId);
         }
         return newStatus();
     }
 
     @Override
     public StatusInfo addExamPeriodToTerm(String termId, String examPeriodId, ContextInfo contextInfo)
             throws AlreadyExistsException
             ,DoesNotExistException
             ,InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         if (!term2examPeriodSet.containsKey(termId)) {
             term2examPeriodSet.put(termId, new HashSet<String>());
     }
         // Note: this doens't check if the examPeriodId already exists for this term
         term2examPeriodSet.get(termId).add(examPeriodId);
         return newStatus();
     }
 
     @Override
     public StatusInfo removeExamPeriodFromTerm(String termId, String examPeriodId, ContextInfo contextInfo)
             throws DoesNotExistException
             ,InvalidParameterException
             ,MissingParameterException
             ,OperationFailedException
             ,PermissionDeniedException
     {
         throw new OperationFailedException ("removeExamPeriodFromTerm has not been implemented");
     }
 
     @Override
     public List<ExamPeriodInfo> getExamPeriodsForTerm(String termId, ContextInfo contextInfo)
             throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
             PermissionDeniedException {
 
         List<ExamPeriodInfo> examPeriodInfos = new ArrayList<ExamPeriodInfo>();
 
         Set<String> examPeriodIds = term2examPeriodSet.get(termId);
         if(examPeriodIds==null){
             return examPeriodInfos;
     }
 
         for(String examPeriodId : examPeriodIds){
             examPeriodInfos.add(this.getExamPeriod(examPeriodId, contextInfo));
         }
         return examPeriodInfos;
     }
 
     @Override
     public List<TermInfo> getTermsForExamPeriod(String examPeriodId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
         throw new OperationFailedException ("getTermsForExamPeriod has not been implemented");
     }
 
     ////////////////////////////
     // Helper Methods
     ////////////////////////////
 
     private StatusInfo newStatus() {
         StatusInfo status = new StatusInfo();
         status.setSuccess(Boolean.TRUE);
         return status;
     }
 
     private MetaInfo newMeta(ContextInfo context) {
         MetaInfo meta = new MetaInfo();
         meta.setCreateId(context.getPrincipalId());
         meta.setCreateTime(new Date());
         meta.setUpdateId(context.getPrincipalId());
         meta.setUpdateTime(meta.getCreateTime());
         meta.setVersionInd("0");
         return meta;
     }
 
     private MetaInfo updateMeta(MetaInfo old, ContextInfo context) {
         MetaInfo meta = new MetaInfo(old);
         meta.setUpdateId(context.getPrincipalId());
         meta.setUpdateTime(new Date());
         meta.setVersionInd((Integer.parseInt(meta.getVersionInd()) + 1) + "");
         return meta;
     }
 
 }