ProgramServiceImpl (Kuali Student 1.2.2-M3-SNAPSHOT API)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.kuali.student.lum.program.service.impl
Class ProgramServiceImpl

java.lang.Object
  org.kuali.student.lum.program.service.impl.ProgramServiceImpl

All Implemented Interfaces:: DictionaryService, SearchService, VersionManagementService, ProgramService

public class ProgramServiceImpl
extends Object
implements ProgramService
extends Object
implements ProgramService

Field Summary
`private AtpService`	`atpService`
`private CoreProgramAssembler`	`coreProgramAssembler`
`private CredentialProgramAssembler`	`credentialProgramAssembler`
`private DictionaryService`	`dictionaryService`
`private DocumentService`	`documentService`
`(package private) static Logger`	`LOG`
`private LuService`	`luService`
`private MajorDisciplineAssembler`	`majorDisciplineAssembler`
`private ProgramRequirementAssembler`	`programRequirementAssembler`
`private BusinessServiceMethodInvoker`	`programServiceMethodInvoker`
`private SearchManager`	`searchManager`
`private ValidatorFactory`	`validatorFactory`

Constructor Summary
`ProgramServiceImpl()`

Method Summary
`private void`	`checkForMissingParameter(Object param, String paramName)` Check for missing parameter and throw localized exception if missing
`private void`	`clearStatementTreeViewIdsRecursively(StatementTreeViewInfo statementTreeView)` Recurses through the statement tree and clears out ids so the tree can be copied.
`private void`	`compareAtps(String aptKey1, String aptKey2, List<ValidationResultInfo> validationResults, String field, String path)`
`private void`	`copyProgramRequirements(List<String> originalProgramRequirementIds, String state)` Copy requirements (these exist external to the program save process and are referenced by id)
`CoreProgramInfo`	`createCoreProgram(CoreProgramInfo coreProgramInfo)` Creates a Core Program
`CredentialProgramInfo`	`createCredentialProgram(CredentialProgramInfo credentialProgramInfo)` Creates a Credential Program
`HonorsProgramInfo`	`createHonorsProgram(HonorsProgramInfo honorsProgramInfo)` Creates a Honors Program
`MajorDisciplineInfo`	`createMajorDiscipline(MajorDisciplineInfo majorDisciplineInfo)` Creates a Major Discipline Program
`MinorDisciplineInfo`	`createMinorDiscipline(MinorDisciplineInfo minorDisciplineInfo)` Creates a Minor Discipline Program
`CoreProgramInfo`	`createNewCoreProgramVersion(String coreProgramId, String versionComment)` Creates a new Core Program version based on the current Core Program
`CredentialProgramInfo`	`createNewCredentialProgramVersion(String credentialProgramId, String versionComment)` Creates a new Credential Program version based on the current Credential Program
`MajorDisciplineInfo`	`createNewMajorDisciplineVersion(String majorDisciplineVerIndId, String versionComment)` Creates a new Major Discipline version based on the current Major
`ProgramRequirementInfo`	`createProgramRequirement(ProgramRequirementInfo programRequirementInfo)` Creates a Program Requirement
`StatusInfo`	`deleteCoreProgram(String coreProgramId)` Deletes a Core Program
`StatusInfo`	`deleteCredentialProgram(String credentialProgramId)` Deletes a Credential Program
`StatusInfo`	`deleteHonorsProgram(String honorsProgramId)` Deletes a Honors Program
`StatusInfo`	`deleteMajorDiscipline(String majorDisciplineId)` Deletes a Major Discipline
`StatusInfo`	`deleteMinorDiscipline(String minorDisciplineId)` Deletes a Minor Discipline
`StatusInfo`	`deleteProgramRequirement(String programRequirementId)` Deletes a Program Requirement
`private AtpInfo`	`getAtpInfo(String atpKey)`
`AtpService`	`getAtpService()`
`CoreProgramInfo`	`getCoreProgram(String coreProgramId)` Retrieves a Core Program
`CoreProgramAssembler`	`getCoreProgramAssembler()`
`CredentialProgramInfo`	`getCredentialProgram(String credentialProgramId)` Retrieves a CredentialProgram
`CredentialProgramAssembler`	`getCredentialProgramAssembler()`
`LuTypeInfo`	`getCredentialProgramType(String credentialProgramTypeKey)` Retrieves information about a credential program type
`List<LuTypeInfo>`	`getCredentialProgramTypes()` Retrieves the list of credential program types
`VersionDisplayInfo`	`getCurrentVersion(String refObjectTypeURI, String refObjectId)` Retrieves current version associated with the objectId.
`VersionDisplayInfo`	`getCurrentVersionOnDate(String refObjectTypeURI, String refObjectId, Date date)` Retrieves the current version associated with the objectId on a given date.
`DictionaryService`	`getDictionaryService()`
`DocumentService`	`getDocumentService()`
`VersionDisplayInfo`	`getFirstVersion(String refObjectTypeURI, String refObjectId)` Retrieves first version associated with the objectId.
`List<String>`	`getHonorsByCredentialProgramType(String programType)` Retrieves the list of Honors Program Program a given Credential Program Type.
`HonorsProgramInfo`	`getHonorsProgram(String honorsProgramId)` Retrieves a HonorsProgram
`VersionDisplayInfo`	`getLatestVersion(String refObjectTypeURI, String refObjectId)` Retrieves latest version associated with the objectId.
`LuService`	`getLuService()`
`MajorDisciplineInfo`	`getMajorDiscipline(String majorDisciplineId)` Retrieves a MajorDiscipline
`MajorDisciplineAssembler`	`getMajorDisciplineAssembler()`
`List<String>`	`getMajorIdsByCredentialProgramType(String programType)` Retrieves the list of Major Discipline identifiers a given Credential Program Type.
`MinorDisciplineInfo`	`getMinorDiscipline(String minorDisciplineId)` Retrieves a MinorDiscipline
`List<String>`	`getMinorsByCredentialProgramType(String programType)` Retrieves the list of Minor Discipline Program a given Credential Program Type.
`ObjectStructureDefinition`	`getObjectStructure(String objectTypeKey)`
`List<String>`	`getObjectTypes()`
`ProgramRequirementInfo`	`getProgramRequirement(String programRequirementId, String nlUsageTypeKey, String language)` Retrieves a ProgramRequirement
`ProgramRequirementAssembler`	`getProgramRequirementAssembler()`
`BusinessServiceMethodInvoker`	`getProgramServiceMethodInvoker()`
`SearchCriteriaTypeInfo`	`getSearchCriteriaType(String searchCriteriaTypeKey)` Retrieves information about a particular search criteria type.
`List<SearchCriteriaTypeInfo>`	`getSearchCriteriaTypes()` Retrieves the list of search criteria types known by this service.
`SearchManager`	`getSearchManager()`
`SearchResultTypeInfo`	`getSearchResultType(String searchResultTypeKey)` Retrieves information about a particular search result type.
`List<SearchResultTypeInfo>`	`getSearchResultTypes()` Retrieves the list of search result types known by this service.
`SearchTypeInfo`	`getSearchType(String searchTypeKey)` Retrieves information about a particular search type.
`List<SearchTypeInfo>`	`getSearchTypes()` Retrieves the list of search types known by this service.
`List<SearchTypeInfo>`	`getSearchTypesByCriteria(String searchCriteriaTypeKey)` Retrieves the list of search types which use criteria in the specified format.
`List<SearchTypeInfo>`	`getSearchTypesByResult(String searchResultTypeKey)` Retrieves the list of search types which return results in the specified format.
`private StatusInfo`	`getStatus()`
`ValidatorFactory`	`getValidatorFactory()`
`List<ProgramVariationInfo>`	`getVariationsByMajorDisciplineId(String majorDisciplineId)` Retrieves a list of program variations for a particular major
`VersionDisplayInfo`	`getVersionBySequenceNumber(String refObjectTypeURI, String refObjectId, Long sequence)` Retrieves the version associated with the objectId and the sequence number.
`List<VersionDisplayInfo>`	`getVersions(String refObjectTypeURI, String refObjectId)` Retrieves list of version associated with the objectId.
`List<VersionDisplayInfo>`	`getVersionsInDateRange(String refObjectTypeURI, String refObjectId, Date from, Date to)` Retrieves the current version associated with the objectId on a given date.
`private void`	`invokeServiceCalls(BaseDTOAssemblyNode<?,CluInfo> results)`
`private boolean`	`isEmpty(String value)`
`private void`	`processCopy(CoreProgramInfo originalCoreProgram, String originalId)`
`private void`	`processCopy(CredentialProgramInfo originaCredentialProgram, String originalId)`
`private void`	`processCopy(MajorDisciplineInfo majorDiscipline, String originalId)` Clears out any ids so that a subsequent call to create will copy complex structures.
`private CoreProgramInfo`	`processCoreProgramInfo(CoreProgramInfo coreProgramInfo, BaseDTOAssemblyNode.NodeOperation operation)`
`private CredentialProgramInfo`	`processCredentialProgramInfo(CredentialProgramInfo credentialProgramInfo, BaseDTOAssemblyNode.NodeOperation operation)`
`private MajorDisciplineInfo`	`processMajorDisciplineInfo(MajorDisciplineInfo majorDisciplineInfo, BaseDTOAssemblyNode.NodeOperation operation)`
`private ProgramRequirementInfo`	`processProgramRequirement(ProgramRequirementInfo programRequirementInfo, BaseDTOAssemblyNode.NodeOperation operation)`
`private void`	`resetLoRecursively(LoDisplayInfo lo)` Recursively clears out the ids in a Lo and in its child Los
`SearchResult`	`search(SearchRequest searchRequest)`
`void`	`setAtpService(AtpService atpService)`
`void`	`setCoreProgramAssembler(CoreProgramAssembler coreProgramAssembler)`
`void`	`setCredentialProgramAssembler(CredentialProgramAssembler credentialProgramAssembler)`
`StatusInfo`	`setCurrentCoreProgramVersion(String coreProgramId, Date currentVersionStart)` Sets a specific version of the Core Program as current.
`StatusInfo`	`setCurrentCredentialProgramVersion(String credentialProgramId, Date currentVersionStart)` Sets a specific version of the Credential Program as current.
`StatusInfo`	`setCurrentMajorDisciplineVersion(String majorDisciplineId, Date currentVersionStart)` Sets a specific version of the Major as current.
`void`	`setDictionaryService(DictionaryService dictionaryService)`
`void`	`setDocumentService(DocumentService documentService)`
`void`	`setLuService(LuService luService)`
`void`	`setMajorDisciplineAssembler(MajorDisciplineAssembler majorDisciplineAssembler)`
`void`	`setProgramRequirementAssembler(ProgramRequirementAssembler programRequirementAssembler)`
`void`	`setProgramServiceMethodInvoker(BusinessServiceMethodInvoker serviceMethodInvoker)`
`void`	`setSearchManager(SearchManager searchManager)`
`void`	`setValidatorFactory(ValidatorFactory validatorFactory)`
`CoreProgramInfo`	`updateCoreProgram(CoreProgramInfo coreProgramInfo)` Updates a Core Program
`CredentialProgramInfo`	`updateCredentialProgram(CredentialProgramInfo credentialProgramInfo)` Updates a Credential Program
`HonorsProgramInfo`	`updateHonorsProgram(HonorsProgramInfo honorsProgramInfo)` Updates a Honors Program
`MajorDisciplineInfo`	`updateMajorDiscipline(MajorDisciplineInfo majorDisciplineInfo)` Updates a Major Discipline
`MinorDisciplineInfo`	`updateMinorDiscipline(MinorDisciplineInfo minorDisciplineInfo)` Updates a Minor Discipline
`ProgramRequirementInfo`	`updateProgramRequirement(ProgramRequirementInfo programRequirementInfo)` Updates a Program Requirement
`private void`	`updateRequirementsState(List<String> programRequirementIds, String newState)` This method will update the requirement state.
`private static void`	`updateStatementTreeViewInfoState(String state, StatementTreeViewInfo statementTreeViewInfo)` This method will recursively set the state of all statements in the tree.
`List<ValidationResultInfo>`	`validateCoreProgram(String validationType, CoreProgramInfo coreProgramInfo)` Validates a Core Program against its data dictionary
`List<ValidationResultInfo>`	`validateCredentialProgram(String validationType, CredentialProgramInfo credentialProgramInfo)` Validates a Credential Program against its data dictionary
`List<ValidationResultInfo>`	`validateHonorsProgram(String validationType, HonorsProgramInfo honorsProgramInfo)` Validates a Honors Program against its data dictionary
`List<ValidationResultInfo>`	`validateMajorDiscipline(String validationType, MajorDisciplineInfo majorDisciplineInfo)` Validates a Major discipline against its data dictionary
`private void`	`validateMajorDisciplineAtps(MajorDisciplineInfo majorDisciplineInfo, List<ValidationResultInfo> validationResults)`
`List<ValidationResultInfo>`	`validateMinorDiscipline(String validationType, MinorDisciplineInfo minorDisciplineInfo)` Validates a Minor discipline against its data dictionary
`List<ValidationResultInfo>`	`validateProgramRequirement(String validationType, ProgramRequirementInfo programRequirementInfo)` Validates a Program Requirement against its data dictionary
`private void`	`validateVariationAtps(ProgramVariationInfo programVariationInfo, List<ValidationResultInfo> validationResults, int idx)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

LOG

static final Logger LOG

luService

private LuService luService

validatorFactory

private ValidatorFactory validatorFactory

programServiceMethodInvoker

private BusinessServiceMethodInvoker programServiceMethodInvoker

dictionaryService

private DictionaryService dictionaryService

searchManager

private SearchManager searchManager

majorDisciplineAssembler

private MajorDisciplineAssembler majorDisciplineAssembler

programRequirementAssembler

private ProgramRequirementAssembler programRequirementAssembler

credentialProgramAssembler

private CredentialProgramAssembler credentialProgramAssembler

coreProgramAssembler

private CoreProgramAssembler coreProgramAssembler

atpService

private AtpService atpService

documentService

private DocumentService documentService

Constructor Detail

ProgramServiceImpl

public ProgramServiceImpl()

Method Detail

createCredentialProgram

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public CredentialProgramInfo createCredentialProgram(CredentialProgramInfo credentialProgramInfo)
                                              throws AlreadyExistsException,
                                                     DataValidationErrorException,
                                                     InvalidParameterException,
                                                     MissingParameterException,
                                                     OperationFailedException,
                                                     PermissionDeniedException

Description copied from interface: ProgramService

Creates a Credential Program

Specified by:: createCredentialProgram in interface ProgramService

Parameters:: credentialProgramInfo - credentialProgramInfo
Returns:: the created Credential Program
Throws:: AlreadyExistsException - The Credential Program already exists; DataValidationErrorException - One or more values invalid for this operation; InvalidParameterException - invalid Credential Program; MissingParameterException - missing Credential Program; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

createHonorsProgram

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public HonorsProgramInfo createHonorsProgram(HonorsProgramInfo honorsProgramInfo)
                                      throws AlreadyExistsException,
                                             DataValidationErrorException,
                                             InvalidParameterException,
                                             MissingParameterException,
                                             OperationFailedException,
                                             PermissionDeniedException

Description copied from interface: ProgramService

Creates a Honors Program

Specified by:: createHonorsProgram in interface ProgramService

Parameters:: honorsProgramInfo - honorsProgramInfo
Returns:: the created Honors Program
Throws:: AlreadyExistsException - The Honors Program already exists; DataValidationErrorException - One or more values invalid for this operation; InvalidParameterException - invalid Honors Program; MissingParameterException - missing Honors Program; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

createProgramRequirement

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public ProgramRequirementInfo createProgramRequirement(ProgramRequirementInfo programRequirementInfo)
                                                throws AlreadyExistsException,
                                                       DataValidationErrorException,
                                                       InvalidParameterException,
                                                       MissingParameterException,
                                                       OperationFailedException,
                                                       PermissionDeniedException

Description copied from interface: ProgramService

Creates a Program Requirement

Specified by:: createProgramRequirement in interface ProgramService

Parameters:: programRequirementInfo - programRequirementInfo
Returns:: the created Program Requirement
Throws:: AlreadyExistsException - The Program Requirement already exists; DataValidationErrorException - One or more values invalid for this operation; InvalidParameterException - invalid Program Requirement; MissingParameterException - missing Program Requirement; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

createMajorDiscipline

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public MajorDisciplineInfo createMajorDiscipline(MajorDisciplineInfo majorDisciplineInfo)
                                          throws AlreadyExistsException,
                                                 DataValidationErrorException,
                                                 InvalidParameterException,
                                                 MissingParameterException,
                                                 OperationFailedException,
                                                 PermissionDeniedException

Description copied from interface: ProgramService

Creates a Major Discipline Program

Specified by:: createMajorDiscipline in interface ProgramService

Parameters:: majorDisciplineInfo - majorDisciplineInfo
Returns:: the created Major Discipline
Throws:: AlreadyExistsException - The Major already exists; DataValidationErrorException - One or more values invalid for this operation; InvalidParameterException - invalid Major; MissingParameterException - missing Major; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

createNewMajorDisciplineVersion

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public MajorDisciplineInfo createNewMajorDisciplineVersion(String majorDisciplineVerIndId,
                                                                                                                                                             String versionComment)
                                                    throws DoesNotExistException,
                                                           InvalidParameterException,
                                                           MissingParameterException,
                                                           OperationFailedException,
                                                           PermissionDeniedException,
                                                           VersionMismatchException,
                                                           DataValidationErrorException

Description copied from interface: ProgramService

Creates a new Major Discipline version based on the current Major

Specified by:: createNewMajorDisciplineVersion in interface ProgramService

Parameters:: majorDisciplineVerIndId - identifier for the Major Discipline to be versioned; versionComment - comment for the current version
Returns:: the new versioned Major Discipline information
Throws:: DoesNotExistException - Major does not exist; InvalidParameterException - invalid majorDisciplineId; MissingParameterException - invalid majorDisciplineId; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure; VersionMismatchException - The action was attempted on an out of date version; DataValidationErrorException

updateRequirementsState

private void updateRequirementsState(List<String> programRequirementIds,
                                     String newState)
                              throws DoesNotExistException,
                                     InvalidParameterException,
                                     MissingParameterException,
                                     OperationFailedException,
                                     PermissionDeniedException,
                                     VersionMismatchException,
                                     DataValidationErrorException

This method will update the requirement state.

Note that it uses StatementUtil to update the statement tree.

Parameters:: majorDisciplineInfo -; newState -
Throws:: Exception; DoesNotExistException; InvalidParameterException; MissingParameterException; OperationFailedException; PermissionDeniedException; VersionMismatchException; DataValidationErrorException

updateStatementTreeViewInfoState

private static void updateStatementTreeViewInfoState(String state,
                                                     StatementTreeViewInfo statementTreeViewInfo)

This method will recursively set the state of all statements in the tree.

WARNING: you must call the statement service in order to update statements.

Parameters:: state - is the state we should set all statements in the tree to; statementTreeViewInfo - the tree of statements
Throws:: Exception

clearStatementTreeViewIdsRecursively

private void clearStatementTreeViewIdsRecursively(StatementTreeViewInfo statementTreeView)
                                           throws OperationFailedException

Recurses through the statement tree and clears out ids so the tree can be copied. Also creates copies of clusets since they are single use

Parameters:: statementTreeView -
Throws:: OperationFailedException
See Also:: (This is duplicate code because of the weird dependencies cause by program being in its own module)

processCopy

private void processCopy(MajorDisciplineInfo majorDiscipline,
                         String originalId)
                  throws DoesNotExistException,
                         InvalidParameterException,
                         MissingParameterException,
                         OperationFailedException,
                         PermissionDeniedException,
                         AlreadyExistsException,
                         DataValidationErrorException,
                         VersionMismatchException,
                         CircularRelationshipException

Clears out any ids so that a subsequent call to create will copy complex structures. Also updates VersionInfo on variations to match VersionInfo on parent.

Parameters:: majorDiscipline -
Throws:: PermissionDeniedException; OperationFailedException; MissingParameterException; InvalidParameterException; DoesNotExistException; DataValidationErrorException; AlreadyExistsException; VersionMismatchException; CircularRelationshipException

processCopy

private void processCopy(CredentialProgramInfo originaCredentialProgram,
                         String originalId)
                  throws OperationFailedException,
                         AlreadyExistsException,
                         DataValidationErrorException,
                         InvalidParameterException,
                         MissingParameterException,
                         PermissionDeniedException,
                         DoesNotExistException

Throws:: OperationFailedException; AlreadyExistsException; DataValidationErrorException; InvalidParameterException; MissingParameterException; PermissionDeniedException; DoesNotExistException

processCopy

private void processCopy(CoreProgramInfo originalCoreProgram,
                         String originalId)
                  throws OperationFailedException,
                         AlreadyExistsException,
                         DataValidationErrorException,
                         InvalidParameterException,
                         MissingParameterException,
                         PermissionDeniedException,
                         DoesNotExistException

Throws:: OperationFailedException; AlreadyExistsException; DataValidationErrorException; InvalidParameterException; MissingParameterException; PermissionDeniedException; DoesNotExistException

copyProgramRequirements

private void copyProgramRequirements(List<String> originalProgramRequirementIds,
                                     String state)
                              throws OperationFailedException,
                                     AlreadyExistsException,
                                     DataValidationErrorException,
                                     InvalidParameterException,
                                     MissingParameterException,
                                     PermissionDeniedException,
                                     DoesNotExistException

Copy requirements (these exist external to the program save process and are referenced by id)

Parameters:: originalProgramRequirementIds -; state -
Throws:: OperationFailedException; AlreadyExistsException; DataValidationErrorException; InvalidParameterException; MissingParameterException; PermissionDeniedException; DoesNotExistException

resetLoRecursively

private void resetLoRecursively(LoDisplayInfo lo)

Recursively clears out the ids in a Lo and in its child Los

Parameters:: lo -

setCurrentMajorDisciplineVersion

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public StatusInfo setCurrentMajorDisciplineVersion(String majorDisciplineId,
                                                                                                                                                     Date currentVersionStart)
                                            throws DoesNotExistException,
                                                   InvalidParameterException,
                                                   MissingParameterException,
                                                   IllegalVersionSequencingException,
                                                   OperationFailedException,
                                                   PermissionDeniedException

Description copied from interface: ProgramService

Sets a specific version of the Major as current. The sequence number must be greater than the existing current Major version. This will truncate the current version's end date to the currentVersionStart param. If a Major exists which is set to become current in the future, that Major's currentVersionStart and CurrentVersionEnd will be nullified. The currentVersionStart must be in the future to prevent changing historic data.

Specified by:: setCurrentMajorDisciplineVersion in interface ProgramService

Parameters:: majorDisciplineId - Version Specific Id of the Major Discipline; currentVersionStart - Date when this Major becomes current. Must be in the future and be after the most current major's start date.
Returns:: status of the operation (success or failure)
Throws:: DoesNotExistException - Major for majorVersionId does not exist; InvalidParameterException - invalid majorVersionId, currentVersionStart; MissingParameterException - invalid majorVersionId; IllegalVersionSequencingException - a Major with higher sequence number from the one provided is marked current; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

createMinorDiscipline

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public MinorDisciplineInfo createMinorDiscipline(MinorDisciplineInfo minorDisciplineInfo)
                                          throws AlreadyExistsException,
                                                 DataValidationErrorException,
                                                 InvalidParameterException,
                                                 MissingParameterException,
                                                 OperationFailedException,
                                                 PermissionDeniedException

Description copied from interface: ProgramService

Creates a Minor Discipline Program

Specified by:: createMinorDiscipline in interface ProgramService

Parameters:: minorDisciplineInfo - minorDisciplineInfo
Returns:: the created Minor Discipline
Throws:: AlreadyExistsException - The Minor already exists; DataValidationErrorException - One or more values invalid for this operation; InvalidParameterException - invalid Minor; MissingParameterException - missing Minor; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

deleteCredentialProgram

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public StatusInfo deleteCredentialProgram(String credentialProgramId)
                                   throws DoesNotExistException,
                                          InvalidParameterException,
                                          MissingParameterException,
                                          OperationFailedException,
                                          PermissionDeniedException

Description copied from interface: ProgramService

Deletes a Credential Program

Specified by:: deleteCredentialProgram in interface ProgramService

Parameters:: credentialProgramId - identifier for credentialProgramId.Maps to cluId
Returns:: status of the operation (success or failure)
Throws:: DoesNotExistException - Credential Program does not exist; InvalidParameterException - invalid credentialProgramId; MissingParameterException - invalid credentialProgramId; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

deleteHonorsProgram

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public StatusInfo deleteHonorsProgram(String honorsProgramId)
                               throws DoesNotExistException,
                                      InvalidParameterException,
                                      MissingParameterException,
                                      OperationFailedException,
                                      PermissionDeniedException

Description copied from interface: ProgramService

Deletes a Honors Program

Specified by:: deleteHonorsProgram in interface ProgramService

Parameters:: honorsProgramId - identifier for honorsProgramId.Maps to cluId
Returns:: status of the operation (success or failure)
Throws:: DoesNotExistException - Honors Program does not exist; InvalidParameterException - invalid honorsProgramId; MissingParameterException - invalid honorsProgramId; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

deleteMajorDiscipline

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public StatusInfo deleteMajorDiscipline(String majorDisciplineId)
                                 throws DoesNotExistException,
                                        InvalidParameterException,
                                        MissingParameterException,
                                        OperationFailedException,
                                        PermissionDeniedException

Description copied from interface: ProgramService

Deletes a Major Discipline

Specified by:: deleteMajorDiscipline in interface ProgramService

Parameters:: majorDisciplineId - identifier for majorDisciplineId.Maps to cluId
Returns:: status of the operation (success or failure)
Throws:: DoesNotExistException - Major does not exist; InvalidParameterException - invalid majorDisciplineId; MissingParameterException - invalid majorDisciplineId; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

deleteMinorDiscipline

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public StatusInfo deleteMinorDiscipline(String minorDisciplineId)
                                 throws DoesNotExistException,
                                        InvalidParameterException,
                                        MissingParameterException,
                                        OperationFailedException,
                                        PermissionDeniedException

Description copied from interface: ProgramService

Deletes a Minor Discipline

Specified by:: deleteMinorDiscipline in interface ProgramService

Parameters:: minorDisciplineId - identifier for minorDisciplineId.Maps to cluId
Returns:: status of the operation (success or failure)
Throws:: DoesNotExistException - Minor does not exist; InvalidParameterException - invalid minorDisciplineId; MissingParameterException - invalid minorDisciplineId; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

deleteProgramRequirement

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public StatusInfo deleteProgramRequirement(String programRequirementId)
                                    throws DoesNotExistException,
                                           InvalidParameterException,
                                           MissingParameterException,
                                           OperationFailedException,
                                           PermissionDeniedException

Description copied from interface: ProgramService

Deletes a Program Requirement

Specified by:: deleteProgramRequirement in interface ProgramService

Parameters:: programRequirementId - identifier for programRequirementId.Maps to cluId
Returns:: status of the operation (success or failure)
Throws:: DoesNotExistException - Program Requirement does not exist; InvalidParameterException - invalid programRequirementId; MissingParameterException - invalid programRequirementId; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getCredentialProgram

@Transactional(readOnly=true)
public CredentialProgramInfo getCredentialProgram(String credentialProgramId)
                                           throws DoesNotExistException,
                                                  InvalidParameterException,
                                                  MissingParameterException,
                                                  OperationFailedException,
                                                  PermissionDeniedException

Description copied from interface: ProgramService

Retrieves a CredentialProgram

Specified by:: getCredentialProgram in interface ProgramService

Parameters:: credentialProgramId - Unique Id of the CredentialProgram. Maps to cluId
Returns:: the created Credential Program
Throws:: DoesNotExistException - CredentialProgram does not exist; InvalidParameterException - invalid Credential Program; MissingParameterException - missing Credential Program; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getCredentialProgramType

public LuTypeInfo getCredentialProgramType(String credentialProgramTypeKey)
                                    throws DoesNotExistException,
                                           InvalidParameterException,
                                           MissingParameterException,
                                           OperationFailedException

Description copied from interface: ProgramService

Retrieves information about a credential program type

Specified by:: getCredentialProgramType in interface ProgramService

Parameters:: credentialProgramTypeKey - Key of the Credential Program Type
Returns:: information about a Credential Program Type
Throws:: DoesNotExistException - credentialProgramType not found; InvalidParameterException - invalid credentialProgramType; MissingParameterException - missing credentialProgramType; OperationFailedException - unable to complete request

getCredentialProgramTypes

public List<LuTypeInfo> getCredentialProgramTypes()
                                           throws OperationFailedException

Description copied from interface: ProgramService

Retrieves the list of credential program types

Specified by:: getCredentialProgramTypes in interface ProgramService

Returns:: list of credential program type information
Throws:: OperationFailedException - unable to complete request

getHonorsByCredentialProgramType

public List<String> getHonorsByCredentialProgramType(String programType)
                                              throws DoesNotExistException,
                                                     InvalidParameterException,
                                                     MissingParameterException,
                                                     OperationFailedException

Description copied from interface: ProgramService

Retrieves the list of Honors Program Program a given Credential Program Type.

Specified by:: getHonorsByCredentialProgramType in interface ProgramService

Parameters:: programType - Type of Credential Program
Returns:: List of Honors Programs for the given Credential Program Type
Throws:: DoesNotExistException - program type not found; InvalidParameterException - invalid program type; MissingParameterException - program type is not specified; OperationFailedException - unable to complete request

getHonorsProgram

public HonorsProgramInfo getHonorsProgram(String honorsProgramId)
                                   throws DoesNotExistException,
                                          InvalidParameterException,
                                          MissingParameterException,
                                          OperationFailedException,
                                          PermissionDeniedException

Description copied from interface: ProgramService

Retrieves a HonorsProgram

Specified by:: getHonorsProgram in interface ProgramService

Parameters:: honorsProgramId - Unique Id of the HonorsProgram. Maps to cluId
Returns:: the created Honors Program
Throws:: DoesNotExistException - HonorsProgram does not exist; InvalidParameterException - invalid Honors Program; MissingParameterException - missing Honors Program; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getMajorDiscipline

@Transactional(readOnly=true)
public MajorDisciplineInfo getMajorDiscipline(String majorDisciplineId)
                                       throws DoesNotExistException,
                                              InvalidParameterException,
                                              MissingParameterException,
                                              OperationFailedException,
                                              PermissionDeniedException

Description copied from interface: ProgramService

Retrieves a MajorDiscipline

Specified by:: getMajorDiscipline in interface ProgramService

Parameters:: majorDisciplineId - Unique Id of the MajorDiscipline. Maps to cluId
Returns:: the created MajorDiscipline
Throws:: DoesNotExistException - MajorDiscipline does not exist; InvalidParameterException - invalid MajorDiscipline; MissingParameterException - missing MajorDiscipline; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getMajorIdsByCredentialProgramType

public List<String> getMajorIdsByCredentialProgramType(String programType)
                                                throws DoesNotExistException,
                                                       InvalidParameterException,
                                                       MissingParameterException,
                                                       OperationFailedException

Description copied from interface: ProgramService

Retrieves the list of Major Discipline identifiers a given Credential Program Type.

Specified by:: getMajorIdsByCredentialProgramType in interface ProgramService

Parameters:: programType - Type of Credential Program
Returns:: List of Major Discipline identifiers for the given Credential Program Type
Throws:: DoesNotExistException - program type not found; InvalidParameterException - invalid program type; MissingParameterException - program type is not specified; OperationFailedException - unable to complete request

getMinorDiscipline

public MinorDisciplineInfo getMinorDiscipline(String minorDisciplineId)
                                       throws DoesNotExistException,
                                              InvalidParameterException,
                                              MissingParameterException,
                                              OperationFailedException,
                                              PermissionDeniedException

Description copied from interface: ProgramService

Retrieves a MinorDiscipline

Specified by:: getMinorDiscipline in interface ProgramService

Parameters:: minorDisciplineId - Unique Id of the MinorDiscipline. Maps to cluId
Returns:: the created MinorDiscipline
Throws:: DoesNotExistException - MinorDiscipline does not exist; InvalidParameterException - invalid MinorDiscipline; MissingParameterException - missing MinorDiscipline; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getMinorsByCredentialProgramType

public List<String> getMinorsByCredentialProgramType(String programType)
                                              throws DoesNotExistException,
                                                     InvalidParameterException,
                                                     MissingParameterException,
                                                     OperationFailedException

Description copied from interface: ProgramService

Retrieves the list of Minor Discipline Program a given Credential Program Type.

Specified by:: getMinorsByCredentialProgramType in interface ProgramService

Parameters:: programType - Type of Credential Program
Returns:: List of Minor Disciplines for the given Credential Program Type
Throws:: DoesNotExistException - program type not found; InvalidParameterException - invalid program type; MissingParameterException - program type is not specified; OperationFailedException - unable to complete request

getProgramRequirement

@Transactional(readOnly=true)
public ProgramRequirementInfo getProgramRequirement(String programRequirementId,
                                                                          String nlUsageTypeKey,
                                                                          String language)
                                             throws DoesNotExistException,
                                                    InvalidParameterException,
                                                    MissingParameterException,
                                                    OperationFailedException,
                                                    PermissionDeniedException

Description copied from interface: ProgramService

Retrieves a ProgramRequirement

Specified by:: getProgramRequirement in interface ProgramService

Parameters:: programRequirementId - Unique Id of the ProgramRequirement. Maps to cluId; nlUsageTypeKey - Natural language usage type key (context); language - Translation language e.g en, es, gr
Returns:: the Program Requirement
Throws:: DoesNotExistException - Program Requirement does not exist; InvalidParameterException - invalid Program Requirement; MissingParameterException - missing Program Requirement; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getVariationsByMajorDisciplineId

@Transactional(readOnly=true)
public List<ProgramVariationInfo> getVariationsByMajorDisciplineId(String majorDisciplineId)
                                                            throws DoesNotExistException,
                                                                   InvalidParameterException,
                                                                   MissingParameterException,
                                                                   OperationFailedException

Description copied from interface: ProgramService

Retrieves a list of program variations for a particular major

Specified by:: getVariationsByMajorDisciplineId in interface ProgramService

Parameters:: majorDisciplineId - Major Discipline Identifier
Returns:: list of program variations associated with the specified Major
Throws:: DoesNotExistException - Major not found; InvalidParameterException - invalid majorDisciplineId; MissingParameterException - majorDisciplineId not specified; OperationFailedException - unable to complete request

updateCredentialProgram

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public CredentialProgramInfo updateCredentialProgram(CredentialProgramInfo credentialProgramInfo)
                                              throws DataValidationErrorException,
                                                     DoesNotExistException,
                                                     InvalidParameterException,
                                                     MissingParameterException,
                                                     VersionMismatchException,
                                                     OperationFailedException,
                                                     PermissionDeniedException

Description copied from interface: ProgramService

Updates a Credential Program

Specified by:: updateCredentialProgram in interface ProgramService

Parameters:: credentialProgramInfo - credentialProgramInfo
Returns:: updated Credential Program
Throws:: DataValidationErrorException - One or more values invalid for this operation; DoesNotExistException - Credential Program not found; InvalidParameterException - invalid Credential Program; MissingParameterException - missing Credential Program; VersionMismatchException - The action was attempted on an out of date version; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

updateHonorsProgram

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public HonorsProgramInfo updateHonorsProgram(HonorsProgramInfo honorsProgramInfo)
                                      throws DataValidationErrorException,
                                             DoesNotExistException,
                                             InvalidParameterException,
                                             MissingParameterException,
                                             VersionMismatchException,
                                             OperationFailedException,
                                             PermissionDeniedException

Description copied from interface: ProgramService

Updates a Honors Program

Specified by:: updateHonorsProgram in interface ProgramService

Parameters:: honorsProgramInfo - honorsProgramInfo
Returns:: updated Honors Program
Throws:: DataValidationErrorException - One or more values invalid for this operation; DoesNotExistException - Honors Program not found; InvalidParameterException - invalid Honors Program; MissingParameterException - missing Honors Program; VersionMismatchException - The action was attempted on an out of date version; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

updateMajorDiscipline

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public MajorDisciplineInfo updateMajorDiscipline(MajorDisciplineInfo majorDisciplineInfo)
                                          throws DataValidationErrorException,
                                                 DoesNotExistException,
                                                 InvalidParameterException,
                                                 MissingParameterException,
                                                 VersionMismatchException,
                                                 OperationFailedException,
                                                 PermissionDeniedException

Description copied from interface: ProgramService

Updates a Major Discipline

Specified by:: updateMajorDiscipline in interface ProgramService

Parameters:: majorDisciplineInfo - majorDisciplineInfo
Returns:: updated Major Discipline
Throws:: DataValidationErrorException - One or more values invalid for this operation; DoesNotExistException - Major not found; InvalidParameterException - invalid Major; MissingParameterException - missing Major; VersionMismatchException - The action was attempted on an out of date version; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

updateMinorDiscipline

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public MinorDisciplineInfo updateMinorDiscipline(MinorDisciplineInfo minorDisciplineInfo)
                                          throws DataValidationErrorException,
                                                 DoesNotExistException,
                                                 InvalidParameterException,
                                                 MissingParameterException,
                                                 VersionMismatchException,
                                                 OperationFailedException,
                                                 PermissionDeniedException

Description copied from interface: ProgramService

Updates a Minor Discipline

Specified by:: updateMinorDiscipline in interface ProgramService

Parameters:: minorDisciplineInfo - minorDisciplineInfo
Returns:: updated Minor Discipline
Throws:: DataValidationErrorException - One or more values invalid for this operation; DoesNotExistException - Minor not found; InvalidParameterException - invalid Minor; MissingParameterException - missing Minor; VersionMismatchException - The action was attempted on an out of date version; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

updateProgramRequirement

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public ProgramRequirementInfo updateProgramRequirement(ProgramRequirementInfo programRequirementInfo)
                                                throws DataValidationErrorException,
                                                       DoesNotExistException,
                                                       InvalidParameterException,
                                                       MissingParameterException,
                                                       VersionMismatchException,
                                                       OperationFailedException,
                                                       PermissionDeniedException

Description copied from interface: ProgramService

Updates a Program Requirement

Specified by:: updateProgramRequirement in interface ProgramService

Parameters:: programRequirementInfo - programRequirementInfo
Returns:: updated Program Requirement
Throws:: DataValidationErrorException - One or more values invalid for this operation; DoesNotExistException - Program Requirement not found; InvalidParameterException - invalid Program Requirement; MissingParameterException - missing Program Requirement; VersionMismatchException - The action was attempted on an out of date version; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

validateCredentialProgram

public List<ValidationResultInfo> validateCredentialProgram(String validationType,
                                                            CredentialProgramInfo credentialProgramInfo)
                                                     throws InvalidParameterException,
                                                            MissingParameterException,
                                                            OperationFailedException

Description copied from interface: ProgramService

Validates a Credential Program against its data dictionary

Specified by:: validateCredentialProgram in interface ProgramService

Parameters:: validationType - identifier of the extent of validation; credentialProgramInfo - Credential Program information to be tested
Returns:: results from performing the validation
Throws:: InvalidParameterException - invalid validationTypeKey, cluInfo; MissingParameterException - missing validationTypeKey, cluInfo; OperationFailedException - unable to complete request

validateHonorsProgram

public List<ValidationResultInfo> validateHonorsProgram(String validationType,
                                                        HonorsProgramInfo honorsProgramInfo)
                                                 throws InvalidParameterException,
                                                        MissingParameterException,
                                                        OperationFailedException

Description copied from interface: ProgramService

Validates a Honors Program against its data dictionary

Specified by:: validateHonorsProgram in interface ProgramService

Parameters:: validationType - identifier of the extent of validation; honorsProgramInfo - Honors Program information to be tested
Returns:: results from performing the validation
Throws:: InvalidParameterException - invalid validationTypeKey, cluInfo; MissingParameterException - missing validationTypeKey, cluInfo; OperationFailedException - unable to complete request

validateMajorDiscipline

public List<ValidationResultInfo> validateMajorDiscipline(String validationType,
                                                          MajorDisciplineInfo majorDisciplineInfo)
                                                   throws InvalidParameterException,
                                                          MissingParameterException,
                                                          OperationFailedException

Description copied from interface: ProgramService

Validates a Major discipline against its data dictionary

Specified by:: validateMajorDiscipline in interface ProgramService

Parameters:: validationType - identifier of the extent of validation; majorDisciplineInfo - Major discipline information to be tested
Returns:: results from performing the validation
Throws:: InvalidParameterException - invalid validationTypeKey, cluInfo; MissingParameterException - missing validationTypeKey, cluInfo; OperationFailedException - unable to complete request

validateMinorDiscipline

public List<ValidationResultInfo> validateMinorDiscipline(String validationType,
                                                          MinorDisciplineInfo minorDisciplineInfo)
                                                   throws InvalidParameterException,
                                                          MissingParameterException,
                                                          OperationFailedException

Description copied from interface: ProgramService

Validates a Minor discipline against its data dictionary

Specified by:: validateMinorDiscipline in interface ProgramService

Parameters:: validationType - identifier of the extent of validation; minorDisciplineInfo - Minor discipline information to be tested
Returns:: results from performing the validation
Throws:: InvalidParameterException - invalid validationTypeKey, cluInfo; MissingParameterException - missing validationTypeKey, cluInfo; OperationFailedException - unable to complete request

validateProgramRequirement

public List<ValidationResultInfo> validateProgramRequirement(String validationType,
                                                             ProgramRequirementInfo programRequirementInfo)
                                                      throws InvalidParameterException,
                                                             MissingParameterException,
                                                             OperationFailedException

Description copied from interface: ProgramService

Validates a Program Requirement against its data dictionary

Specified by:: validateProgramRequirement in interface ProgramService

Parameters:: validationType - identifier of the extent of validation; programRequirementInfo - Program Requirement information to be tested
Returns:: results from performing the validation
Throws:: InvalidParameterException - invalid validationTypeKey, cluInfo; MissingParameterException - missing validationTypeKey, cluInfo; OperationFailedException - unable to complete request

getObjectStructure

public ObjectStructureDefinition getObjectStructure(String objectTypeKey)

Specified by:: getObjectStructure in interface DictionaryService

getObjectTypes

public List<String> getObjectTypes()

Specified by:: getObjectTypes in interface DictionaryService

getSearchCriteriaType

public SearchCriteriaTypeInfo getSearchCriteriaType(String searchCriteriaTypeKey)
                                             throws DoesNotExistException,
                                                    InvalidParameterException,
                                                    MissingParameterException,
                                                    OperationFailedException

Description copied from interface: SearchService

Retrieves information about a particular search criteria type.

Specified by:: getSearchCriteriaType in interface SearchService

Parameters:: searchCriteriaTypeKey - identifier of the search criteria type
Returns:: information on the search criteria type
Throws:: DoesNotExistException - specified searchCriteriaTypeKey not found; InvalidParameterException - invalid searchCriteriaTypeKey; MissingParameterException - searchCriteriaTypeKey not specified; OperationFailedException - unable to complete request

getSearchCriteriaTypes

public List<SearchCriteriaTypeInfo> getSearchCriteriaTypes()
                                                    throws OperationFailedException

Description copied from interface: SearchService

Retrieves the list of search criteria types known by this service.

Specified by:: getSearchCriteriaTypes in interface SearchService

Returns:: list of search criteria type information
Throws:: OperationFailedException - unable to complete request

getSearchResultType

public SearchResultTypeInfo getSearchResultType(String searchResultTypeKey)
                                         throws DoesNotExistException,
                                                InvalidParameterException,
                                                MissingParameterException,
                                                OperationFailedException

Description copied from interface: SearchService

Retrieves information about a particular search result type. Search result types describe the return structure for a search.

Specified by:: getSearchResultType in interface SearchService

Parameters:: searchResultTypeKey - identifier of the search result type
Returns:: information on the search result type
Throws:: DoesNotExistException - specified searchResultTypeKey not found; InvalidParameterException - invalid searchResultTypeKey; MissingParameterException - searchResultTypeKey not specified; OperationFailedException - unable to complete request

getSearchResultTypes

public List<SearchResultTypeInfo> getSearchResultTypes()
                                                throws OperationFailedException

Description copied from interface: SearchService

Retrieves the list of search result types known by this service. Search result types describe the return structure for a search.

Specified by:: getSearchResultTypes in interface SearchService

Returns:: list of search result type information
Throws:: OperationFailedException - unable to complete request

getSearchType

public SearchTypeInfo getSearchType(String searchTypeKey)
                             throws DoesNotExistException,
                                    InvalidParameterException,
                                    MissingParameterException,
                                    OperationFailedException

Description copied from interface: SearchService

Retrieves information about a particular search type.

Specified by:: getSearchType in interface SearchService

Parameters:: searchTypeKey - identifier of the search type
Returns:: information on the search type
Throws:: DoesNotExistException - specified searchTypeKey not found; InvalidParameterException - invalid searchTypeKey; MissingParameterException - searchTypeKey not specified; OperationFailedException - unable to complete request

getSearchTypes

public List<SearchTypeInfo> getSearchTypes()
                                    throws OperationFailedException

Description copied from interface: SearchService

Retrieves the list of search types known by this service.

Specified by:: getSearchTypes in interface SearchService

Returns:: list of search type information
Throws:: OperationFailedException - unable to complete request

getSearchTypesByCriteria

public List<SearchTypeInfo> getSearchTypesByCriteria(String searchCriteriaTypeKey)
                                              throws DoesNotExistException,
                                                     InvalidParameterException,
                                                     MissingParameterException,
                                                     OperationFailedException

Description copied from interface: SearchService

Retrieves the list of search types which use criteria in the specified format.

Specified by:: getSearchTypesByCriteria in interface SearchService

Parameters:: searchCriteriaTypeKey - identifier of the search criteria
Returns:: list of search type information
Throws:: DoesNotExistException - specified searchCriteriaTypeKey not found; InvalidParameterException - invalid searchCriteriaTypeKey; MissingParameterException - searchCriteriaTypeKey not specified; OperationFailedException - unable to complete request

getSearchTypesByResult

public List<SearchTypeInfo> getSearchTypesByResult(String searchResultTypeKey)
                                            throws DoesNotExistException,
                                                   InvalidParameterException,
                                                   MissingParameterException,
                                                   OperationFailedException

Description copied from interface: SearchService

Retrieves the list of search types which return results in the specified format.

Specified by:: getSearchTypesByResult in interface SearchService

Parameters:: searchResultTypeKey - identifier of the search result type
Returns:: list of search type information
Throws:: DoesNotExistException - specified searchResultTypeKey not found; InvalidParameterException - invalid searchResultTypeKey; MissingParameterException - searchResultTypeKey not specified; OperationFailedException - unable to complete request

search

public SearchResult search(SearchRequest searchRequest)
                    throws MissingParameterException

Specified by:: search in interface SearchService

Throws:: MissingParameterException

checkForMissingParameter

private void checkForMissingParameter(Object param,
                                      String paramName)
                               throws MissingParameterException

Check for missing parameter and throw localized exception if missing

Parameters:: param -; parameter - name
Throws:: MissingParameterException

processMajorDisciplineInfo

private MajorDisciplineInfo processMajorDisciplineInfo(MajorDisciplineInfo majorDisciplineInfo,
                                                       BaseDTOAssemblyNode.NodeOperation operation)
                                                throws AssemblyException

Throws:: AssemblyException

processCredentialProgramInfo

private CredentialProgramInfo processCredentialProgramInfo(CredentialProgramInfo credentialProgramInfo,
                                                           BaseDTOAssemblyNode.NodeOperation operation)
                                                    throws AssemblyException

Throws:: AssemblyException

processProgramRequirement

private ProgramRequirementInfo processProgramRequirement(ProgramRequirementInfo programRequirementInfo,
                                                         BaseDTOAssemblyNode.NodeOperation operation)
                                                  throws AssemblyException

Throws:: AssemblyException

invokeServiceCalls

private void invokeServiceCalls(BaseDTOAssemblyNode<?,CluInfo> results)
                         throws AssemblyException

Throws:: AssemblyException

setLuService

public void setLuService(LuService luService)

getLuService

public LuService getLuService()

setDictionaryService

public void setDictionaryService(DictionaryService dictionaryService)

getDictionaryService

public DictionaryService getDictionaryService()

setSearchManager

public void setSearchManager(SearchManager searchManager)

getSearchManager

public SearchManager getSearchManager()

setMajorDisciplineAssembler

public void setMajorDisciplineAssembler(MajorDisciplineAssembler majorDisciplineAssembler)

getMajorDisciplineAssembler

public MajorDisciplineAssembler getMajorDisciplineAssembler()

setCredentialProgramAssembler

public void setCredentialProgramAssembler(CredentialProgramAssembler credentialProgramAssembler)

getCredentialProgramAssembler

public CredentialProgramAssembler getCredentialProgramAssembler()

setProgramRequirementAssembler

public void setProgramRequirementAssembler(ProgramRequirementAssembler programRequirementAssembler)

getProgramRequirementAssembler

public ProgramRequirementAssembler getProgramRequirementAssembler()

setProgramServiceMethodInvoker

public void setProgramServiceMethodInvoker(BusinessServiceMethodInvoker serviceMethodInvoker)

getProgramServiceMethodInvoker

public BusinessServiceMethodInvoker getProgramServiceMethodInvoker()

setValidatorFactory

public void setValidatorFactory(ValidatorFactory validatorFactory)

getValidatorFactory

public ValidatorFactory getValidatorFactory()

setCoreProgramAssembler

public void setCoreProgramAssembler(CoreProgramAssembler coreProgramAssembler)

getCoreProgramAssembler

public CoreProgramAssembler getCoreProgramAssembler()

getStatus

private StatusInfo getStatus()

processCoreProgramInfo

private CoreProgramInfo processCoreProgramInfo(CoreProgramInfo coreProgramInfo,
                                               BaseDTOAssemblyNode.NodeOperation operation)
                                        throws AssemblyException

Throws:: AssemblyException

createCoreProgram

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public CoreProgramInfo createCoreProgram(CoreProgramInfo coreProgramInfo)
                                  throws AlreadyExistsException,
                                         DataValidationErrorException,
                                         InvalidParameterException,
                                         MissingParameterException,
                                         OperationFailedException,
                                         PermissionDeniedException

Description copied from interface: ProgramService

Creates a Core Program

Specified by:: createCoreProgram in interface ProgramService

Parameters:: coreProgramInfo - coreProgramInfo
Returns:: the created Core Program
Throws:: AlreadyExistsException - The Core Program already exists; DataValidationErrorException - One or more values invalid for this operation; InvalidParameterException - invalid Core Program; MissingParameterException - missing Core Program; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

createNewCoreProgramVersion

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public CoreProgramInfo createNewCoreProgramVersion(String coreProgramId,
                                                                                                                                                     String versionComment)
                                            throws DoesNotExistException,
                                                   InvalidParameterException,
                                                   MissingParameterException,
                                                   OperationFailedException,
                                                   PermissionDeniedException,
                                                   VersionMismatchException,
                                                   DataValidationErrorException

Description copied from interface: ProgramService

Creates a new Core Program version based on the current Core Program

Specified by:: createNewCoreProgramVersion in interface ProgramService

Parameters:: coreProgramId - identifier for the Core Program to be versioned; versionComment - comment for the current version
Returns:: the new versioned Core Program information
Throws:: DoesNotExistException - Core Program does not exist; InvalidParameterException - invalid coreProgramId; MissingParameterException - invalid coreProgramId; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure; VersionMismatchException - The action was attempted on an out of date version; DataValidationErrorException

deleteCoreProgram

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public StatusInfo deleteCoreProgram(String coreProgramId)
                             throws DoesNotExistException,
                                    InvalidParameterException,
                                    MissingParameterException,
                                    OperationFailedException,
                                    PermissionDeniedException

Description copied from interface: ProgramService

Deletes a Core Program

Specified by:: deleteCoreProgram in interface ProgramService

Parameters:: coreProgramId - identifier for coreProgramId.Maps to cluId
Returns:: status of the operation (success or failure)
Throws:: DoesNotExistException - Core Program does not exist; InvalidParameterException - invalid coreProgramId; MissingParameterException - invalid coreProgramId; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getCoreProgram

@Transactional(readOnly=true)
public CoreProgramInfo getCoreProgram(String coreProgramId)
                               throws DoesNotExistException,
                                      InvalidParameterException,
                                      MissingParameterException,
                                      OperationFailedException,
                                      PermissionDeniedException

Description copied from interface: ProgramService

Retrieves a Core Program

Specified by:: getCoreProgram in interface ProgramService

Parameters:: coreProgramId - Unique Id of the Core Program. Maps to cluId
Returns:: the Core Program
Throws:: DoesNotExistException - Program Requirement does not exist; InvalidParameterException - invalid Program Requirement; MissingParameterException - missing Program Requirement; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

updateCoreProgram

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public CoreProgramInfo updateCoreProgram(CoreProgramInfo coreProgramInfo)
                                  throws DataValidationErrorException,
                                         DoesNotExistException,
                                         InvalidParameterException,
                                         MissingParameterException,
                                         VersionMismatchException,
                                         OperationFailedException,
                                         PermissionDeniedException

Description copied from interface: ProgramService

Updates a Core Program

Specified by:: updateCoreProgram in interface ProgramService

Parameters:: coreProgramInfo - coreProgramInfo
Returns:: updated Core Program
Throws:: DataValidationErrorException - One or more values invalid for this operation; DoesNotExistException - Core Program not found; InvalidParameterException - invalid Core Program; MissingParameterException - missing Core Program; VersionMismatchException - The action was attempted on an out of date version; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

validateCoreProgram

public List<ValidationResultInfo> validateCoreProgram(String validationType,
                                                      CoreProgramInfo coreProgramInfo)
                                               throws InvalidParameterException,
                                                      MissingParameterException,
                                                      OperationFailedException

Description copied from interface: ProgramService

Validates a Core Program against its data dictionary

Specified by:: validateCoreProgram in interface ProgramService

Parameters:: validationType - identifier of the extent of validation; coreProgramInfo - Core Program information to be tested
Returns:: results from performing the validation
Throws:: InvalidParameterException - invalid validationTypeKey, cluInfo; MissingParameterException - missing validationTypeKey, cluInfo; OperationFailedException - unable to complete request

createNewCredentialProgramVersion

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public CredentialProgramInfo createNewCredentialProgramVersion(String credentialProgramId,
                                                                                                                                                                 String versionComment)
                                                        throws DoesNotExistException,
                                                               InvalidParameterException,
                                                               MissingParameterException,
                                                               OperationFailedException,
                                                               PermissionDeniedException,
                                                               VersionMismatchException,
                                                               DataValidationErrorException

Description copied from interface: ProgramService

Creates a new Credential Program version based on the current Credential Program

Specified by:: createNewCredentialProgramVersion in interface ProgramService

Parameters:: credentialProgramId - identifier for the Credential Program to be versioned; versionComment - comment for the current version
Returns:: the new versioned Credential Program information
Throws:: DoesNotExistException - Credential Program does not exist; InvalidParameterException - invalid credentialProgramId; MissingParameterException - invalid credentialProgramId; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure; VersionMismatchException - The action was attempted on an out of date version; DataValidationErrorException

setCurrentCoreProgramVersion

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public StatusInfo setCurrentCoreProgramVersion(String coreProgramId,
                                                                                                                                                 Date currentVersionStart)
                                        throws DoesNotExistException,
                                               InvalidParameterException,
                                               MissingParameterException,
                                               IllegalVersionSequencingException,
                                               OperationFailedException,
                                               PermissionDeniedException

Description copied from interface: ProgramService

Sets a specific version of the Core Program as current. The sequence number must be greater than the existing current Core Program version. This will truncate the current version's end date to the currentVersionStart param. If a Major exists which is set to become current in the future, that Major's currentVersionStart and CurrentVersionEnd will be nullified. The currentVersionStart must be in the future to prevent changing historic data.

Specified by:: setCurrentCoreProgramVersion in interface ProgramService

Parameters:: coreProgramId - Version Specific Id of the Core Program; currentVersionStart - Date when this Core Program becomes current. Must be in the future and be after the most current major's start date.
Returns:: status of the operation (success or failure)
Throws:: DoesNotExistException - Core Program for coreProgramId does not exist; InvalidParameterException - invalid coreProgramId, currentVersionStart; MissingParameterException - invalid coreProgramId; IllegalVersionSequencingException - a CoreProgram with higher sequence number from the one provided is marked current; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

setCurrentCredentialProgramVersion

@Transactional(readOnly=false,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public StatusInfo setCurrentCredentialProgramVersion(String credentialProgramId,
                                                                                                                                                       Date currentVersionStart)
                                              throws DoesNotExistException,
                                                     InvalidParameterException,
                                                     MissingParameterException,
                                                     IllegalVersionSequencingException,
                                                     OperationFailedException,
                                                     PermissionDeniedException

Description copied from interface: ProgramService

Sets a specific version of the Credential Program as current. The sequence number must be greater than the existing current Credential Program version. This will truncate the current version's end date to the currentVersionStart param. If a Major exists which is set to become current in the future, that Major's currentVersionStart and CurrentVersionEnd will be nullified. The currentVersionStart must be in the future to prevent changing historic data.

Specified by:: setCurrentCredentialProgramVersion in interface ProgramService

currentVersionStart - Date when this Credential Program becomes current. Must be in the future and be after the most current Credential Program's start date.
Returns:: status of the operation (success or failure)
Throws:: DoesNotExistException - Credential Program for credentialProgramId does not exist; InvalidParameterException - invalid credentialProgramId, currentVersionStart; MissingParameterException - invalid credentialProgramId; IllegalVersionSequencingException - a Credential Program with higher sequence number from the one provided is marked current; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getCurrentVersion

@Transactional(readOnly=true)
public VersionDisplayInfo getCurrentVersion(String refObjectTypeURI,
                                                                  String refObjectId)
                                     throws DoesNotExistException,
                                            InvalidParameterException,
                                            MissingParameterException,
                                            OperationFailedException,
                                            PermissionDeniedException

Description copied from interface: VersionManagementService

Retrieves current version associated with the objectId.

Specified by:: getCurrentVersion in interface VersionManagementService

Parameters:: refObjectTypeURI - reference object type URI; refObjectId - reference object Id
Returns:: current version
Throws:: DoesNotExistException - specified refObjectId, refObjectTypeURI not found; InvalidParameterException - invalid refObjectId, refObjectTypeURI; MissingParameterException - refObjectId, refObjectTypeURI not specified; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getCurrentVersionOnDate

@Transactional(readOnly=true)
public VersionDisplayInfo getCurrentVersionOnDate(String refObjectTypeURI,
                                                                        String refObjectId,
                                                                        Date date)
                                           throws DoesNotExistException,
                                                  InvalidParameterException,
                                                  MissingParameterException,
                                                  OperationFailedException,
                                                  PermissionDeniedException

Description copied from interface: VersionManagementService

Retrieves the current version associated with the objectId on a given date.

Specified by:: getCurrentVersionOnDate in interface VersionManagementService

Parameters:: refObjectTypeURI - reference object type URI; refObjectId - reference object Id; date - date
Returns:: current version on date
Throws:: DoesNotExistException - specified refObjectId, refObjectTypeURI not found; InvalidParameterException - invalid refObjectId, refObjectTypeURI, date; MissingParameterException - refObjectId, refObjectTypeURI, date not specified; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getFirstVersion

@Transactional(readOnly=true)
public VersionDisplayInfo getFirstVersion(String refObjectTypeURI,
                                                                String refObjectId)
                                   throws DoesNotExistException,
                                          InvalidParameterException,
                                          MissingParameterException,
                                          OperationFailedException,
                                          PermissionDeniedException

Description copied from interface: VersionManagementService

Retrieves first version associated with the objectId.

Specified by:: getFirstVersion in interface VersionManagementService

Parameters:: refObjectTypeURI - reference object type URI; refObjectId - reference object Id
Returns:: first version
Throws:: DoesNotExistException - specified refObjectId, refObjectTypeURI not found; InvalidParameterException - invalid refObjectId, refObjectTypeURI; MissingParameterException - refObjectId, refObjectTypeURI not specified; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getLatestVersion

@Transactional(readOnly=true)
public VersionDisplayInfo getLatestVersion(String refObjectTypeURI,
                                                                 String refObjectId)
                                    throws DoesNotExistException,
                                           InvalidParameterException,
                                           MissingParameterException,
                                           OperationFailedException,
                                           PermissionDeniedException

Description copied from interface: VersionManagementService

Retrieves latest version associated with the objectId. This is not always the current version. A current version is what is being used by the system right now, but there could be draft version created after the current version.

Specified by:: getLatestVersion in interface VersionManagementService

Parameters:: refObjectTypeURI - reference object type URI; refObjectId - reference object Id
Returns:: current version
Throws:: DoesNotExistException - specified refObjectId, refObjectTypeURI not found; InvalidParameterException - invalid refObjectId, refObjectTypeURI; MissingParameterException - refObjectId, refObjectTypeURI not specified; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getVersionBySequenceNumber

@Transactional(readOnly=true)
public VersionDisplayInfo getVersionBySequenceNumber(String refObjectTypeURI,
                                                                           String refObjectId,
                                                                           Long sequence)
                                              throws DoesNotExistException,
                                                     InvalidParameterException,
                                                     MissingParameterException,
                                                     OperationFailedException,
                                                     PermissionDeniedException

Description copied from interface: VersionManagementService

Retrieves the version associated with the objectId and the sequence number.

Specified by:: getVersionBySequenceNumber in interface VersionManagementService

Parameters:: refObjectTypeURI - reference object type URI; refObjectId - reference object Id; sequence - sequence number
Returns:: version matching the sequence
Throws:: DoesNotExistException - specified refObjectId, refObjectTypeURI, sequence not found; InvalidParameterException - invalid refObjectId, refObjectTypeURI, sequence; MissingParameterException - refObjectId, refObjectTypeURI, sequence not specified; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getVersions

@Transactional(readOnly=true)
public List<VersionDisplayInfo> getVersions(String refObjectTypeURI,
                                                                  String refObjectId)
                                     throws DoesNotExistException,
                                            InvalidParameterException,
                                            MissingParameterException,
                                            OperationFailedException,
                                            PermissionDeniedException

Description copied from interface: VersionManagementService

Retrieves list of version associated with the objectId.

Specified by:: getVersions in interface VersionManagementService

Parameters:: refObjectTypeURI - reference object type URI; refObjectId - reference object Id
Returns:: list of versions
Throws:: DoesNotExistException - specified refObjectId, refObjectTypeURI not found; InvalidParameterException - invalid refObjectId, refObjectTypeURI; MissingParameterException - refObjectId, refObjectTypeURI not specified; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getVersionsInDateRange

@Transactional(readOnly=true)
public List<VersionDisplayInfo> getVersionsInDateRange(String refObjectTypeURI,
                                                                             String refObjectId,
                                                                             Date from,
                                                                             Date to)
                                                throws DoesNotExistException,
                                                       InvalidParameterException,
                                                       MissingParameterException,
                                                       OperationFailedException,
                                                       PermissionDeniedException

Description copied from interface: VersionManagementService

Retrieves the current version associated with the objectId on a given date.

Specified by:: getVersionsInDateRange in interface VersionManagementService

Parameters:: refObjectTypeURI - reference object type URI; refObjectId - reference object Id; from - from date; to - to date
Returns:: current version on date
Throws:: DoesNotExistException - specified refObjectId, refObjectTypeURI not found; InvalidParameterException - invalid refObjectId, refObjectTypeURI, date; MissingParameterException - refObjectId, refObjectTypeURI, date not specified; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

setAtpService

public void setAtpService(AtpService atpService)

getAtpService

public AtpService getAtpService()

validateMajorDisciplineAtps

private void validateMajorDisciplineAtps(MajorDisciplineInfo majorDisciplineInfo,
                                         List<ValidationResultInfo> validationResults)
                                  throws InvalidParameterException,
                                         MissingParameterException,
                                         OperationFailedException

Throws:: InvalidParameterException; MissingParameterException; OperationFailedException

validateVariationAtps

private void validateVariationAtps(ProgramVariationInfo programVariationInfo,
                                   List<ValidationResultInfo> validationResults,
                                   int idx)
                            throws InvalidParameterException,
                                   MissingParameterException,
                                   OperationFailedException

Throws:: InvalidParameterException; MissingParameterException; OperationFailedException

getAtpInfo

private AtpInfo getAtpInfo(String atpKey)
                    throws DoesNotExistException,
                           InvalidParameterException,
                           MissingParameterException,
                           OperationFailedException

Throws:: DoesNotExistException; InvalidParameterException; MissingParameterException; OperationFailedException

compareAtps

private void compareAtps(String aptKey1,
                         String aptKey2,
                         List<ValidationResultInfo> validationResults,
                         String field,
                         String path)
                  throws InvalidParameterException,
                         MissingParameterException,
                         OperationFailedException

Throws:: InvalidParameterException; MissingParameterException; OperationFailedException

isEmpty

private boolean isEmpty(String value)

setDocumentService

public void setDocumentService(DocumentService documentService)

getDocumentService

public DocumentService getDocumentService()

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.kuali.student.lum.program.service.impl Class ProgramServiceImpl

LOG

luService

validatorFactory

programServiceMethodInvoker

dictionaryService

searchManager

majorDisciplineAssembler

programRequirementAssembler

credentialProgramAssembler

coreProgramAssembler

atpService

documentService

ProgramServiceImpl

createCredentialProgram

createHonorsProgram

createProgramRequirement

createMajorDiscipline

createNewMajorDisciplineVersion

updateRequirementsState

updateStatementTreeViewInfoState

clearStatementTreeViewIdsRecursively

processCopy

processCopy

processCopy

copyProgramRequirements

resetLoRecursively

setCurrentMajorDisciplineVersion

createMinorDiscipline

deleteCredentialProgram

deleteHonorsProgram

deleteMajorDiscipline

deleteMinorDiscipline

deleteProgramRequirement

getCredentialProgram

getCredentialProgramType

getCredentialProgramTypes

getHonorsByCredentialProgramType

getHonorsProgram

getMajorDiscipline

getMajorIdsByCredentialProgramType

getMinorDiscipline

getMinorsByCredentialProgramType

getProgramRequirement

getVariationsByMajorDisciplineId

updateCredentialProgram

updateHonorsProgram

updateMajorDiscipline

updateMinorDiscipline

updateProgramRequirement

validateCredentialProgram

validateHonorsProgram

validateMajorDiscipline

validateMinorDiscipline

validateProgramRequirement

getObjectStructure

getObjectTypes

getSearchCriteriaType

getSearchCriteriaTypes

getSearchResultType

getSearchResultTypes

getSearchType

getSearchTypes

getSearchTypesByCriteria

getSearchTypesByResult

search

checkForMissingParameter

processMajorDisciplineInfo

processCredentialProgramInfo

processProgramRequirement

invokeServiceCalls

setLuService

getLuService

setDictionaryService

getDictionaryService

setSearchManager

getSearchManager

setMajorDisciplineAssembler

getMajorDisciplineAssembler

setCredentialProgramAssembler

org.kuali.student.lum.program.service.impl
Class ProgramServiceImpl