LprServiceImpl (Kuali Student 2.0.0-M6 API)

java.lang.Object
- org.kuali.student.enrollment.class1.lpr.service.impl.LprServiceImpl

All Implemented Interfaces:: LprService

public class LprServiceImpl
extends Object
implements LprService

Author:: sambit

Constructor Summary

Constructors
Constructor and Description

LprServiceImpl()

Constructors
Constructor and Description
`LprServiceImpl()`

Method Summary

Methods
Modifier and Type	Method and Description
`LprInfo`	`createLpr(String personId, String luiId, String lprTypeKey, LprInfo lprInfo, ContextInfo context)` Creates relation between the specified Person and LUI
`List<BulkStatusInfo>`	`createLprsForLui(String luiId, String lprTypeKey, List<LprInfo> lprInfos, ContextInfo contextInfo)` Creates multiple LPRs for one specified LUI.
`List<BulkStatusInfo>`	`createLprsForPerson(String personId, String lprTypeKey, List<LprInfo> lprInfos, ContextInfo contextInfo)` Creates multiple LPRs for one specified person.
`LprTransactionInfo`	`createLprTransaction(String lprTransactionType, LprTransactionInfo lprTransactionInfo, ContextInfo context)` This method creates a LPR transaction of the specified type Validates the transaction generates a unique id for the request and persists it in the back-end.
`LprTransactionInfo`	`createLprTransactionFromExisting(String lprTransactionId, ContextInfo context)` Creates a new Lpr Transaction from an existing LPR transaction Copies the transaction's Items as well.
`StatusInfo`	`deleteLpr(String lprId, ContextInfo context)` Deletes relation between the specified Person and LUI
`StatusInfo`	`deleteLprTransaction(String lprTransactionId, ContextInfo context)` Deletes an lpr Transaction based on Id.
`LprInfo`	`getLpr(String lprId, ContextInfo context)` Retrieves the Relation for the specified LUI Person Relation id
`LprDao`	`getLprDao()`
`List<LprInfo>`	`getLprsByIds(List<String> luiPersonRelationIds, ContextInfo context)` Retrieves the Relation for the specified list of LUI Person Relation Ids
`List<LprInfo>`	`getLprsByLui(String luiId, ContextInfo context)` Retrieves LUI Person Relation for a specified LUI Example Use Case: Can be used to get all the people and their relationships to a particular course offering.
`List<LprInfo>`	`getLprsByLuiAndType(String luiId, String lprTypeKey, ContextInfo context)` Retrieves LUI Person Relation for a particular type and specified LUI Example: Can be used to get all the people with a particular relationship to a specified course offering.
`List<LprInfo>`	`getLprsByLuis(List<String> luiIds, ContextInfo contextInfo)` Retrieves LUI Person Relations for a list of Lui ids Example Use Case: Can be used to get all the people and their relationships to a particular list of course offering's.
`List<LprInfo>`	`getLprsByPerson(String personId, ContextInfo context)` Retrieves LUI Person Relations for Person Example Use Case: Can be used to get all the course registrations for a person for as long as they have been at the school, but please note it could include student registrations in things that are not courses OR student's acting as teaching assistants to courses.
`List<LprInfo>`	`getLprsByPersonAndLui(String personId, String luiId, ContextInfo context)` Retrieves Person Relation for person and LUI Example Use Case: Can be used to get course registrations for a person in a particular course.
`List<LprInfo>`	`getLprsByPersonAndLuiType(String personId, String luiTypeKey, ContextInfo context)` Gets the LPRs for a person and the type Lui.
`List<LprInfo>`	`getLprsByPersonAndTypeForAtp(String personId, String atpId, String typeKey, ContextInfo context)` Retrieves a list of LPRs for a person and particular ATP by the type of LPR.
`List<LprInfo>`	`getLprsByPersonForAtp(String personId, String atpId, ContextInfo context)` Retrieves a list of LPRs by person and ATP Example Use Case: Can be used to get a list of registrations or instructor assignments for a person and a term Note: the ATP is not stored on the LPR but on the Lui so the ATP specified is used to select or filter the Lui ids that can appear on the LPRs that are returned.
`List<LprInfo>`	`getLprsByPersonForAtpAndLuiType(String personId, String atpId, String luiTypeKey, ContextInfo context)` Gets the the LPRs for a person and atp and Lui type.
`LprTransactionInfo`	`getLprTransaction(String lprTransactionId, ContextInfo context)` Retrieves the LPR Transactions based on it's identifier.
`LprTransactionDao`	`getLprTransactionDao()`
`LprTransactionItemDao`	`getLprTransactionItemDao()`
`List<LprTransactionItemInfo>`	`getLprTransactionItemsByLui(String luiId, ContextInfo contextInfo)` Retrieves LPR Transaction Items based on an item with the specified LUI.
`List<LprTransactionItemInfo>`	`getLprTransactionItemsByPersonAndLui(String personId, String luiId, ContextInfo contextInfo)` Retrieves LPR Transactions with an item by Person and LUI Selects all transactions that have at least one item that matches the specified person and either the existing or new lui.
`List<LprTransactionItemInfo>`	`getLprTransactionItemsByResultingLpr(String lprId, ContextInfo context)` Retrieves LPR Transaction Items based on the resulting LPR.
`List<LprTransactionInfo>`	`getLprTransactionsByIds(List<String> lprIds, ContextInfo context)` Get lpr transactions for the specified list of transaction ids.
`List<String>`	`getLuiIdsByPersonAndTypeAndState(String personId, String luiPersonRelationType, String relationState, ContextInfo context)` Retrieves the LUI Ids for Person, type and state.
`List<String>`	`getPersonIdsByLuiAndTypeAndState(String luiId, String luiPersonRelationType, String relationState, ContextInfo context)` Retrieves Person Ids related to the specified LUI, type and state This would allow you to get a list of people who are active (state) students (type=registration) for a particular course (luiId) Example Use Case: get all students in a course.
`List<LprTransactionInfo>`	`getUnsubmittedLprTransactionsByRequestingPersonAndAtp(String requestingPersonId, String atpId, ContextInfo contextInfo)` Retrieves transactions for the requesting person and the ATP.
`LprTransactionInfo`	`processLprTransaction(String lprTransactionId, ContextInfo context)` Submits a LPR transaction - validates the input and based on the type of transaction creates, updates, cancels or removes LPRs.
`List<String>`	`searchForLprIds(QueryByCriteria criteria, ContextInfo context)` Searches details of LUI Person Relation Ids
`List<LprInfo>`	`searchForLprs(QueryByCriteria criteria, ContextInfo context)` Searches details of LUI Person Relation by search criteria
`List<String>`	`searchForLprTransactionIds(QueryByCriteria criteria, ContextInfo context)` Search for matching LPR transactions returning their ids
`List<LprTransactionInfo>`	`searchForLprTransactions(QueryByCriteria criteria, ContextInfo context)` search for matching LPR transactions
`void`	`setLprDao(LprDao lprDao)`
`void`	`setLprTransactionDao(LprTransactionDao lprTransactionDao)`
`void`	`setLprTransactionItemDao(LprTransactionItemDao lprTransactionItemDao)`
`LprInfo`	`updateLpr(String lprId, LprInfo lprInfo, ContextInfo contextInfo)` Update relations between Person and LUI
`LprTransactionInfo`	`updateLprTransaction(String lprTransactionId, LprTransactionInfo lprTransactionInfo, ContextInfo context)` This method updates an LPR Transaction and all of it's items.
`List<ValidationResultInfo>`	`validateLpr(String validationType, String luiId, String personId, String lprTypeKey, LprInfo lprInfo, ContextInfo contextInfo)` Validates the particular relation in a state for a Person and LUI
`List<ValidationResultInfo>`	`validateLprTransaction(String validationType, String lprTransactionType, LprTransactionInfo lprTransactionInfo, ContextInfo contextInfo)` Validates the specific Lpr provided.
`List<ValidationResultInfo>`	`verifyLprTransaction(String lprTransactionId, ContextInfo contextInfo)` Validate the LPR Transaction

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

