org.kuali.student.enrollment.class1.hold.service.impl
Class HoldServiceImpl

java.lang.Object
  extended by org.kuali.student.enrollment.class1.hold.service.impl.HoldServiceImpl
All Implemented Interfaces:
HoldService

@Transactional(readOnly=true,
               noRollbackFor=DoesNotExistException.class,
               rollbackFor=java.lang.Throwable.class)
public class HoldServiceImpl
extends Object
implements HoldService


Constructor Summary
HoldServiceImpl()
           
 
Method Summary
 AppliedHoldInfo createAppliedHold(String personId, String issueId, String holdTypeKey, AppliedHoldInfo holdInfo, ContextInfo context)
          Creates a new applied hold.
 HoldIssueInfo createHoldIssue(String issueTypeKey, HoldIssueInfo issueInfo, ContextInfo context)
          Creates a new hold Issue.
 StatusInfo deleteAppliedHold(String holdId, ContextInfo context)
          Deletes an existing applied hold record.
 StatusInfo deleteHoldIssue(String issueId, ContextInfo contextInfo)
          Deletes an existing hold Issue.
 List<AppliedHoldInfo> getActiveAppliedHoldsByIssueAndPerson(String issueId, String personId, ContextInfo contextInfo)
          Retrieves a list of active applied holds, both warning and blocking, by hold Issue for a Person.
 List<AppliedHoldInfo> getActiveAppliedHoldsByPerson(String personId, ContextInfo contextInfo)
          Retrieves a list of active applied holds, that pertain to the given Person.
 AppliedHoldInfo getAppliedHold(String holdId, ContextInfo context)
          Retrieves the a single applied hold by the applied hold Id.
 AppliedHoldDao getAppliedHoldDao()
           
 List<String> getAppliedHoldIdsByIssue(String issueId, ContextInfo contextInfo)
          Retrieves all Student Holds related to the given hold Issue.
 List<String> getAppliedHoldIdsByType(String holdTypeKey, ContextInfo contextInfo)
          Retrieves a list Student Hold Ids by Student Hold Type.
 List<AppliedHoldInfo> getAppliedHoldsByIds(List<String> holdIds, ContextInfo contextInfo)
          Retrieves a list applied holds from to a list of applied hold Ids.
 List<AppliedHoldInfo> getAppliedHoldsByIssueAndPerson(String issueId, String personId, ContextInfo contextInfo)
          Retrieves a list of all Holds by Issue for a Person.
 List<AppliedHoldInfo> getAppliedHoldsByPerson(String personId, ContextInfo contextInfo)
          Retrieves all applied holds to the given Person.
 CriteriaLookupService getCriteriaLookupService()
           
 HoldIssueInfo getHoldIssue(String issueId, ContextInfo context)
          Retrieves the details of a single hold Issue by it's hold issue Id.
 HoldIssueDao getHoldIssueDao()
           
 List<String> getHoldIssueIdsByType(String issueTypeKey, ContextInfo context)
          Retrieves a list of hold Issues by Type.
 List<HoldIssueInfo> getHoldIssuesByIds(List<String> issueIds, ContextInfo contextInfo)
          Retrieves a list hold Issues corresponding to a list of issue Ids.
 List<HoldIssueInfo> getHoldIssuesByOrg(String organizationId, ContextInfo context)
          Retrieves a list of hold Issues that pertain to the given organization.
 AppliedHoldInfo releaseAppliedHold(String holdId, ContextInfo context)
          Releases a applied hold.
 List<String> searchForAppliedHoldIds(QueryByCriteria criteria, ContextInfo context)
          Searches for applied holds based on the criteria and returns a list of Hold identifiers which match the search criteria.
 List<AppliedHoldInfo> searchForAppliedHolds(QueryByCriteria criteria, ContextInfo context)
          Searches for applied holds based on the criteria and returns a list of Holds which match the search criteria.
 List<String> searchForHoldIssueIds(QueryByCriteria criteria, ContextInfo context)
          Searches for Issues based on the criteria and returns a list of Issue identifiers which match the search criteria.
 List<HoldIssueInfo> searchForHoldIssues(QueryByCriteria criteria, ContextInfo context)
          Searches for Issues based on the criteria and returns a list of Issues which match the search criteria.
 void setAppliedHoldDao(AppliedHoldDao appliedHoldDao)
           
 void setCriteriaLookupService(CriteriaLookupService criteriaLookupService)
           
 void setHoldIssueDao(HoldIssueDao holdIssueDao)
           
 AppliedHoldInfo updateAppliedHold(String holdId, AppliedHoldInfo holdInfo, ContextInfo context)
          Updates an existing applied hold.
 HoldIssueInfo updateHoldIssue(String issueId, HoldIssueInfo issueInfo, ContextInfo context)
          Updates an existing hold Issue.
 List<ValidationResultInfo> validateAppliedHold(String validationTypeKey, AppliedHoldInfo holdInfo, ContextInfo context)
          Validates a applied hold.
 List<ValidationResultInfo> validateHoldIssue(String validationTypeKey, HoldIssueInfo issueInfo, ContextInfo context)
          Validates an issue.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

