/**

  * Copyright 2010 The Kuali Foundation Licensed under the

  * Educational Community License, Version 2.0 (the "License"); you may

  * not use this file except in compliance with the License. You may

  * obtain a copy of the License at

  *

  * http://www.osedu.org/licenses/ECL-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an "AS IS"

  * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express

  * or implied. See the License for the specific language governing

  * permissions and limitations under the License.

  */

 package org.kuali.student.lum.lu.service.impl;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.Comparator;

 import java.util.Date;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Map.Entry;

 import java.util.Set;

 import javax.jws.WebService;

 import javax.persistence.NoResultException;

 import org.apache.log4j.Logger;

 import org.kuali.student.common.dictionary.dto.ObjectStructureDefinition;

 import org.kuali.student.common.dictionary.service.DictionaryService;

 import org.kuali.student.common.dto.CurrencyAmountInfo;

 import org.kuali.student.common.dto.DtoConstants;

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

 import org.kuali.student.common.entity.Amount;

 import org.kuali.student.common.entity.TimeAmount;

 import org.kuali.student.common.entity.Version;

 import org.kuali.student.common.entity.VersionEntity;

 import org.kuali.student.common.exceptions.AlreadyExistsException;

 import org.kuali.student.common.exceptions.CircularRelationshipException;

 import org.kuali.student.common.exceptions.DataValidationErrorException;

 import org.kuali.student.common.exceptions.DependentObjectsExistException;

 import org.kuali.student.common.exceptions.DoesNotExistException;

 import org.kuali.student.common.exceptions.IllegalVersionSequencingException;

 import org.kuali.student.common.exceptions.InvalidParameterException;

 import org.kuali.student.common.exceptions.MissingParameterException;

 import org.kuali.student.common.exceptions.OperationFailedException;

 import org.kuali.student.common.exceptions.PermissionDeniedException;

 import org.kuali.student.common.exceptions.UnsupportedActionException;

 import org.kuali.student.common.exceptions.VersionMismatchException;

 import org.kuali.student.common.search.dto.SearchCriteriaTypeInfo;

 import org.kuali.student.common.search.dto.SearchParam;

 import org.kuali.student.common.search.dto.SearchRequest;

 import org.kuali.student.common.search.dto.SearchResult;

 import org.kuali.student.common.search.dto.SearchResultCell;

 import org.kuali.student.common.search.dto.SearchResultRow;

 import org.kuali.student.common.search.dto.SearchResultTypeInfo;

 import org.kuali.student.common.search.dto.SearchTypeInfo;

 import org.kuali.student.common.search.service.SearchDispatcher;

 import org.kuali.student.common.search.service.SearchManager;

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

 import org.kuali.student.common.validator.Validator;

 import org.kuali.student.common.validator.ValidatorFactory;

 import org.kuali.student.common.versionmanagement.dto.VersionDisplayInfo;

 import org.kuali.student.lum.lu.dao.LuDao;

 import org.kuali.student.lum.lu.dto.AccreditationInfo;

 import org.kuali.student.lum.lu.dto.AdminOrgInfo;

 import org.kuali.student.lum.lu.dto.AffiliatedOrgInfo;

 import org.kuali.student.lum.lu.dto.CluCluRelationInfo;

 import org.kuali.student.lum.lu.dto.CluFeeRecordInfo;

 import org.kuali.student.lum.lu.dto.CluIdentifierInfo;

 import org.kuali.student.lum.lu.dto.CluInfo;

 import org.kuali.student.lum.lu.dto.CluInstructorInfo;

 import org.kuali.student.lum.lu.dto.CluLoRelationInfo;

 import org.kuali.student.lum.lu.dto.CluLoRelationTypeInfo;

 import org.kuali.student.lum.lu.dto.CluPublicationInfo;

 import org.kuali.student.lum.lu.dto.CluResultInfo;

 import org.kuali.student.lum.lu.dto.CluResultTypeInfo;

 import org.kuali.student.lum.lu.dto.CluSetInfo;

 import org.kuali.student.lum.lu.dto.CluSetTreeViewInfo;

 import org.kuali.student.lum.lu.dto.CluSetTypeInfo;

 import org.kuali.student.lum.lu.dto.DeliveryMethodTypeInfo;

 import org.kuali.student.lum.lu.dto.FieldInfo;

 import org.kuali.student.lum.lu.dto.InstructionalFormatTypeInfo;

 import org.kuali.student.lum.lu.dto.LuCodeInfo;

 import org.kuali.student.lum.lu.dto.LuCodeTypeInfo;

 import org.kuali.student.lum.lu.dto.LuLuRelationTypeInfo;

 import org.kuali.student.lum.lu.dto.LuPublicationTypeInfo;

 import org.kuali.student.lum.lu.dto.LuTypeInfo;

 import org.kuali.student.lum.lu.dto.LuiInfo;

 import org.kuali.student.lum.lu.dto.LuiLuiRelationInfo;

 import org.kuali.student.lum.lu.dto.MembershipQueryInfo;

 import org.kuali.student.lum.lu.dto.ResultOptionInfo;

 import org.kuali.student.lum.lu.dto.ResultUsageTypeInfo;

 import org.kuali.student.lum.lu.entity.Clu;

 import org.kuali.student.lum.lu.entity.CluAccounting;

 import org.kuali.student.lum.lu.entity.CluAccountingAttribute;

 import org.kuali.student.lum.lu.entity.CluAccreditation;

 import org.kuali.student.lum.lu.entity.CluAccreditationAttribute;

 import org.kuali.student.lum.lu.entity.CluAdminOrg;

 import org.kuali.student.lum.lu.entity.CluAdminOrgAttribute;

 import org.kuali.student.lum.lu.entity.CluAtpTypeKey;

 import org.kuali.student.lum.lu.entity.CluAttribute;

 import org.kuali.student.lum.lu.entity.CluCampusLocation;

 import org.kuali.student.lum.lu.entity.CluCluRelation;

 import org.kuali.student.lum.lu.entity.CluCluRelationAttribute;

 import org.kuali.student.lum.lu.entity.CluFee;

 import org.kuali.student.lum.lu.entity.CluIdentifier;

 import org.kuali.student.lum.lu.entity.CluInstructor;

 import org.kuali.student.lum.lu.entity.CluInstructorAttribute;

 import org.kuali.student.lum.lu.entity.CluLoRelation;

 import org.kuali.student.lum.lu.entity.CluLoRelationAttribute;

 import org.kuali.student.lum.lu.entity.CluLoRelationType;

 import org.kuali.student.lum.lu.entity.CluPublication;

 import org.kuali.student.lum.lu.entity.CluPublicationAttribute;

 import org.kuali.student.lum.lu.entity.CluPublicationType;

 import org.kuali.student.lum.lu.entity.CluPublicationVariant;

 import org.kuali.student.lum.lu.entity.CluResult;

 import org.kuali.student.lum.lu.entity.CluResultType;

 import org.kuali.student.lum.lu.entity.CluSet;

 import org.kuali.student.lum.lu.entity.CluSetAttribute;

 import org.kuali.student.lum.lu.entity.CluSetJoinVersionIndClu;

 import org.kuali.student.lum.lu.entity.CluSetType;

 import org.kuali.student.lum.lu.entity.DeliveryMethodType;

 import org.kuali.student.lum.lu.entity.InstructionalFormatType;

 import org.kuali.student.lum.lu.entity.LuCode;

 import org.kuali.student.lum.lu.entity.LuCodeAttribute;

 import org.kuali.student.lum.lu.entity.LuCodeType;

 import org.kuali.student.lum.lu.entity.LuLuRelationType;

 import org.kuali.student.lum.lu.entity.LuPublicationType;

 import org.kuali.student.lum.lu.entity.LuRichText;

 import org.kuali.student.lum.lu.entity.LuType;

 import org.kuali.student.lum.lu.entity.Lui;

 import org.kuali.student.lum.lu.entity.LuiAttribute;

 import org.kuali.student.lum.lu.entity.LuiLuiRelation;

 import org.kuali.student.lum.lu.entity.LuiLuiRelationAttribute;

 import org.kuali.student.lum.lu.entity.MembershipQuery;

 import org.kuali.student.lum.lu.entity.ResultOption;

 import org.kuali.student.lum.lu.entity.ResultUsageType;

 import org.kuali.student.lum.lu.service.LuService;

 import org.kuali.student.lum.lu.service.LuServiceConstants;

 import org.springframework.beans.BeanUtils;

 import org.springframework.transaction.annotation.Transactional;

 @WebService(endpointInterface = "org.kuali.student.lum.lu.service.LuService", serviceName = "LuService", portName = "LuService", targetNamespace = "http://student.kuali.org/wsdl/lu")

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

 public class LuServiceImpl implements LuService {

         private static final String SEARCH_KEY_DEPENDENCY_ANALYSIS = "lu.search.dependencyAnalysis";

         private static final String SEARCH_KEY_BROWSE_PROGRAM = "lu.search.browseProgram";

         private static final String SEARCH_KEY_BROWSE_VARIATIONS = "lu.search.browseVariations";

         private static final String SEARCH_KEY_RESULT_COMPONENT = "lrc.search.resultComponent";

         private static final String SEARCH_KEY_PROPOSALS_BY_COURSE_CODE = "lu.search.proposalsByCourseCode";

         final Logger logger = Logger.getLogger(LuServiceImpl.class);

         private LuDao luDao;

         private SearchManager searchManager;

         private SearchDispatcher searchDispatcher;

         private DictionaryService dictionaryServiceDelegate;

         private ValidatorFactory validatorFactory;

         public void setSearchManager(SearchManager searchManager) {

                 this.searchManager = searchManager;

         }

         public void setDictionaryServiceDelegate(

                         DictionaryService dictionaryServiceDelegate) {

                 this.dictionaryServiceDelegate = dictionaryServiceDelegate;

         }

         public DictionaryService getDictionaryServiceDelegate() {

                 return dictionaryServiceDelegate;

         }

         /**************************************************************************

          * SETUP OPERATION *

          **************************************************************************/

         @Override

         public List<DeliveryMethodTypeInfo> getDeliveryMethodTypes()

                         throws OperationFailedException {

                 return LuServiceAssembler.toDeliveryMethodTypeInfos(luDao

                                 .find(DeliveryMethodType.class));

         }

         @Override

         public DeliveryMethodTypeInfo getDeliveryMethodType(

                         String deliveryMethodTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(deliveryMethodTypeKey, "deliveryMethodTypeKey");

                 return LuServiceAssembler.toDeliveryMethodTypeInfo(luDao.fetch(

                                 DeliveryMethodType.class, deliveryMethodTypeKey));

         }

         @Override

         public List<InstructionalFormatTypeInfo> getInstructionalFormatTypes()

                         throws OperationFailedException {

                 return LuServiceAssembler.toInstructionalFormatTypeInfos(luDao

                                 .find(InstructionalFormatType.class));

         }

         @Override

         public InstructionalFormatTypeInfo getInstructionalFormatType(

                         String instructionalFormatTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(instructionalFormatTypeKey,

                                 "instructionalFormatTypeKey");

                 return LuServiceAssembler.toInstructionalFormatTypeInfo(luDao.fetch(

                                 InstructionalFormatType.class, instructionalFormatTypeKey));

         }

         @Override

         public List<LuTypeInfo> getLuTypes() throws OperationFailedException {

                 return LuServiceAssembler.toLuTypeInfos(luDao.find(LuType.class));

         }

         @Override

         public LuTypeInfo getLuType(String luTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(luTypeKey, "luTypeKey");

                 return LuServiceAssembler.toLuTypeInfo(luDao.fetch(LuType.class,

                                 luTypeKey));

         }

         @Override

         public LuCodeTypeInfo getLuCodeType(String luCodeTypeKey)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(luCodeTypeKey, "luCodeTypeKey");

                 return LuServiceAssembler.toLuCodeTypeInfo(luDao.fetch(

                                 LuCodeType.class, luCodeTypeKey));

         }

         @Override

         public List<LuCodeTypeInfo> getLuCodeTypes()

                         throws OperationFailedException {

                 return LuServiceAssembler.toLuCodeTypeInfos(luDao

                                 .find(LuCodeType.class));

         }

         @Override

         public List<LuLuRelationTypeInfo> getLuLuRelationTypes()

                         throws OperationFailedException {

                 return LuServiceAssembler.toLuLuRelationTypeInfos(luDao

                                 .find(LuLuRelationType.class));

         }

         @Override

         public LuLuRelationTypeInfo getLuLuRelationType(String luLuRelationTypeKey)

                         throws OperationFailedException, MissingParameterException,

                         DoesNotExistException {

                 checkForMissingParameter(luLuRelationTypeKey, "luLuRelationTypeKey");

                 LuLuRelationType luLuRelationType = luDao.fetch(LuLuRelationType.class,

                                 luLuRelationTypeKey);

                 return LuServiceAssembler.toLuLuRelationTypeInfo(luLuRelationType);

         }

         @Override

         public List<String> getAllowedLuLuRelationTypesForLuType(String luTypeKey,

                         String relatedLuTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(luTypeKey, "luTypeKey");

                 checkForMissingParameter(relatedLuTypeKey, "relatedLuTypeKey");

                 return luDao.getAllowedLuLuRelationTypesForLuType(luTypeKey,

                                 relatedLuTypeKey);

         }

         @Override

         public List<LuPublicationTypeInfo> getLuPublicationTypes()

                         throws OperationFailedException {

                 return LuServiceAssembler.toLuPublicationTypeInfos(luDao

                                 .find(LuPublicationType.class));

         }

         @Override

         public LuPublicationTypeInfo getLuPublicationType(

                         String luPublicationTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(luPublicationTypeKey, "luPublicationTypeKey");

                 return LuServiceAssembler.toLuPublicationTypeInfo(luDao.fetch(

                                 LuPublicationType.class, luPublicationTypeKey));

         }

         @Override

         public List<String> getLuPublicationTypesForLuType(String luTypeKey)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 throw new UnsupportedOperationException("getLuPublicationTypesForLuType");

         }

         @Override

         public List<CluResultTypeInfo> getCluResultTypes()

                         throws OperationFailedException {

                 return LuServiceAssembler.toCluResultTypeInfos(luDao

                                 .find(CluResultType.class));

         }

         @Override

         public CluResultTypeInfo getCluResultType(String cluResultTypeKey)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 return LuServiceAssembler.toCluResultTypeInfo(luDao.fetch(

                                 CluResultType.class, cluResultTypeKey));

         }

         @Override

         public List<CluResultTypeInfo> getCluResultTypesForLuType(String luTypeKey)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(luTypeKey, "luTypeKey");

                 return LuServiceAssembler.toCluResultTypeInfos((luDao

                                 .getAllowedCluResultTypesForLuType(luTypeKey)));

         }

         @Override

         public List<ResultUsageTypeInfo> getResultUsageTypes()

                         throws OperationFailedException {

                 return LuServiceAssembler.toResultUsageTypeInfos(luDao

                                 .find(ResultUsageType.class));

         }

         @Override

         public ResultUsageTypeInfo getResultUsageType(String resultUsageTypeKey)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(resultUsageTypeKey, "resultUsageTypeKey");

                 return LuServiceAssembler.toResultUsageTypeInfo(luDao.fetch(

                                 ResultUsageType.class, resultUsageTypeKey));

         }

         @Override

         public List<String> getAllowedResultUsageTypesForLuType(String luTypeKey)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(luTypeKey, "luTypeKey");

                 return luDao.getAllowedResultUsageTypesForLuType(luTypeKey);

         }

         @Override

         public List<String> getAllowedResultComponentTypesForResultUsageType(

                         String resultUsageTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(resultUsageTypeKey, "resultUsageTypeKey");

                 return luDao

                                 .getAllowedResultComponentTypesForResultUsageType(resultUsageTypeKey);

         }

         @Override

         public CluLoRelationTypeInfo getCluLoRelationType(

                         String cluLoRelationTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(cluLoRelationTypeKey, "cluLoRelationTypeKey");

                 CluLoRelationType cluLoRelationType = luDao.fetch(

                                 CluLoRelationType.class, cluLoRelationTypeKey);

                 return LuServiceAssembler.toCluLoRelationTypeInfo(cluLoRelationType);

         }

         @Override

         public List<CluLoRelationTypeInfo> getCluLoRelationTypes()

                         throws OperationFailedException {

                 return LuServiceAssembler.toCluLoRelationTypeInfos(luDao

                                 .find(CluLoRelationType.class));

         }

         @Override

         public List<String> getAllowedCluLoRelationTypesForLuType(String luTypeKey)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(luTypeKey, luTypeKey);

                 return luDao.getAllowedCluLoRelationTypesForLuType(luTypeKey);

         }

         @Override

         public List<CluSetTypeInfo> getCluSetTypes()

                         throws OperationFailedException {

                 return LuServiceAssembler.toCluSetTypeInfos(luDao

                                 .find(CluSetType.class));

         }

         @Override

         public CluSetTypeInfo getCluSetType(String cluSetTypeKey)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(cluSetTypeKey, "cluSetTypeKey");

                 return LuServiceAssembler.toCluSetTypeInfo(luDao.fetch(

                                 CluSetType.class, cluSetTypeKey));

         }

         /**************************************************************************

          * READ OPERATION *

          **************************************************************************/

         // **** Core **********

         @Override

         public CluInfo getClu(String cluId) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(cluId, "cluId");

                 Clu clu = luDao.fetch(Clu.class, cluId);

                 return LuServiceAssembler.toCluInfo(clu);

         }

         @Override

         public List<CluInfo> getClusByIdList(List<String> cluIdList)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(cluIdList, "cluIdList");

                 checkForEmptyList(cluIdList, "cluIdList");

                 List<Clu> clus = luDao.getClusByIdList(cluIdList);

                 return LuServiceAssembler.toCluInfos(clus);

         }

         @Override

         public List<CluInfo> getClusByLuType(String luTypeKey, String luState)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(luTypeKey, "luTypeKey");

                 checkForMissingParameter(luState, "lustate");

                 List<Clu> clus = luDao.getClusByLuType(luTypeKey, luState);

                 return LuServiceAssembler.toCluInfos(clus);

         }

         @Override

         public List<String> getCluIdsByLuType(String luTypeKey, String luState)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(luTypeKey, "luTypeKey");

                 checkForMissingParameter(luState, "luState");

                 List<Clu> clus = luDao.getClusByLuType(luTypeKey, luState);

                 List<String> ids = new ArrayList<String>(clus.size());

                 for (Clu clu : clus) {

                         ids.add(clu.getId());

                 }

                 return ids;

         }

         // ****** Relations

         @Override

         public List<String> getAllowedLuLuRelationTypesByCluId(String cluId,

                         String relatedCluId) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(cluId, "cluId");

                 checkForMissingParameter(relatedCluId, "relatedCluId");

                 return luDao.getAllowedLuLuRelationTypesByCluId(cluId, relatedCluId);

         }

         @Override

         public List<CluInfo> getClusByRelation(String relatedCluId,

                         String luLuRelationTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(relatedCluId, "relatedCluId");

                 checkForMissingParameter(luLuRelationTypeKey, "luLuRelationTypeKey");

                 List<Clu> clus = luDao.getClusByRelation(relatedCluId,

                                 luLuRelationTypeKey);

                 List<CluInfo> result = LuServiceAssembler.toCluInfos(clus);

                 return result;

         }

         @Override

         public List<String> getCluIdsByRelation(String relatedCluId,

                         String luLuRelationTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(relatedCluId, "relatedCluId");

                 checkForMissingParameter(luLuRelationTypeKey, "luLuRelationTypeKey");

         List<String> cluIds = luDao.getCluIdsByRelatedCluId(relatedCluId, luLuRelationTypeKey);

         return cluIds;

         }

         @Override

         public List<CluInfo> getRelatedClusByCluId(String cluId,

                         String luLuRelationTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(cluId, "cluId");

                 checkForMissingParameter(luLuRelationTypeKey, "luLuRelationTypeKey");

                 List<Clu> relatedClus = luDao.getRelatedClusByCluId(cluId,

                                 luLuRelationTypeKey);

                 return LuServiceAssembler.toCluInfos(relatedClus);

         }

         @Override

         public List<String> getRelatedCluIdsByCluId(String cluId,

                         String luLuRelationTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(cluId, "cluId");

                 checkForMissingParameter(luLuRelationTypeKey, "luLuRelationTypeKey");

                 List<String> relatedCluIds = luDao.getRelatedCluIdsByCluId(cluId,

                                 luLuRelationTypeKey);

                 return relatedCluIds;

         }

         @Override

         public CluCluRelationInfo getCluCluRelation(String cluCluRelationId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(cluCluRelationId, "cluCluRelationId");

                 return LuServiceAssembler.toCluCluRelationInfo(luDao.fetch(

                                 CluCluRelation.class, cluCluRelationId));

         }

         @Override

         public List<CluCluRelationInfo> getCluCluRelationsByClu(String cluId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(cluId, "cluId");

                 List<CluCluRelation> cluCluRelations = luDao

                                 .getCluCluRelationsByClu(cluId);

                 return LuServiceAssembler.toCluCluRelationInfos(cluCluRelations);

         }

         // **** Publication

         @Override

         public List<CluPublicationInfo> getCluPublicationsByCluId(String cluId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

               checkForMissingParameter(cluId, "cluId");

               List<CluPublication> cluPublications = luDao.getCluPublicationsByCluId(cluId);

               return LuServiceAssembler.toCluPublicationInfos(cluPublications);

         }

         @Override

         public List<CluPublicationInfo> getCluPublicationsByType(

                         String luPublicationTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

               checkForMissingParameter(luPublicationTypeKey, "luPublicationTypeKey");

               List<CluPublication> cluPublications = luDao.getCluPublicationsByType(luPublicationTypeKey);

               return LuServiceAssembler.toCluPublicationInfos(cluPublications);

         }

         @Override

         public CluPublicationInfo getCluPublication(String cluPublicationId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

               checkForMissingParameter(cluPublicationId, "cluPublicationId");

               CluPublication cluPublication = luDao.fetch(CluPublication.class, cluPublicationId);

               return LuServiceAssembler.toCluPublicationInfo(cluPublication);

         }

         // **** Results

         @Override

         public CluResultInfo getCluResult(String cluResultId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(cluResultId, "cluResultId");

                 CluResult cluResult = luDao.fetch(CluResult.class, cluResultId);

                 return LuServiceAssembler.toCluResultInfo(cluResult);

         }

         @Override

         public List<CluResultInfo> getCluResultByClu(String cluId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(cluId, "cluId");

                 return LuServiceAssembler.toCluResultInfos(luDao

                                 .getCluResultByClu(cluId));

         }

         @Override

         public List<String> getCluIdsByResultUsageType(String resultUsageTypeKey)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 return luDao.getCluIdsByResultUsageType(resultUsageTypeKey);

         }

         @Override

         public List<String> getCluIdsByResultComponent(String resultComponentId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 return luDao.getCluIdsByResultComponentId(resultComponentId);

         }

         // **** Learning Objectives

         @Override

         public CluLoRelationInfo getCluLoRelation(String cluLoRelationId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException,

                         PermissionDeniedException {

                 checkForMissingParameter(cluLoRelationId, "cluLoRelationId");

                 CluLoRelation reltn = luDao.fetch(CluLoRelation.class, cluLoRelationId);

                 return LuServiceAssembler.toCluLoRelationInfo(reltn);

         }

         @Override

         public List<CluLoRelationInfo> getCluLoRelationsByClu(String cluId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(cluId, "cluId");

                 List<CluLoRelation> cluLoRelations = luDao

                                 .getCluLoRelationsByClu(cluId);

                 return LuServiceAssembler.toCluLoRelationInfos(cluLoRelations);

         }

         @Override

         public List<CluLoRelationInfo> getCluLoRelationsByLo(String loId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(loId, "loId");

                 List<CluLoRelation> cluLoRelations = luDao.getCluLoRelationsByLo(loId);

                 return LuServiceAssembler.toCluLoRelationInfos(cluLoRelations);

         }

         // *** Resources

         @Override

         public List<String> getResourceRequirementsForCluId(String cluId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

               throw new UnsupportedOperationException("Method not yet implemented!");

         }

         // *** Sets

         @Override

         public CluSetInfo getCluSetInfo(String cluSetId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException,

                         PermissionDeniedException {

                 checkForMissingParameter(cluSetId, "cluSetId");

                 CluSet cluSet = luDao.fetch(CluSet.class, cluSetId);

                 CluSetInfo cluSetInfo = LuServiceAssembler.toCluSetInfo(cluSet);

                 setMembershipQuerySearchResult(cluSetInfo);

                 return cluSetInfo;

         }

         @Override

         public CluSetTreeViewInfo getCluSetTreeView(String cluSetId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException,

                         PermissionDeniedException {

                 checkForMissingParameter(cluSetId, "cluSetId");

                 CluSetInfo cluSet = getCluSetInfo(cluSetId);

                 if (cluSet == null) {

                         return null;

                 }

                 CluSetTreeViewInfo cluSetTreeView = new CluSetTreeViewInfo();

                 getCluSetTreeViewHelper(cluSet, cluSetTreeView);

                 return cluSetTreeView;

         }

         /**

          * Go through the list of CluSets and retrieve all the information regarding child

          * Clu Sets and associated Clus

          *

          * @param cluSetInfo

          * @param cluSetTreeViewInfo

          * @throws DoesNotExistException

          * @throws InvalidParameterException

          * @throws MissingParameterException

          * @throws OperationFailedException

          * @throws PermissionDeniedException

          */

         private void getCluSetTreeViewHelper(CluSetInfo cluSetInfo,

                         CluSetTreeViewInfo cluSetTreeViewInfo) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {

                 cluSetTreeViewInfo.setName(cluSetInfo.getName());

                 cluSetTreeViewInfo.setDescr(cluSetInfo.getDescr());

                 cluSetTreeViewInfo.setEffectiveDate(cluSetInfo.getEffectiveDate());

                 cluSetTreeViewInfo.setExpirationDate(cluSetInfo.getExpirationDate());

                 cluSetTreeViewInfo.setAdminOrg(cluSetInfo.getAdminOrg());

                 cluSetTreeViewInfo.setIsReusable(cluSetInfo.getIsReusable());

                 cluSetTreeViewInfo.setIsReferenceable(cluSetInfo.getIsReferenceable());

                 cluSetTreeViewInfo.setMetaInfo(cluSetInfo.getMetaInfo());

                 cluSetTreeViewInfo.setAttributes(cluSetInfo.getAttributes());

                 cluSetTreeViewInfo.setType(cluSetInfo.getType());

                 cluSetTreeViewInfo.setState(cluSetInfo.getState());

                 cluSetTreeViewInfo.setId(cluSetInfo.getId());

                 if (!cluSetInfo.getCluSetIds().isEmpty()) {

                         for (String cluSetId : cluSetInfo.getCluSetIds()) {

                                 CluSetInfo subCluSet = getCluSetInfo(cluSetId);

                                 List<CluSetTreeViewInfo> cluSets =

                     cluSetTreeViewInfo.getCluSets() == null ?

                             new ArrayList<CluSetTreeViewInfo>(0) : cluSetTreeViewInfo.getCluSets();

                 CluSetTreeViewInfo subCluSetTreeViewInfo = new CluSetTreeViewInfo();

                 getCluSetTreeViewHelper(subCluSet, subCluSetTreeViewInfo);

                 cluSets.add(subCluSetTreeViewInfo);

                 cluSetTreeViewInfo.setCluSets(cluSets);

                         }

                 }

                 List<CluInfo> clus = new ArrayList<CluInfo>();

                 for (String cluId : cluSetInfo.getCluIds()) {

                         if(cluId!=null){

                 //Optimized version of clu translation. It seems like for now we only need the following information.

                 //If more information is needed, then appropriate method in assembler has to be used.

                 Clu clu = luDao.getCurrentCluVersion(cluId);

                 CluInfo cluInfo = new CluInfo();

                 cluInfo.setId(clu.getId());

                 cluInfo.setType(clu.getLuType().getId());

                 cluInfo.setOfficialIdentifier(LuServiceAssembler.toCluIdentifierInfo(clu.getOfficialIdentifier()));

                                 clus.add(cluInfo);

                         }

                 }

                 cluSetTreeViewInfo.setClus(clus);

         }

         @Override

         public List<CluSetInfo> getCluSetInfoByIdList(List<String> cluSetIdList)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException,

                         PermissionDeniedException {

                 checkForMissingParameter(cluSetIdList, "cluSetIdList");

                 checkForEmptyList(cluSetIdList, "cluSetIdList");

                 List<CluSet> cluSets = luDao.getCluSetInfoByIdList(cluSetIdList);

                 return LuServiceAssembler.toCluSetInfos(cluSets);

         }

         @Override

         public List<String> getCluSetIdsFromCluSet(String cluSetId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException,

                         PermissionDeniedException {

                 checkForMissingParameter(cluSetId, "cluSetId");

                 CluSet cluSet = luDao.fetch(CluSet.class, cluSetId);

                 List<String> ids = new ArrayList<String>(cluSet.getCluVerIndIds().size());

                 if(cluSet.getCluSets()!=null){

                         for (CluSet cluSet2 : cluSet.getCluSets()) {

                                 ids.add(cluSet2.getId());

                         }

                 }

                 return ids;

         }

         @Override

         public Boolean isCluSetDynamic(String cluSetId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException,

                         PermissionDeniedException {

               throw new UnsupportedOperationException("Method not yet implemented!");

         }

         @Override

         public List<CluInfo> getClusFromCluSet(String cluSetId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException,

                         PermissionDeniedException {

                 checkForMissingParameter(cluSetId, "cluSetId");

                 CluSet cluSet = luDao.fetch(CluSet.class, cluSetId);

                 List<CluInfo> clus = new ArrayList<CluInfo>(cluSet.getCluVerIndIds().size());

                 for (CluSetJoinVersionIndClu cluSetJnClu : cluSet.getCluVerIndIds()) {

                         clus.add(LuServiceAssembler.toCluInfo(luDao.getCurrentCluVersion(cluSetJnClu.getCluVersionIndId())));

                 }

                 return clus;

         }

         @Override

         public List<String> getCluIdsFromCluSet(String cluSetId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException,

                         PermissionDeniedException {

                 checkForMissingParameter(cluSetId, "cluSetId");

                 CluSet cluSet = luDao.fetch(CluSet.class, cluSetId);

                 List<String> ids = new ArrayList<String>(cluSet.getCluVerIndIds().size());

                 for (CluSetJoinVersionIndClu cluSetJnClu : cluSet.getCluVerIndIds()) {

                         ids.add(cluSetJnClu.getCluVersionIndId());

                 }

                 return ids;

         }

         @Override

         public List<CluInfo> getAllClusInCluSet(String cluSetId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException,

                         PermissionDeniedException {

                 checkForMissingParameter(cluSetId, "cluSetId");

                 List<String> cluIndIds = new ArrayList<String>();

                 CluSet cluSet = luDao.fetch(CluSet.class, cluSetId);

                 findClusInCluSet(cluIndIds, cluSet);

                 List<CluInfo> infos = new ArrayList<CluInfo>(cluIndIds.size());

                 for (String cluIndId : cluIndIds) {

                         infos.add(LuServiceAssembler.toCluInfo(luDao.getCurrentCluVersion(cluIndId)));

                 }

                 return infos;

         }

         @Override

         public List<String> getAllCluIdsInCluSet(String cluSetId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException,

                         PermissionDeniedException {

                 checkForMissingParameter(cluSetId, "cluSetId");

                 List<String> ids = new ArrayList<String>();

                 CluSet cluSet = luDao.fetch(CluSet.class, cluSetId);

                 findClusInCluSet(ids, cluSet);

                 return ids;

         }

         @Override

         public Boolean isCluInCluSet(String cluId, String cluSetId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException,

                         PermissionDeniedException {

                 checkForMissingParameter(cluId, "cluId");

                 checkForMissingParameter(cluSetId, "cluSetId");

                 return luDao.isCluInCluSet(cluId, cluSetId);

         }

         // ******** LUI OPERATIONS

         // *** Core

         @Override

         public LuiInfo getLui(String luiId) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(luiId, "luiId");

                 Lui lui = luDao.fetch(Lui.class, luiId);

                 return LuServiceAssembler.toLuiInfo(lui);

         }

         @Override

         public List<LuiInfo> getLuisByIdList(List<String> luiIdList)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(luiIdList, "luiIdList");

                 checkForEmptyList(luiIdList, "luiIdList");

                 List<Lui> luis = luDao.getLuisByIdList(luiIdList);

                 return LuServiceAssembler.toLuiInfos(luis);

         }

         @Override

         public List<LuiInfo> getLuisInAtpByCluId(String cluId, String atpKey)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

               throw new UnsupportedOperationException("Method not yet implemented!");

         }

         @Override

         public List<String> getLuiIdsByCluId(String cluId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(cluId, "cluId");

                 return luDao.getLuiIdsByCluId(cluId);

         }

         @Override

         public List<String> getLuiIdsInAtpByCluId(String cluId, String atpKey)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(cluId, "cluId");

                 checkForMissingParameter(atpKey, "atpKey");

                 return luDao.getLuiIdsInAtpByCluId(cluId, atpKey);

         }

         // *** Relations

         @Override

         public List<String> getAllowedLuLuRelationTypesByLuiId(String luiId,

                         String relatedLuiId) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(luiId, "luiId");

                 checkForMissingParameter(relatedLuiId, "relatedLuiId");

                 return luDao.getAllowedLuLuRelationTypesByLuiId(luiId, relatedLuiId);

         }

         @Override

         public List<LuiInfo> getLuisByRelation(String luiId,

                         String luLuRelationTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(luiId, "luiId");

                 checkForMissingParameter(luLuRelationTypeKey, "luLuRelationTypeKey");

                 return LuServiceAssembler.toLuiInfos(luDao.getLuisByRelationType(luiId,

                                 luLuRelationTypeKey));

         }

         @Override

         public List<String> getLuiIdsByRelation(String luiId,

                         String luLuRelationTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(luiId, "luiId");

                 checkForMissingParameter(luLuRelationTypeKey, "luLuRelationTypeKey");

                 return luDao.getLuiIdsByRelationType(luiId, luLuRelationTypeKey);

         }

         @Override

         public List<LuiInfo> getRelatedLuisByLuiId(String luiId,

                         String luLuRelationTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(luiId, "luiId");

                 checkForMissingParameter(luLuRelationTypeKey, "luLuRelationTypeKey");

                 List<Lui> relatedLuis = luDao.getRelatedLuisByLuiId(luiId,

                                 luLuRelationTypeKey);

                 return LuServiceAssembler.toLuiInfos(relatedLuis);

         }

         @Override

         public List<String> getRelatedLuiIdsByLuiId(String luiId,

                         String luLuRelationTypeKey) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(luiId, "luiId");

                 checkForMissingParameter(luLuRelationTypeKey, "luLuRelationTypeKey");

                 List<String> relatedLuiIds = luDao.getRelatedLuiIdsByLuiId(luiId,

                                 luLuRelationTypeKey);

                 return relatedLuiIds;

         }

         @Override

         public LuiLuiRelationInfo getLuiLuiRelation(String luiLuiRelationId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(luiLuiRelationId, "luiLuiRelationId");

                 LuiLuiRelation luiLuiRelation = luDao.fetch(LuiLuiRelation.class,

                                 luiLuiRelationId);

                 return LuServiceAssembler.toLuiLuiRelationInfo(luiLuiRelation);

         }

         @Override

         public List<LuiLuiRelationInfo> getLuiLuiRelationsByLui(String luiId)

                         throws DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException {

                 checkForMissingParameter(luiId, "luiId");

                 List<LuiLuiRelation> entities = luDao.getLuiLuiRelations(luiId);

                 return LuServiceAssembler.toLuiLuiRelationInfos(entities);

         }

         /**************************************************************************

          * MAINTENANCE OPERATIONS *

          **************************************************************************/

         @Override

         public List<ValidationResultInfo> validateClu(String validationType,

                         CluInfo cluInfo) throws DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException {

                 checkForMissingParameter(validationType, "validationType");

                 checkForMissingParameter(cluInfo, "cluInfo");

         ObjectStructureDefinition objStructure = this.getObjectStructure(CluInfo.class.getName());

         Validator defaultValidator = validatorFactory.getValidator();

         List<ValidationResultInfo> validationResults = defaultValidator.validateObject(cluInfo, objStructure);

         return validationResults;

         }

         @Override

         @Transactional(readOnly=false)

         public CluInfo createClu(String luTypeKey, CluInfo cluInfo)

                         throws AlreadyExistsException, DataValidationErrorException,

                         DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException,

                         PermissionDeniedException {

                 Clu clu = toCluForCreate(luTypeKey,cluInfo);

                 //Set current (since this is brand new and every verIndId needs one current)

                 if(clu.getVersion() == null){

                         clu.setVersion(new Version());

                 }

                 clu.getVersion().setCurrentVersionStart(new Date());

                 luDao.create(clu);

                 return LuServiceAssembler.toCluInfo(clu);

         }

         public Clu toCluForCreate(String luTypeKey, CluInfo cluInfo)

                         throws AlreadyExistsException, DataValidationErrorException,

                         DoesNotExistException, InvalidParameterException,

                         MissingParameterException, OperationFailedException,

                         PermissionDeniedException {

                 checkForMissingParameter(luTypeKey, "luTypeKey");

                 checkForMissingParameter(cluInfo, "cluInfo");

                 // Validate CLU

                 List<ValidationResultInfo> val = validateClu("SYSTEM", cluInfo);

                 if(null != val && val.size() > 0) {

                         throw new DataValidationErrorException("Validation error!", val);

                 }

                 Clu clu = new Clu();

                 LuType luType = luDao.fetch(LuType.class, luTypeKey);

                 clu.setLuType(luType);

                 if (cluInfo.getOfficialIdentifier() != null) {

                         clu.setOfficialIdentifier(LuServiceAssembler.createOfficialIdentifier(cluInfo, luDao));

                 }

                 clu.setAlternateIdentifiers(LuServiceAssembler.createAlternateIdentifiers(cluInfo, luDao));

                 if (cluInfo.getDescr() != null) {

                     LuRichText descr = LuServiceAssembler.toRichText(LuRichText.class, cluInfo.getDescr());

                     if (descr.getPlain() != null || descr.getFormatted() != null) {

                         clu.setDescr(descr);

                     }

                 }

                 if (clu.getAdminOrgs() == null) {

                         clu.setAdminOrgs(new ArrayList<CluAdminOrg>(0));

                 }

                 List<CluAdminOrg> adminOrgs = clu.getAdminOrgs();

                 for (AdminOrgInfo orgInfo : cluInfo.getAdminOrgs()) {

                         CluAdminOrg instructor = new CluAdminOrg();

                         BeanUtils.copyProperties(orgInfo, instructor,

                                         new String[] { "attributes" });

                         instructor.setAttributes(LuServiceAssembler.toGenericAttributes(

                                         CluAdminOrgAttribute.class, orgInfo.getAttributes(),

                                         instructor, luDao));

                         instructor.setClu(clu);

                         adminOrgs.add(instructor);

                 }

                 if (cluInfo.getPrimaryInstructor() != null) {

                         CluInstructor primaryInstructor = new CluInstructor();

                         BeanUtils.copyProperties(cluInfo.getPrimaryInstructor(),

                                         primaryInstructor, new String[] { "attributes" });

                         primaryInstructor.setAttributes(LuServiceAssembler

                                         .toGenericAttributes(CluInstructorAttribute.class, cluInfo

                                                         .getPrimaryInstructor().getAttributes(),

                                                         primaryInstructor, luDao));

                         clu.setPrimaryInstructor(primaryInstructor);

                 }

                 if (clu.getInstructors() == null) {

                         clu.setInstructors(new ArrayList<CluInstructor>(0));

                 }

                 List<CluInstructor> instructors = clu.getInstructors();

                 for (CluInstructorInfo instructorInfo : cluInfo.getInstructors()) {

                         CluInstructor instructor = new CluInstructor();

                         BeanUtils.copyProperties(instructorInfo, instructor,

                                         new String[] { "attributes" });

                         instructor.setAttributes(LuServiceAssembler.toGenericAttributes(

                                         CluInstructorAttribute.class, instructorInfo

                                                         .getAttributes(), instructor, luDao));

                         instructors.add(instructor);

                 }

                 if (cluInfo.getStdDuration() != null) {

                         clu.setStdDuration(LuServiceAssembler.toTimeAmount(cluInfo

                                         .getStdDuration()));

                 }

                 if (clu.getLuCodes() == null) {

                         clu.setLuCodes(new ArrayList<LuCode>(0));

                 }

                 List<LuCode> luCodes = clu.getLuCodes();

                 for (LuCodeInfo luCodeInfo : cluInfo.getLuCodes()) {

                         LuCode luCode = new LuCode();

                         luCode.setAttributes(LuServiceAssembler.toGenericAttributes(

                                         LuCodeAttribute.class, luCodeInfo.getAttributes(), luCode,

                                         luDao));

                         BeanUtils.copyProperties(luCodeInfo, luCode, new String[] {

                                         "attributes", "metaInfo" });

                         luCode.setDescr(luCodeInfo.getDescr());

                         luCode.setClu(clu);

                         luCodes.add(luCode);

                 }

                 if (clu.getOfferedAtpTypes() == null) {

                         clu.setOfferedAtpTypes(new ArrayList<CluAtpTypeKey>(0));

                 }

                 List<CluAtpTypeKey> offeredAtpTypes = clu.getOfferedAtpTypes();

                 for (String atpTypeKey : cluInfo.getOfferedAtpTypes()) {

                         CluAtpTypeKey cluAtpTypeKey = new CluAtpTypeKey();

                         cluAtpTypeKey.setAtpTypeKey(atpTypeKey);

                         cluAtpTypeKey.setClu(clu);

                         offeredAtpTypes.add(cluAtpTypeKey);

                 }

                 // FEE INFO

                 if (cluInfo.getFeeInfo() != null) {

                         CluFee cluFee = null;

                         try {

                                 cluFee = LuServiceAssembler.toCluFee(clu, false, cluInfo

                                                 .getFeeInfo(), luDao);

                         } catch (VersionMismatchException e) {

                                 // Version Mismatch Should Happen only for updates

                         }

                         clu.setFee(cluFee);

                 }

                 if (cluInfo.getAccountingInfo() != null) {

                         CluAccounting cluAccounting = new CluAccounting();

                         cluAccounting.setAttributes(LuServiceAssembler.toGenericAttributes(

                                         CluAccountingAttribute.class, cluInfo.getAccountingInfo()

                                                         .getAttributes(), cluAccounting, luDao));

                         cluAccounting.setAffiliatedOrgs(LuServiceAssembler

                                         .toAffiliatedOrgs(false, cluAccounting.getAffiliatedOrgs(),

                                                         cluInfo.getAccountingInfo().getAffiliatedOrgs(),

                                                         luDao));

                         clu.setAccounting(cluAccounting);

                 }

                 clu.setAttributes(LuServiceAssembler.toGenericAttributes(

                                 CluAttribute.class, cluInfo.getAttributes(), clu, luDao));

                 if (cluInfo.getIntensity() != null) {

                         clu.setIntensity(LuServiceAssembler

                                         .toAmount(cluInfo.getIntensity()));

                 }

                 if (clu.getCampusLocations() == null) {

                         clu.setCampusLocations(new ArrayList<CluCampusLocation>(0));

                 }

                 List<CluCampusLocation> locations = clu.getCampusLocations();

                 for (String locationName : cluInfo.getCampusLocations()) {

                         CluCampusLocation location = new CluCampusLocation();

                         location.setCampusLocation(locationName);

                         location.setClu(clu);

                         locations.add(location);

                 }

                 if (clu.getAccreditations() == null) {

                         clu.setAccreditations(new ArrayList<CluAccreditation>(0));

                 }

                 List<CluAccreditation> accreditations = clu.getAccreditations();

                 for (AccreditationInfo accreditationInfo : cluInfo.getAccreditations()) {

                         CluAccreditation accreditation = new CluAccreditation();

                         BeanUtils.copyProperties(accreditationInfo, accreditation,

                                         new String[] { "attributes" });

                         accreditation.setAttributes(LuServiceAssembler.toGenericAttributes(

                                         CluAccreditationAttribute.class, accreditationInfo

                                                         .getAttributes(), accreditation, luDao));

                         accreditations.add(accreditation);

                 }

                 // Now copy all not standard properties

                 BeanUtils.copyProperties(cluInfo, clu, new String[] { "luType",

                                 "officialIdentifier", "alternateIdentifiers", "descr",

                                 "luCodes", "primaryInstructor", "instructors", "stdDuration",

                                 "offeredAtpTypes", "feeInfo", "accountingInfo", "attributes",

                                 "metaInfo", "versionInfo", "intensity",

                                 "campusLocations", "accreditations",

                                 "adminOrgs" });

                 return clu;

         }

         @Override

         @Transactional(readOnly=false)

         public CluInfo updateClu(String cluId, CluInfo cluInfo)

                         throws DataValidationErrorException, DoesNotExistException,

                         InvalidParameterException, MissingParameterException,

                         OperationFailedException, PermissionDeniedException,

                         VersionMismatchException {

                 checkForMissingParameter(cluId, "cluId");

                 checkForMissingParameter(cluInfo, "cluInfo");

                 // Validate CLU

                 List<ValidationResultInfo> val = validateClu("SYSTEM", cluInfo);

                 if(null != val && val.size() > 0) {

                         throw new DataValidationErrorException("Validation error!", val);

                 }

                 Clu clu = luDao.fetch(Clu.class, cluId);

                 if (!String.valueOf(clu.getVersionNumber()).equals(

                                 cluInfo.getMetaInfo().getVersionInd())) {

                         throw new VersionMismatchException(

                                         "Clu to be updated is not the current version");

                 }

                 LuType luType = luDao.fetch(LuType.class, cluInfo.getType());

                 clu.setLuType(luType);

                 if (cluInfo.getOfficialIdentifier() != null) {

                     LuServiceAssembler.updateOfficialIdentifier(clu, cluInfo, luDao);

                 } else if (clu.getOfficialIdentifier() != null) {

                         luDao.delete(clu.getOfficialIdentifier());

                 }

                 // Update the list of Alternate Identifiers

                 // Get a map of Id->object of all the currently persisted objects in the

                 // list

                 Map<String, CluIdentifier> oldAltIdMap = new HashMap<String, CluIdentifier>();

                 LuServiceAssembler.updateAlternateIdentifier(oldAltIdMap, clu, cluInfo, luDao);

                 // Now delete anything left over

                 for (Entry<String, CluIdentifier> entry : oldAltIdMap.entrySet()) {

                         luDao.delete(entry.getValue());

                 }

                 if (cluInfo.getDescr() != null && (cluInfo.getDescr().getPlain() != null || cluInfo.getDescr().getFormatted() != null)) {

                         if (clu.getDescr() == null) {

                                 clu.setDescr(new LuRichText());

                         }

                         BeanUtils.copyProperties(cluInfo.getDescr(), clu.getDescr());

                 } else if (clu.getDescr() != null) {

                         luDao.delete(clu.getDescr());

                         clu.setDescr(null);//TODO is the is the best method of doing this? what if the user passes in a new made up id, does that mean we have orphaned richtexts?

                 }

                 if (cluInfo.getPrimaryInstructor() != null) {

                         if (clu.getPrimaryInstructor() == null) {

                                 clu.setPrimaryInstructor(new CluInstructor());

                         }

                         BeanUtils.copyProperties(cluInfo.getPrimaryInstructor(), clu

                                         .getPrimaryInstructor(), new String[] { "attributes" });

                         clu.getPrimaryInstructor().setAttributes(

                                         LuServiceAssembler.toGenericAttributes(

                                                         CluInstructorAttribute.class, cluInfo

                                                                         .getPrimaryInstructor().getAttributes(),

                                                         clu.getPrimaryInstructor(), luDao));

                 } else if (clu.getPrimaryInstructor() != null) {

                         luDao.delete(clu.getPrimaryInstructor());

                 }

                 // Update the List of instructors

                 // Get a map of Id->object of all the currently persisted objects in the

                 // list

                 Map<String, CluInstructor> oldInstructorMap = new HashMap<String, CluInstructor>();

                 for (CluInstructor cluInstructor : clu.getInstructors()) {

                         oldInstructorMap.put(cluInstructor.getOrgId() + "_"

                                         + cluInstructor.getPersonId(), cluInstructor);

                 }

                 clu.getInstructors().clear();

                 // Loop through the new list, if the item exists already update and

                 // remove from the list

                 // otherwise create a new entry

                 for (CluInstructorInfo instructorInfo : cluInfo.getInstructors()) {

                         CluInstructor cluInstructor = oldInstructorMap

                                         .remove(instructorInfo.getOrgId() + "_"

                                                         + instructorInfo.getPersonId());

                         if (cluInstructor == null) {

                                 cluInstructor = new CluInstructor();

                         }

                         // Do Copy

                         BeanUtils.copyProperties(instructorInfo, cluInstructor,

                                         new String[] { "attributes" });

                         cluInstructor.setAttributes(LuServiceAssembler.toGenericAttributes(

                                         CluInstructorAttribute.class, instructorInfo

                                                         .getAttributes(), cluInstructor, luDao));

                         clu.getInstructors().add(cluInstructor);

                 }

                 // Now delete anything left over

                 for (Entry<String, CluInstructor> entry : oldInstructorMap.entrySet()) {

                         luDao.delete(entry.getValue());

                 }

                 if (cluInfo.getStdDuration() != null) {

                         if (clu.getStdDuration() == null) {

                                 clu.setStdDuration(new TimeAmount());

                         }

                         BeanUtils.copyProperties(cluInfo.getStdDuration(), clu

                                         .getStdDuration());

                 } else if (clu.getStdDuration() != null) {

                         luDao.delete(clu.getStdDuration());

                 }

                 // Update the LuCodes

                 // Get a map of Id->object of all the currently persisted objects in the

                 // list

                 Map<String, LuCode> oldLuCodeMap = new HashMap<String, LuCode>();

                 for (LuCode luCode : clu.getLuCodes()) {

                         oldLuCodeMap.put(luCode.getId(), luCode);

                 }

                 clu.getLuCodes().clear();

                 // Loop through the new list, if the item exists already update and

                 // remove from the list

                 // otherwise create a new entry

                 for (LuCodeInfo luCodeInfo : cluInfo.getLuCodes()) {

                         LuCode luCode = oldLuCodeMap.remove(luCodeInfo.getId());

                         if (luCode == null) {

                                 luCode = new LuCode();

                         } else {

                                 if (!String.valueOf(luCode.getVersionNumber()).equals(

                                                 luCodeInfo.getMetaInfo().getVersionInd())) {

                                         throw new VersionMismatchException(

                                                         "LuCode to be updated is not the current version");

                                 }

                         }

                         // Do Copy

                         luCode.setAttributes(LuServiceAssembler.toGenericAttributes(

                                         LuCodeAttribute.class, luCodeInfo.getAttributes(), luCode,

                                         luDao));

                         BeanUtils.copyProperties(luCodeInfo, luCode, new String[] {

                                         "attributes", "metaInfo" });

                         luCode.setDescr(luCodeInfo.getDescr());

                         luCode.setClu(clu);

                         clu.getLuCodes().add(luCode);

                 }

                 // Now delete anything left over

                 for (Entry<String, LuCode> entry : oldLuCodeMap.entrySet()) {

                         luDao.delete(entry.getValue());

                 }

                 // Update the list of AtpTypeKeys

                 // Get a map of Id->object of all the currently persisted objects in the

                 // list

                 Map<String, CluAtpTypeKey> oldOfferedAtpTypesMap = new HashMap<String, CluAtpTypeKey>();

                 for (CluAtpTypeKey cluAtpTypeKey : clu.getOfferedAtpTypes()) {

                         oldOfferedAtpTypesMap.put(cluAtpTypeKey.getAtpTypeKey(),

                                         cluAtpTypeKey);

                 }

                 clu.getOfferedAtpTypes().clear();

                 // Loop through the new list, if the item exists already update and

                 // remove from the list

                 // otherwise create a new entry

                 for (String atpTypeKey : cluInfo.getOfferedAtpTypes()) {

                         CluAtpTypeKey cluAtpTypeKey = oldOfferedAtpTypesMap

                                         .remove(atpTypeKey);

                         if (cluAtpTypeKey == null) {

                                 cluAtpTypeKey = new CluAtpTypeKey();

                         }

                         // Do Copy

                         cluAtpTypeKey.setAtpTypeKey(atpTypeKey);

                         cluAtpTypeKey.setClu(clu);

                         clu.getOfferedAtpTypes().add(cluAtpTypeKey);

                 }

                 // Now delete anything left over

                 for (Entry<String, CluAtpTypeKey> entry : oldOfferedAtpTypesMap

                                 .entrySet()) {

                         luDao.delete(entry.getValue());

                 }

                 if (cluInfo.getFeeInfo() != null) {

                         if (clu.getFee() == null) {

                                 clu.setFee(LuServiceAssembler.toCluFee(clu, false, cluInfo

                                                 .getFeeInfo(), luDao));

                         } else {

                                 clu.setFee(LuServiceAssembler.toCluFee(clu, true, cluInfo

                                                 .getFeeInfo(), luDao));

                         }