Constructor Detail
- LprServiceImpl
```
public LprServiceImpl()
```

Method Detail

getLprTransactionDao

public LprTransactionDao getLprTransactionDao()

setLprTransactionDao

public void setLprTransactionDao(LprTransactionDao lprTransactionDao)

getLprTransactionItemDao

public LprTransactionItemDao getLprTransactionItemDao()

setLprTransactionItemDao

public void setLprTransactionItemDao(LprTransactionItemDao lprTransactionItemDao)

getLprDao
```
public LprDao getLprDao()
```

setLprDao
```
public void setLprDao(LprDao lprDao)
```

getLprsByLui
```
@Transactional(readOnly=true)
public List<LprInfo> getLprsByLui(String luiId,
                                               ContextInfo context)
                           throws DoesNotExistException,
                                  InvalidParameterException,
                                  MissingParameterException,
                                  OperationFailedException,
                                  PermissionDeniedException
```
Description copied from interface: LprService

Retrieves LUI Person Relation for a specified LUI Example Use Case: Can be used to get all the people and their relationships to a particular course offering.

Specified by:

getLprsByLui in interface LprService

Parameters:
luiId - Identifier for LUI
context - Context information containing the principalId and locale information about the caller of service operation

Returns:
List of LUI Person Relation info

Throws:

DoesNotExistException - luiId not found

InvalidParameterException - invalid luiId

MissingParameterException - missing luiId

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

getLprsByLuis
```
public List<LprInfo> getLprsByLuis(List<String> luiIds,
                          ContextInfo contextInfo)
                            throws DoesNotExistException,
                                   InvalidParameterException,
                                   MissingParameterException,
                                   OperationFailedException,
                                   PermissionDeniedException
```
Description copied from interface: LprService

Retrieves LUI Person Relations for a list of Lui ids Example Use Case: Can be used to get all the people and their relationships to a particular list of course offering's.

Specified by:

getLprsByLuis in interface LprService

Parameters:
luiIds - Identifiers for LUI's that we want to load the related LPR's
contextInfo - Context information containing the principalId and locale information about the caller of service operation

Returns:
List of LUI Person Relation info

Throws:

DoesNotExistException - one or more of the provided luiId's are not found

InvalidParameterException - invalid luiIds or contextInfo

MissingParameterException - one or more missing parameters.

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

createLprsForPerson

@Transactional
public List<BulkStatusInfo> createLprsForPerson(String personId,
                                                     String lprTypeKey,
                                                     List<LprInfo> lprInfos,
                                                     ContextInfo contextInfo)
                                         throws DataValidationErrorException,
                                                DoesNotExistException,
                                                InvalidParameterException,
                                                MissingParameterException,
                                                OperationFailedException,
                                                PermissionDeniedException,
                                                ReadOnlyException