HoldServiceImpl

public HoldServiceImpl()
Method Detail

getHoldIssueDao

public HoldIssueDao getHoldIssueDao()

setHoldIssueDao

public void setHoldIssueDao(HoldIssueDao holdIssueDao)

getAppliedHoldDao

public AppliedHoldDao getAppliedHoldDao()

setAppliedHoldDao

public void setAppliedHoldDao(AppliedHoldDao appliedHoldDao)

setCriteriaLookupService

public void setCriteriaLookupService(CriteriaLookupService criteriaLookupService)

getCriteriaLookupService

public CriteriaLookupService getCriteriaLookupService()

getAppliedHold

@Transactional(readOnly=true)
public AppliedHoldInfo getAppliedHold(String holdId,
                                                            ContextInfo context)
                               throws DoesNotExistException,
                                      InvalidParameterException,
                                      MissingParameterException,
                                      OperationFailedException,
                                      PermissionDeniedException
Description copied from interface: HoldService
Retrieves the a single applied hold by the applied hold Id.

Specified by:
getAppliedHold in interface HoldService
Parameters:
holdId - a unique identifier of the Hold to be retrieved
context - information containing the principalId and locale information about the caller of service operation
Returns:
the Hold requested
Throws:
DoesNotExistException - appliedHoldId not found
InvalidParameterException - contextInfo is not valid
MissingParameterException - appliedHoldId or contextInfo is missing or null
OperationFailedException - unable to complete request
PermissionDeniedException - an authorization failure occurred

searchForAppliedHoldIds

@Transactional(readOnly=true)
public List<String> searchForAppliedHoldIds(QueryByCriteria criteria,
                                                                  ContextInfo context)
                                     throws InvalidParameterException,
                                            MissingParameterException,
                                            OperationFailedException,
                                            PermissionDeniedException
Description copied from interface: HoldService
Searches for applied holds based on the criteria and returns a list of Hold identifiers which match the search criteria.

Specified by:
searchForAppliedHoldIds in interface HoldService
Parameters:
criteria - the search criteria
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
list of Hold Ids
Throws:
InvalidParameterException - invalid parameter
MissingParameterException - parameter is missing
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

searchForAppliedHolds

@Transactional(readOnly=true)
public List<AppliedHoldInfo> searchForAppliedHolds(QueryByCriteria criteria,
                                                                         ContextInfo context)
                                            throws InvalidParameterException,
                                                   MissingParameterException,
                                                   OperationFailedException,
                                                   PermissionDeniedException
Description copied from interface: HoldService
Searches for applied holds based on the criteria and returns a list of Holds which match the search criteria.

Specified by:
searchForAppliedHolds in interface HoldService
Parameters:
criteria - the search criteria
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
list of Holds
Throws:
InvalidParameterException - invalid parameter
MissingParameterException - parameter is missing
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

validateAppliedHold

public List<ValidationResultInfo> validateAppliedHold(String validationTypeKey,
                                                      AppliedHoldInfo holdInfo,
                                                      ContextInfo context)
                                               throws DoesNotExistException,
                                                      InvalidParameterException,
                                                      MissingParameterException,
                                                      OperationFailedException
Description copied from interface: HoldService
Validates a applied hold. Depending on the value of validationType, this validation could be limited to tests on just the current object and its directly contained subobjects or expanded to perform all tests related to this object. If an identifier is present for the hold and a record is found for that identifier, the validation checks if the hold can be shifted to the new values. If a record cannot be found for the identifier, it is assumed that the record does not exist and as such, the checks performed will be much shallower, typically mimicking those performed by setting the validationType to the current object. This is a slightly different pattern from the standard validation as the caller provides the identifier in the create statement instead of the server assigning an identifier.

