package org.kuali.student.enrollment.class2.acal.service.impl;

 import org.apache.commons.lang.StringUtils;

 import org.joda.time.Days;

 import org.joda.time.Period;

 import org.joda.time.Weeks;

 import org.kuali.rice.core.api.criteria.QueryByCriteria;

 import org.kuali.student.enrollment.acal.dto.*;

 import org.kuali.student.enrollment.acal.service.AcademicCalendarService;

 import org.kuali.student.enrollment.class2.acal.service.assembler.*;

 import org.kuali.student.r2.common.assembler.AssemblyException;

 import org.kuali.student.r2.common.datadictionary.service.DataDictionaryService;

 import org.kuali.student.r2.common.dto.ContextInfo;

 import org.kuali.student.r2.common.dto.DateRangeInfo;

 import org.kuali.student.r2.common.dto.StatusInfo;

 import org.kuali.student.r2.common.dto.ValidationResultInfo;

 import org.kuali.student.r2.common.exceptions.*;

 import org.kuali.student.r2.common.util.constants.AtpServiceConstants;

 import org.kuali.student.r2.common.util.constants.TypeServiceConstants;

 import org.kuali.student.r2.core.atp.dto.AtpAtpRelationInfo;

 import org.kuali.student.r2.core.atp.dto.AtpInfo;

 import org.kuali.student.r2.core.atp.dto.MilestoneInfo;

 import org.kuali.student.r2.core.atp.service.AtpService;

 import org.kuali.student.r2.core.state.dto.StateInfo;

 import org.kuali.student.r2.core.state.service.StateService;

 import org.kuali.student.r2.core.type.dto.TypeInfo;

 import org.kuali.student.r2.core.type.dto.TypeTypeRelationInfo;

 import org.kuali.student.r2.core.type.service.TypeService;

 import org.springframework.transaction.annotation.Transactional;

 import java.util.*;

 @Transactional(readOnly = true, noRollbackFor = {DoesNotExistException.class}, rollbackFor = {Throwable.class})

 public class AcademicCalendarServiceImpl implements AcademicCalendarService {

     private AtpService atpService;

     private StateService stateService;

     private TypeService typeService;

     private AcademicCalendarAssembler acalAssembler;

     private TermAssembler termAssembler;

     private DataDictionaryService dataDictionaryService;

     private HolidayCalendarAssembler holidayCalendarAssembler;

     private HolidayAssembler holidayAssembler;

     private KeyDateAssembler keyDateAssembler;

     private AcalEventAssembler acalEventAssembler;

     public AcalEventAssembler getAcalEventAssembler() {

         return acalEventAssembler;

     }

     public void setAcalEventAssembler(AcalEventAssembler acalEventAssembler) {

         this.acalEventAssembler = acalEventAssembler;

     }

     public KeyDateAssembler getKeyDateAssembler() {

         return keyDateAssembler;

     }

     public void setKeyDateAssembler(KeyDateAssembler keyDateAssembler) {

         this.keyDateAssembler = keyDateAssembler;

     }

     public HolidayAssembler getHolidayAssembler() {

         return holidayAssembler;

     }

     public void setHolidayAssembler(HolidayAssembler holidayAssembler) {

         this.holidayAssembler = holidayAssembler;

     }

     public HolidayCalendarAssembler getHolidayCalendarAssembler() {

         return holidayCalendarAssembler;

     }

     public void setHolidayCalendarAssembler(HolidayCalendarAssembler holidayCalendarAssembler) {

         this.holidayCalendarAssembler = holidayCalendarAssembler;

     }

     public DataDictionaryService getDataDictionaryService() {

         return dataDictionaryService;

     }

     public void setDataDictionaryService(DataDictionaryService dataDictionaryService) {

         this.dataDictionaryService = dataDictionaryService;

     }

     public TypeService getTypeService() {

         return typeService;

     }

     public void setTypeService(TypeService typeService) {

         this.typeService = typeService;

     }

     public StateService getStateService() {

         return stateService;

     }

     public void setStateService(StateService stateService) {

         this.stateService = stateService;

     }

     @Override

     public TypeInfo getAcademicCalendarType(String academicCalendarTypeKey, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException {

         // TODO Li Pan - THIS METHOD NEEDS JAVADOCS

         return null;

     }

     @Override

     public List<TypeInfo> getAcademicCalendarTypes(ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException {

         // TODO Li Pan - THIS METHOD NEEDS JAVADOCS

         return new ArrayList<TypeInfo>();

     }

     @Override

     public StateInfo getAcademicCalendarState(String academicCalendarStateKey, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException {

         // TODO Li Pan - THIS METHOD NEEDS JAVADOCS

         return null;

     }

     private List<StateInfo> getAtpStates(ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {

         List<StateInfo> results;

         try {

             results = stateService.getStatesByLifecycle(AtpServiceConstants.ATP_LIFECYCLE_KEY, context);

         } catch (DoesNotExistException ex) {

             throw new OperationFailedException(AtpServiceConstants.ATP_LIFECYCLE_KEY, ex);

         }

         return results;

     }

     @Override

     public List<StateInfo> getAcademicCalendarStates(ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {

         return getAtpStates(context);

     }

     @Override

     public AcademicCalendarInfo getAcademicCalendar(String academicCalendarKey, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException {

         AtpInfo atp = atpService.getAtp(academicCalendarKey, context);

         AcademicCalendarInfo acal;

         try {

             acal = acalAssembler.assemble(atp, context);

         } catch (AssemblyException e) {

             throw new OperationFailedException("AssemblyException : " + e.getMessage());

         }

         return acal;

     }

     @Override

     public List<AcademicCalendarInfo> getAcademicCalendarsByIds(List<String> academicCalendarKeyList, ContextInfo context) throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException, PermissionDeniedException {

         List<AcademicCalendarInfo> academicCalendars = new ArrayList<AcademicCalendarInfo>();

         List<AtpInfo> atps = atpService.getAtpsByIds(academicCalendarKeyList, context);

         for (AtpInfo atp : atps) {

             try {

                 academicCalendars.add(acalAssembler.assemble(atp, context));

             } catch (AssemblyException e) {

                 throw new OperationFailedException("AssemblyException : " + e.getMessage());

             }

         }

         return academicCalendars;

     }

     @Override

     public List<String> getAcademicCalendarIdsByType(String academicCalendarTypeKey, ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         // TODO Li Pan - THIS METHOD NEEDS JAVADOCS

         return new ArrayList<String>();

     }

     @Override

     public List<AcademicCalendarInfo> getAcademicCalendarsByStartYear(Integer year, ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         final Date yearBegin, yearEnd;

         Calendar cal = Calendar.getInstance();

         cal.clear();

         cal.set(year, 0, 1);

         yearBegin = cal.getTime(); // XXXX-01-01 00:00:00.000

         cal.add(Calendar.YEAR, 1);

         cal.add(Calendar.MILLISECOND, -1);

         yearEnd = cal.getTime(); // XXXX-12-31 23:59:59.999

         Set<AtpInfo> atpInfos = new TreeSet<AtpInfo>(new Comparator<AtpInfo>() {

             @Override

             public int compare(AtpInfo atpInfo1, AtpInfo atpInfo2) {

                 return atpInfo1.getId().compareTo(atpInfo2.getId());

             }

         });

         atpInfos.addAll(atpService.getAtpsByStartDateRangeAndType(yearBegin, yearEnd, AtpServiceConstants.ATP_ACADEMIC_CALENDAR_TYPE_KEY, context));

         List<AcademicCalendarInfo> acalInfos = new ArrayList<AcademicCalendarInfo>();

         for (AtpInfo atpInfo : atpInfos) {

             try {

                 acalInfos.add(acalAssembler.assemble(atpInfo, context));

             } catch (AssemblyException e) {

                 throw new OperationFailedException("AssemblyException : " + e.getMessage());

             }

         }

         return acalInfos;

     }

     @Override

     @Transactional(readOnly = false)

     public AcademicCalendarInfo createAcademicCalendar(String academicCalendarTypeKey, AcademicCalendarInfo academicCalendarInfo, ContextInfo context) throws DataValidationErrorException,

             InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {

         // TODO: move this to a validation layer

         try {

             AtpInfo toCreate = acalAssembler.disassemble(academicCalendarInfo, context);

             AtpInfo createdAtp = atpService.createAtp(toCreate.getTypeKey(), toCreate, context);

             try {

                 createDeleteAtpAtpRelations(createdAtp.getId(),

                         academicCalendarInfo.getHolidayCalendarIds(),

                         AtpServiceConstants.ATP_HOLIDAY_CALENDAR_TYPE_KEY,

                         context);

             } catch (VersionMismatchException e) {

                 throw new OperationFailedException();

             }

             return acalAssembler.assemble(createdAtp, context);

         } catch (AlreadyExistsException e) {

             throw new OperationFailedException("Unexpected", e);

         } catch (AssemblyException e) {

             throw new OperationFailedException("Unexpected", e);

         } catch (ReadOnlyException e) {

             throw new OperationFailedException("Unexpected", e);

         }

     }

     @Override

     @Transactional(readOnly = false)

     public AcademicCalendarInfo updateAcademicCalendar(String academicCalendarId, AcademicCalendarInfo academicCalendarInfo, ContextInfo context) throws DataValidationErrorException,

             DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, VersionMismatchException {

         try {

             AtpInfo toUpdate = acalAssembler.disassemble(academicCalendarInfo, context);

             AtpInfo updated = atpService.updateAtp(academicCalendarId, toUpdate, context);

             try {

                 createDeleteAtpAtpRelations(academicCalendarId,

                         academicCalendarInfo.getHolidayCalendarIds(),

                         AtpServiceConstants.ATP_HOLIDAY_CALENDAR_TYPE_KEY,

                         context);

             } catch (VersionMismatchException e) {

                 throw new OperationFailedException();

             }

             return acalAssembler.assemble(updated, context);

         } catch (Exception e) {

             throw new OperationFailedException("Unexpected", e);

         }

     }

     @Override

     @Transactional(readOnly = false)

     public StatusInfo deleteAcademicCalendar(String academicCalendarKey, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException {

         StatusInfo status = new StatusInfo();

         status.setSuccess(Boolean.TRUE);

         AtpInfo atp = atpService.getAtp(academicCalendarKey, context);

         if (atp != null) {

             // delete atp/acal

             atpService.deleteAtp(academicCalendarKey, context);

         }

         return status;

     }

     @Override

     public AcademicCalendarInfo copyAcademicCalendar(String academicCalendarId, Date startDate, Date endDate, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException, PermissionDeniedException {

         throw new OperationFailedException("Method implemented in calculation decorator.");

     }

     @Override

     @Transactional(readOnly = true)

     public HolidayCalendarInfo getHolidayCalendar(String holidayCalendarId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException {

         AtpInfo atp = atpService.getAtp(holidayCalendarId, contextInfo);

         HolidayCalendarInfo ccal;

         try {

             ccal = holidayCalendarAssembler.assemble(atp, contextInfo);

         } catch (AssemblyException e) {

             throw new OperationFailedException("AssemblyException : " + e.getMessage());

         }

         return ccal;

     }

     @Override

     public List<HolidayCalendarInfo> getHolidayCalendarsByIds(List<String> holidayCalendarIds, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException {

         List<AtpInfo> atps = atpService.getAtpsByIds(holidayCalendarIds, context);

         List<HolidayCalendarInfo> holidayCalendarInfos = new ArrayList<HolidayCalendarInfo>();

         for (AtpInfo atp : atps) {

             try {

                 holidayCalendarInfos.add(holidayCalendarAssembler.assemble(atp, context));

             } catch (AssemblyException e) {

                 throw new OperationFailedException("AssemblyException : " + e.getMessage());

             }

         }

         return holidayCalendarInfos;

     }

     @Override

     @Transactional(readOnly = false)

     public HolidayCalendarInfo createHolidayCalendar(String holidayCalendarTypeKey, HolidayCalendarInfo holidayCalendarInfo, ContextInfo context) throws DataValidationErrorException,

             InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {

         AtpInfo atpInfo;

         try {

             atpInfo = holidayCalendarAssembler.disassemble(holidayCalendarInfo, context);

         } catch (AssemblyException ex) {

             throw new OperationFailedException("Unexpected", ex);

         }

         try {

             System.out.println("AcademicCalendarServiceImp: creating atp for holiday calendar ");

             atpInfo = atpService.createAtp(atpInfo.getTypeKey(), atpInfo, context);

             System.out.println("atp created for holiday calendar " + atpInfo.getId());

         } catch (ReadOnlyException ex) {

             throw new OperationFailedException("Unexpected", ex);

         }

         HolidayCalendarInfo newHolidayCalendar;

         try {

             newHolidayCalendar = holidayCalendarAssembler.assemble(atpInfo, context);

         } catch (AssemblyException ex) {

             throw new OperationFailedException("unexpected", ex);

         }

         return newHolidayCalendar;

     }

     @Override

     @Transactional(readOnly = false)

     public HolidayCalendarInfo copyHolidayCalendar(String holidayCalendarId, Date startDate, Date endDate, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {

         throw new OperationFailedException("Method implemented in calculation decorator.");

     }

     @Override

     @Transactional(readOnly = false)

     public HolidayCalendarInfo updateHolidayCalendar(String holidayCalendarId, HolidayCalendarInfo holidayCalendarInfo, ContextInfo contextInfo) throws DataValidationErrorException,

             DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, ReadOnlyException, VersionMismatchException {

         try {

             AtpInfo toUpdate = holidayCalendarAssembler.disassemble(holidayCalendarInfo, contextInfo);

             AtpInfo updated = atpService.updateAtp(holidayCalendarId, toUpdate, contextInfo);

             return holidayCalendarAssembler.assemble(updated, contextInfo);

         } catch (AssemblyException e) {

             throw new OperationFailedException("AssemblyException : " + e.getMessage());

         } catch (DoesNotExistException e) {

             throw new OperationFailedException("Failed to update ATP - " + e.getMessage(), e);

         } catch (ReadOnlyException e) {

             throw new OperationFailedException("Failed to update ATP - " + e.getMessage(), e);

         }

     }

     @Override

     @Transactional(readOnly = false)

     public StatusInfo deleteHolidayCalendar(String holidayCalendarId, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException {

         return atpService.deleteAtp(holidayCalendarId, context);

     }

     @Override

     public TypeInfo getTermType(String termTypeKey, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         TypeInfo type = typeService.getType(termTypeKey, context);

         if (!checkTypeForTermType(termTypeKey, context)) {

             throw new InvalidParameterException(termTypeKey + " is not a Term type");

         }

         return type;

     }

     @Override

     public List<TypeInfo> getTermTypes(ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {

         List<TypeTypeRelationInfo> relations = null;

         try {

             relations = typeService.getTypeTypeRelationsByOwnerAndType(AtpServiceConstants.ATP_TERM_GROUPING_TYPE_KEY, TypeServiceConstants.TYPE_TYPE_RELATION_GROUP_TYPE_KEY, context);

         } catch (DoesNotExistException e) {

             throw new OperationFailedException(e.getMessage(), e);

         }

         if (relations != null) {

             List<TypeInfo> results = new ArrayList<TypeInfo>(relations.size());

             for (TypeTypeRelationInfo rel : relations) {

                 try {

                     results.add(typeService.getType(rel.getRelatedTypeKey(), context));

                 } catch (DoesNotExistException e) {

                     throw new OperationFailedException(e.getMessage(), e);

                 }

             }

             return results;

         }

         return null;

     }

     @Override

     public List<TypeInfo> getTermTypesForAcademicCalendarType(String academicCalendarTypeKey, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException {

         TypeInfo acalType = typeService.getType(academicCalendarTypeKey, context);

         return typeService.getAllowedTypesForType(acalType.getKey(), context);

     }

     @Override

     public List<TypeInfo> getTermTypesForTermType(String termTypeKey, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException {

         TypeInfo termType = getTermType(termTypeKey, context);

         return typeService.getAllowedTypesForType(termType.getKey(), context);

     }

     @Override

     public StateInfo getTermState(String termStateKey, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         StateInfo termState = stateService.getState(termStateKey, context);

         return termState;

     }

     @Override

     public List<StateInfo> getTermStates(ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {

         List<StateInfo> results;

         try {

             results = stateService.getStatesByLifecycle(AtpServiceConstants.ATP_LIFECYCLE_KEY, context);

         } catch (DoesNotExistException ex) {

             throw new OperationFailedException(AtpServiceConstants.ATP_LIFECYCLE_KEY, ex);

         }

         return results;

     }

     @Override

     public TermInfo getTerm(String termId, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {

         AtpInfo atp = atpService.getAtp(termId, context);

         TermInfo term = null;

         if (atp != null && checkTypeForTermType(atp.getTypeKey(), context)) {

             try {

                 term = termAssembler.assemble(atp, context);

             } catch (AssemblyException e) {

                 throw new OperationFailedException("AssemblyException : " + e.getMessage());

             }

         } else {

             throw new DoesNotExistException("This is either not valid Atp or not valid Term. " + termId);

         }

         return term;

     }

     @Override

     public List<TermInfo> getTermsByIds(List<String> termIds, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         List<AtpInfo> results = atpService.getAtpsByIds(termIds, context);

         List<TermInfo> terms = new ArrayList<TermInfo>();

         for (AtpInfo atp : results) {

             try {

                 terms.add(termAssembler.assemble(atp, context));

             } catch (AssemblyException e) {

                 throw new OperationFailedException("AssemblyException : " + e.getMessage());

             }

         }

         return terms;

     }

     @Override

     public List<TermInfo> getTermsForAcademicCalendar(String academicCalendarId, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException {

         List<AtpAtpRelationInfo> results = atpService.getAtpAtpRelationsByTypeAndAtp(academicCalendarId,

                 AtpServiceConstants.ATP_ATP_RELATION_INCLUDES_TYPE_KEY,

                 context);

         List<TermInfo> terms = new ArrayList<TermInfo>(results.size());

         for (AtpAtpRelationInfo atpRelation : results) {

             if (atpRelation.getAtpId().equals(academicCalendarId)) {

                 AtpInfo possibleTerm = atpService.getAtp(atpRelation.getRelatedAtpId(), context);

                 if (checkTypeForTermType(possibleTerm.getTypeKey(), context)) {

                     try {

                         terms.add(termAssembler.assemble(possibleTerm, context));

                     } catch (AssemblyException e) {

                         throw new OperationFailedException("AssemblyException : " + e.getMessage());

                     }

                 }

             }

         }

         return terms;

     }

     @Override

     public List<TermInfo> getCurrentTerms(String processKey, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         List<AcademicCalendarInfo> currentACInfos = getAcademicCalendarsByStartYear(new Integer(Calendar.getInstance().get(Calendar.YEAR)), context);

         List<TermInfo> terms = getTermsForAcademicCalendar(currentACInfos.get(0).getId(), context);

         if (terms == null || terms.size() == 0) {

             throw new DoesNotExistException("This academic calendar doesn't contain any terms : " + currentACInfos.get(0).getId());

         }

         return terms;

     }

     @Override

     public List<TermInfo> getIncludedTermsInTerm(String termId, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         // check for a valid term

         TermInfo parentTerm = getTerm(termId, context);

         List<AtpAtpRelationInfo> results = atpService.getAtpAtpRelationsByTypeAndAtp(parentTerm.getId(), AtpServiceConstants.ATP_ATP_RELATION_INCLUDES_TYPE_KEY, context);

         List<TermInfo> terms = new ArrayList<TermInfo>(results.size());

         for (AtpAtpRelationInfo atpRelation : results) {

             if (atpRelation.getAtpId().equals(termId)) {

                 AtpInfo possibleTerm = atpService.getAtp(atpRelation.getRelatedAtpId(), context);

                 if (checkTypeForTermType(possibleTerm.getTypeKey(), context)) {

                     try {

                         terms.add(termAssembler.assemble(possibleTerm, context));

                     } catch (AssemblyException e) {

                         throw new OperationFailedException("AssemblyException : " + e.getMessage());

                     }

                 }

             }

         }

         return terms;

     }

     @Override

     public List<TermInfo> getContainingTerms(String termId, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         // check for a valid term

         TermInfo term = getTerm(termId, context);

         List<AtpAtpRelationInfo> results = atpService.getAtpAtpRelationsByAtp(term.getId(), context);

         List<TermInfo> terms = new ArrayList<TermInfo>(results.size());

         // check that the relations we found have the given termId as the

         // "related" atp, and that the owning atp is a term

         for (AtpAtpRelationInfo atpRelation : results) {

             if (atpRelation.getRelatedAtpId().equals(termId)) {

                 AtpInfo possibleTerm = atpService.getAtp(atpRelation.getAtpId(), context);

                 if (checkTypeForTermType(possibleTerm.getTypeKey(), context)) {

                     try {

                         terms.add(termAssembler.assemble(possibleTerm, context));

                     } catch (AssemblyException e) {

                         throw new OperationFailedException("AssemblyException : " + e.getMessage());

                     }

                 }

             }

         }

         return terms;

     }

     @Override

     public List<ValidationResultInfo> validateTerm(String validationTypeKey, String termTypeKey, TermInfo termInfo, ContextInfo context) throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         // TODO Li Pan - THIS METHOD NEEDS JAVADOCS

         return new ArrayList<ValidationResultInfo>();

     }

     @Override

     @Transactional(readOnly = false)

     public TermInfo createTerm(String termTypeKey, TermInfo termInfo, ContextInfo context) throws DataValidationErrorException, InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException {

         AtpInfo atp;

         if (checkTypeForTermType(termTypeKey, context)) {

             try {

                 atp = termAssembler.disassemble(termInfo, context);

             } catch (AssemblyException e) {

                 throw new OperationFailedException("AssemblyException : " + e.getMessage());

             }

             try {

                 AtpInfo newAtp = atpService.createAtp(atp.getTypeKey(), atp, context);

                 termInfo = termAssembler.assemble(newAtp, context);

             } catch (AssemblyException e) {

                 throw new OperationFailedException("Error assembling term", e);

             } catch (ReadOnlyException e) {

                 throw new OperationFailedException("Error assembling term", e);

             }

         } else {

             throw new InvalidParameterException("Term type not found: '" + termTypeKey + "'");

         }

         return termInfo;

     }

     @Override

     @Transactional(readOnly = false)

     public TermInfo updateTerm(String termId, TermInfo termInfo, ContextInfo context) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException, VersionMismatchException {

         TermInfo updatedTerm;

         try {

             AtpInfo toUpdate = termAssembler.disassemble(termInfo, context);

             AtpInfo updated = atpService.updateAtp(termId, toUpdate, context);

             updatedTerm = termAssembler.assemble(updated, context);

         } catch (AssemblyException e) {

             throw new OperationFailedException("AssemblyException : " + e.getMessage());

         } catch (ReadOnlyException e) {

             throw new OperationFailedException("Error updating ATP - " + e.getMessage(), e);

         }

         return updatedTerm;

     }

     @Override

     @Transactional(readOnly = false)

     public StatusInfo deleteTerm(String termId, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         AtpInfo atp = atpService.getAtp(termId, context);

         if (atp == null) {

             throw new DoesNotExistException(termId);

         }

         if (!checkTypeForTermType(atp.getTypeKey(), context)) {

             throw new InvalidParameterException("Invalid termId: " + termId + "  Given key does not map to a Term");

         }

         StatusInfo result = atpService.deleteAtp(termId, context);

         return result;

     }

     @Override

     @Transactional(readOnly = false)

     public StatusInfo addTermToAcademicCalendar(String academicCalendarId,

                                                 String termId, ContextInfo context) throws DoesNotExistException,

             InvalidParameterException,

             MissingParameterException,

             OperationFailedException, PermissionDeniedException,

             AlreadyExistsException {

         // TODO: move this to a validation layer

         AtpInfo acal = atpService.getAtp(academicCalendarId, context);

         if (!isAcademicCalendar(acal.getTypeKey())) {

             throw new DoesNotExistException("AcademicCalendar with id = " + academicCalendarId + " is not an academic calendar " + acal.getTypeKey());

         }

         // TODO: move this to a validation layer

         AtpInfo term = atpService.getAtp(termId, context);

         if (!checkTypeForTermType(term.getTypeKey(), context)) {

             throw new DoesNotExistException("ter with id = " + termId + " is not an academic calendar " + term.getTypeKey());

         }

         // check if already exists

         if (termAlreadyExists(academicCalendarId, termId, context)) {

             throw new AlreadyExistsException("Term with id = " + termId + " is already associated with academic calendar " + academicCalendarId);

         }

         // actually create it

         try {

             createAtpAtpRelation(academicCalendarId, termId, AtpServiceConstants.ATP_ATP_RELATION_INCLUDES_TYPE_KEY, context);

         } catch (DataValidationErrorException ex) {

             throw new OperationFailedException("unexpected", ex);

         }

         StatusInfo status = new StatusInfo();

         status.setSuccess(Boolean.TRUE);

         return status;

     }

     private boolean isAcademicCalendar(String acalType) {

         return acalType.equals(AtpServiceConstants.ATP_ACADEMIC_CALENDAR_TYPE_KEY);

     }

     private boolean termAlreadyExists(String parentTermOrAcalId, String termId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         List<AtpAtpRelationInfo> atpRels = atpService.getAtpAtpRelationsByTypeAndAtp(parentTermOrAcalId, AtpServiceConstants.ATP_ATP_RELATION_INCLUDES_TYPE_KEY, context);

         for (AtpAtpRelationInfo atpRelInfo : atpRels) {

             if (atpRelInfo.getAtpId().equals(parentTermOrAcalId)) {

                 if (atpRelInfo.getRelatedAtpId().equals(termId)) {

                     return true;

                 }

             }

         }

         return false;

     }

     @Override

     @Transactional(readOnly = false)

     public StatusInfo removeTermFromAcademicCalendar(String academicCalendarKey, String termId, ContextInfo context) throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException, PermissionDeniedException {

         AtpInfo acal = atpService.getAtp(academicCalendarKey, context);

         if (acal == null) {

             throw new InvalidParameterException("Invalid academicCalendarKey: " + academicCalendarKey);

         }

         AtpInfo term = atpService.getAtp(termId, context);

         if (term == null) {

             throw new InvalidParameterException("Invalid termId: " + termId);

         }

         List<AtpAtpRelationInfo> relations = atpService.getAtpAtpRelationsByTypeAndAtp(academicCalendarKey, AtpServiceConstants.ATP_ATP_RELATION_INCLUDES_TYPE_KEY, context);

         if (relations == null || relations.isEmpty()) {

             throw new DoesNotExistException("No relationship exists between academic calendar: " + academicCalendarKey + " and term: " + termId);

         }

         AtpAtpRelationInfo relationToRemove = null;

         for (AtpAtpRelationInfo rel : relations) {

             if (rel.getAtpId().equals(academicCalendarKey)) {

                 if (rel.getRelatedAtpId().equals(termId)) {

                     // if the relation represents an "includes" relationship

                     // from the AcademicCalendar to the Term,

                     // then it is the one we need to remove

                     relationToRemove = rel;

                     break;

                 }

             }

         }

         if (relationToRemove == null) {

             throw new DoesNotExistException("No relationship exists between academic calendar: " + academicCalendarKey + " and term: " + termId);

         }

         StatusInfo resultStatus = atpService.deleteAtpAtpRelation(relationToRemove.getId(), context);

         return resultStatus;

     }

     @Override

     @Transactional(readOnly = false)

     public StatusInfo addTermToTerm(String termId, String includedTermId, ContextInfo context) throws AlreadyExistsException, DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException, PermissionDeniedException {

         TermInfo term = getTerm(termId, context);

         TermInfo includedTerm = getTerm(includedTermId, context);

         // check if the relationship already exists

         List<TermInfo> terms = getIncludedTermsInTerm(term.getId(), context);

         for (TermInfo t : terms) {

             if (t.getId().equals(includedTerm.getId())) {

                 throw new AlreadyExistsException("A relationship already exists exists between term: " + termId + " and included term: " + includedTermId);

             }

         }

         StatusInfo resultStatus = new StatusInfo();

         try {

             createAtpAtpRelation(termId, includedTermId, AtpServiceConstants.ATP_ATP_RELATION_INCLUDES_TYPE_KEY, context);

         } catch (DataValidationErrorException e) {

             resultStatus.setSuccess(false);

             resultStatus.setMessage("Creation of AtpAtpRelation failed due to DataValidationErrorExecption: " + e.getMessage());

         }

         return resultStatus;

     }

     @Override

     @Transactional(readOnly = false)

     public StatusInfo removeTermFromTerm(String termId, String includedTermId, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException {

         try {

             atpService.getAtp(termId, context);

         } catch (DoesNotExistException e) {

             throw new InvalidParameterException("Invalid termId: " + termId);

         }

         try {

             atpService.getAtp(includedTermId, context);

         } catch (DoesNotExistException e) {

             throw new InvalidParameterException("Invalid includedTermId: " + includedTermId);

         }

         List<AtpAtpRelationInfo> relations = atpService.getAtpAtpRelationsByTypeAndAtp(termId, AtpServiceConstants.ATP_ATP_RELATION_INCLUDES_TYPE_KEY, context);

         if (relations == null || relations.isEmpty()) {

             throw new DoesNotExistException("No relationship exists between term: " + termId + " and included term: " + includedTermId);

         }

         AtpAtpRelationInfo relationToRemove = null;

         for (AtpAtpRelationInfo rel : relations) {

             if (rel.getAtpId().equals(termId)) {

                 if (rel.getRelatedAtpId().equals(includedTermId)) {

                     // if the relation represents an "includes" relationship

                     // from the Term to the included Term,

                     // then it is the one we need to remove

                     relationToRemove = rel;

                     break;

                 }

             }

         }

         if (relationToRemove == null) {

             throw new DoesNotExistException("No relationship exists between term: " + termId + " and included term: " + includedTermId);

         }

         StatusInfo resultStatus = atpService.deleteAtpAtpRelation(relationToRemove.getId(), context);

         return resultStatus;

     }

     @Override

     public TypeInfo getKeyDateType(String keyDateTypeKey, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException {

         // TODO Li Pan - THIS METHOD NEEDS JAVADOCS

         return null;

     }

     @Override

     public List<TypeInfo> getKeyDateTypesForTermType(String termTypeKey, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException {

         List<TypeInfo> types = null;

         try {

             // TODO: change this when the new contract gets merged in because it does not have the refobject uri as a parameter

             types = this.typeService.getAllowedTypesForType(termTypeKey, context);

         } catch (PermissionDeniedException ex) {

             throw new OperationFailedException("TODO: change the contract to allow this method, getKeyDateTypesForTermType, to throw the PermissionDeniedException", ex);

         }

         // filter by ref object uri

         List<TypeInfo> list = new ArrayList<TypeInfo>(types.size());

         for (TypeInfo type : types) {

             if (type.getRefObjectUri() == null) {

                 throw new NullPointerException(type.getKey());

             }

             if (type.getRefObjectUri().equals(AtpServiceConstants.REF_OBJECT_URI_MILESTONE)) {

                 list.add(type);

             }

         }

         return list;

     }

     @Override

     public KeyDateInfo getKeyDate(String keyDateId, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         MilestoneInfo ms = atpService.getMilestone(keyDateId, context);

         return (null != ms) ? fromMilestoneInfo(ms) : null;

     }

     @Override

     public List<KeyDateInfo> getKeyDatesByIds(List<String> keyDateIds, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException {

         return new ArrayList<KeyDateInfo>();

     }

     @Override

     public List<KeyDateInfo> getKeyDatesForTerm(String termId, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         AtpInfo termAtp = atpService.getAtp(termId, context);

         if (termAtp == null) {

             throw new DoesNotExistException(termId);

         }

         List<MilestoneInfo> milestones = atpService.getMilestonesForAtp(termId, context);

         if (milestones == null || milestones.isEmpty()) {

             return Collections.emptyList();

         }

         List<KeyDateInfo> keyDates = new ArrayList<KeyDateInfo>(milestones.size());

         for (MilestoneInfo milestone : milestones) {

             keyDates.add(fromMilestoneInfo(milestone));

         }

         return keyDates;

     }

     @Override

     public List<KeyDateInfo> getKeyDatesForTermByDate(String termId, Date startDate, Date endDate, ContextInfo context) throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException, PermissionDeniedException {

         List<MilestoneInfo> milestoneInfos = atpService.getMilestonesByDatesForAtp(termId, startDate, endDate, context);

         List<KeyDateInfo> keyDates = new ArrayList<KeyDateInfo>();

         for (MilestoneInfo milestoneInfo : milestoneInfos) {

             keyDates.add(fromMilestoneInfo(milestoneInfo));

         }

         return keyDates;

     }

     @Override

     public List<KeyDateInfo> getImpactedKeyDates(String keyDateId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException {

         List<KeyDateInfo> impactedKeyDates = new ArrayList<KeyDateInfo>();

         List<MilestoneInfo> impactedMilestones = atpService.getImpactedMilestones(keyDateId, contextInfo);

         for (MilestoneInfo impactedMilestone : impactedMilestones) {

             impactedKeyDates.add(fromMilestoneInfo(impactedMilestone));

         }

         return impactedKeyDates;

     }

     private MilestoneInfo toMilestoneInfo(KeyDateInfo keyDateInfo) {

         if (keyDateInfo != null) {

             MilestoneInfo msInfo = new MilestoneInfo();

             msInfo.setIsAllDay(keyDateInfo.getIsAllDay());

             msInfo.setAttributes(keyDateInfo.getAttributes());

             msInfo.setIsDateRange(keyDateInfo.getIsDateRange());

             msInfo.setDescr(keyDateInfo.getDescr());

             msInfo.setId(keyDateInfo.getId());

             msInfo.setMeta(keyDateInfo.getMeta());

             msInfo.setName(keyDateInfo.getName());

             msInfo.setStartDate(keyDateInfo.getStartDate());

             msInfo.setEndDate(keyDateInfo.getEndDate());

             msInfo.setStateKey(keyDateInfo.getStateKey());

             msInfo.setTypeKey(keyDateInfo.getTypeKey());

             return msInfo;

         } else {

             return null;

         }

     }

     private KeyDateInfo fromMilestoneInfo(MilestoneInfo milestoneInfo) {

         if (milestoneInfo != null) {

             KeyDateInfo keyInfo = new KeyDateInfo();

             keyInfo.setIsAllDay(milestoneInfo.getIsAllDay());

             keyInfo.setAttributes(milestoneInfo.getAttributes());

             keyInfo.setIsDateRange(milestoneInfo.getIsDateRange());

             keyInfo.setDescr(milestoneInfo.getDescr());

             keyInfo.setId(milestoneInfo.getId());

             keyInfo.setMeta(milestoneInfo.getMeta());

             keyInfo.setName(milestoneInfo.getName());

             keyInfo.setStartDate(milestoneInfo.getStartDate());

             keyInfo.setEndDate(milestoneInfo.getEndDate());

             keyInfo.setStateKey(milestoneInfo.getStateKey());

             keyInfo.setTypeKey(milestoneInfo.getTypeKey());

             keyInfo.setIsRelativeToKeyDate(milestoneInfo.getIsRelative());

             keyInfo.setRelativeAnchorKeyDateId(milestoneInfo.getRelativeAnchorMilestoneId());

             return keyInfo;

         } else {

             return null;

         }

     }

     @Override

     @Transactional(readOnly = false)

     public KeyDateInfo updateKeyDate(String keyDateId, KeyDateInfo keyDateInfo, ContextInfo context) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException, PermissionDeniedException, VersionMismatchException {

         MilestoneInfo toUpdate = toMilestoneInfo(keyDateInfo);

         MilestoneInfo newMilestone = null;

         try {

             newMilestone = atpService.updateMilestone(keyDateId, toUpdate, context);

         } catch (ReadOnlyException e) {

             throw new OperationFailedException("Error updating milestone", e);

         }

         return fromMilestoneInfo(newMilestone);

     }

     @Override

     @Transactional(readOnly = false)

     public StatusInfo deleteKeyDate(String keyDateId, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         return atpService.deleteMilestone(keyDateId, context);

     }

     @Override

     @Transactional(readOnly = false)

     public KeyDateInfo calculateKeyDate(String keyDateId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         MilestoneInfo milestone = atpService.calculateMilestone(keyDateId, contextInfo);

         return fromMilestoneInfo(milestone);

     }

     @Override

     public TypeInfo getHolidayType(String holidayTypeKey, ContextInfo context) throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException, PermissionDeniedException {

         TypeInfo type = typeService.getType(holidayTypeKey, context);

         if (!checkTypeForHolidayType(holidayTypeKey, context)) {

             throw new InvalidParameterException(holidayTypeKey + " is not a Holiday type");

         }

         return type;

     }

     @Override

     @Transactional(readOnly = false)

     public HolidayInfo updateHoliday(String holidayId, HolidayInfo holidayInfo, ContextInfo context) throws DataValidationErrorException, DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException, PermissionDeniedException, VersionMismatchException {

         try {

             MilestoneInfo toUpdate = holidayAssembler.disassemble(holidayInfo, context);

             MilestoneInfo updated = null;

             try {

                 updated = atpService.updateMilestone(holidayId, toUpdate, context);

             } catch (ReadOnlyException e) {

                 throw new OperationFailedException("Error updating milestone", e);

             }

             return holidayAssembler.assemble(updated, context);

         } catch (AssemblyException e) {

             throw new OperationFailedException("AssemblyException : " + e.getMessage());

         }

     }

     @Override

     @Transactional(readOnly = false)

     public StatusInfo deleteHoliday(String holidayId, ContextInfo context) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         return atpService.deleteMilestone(holidayId, context);

     }

     @Override

     @Transactional(readOnly = false)

     public HolidayInfo calculateHoliday(String holidayId, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         return getHoliday(holidayId, contextInfo);

     }

     private DateRangeInfo getDateRangeFromKeyDate(KeyDateInfo keyDate) {

         DateRangeInfo dateRange = null;

         if (keyDate != null) {

             dateRange = new DateRangeInfo();

             dateRange.setStartDate(keyDate.getStartDate());

             dateRange.setEndDate(keyDate.getEndDate());

         }

         return dateRange;

     }

     private KeyDateInfo getKeyDatePrepairedFromDateRange(KeyDateInfo keyDate, DateRangeInfo dateRange) {

         if (null == dateRange) {

             return null;

         }

         if (keyDate == null) {

             keyDate = new KeyDateInfo();

         }

         keyDate.setStartDate(dateRange.getStartDate());

         keyDate.setEndDate(dateRange.getEndDate());

         keyDate.setIsDateRange(Boolean.TRUE);

         return keyDate;

     }

     private KeyDateInfo getKeyDatePrepairedFromDate(KeyDateInfo keyDate, Date date) {

         if (null == date) {

             return null;

         }

         if (keyDate == null) {

             keyDate = new KeyDateInfo();

         }

         keyDate.setStartDate(date);

         keyDate.setEndDate(date);

         keyDate.setIsAllDay(Boolean.FALSE);

         keyDate.setIsDateRange(Boolean.FALSE);

         return keyDate;

     }

     public AtpService getAtpService() {

         return atpService;

     }

     public void setAtpService(AtpService atpService) {

         this.atpService = atpService;

     }

     public AcademicCalendarAssembler getAcalAssembler() {

         return acalAssembler;

     }

     public void setAcalAssembler(AcademicCalendarAssembler acalAssembler) {

         this.acalAssembler = acalAssembler;

     }

     public TermAssembler getTermAssembler() {

         return termAssembler;

     }

     public void setTermAssembler(TermAssembler termAssembler) {

         this.termAssembler = termAssembler;

     }

     @Override

     public List<AcademicCalendarInfo> searchForAcademicCalendars(QueryByCriteria criteria, ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         List<AcademicCalendarInfo> academicCalendars = new ArrayList<AcademicCalendarInfo>();

         List<AtpInfo> atps = atpService.searchForAtps(criteria, context);

         for (AtpInfo atp : atps) {

             try {

                 academicCalendars.add(acalAssembler.assemble(atp, context));

             } catch (AssemblyException e) {

                 throw new OperationFailedException("AssemblyException : " + e.getMessage());

             }

         }

         return academicCalendars;

     }

     @Override

     public List<TermInfo> searchForTerms(QueryByCriteria criteria, ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         List<AtpInfo> results = atpService.searchForAtps(criteria, context);

         List<TermInfo> terms = new ArrayList<TermInfo>(results.size());

         for (AtpInfo atp : results) {

             try {

                 terms.add(termAssembler.assemble(atp, context));

             } catch (AssemblyException e) {

                 throw new OperationFailedException("AssemblyException : " + e.getMessage());

             }

         }

         return terms;

     }

     @Override

     public List<KeyDateInfo> searchForKeyDates(QueryByCriteria criteria, ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         // TODO sambit - THIS METHOD NEEDS JAVADOCS

         return new ArrayList<KeyDateInfo>();

     }

     @Override

     public List<HolidayInfo> searchForHolidays(QueryByCriteria criteria, ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         List<MilestoneInfo> milestoneInfos = atpService.searchForMilestones(criteria, context);

         List<HolidayInfo> holidayInfos = new ArrayList<HolidayInfo>();

         for (MilestoneInfo milestoneInfo : milestoneInfos) {

             try {

                 holidayInfos.add(holidayAssembler.assemble(milestoneInfo, context));

             } catch (AssemblyException e) {

                 throw new OperationFailedException("Error assembling holiday with Id " + milestoneInfo.getId(), e);

             }

         }

         return holidayInfos;

     }

     private boolean checkTypeForTermType(String typeKey, ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {

         List<TypeInfo> types = getTermTypes(context);

         return checkTypeInTypes(typeKey, types);

     }

     private boolean checkTypeForHolidayType(String typeKey, ContextInfo context) throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {

         List<TypeInfo> types = getHolidayTypes(context);

         return checkTypeInTypes(typeKey, types);

     }

     private boolean checkTypeInTypes(String typeKey, List<TypeInfo> types) {

         if (types != null && !types.isEmpty()) {

             for (TypeInfo type : types) {

                 if (type.getKey().equals(typeKey)) {

                     return true;

                 }

             }

         }

         return false;

     }

     private void createDeleteAtpAtpRelations(String fromAtpId,

                                              List<String> newRelatedAtpIds,

                                              String relatedAtpType,

                                              ContextInfo context)

             throws AlreadyExistsException, DataValidationErrorException,

             InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException, VersionMismatchException {

         // get the existing but remember the relationship Id too

         List<AtpAtpRelationInfo> atpRels = atpService.getAtpAtpRelationsByAtp(fromAtpId, context);

         Map<String, String> existing = new HashMap<String, String>();

         for (AtpAtpRelationInfo atpRelInfo : atpRels) {

             if (AtpServiceConstants.ATP_ATP_RELATION_ASSOCIATED_TYPE_KEY.equals(atpRelInfo.getTypeKey())) {

                 AtpInfo atp = null;

                 try {

                     atp = atpService.getAtp(atpRelInfo.getRelatedAtpId(), context);

                 } catch (DoesNotExistException ex) {

                     throw new OperationFailedException(atpRelInfo.getRelatedAtpId(), ex);

                 }

                 if (atp.getTypeKey().equals(relatedAtpType)) {

                     existing.put(atpRelInfo.getRelatedAtpId(), atpRelInfo.getId());

                 }

             }

         }

         // create any new ones

         for (String relatedAtpId : newRelatedAtpIds) {

             if (!existing.containsKey(relatedAtpId)) {

                 createAtpAtpRelation(fromAtpId, relatedAtpId, AtpServiceConstants.ATP_ATP_RELATION_ASSOCIATED_TYPE_KEY, context);

             }

         }

         // delete any existing ones that should no longer exist

         for (String existingAtpId : existing.keySet()) {

             if (!newRelatedAtpIds.contains(existingAtpId)) {

                 String atpAtpRelationId = existing.get(existingAtpId);

                 try {

                     StatusInfo status = atpService.deleteAtpAtpRelation(atpAtpRelationId, context);

                 } catch (DoesNotExistException ex) {

                     throw new OperationFailedException("Unexpected", ex);

                 }

             }

         }

     }

     private AtpAtpRelationInfo createAtpAtpRelation(String atpId,

                                                     String relatedAtpId,

                                                     String relationType,

                                                     ContextInfo context)

             throws AlreadyExistsException, DataValidationErrorException,

             InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException {

         AtpAtpRelationInfo atpRel = new AtpAtpRelationInfo();

         atpRel.setAtpId(atpId);

         atpRel.setRelatedAtpId(relatedAtpId);

         atpRel.setTypeKey(relationType);

         atpRel.setStateKey(AtpServiceConstants.ATP_ATP_RELATION_ACTIVE_STATE_KEY);

         atpRel.setEffectiveDate(new Date());

         try {

             atpRel = atpService.createAtpAtpRelation(atpRel.getAtpId(), atpRel.getRelatedAtpId(), atpRel.getTypeKey(), atpRel, context);

         } catch (DoesNotExistException e) {

             throw new OperationFailedException("Error creating atp-atp relation", e);

         } catch (ReadOnlyException e) {

             throw new OperationFailedException("Error creating atp-atp relation", e);

         }

         return atpRel;

     }

     @Override

     public List<String> searchForAcademicCalendarIds(QueryByCriteria criteria, ContextInfo contextInfo) throws InvalidParameterException, MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         // TODO sambit - THIS METHOD NEEDS JAVADOCS

         return null;

     }

     @Override

     public List<ValidationResultInfo> validateAcademicCalendar(String validationTypeKey, String academicCalendarTypeKey, AcademicCalendarInfo academicCalendarInfo, ContextInfo contextInfo)

             throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {

         // TODO sambit - THIS METHOD NEEDS JAVADOCS

         return null;

     }

     @Override

     public TypeInfo getHolidayCalendarType(String holidayCalendarTypeKey, ContextInfo contextInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException,

             OperationFailedException {

         TypeInfo type;

         try {

             type = typeService.getType(holidayCalendarTypeKey, contextInfo);

         } catch (PermissionDeniedException ex) {

             throw new OperationFailedException("Permission Denied");

         }

         return type;

     }