Description copied from interface: LprService

Creates multiple LPRs for one specified person. This is an all or nothing transaction - any error will invalidate the entire transaction.

Specified by:: createLprsForPerson in interface LprService
Parameters:: personId - Identifier for Person; lprTypeKey - Type of LUI Person relation; lprInfos - List of Information required to create the LUI Person relation; contextInfo - Context information containing the principalId and locale information about the caller of service operation
Returns:: Structure containing status and LUI Person relation identifiers and message
Throws:: DataValidationErrorException - if luiPersonsRelationInfo is not valid; DoesNotExistException - personId, lprTypeKey does not exist; InvalidParameterException - invalid personId, lprTypeKey, lprInfo; MissingParameterException - missing personId, lprTypeKey, lprInfo; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure; ReadOnlyException - attempt to update a read only attribute

getLpr
```
@Transactional(readOnly=true)
public LprInfo getLpr(String lprId,
                                   ContextInfo context)
               throws DoesNotExistException,
                      InvalidParameterException,
                      MissingParameterException,
                      OperationFailedException,
                      PermissionDeniedException
```
Description copied from interface: LprService

Retrieves the Relation for the specified LUI Person Relation id

Specified by:

getLpr in interface LprService

Parameters:
lprId - Identifier for the LUI Person Relation
context - Context information containing the principalId and locale information about the caller of service operation

Returns:
LUI Person Relation information

Throws:

DoesNotExistException - lprId not found

InvalidParameterException - invalid lprId

MissingParameterException - missing lprId

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

getLprsByIds
```
@Transactional(readOnly=true)
public List<LprInfo> getLprsByIds(List<String> luiPersonRelationIds,
                                               ContextInfo context)
                           throws DoesNotExistException,
                                  InvalidParameterException,
                                  MissingParameterException,
                                  OperationFailedException,
                                  PermissionDeniedException
```
Description copied from interface: LprService

Retrieves the Relation for the specified list of LUI Person Relation Ids

Specified by:

getLprsByIds in interface LprService

Parameters:
luiPersonRelationIds - List of identifiers for LUI Person Relations
context - Context information containing the principalId and locale information about the caller of service operation

Returns:
List of LUI Person Relation information

Throws:

DoesNotExistException - One or more lprIds not found

InvalidParameterException - One or more invalid lprIds

MissingParameterException - missing lprIds

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

getLuiIdsByPersonAndTypeAndState
```
public List<String> getLuiIdsByPersonAndTypeAndState(String personId,
                                            String luiPersonRelationType,
                                            String relationState,
                                            ContextInfo context)
                                              throws DoesNotExistException,
                                                     InvalidParameterException,
                                                     MissingParameterException,
                                                     OperationFailedException,
                                                     PermissionDeniedException
```
Description copied from interface: LprService

Retrieves the LUI Ids for Person, type and state. Example Use Case: This would allow you to get all the active (state) courses (type=registration) for a student.

Specified by:

getLuiIdsByPersonAndTypeAndState in interface LprService

Parameters:
personId - Identifier for the Person
luiPersonRelationType - Type of LUI Person Relation
relationState - Relation State
context - Context information containing the principalId and locale information about the caller of service operation

Returns:
Simple list of LUI Ids

Throws:

DoesNotExistException - personId, lprTypeKey, relationState, person to LUI relationship not found

InvalidParameterException - invalid personId, lprTypeKey, relationState

MissingParameterException - missing personId, lprTypeKey, relationState

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

getPersonIdsByLuiAndTypeAndState

@Transactional(readOnly=true)
public List<String> getPersonIdsByLuiAndTypeAndState(String luiId,
                                                                  String luiPersonRelationType,
                                                                  String relationState,
                                                                  ContextInfo context)
                                              throws DoesNotExistException,
                                                     InvalidParameterException,
                                                     MissingParameterException,
                                                     OperationFailedException,
                                                     PermissionDeniedException

Description copied from interface: LprService

Retrieves Person Ids related to the specified LUI, type and state This would allow you to get a list of people who are active (state) students (type=registration) for a particular course (luiId) Example Use Case: get all students in a course.

Specified by:: getPersonIdsByLuiAndTypeAndState in interface LprService
Parameters:: luiId - Identifier for the LUI; luiPersonRelationType - Type of LUI Person Relation; relationState - Relation State; context - Context information containing the principalId and locale information about the caller of service operation
Returns:: Simple list of Person Ids
Throws:: DoesNotExistException - luiId, lprTypeKey, relationState, LUI to person relationship not found; InvalidParameterException - invalid luiId, lprTypeKey, relationState; MissingParameterException - missing luiId, lprTypeKey, relationState; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getLprsByPersonAndLui
```
@Transactional(readOnly=true)
public List<LprInfo> getLprsByPersonAndLui(String personId,
                                                        String luiId,
                                                        ContextInfo context)
                                    throws DoesNotExistException,
                                           InvalidParameterException,
                                           MissingParameterException,
                                           OperationFailedException,
                                           PermissionDeniedException
```
Description copied from interface: LprService