Specified by:
validateAppliedHold in interface HoldService
Parameters:
validationTypeKey - Identifier of the extent of validation
holdInfo - the hold information to be tested.
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
the results from performing the validation
Throws:
DoesNotExistException - validationTypeKey not found
InvalidParameterException - invalid validationTypeKey, appliedHoldInfo
MissingParameterException - missing validationTypeKey, appliedHoldInfo
OperationFailedException - unable to complete request

createAppliedHold

@Transactional
public AppliedHoldInfo createAppliedHold(String personId,
                                                       String issueId,
                                                       String holdTypeKey,
                                                       AppliedHoldInfo holdInfo,
                                                       ContextInfo context)
                                  throws DataValidationErrorException,
                                         InvalidParameterException,
                                         MissingParameterException,
                                         OperationFailedException,
                                         PermissionDeniedException
Description copied from interface: HoldService
Creates a new applied hold.

Specified by:
createAppliedHold in interface HoldService
Parameters:
personId - identifying the person for whom the hold is to be applied
issueId - identifying the exact issue involved
holdTypeKey - identifying the type of the hold
holdInfo - Details of the Hold to be created
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
the details of the Hold just created
Throws:
DataValidationErrorException - One or more values invalid for this operation
InvalidParameterException - One or more parameters invalid
MissingParameterException - One or more parameters missing
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

updateAppliedHold

@Transactional
public AppliedHoldInfo updateAppliedHold(String holdId,
                                                       AppliedHoldInfo holdInfo,
                                                       ContextInfo context)
                                  throws DataValidationErrorException,
                                         DoesNotExistException,
                                         InvalidParameterException,
                                         MissingParameterException,
                                         OperationFailedException,
                                         PermissionDeniedException,
                                         VersionMismatchException
Description copied from interface: HoldService
Updates an existing applied hold.

Specified by:
updateAppliedHold in interface HoldService
Parameters:
holdId - Id of Hold to be updated
holdInfo - Details of updates to the Hold being updated
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
the details of Hold just updated
Throws:
DataValidationErrorException - One or more values invalid for this operation
DoesNotExistException - the Hold does not exist
InvalidParameterException - One or more parameters invalid
MissingParameterException - One or more parameters missing
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure
VersionMismatchException - The action was attempted on an out of date version.

releaseAppliedHold

@Transactional
public AppliedHoldInfo releaseAppliedHold(String holdId,
                                                        ContextInfo context)
                                   throws DoesNotExistException,
                                          InvalidParameterException,
                                          MissingParameterException,
                                          OperationFailedException,
                                          PermissionDeniedException
Description copied from interface: HoldService
Releases a applied hold. A release preserves the record and marks the State as released and sets the released date. A Hold should be released instead of deleted when the record needs to be preserved.

Specified by:
releaseAppliedHold in interface HoldService
Parameters:
holdId - a hold
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
the modified HoldInfo
Throws:
DoesNotExistException - the Hold does not exist
InvalidParameterException - invalid parameter
MissingParameterException - missing parameter
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

deleteAppliedHold

@Transactional
public StatusInfo deleteAppliedHold(String holdId,
                                                  ContextInfo context)
                             throws DoesNotExistException,
                                    InvalidParameterException,
                                    MissingParameterException,
                                    OperationFailedException,
                                    PermissionDeniedException
Description copied from interface: HoldService
Deletes an existing applied hold record.

Specified by:
deleteAppliedHold in interface HoldService
Parameters:
holdId - the Id of the Hold to be deleted
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
status of the operation (success, failed)
Throws:
DoesNotExistException - the Hold does not exist
InvalidParameterException - One or more parameters invalid
MissingParameterException - One or more parameters missing
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

getHoldIssue

@Transactional(readOnly=true)
public HoldIssueInfo getHoldIssue(String issueId,
                                                        ContextInfo context)
                           throws DoesNotExistException,
                                  InvalidParameterException,
                                  MissingParameterException,
                                  OperationFailedException,
                                  PermissionDeniedException
Description copied from interface: HoldService
Retrieves the details of a single hold Issue by it's hold issue Id.

Specified by:
getHoldIssue in interface HoldService
Parameters:
issueId - Unique Id of the Issue to be retrieved
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
the details of the Issue requested
Throws:
DoesNotExistException - holdIssueId not found
InvalidParameterException - invalid holdIssueId
MissingParameterException - missing holdIssueId
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

getHoldIssueIdsByType

@Transactional(readOnly=true)
public List<String> getHoldIssueIdsByType(String issueTypeKey,
                                                                ContextInfo context)
                                   throws InvalidParameterException,
                                          MissingParameterException,
                                          OperationFailedException,
                                          PermissionDeniedException
