/**

  * 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.enrollment.class1.lu.service.impl;

 import java.util.ArrayList;

 import java.util.Collections;

 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.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.DtoConstants;

 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.search.dto.SearchRequest;

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

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

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

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

 import org.kuali.student.enrollment.class1.lui.service.impl.LuServiceAssembler;

 import org.kuali.student.enrollment.courseoffering.service.R1ToR2CopyHelper;

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

 import org.kuali.student.r2.lum.clu.dto.AffiliatedOrgInfo;

 import org.kuali.student.r2.lum.clu.dto.CluCluRelationInfo;

 import org.kuali.student.r2.lum.clu.dto.CluFeeRecordInfo;

 import org.kuali.student.r2.lum.clu.dto.CluIdentifierInfo;

 import org.kuali.student.r2.lum.clu.dto.CluInfo;

 import org.kuali.student.r2.lum.clu.dto.CluLoRelationInfo;

 import org.kuali.student.r2.lum.clu.dto.CluResultInfo;

 import org.kuali.student.r2.lum.clu.dto.CluSetInfo;

 import org.kuali.student.r2.lum.clu.dto.CluSetTreeViewInfo;

 import org.kuali.student.r2.lum.clu.dto.LuCodeInfo;

 import org.kuali.student.r2.lum.clu.dto.MembershipQueryInfo;

 import org.kuali.student.r2.lum.clu.dto.ResultOptionInfo;

 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.MembershipQuery;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 import org.kuali.student.r2.core.search.dto.SearchRequestInfo;

 import org.kuali.student.r2.core.search.dto.SearchResultCellInfo;

 import org.kuali.student.r2.core.search.dto.SearchResultInfo;

 import org.kuali.student.r2.core.search.dto.SearchResultRowInfo;

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

 import org.kuali.student.r2.core.versionmanagement.dto.VersionDisplayInfo;

 import org.kuali.student.r2.lum.clu.dto.AccreditationInfo;

 import org.kuali.student.r2.lum.clu.dto.AdminOrgInfo;

 import org.kuali.student.r2.lum.clu.dto.CluInstructorInfo;

 import org.kuali.student.r2.lum.clu.dto.CluPublicationInfo;

 import org.kuali.student.r2.lum.clu.dto.FieldInfo;

 import org.kuali.student.r2.lum.clu.service.CluService;

 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 CluServiceImpl implements CluService {

     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";

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

     private LuDao luDao;

     private ValidatorFactory validatorFactory;

     private DictionaryService dictionaryServiceDelegate;

     private SearchDispatcher searchDispatcher;

     public void setDictionaryServiceDelegate(

             DictionaryService dictionaryServiceDelegate) {

         this.dictionaryServiceDelegate = dictionaryServiceDelegate;

     }

     public DictionaryService getDictionaryServiceDelegate() {

         return dictionaryServiceDelegate;

     }

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

      * SETUP OPERATION *

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

     @Override

     public List<TypeInfo> getDeliveryMethodTypes(ContextInfo context)

             throws OperationFailedException {

         return LuServiceAssembler.toDeliveryMethodTypeInfos(luDao.find(DeliveryMethodType.class));

     }

     @Override

     public TypeInfo getDeliveryMethodType(

             String deliveryMethodTypeKey, ContextInfo context) throws DoesNotExistException,

             InvalidParameterException, MissingParameterException,

             OperationFailedException {

         checkForMissingParameter(deliveryMethodTypeKey, "deliveryMethodTypeKey");

         try {

             return LuServiceAssembler.toDeliveryMethodTypeInfo(luDao.fetch(

                     DeliveryMethodType.class, deliveryMethodTypeKey));

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(deliveryMethodTypeKey);

         }

     }

     @Override

     public List<TypeInfo> getInstructionalFormatTypes(ContextInfo context)

             throws OperationFailedException {

         return LuServiceAssembler.toInstructionalFormatTypeInfos(luDao.find(InstructionalFormatType.class));

     }

     @Override

     public TypeInfo getInstructionalFormatType(

             String instructionalFormatTypeKey, ContextInfo context) throws DoesNotExistException,

             InvalidParameterException, MissingParameterException,

             OperationFailedException {

         checkForMissingParameter(instructionalFormatTypeKey,

                 "instructionalFormatTypeKey");

         try {

             return LuServiceAssembler.toInstructionalFormatTypeInfo(luDao.fetch(

                     InstructionalFormatType.class, instructionalFormatTypeKey));

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(instructionalFormatTypeKey);

         }

     }

     @Override

     public List<TypeInfo> getLuTypes(ContextInfo context) throws OperationFailedException {

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

     }

     @Override

     public TypeInfo getLuType(String luTypeKey, ContextInfo context) throws DoesNotExistException,

             InvalidParameterException, MissingParameterException,

             OperationFailedException {

         checkForMissingParameter(luTypeKey, "luTypeKey");

         try {

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

                     luTypeKey));

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(luTypeKey);

         }

     }

     @Override

     public TypeInfo getLuCodeType(String luCodeTypeKey, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         try {

             checkForMissingParameter(luCodeTypeKey, "luCodeTypeKey");

             return LuServiceAssembler.toLuCodeTypeInfo(luDao.fetch(

                     LuCodeType.class, luCodeTypeKey));

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(luCodeTypeKey);

         }

     }

     @Override

     public List<TypeInfo> getLuCodeTypes(ContextInfo context)

             throws OperationFailedException {

         return LuServiceAssembler.toLuCodeTypeInfos(luDao.find(LuCodeType.class));

     }

     @Override

     public List<TypeInfo> getCluCluRelationTypes(ContextInfo context)

             throws OperationFailedException {

         return LuServiceAssembler.toLuLuRelationTypeInfos(luDao.find(LuLuRelationType.class));

     }

     @Override

     public TypeInfo getLuLuRelationType(String luLuRelationTypeKey, ContextInfo context)

             throws OperationFailedException, MissingParameterException,

             DoesNotExistException {

         checkForMissingParameter(luLuRelationTypeKey, "luLuRelationTypeKey");

         LuLuRelationType luLuRelationType;

         try {

             luLuRelationType = luDao.fetch(LuLuRelationType.class,

                     luLuRelationTypeKey);

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(luLuRelationTypeKey);

         }

         return LuServiceAssembler.toLuLuRelationTypeInfo(luLuRelationType);

     }

     @Override

     public List<String> getAllowedLuLuRelationTypesForLuType(String luTypeKey,

             String relatedLuTypeKey, ContextInfo context) throws DoesNotExistException,

             InvalidParameterException, MissingParameterException,

             OperationFailedException {

         checkForMissingParameter(luTypeKey, "luTypeKey");

         checkForMissingParameter(relatedLuTypeKey, "relatedLuTypeKey");

         return luDao.getAllowedLuLuRelationTypesForLuType(luTypeKey,

                 relatedLuTypeKey);

     }

     @Override

     public List<TypeInfo> getLuPublicationTypes(ContextInfo context)

             throws OperationFailedException {

         return LuServiceAssembler.toLuPublicationTypeInfos(luDao.find(LuPublicationType.class));

     }

     @Override

     public TypeInfo getLuPublicationType(

             String luPublicationTypeKey, ContextInfo context) throws DoesNotExistException,

             InvalidParameterException, MissingParameterException,

             OperationFailedException {

         checkForMissingParameter(luPublicationTypeKey, "luPublicationTypeKey");

         try {

             return LuServiceAssembler.toLuPublicationTypeInfo(luDao.fetch(

                     LuPublicationType.class, luPublicationTypeKey));

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(luPublicationTypeKey);

         }

     }

     @Override

     public List<String> getLuPublicationTypesForLuType(String luTypeKey, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         throw new UnsupportedOperationException("getLuPublicationTypesForLuType");

     }

     @Override

     public List<TypeInfo> getCluResultTypes(ContextInfo context)

             throws OperationFailedException {

         return LuServiceAssembler.toCluResultTypeInfos(luDao.find(CluResultType.class));

     }

     @Override

     public TypeInfo getCluResultType(String cluResultTypeKey, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         try {

             return LuServiceAssembler.toCluResultTypeInfo(luDao.fetch(

                     CluResultType.class, cluResultTypeKey));

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(cluResultTypeKey);

         }

     }

     @Override

     public List<TypeInfo> getCluResultTypesForLuType(String luTypeKey, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         checkForMissingParameter(luTypeKey, "luTypeKey");

         return LuServiceAssembler.toCluResultTypeInfos((luDao.getAllowedCluResultTypesForLuType(luTypeKey)));

     }

     @Override

     public List<TypeInfo> getResultUsageTypes(ContextInfo context)

             throws OperationFailedException {

         return LuServiceAssembler.toResultUsageTypeInfos(luDao.find(ResultUsageType.class));

     }

     @Override

     public TypeInfo getResultUsageType(String resultUsageTypeKey, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         checkForMissingParameter(resultUsageTypeKey, "resultUsageTypeKey");

         try {

             return LuServiceAssembler.toResultUsageTypeInfo(luDao.fetch(

                     ResultUsageType.class, resultUsageTypeKey));

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(resultUsageTypeKey);

         }

     }

     @Override

     public List<String> getAllowedResultUsageTypesForLuType(String luTypeKey, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         checkForMissingParameter(luTypeKey, "luTypeKey");

         return luDao.getAllowedResultUsageTypesForLuType(luTypeKey);

     }

     @Override

     public List<String> getAllowedResultComponentTypesForResultUsageType(

             String resultUsageTypeKey, ContextInfo context) throws DoesNotExistException,

             InvalidParameterException, MissingParameterException,

             OperationFailedException {

         checkForMissingParameter(resultUsageTypeKey, "resultUsageTypeKey");

         return luDao.getAllowedResultComponentTypesForResultUsageType(resultUsageTypeKey);

     }

     @Override

     public TypeInfo getCluLoRelationType(

             String cluLoRelationTypeKey, ContextInfo context) throws DoesNotExistException,

             InvalidParameterException, MissingParameterException,

             OperationFailedException {

         checkForMissingParameter(cluLoRelationTypeKey, "cluLoRelationTypeKey");

         CluLoRelationType cluLoRelationType;

         try {

             cluLoRelationType = luDao.fetch(

                     CluLoRelationType.class, cluLoRelationTypeKey);

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(cluLoRelationTypeKey);

         }

         return LuServiceAssembler.toCluLoRelationTypeInfo(cluLoRelationType);

     }

     @Override

     public List<TypeInfo> getCluLoRelationTypes(ContextInfo context)

             throws OperationFailedException {

         return LuServiceAssembler.toCluLoRelationTypeInfos(luDao.find(CluLoRelationType.class));

     }

     @Override

     public List<String> getAllowedCluLoRelationTypesForLuType(String luTypeKey, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         checkForMissingParameter(luTypeKey, luTypeKey);

         return luDao.getAllowedCluLoRelationTypesForLuType(luTypeKey);

     }

     @Override

     public List<TypeInfo> getCluSetTypes(ContextInfo context)

             throws OperationFailedException {

         return LuServiceAssembler.toCluSetTypeInfos(luDao.find(CluSetType.class));

     }

     @Override

     public TypeInfo getCluSetType(String cluSetTypeKey, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         checkForMissingParameter(cluSetTypeKey, "cluSetTypeKey");

         try {

             return LuServiceAssembler.toCluSetTypeInfo(luDao.fetch(

                     CluSetType.class, cluSetTypeKey));

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(cluSetTypeKey);

         }

     }

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

      * READ OPERATION *

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

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

     @Override

     public CluInfo getClu(String cluId, ContextInfo context) throws DoesNotExistException,

             InvalidParameterException, MissingParameterException,

             OperationFailedException {

         checkForMissingParameter(cluId, "cluId");

         Clu clu;

         try {

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

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(cluId);

         }

         return LuServiceAssembler.toCluInfo(clu);

     }

     @Override

     public List<CluInfo> getClusByIds(List<String> cluIds, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         checkForMissingParameter(cluIds, "cluIds");

         checkForEmptyList(cluIds, "cluIds");

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

         return LuServiceAssembler.toCluInfos(clus);

     }

     @Override

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

             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, ContextInfo context)

             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> getAllowedCluCluRelationTypesByClu(String cluId,

             String relatedCluId, ContextInfo context) throws DoesNotExistException,

             InvalidParameterException, MissingParameterException,

             OperationFailedException {

         checkForMissingParameter(cluId, "cluId");

         checkForMissingParameter(relatedCluId, "relatedCluId");

         return luDao.getAllowedLuLuRelationTypesByCluId(cluId, relatedCluId);

     }

     @Override

     public List<CluInfo> getClusByRelatedCluAndRelationType(String relatedCluId,

             String luLuRelationTypeKey, ContextInfo context) 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> getCluIdsByRelatedCluAndRelationType(String relatedCluId,

             String cluCluRelationTypeKey,

             ContextInfo contextInfo)

             throws DoesNotExistException,

             InvalidParameterException,

             MissingParameterException,

             OperationFailedException,

             PermissionDeniedException {

         checkForMissingParameter(relatedCluId, "relatedCluId");

         checkForMissingParameter(cluCluRelationTypeKey, "cluCluRelationTypeKey");

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

         return cluIds;

     }

     @Override

     public List<CluInfo> getRelatedClusByCluAndRelationType(String relatedCluId,

             String cluCLuRelationTypeKey,

             ContextInfo contextInfo)

             throws DoesNotExistException,

             InvalidParameterException,

             MissingParameterException,

             OperationFailedException,

             PermissionDeniedException {

         checkForMissingParameter(relatedCluId, "cluId");

         checkForMissingParameter(cluCLuRelationTypeKey, "cluCLuRelationTypeKey");

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

                 cluCLuRelationTypeKey);

         return LuServiceAssembler.toCluInfos(relatedClus);

     }

     @Override

     public List<String> getRelatedCluIdsByCluAndRelationType(String cluId,

             String luLuRelationTypeKey, ContextInfo context) 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, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         checkForMissingParameter(cluCluRelationId, "cluCluRelationId");

         try {

             return LuServiceAssembler.toCluCluRelationInfo(luDao.fetch(

                     CluCluRelation.class, cluCluRelationId));

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(cluCluRelationId);

         }

     }

     @Override

     public List<CluCluRelationInfo> getCluCluRelationsByClu(String cluId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         checkForMissingParameter(cluId, "cluId");

         List<CluCluRelation> cluCluRelations = luDao.getCluCluRelationsByClu(cluId);

         return LuServiceAssembler.toCluCluRelationInfos(cluCluRelations);

     }

     // **** Publication

     @Override

     public List<CluPublicationInfo> getCluPublicationsByClu(String cluId, ContextInfo context)

             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, ContextInfo context) throws DoesNotExistException,

             InvalidParameterException, MissingParameterException,

             OperationFailedException {

         checkForMissingParameter(luPublicationTypeKey, "luPublicationTypeKey");

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

         return LuServiceAssembler.toCluPublicationInfos(cluPublications);

     }

     @Override

     public CluPublicationInfo getCluPublication(String cluPublicationId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         checkForMissingParameter(cluPublicationId, "cluPublicationId");

         CluPublication cluPublication;

         try {

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

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(cluPublicationId);

         }

         return LuServiceAssembler.toCluPublicationInfo(cluPublication);

     }

     // **** Results

     @Override

     public CluResultInfo getCluResult(String cluResultId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         checkForMissingParameter(cluResultId, "cluResultId");

         CluResult cluResult;

         try {

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

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(cluResultId);

         }

         return LuServiceAssembler.toCluResultInfo(cluResult);

     }

     @Override

     public List<CluResultInfo> getCluResultByClu(String cluId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         checkForMissingParameter(cluId, "cluId");

         return LuServiceAssembler.toCluResultInfos(luDao.getCluResultByClu(cluId));

     }

     @Override

     public List<String> getCluIdsByResultUsageType(String resultUsageTypeKey, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         return luDao.getCluIdsByResultUsageType(resultUsageTypeKey);

     }

     @Override

     public List<String> getCluIdsByResultComponent(String resultComponentId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         return luDao.getCluIdsByResultComponentId(resultComponentId);

     }

     // **** Learning Objectives

     @Override

     public CluLoRelationInfo getCluLoRelation(String cluLoRelationId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         checkForMissingParameter(cluLoRelationId, "cluLoRelationId");

         CluLoRelation reltn;

         try {

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

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(cluLoRelationId);

         }

         return LuServiceAssembler.toCluLoRelationInfo(reltn);

     }

     @Override

     public List<CluLoRelationInfo> getCluLoRelationsByClu(String cluId, ContextInfo context)

             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, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         checkForMissingParameter(loId, "loId");

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

         return LuServiceAssembler.toCluLoRelationInfos(cluLoRelations);

     }

     // *** Resources

     @Override

     public List<String> getResourceRequirementsForClu(String cluId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException {

         return new ArrayList<String>();

     }

     // *** Sets

     @Override

     public CluSetInfo getCluSet(String cluSetId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         checkForMissingParameter(cluSetId, "cluSetId");

         CluSet cluSet;

         try {

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

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(cluSetId);

         }

         CluSetInfo cluSetInfo = LuServiceAssembler.toCluSetInfo(cluSet);

         setMembershipQuerySearchResult(cluSetInfo);

         return cluSetInfo;

     }

     @Override

     public CluSetTreeViewInfo getCluSetTreeView(String cluSetId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         checkForMissingParameter(cluSetId, "cluSetId");

         CluSetInfo cluSet = getCluSet(cluSetId, context);

         if (cluSet == null) {

             return null;

         }

         CluSetTreeViewInfo cluSetTreeView = new CluSetTreeViewInfo();

         getCluSetTreeViewHelper(cluSet, cluSetTreeView, context);

         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, ContextInfo context) 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.setMeta(cluSetInfo.getMeta());

         cluSetTreeViewInfo.setAttributes(cluSetInfo.getAttributes());

         cluSetTreeViewInfo.setTypeKey(cluSetInfo.getTypeKey());

         cluSetTreeViewInfo.setStateKey(cluSetInfo.getStateKey());

         cluSetTreeViewInfo.setId(cluSetInfo.getId());

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

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

                 CluSetInfo subCluSet = getCluSet(cluSetId, context);

                 List<CluSetTreeViewInfo> cluSets =

                         cluSetTreeViewInfo.getCluSets() == null

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

                 CluSetTreeViewInfo subCluSetTreeViewInfo = new CluSetTreeViewInfo();

                 getCluSetTreeViewHelper(subCluSet, subCluSetTreeViewInfo, context);

                 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> getCluSetsByIds(List<String> cluSetIds, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         checkForMissingParameter(cluSetIds, "cluSetIds");

         checkForEmptyList(cluSetIds, "cluSetIds");

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

         return LuServiceAssembler.toCluSetInfos(cluSets);

     }

     @Override

     public List<String> getCluSetIdsFromCluSet(String cluSetId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         checkForMissingParameter(cluSetId, "cluSetId");

         CluSet cluSet;

         try {

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

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(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, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         return null;

     }

     @Override

     public List<CluInfo> getClusFromCluSet(String cluSetId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         checkForMissingParameter(cluSetId, "cluSetId");

         CluSet cluSet;

         try {

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

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(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, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         checkForMissingParameter(cluSetId, "cluSetId");

         CluSet cluSet;

         try {

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

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(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, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         checkForMissingParameter(cluSetId, "cluSetId");

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

         CluSet cluSet;

         try {

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

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(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;

     }

     private void findClusInCluSet(List<String> clus, CluSet parentCluSet)

             throws DoesNotExistException {

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

         doFindClusInCluSet(processedCluSetIds, clus, parentCluSet);

     }

     private void doFindClusInCluSet(List<String> processedCluSetIds,

             List<String> clus, CluSet parentCluSet) {

         for (CluSetJoinVersionIndClu join : parentCluSet.getCluVerIndIds()) {

             if (!clus.contains(join.getCluVersionIndId())) {

                 clus.add(join.getCluVersionIndId());

             }

         }

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

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

                 // This condition avoIds infinite recursion problem

                 if (!processedCluSetIds.contains(cluSet.getId())) {

                     processedCluSetIds.add(cluSet.getId());

                     doFindClusInCluSet(processedCluSetIds, clus, cluSet);

                 }

             }

         }

     }

     @Override

     public List<String> getAllCluIdsInCluSet(String cluSetId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         checkForMissingParameter(cluSetId, "cluSetId");

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

         CluSet cluSet;

         try {

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

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(cluSetId);

         }

         findClusInCluSet(Ids, cluSet);

         return Ids;

     }

     @Override

     public Boolean isCluInCluSet(String cluId, String cluSetId, ContextInfo context)

             throws DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         checkForMissingParameter(cluId, "cluId");

         checkForMissingParameter(cluSetId, "cluSetId");

         return luDao.isCluInCluSet(cluId, cluSetId);

     }

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

      * MAINTENANCE OPERATIONS *

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

     @Override

     public List<ValidationResultInfo> validateClu(String validationType,

             CluInfo cluInfo, ContextInfo context) throws DoesNotExistException,

             InvalidParameterException, MissingParameterException,

             OperationFailedException {

         checkForMissingParameter(validationType, "validationType");

         checkForMissingParameter(cluInfo, "cluInfo");

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

         Validator defaultValidator = validatorFactory.getValidator();

         List<org.kuali.student.common.validation.dto.ValidationResultInfo> r1vrs = defaultValidator.validateObject(cluInfo, objStructure);

         List<ValidationResultInfo> r2vrs = new R1ToR2CopyHelper().copyValidationResultList(r1vrs);

         return r2vrs;

     }

     @Override

     @Transactional(readOnly = false)

     public CluInfo createClu(String luTypeKey, CluInfo cluInfo, ContextInfo context)

             throws DataValidationErrorException,

             DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         Clu clu;

         try {

             clu = toCluForCreate(luTypeKey, cluInfo, context);

         } catch (AlreadyExistsException ex) {

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

         }

         //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, ContextInfo context)

             throws AlreadyExistsException, DataValidationErrorException,

             DoesNotExistException, InvalidParameterException,

             MissingParameterException, OperationFailedException,

             PermissionDeniedException {

         checkForMissingParameter(luTypeKey, "luTypeKey");

         checkForMissingParameter(cluInfo, "cluInfo");

         // Validate CLU

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

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

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

         }

         Clu clu = new Clu();

         LuType luType;

         try {

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

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(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", "meta"});

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

                 luCode.setDescr(luCodeInfo.getDescr().getPlain());

             }

             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",

                     "meta", "versionInfo", "intensity",

                     "campusLocations", "accreditations",

                     "adminOrgs"});

         return clu;

     }

     @Override

     @Transactional(readOnly = false)

     public CluInfo updateClu(String cluId, CluInfo cluInfo, ContextInfo context)

             throws DataValidationErrorException, DoesNotExistException,

             InvalidParameterException, MissingParameterException,

             OperationFailedException, PermissionDeniedException,

             VersionMismatchException {

         checkForMissingParameter(cluId, "cluId");

         checkForMissingParameter(cluInfo, "cluInfo");

         // Validate CLU

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

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

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

         }

         Clu clu;

         try {

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

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(cluId);

         }

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

                 cluInfo.getMeta().getVersionInd())) {

             throw new VersionMismatchException(

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

         }

         LuType luType;

         try {

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

         } catch (org.kuali.student.common.exceptions.DoesNotExistException ex) {

             throw new DoesNotExistException(cluInfo.getTypeKey());

         }

         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.getMeta().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", "meta"});

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

                 luCode.setDescr(luCodeInfo.getDescr().getPlain());

             }

             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();