Retrieves Person Relation for person and LUI Example Use Case: Can be used to get course registrations for a person in a particular course. Although this would typically only return one registration for each set of values, but if a person adds a course then drops it then adds it again you could get multiple registrations.

Specified by:

getLprsByPersonAndLui in interface LprService

Parameters:
personId - Identifier for person
luiId - Identifier for LUI
context - Context information containing the principalId and locale information about the caller of service operation

Returns:
List of LUI Person Relation info

Throws:

DoesNotExistException - personId, luiId not found

InvalidParameterException - invalid personId, luiId

MissingParameterException - missing personId, luiId

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

getLprsByPerson
```
@Transactional(readOnly=true)
public List<LprInfo> getLprsByPerson(String personId,
                                                  ContextInfo context)
                              throws DoesNotExistException,
                                     InvalidParameterException,
                                     MissingParameterException,
                                     OperationFailedException,
                                     PermissionDeniedException
```
Description copied from interface: LprService

Retrieves LUI Person Relations for Person Example Use Case: Can be used to get all the course registrations for a person for as long as they have been at the school, but please note it could include student registrations in things that are not courses OR student's acting as teaching assistants to courses.

Specified by:

getLprsByPerson in interface LprService

Parameters:
personId - Identifier for person
context - Context information containing the principalId and locale information about the caller of service operation

Returns:
List of LUI Person Relation info

Throws:

DoesNotExistException - personId not found

InvalidParameterException - invalid personId

MissingParameterException - missing personId

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

searchForLprIds
```
public List<String> searchForLprIds(QueryByCriteria criteria,
                           ContextInfo context)
                             throws InvalidParameterException,
                                    MissingParameterException,
                                    OperationFailedException,
                                    PermissionDeniedException
```
Description copied from interface: LprService

Searches details of LUI Person Relation Ids

Specified by:

searchForLprIds in interface LprService

Parameters:
criteria - Criteria to be used for retrieval of multiple LUI Person Relation identifiers
context - Context information containing the principalId and locale information about the caller of service operation

Returns:
Simple list of LUI Person Relation identifiers

Throws:

InvalidParameterException - invalid relation criteria

MissingParameterException - missing relation criteria

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

createLpr
```
@Transactional
public LprInfo createLpr(String personId,
                              String luiId,
                              String lprTypeKey,
                              LprInfo lprInfo,
                              ContextInfo context)
                  throws DataValidationErrorException,
                         DoesNotExistException,
                         InvalidParameterException,
                         MissingParameterException,
                         OperationFailedException,
                         PermissionDeniedException,
                         ReadOnlyException
```
Description copied from interface: LprService

Creates relation between the specified Person and LUI

Specified by:

createLpr in interface LprService

Parameters:
personId - Person Identifier
luiId - LUI Identifier
lprTypeKey - Type of LUI to Person Relation
lprInfo - Information required to create the LUI Person relation
context - Context information containing the principalId and locale information about the caller of service operation

Returns:
Structure containing LUI Person relation identifiers

Throws:

DataValidationErrorException - if lprInfo is not valid

DoesNotExistException - personId, luiId, relationState, lprTypeKey does not exist

InvalidParameterException - invalid personId, luiId, relationState, lprTypeKey, lprInfo

MissingParameterException - missing personId, luiId, relationState, lprTypeKey, lprInfo

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

ReadOnlyException - attempt to update a read only attribute

updateLpr
```
@Transactional
public LprInfo updateLpr(String lprId,
                              LprInfo lprInfo,
                              ContextInfo contextInfo)
                  throws DoesNotExistException,
                         InvalidParameterException,
                         MissingParameterException,
                         ReadOnlyException,
                         OperationFailedException,
                         PermissionDeniedException
```
Description copied from interface: LprService

Update relations between Person and LUI

Specified by:

updateLpr in interface LprService

Parameters:
lprId - Identifier for the LUI Person Relation
lprInfo - Changed information about the LUI Person Relation
contextInfo - Context information containing the principalId and locale information about the caller of service operation

Returns:
Updated information about the LUI Person Relation

Throws:

DoesNotExistException - lprId does not exist

InvalidParameterException - invalid lprId, lprInfo

MissingParameterException - missing lprId, lprInfo

ReadOnlyException - attempt to update a read only attribute

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

deleteLpr
```
@Transactional
public StatusInfo deleteLpr(String lprId,
                                 ContextInfo context)
                     throws DoesNotExistException,
                            InvalidParameterException,
                            MissingParameterException,
                            OperationFailedException,
                            PermissionDeniedException
```
Description copied from interface: LprService

Deletes relation between the specified Person and LUI

Specified by:

deleteLpr in interface LprService

Parameters:
lprId - Identifier for the LUI Person Relation
context - Context information containing the principalId and locale information about the caller of service operation

Returns:
status of the operation (success, failed)

Throws:

DoesNotExistException - lprId does not exist

InvalidParameterException - invalid lprId

MissingParameterException - missing lprId

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

searchForLprs
```
public List<LprInfo> searchForLprs(QueryByCriteria criteria,
                          ContextInfo context)
                            throws InvalidParameterException,
                                   MissingParameterException,
                                   OperationFailedException,
                                   PermissionDeniedException
```
Description copied from interface: LprService

Searches details of LUI Person Relation by search criteria

Specified by:

searchForLprs in interface LprService

Parameters:
criteria - Criteria to be used for retrieval of multiple LUI Person Relation identifiers
context - Context information containing the principalId and locale information about the caller of service operation