Description copied from interface: HoldService
Retrieves a list of hold Issues by Type.

Specified by:
getHoldIssueIdsByType in interface HoldService
Parameters:
issueTypeKey - a Type of the Issue to be retrieved
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
a list of Issues of the given Type
Throws:
InvalidParameterException - invalid parameter
MissingParameterException - missing parameter
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

getHoldIssuesByOrg

@Transactional(readOnly=true)
public List<HoldIssueInfo> getHoldIssuesByOrg(String organizationId,
                                                                    ContextInfo context)
                                       throws InvalidParameterException,
                                              MissingParameterException,
                                              OperationFailedException,
                                              PermissionDeniedException
Description copied from interface: HoldService
Retrieves a list of hold Issues that pertain to the given organization.

Specified by:
getHoldIssuesByOrg in interface HoldService
Parameters:
organizationId - a unique Id of an organization
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
a list of Issues
Throws:
InvalidParameterException - invalid parameter
MissingParameterException - missing parameter
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

searchForHoldIssueIds

@Transactional(readOnly=true)
public List<String> searchForHoldIssueIds(QueryByCriteria criteria,
                                                                ContextInfo context)
                                   throws InvalidParameterException,
                                          MissingParameterException,
                                          OperationFailedException,
                                          PermissionDeniedException
Description copied from interface: HoldService
Searches for Issues based on the criteria and returns a list of Issue identifiers which match the search criteria.

Specified by:
searchForHoldIssueIds in interface HoldService
Parameters:
criteria - the search criteria
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
list of Issue Ids
Throws:
InvalidParameterException - invalid parameter
MissingParameterException - parameter is missing
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

searchForHoldIssues

@Transactional(readOnly=true)
public List<HoldIssueInfo> searchForHoldIssues(QueryByCriteria criteria,
                                                                     ContextInfo context)
                                        throws InvalidParameterException,
                                               MissingParameterException,
                                               OperationFailedException,
                                               PermissionDeniedException
Description copied from interface: HoldService
Searches for Issues based on the criteria and returns a list of Issues which match the search criteria.

Specified by:
searchForHoldIssues in interface HoldService
Parameters:
criteria - the search criteria
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
list of IssueIds
Throws:
InvalidParameterException - invalid parameter
MissingParameterException - parameter is missing
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

validateHoldIssue

public List<ValidationResultInfo> validateHoldIssue(String validationTypeKey,
                                                    HoldIssueInfo issueInfo,
                                                    ContextInfo context)
                                             throws DoesNotExistException,
                                                    InvalidParameterException,
                                                    MissingParameterException,
                                                    OperationFailedException
Description copied from interface: HoldService
Validates an issue. Depending on the value of validationType, this validation could be limited to tests on just the current object and its directly contained subobjects or expanded to perform all tests related to this object. If an identifier is present for the issue and a record is found for that identifier, the validation checks if the issue can be shifted to the new values. If a record cannot be found for the identifier, it is assumed that the record does not exist and as such, the checks performed will be much shallower, typically mimicking those performed by setting the validationType to the current object. This is a slightly different pattern from the standard validation as the caller provides the identifier in the create statement instead of the server assigning an identifier.

Specified by:
validateHoldIssue in interface HoldService
Parameters:
validationTypeKey - Identifier of the extent of validation
issueInfo - the issue information to be tested.
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
the results from performing the validation
Throws:
DoesNotExistException - validationTypeKey not found
InvalidParameterException - invalid validationTypeKey, holdIssueInfo
MissingParameterException - missing validationTypeKey, holdIssueInfo
OperationFailedException - unable to complete request

createHoldIssue

@Transactional
public HoldIssueInfo createHoldIssue(String issueTypeKey,
                                                   HoldIssueInfo issueInfo,
                                                   ContextInfo context)
                              throws DataValidationErrorException,
                                     InvalidParameterException,
                                     MissingParameterException,
                                     OperationFailedException,
                                     PermissionDeniedException
Description copied from interface: HoldService
Creates a new hold Issue.

Specified by:
createHoldIssue in interface HoldService
Parameters:
issueTypeKey - indicates the type of issue
issueInfo - Details of the Issue to be created
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
the details of the Issue just created
Throws:
DataValidationErrorException - One or more values invalid for this operation
InvalidParameterException - One or more parameters invalid
MissingParameterException - One or more parameters missing
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

updateHoldIssue