Returns:
Simple list of LUI Person Relation identifiers

Throws:

InvalidParameterException - invalid relation criteria

MissingParameterException - missing relation criteria

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

getLprTransaction

@Transactional(readOnly=true)
public LprTransactionInfo getLprTransaction(String lprTransactionId,
                                                         ContextInfo context)
                                     throws DoesNotExistException,
                                            InvalidParameterException,
                                            MissingParameterException,
                                            OperationFailedException,
                                            PermissionDeniedException

Description copied from interface: LprService

Retrieves the LPR Transactions based on it's identifier.

Specified by:: getLprTransaction in interface LprService
Parameters:: lprTransactionId - The transaction identifier; context - the contextual information
Throws:: DoesNotExistException - lprTransactionId doesn't exist; InvalidParameterException - Invalid lprTransactionId; MissingParameterException - Missing lprTransactionId; OperationFailedException - Unable to complete request; PermissionDeniedException - Authorization failure

deleteLprTransaction

@Transactional
public StatusInfo deleteLprTransaction(String lprTransactionId,
                                            ContextInfo context)
                                throws DoesNotExistException,
                                       InvalidParameterException,
                                       MissingParameterException,
                                       OperationFailedException,
                                       PermissionDeniedException

Description copied from interface: LprService

Deletes an lpr Transaction based on Id.

Specified by:: deleteLprTransaction in interface LprService
Parameters:: lprTransactionId - LPR Transaction identifier; context - the context info
Returns:
Throws:: DoesNotExistException - lprTransactionId doesn't exist; InvalidParameterException - Invalid lprTransactionId; MissingParameterException - Missing lprTransactionId; OperationFailedException - Unable to complete request; PermissionDeniedException - Authorization failure

getLprsByPersonForAtp
```
public List<LprInfo> getLprsByPersonForAtp(String personId,
                                  String atpId,
                                  ContextInfo context)
                                    throws DoesNotExistException,
                                           InvalidParameterException,
                                           MissingParameterException,
                                           OperationFailedException,
                                           PermissionDeniedException
```
Description copied from interface: LprService

Retrieves a list of LPRs by person and ATP Example Use Case: Can be used to get a list of registrations or instructor assignments for a person and a term Note: the ATP is not stored on the LPR but on the Lui so the ATP specified is used to select or filter the Lui ids that can appear on the LPRs that are returned.

Specified by:

getLprsByPersonForAtp in interface LprService

Parameters:
personId - the person id
atpId - the id of the academic time period
context - Context information containing the principalId and locale information about the caller of service operation

Returns:
List of LUI Person Relation info

Throws:

DoesNotExistException - luiId not found

InvalidParameterException - invalid luiId

MissingParameterException - missing luiId

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

createLprTransaction

@Transactional
public LprTransactionInfo createLprTransaction(String lprTransactionType,
                                                    LprTransactionInfo lprTransactionInfo,
                                                    ContextInfo context)
                                        throws DataValidationErrorException,
                                               DoesNotExistException,
                                               InvalidParameterException,
                                               MissingParameterException,
                                               OperationFailedException,
                                               PermissionDeniedException

Description copied from interface: LprService

This method creates a LPR transaction of the specified type Validates the transaction generates a unique id for the request and persists it in the back-end.

Specified by:: createLprTransaction in interface LprService
Parameters:: lprTransactionType - LPR transaction type; lprTransactionInfo - LPR transaction info; context - context info
Throws:: DataValidationErrorException - if LprTransactionInfo fields are not valid; DoesNotExistException - LUI or Person doesn't exist; InvalidParameterException - Invalid lprTransactionType, lprTransaction; MissingParameterException - Missing fields on LprTransactionInfo; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

createLprTransactionFromExisting
```
@Transactional
public LprTransactionInfo createLprTransactionFromExisting(String lprTransactionId,
                                                                ContextInfo context)
                                                    throws DoesNotExistException,
                                                           InvalidParameterException,
                                                           MissingParameterException,
                                                           OperationFailedException,
                                                           PermissionDeniedException
```
Description copied from interface: LprService

Creates a new Lpr Transaction from an existing LPR transaction Copies the transaction's Items as well. The new transaction has the same type as the existing transaction. Since transactions can only be processed once this method was intended to allow the application to easily create a new transaction with all of it's items that the user be able to fix and update any problems that resulted from processing the existing transaction.

Specified by:

createLprTransactionFromExisting in interface LprService

Parameters:
lprTransactionId - LprTransaction identifier
context - the context information

Throws:

DoesNotExistException - lprTransactionId doesn't exist

InvalidParameterException - Invalid lprTransactionId

MissingParameterException - Missing lprTransactionId

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

processLprTransaction

@Transactional
public LprTransactionInfo processLprTransaction(String lprTransactionId,
                                                     ContextInfo context)
                                         throws AlreadyExistsException,
                                                DoesNotExistException,
                                                InvalidParameterException,
                                                MissingParameterException,
                                                OperationFailedException,
                                                PermissionDeniedException

Description copied from interface: LprService

Submits a LPR transaction - validates the input and based on the type of transaction creates, updates, cancels or removes LPRs.

Specified by:: processLprTransaction in interface LprService
Parameters:: lprTransactionId - the id for the LPR transaction
Throws:: AlreadyExistsException - LPR is already present; DoesNotExistException - lprTransactionId doesn't exist; InvalidParameterException - Invalid lprTransactionId; MissingParameterException - Missing lprTransactionId; OperationFailedException - Unable to complete request; PermissionDeniedException - Authorization failure

getLprTransactionsByIds

public List<LprTransactionInfo> getLprTransactionsByIds(List<String> lprIds,
                                               ContextInfo context)
                                                 throws DoesNotExistException,
                                                        InvalidParameterException,
                                                        MissingParameterException,
                                                        OperationFailedException,
                                                        PermissionDeniedException

Description copied from interface: LprService

Get lpr transactions for the specified list of transaction ids.

Specified by:: getLprTransactionsByIds in interface LprService
Parameters:: lprIds - the ids of the lpr transactions; context - the context information
Throws:: DoesNotExistException - personId or luiId doesn't exist; InvalidParameterException - Invalid personId or luiId; MissingParameterException - Missing personId or luiId; OperationFailedException - Unable to complete request; PermissionDeniedException - Authorization failure

getLprTransactionItemsByResultingLpr

@Transactional(readOnly=true)
public List<LprTransactionItemInfo> getLprTransactionItemsByResultingLpr(String lprId,
                                                                                      ContextInfo context)
                                                                  throws InvalidParameterException,
                                                                         MissingParameterException,
                                                                         OperationFailedException,
                                                                         PermissionDeniedException

Description copied from interface: LprService

Retrieves LPR Transaction Items based on the resulting LPR. Selects all transaction items that have this resulting lpr

Specified by:: getLprTransactionItemsByResultingLpr in interface LprService
Parameters:: lprId - The resulting lpr; context - the context info
Throws:: InvalidParameterException - Invalid personId; MissingParameterException - Missing personId; OperationFailedException - Unable to complete request; PermissionDeniedException - Authorization failure

updateLprTransaction

@Transactional
public LprTransactionInfo updateLprTransaction(String lprTransactionId,
                                                    LprTransactionInfo lprTransactionInfo,
                                                    ContextInfo context)
                                        throws DataValidationErrorException,
                                               DoesNotExistException,
                                               InvalidParameterException,
                                               MissingParameterException,
                                               OperationFailedException,
                                               PermissionDeniedException

Description copied from interface: LprService

This method updates an LPR Transaction and all of it's items.

Specified by:: updateLprTransaction in interface LprService
Parameters:: lprTransactionId - The transaction identifier; lprTransactionInfo - The updated Lpr Transaction
Throws:: DataValidationErrorException - LprTransactionInfo is not valid; DoesNotExistException - lprTransactionId doesn't exist; InvalidParameterException - Invalid lprTransactionId or lprTransactionInfo; MissingParameterException - Missing lprTransactionId or lprTransactionInfo; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

searchForLprTransactions

public List<LprTransactionInfo> searchForLprTransactions(QueryByCriteria criteria,
                                                ContextInfo context)
                                                  throws InvalidParameterException,
                                                         MissingParameterException,
                                                         OperationFailedException,
                                                         PermissionDeniedException

Description copied from interface: LprService

search for matching LPR transactions

Specified by:: searchForLprTransactions in interface LprService
Returns:
Throws:: InvalidParameterException; MissingParameterException; OperationFailedException; PermissionDeniedException

searchForLprTransactionIds

public List<String> searchForLprTransactionIds(QueryByCriteria criteria,
                                      ContextInfo context)
                                        throws InvalidParameterException,
                                               MissingParameterException,
                                               OperationFailedException,
                                               PermissionDeniedException

Description copied from interface: LprService

Search for matching LPR transactions returning their ids

Specified by:: searchForLprTransactionIds in interface LprService
Returns:
Throws:: InvalidParameterException; MissingParameterException; OperationFailedException; PermissionDeniedException

getLprsByPersonAndTypeForAtp

@Transactional(readOnly=true)
public List<LprInfo> getLprsByPersonAndTypeForAtp(String personId,
                                                               String atpId,
                                                               String typeKey,
                                                               ContextInfo context)
                                           throws DoesNotExistException,
                                                  InvalidParameterException,
                                                  MissingParameterException,
                                                  OperationFailedException,
                                                  PermissionDeniedException

Description copied from interface: LprService

Retrieves a list of LPRs for a person and particular ATP by the type of LPR. Example Use Case: Can be used to get a list of registrations for a person and a relation type but making sure to exclude other types of relations the student may have during that term such as also being an teaching assistant for a course.

Specified by:: getLprsByPersonAndTypeForAtp in interface LprService
Parameters:: personId - the person id; atpId - the id of the academic time period; typeKey - LUI person relation type key; context - Context information containing the principalId and locale information about the caller of service operation
Returns:: List of LUI Person Relation info
Throws:: DoesNotExistException - luiId not found; InvalidParameterException - invalid luiId; MissingParameterException - missing luiId; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getLprsByPersonForAtpAndLuiType

@Transactional(readOnly=true)
public List<LprInfo> getLprsByPersonForAtpAndLuiType(String personId,
                                                                  String atpId,
                                                                  String luiTypeKey,
                                                                  ContextInfo context)
                                              throws DoesNotExistException,
                                                     InvalidParameterException,
                                                     MissingParameterException,
                                                     OperationFailedException,
                                                     PermissionDeniedException

Description copied from interface: LprService