@Transactional
public HoldIssueInfo updateHoldIssue(String issueId,
                                                   HoldIssueInfo issueInfo,
                                                   ContextInfo context)
                              throws DataValidationErrorException,
                                     DoesNotExistException,
                                     InvalidParameterException,
                                     MissingParameterException,
                                     OperationFailedException,
                                     PermissionDeniedException,
                                     VersionMismatchException
Description copied from interface: HoldService
Updates an existing hold Issue.

Specified by:
updateHoldIssue in interface HoldService
Parameters:
issueId - Id of the Issue to be updated
issueInfo - Details of updates to the Issue being updated
context - Context information containing the principalId and locale information about the caller of service operation
Returns:
the details of the Issue just updated
Throws:
DataValidationErrorException - One or more values invalid for this operation
DoesNotExistException - the Issue does not exist
InvalidParameterException - One or more parameters invalid
MissingParameterException - One or more parameters missing
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure
VersionMismatchException - The action was attempted on an out of date version.

deleteHoldIssue

@Transactional
public StatusInfo deleteHoldIssue(String issueId,
                                                ContextInfo contextInfo)
                           throws DoesNotExistException,
                                  InvalidParameterException,
                                  MissingParameterException,
                                  OperationFailedException,
                                  PermissionDeniedException,
                                  DependentObjectsExistException
Description copied from interface: HoldService
Deletes an existing hold Issue.

Specified by:
deleteHoldIssue in interface HoldService
Parameters:
issueId - the Id of the Issue to be deleted
contextInfo - Context information containing the principalId and locale information about the caller of service operation
Returns:
status of the operation (success, failed)
Throws:
DoesNotExistException - the Issue does not exist
InvalidParameterException - One or more parameters invalid
MissingParameterException - One or more parameters missing
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure
DependentObjectsExistException - if a hold exists for this issue

getAppliedHoldsByIds

@Transactional(readOnly=true)
public List<AppliedHoldInfo> getAppliedHoldsByIds(List<String> holdIds,
                                                                        ContextInfo contextInfo)
                                           throws DoesNotExistException,
                                                  InvalidParameterException,
                                                  MissingParameterException,
                                                  OperationFailedException,
                                                  PermissionDeniedException
Description copied from interface: HoldService
Retrieves a list applied holds from to a list of applied hold Ids. The returned list may be in any order and of duplicate Ids are supplied, a unique set may or may not be returned.

Specified by:
getAppliedHoldsByIds in interface HoldService
Parameters:
holdIds - list of Hold identifiers
contextInfo - information containing the principalId and locale information about the caller of service operation
Returns:
a list of Holds
Throws:
DoesNotExistException - a appliedHoldId in list not found
InvalidParameterException - contextInfo is not valid
MissingParameterException - appliedHoldIds, a appliedHoldId in appliedHoldIds, or contextInfo is missing or null
OperationFailedException - unable to complete request
PermissionDeniedException - an authorization failure occurred

getAppliedHoldIdsByType

@Transactional(readOnly=true)
public List<String> getAppliedHoldIdsByType(String holdTypeKey,
                                                                  ContextInfo contextInfo)
                                     throws InvalidParameterException,
                                            MissingParameterException,
                                            OperationFailedException,
                                            PermissionDeniedException
Description copied from interface: HoldService
Retrieves a list Student Hold Ids by Student Hold Type.

Specified by:
getAppliedHoldIdsByType in interface HoldService
Parameters:
holdTypeKey - an identifier for a Hold Type
contextInfo - information containing the principalId and locale information about the caller of service operation
Returns:
a list of Hold identifiers
Throws:
InvalidParameterException - contextInfo is not valid
MissingParameterException - appliedHoldTypeKey or contextInfo is missing or null
OperationFailedException - unable to complete request
PermissionDeniedException - an authorization failure occurred

getAppliedHoldIdsByIssue

@Transactional(readOnly=true)
public List<String> getAppliedHoldIdsByIssue(String issueId,
                                                                   ContextInfo contextInfo)
                                      throws InvalidParameterException,
                                             MissingParameterException,
                                             OperationFailedException,
                                             PermissionDeniedException
Description copied from interface: HoldService
Retrieves all Student Holds related to the given hold Issue.

Specified by:
getAppliedHoldIdsByIssue in interface HoldService
Parameters:
issueId - a unique identifier for the Issue
contextInfo - information containing the principalId and locale information about the caller of service operation
Returns:
the Hold ids to the given Issue
Throws:
InvalidParameterException - contextInfo is not valid
MissingParameterException - holdIssueId or contetInfo is missing or null
OperationFailedException - unable to complete request
PermissionDeniedException - an authorization failure occurred