Gets the the LPRs for a person and atp and Lui type. Example Use Case: Can be used to get the relations a person may have to a course offering (which is a lui type) and a particular term (atpId)

Specified by:: getLprsByPersonForAtpAndLuiType in interface LprService
Parameters:: personId - person identifier; atpId - academic time period identifier; luiTypeKey - type of the LUI; context - Context information containing the principalId and locale information about the caller of service operation
Returns:: a List of Lui Person Relation Info
Throws:: DoesNotExistException - luiId not found; InvalidParameterException - invalid luiId; MissingParameterException - missing luiId; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getLprsByLuiAndType
```
public List<LprInfo> getLprsByLuiAndType(String luiId,
                                String lprTypeKey,
                                ContextInfo context)
                                  throws DoesNotExistException,
                                         InvalidParameterException,
                                         MissingParameterException,
                                         OperationFailedException,
                                         PermissionDeniedException
```
Description copied from interface: LprService

Retrieves LUI Person Relation for a particular type and specified LUI Example: Can be used to get all the people with a particular relationship to a specified course offering.

Specified by:

getLprsByLuiAndType in interface LprService

Parameters:
luiId - Identifier for LUI
lprTypeKey - LUI person relation type key
context - Context information containing the principalId and locale information about the caller of service operation

Returns:
List of LUI Person Relation info

Throws:

DoesNotExistException - luiId not found

InvalidParameterException - invalid luiId

MissingParameterException - missing luiId

OperationFailedException - unable to complete request

PermissionDeniedException - authorization failure

getLprsByPersonAndLuiType

@Transactional(readOnly=true)
public List<LprInfo> getLprsByPersonAndLuiType(String personId,
                                                            String luiTypeKey,
                                                            ContextInfo context)
                                        throws DoesNotExistException,
                                               InvalidParameterException,
                                               MissingParameterException,
                                               OperationFailedException,
                                               PermissionDeniedException

Description copied from interface: LprService

Gets the LPRs for a person and the type Lui. Example Use Case: Can be used to get a list of all the relations a person may have to a course offering (which is a lui type).

Specified by:: getLprsByPersonAndLuiType in interface LprService
Parameters:: personId - person identifier; luiTypeKey - type of the LUI; context - Context information containing the principalId and locale information about the caller of service operation
Returns:: List of LUI Person Relation info
Throws:: DoesNotExistException - luiId not found; InvalidParameterException - invalid luiId; MissingParameterException - missing luiId; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

verifyLprTransaction

public List<ValidationResultInfo> verifyLprTransaction(String lprTransactionId,
                                              ContextInfo contextInfo)
                                                throws DoesNotExistException,
                                                       InvalidParameterException,
                                                       MissingParameterException,
                                                       OperationFailedException,
                                                       PermissionDeniedException

Description copied from interface: LprService

Validate the LPR Transaction

Specified by:: verifyLprTransaction in interface LprService
Parameters:: lprTransactionId - the id of the transaction; contextInfo - the context info
Returns:
Throws:: DoesNotExistException - lprTransactionId doesn't exist; InvalidParameterException - Invalid lprTransactionId; MissingParameterException - Missing lprTransactionId; OperationFailedException - Unable to complete request; PermissionDeniedException - Authorization failure

validateLpr

public List<ValidationResultInfo> validateLpr(String validationType,
                                     String luiId,
                                     String personId,
                                     String lprTypeKey,
                                     LprInfo lprInfo,
                                     ContextInfo contextInfo)
                                       throws DoesNotExistException,
                                              InvalidParameterException,
                                              MissingParameterException,
                                              OperationFailedException,
                                              PermissionDeniedException

Description copied from interface: LprService

Validates the particular relation in a state for a Person and LUI

Specified by:: validateLpr in interface LprService
Parameters:: validationType - Identifier of the extent of validation; luiId - the identifier of the lui; personId - the identifier of the person; lprTypeKey - the key to the type of the relationship; lprInfo - lpr to be validated; contextInfo - Context information containing the principalId and locale information about the caller of service operation
Returns:: list of validation results, list should be be zero length if no validation results are generated
Throws:: DoesNotExistException - lprInfo not found; InvalidParameterException - invalid lprInfo relationState; MissingParameterException - missing lprInfo; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

getLprTransactionItemsByLui

public List<LprTransactionItemInfo> getLprTransactionItemsByLui(String luiId,
                                                       ContextInfo contextInfo)
                                                         throws InvalidParameterException,
                                                                MissingParameterException,
                                                                OperationFailedException,
                                                                PermissionDeniedException

Description copied from interface: LprService

Retrieves LPR Transaction Items based on an item with the specified LUI. Selects all transaction items that where the specified LUI matches either the existing or new lui

Specified by:: getLprTransactionItemsByLui in interface LprService
Parameters:: luiId - The LUI identifier; contextInfo - the ontext info
Throws:: InvalidParameterException - Invalid personId; MissingParameterException - Missing personId; OperationFailedException - Unable to complete request; PermissionDeniedException - Authorization failure

getUnsubmittedLprTransactionsByRequestingPersonAndAtp

public List<LprTransactionInfo> getUnsubmittedLprTransactionsByRequestingPersonAndAtp(String requestingPersonId,
                                                                             String atpId,
                                                                             ContextInfo contextInfo)
                                                                               throws InvalidParameterException,
                                                                                      MissingParameterException,
                                                                                      OperationFailedException,
                                                                                      PermissionDeniedException

Description copied from interface: LprService

Retrieves transactions for the requesting person and the ATP. Unsubmitted transactions are those that have not been submitted (processed) yet. They can be found by checking the state of transactions where state is "New" (see wiki).

Specified by:: getUnsubmittedLprTransactionsByRequestingPersonAndAtp in interface LprService
Parameters:: requestingPersonId - The person identifier; atpId - The ATP Id; contextInfo - the context info
Returns:
Throws:: InvalidParameterException - Invalid personId or atpId; MissingParameterException - Missing personId or atpId; OperationFailedException - Unable to complete request; PermissionDeniedException - Authorization failure

getLprTransactionItemsByPersonAndLui

public List<LprTransactionItemInfo> getLprTransactionItemsByPersonAndLui(String personId,
                                                                String luiId,
                                                                ContextInfo contextInfo)
                                                                  throws DoesNotExistException,
                                                                         InvalidParameterException,
                                                                         MissingParameterException,
                                                                         OperationFailedException,
                                                                         PermissionDeniedException

Description copied from interface: LprService

Retrieves LPR Transactions with an item by Person and LUI Selects all transactions that have at least one item that matches the specified person and either the existing or new lui. Note: this matches the person on the item not the person requesting the transaction which is on the transaction.

Specified by:: getLprTransactionItemsByPersonAndLui in interface LprService
Parameters:: personId - The person identifier; luiId - The LUI id; contextInfo - the context information
Throws:: DoesNotExistException - personId or luiId doesn't exist; InvalidParameterException - Invalid personId or luiId; MissingParameterException - Missing personId or luiId; OperationFailedException - Unable to complete request; PermissionDeniedException - Authorization failure

createLprsForLui

@Transactional
public List<BulkStatusInfo> createLprsForLui(String luiId,
                                                  String lprTypeKey,
                                                  List<LprInfo> lprInfos,
                                                  ContextInfo contextInfo)
                                      throws DataValidationErrorException,
                                             DoesNotExistException,
                                             InvalidParameterException,
                                             MissingParameterException,
                                             OperationFailedException,
                                             PermissionDeniedException,
                                             ReadOnlyException

Description copied from interface: LprService

Creates multiple LPRs for one specified LUI. This is an all or nothing transaction - any error will invalidate the entire transaction.

Specified by:: createLprsForLui in interface LprService
Parameters:: luiId - Identifier for Lui; lprTypeKey - Type of LUI Person relation; lprInfos - List of Information required to create the LUI Person relation; contextInfo - Context information containing the principalId and locale information about the caller of service operation
Returns:: Structure containing status and LUI Person relation identifiers and message
Throws:: DataValidationErrorException - if luiPersonsRelationInfo is not valid; DoesNotExistException - luiId, lprTypeKey does not exist; InvalidParameterException - invalid luiId, lprTypeKey, lprInfos; MissingParameterException - missing luiId, lprTypeKey, lprInfos; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure; ReadOnlyException - attempt to update a read only attribute

validateLprTransaction

public List<ValidationResultInfo> validateLprTransaction(String validationType,
                                                String lprTransactionType,
                                                LprTransactionInfo lprTransactionInfo,
                                                ContextInfo contextInfo)
                                                  throws DoesNotExistException,
                                                         InvalidParameterException,
                                                         MissingParameterException,
                                                         OperationFailedException,
                                                         PermissionDeniedException

Description copied from interface: LprService

Validates the specific Lpr provided.

Specified by:: validateLprTransaction in interface LprService
Parameters:: validationType - Identifier of the extent of validation; lprTransactionType - The type of the LprTransaction.; lprTransactionInfo - The lprTransaction to be validated; contextInfo - Context information containing the principalId and locale information about the caller of service operation
Returns:: list of validation results, list should be be zero length if no validation results are generated
Throws:: DoesNotExistException - lprInfo not found; InvalidParameterException - invalid lprInfo relationState; MissingParameterException - missing lprInfo; OperationFailedException - unable to complete request; PermissionDeniedException - authorization failure

Class LprServiceImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

LprServiceImpl

Method Detail

getLprTransactionDao

setLprTransactionDao

getLprTransactionItemDao

setLprTransactionItemDao

getLprDao

setLprDao

getLprsByLui

getLprsByLuis

createLprsForPerson

getLpr

getLprsByIds

getLuiIdsByPersonAndTypeAndState

getPersonIdsByLuiAndTypeAndState

getLprsByPersonAndLui

getLprsByPerson

searchForLprIds

createLpr

updateLpr

deleteLpr

searchForLprs

getLprTransaction

deleteLprTransaction

getLprsByPersonForAtp

createLprTransaction

createLprTransactionFromExisting

processLprTransaction

getLprTransactionsByIds

getLprTransactionItemsByResultingLpr

updateLprTransaction

searchForLprTransactions

searchForLprTransactionIds

getLprsByPersonAndTypeForAtp

getLprsByPersonForAtpAndLuiType

getLprsByLuiAndType

getLprsByPersonAndLuiType

verifyLprTransaction

validateLpr

getLprTransactionItemsByLui

getUnsubmittedLprTransactionsByRequestingPersonAndAtp

getLprTransactionItemsByPersonAndLui

createLprsForLui

validateLprTransaction