getAppliedHoldsByPerson

@Transactional(readOnly=true)
public List<AppliedHoldInfo> getAppliedHoldsByPerson(String personId,
                                                                           ContextInfo contextInfo)
                                              throws InvalidParameterException,
                                                     MissingParameterException,
                                                     OperationFailedException,
                                                     PermissionDeniedException
Description copied from interface: HoldService
Retrieves all applied holds to the given Person.

Specified by:
getAppliedHoldsByPerson in interface HoldService
Parameters:
personId - a unique identifier for the Person
contextInfo - information containing the principalId and locale information about the caller of service operation
Returns:
the Holds to the given Person
Throws:
InvalidParameterException - contextInfo is not valid
MissingParameterException - personId of contextInfo is missing or null
OperationFailedException - unable to complete request
PermissionDeniedException - an authorization failure occurred

getActiveAppliedHoldsByPerson

@Transactional(readOnly=true)
public List<AppliedHoldInfo> getActiveAppliedHoldsByPerson(String personId,
                                                                                 ContextInfo contextInfo)
                                                    throws InvalidParameterException,
                                                           MissingParameterException,
                                                           OperationFailedException,
                                                           PermissionDeniedException
Description copied from interface: HoldService
Retrieves a list of active applied holds, that pertain to the given Person. An active Hold is any open Hold that has had not been released or canceled.

Specified by:
getActiveAppliedHoldsByPerson in interface HoldService
Parameters:
personId - an Id of a Person
contextInfo - Context information containing the principalId and locale information about the caller of service operation
Returns:
a list of Holds
Throws:
InvalidParameterException - invalid parameter
MissingParameterException - missing parameter
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

getAppliedHoldsByIssueAndPerson

@Transactional(readOnly=true)
public List<AppliedHoldInfo> getAppliedHoldsByIssueAndPerson(String issueId,
                                                                                   String personId,
                                                                                   ContextInfo contextInfo)
                                                      throws InvalidParameterException,
                                                             MissingParameterException,
                                                             OperationFailedException,
                                                             PermissionDeniedException
Description copied from interface: HoldService
Retrieves a list of all Holds by Issue for a Person.

Specified by:
getAppliedHoldsByIssueAndPerson in interface HoldService
Parameters:
issueId - an Issue
personId - Id of a person
contextInfo - Context information containing the principalId and locale information about the caller of service operation
Returns:
a list of Holds
Throws:
InvalidParameterException - invalid parameter
MissingParameterException - missing parameter
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

getActiveAppliedHoldsByIssueAndPerson

@Transactional(readOnly=true)
public List<AppliedHoldInfo> getActiveAppliedHoldsByIssueAndPerson(String issueId,
                                                                                         String personId,
                                                                                         ContextInfo contextInfo)
                                                            throws InvalidParameterException,
                                                                   MissingParameterException,
                                                                   OperationFailedException,
                                                                   PermissionDeniedException
Description copied from interface: HoldService
Retrieves a list of active applied holds, both warning and blocking, by hold Issue for a Person. An active Hold is any open Hold that has had not been released or canceled.

Specified by:
getActiveAppliedHoldsByIssueAndPerson in interface HoldService
Parameters:
issueId - an Issue
personId - Id of a person
contextInfo - Context information containing the principalId and locale information about the caller of service operation
Returns:
a list of Holds
Throws:
InvalidParameterException - invalid parameter
MissingParameterException - missing parameter
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure

getHoldIssuesByIds

@Transactional(readOnly=true)
public List<HoldIssueInfo> getHoldIssuesByIds(List<String> issueIds,
                                                                    ContextInfo contextInfo)
                                       throws DoesNotExistException,
                                              InvalidParameterException,
                                              MissingParameterException,
                                              OperationFailedException,
                                              PermissionDeniedException
Description copied from interface: HoldService
Retrieves a list hold Issues corresponding to a list of issue Ids.

Specified by:
getHoldIssuesByIds in interface HoldService
Parameters:
issueIds - list of unique Ids of the Issue to be retrieved
contextInfo - Context information containing the principalId and locale information about the caller of service operation
Returns:
a list of Issues
Throws:
DoesNotExistException - a holdIssueId in list not found
InvalidParameterException - invalid holdIssueId in list
MissingParameterException - missing holdIssueIds
OperationFailedException - unable to complete request
PermissionDeniedException - authorization failure


Copyright © 2004-2013 The Kuali Foundation. All Rights Reserved.